From 6927d7110d660b8278e1452168ddc994338b2e05 Mon Sep 17 00:00:00 2001 From: Oh Chin Yang Date: Thu, 3 Nov 2022 16:16:37 +0800 Subject: [PATCH] HloEnv v0.0.1 --- .bazelrc | 246 + .clang-format | 4 + .gitignore | 52 + .hloenv_configure.bazelrc | 20 + BUILD | 33 + LICENSE | 201 + Makefile | 54 + README.md | 100 + WORKSPACE | 103 + docs/Makefile | 19 + docs/conf.py | 232 + docs/examples.rst | 416 + docs/images/altgraph.png | Bin 0 -> 132598 bytes docs/images/sys.png | Bin 0 -> 135013 bytes docs/index.rst | 20 + docs/intro.rst | 80 + docs/reference.rst | 5 + docs/release_notes.rst | 9 + docs/xla_passes.rst | 9 + examples/__init__.py | 13 + examples/always_pick_first.py | 86 + examples/general_fusion_pipeline.py | 434 + examples/hlo_play.py | 83 + ...13.jit__lambda_.7.before_optimizations.txt | 16 + ....jit_safe_mask.15.before_optimizations.txt | 29 + ....jit_safe_mask.61.before_optimizations.txt | 53 + examples/uniform_policy.py | 171 + hloenv/BUILD | 148 + hloenv/__init__.py | 34 + hloenv/bin/BUILD | 25 + hloenv/bin/extract_subgraphs.cc | 126 + hloenv/evaluation/BUILD | 58 + hloenv/evaluation/evaluator.cc | 165 + hloenv/evaluation/evaluator.h | 59 + hloenv/evaluation/main.cc | 87 + hloenv/gpu_backend.h | 108 + hloenv/hlo_env.cc | 255 + hloenv/hlo_env.h | 117 + hloenv/hlo_graph.cc | 583 + hloenv/hlo_graph.h | 352 + hloenv/hlo_module.h | 147 + hloenv/hlo_pass_defs.h | 182 + hloenv/pip.bzl | 28 + hloenv/python/BUILD | 54 + hloenv/python/__init__.py | 13 + hloenv/python/py_hlo_env.cc | 493 + hloenv/python/py_hlo_env.h | 53 + hloenv/python/py_hlo_graph.h | 124 + hloenv/python/py_hlo_passes.cc | 992 ++ hloenv/python/py_hlo_passes.h | 35 + hloenv/schedule.h | 258 + hloenv/utils/BUILD | 30 + hloenv/utils/hlo_utils.cc | 648 ++ hloenv/utils/hlo_utils.h | 318 + hloenv/xla_compile.cc | 117 + setup.cfg | 41 + setup.py | 34 + tests/BUILD | 73 + tests/cycle_detection_test.cc | 44 + tests/evaluator_test.cc | 66 + tests/extract_test.sh | 3 + tests/hlo_env_test.py | 1739 +++ tests/hlo_graph_test.cc | 79 + tests/hlo_texts/fn_hlo.txt | 13 + tests/hlo_texts/hlo_test.txt | 169 + ...__cho_solve__38.9.before_optimizations.txt | 13 + ..._searchsorted.120.before_optimizations.txt | 136 + ...1d_sorted_mask.54.before_optimizations.txt | 64 + ....jit_matmul__15.6.before_optimizations.txt | 10 + ...t__cholesky__4.58.before_optimizations.txt | 64 + ...14.jit__unstack.6.before_optimizations.txt | 15 + ...9.jit__one_hot.13.before_optimizations.txt | 17 + ...34.jit__normal.12.before_optimizations.txt | 154 + ....jit__randint.109.before_optimizations.txt | 113 + ..._computation_lt.5.before_optimizations.txt | 9 + ...eefry_split__2.20.before_optimizations.txt | 24 + ...337.jit_loss.9581.before_optimizations.txt | 9809 +++++++++++++++++ ...ule_0005.jit_fn.3.before_optimizations.txt | 10 + ..._threefry_split.8.before_optimizations.txt | 39 + ...19.jit__unstack.9.before_optimizations.txt | 21 + ..._threefry_split.5.before_optimizations.txt | 39 + ...14.jit__unstack.6.before_optimizations.txt | 13 + ...040.jit_serial.13.before_optimizations.txt | 118 + ..._threefry_split.5.before_optimizations.txt | 20 + ...15.jit__uniform.7.before_optimizations.txt | 49 + ...4.jit__shuffle.43.before_optimizations.txt | 50 + ..._0093.jit_loss.44.before_optimizations.txt | 108 + ...6.jit__uniform.21.before_optimizations.txt | 48 + ...5.jit__uniform.30.before_optimizations.txt | 48 + ...3.jit__uniform.33.before_optimizations.txt | 48 + ...1.jit__uniform.46.before_optimizations.txt | 48 + ...jit_heaviside.238.before_optimizations.txt | 32 + ...9.jit_slogdet.280.before_optimizations.txt | 130 + ...00.jit__power.288.before_optimizations.txt | 16 + ...7.jit_slogdet.385.before_optimizations.txt | 149 + ....jit__lambda_.129.before_optimizations.txt | 11 + ...e_0352.jit_fn.131.before_optimizations.txt | 11 + ....jit__lambda_.256.before_optimizations.txt | 2172 ++++ ...t__normal__49.159.before_optimizations.txt | 171 + ..._threefry_split.8.before_optimizations.txt | 39 + ...le_0032.jit_fn.12.before_optimizations.txt | 12 + ...94.jit__normal.39.before_optimizations.txt | 154 + ...hreefry_fold_in.8.before_optimizations.txt | 40 + ...3.jit_prim_fun.13.before_optimizations.txt | 8 + ...le_0039.jit_fn.15.before_optimizations.txt | 12 + ...13.jit__lambda_.7.before_optimizations.txt | 16 + ....jit_safe_mask.15.before_optimizations.txt | 29 + ....jit_safe_mask.61.before_optimizations.txt | 53 + ...0235.jit_fn__34.7.before_optimizations.txt | 11 + ...it__reduce_max.11.before_optimizations.txt | 17 + ....jit__uniform.218.before_optimizations.txt | 67 + ...threefry_split.22.before_optimizations.txt | 39 + ...4.jit__unstack.23.before_optimizations.txt | 15 + ...19.jit__normal.38.before_optimizations.txt | 156 + ...95.jit__var__1.31.before_optimizations.txt | 39 + ...it__lambda___12.8.before_optimizations.txt | 12 + ...ted_normal__7.318.before_optimizations.txt | 324 + ..._0009.jit_round.2.before_optimizations.txt | 34 + ..._0025.jit_apply.7.before_optimizations.txt | 160 + ...1.jit_prim_fun.14.before_optimizations.txt | 8 + ...get_td_target.657.before_optimizations.txt | 701 ++ ...le_0140.jit_qr.53.before_optimizations.txt | 61 + ...0145.jit__diag.54.before_optimizations.txt | 36 + ...le_0183.jit_fn.71.before_optimizations.txt | 12 + ...uncated_normal.20.before_optimizations.txt | 319 + ...1.jit_accuracy.49.before_optimizations.txt | 167 + ...4.jit_prim_fun.56.before_optimizations.txt | 15 + ....jit_prim_fun.115.before_optimizations.txt | 7 + ...le_0033.jit_fn.13.before_optimizations.txt | 12 + ...jit_train_step.26.before_optimizations.txt | 178 + ...082.jit_divmod.28.before_optimizations.txt | 47 + ...ule_0000.jit__f.0.before_optimizations.txt | 93 + ...ule_0011.jit_fn.7.before_optimizations.txt | 12 + ....jit__cholesky.12.before_optimizations.txt | 40 + ...9.jit__uniform.25.before_optimizations.txt | 49 + ...jit_leaky_relu.74.before_optimizations.txt | 34 + ...8.jit__lambda_.59.before_optimizations.txt | 7 + ...08.jit_median.138.before_optimizations.txt | 88 + ..._threefry_split.5.before_optimizations.txt | 39 + ...14.jit__unstack.6.before_optimizations.txt | 11 + ...17.jit__uniform.7.before_optimizations.txt | 66 + tests/pass_pipelines.py | 434 + third_party/pip_requirements/BUILD | 3 + third_party/pip_requirements/requirements.txt | 1 + third_party/tensorflow/BUILD | 0 .../tensorflow/org_tensorflow_hloenv.patch | 4486 ++++++++ 146 files changed, 32300 insertions(+) create mode 100644 .bazelrc create mode 100644 .clang-format create mode 100644 .gitignore create mode 100644 .hloenv_configure.bazelrc create mode 100644 BUILD create mode 100644 LICENSE create mode 100644 Makefile create mode 100644 README.md create mode 100644 WORKSPACE create mode 100644 docs/Makefile create mode 100644 docs/conf.py create mode 100644 docs/examples.rst create mode 100644 docs/images/altgraph.png create mode 100644 docs/images/sys.png create mode 100644 docs/index.rst create mode 100644 docs/intro.rst create mode 100644 docs/reference.rst create mode 100644 docs/release_notes.rst create mode 100644 docs/xla_passes.rst create mode 100644 examples/__init__.py create mode 100644 examples/always_pick_first.py create mode 100644 examples/general_fusion_pipeline.py create mode 100644 examples/hlo_play.py create mode 100644 examples/hlo_texts/jax-md/module_0013.jit__lambda_.7.before_optimizations.txt create mode 100644 examples/hlo_texts/jax-md/module_0029.jit_safe_mask.15.before_optimizations.txt create mode 100644 examples/hlo_texts/jax-md/module_0190.jit_safe_mask.61.before_optimizations.txt create mode 100644 examples/uniform_policy.py create mode 100644 hloenv/BUILD create mode 100644 hloenv/__init__.py create mode 100644 hloenv/bin/BUILD create mode 100644 hloenv/bin/extract_subgraphs.cc create mode 100644 hloenv/evaluation/BUILD create mode 100644 hloenv/evaluation/evaluator.cc create mode 100644 hloenv/evaluation/evaluator.h create mode 100644 hloenv/evaluation/main.cc create mode 100644 hloenv/gpu_backend.h create mode 100644 hloenv/hlo_env.cc create mode 100644 hloenv/hlo_env.h create mode 100644 hloenv/hlo_graph.cc create mode 100644 hloenv/hlo_graph.h create mode 100644 hloenv/hlo_module.h create mode 100644 hloenv/hlo_pass_defs.h create mode 100644 hloenv/pip.bzl create mode 100644 hloenv/python/BUILD create mode 100644 hloenv/python/__init__.py create mode 100644 hloenv/python/py_hlo_env.cc create mode 100644 hloenv/python/py_hlo_env.h create mode 100644 hloenv/python/py_hlo_graph.h create mode 100644 hloenv/python/py_hlo_passes.cc create mode 100644 hloenv/python/py_hlo_passes.h create mode 100644 hloenv/schedule.h create mode 100644 hloenv/utils/BUILD create mode 100644 hloenv/utils/hlo_utils.cc create mode 100644 hloenv/utils/hlo_utils.h create mode 100644 hloenv/xla_compile.cc create mode 100644 setup.cfg create mode 100644 setup.py create mode 100644 tests/BUILD create mode 100644 tests/cycle_detection_test.cc create mode 100644 tests/evaluator_test.cc create mode 100755 tests/extract_test.sh create mode 100644 tests/hlo_env_test.py create mode 100644 tests/hlo_graph_test.cc create mode 100644 tests/hlo_texts/fn_hlo.txt create mode 100644 tests/hlo_texts/hlo_test.txt create mode 100644 tests/hlo_texts/test_hlos/BayesNewton/1649161870141180.module_1898.jit__cho_solve__38.9.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/BayesNewton/1649161872771469.module_1959.jit_searchsorted.120.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/BayesNewton/1649162002058928.module_0001.jit__unique1d_sorted_mask.54.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/BayesNewton/1649162245014652.module_2517.jit_matmul__15.6.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/BayesNewton/1649162750550487.module_0785.jit__cholesky__4.58.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/GANs-JAX/module_0014.jit__unstack.6.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/GANs-JAX/module_0029.jit__one_hot.13.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/GANs-JAX/module_0034.jit__normal.12.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/NuX/1648647389204864.module_0018.jit__randint.109.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/NuX/1648647389777040.module_0026.primitive_computation_lt.5.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/NuX/1648647393457587.module_0054.jit__threefry_split__2.20.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/NuX/1648647409115717.module_0337.jit_loss.9581.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/Physics-informed-neural-network-in-JAX/module_0005.jit_fn.3.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/Physics-informed-neural-network-in-JAX/module_0015.jit__threefry_split.8.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/Physics-informed-neural-network-in-JAX/module_0019.jit__unstack.9.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/Scale-Mixtures-of-NNGP/module_0010.jit__threefry_split.5.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/Scale-Mixtures-of-NNGP/module_0014.jit__unstack.6.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/Scale-Mixtures-of-NNGP/module_0040.jit_serial.13.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/Toy-neural-network-in-jax/module_0009.jit__threefry_split.5.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/Toy-neural-network-in-jax/module_0015.jit__uniform.7.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/Toy-neural-network-in-jax/module_0084.jit__shuffle.43.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/Toy-neural-network-in-jax/module_0093.jit_loss.44.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/brax/module_0196.jit__uniform.21.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/brax/module_0215.jit__uniform.30.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/brax/module_0223.jit__uniform.33.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/brax/module_0251.jit__uniform.46.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/deeperwin/module_0407.jit_heaviside.238.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/deeperwin/module_0479.jit_slogdet.280.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/deeperwin/module_0500.jit__power.288.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/deeperwin/module_0667.jit_slogdet.385.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/efficientnet-jax/module_0348.jit__lambda_.129.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/efficientnet-jax/module_0352.jit_fn.131.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/efficientnet-jax/module_0698.jit__lambda_.256.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/efficientnet-jax/module_1116.jit__normal__49.159.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jax-bayes/module_0018.jit__threefry_split.8.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jax-bayes/module_0032.jit_fn.12.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jax-bayes/module_0094.jit__normal.39.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jax-enhance/module_0015.jit__threefry_fold_in.8.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jax-enhance/module_0033.jit_prim_fun.13.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jax-enhance/module_0039.jit_fn.15.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jax-md/module_0013.jit__lambda_.7.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jax-md/module_0029.jit_safe_mask.15.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jax-md/module_0190.jit_safe_mask.61.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jax-models/1648622084550459.module_0235.jit_fn__34.7.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jax-models/1648627826626299.module_0161.jit__reduce_max.11.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jax-models/module_0471.jit__uniform.218.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jax-unirep/module_0050.jit__threefry_split.22.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jax-unirep/module_0054.jit__unstack.23.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jax-unirep/module_0119.jit__normal.38.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jax_muzero/1649835456716499.module_0095.jit__var__1.31.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jax_muzero/1649835462650207.module_0259.jit__lambda___12.8.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jax_muzero/1649835463509413.module_0275.jit__truncated_normal__7.318.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jaxlie/module_0009.jit_round.2.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jaxlie/module_0025.jit_apply.7.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jaxlie/module_0041.jit_prim_fun.14.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jaxrl/1652091810809638.module_0083.jit_get_td_target.657.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jaxrl/module_0140.jit_qr.53.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jaxrl/module_0145.jit__diag.54.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jaxrl/module_0183.jit_fn.71.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jraph/module_0047.jit__truncated_normal.20.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jraph/module_0101.jit_accuracy.49.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jraph/module_0104.jit_prim_fun.56.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/jraph/module_0243.jit_prim_fun.115.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/maml_flax/module_0033.jit_fn.13.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/maml_flax/module_0067.jit_train_step.26.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/maml_flax/module_0082.jit_divmod.28.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/neural-tangents/module_0000.jit__f.0.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/neural-tangents/module_0011.jit_fn.7.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/neural-tangents/module_0028.jit__cholesky.12.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/ott/module_0059.jit__uniform.25.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/ott/module_0164.jit_leaky_relu.74.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/ott/module_0308.jit__lambda_.59.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/ott/module_0308.jit_median.138.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/siren-jax/module_0010.jit__threefry_split.5.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/siren-jax/module_0014.jit__unstack.6.before_optimizations.txt create mode 100644 tests/hlo_texts/test_hlos/siren-jax/module_0017.jit__uniform.7.before_optimizations.txt create mode 100644 tests/pass_pipelines.py create mode 100755 third_party/pip_requirements/BUILD create mode 100755 third_party/pip_requirements/requirements.txt create mode 100644 third_party/tensorflow/BUILD create mode 100644 third_party/tensorflow/org_tensorflow_hloenv.patch diff --git a/.bazelrc b/.bazelrc new file mode 100644 index 0000000..15d2790 --- /dev/null +++ b/.bazelrc @@ -0,0 +1,246 @@ +############################################################################ +# All default build options below. + +# Sets the default Apple platform to macOS. +build --apple_platform_type=macos +build --macos_minimum_os=10.9 + +# Make Bazel print out all options from rc files. +build --announce_rc + +build --define open_source_build=true + +build --spawn_strategy=standalone + +build --enable_platform_specific_config + +# Disable enabled-by-default TensorFlow features that we don't care about. +build --define=no_aws_support=true +build --define=no_gcp_support=true +build --define=no_hdfs_support=true +build --define=no_kafka_support=true +build --define=no_ignite_support=true + +build --define=grpc_no_ares=true + +build -c opt + +build --config=short_logs + +build --copt=-DMLIR_PYTHON_PACKAGE_PREFIX=jaxlib.mlir. + +########################################################################### + +build:debug -c dbg +build:debug --javacopt="-g" +build:debug --copt="-g" +build:debug --strip="never" + +build:posix --copt=-fvisibility=hidden +build:posix --copt=-Wno-sign-compare +build:posix --cxxopt=-std=c++14 +build:posix --host_cxxopt=-std=c++14 + +build:avx_posix --copt=-mavx +build:avx_posix --host_copt=-mavx + +build:avx_windows --copt=/arch=AVX + +build:avx_linux --copt=-mavx +build:avx_linux --host_copt=-mavx + +build:native_arch_posix --copt=-march=native +build:native_arch_posix --host_copt=-march=native + +build:mkl_open_source_only --define=tensorflow_mkldnn_contraction_kernel=1 + +build:cuda --repo_env TF_NEED_CUDA=1 +build:cuda --action_env TF_CUDA_COMPUTE_CAPABILITIES="3.5,5.2,6.0,7.0,8.0" +build:cuda --crosstool_top=@local_config_cuda//crosstool:toolchain +build:cuda --@local_config_cuda//:enable_cuda +build:cuda --define=xla_python_enable_gpu=true + +build:rocm --crosstool_top=@local_config_rocm//crosstool:toolchain +build:rocm --define=using_rocm=true --define=using_rocm_hipcc=true +build:rocm --define=xla_python_enable_gpu=true +build:rocm --repo_env TF_NEED_ROCM=1 +build:rocm --action_env TF_ROCM_AMDGPU_TARGETS="gfx900,gfx906,gfx908" + +build:nonccl --define=no_nccl_support=true + +# Tensorflow uses M_* math constants that only get defined by MSVC headers if +# _USE_MATH_DEFINES is defined. +build:windows --copt=/D_USE_MATH_DEFINES +build:windows --host_copt=/D_USE_MATH_DEFINES +# Make sure to include as little of windows.h as possible +build:windows --copt=-DWIN32_LEAN_AND_MEAN +build:windows --host_copt=-DWIN32_LEAN_AND_MEAN +build:windows --copt=-DNOGDI +build:windows --host_copt=-DNOGDI +# https://devblogs.microsoft.com/cppblog/announcing-full-support-for-a-c-c-conformant-preprocessor-in-msvc/ +# otherwise, there will be some compiling error due to preprocessing. +build:windows --copt=/Zc:preprocessor +build:windows --cxxopt=/std:c++14 +build:windows --host_cxxopt=/std:c++14 +# Generate PDB files, to generate useful PDBs, in opt compilation_mode +# --copt /Z7 is needed. +build:windows --linkopt=/DEBUG +build:windows --host_linkopt=/DEBUG +build:windows --linkopt=/OPT:REF +build:windows --host_linkopt=/OPT:REF +build:windows --linkopt=/OPT:ICF +build:windows --host_linkopt=/OPT:ICF +build:windows --experimental_strict_action_env=true + +build:linux --config=posix +# Workaround for gcc 10+ warnings related to upb. +# See https://github.com/tensorflow/tensorflow/issues/39467 +build:linux --copt=-Wno-stringop-truncation +build:linux --copt=-Wno-array-parameter + +build:macos --config=posix + +# Suppress all warning messages. +build:short_logs --output_filter=DONT_MATCH_ANYTHING + +build:tpu --define=with_tpu_support=true + +######################################################################### +# RBE config options below. +# Flag to enable remote config +common --experimental_repo_remote_exec + +build:rbe --repo_env=BAZEL_DO_NOT_DETECT_CPP_TOOLCHAIN=1 +build:rbe --google_default_credentials +build:rbe --bes_backend=buildeventservice.googleapis.com +build:rbe --bes_results_url="https://source.cloud.google.com/results/invocations" +build:rbe --bes_timeout=600s +build:rbe --define=EXECUTOR=remote +build:rbe --distinct_host_configuration=false +build:rbe --flaky_test_attempts=3 +build:rbe --jobs=200 +build:rbe --remote_executor=grpcs://remotebuildexecution.googleapis.com +build:rbe --remote_timeout=3600 +build:rbe --spawn_strategy=remote,worker,standalone,local +test:rbe --test_env=USER=anon +# Attempt to minimize the amount of data transfer between bazel and the remote +# workers: +build:rbe --remote_download_toplevel + +build:rbe_linux --config=rbe +build:rbe_linux --action_env=PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/go/bin" +build:rbe_linux --host_javabase=@bazel_toolchains//configs/ubuntu16_04_clang/1.1:jdk8 +build:rbe_linux --javabase=@bazel_toolchains//configs/ubuntu16_04_clang/1.1:jdk8 +build:rbe_linux --host_java_toolchain=@bazel_tools//tools/jdk:toolchain_hostjdk8 +build:rbe_linux --java_toolchain=@bazel_tools//tools/jdk:toolchain_hostjdk8 + +# Non-rbe settings we should include because we do not run configure +build:rbe_linux --config=avx_linux +build:rbe_linux --linkopt=-lrt +build:rbe_linux --host_linkopt=-lrt +build:rbe_linux --linkopt=-lm +build:rbe_linux --host_linkopt=-lm + +# Use the GPU toolchain until the CPU one is ready. +# https://github.com/bazelbuild/bazel/issues/13623 +build:rbe_cpu_linux_base --config=rbe_linux +build:rbe_cpu_linux_base --host_crosstool_top="@ubuntu18.04-gcc7_manylinux2010-cuda11.2-cudnn8.1-tensorrt7.2_config_cuda//crosstool:toolchain" +build:rbe_cpu_linux_base --crosstool_top="@ubuntu18.04-gcc7_manylinux2010-cuda11.2-cudnn8.1-tensorrt7.2_config_cuda//crosstool:toolchain" +build:rbe_cpu_linux_base --extra_toolchains="@ubuntu18.04-gcc7_manylinux2010-cuda11.2-cudnn8.1-tensorrt7.2_config_cuda//crosstool:toolchain-linux-x86_64" +build:rbe_cpu_linux_base --extra_execution_platforms="@ubuntu18.04-gcc7_manylinux2010-cuda11.2-cudnn8.1-tensorrt7.2_config_platform//:platform" +build:rbe_cpu_linux_base --host_platform="@ubuntu18.04-gcc7_manylinux2010-cuda11.2-cudnn8.1-tensorrt7.2_config_platform//:platform" +build:rbe_cpu_linux_base --platforms="@ubuntu18.04-gcc7_manylinux2010-cuda11.2-cudnn8.1-tensorrt7.2_config_platform//:platform" + +build:rbe_cpu_linux_py37 --config=rbe_cpu_linux_base --repo_env=TF_PYTHON_CONFIG_REPO="@ubuntu18.04-gcc7_manylinux2010-cuda11.2-cudnn8.1-tensorrt7.2_config_python3.7" +build:rbe_cpu_linux_py37 --python_path="/usr/local/bin/python3.7" +build:rbe_cpu_linux_py38 --config=rbe_cpu_linux_base --repo_env=TF_PYTHON_CONFIG_REPO="@ubuntu18.04-gcc7_manylinux2010-cuda11.2-cudnn8.1-tensorrt7.2_config_python3.8" +build:rbe_cpu_linux_py38 --python_path="/usr/local/bin/python3.8" +build:rbe_cpu_linux_py39 --config=rbe_cpu_linux_base --repo_env=TF_PYTHON_CONFIG_REPO="@ubuntu18.04-gcc7_manylinux2010-cuda11.2-cudnn8.1-tensorrt7.2_config_python3.9" +build:rbe_cpu_linux_py39 --python_path="/usr/local/bin/python3.9" +build:rbe_cpu_linux_py310 --config=rbe_cpu_linux_base --repo_env=TF_PYTHON_CONFIG_REPO="@ubuntu18.04-gcc7_manylinux2010-cuda11.2-cudnn8.1-tensorrt7.2_config_python3.10" +build:rbe_cpu_linux_py310 --python_path="/usr/local/bin/python3.10" + +build:rbe_linux_cuda_base --config=rbe_linux +build:rbe_linux_cuda_base --config=cuda +build:rbe_linux_cuda_base --repo_env=REMOTE_GPU_TESTING=1 + +build:rbe_linux_cuda11.1_nvcc_base --config=rbe_linux_cuda_base +build:rbe_linux_cuda11.1_nvcc_base --action_env=TF_CUDA_VERSION=11 +build:rbe_linux_cuda11.1_nvcc_base --action_env=TF_CUDNN_VERSION=8 +build:rbe_linux_cuda11.1_nvcc_base --action_env=CUDA_TOOLKIT_PATH="/usr/local/cuda-11.1" +build:rbe_linux_cuda11.1_nvcc_base --action_env=LD_LIBRARY_PATH="/usr/local/cuda:/usr/local/cuda/lib64:/usr/local/cuda/extras/CUPTI/lib64:/usr/local/tensorrt/lib" +build:rbe_linux_cuda11.1_nvcc_base --action_env=GCC_HOST_COMPILER_PATH="/dt7/usr/bin/gcc" +test:rbe_linux_cuda11.1_nvcc_base --test_env=LD_LIBRARY_PATH="/usr/local/cuda/lib64:/usr/local/cuda/extras/CUPTI/lib64:/usr/local/cuda-11.1/lib64" +build:rbe_linux_cuda11.1_nvcc_base --host_crosstool_top="@ubuntu18.04-gcc7_manylinux2010-cuda11.1-cudnn8-tensorrt7.2_config_cuda//crosstool:toolchain" +build:rbe_linux_cuda11.1_nvcc_base --crosstool_top="@ubuntu18.04-gcc7_manylinux2010-cuda11.1-cudnn8-tensorrt7.2_config_cuda//crosstool:toolchain" +build:rbe_linux_cuda11.1_nvcc_base --extra_toolchains="@ubuntu18.04-gcc7_manylinux2010-cuda11.1-cudnn8-tensorrt7.2_config_cuda//crosstool:toolchain-linux-x86_64" +build:rbe_linux_cuda11.1_nvcc_base --extra_execution_platforms="@ubuntu18.04-gcc7_manylinux2010-cuda11.1-cudnn8-tensorrt7.2_config_platform//:platform" +build:rbe_linux_cuda11.1_nvcc_base --host_platform="@ubuntu18.04-gcc7_manylinux2010-cuda11.1-cudnn8-tensorrt7.2_config_platform//:platform" +build:rbe_linux_cuda11.1_nvcc_base --platforms="@ubuntu18.04-gcc7_manylinux2010-cuda11.1-cudnn8-tensorrt7.2_config_platform//:platform" +build:rbe_linux_cuda11.1_nvcc_base --repo_env=TF_CUDA_CONFIG_REPO="@ubuntu18.04-gcc7_manylinux2010-cuda11.1-cudnn8-tensorrt7.2_config_cuda" +build:rbe_linux_cuda11.1_nvcc_base --repo_env=TF_TENSORRT_CONFIG_REPO="@ubuntu18.04-gcc7_manylinux2010-cuda11.1-cudnn8-tensorrt7.2_config_tensorrt" +build:rbe_linux_cuda11.1_nvcc_base --repo_env=TF_NCCL_CONFIG_REPO="@ubuntu18.04-gcc7_manylinux2010-cuda11.1-cudnn8-tensorrt7.2_config_nccl" +build:rbe_linux_cuda11.1_nvcc_py3.7 --config=rbe_linux_cuda11.1_nvcc_base --repo_env=TF_PYTHON_CONFIG_REPO="@ubuntu18.04-gcc7_manylinux2010-cuda11.1-cudnn8-tensorrt7.2_config_python3.7" +build:rbe_linux_cuda11.1_nvcc_py3.7 --python_path="/usr/local/bin/python3.7" +build:rbe_linux_cuda11.1_nvcc_py3.8 --config=rbe_linux_cuda11.1_nvcc_base --repo_env=TF_PYTHON_CONFIG_REPO="@ubuntu18.04-gcc7_manylinux2010-cuda11.1-cudnn8-tensorrt7.2_config_python3.8" +build:rbe_linux_cuda11.1_nvcc_py3.8 --python_path="/usr/local/bin/python3.8" +build:rbe_linux_cuda11.1_nvcc_py3.9 --config=rbe_linux_cuda11.1_nvcc_base --repo_env=TF_PYTHON_CONFIG_REPO="@ubuntu18.04-gcc7_manylinux2010-cuda11.1-cudnn8-tensorrt7.2_config_python3.9" +build:rbe_linux_cuda11.1_nvcc_py3.9 --python_path="/usr/local/bin/python3.9" +build:rbe_linux_cuda11.1_nvcc_py3.10 --config=rbe_linux_cuda11.1_nvcc_base --repo_env=TF_PYTHON_CONFIG_REPO="@ubuntu18.04-gcc7_manylinux2010-cuda11.1-cudnn8-tensorrt7.2_config_python3.10" +build:rbe_linux_cuda11.1_nvcc_py3.10 --python_path="/usr/local/bin/python3.10" + +build:rbe_linux_cuda11.4_nvcc_base --config=rbe_linux_cuda_base +build:rbe_linux_cuda11.4_nvcc_base --action_env=TF_CUDA_VERSION=11 +build:rbe_linux_cuda11.4_nvcc_base --action_env=TF_CUDNN_VERSION=8 +build:rbe_linux_cuda11.4_nvcc_base --action_env=CUDA_TOOLKIT_PATH="/usr/local/cuda-11.4" +build:rbe_linux_cuda11.4_nvcc_base --action_env=LD_LIBRARY_PATH="/usr/local/cuda:/usr/local/cuda/lib64:/usr/local/cuda/extras/CUPTI/lib64:/usr/local/tensorrt/lib" +build:rbe_linux_cuda11.4_nvcc_base --action_env=GCC_HOST_COMPILER_PATH="/dt7/usr/bin/gcc" +build:rbe_linux_cuda11.4_nvcc_base --host_crosstool_top="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.2-tensorrt7.2_config_cuda//crosstool:toolchain" +build:rbe_linux_cuda11.4_nvcc_base --crosstool_top="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.2-tensorrt7.2_config_cuda//crosstool:toolchain" +build:rbe_linux_cuda11.4_nvcc_base --extra_toolchains="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.2-tensorrt7.2_config_cuda//crosstool:toolchain-linux-x86_64" +build:rbe_linux_cuda11.4_nvcc_base --extra_execution_platforms="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.2-tensorrt7.2_config_platform//:platform" +build:rbe_linux_cuda11.4_nvcc_base --host_platform="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.2-tensorrt7.2_config_platform//:platform" +build:rbe_linux_cuda11.4_nvcc_base --platforms="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.2-tensorrt7.2_config_platform//:platform" +build:rbe_linux_cuda11.4_nvcc_base --repo_env=TF_CUDA_CONFIG_REPO="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.2-tensorrt7.2_config_cuda" +build:rbe_linux_cuda11.4_nvcc_base --repo_env=TF_TENSORRT_CONFIG_REPO="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.2-tensorrt7.2_config_tensorrt" +build:rbe_linux_cuda11.4_nvcc_base --repo_env=TF_NCCL_CONFIG_REPO="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.2-tensorrt7.2_config_nccl" +build:rbe_linux_cuda11.4_nvcc_py3.7 --config=rbe_linux_cuda11.4_nvcc_base --repo_env=TF_PYTHON_CONFIG_REPO="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.2-tensorrt7.2_config_python3.7" +build:rbe_linux_cuda11.4_nvcc_py3.7 --python_path="/usr/local/bin/python3.7" +build:rbe_linux_cuda11.4_nvcc_py3.8 --config=rbe_linux_cuda11.4_nvcc_base --repo_env=TF_PYTHON_CONFIG_REPO="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.2-tensorrt7.2_config_python3.8" +build:rbe_linux_cuda11.4_nvcc_py3.8 --python_path="/usr/local/bin/python3.8" +build:rbe_linux_cuda11.4_nvcc_py3.9 --config=rbe_linux_cuda11.4_nvcc_base --repo_env=TF_PYTHON_CONFIG_REPO="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.2-tensorrt7.2_config_python3.9" +build:rbe_linux_cuda11.4_nvcc_py3.9 --python_path="/usr/local/bin/python3.9" +build:rbe_linux_cuda11.4_nvcc_py3.10 --config=rbe_linux_cuda11.4_nvcc_base --repo_env=TF_PYTHON_CONFIG_REPO="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.2-tensorrt7.2_config_python3.10" +build:rbe_linux_cuda11.4_nvcc_py3.10 --python_path="/usr/local/bin/python3.10" + +build:rbe_linux_cuda11.4_cudnn8.0.5_nvcc_base --config=rbe_linux_cuda_base +build:rbe_linux_cuda11.4_cudnn8.0.5_nvcc_base --action_env=TF_CUDA_VERSION=11 +build:rbe_linux_cuda11.4_cudnn8.0.5_nvcc_base --action_env=TF_CUDNN_VERSION=8.0.5 +build:rbe_linux_cuda11.4_cudnn8.0.5_nvcc_base --action_env=CUDA_TOOLKIT_PATH="/usr/local/cuda-11.4" +build:rbe_linux_cuda11.4_cudnn8.0.5_nvcc_base --action_env=LD_LIBRARY_PATH="/usr/local/cuda:/usr/local/cuda/lib64:/usr/local/cuda/extras/CUPTI/lib64:/usr/local/tensorrt/lib" +build:rbe_linux_cuda11.4_cudnn8.0.5_nvcc_base --action_env=GCC_HOST_COMPILER_PATH="/dt7/usr/bin/gcc" +build:rbe_linux_cuda11.4_cudnn8.0.5_nvcc_base --host_crosstool_top="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.0.5-tensorrt7.2_config_cuda//crosstool:toolchain" +build:rbe_linux_cuda11.4_cudnn8.0.5_nvcc_base --crosstool_top="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.0.5-tensorrt7.2_config_cuda//crosstool:toolchain" +build:rbe_linux_cuda11.4_cudnn8.0.5_nvcc_base --extra_toolchains="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.0.5-tensorrt7.2_config_cuda//crosstool:toolchain-linux-x86_64" +build:rbe_linux_cuda11.4_cudnn8.0.5_nvcc_base --extra_execution_platforms="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.0.5-tensorrt7.2_config_platform//:platform" +build:rbe_linux_cuda11.4_cudnn8.0.5_nvcc_base --host_platform="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.0.5-tensorrt7.2_config_platform//:platform" +build:rbe_linux_cuda11.4_cudnn8.0.5_nvcc_base --platforms="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.0.5-tensorrt7.2_config_platform//:platform" +build:rbe_linux_cuda11.4_cudnn8.0.5_nvcc_base --repo_env=TF_CUDA_CONFIG_REPO="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.0.5-tensorrt7.2_config_cuda" +build:rbe_linux_cuda11.4_cudnn8.0.5_nvcc_base --repo_env=TF_NCCL_CONFIG_REPO="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.0.5-tensorrt7.2_config_nccl" +build:rbe_linux_cuda11.4_cudnn8.0.5_nvcc_py3.7 --config=rbe_linux_cuda11.4_cudnn8.0.5_nvcc_base --repo_env=TF_PYTHON_CONFIG_REPO="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.0.5-tensorrt7.2_config_python3.7" +build:rbe_linux_cuda11.4_cudnn8.0.5_nvcc_py3.7 --python_path="/usr/local/bin/python3.7" +build:rbe_linux_cuda11.4_cudnn8.0.5_nvcc_py3.8 --config=rbe_linux_cuda11.4_cudnn8.0.5_nvcc_base --repo_env=TF_PYTHON_CONFIG_REPO="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.0.5-tensorrt7.2_config_python3.8" +build:rbe_linux_cuda11.4_cudnn8.0.5_nvcc_py3.8 --python_path="/usr/local/bin/python3.8" +build:rbe_linux_cuda11.4_cudnn8.0.5_nvcc_py3.9 --config=rbe_linux_cuda11.4_cudnn8.0.5_nvcc_base --repo_env=TF_PYTHON_CONFIG_REPO="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.0.5-tensorrt7.2_config_python3.9" +build:rbe_linux_cuda11.4_cudnn8.0.5_nvcc_py3.9 --python_path="/usr/local/bin/python3.9" +build:rbe_linux_cuda11.4_cudnn8.0.5_nvcc_py3.10 --config=rbe_linux_cuda11.4_cudnn8.0.5_nvcc_base --repo_env=TF_PYTHON_CONFIG_REPO="@ubuntu18.04-gcc7_manylinux2010-cuda11.4-cudnn8.0.5-tensorrt7.2_config_python3.10" +build:rbe_linux_cuda11.4_cudnn8.0.5_nvcc_py3.10 --python_path="/usr/local/bin/python3.10" + +# These you may need to change for your own GCP project. +build:tensorflow_testing_rbe --project_id=tensorflow-testing +common:tensorflow_testing_rbe_linux --remote_instance_name=projects/tensorflow-testing/instances/default_instance +build:tensorflow_testing_rbe_linux --config=tensorflow_testing_rbe +############################################################################# + +try-import %workspace%/.hloenv_configure.bazelrc + diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..e06cf47 --- /dev/null +++ b/.clang-format @@ -0,0 +1,4 @@ +# Run manually to reformat a file: +# clang-format -i --style=file +BasedOnStyle: Google +DerivePointerAlignment: false diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..d06ddc9 --- /dev/null +++ b/.gitignore @@ -0,0 +1,52 @@ +.DS_Store +.ipynb_checkpoints +node_modules +/.bazelrc.user +/.tf_configure.bazelrc +/bazel-* +/bazel_pip +/tools/python_bin_path.sh +/tensorflow/tools/git/gen +/pip_test +/_python_build +/_build +*.pyc +__pycache__ +*.swp +.vscode/ +cmake_build/ +.idea/** +/build/ +[Bb]uild/ +/api_init_files_list.txt +/estimator_api_init_files_list.txt +*.whl +docs/_build + +# Android +.gradle +.idea +*.iml +local.properties +gradleBuild + +# iOS +*.pbxproj +*.xcworkspace +/*.podspec +Podfile.lock +Pods +xcuserdata + +# For Sublime SFTP +*sftp-config.json + +# Debug files +/debug + +# For trunk.io +.flake8 +.isort.cfg +.markdownlint.yaml +.shellcheckrc +.trunk/ diff --git a/.hloenv_configure.bazelrc b/.hloenv_configure.bazelrc new file mode 100644 index 0000000..c241b45 --- /dev/null +++ b/.hloenv_configure.bazelrc @@ -0,0 +1,20 @@ +build --action_env PYTHON_BIN_PATH="/usr/bin/python3" +build --action_env PYTHON_LIB_PATH="/usr/lib/python3/dist-packages" +build --python_path="/usr/bin/python3" +build --action_env TF_CUDA_VERSION="11" +build --action_env TF_CUDNN_VERSION="8" +build --action_env TF_NCCL_VERSION="" +build --action_env TF_CUDA_PATHS="/usr/local/cuda-11.2,/usr" +build --action_env CUDA_TOOLKIT_PATH="/usr/local/cuda-11.2" +build --action_env TF_CUDA_COMPUTE_CAPABILITIES="8.0" +build --action_env GCC_HOST_COMPILER_PATH="/usr/bin/x86_64-linux-gnu-gcc-9" +build --config=cuda +build:opt --copt=-Wno-sign-compare +build:opt --host_copt=-Wno-sign-compare +test --flaky_test_attempts=3 +test --test_size_filters=small,medium +test --test_env=LD_LIBRARY_PATH +test:v1 --test_tag_filters=-benchmark-test,-no_oss,-no_gpu,-oss_serial +test:v1 --build_tag_filters=-benchmark-test,-no_oss,-no_gpu +test:v2 --test_tag_filters=-benchmark-test,-no_oss,-no_gpu,-oss_serial,-v1only +test:v2 --build_tag_filters=-benchmark-test,-no_oss,-no_gpu,-v1only diff --git a/BUILD b/BUILD new file mode 100644 index 0000000..7fcf5fc --- /dev/null +++ b/BUILD @@ -0,0 +1,33 @@ +# Copyright 2022 Garena Online Private Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +load("@pip_requirements//:requirements.bzl", "requirement") + +py_binary( + name = "setup", + srcs = [ + "setup.py", + ], + data = [ + "README.md", + "setup.cfg", + "//hloenv", + ], + main = "setup.py", + python_version = "PY3", + deps = [ + "//hloenv", + requirement("setuptools"), + ], +) diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..f2430e6 --- /dev/null +++ b/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2021 Garena Online Private Limited + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..d821c3e --- /dev/null +++ b/Makefile @@ -0,0 +1,54 @@ +SHELL=/bin/bash +PROJECT_NAME = hloenv +CPP_FILES = $(shell find hloenv/ -type f -name "*.h" -o -name "*.cc") +ROOT_DIR = $(shell dirname $(realpath $(firstword $(MAKEFILE_LIST)))) +VERSION = 0.0.1 +check_install = python3 -c "import $(1)" || pip3 install $(1) --upgrade +check_install_extra = python3 -c "import $(1)" || pip3 install $(2) --upgrade + +go-install: + # requires go >= 1.16 + command -v go || (sudo apt-get install -y golang-1.16 && sudo ln -sf /usr/lib/go-1.16/bin/go /usr/bin/go) + +bazel-install: go-install + command -v bazel || (go install github.com/bazelbuild/bazelisk@latest && ln -sf $(HOME)/go/bin/bazelisk $(HOME)/go/bin/bazel) + +build: bazel-install + bazel run //:setup -- bdist_wheel + mkdir -p dist + cp bazel-bin/setup.runfiles/org_$(PROJECT_NAME)/dist/*.whl ./dist + +build-debug: bazel-install + bazel run --strip=never --copt="-DNDEBUG" --compilation_mode=dbg //:setup -- bdist_wheel + mkdir -p dist + cp bazel-bin/setup.runfiles/org_$(PROJECT_NAME)/dist/*.whl ./dist + +clean: bazel-install + bazel clean --expunge + +doc-install: + $(call check_install, sphinx) + $(call check_install, sphinx_rtd_theme) + +doc: doc-install + cd docs && make html && cd _build/html && python3 -m http.server + +install: + python3 -m pip install --force-reinstall "${ROOT_DIR}/dist/hloenv-${VERSION}-cp38-cp38-linux_x86_64.whl" + +test: + bazel test --test_output=all //tests/... + +format: yapf clang-format + +lint: + flake8 hloenv/ --count --show-source --statistics + cpplint --root=. --recursive hloenv/ + clang-format-11 --style=Google -i ${CPP_FILES} -n -Werror + +yapf: + $(call check_install, yapf) + yapf -r -i hloenv/ tests/ examples/ + +clang-format: + clang-format-11 --style=Google -i ${CPP_FILES} diff --git a/README.md b/README.md new file mode 100644 index 0000000..a3c4f76 --- /dev/null +++ b/README.md @@ -0,0 +1,100 @@ +# HloEnv + +*HloEnv* is an environment based on Accelerated Linear Algebra +([XLA](https://www.tensorflow.org/xla/)) for deep learning compiler +optimization research. HloEnv transforms all graph rewrites into a +common representation, providing a flexible interface to control and +modify existing graph optimization passes. In this representation, an +XLA pass is converted into a set of sequential rewrite decisions. + +HloEnv has the following major features: + + - **The alternative graph representation** + + HloEnv frames the graph optimization problem as a sequential + rewrite decision problem, serving as a single-player game engine. + See [always_pick_first](examples/alway_pick_first.py) and + [uniform_policy](examples/uniform_policy.py) for examples of interacting with + HloEnv and optimizing a HLO computation grpah. + + + - **Python interface for full XLA optimization passes and pipelines** + + HloEnv provides a Python interface to control and modify existing + graph optimization passes. See [general_fusion_pipeline](examples/general_fusion_pipeline.py) for + an example of our customized XLA optimization pipeline. + +The design of HloEnv points to a potential future where deep learning +compiler engineers only need to develop and maintain a simple set of +rewrite rules. The complicated heuristics are left to machine +learning-generated optimization strategies that generalize to both new +deep learning models and new deep learning hardware. + +## Citations + +HloEnv is described in details in the following paper: + +``` bibtex +@inproceedings{HloEnv2022, + author = {Chin Yang Oh, Kunhao Zheng, Bingyi Kang, Xinyi Wan, Zhongwen Xu, Shuicheng Yan, Min Lin, Yangzihao Wang}, + title = {HloEnv: A Graph Rewrite Environment for Deep Learning Compiler Optimization Research}, + booktitle = {Workshop on ML for Systems at NeurIPS 2022}, + year = {2022}, + series = {NeurIPS '22}, + month = dec, +} +``` + +## Docs + +The full documentation for HloEnv can be found at [this link](https://hloenv.readthedocs.io/). + +## Quick Start + +Install the pre-built HloEnv wheel from PyPI: + +```bash +python3 -m pip install hloenv +``` + +To run examples, you need to install the following dependencies in your python package: + + - [TensorFlow==2.9.0](https://www.tensorflow.org/install) + - NumPy + +## Build HloEnv + +To build HloEnv and evaluate HLO graph runtime, you need to install the following dependencies: + + - [Bazel](https://bazel.build/install?hl=en) + - liblapack-dev + - CUDA + +To clone HloEnv and install Tensorflow, run the following command: + +```bash +git clone git@github.com:sail-sg/hloenv.git +cd hloenv +python -m venv hloenv-env +source hloenv-env/bin/activate +python3 -m pip install tensorflow==2.9.0 +``` + +When met the minimum requirement, building HloEnv Python Wheels can be very simple. + +In the root directory of HloEnv, run the following command: + +```bash +make build +``` +Will build the wheels file and put it under the folder *dist*. + +```bash +make install +``` +Will install the freshly built Python Wheels and all the dependencies. + +## HLO Dataset + +You can find the unoptimized HLO text files harvested from JAX implemented repositories on GitHub [here](https://drive.google.com/file/d/1XF7fz59HvsUIfUhgF-yXF7YE3y-lOBFZ/view?usp=sharing) + diff --git a/WORKSPACE b/WORKSPACE new file mode 100644 index 0000000..03203bf --- /dev/null +++ b/WORKSPACE @@ -0,0 +1,103 @@ +# Copyright 2022 Garena Online Private Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +workspace(name = "org_hloenv") + +load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository") +load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive") + +http_archive( + name = "rules_python", + sha256 = "954aa89b491be4a083304a2cb838019c8b8c3720a7abb9c4cb81ac7a24230cea", + urls = [ + "https://mirror.bazel.build/github.com/bazelbuild/rules_python/releases/download/0.4.0/rules_python-0.4.0.tar.gz", + "https://github.com/bazelbuild/rules_python/releases/download/0.4.0/rules_python-0.4.0.tar.gz", + ], +) + +load("//hloenv:pip.bzl", pip_workspace = "workspace") +pip_workspace() + +load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository") + +git_repository( + name = "org_tensorflow", + remote = "https://github.com/tensorflow/tensorflow.git", + commit = "8727d035e7aa593720d16a5f57f70f3b5a93bd00", + patches = ["//third_party/tensorflow:org_tensorflow_hloenv.patch"], + patch_args = ["-p1"], +) + +git_repository( + name = "jax", + remote = "https://github.com/google/jax.git", + tag = "jaxlib-v0.3.0", +) + + +http_archive( + name = "com_google_googletest", + urls = ["https://github.com/google/googletest/archive/609281088cfefc76f9d0ce82e1ff6c30cc3591e5.zip"], + strip_prefix = "googletest-609281088cfefc76f9d0ce82e1ff6c30cc3591e5", +) + +http_archive( + name = "pocketfft", + build_file = "@jax//third_party/pocketfft:BUILD.bazel", + sha256 = "66eda977b195965d27aeb9d74f46e0029a6a02e75fbbc47bb554aad68615a260", + strip_prefix = "pocketfft-f800d91ba695b6e19ae2687dd60366900b928002", + urls = [ + "https://github.com/mreineck/pocketfft/archive/f800d91ba695b6e19ae2687dd60366900b928002.tar.gz", + "https://storage.googleapis.com/jax-releases/mirror/pocketfft/pocketfft-f800d91ba695b6e19ae2687dd60366900b928002.tar.gz", + ], +) + +http_archive( + name = "pybind11_bazel", + sha256 = "a5666d950c3344a8b0d3892a88dc6b55c8e0c78764f9294e806d69213c03f19d", + strip_prefix = "pybind11_bazel-26973c0ff320cb4b39e45bc3e4297b82bc3a6c09", + urls = ["https://github.com/pybind/pybind11_bazel/archive/26973c0ff320cb4b39e45bc3e4297b82bc3a6c09.zip"], +) + +# *************************************************************** +# TensorFlow Initialization +# *************************************************************** + +# Initialize TensorFlow's external dependencies. +load("@org_tensorflow//tensorflow:workspace3.bzl", "workspace") + +workspace() + +load("@org_tensorflow//tensorflow:workspace2.bzl", "workspace") + +workspace() + +load("@org_tensorflow//tensorflow:workspace1.bzl", "workspace") + +workspace() + +load("@org_tensorflow//tensorflow:workspace0.bzl", "workspace") + +workspace() + +# Initialize bazel package rules' external dependencies. +load("@rules_pkg//:deps.bzl", "rules_pkg_dependencies") + +rules_pkg_dependencies() + +load("@rules_proto//proto:repositories.bzl", "rules_proto_dependencies", "rules_proto_toolchains") + +rules_proto_dependencies() + +rules_proto_toolchains() diff --git a/docs/Makefile b/docs/Makefile new file mode 100644 index 0000000..298ea9e --- /dev/null +++ b/docs/Makefile @@ -0,0 +1,19 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line. +SPHINXOPTS = +SPHINXBUILD = sphinx-build +SOURCEDIR = . +BUILDDIR = _build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) \ No newline at end of file diff --git a/docs/conf.py b/docs/conf.py new file mode 100644 index 0000000..ed84458 --- /dev/null +++ b/docs/conf.py @@ -0,0 +1,232 @@ +# -*- coding: utf-8 -*- +# +# Configuration file for the Sphinx documentation builder. +# +# This file does only contain a selection of the most common options. For a +# full list see the documentation: +# http://www.sphinx-doc.org/en/master/config + +# -- Path setup -------------------------------------------------------------- + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. +# +import os +import sys +sys.path.insert(0, os.path.abspath('../hloenv')) + + +def get_version() -> str: + # https://packaging.python.org/guides/single-sourcing-package-version/ + with open(os.path.join("..", "hloenv", "__init__.py"), "r") as f: + init = f.read().split() + return init[init.index("__version__") + 2][1:-1] + +# -- Project information ----------------------------------------------------- + +project = 'HloEnv' +copyright = '2022, Chin Yang Oh, Kunhao Zheng, Bingyi Kang, Xinyi Wan, Zhongwen Xu, Shuicheng Yan, Min Lin, Yangzihao Wang' +author = 'Chin Yang Oh, Kunhao Zheng, Bingyi Kang, Xinyi Wan, Zhongwen Xu, Shuicheng Yan, Min Lin, Yangzihao Wang' + +# The short X.Y version +version = '' +# The full version, including alpha/beta/rc tags +release = get_version() + +# -- General configuration --------------------------------------------------- + +# If your documentation needs a minimal Sphinx version, state it here. +# +# needs_sphinx = '1.0' + +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom +# ones. +extensions = [ + 'sphinx.ext.autodoc', # Core library for html generation from docstrings + 'sphinx.ext.viewcode', + 'sphinx.ext.autosummary', # Create neat summary tables + 'sphinx.ext.napoleon', # Support for NumPy and Google style docstrings + 'sphinx.ext.autosectionlabel', +] +autosummary_generate = True + +autoclass_content = 'both' + +napoleon_include_init_with_doc = True + +def process_docstring(app, what, name, obj, options, lines): + for i in range(len(lines)): + lines[i] = lines[i].replace('hloenv.python.py_hlo_env', 'hloenv') + +def process_signature(app, what, name, obj, options, signature, return_annotation): + if signature: + signature = signature.replace('hloenv.python.py_hlo_env', 'hloenv') + if return_annotation: + return_annotation = return_annotation.replace('hloenv.python.py_hlo_env', 'hloenv') + + return signature, return_annotation + +# Add any paths that contain templates here, relative to this directory. +templates_path = ['_templates'] + +# The suffix(es) of source filenames. +# You can specify multiple suffix as a list of string: +# +# source_suffix = ['.rst', '.md'] +source_suffix = '.rst' + +# The master toctree document. +master_doc = 'index' + +# The language for content autogenerated by Sphinx. Refer to documentation +# for a list of supported languages. +# +# This is also used if you do content translation via gettext catalogs. +# Usually you set "language" from the command line for these cases. +language = None + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +# This pattern also affects html_static_path and html_extra_path. +exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] + +# The name of the Pygments (syntax highlighting) style to use. +pygments_style = None + + +# -- Options for HTML output ------------------------------------------------- + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +# +html_theme = 'sphinx_rtd_theme' + +# Theme options are theme-specific and customize the look and feel of a theme +# further. For a list of options available for each theme, see the +# documentation. +# +# html_theme_options = {} + +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named "default.css" will overwrite the builtin "default.css". +html_static_path = ['_static'] + +# Custom sidebar templates, must be a dictionary that maps document names +# to template names. +# +# The default sidebars (for documents that don't match any pattern) are +# defined by theme itself. Builtin themes are using these templates by +# default: ``['localtoc.html', 'relations.html', 'sourcelink.html', +# 'searchbox.html']``. +# +# html_sidebars = {} + + +# -- Options for HTMLHelp output --------------------------------------------- + +# Output file base name for HTML help builder. +htmlhelp_basename = 'HloEnvdoc' + + +# -- Options for LaTeX output ------------------------------------------------ + +latex_elements = { + # The paper size ('letterpaper' or 'a4paper'). + # + # 'papersize': 'letterpaper', + + # The font size ('10pt', '11pt' or '12pt'). + # + # 'pointsize': '10pt', + + # Additional stuff for the LaTeX preamble. + # + # 'preamble': '', + + # Latex figure (float) alignment + # + # 'figure_align': 'htbp', +} + +# Grouping the document tree into LaTeX files. List of tuples +# (source start file, target name, title, +# author, documentclass [howto, manual, or own class]). +latex_documents = [ + (master_doc, 'HloEnv.tex', 'HloEnv Documentation', + 'Chin Yang Oh, Kunhao Zheng, Bingyi Kang, Xinyi Wan, Zhongwen Xu, Shuicheng Yan, Min Lin, Yangzihao Wang', 'manual'), +] + + +# -- Options for manual page output ------------------------------------------ + +# One entry per manual page. List of tuples +# (source start file, name, description, authors, manual section). +man_pages = [ + (master_doc, 'hloenv', 'HloEnv Documentation', + [author], 1) +] + + +# -- Options for Texinfo output ---------------------------------------------- + +# Grouping the document tree into Texinfo files. List of tuples +# (source start file, target name, title, author, +# dir menu entry, description, category) +texinfo_documents = [ + (master_doc, 'HloEnv', 'HloEnv Documentation', + author, 'HloEnv', 'One line description of project.', + 'Miscellaneous'), +] + + +# -- Options for Epub output ------------------------------------------------- + +# Bibliographic Dublin Core info. +epub_title = project + +# The unique identifier of the text. This can be a ISBN number +# or the project homepage. +# +# epub_identifier = '' + +# A unique identification for the text. +# +# epub_uid = '' + +# A list of files that should not be packed into the epub file. +epub_exclude_files = ['search.html'] + + +# -- Extension configuration ------------------------------------------------- + +# -- Options for intersphinx extension --------------------------------------- + +# Example configuration for intersphinx: refer to the Python standard library. +intersphinx_mapping = {'https://docs.python.org/': None} + +# -- Options for todo extension ---------------------------------------------- + +# If true, `todo` and `todoList` produce output, else they produce nothing. +todo_include_todos = True + +def setup(app): + import hloenv + + # need to assign the names here, otherwise autodoc won't document these classes, + # and will instead just say 'alias of ...' + + hloenv.HloEnv.__name__ = 'HloEnv' + hloenv.HloModule.__name__ = 'HloModule' + hloenv.AltPipeline.__name__ = 'AltPipeline' + hloenv.Pipeline.__name__ = 'Pipeline' + hloenv.Pass.__name__ = 'Pass' + hloenv.HloPass.__name__ = 'HloPass' + hloenv.HloPass.__module__ = 'hloenv' + hloenv.GpuBackend.__name__ = 'GpuBackend' + hloenv.EvaluationResult.__name__ = 'EvaluationResult' + + app.connect('autodoc-process-docstring', process_docstring) + app.connect('autodoc-process-signature', process_signature) diff --git a/docs/examples.rst b/docs/examples.rst new file mode 100644 index 0000000..b7561c1 --- /dev/null +++ b/docs/examples.rst @@ -0,0 +1,416 @@ +.. _examples: + +Examples Using HloEnv +======================== + +This documentation only covers the Python interface. We will walk through two simple examples that make use of several HloEnv features. We first show how to read in an HLO text file and turn it into HLO graph features which can be used for implementing a user-defined decision-making agent. We then present a very simple decision-making agent where the policy randomly choose from available actions. + +Playing with HLO Graph Features +------------------------------- + +First make sure your current working directory is correct. + +.. code-block:: bash + + $ cd /path/to/hloenv/examples + +The HloEnv module holds most functionality, so we usually import it first. + +.. code-block:: python + + import os + import pathlib + import numpy as np + from hloenv import HloEnv + +Pick one hlo text file that we want to take a closer look. + +.. code-block:: python + + hlo_path = os.path.join( + pathlib.Path(__file__).parent.absolute(), + "hlo_texts/jax-md/module_0013.jit__lambda_.7.before_optimizations.txt" + ) + +Now we are ready to create a basic hlo env object on GPU backend. We haven't worked on other ML hardwares so current GPU is the only backend HloEnv supports. + +.. code-block:: python + + hlo_env = HloEnv(hlo_path, "gpu") + +The hlo env can automatically extract features from hlo text files and organize them into another class HloGraph. + +.. code-block:: python + + hlo_graph = hlo_env.get_hlo_graph() + +To make the features more array programming friendly, all the graph features in HloGraph are organized in the form of `CSR `_. There are three types of features: global graph feature, node feature, and in/out edge feature, all serve as the accessible members of HloGraph object. Details are in the following table: + +.. list-table:: **Global Graph Features** + :widths: 42 42 + :header-rows: 1 + + * - Feature Name + - Description + + * - out_edge_offsets + - The offset index to the actual out edge node ID indices array + + * - out_edge_indices + - The out edge node ID indices array + + * - in_edge_offsets + - The offset index to the actual in edge node ID indices array + + * - in_edge_indices + - The in edge node ID indices array + + * - alternative_indices + - The indices to all the *kAlternative* nodes + + * - opcode_attr_counts + - Number of attributes in HLO opcode + +All edge features are vectors of the length of number of edges in the HLO graph. In/Out edge features share the same feature set as follows. + +.. list-table:: **In and Out Edge Features** + :widths: 42 42 + :header-rows: 1 + + * - Feature Name + - Description + + * - uids + - Unique ID of the edge, a concatination of source and destination nodes uids + + * - srcs + - Node index of source node + + * - dsts + - Node index of destination node + + * - dims + - Dimension of the tensor flows by this edge + + * - layout + - Layout of the tensor flows by this edge + + * - lehmercodes + - The `Lehmer code `_ (a better embedding) of the tensor layout + + * - types + - Edge type is one of the following: outside any fusion, inside fusion, and cross fusion + + * - dtypes + - Data type of the tensor flows by this edge + +All node features are vectors of the length of number of HloInstructions (nodes) in the HloModule (HloGraph). + +.. list-table:: **Node Features** + :widths: 42 42 + :header-rows: 1 + + * - Feature Name + - Description + + * - uids + - Unique ID of an HloInstruction + + * - gids + - Sub computation ID the HloInstruction belongs to, 0 means in main computation. + + * - normalized_num_group_inst + - If an HloInstruction is inside a sub-computation, normalized_num_group_inst is the reciprocal of the total number of instructions in a sub-computation. This can serve as a weighting parameter for an instruction's impact + + * - num_users + - Number of HloInstructions that uses the result of this HloInstruction + + * - num_operands + - Number of HloInstructions whose results this HloInstruction uses + + * - opcodes + - HLO opcode index, as defined `here `__ + + * - opcode_attrs + - Unique attribute embeddings for each opcode + + * - num_opcode_attrs + - List of pairs, each pair contains the number of integer attribute and the number of enum attribute in opcode_attrs + + * - is_alternative + - List of boolean that shows if the HloInstruction is *kAlternative* + + * - is_in_fusion + - List of boolean that shows if the HloInstruction is inside a fused computation + + * - in_tensor_sizes + - The total input tensor size from all operands of this HloInstruction + + * - out_tensor_sizes + - The output tensor size of this HloInstruction + + * - has_max_in_tensor + - List of boolean that shows if one of the operands contains the max input tensor size + + * - has_max_out_tensor + - List of boolean that shows if the output tensor size has the maximum size + + * - names + - List of strings that shows the names of the HloInstruction + +The full-size code can be found `here `__. In our second example, we will show you how to use these features to create a simple decision-making agent and run XLA optimizations using it. + +Defining a Custom Pipeline +-------------------------- + +All of the passes that were initially defined in the full XLA optimization pipeline for compilation for GPU have been included in :class:`~hloenv.HloEnv`. A list of all of these passes can be found in :ref:`xla_passes`. + +A pass can be created by wrapping a :class:`~hloenv.HloPass` object within a :class:`~hloenv.Pass` object. This Pass can then be run within the :class:`~hloenv.HloEnv` to modify the :class:`~hloenv.HloModule` object loaded in the HloEnv. + +.. code-block:: python + + hlo_env = HloEnv("path/to/hlo.txt", "gpu") + fusion_pass = Pass(HloPass.GpuInstructionFusion(True)) + hlo_env.run(fusion_pass) + +Passes can be organized into :class:`~hloenv.Pipeline` objects, which can also be run by the HloEnv. + +.. code-block:: python + + op_splitter_pass = Pass(HloPass.VariadicOpSplitter()) + + fusion_pipeline = Pipeline("fusion-pre") + fusion_pipeline.add_pass(op_splitter_pass) + + # You can also add a HloPass directly without first wrapping it in Pass + fusion_pipeline.add_pass(HloPass.GpuInstructionFusion(True)) + + hlo_env.run(fusion_pipeline) + +A Pipeline can contain other Pipelines and Passes recursively, for example: + +.. code-block:: python + + fusion_pipeline_pre = Pipeline("fusion-pre") + fusion_pipeline_pre.add_pass(HloPass.VariadicOpSplitter()) + + self.fusion_pipeline_full = Pipeline("fusion") + self.fusion_pipeline_full.add(fusion_pipeline_pre) + self.fusion_pipeline_full.add(HloPass.GpuInstructionFusion(True)) + +To convert a pass into a `dry pass` we wrap it in an :class:`~hloenv.AltPipeline`. All rewrites performed by an AltPiplines are captures and converted into alternatives. If you wrap multiple passes or pipelines with this AltPipeline wrapper, `all` modifcations performed by each of those passes/pipelines will be in dry mode. + +.. code-block:: python + + # Wrapping a single pass in an AltPipeline + fusion_dry_pass = AltPipeline( + Pass( + HloPass.GpuInstructionFusion(True), # may_duplicate + ) + ) + + fusion_pipeline_post = Pipeline("fusion-post") + fusion_pipeline_post.add_pass(HloPass.FusionMerger()) + fusion_pipeline_post.add_pass(HloPass.GpuMultiOutputFusion()) + fusion_pipeline_post.add_pass(HloPass.HloCSE(True, True)) + + # Wrapping multiple passes in an AltPipeline + fusion_pipeline_post_dry = AltPipeline(fusion_pipeline_post) + + # Adding a pass directly to an AltPipeline + fusion_pipeline_post_dry.add_pass(HloPass.HloDCE()) + +A sample General Fusion Pipeline can be found in `examples/general_fusion_pipeline.py` which contains the full XLA optimization pipeline, except we replace the vertical fusion pipeline with our custom General Fusion pass. + +A Simple Decision-making Agent +------------------------------ + +We here present a very simple decision-making agent that randomly chooses from available actions in an optimization loop. +The loop will isolate out the graph rewrite in an XLA pass, and layout the decisions to choose. +At a high level, the optimization loop follows these steps: + +* run `pre_pass_optimizations` +* enter optimization loop + * run `pre_dry_pass_passes` + * open `pass_dry_run` + * choose an action + * apply the action + * run `post_dry_pass_passes` +* run `post_pass_optimizations` + +We can regard the `pre_pass_optimizations` as the `pre-processing` stage and `post_pass_optimizations` as the `post-processing` stage. +So they are not included in the optimization loop. + +Every step of `pass_dry_run` will expose the alternatives (i.e. action space) to users. +Note that it is also surrounded by `pre_dry_pass_passes` and `post_dry_pass_passes` for some pre/post processing. They are included in the optimization loop. + +Here we are interested in `GeneralFusion` pipeline. All the above described steps are implemented and scheduled in the `GeneralFusionPipeline` class, which is a sample pipeline that we have provided in examples/general_fusion_pipeline.py + +.. code-block:: python + + from general_fusion_pipeline import GeneralFusionPipeline + from hloenv import AltPipeline, HloEnv, HloPass, Pass, Pipeline + + hlo_env = HloEnv(hlo_path, "gpu") + general_fusion_pipeline = GeneralFusionPipeline(hlo_env) + +The code of the optimization loop looks like this: + +.. code-block:: python + + hlo_env.run(general_fusion_pipeline.pre_pass_optimizations) + + num_alts = 1 + while num_alts > 0: + hlo_env.run(general_fusion_pipeline.pre_dry_pass_passes) + # Open up the action space + hlo_env.run(general_fusion_pipeline.pass_dry_run) + + # Get features from hlo_env + hlo_graph = hlo_env.get_hlo_graph(do_hash_verification=False) + num_alts = len(hlo_graph.alternative_indices) + + if num_alts > 0: + # Obtain a probablity distribution over the action space + probablity = uniform_policy(hlo_graph) + # Sample an action + decisions = argmax_sample(probablity, hlo_graph) + decisions = np.asarray(decisions) + # Apply action to the hlo_env + hlo_env.apply_alternatives(decisions) + hlo_env.run(general_fusion_pipeline.post_dry_pass_passes) + + hlo_env.run(general_fusion_pipeline.post_pass_optimizations) + +The `hlo_graph` is the entry point of all available features. The `num_alts` is the number of alternatives (i.e. actions) available in the current state. When `num_alts` is 0, it means there is no more action to choose, and the optimization loop will terminate. + +Next, we details how we implement the `uniform_policy` and `argmax_sample` functions. + +The goal of `uniform_policy` is to output a probability distribution at each kAlternative node over all its operands (i.e. predecessors in HLO graph). +The probability distribution is a tf.RaggedTensor, where the outer dimension is the number of kAlternative nodes, and the inner dimension is the number of operands of each kAlternative node. + +.. code-block:: python + + def uniform_policy(hlo_graph) -> tf.RaggedTensor: + """Produce a uniform policy for the given hlo graph. + + Args: + hlo_graph: the hlo graph + + Returns: + a tf.RaggedTensor with shape [num_alt_idx, None]. The outer dimension + is the alternative index, and the inner dimension is the operand index. + Each row is a list of probability to operand indices for the + corresponding alternative. + """ + # get graph structures + operands, users = get_ragged_tensor_from_hlo(hlo_graph) + # get the indices of kAlternative nodes + alternative_idx = tf.convert_to_tensor(hlo_graph.alternative_indices) + # get the indices of operands for each kAlternative node + alt_oprnd_idx: tf.RaggedTensor = tf.gather(operands, alternative_idx) + + # assign random score to each operand + alt_oprnd_prob = tf.map_fn( + lambda x: tf.random.uniform(shape=x.shape, minval=0, maxval=1), + alt_oprnd_idx, + fn_output_signature=tf.RaggedTensorSpec(shape=[None], dtype=tf.float32) + ) + + return alt_oprnd_prob + +The action space is defined as a 2d-array of dimension [num_alt_idx, 2]. The first column is the index of the kAlternative node, and the second column is the index of the operand to choose. + +To output an action, we implement the `argmax_sample` to choose the operand with the highest score for each kAlternative node. + +.. code-block:: python + + def argmax_sample(probability: tf.RaggedTensor, hlo_graph) -> tf.Tensor: + """Select the operand with the highest score for each alternative. + + Args: + probability: a tf.RaggedTensor with shape [num_alt_idx, None]. + The outer dimension is the alternative index, and the inner + dimension is the operand index. + + hlo_graph: the hlo graph + + Returns: + a tf.Tensor with shape [num_alt_idx, 2], the 1st column is + the uids of alt_idx, the 2nd column is the operand_idx to be selected. + """ + alt_uids = hlo_graph.node_features.uids[hlo_graph.alternative_indices] + + alt_uids = tf.convert_to_tensor(alt_uids, dtype=tf.int64) + + alt_choice = tf.map_fn( + lambda x: tf.argmax(x, axis=0), + probability, + fn_output_signature=tf.TensorSpec(shape=[], dtype=tf.int64) + ) + + return tf.stack([alt_uids, alt_choice], axis=1) + +The full-size code can be found `here `__. + +Other Features +-------------- + +- Saving and Loading HLO module + +At any stage of the optimization pipeline, we can export the current Hlo text to a string object for inspection. + +.. code-block:: python + + init_hlo_str = hlo_env.export_hlo_to_str() + +We can also save the snapshot of an HloEnv object at any stage and restore at a later stage. + +.. code-block:: python + + saved_hlo_module = hlo_env.save_hlo() + hlo_env.pre_fusion_optimizations() + post_fusion_hlo_str = hlo_env.export_hlo_to_str() + hlo_env.load_hlo(saved_hlo_module) + +This can be useful when you want to explore different optimization actions from the same initial state. + +- DAG Hash + +The existing hash implementation in XLA is lacking in two ways which increase the number of hash collisions: 1) It simply hashes the instructions in the HLO graph in post-order, and does not recursively consider the structure and connections of each HLO instruction and computation in the HLO graph; 2) Instruction specific parameters (e.g. the size and stride of an HLO Convolution instruction) are not considered in the hash of each instruction as well. Our custom HloDAGHash function builds upon XLA’s hash implementation, but is designed to be a more powerful hash that additionally accounts for graph topology and the parameters unique to each instruction. This reduces the chance of a hash collision when determining if a graph has been seen before, or is identical to another graph. + +.. code-block:: python + + hlo_hash = hlo_env.get_hlo_module_hash() + +This is useful for de-duplicating the dataset or uniquely labeling the state when performing a search over the state space. + +- Profiling an HLO Graph + +To profile the runtime of an HLO graph we need to obtain both the executable and parameters. We obtain the executable by calling the standard compiler provided by XLA while setting *run_backend_only* to prevent the reinvocation of HLO passes. For parameters, we randomly generate N(0, 1) for floating-point parameters and fill const values for other types. A fixed random seed is used to keep the parameters consistent across the optimization process so that we can verify the correctness of optimizations. The only parameter for evaluate() is the repeated evaluation time. + +.. code-block:: python + + num_eval_iterations = 100 + eval_result = hlo_env.evaluate(num_eval_iterations) + +The above code will run the evaluation for 100 times and generate several metrics and output as shown below: + +.. list-table:: **Evaluation Results** + :widths: 42 42 + :header-rows: 1 + + * - Name + - Description + + * - durations + - The default duration in nanoseconds. This returns the execution duration as measured within the Tensorflow evaluation code, starting from the point when the executable has been enqueued on the compute stream till the completion of the executable. + + * - compute_durations + - The duration in nanoseconds of the computation, without data transfer, as measured on the device. + + * - full_durations + - The full duration of the computation as measured within HloEnv.evaluate(). This captures the entire execution process including processes such as enqueueing the computation on the compute stream, and is hence more subject to timing noise. + + * - output + - The output of the HloModule. diff --git a/docs/images/altgraph.png b/docs/images/altgraph.png new file mode 100644 index 0000000000000000000000000000000000000000..42df8229e8072252ca7b62404ca6bfa1c9b02226 GIT binary patch literal 132598 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∾|px6+UFYPVZl?MDm5$e{?p{2K|+)kzi3 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

Me2of+6~l%`Coy-A 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

I&Qu+t1zDK_PItQ>3MrKa4%WV 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 OL2Tkih5Ztm{N2A7-pX$P literal 0 HcmV?d00001 diff --git a/docs/images/sys.png b/docs/images/sys.png new file mode 100644 index 0000000000000000000000000000000000000000..f6d21e76db5fbd4cdb4214156eac38f878068d2f GIT binary patch literal 135013 zcmaHSbySpH*S?B?N{e&}NOw0#mvncDNJ}?J4oJ6zG)NCMbhmWZFmy-^J=74t(dT>D z_kPbGzq8iB%(b|OeV?=UKKoqzx+7GTWieh6zk2fI35L9!l=_n=C>u|nJfnJnfR7ZpGi1c)mtW-cT%J66?fU2SbmbF;=aVOo zh4ND3nx4jo5Hv$Atrf9{*y!n!s*{4jcgE_P+;7y0P^&+5l|NTImq__u^1W!Mn1Smu zs`$K?sQ7oa)F>MF`bXkzjPll;v}b9lQiL3RB%Gnb&NW*^DzJddfMb`rrel}&B16&R zdE40~_+jn1u@A5f^XOR5mM8J!TdMyWdHQ|t4UyE0jai+Qf@5Q22XS~rm7xB#|NMzt z!~PBGBbkDflq;Mad;UGMZq*aV*3&Run`LtE-;}<$dq00q@s?0XaZ!Q;-MSZ}*u(!ot4MAil9#OI=-^Fx-~@LttaQJvh&DIK|w4^Bfp(KYa3N z+~!Tm#g*8_ZV4?aczyRTlW z#6LIp&mDeY$Cian^+%HsMN$9njOL+42lAIT5dI%5EDC|m{|ozuz^?vc6lc1oq`$*jEG=_kXe57z9@JFAQOy&BVVjgnc$A|HA&*_vT;NAN#of zh5fNl^IzB>`&^SumrvGv{_l)||NN(XdXUkqd7OZl$$1zugMy;d_s`iZX8A_e{f1i={zx@aCe_gCIj3(%7ok+o`~=9c}n% z+X-yC)Xv9;zaF`xtF7Jtb9h6&aXTh4h(sMIX}zdYRnq0rAc0E3Rz1N#DAVla_-_c&^NGvK49eTL;2^ev5LrY z@Bwf>_bt~;Hkk{l4E)iFa%qx`aT||EqcArSYGbJ>S(D9g#;wQoWm1zVL@!>MJcZR( z6P#BJnaRZ;Wd3tc@t?mm)IYpxm-`mfQA={REGV^q>Z zIoZ%;Qb+9|Xef{6JIU-rH658Qr8|<`OzX2o{YiuK_fF5PU*dI&!HM<-+*n9Yrf%C+dm%MB- z+SEmwFGi0g4Kg@~N??$UzM{fXXe$RO#nu_g#lsfh%ndqbcHSnfe@Jdii$Hh;F*U-R zUw_T<_wj~E8@B%TTH+CT-n^%dy-<5(%fxR7=-0gkOAQ$T8Z10E zUKTC;-Dn2A%3l~G6CVN2Cqj`3Bf^VME#Ah+^_!9+rn?YOc~O&V#7B4VtDSL}Y`)3D zTSaRXppcZYLZ@CbCi=kw6g})`P(OVyTV8WU@nf5dHFbaad2o4b*>VrL7U#jasa)X~ z<`~Ni#vhC%DVr|BCLp;6G+=*Wz9Dn^O_aoKiTOv?2nm%6qfVuK>G5KkL1xh)9!bAm zg~&6HA~U_LdybZpM3k&lJs=a$(dJU@wN^P7942eXAWiTCrmF;7Oo^4f;PG4OxjA!$_uVOtiPzvvJF|E~S=gL{+rB$~JFY zTCZ5Zp6;XjNC5BrsRzA!r`eT~nE;g~S T!`zrNKQ@kUbAMQNL~AimRI)X>0Ij% zkAP_A-Ie=l?OY7!p<7>_bs^PleIe4|Szgv*^OYlFe^m!x75bRU)^~!6g{0$=(TP{;}{J+AU>{~ zLip6w9!c0}IsehH^(*D1@gQoe?3bSMqPe&Q$*2m3sa6K%5O@%cg_DEaPrmWQ?v|x2 zllRnK9%KwOhr%q5>no!PNK->E{m5d*%QPCf9c!H^kR!TyfegP~mCH&!x1Rv~7%cVu zr(jwaHVZQCjNvl@RTWd%rP)!A3gJZE~F-A=ul zWkp8VKyDVlkg^7(T1@%o_A>ckGGadJwA-!CO*o+1xgrk2 z9FJL^`8M>{bFs~#^;3!Lavd6Z@xA*>x7liux8G)6on8gTyr-g(EUlanS*3Moopq9* z&oLVfDIS}Ulh>$e%hmgD$_+M8NtcvBx5W=ePUm1(YY95=!N#n0LDFZB@w8?BHVuVL zY{nbU#Un-eArHmtR!xT8pp3aj%q1_Y`9aGJ$16yAd&OxjF2v8{CC>wY{kOt)PY zt2~J|#P&tRsuLyFhRc)In*W)U2JD4*sIYR6-MEh!*nn}8nh(zti zKuOtk0?9~7psJQ7jmNu0ltebq{8^>cXRw*?H=0L*C$RZgN_%)mZ-P7#CJWJ5Z7AH# z*_n6DSm#FC$5P;ox8K4Oh`RPTB9rNMh2&2n*z@4$)B9Ec&V1+r?C{42r(h2BJk_Xf z`%qq9&3Twcv30?P(S~%!Yd)95dJ?P9by|9NZS3(v5#>5h_5)|lIKpX~xEuZ5Nm4Ka z2%l;+49l)Zk?V+Ny?SH~X1Cqs0Bn}E#zk-alga6we+#G@g%0X^=x(vpaTyQXy&W*4 z)3TO09eN}|hF8E0_$U?W@H21mZX84NeL8-f@ieVXP)n9%kXT_zT%FMHYudtc1R2Zs z%kG_q=C8gRI+8;}Bf^GkT4SDKmD!igRP%&;@jub91)9%)^;KyljbaTu2fC}gIBPTh z{v+x;c{|~WcDvDiJMvHxybN!tg@0`5OxP}pBE}f&dNVEBs?0U2BMTC4b=P7#Q64?$ z^4ra#^;06;P4*f}?}PChlcnp)DtWk?Z4YeT$sMeY?ok}6AC=Cb_W%T$+bw&2*qY58 zh`G3@V*4y(=34+YF5M2O!RC95Pr|kUkte8M56*nVQ4D%u<`tdBtnfycz3UgA%`!*$ zjr-Zh5VwSbvjj=jB?~;z)R+MrkA@`M39=Kr7b=?&1*<&seBIqrW^a3UcrAXk|C!7m z^`SJ=C%~168;#_g)MuXIYB&AY{Z{=Q{x~J#cp)X#K!)Tb<^HE+wArd>>DkD)QR(C+ z2eKK zwWcHu;ABxgp3gRx2$#a+MR`*m84pq-Syod(3L#-JW#(u zT2#3K1|r?#*gVz$hB~ii@(qKH`D6JEk29T4*H(;aoOdv~f({KlDTnGU z%z?5ZjUCT#mK|b1&)JsY=v*kh=Cv&(+O2Z<&o(F1ExWc zd&A7zmuFHdT{kM#zgV+?L|4Kxvl670zoC6{9)x^4>#^}TfmCeMyVQH}#^Dgd{dKog z;O>;{q;1|$@!BQpUHdmIJ%bCQ4okiwG5uIw%SrR>^vo-xFjpmgK6*P~Ki7CbgibZc`I>A6{ zLHCQ`28AS<0B&;04Pl?+5+=3=(#U=ie=?zN75kr@Mz^o*7;w-UNh-GOg@%3&D3;f3 zY+Lw_#x1P?cFg@2`>ppaolh4Pyt0f_b}zf~d_(Bj8te*BFI~K2lI*8->;jwkX`7+C zCqYBP_OI9|B)!UG)!0mi^_})@x5CT&-d>>L>8V&tU|$vwX6!k&o+0Z$UNZ72U-*ICp@b=!*EoIh?+fazkO*}OQFXbDQ z!=>p5E$sZ~HPlhbBjoVT=X!G^KL!T&J<6P2cP{rk<~oNTIk1T8+=tZ(R@OI;?{A9a zJ=e)IpF!d%+SF`$IGbeXisX;=CL3~_uzBp~?OhZQj_ByfU^xTzoV%|i3ELgJIX5vU z&v`nQWHF^l8lexIv%w=4=Hmym)+I9g$tQ6RqPhqyV{C-zsC5^#3h$aUhuJy*L70f9kILxYM9n zB>Gfq(aUdFo3*806 zke;k3D8?@o`M)L{h^-CvMK+%G@MJ2JZC9z7ieXX^=%Gv3v_ho?Dtz=2_1cBtrfpcA zt>CkyVCc_v~Jq{vHz6G;FbY@dKI4j{7Q--9+ru3FC^$5z`)%6 z*16IvlxFRHM2WvqALyHKxh6v~4EExC`>^K^F_Vy^el2_m!MclvNSwx*YIVB|_Y1v` zT2@12l+<&JeO2x53P${4+n33T^{eXDBA-|rYy^YJ*xW*v1`E^Ur0hI@eUT;1Ty1+P z;7+g_(9h~}gFfKb_RMQolJptl?Hw0C-I-)!pHfllsxZa*7J$xp|%eywfYZ9!eu>L88qPL1&<9wbZjqbGSOvkRT_F1^6VuKfUOu3BAE$$@L1kUMou)Y zv-hoEEDq!BVt+i7U~7VOeAz^)B;L=Ss?6-(VR-5e(|ft3o%_=Q15ph4$`o$Y?ePOs z*1r#lSQUtO+BJQck8*q52fd!<9n6hcDLsCFvl1mQ5>3JvwW>FCN~T+&jt>zhD*X|b`6sbBaG-328=C$(?^K_470*mJe)0^bCwH(Xw9mr& zy#NPVbU+fd?MK9%m|bWeazNghJFvG@_(z>9QgDEsU_r;j)3Hbz9p6vK?=KSuCdOKk z*jxk5kP`Cy@{*@_As6M&;sNYPB+#r$8;i$?4;kZgIS`BC_$JY%dg0p&-2*is4aLYx zd^AlgsJ3;rOvrd44t-!FGtAyep=#G+z-uWe^|&u4E#T{R9n(M~w$LT3Y?ZEt#^b{k zO?;Wasymrf<+nQmGsnx3Q#BV2IE$YVi{B9?9{gWUReW)Ioy>dfhQevwOM0%N2-aNuzRQzSmeqj1=V47h}K z3{{nCC0oR$+H)g8cVcW+evOd*z?utXkioTyL0Fbur z*?VL=RmYEJ)68!EuQu(eohAy4Ho4$KTHl|-t!eM+#G*^xOWovggQQUvzKmkO<0)G9 z)F4y_R4~o!d*{CD8g@B>W%QipXaSj{>*@L{9-n291?kY8UL}ddTtx?`*PSa5LRVvy z*gDl=trN1)EDdx|+?JJk#>6R-)jkvrsqMvzOgI; zsOMykRK8$Shrgs+DFec1mjC+9>7*2$1qc?*N#b?=4y3!Kgt7(%Mu!1)YYN3Dx_Pb> zAum4h-*H?v`Z*AUiz#C?_^nyxNFP6qF)K3hS3B6;Ov6Rxga(m8IW`M%cGmKFR;v>^ z#*T6>kHt0~p4zWbaPTZwb5C4`SvdIz+B?N;p7_V}O!k`Z-Mvjdr|x*ejRY(fmUS%7 zOKlBOg$0@SXUhm=24@0QB9INlk2v{lG% zd*at$jP6+aQhZ~@jWE|8*XJfj^7zXK{qIpw_yZ=0v0UM?)-duwcZKeYUChI`d6}{X z83jMR#vK*J=gUS4sxMm~KI}7}%}Kz`;s(nT=+KQG|kVu31I_}Kp6KlA# zepq@u?lr7YxI^+^)rx+Fawm3u=baP&^s(Y3`w2r zSRAI6e)<*yH;SV=5@QYN=p`?=uIVf{yGL%w$IW+ERCBz0YUWoA}{ZHk9;1Q{?{xEE=@P!eN9Zpc#Pp+TB9K2KVs!H0JXG78W=qRn1 zp1gS^`rff!pH8PLG@Uu;DZk>AiVSjKn^hdY=jW9@0=z&!nuf?v>=@U%8jIM5?m}A` zyjE7OoK^aKAL(M& z6cJt}B@!4|S=#FUBmMcZLdR07Uw_guVF$b@Rkm!EUJdN>n}GZh=xC^P z{3jOX3B#$+u!Eft{=PwA-P&= zqXvnERDH@4)G@t!Z(P)L-axhc0n62$$5Hpal~?3#4)sz!o?gR|l#7n|*QKIyS#?cx z(xSm26v_ynYGn{pCP=|>L`kx{7U%b35pp`{b8w6w6}$Tmr`?cfZ)Oh6Jh-mjV zd@UdQ+3<|cOBFGG^y8&AD}voXAtaFd;{BHh(8}2GvF-8ECAV$NP6y5+V-wG6;F;3% zpB`#PtA9=zQkp;xY*|g@KWrWk%B)|Uj++A@;c#NiYrGYuShB^yfLQ5VNV@V9xBo-T z(~bng%(~)N8Pw3^9auj(l1t8&l!+h8>svPAU*7~*$o1E14W4nKWlb>$V#R$I({ zCk3(%RW?hkw$tE!HO$nu0mH13VoxaQ z{D=(Pgv0B^KT01JTMi}J)<&*}V5RE9p?CKu?)YHa&&zk7e<<7VbOd1-UK-xTPn8!| zDRc(~WIFHenuvTS=~ugA44A0cLZ+C_dNP)(m%(rWFHSHE(mb-G#KDbWVur1y) z@Jg%)A7BQl`%Q6J+LF=j=Sbr$6MI)c-^=eF8ch2R$7eqJ3(?`+E*+(foN$dog>5>@ zihpi+Rz`T;2x(@!dSC|ML&VR%vIg*YhjtlHsdtMk{`&Z)Ws7IC(@LAfA@~!ROquJ* zE2RtZLVLQZ=4GsbVIsX-{vWj{*}3 z@95zfKwA3;CLJaiOMZd;!M~vZEf{qv&t5j3C-VK-OAzI1CXEUpsH~{oe*H_hz<`s) z$JtB)=>9C@1bQz!SUv|Gvjgr}@x44L%Kr{XuEG3P#R zNx+gpUQ0{xCi}aGVv9~~+-O)D+Pb%X z>1Lu0;88I~Ml&33z5>UUZf$||CVz!n7DL@6>c=NOy6uP2g=CK>LUv=IKc##5{q0n% zfT8==(G0}wdaJuF<{WKls3#tY%62CfGrC4m2k9E~9U`prWDpIbJR9>rRZ;xZMbBCn zm17<_{Hh*2-f6LYhhN~&dPciMkM7L#bDX76dV=DRV%k4~G&%RqfyAERqAuWxVGU6> z8LpSlt?=Qp;dV9kj|uacs9$FR&^H}nzZ;?SxRI6gPjjtSoDP$>AJ5LekN|?o(SmokrEMe;2Y$p7t&g>izQf(QQX>kf z+43>OSu~KJc4Q~b$iG@^7ElPaaN&LdD-y8Dc{b2%_H~d1I8s@>5oDy>Q6$I zC7%1D!4dls*iQ=}Z^pkp#Ht!=e@Vvv#w@zV%=*b{;Geie^mGt$iS#!vWuT|mpTPqa z3b73rjRM!#--aZG{6rJXcT77VilVsvrlunMfv?|)b~_vqlWDVEqhXdvr!fxa@+xUV zUP<@L!Rb2tuHhH&wuCY-6-WbIcvtGka4KcEV>^O6Fx*>BxA!65iI9vAebV)yYN1|x#v>nG3efWFU97OA2Btqy`wj}AZ5m`U*84bQ12JFrrqBI z8!B{6@+WWfMu;ta@Kv(vpx(d5ZmgSVTF6jLuemOvyYkFg7sN4TAOy{JJ|g69pMnx> zku70WJ+mMm)9$+(q*aAu^Q8p2DefF3}s#$%kE<1zDz<1V%aQ!nJ=SbFJs2`5= z^o~VNfLJeB7KwXO&Y$NlMfmz?YTBWZd(rAq*OI?KZ<)E=n{Sw3Snv0nUa;7N*o|P= z1z9-482W^c4s^>~`j;Gj;C!XXPoF1u#4ji~u;h;|DX+{SV#(+Mrz%x!(GQ=6Z;=Py zGMtC33)RzKQ8P!pdcRP{*n=}CXVu#1k4$RepRhs!oCu+4d&?01@O>rn*bc#ZpOFLqmKk!hC>jb{SMHbY05VD$sTZF%pXf#`pDUEV+g3(Pe|(6z}waYBaRP_ z0j+%ZES6ujXY>7{rHatnviqw#pOM2C7+YaH^PnuFfRMRZ-lqmqRe zx39qFG!z+EUg^GD77xaUeM`IybN=8pshbx+;>1=z83-WL2|D;8_-FvsPJPXJuVCTw z(-GA#6MK?|U$W^5mh+#yJbh_n=6Q9Um+y+|9P48t?plhKFE`dw8F-pnWr)k0D;SU!hL!jV^aV6YT93ES)kfjnvhA3RqiW*j zRXz1%;HCYBe4Cl2n|)e198&AvU+~SoW@E>}I;<9M*QrpVYqygm3;o0sGrU&h%E=)$ zwa_u2Snx9bwMuCnliS3YkAL*c{*PLF5!+xJn9#%~e134+$6?j3qQ{+=fwt$D2O5vm zXgW`#euD!`%D%C&aaJz5w6t^t4~7xXW6{}J{Ii~2`4Rzw0upl-47J(zVO!bRb}JH8 z(7ByF@l9rnZL;Igu2TM)u|_G_rP%#$_Tfq$uLDlpmj9CVp^}ifqKUbl8f!U80rQ?qFTTIrt)M@#?O0Dqd<6 z@cp7km#-VLr3w0ZznKr+VX4v34MC$SdubGiQ6GkZZ-nDPwNS2j*XDwrJeozcjX$+(T(Q3t1H7ey;q_M;CvIq_Q8Wxwrdv&}Ir zD0j~e4=)>6fO9`mz)|J&(0}5&>1DRX;m-DO*C{TQZ60q@LA1o1GzYoZ8}r`g&B5;* zI-!Cz6g4L3Q&_+r7P}Z?vC&OJF7bQO$gGD$d-6H8;G9s@xI{vfaedV;CiIs+T-EHw z>GsA*>W>{r+bO=+T$Q_z%#0`o&UwV8%(7W6r5mD*vbd?Mn0}wtOnPZ>c{5v03Z){_RfYiMLE1sQEG? zos+vgK3OiCceQ)iK^M)O04ZP%+m@eemMgf!)?kAEQxWB7IhTE8{Qhro;>n+0MN{P z<{w{-@@t*(toW81;f>GVdve|oI%~@aV%-r3wN_S!qQue_n0<>p(0970i>JngR=puz z%KH8Fgu?v};fgVKsBE8L{%gC3!|#I`uKhDwzrNrpwmURYiu|+&Oddo!Fjf~vx}b1J-0DDm>UsNHQVeE7Z1N=ny| zA0NT5nuH)$xRXEI-#=o`2xooe))BvYbt7c-F`{^fQH91r_v%aQHa{gtysRtul2T<$ zYa7~AZ*#XN3(NG!S}}oox8C#|aH`Uu6%?TZ67tqoEwMLh6*78Nvk=7OEa#ssuk`q6 zj%>0z-`>Wr!LwRFeY3s(5^fh=dZ<3_#=Ro!i9BCPKG2@j7aoZTI%MJ|c8b)fI@Uz4 z+y?eH9#xY2u0+rA4p9EAzxpNnyBAVn-;k^UhR@W`z5RS-mh@vKqPJ=C1&=)iVa%xu zZZ(Y+vdp3|#UBm{E#7OJn03o8eiaw+TeWOlZRn%tDzYJbonAZE{k87J^>q{}(B6O_ zVmOVLud|zfD1oU?5G(7M;~Bf|`;%&S*@OP!%d=)1((#fqi{jTxLc+XUWU>K`VPykX zlq^oH8~p(4iT&DVJp&|TT1)MljowgHQX>&e5zwrk;X$Y<7nhpvQMgiC^0;nh4c1Sf zkrTxhj4Tk=xBKOt8%I9?H9eM#TX3u@)(CikPvZT*>G4ndA8xO8gp>-Cwx`fim~&HU zr^xaqk)Bs3IdUBKLX*0_?vv9x3TC3%K;B-N6Ak-0uyAxRPi7Ejf2C=N%S`|nR<`(Q zXvKV$Qq$2Sx111+S45&-LCQ)ZjL{t9kBhqPqf?T|5NUsGH0>s;<%DtLY~(si%7ftC zp}RxBZe-_M$v{POV>*0`tH)Y4R>I9#niph|VwlxFCd-;F?sG3=mqu;KQ}I@1KT(N1 z5;Kl%n?@R9Re+HSmC`aAkp&1U*A;dogy+Vj%hXY!t-JGb6)OVZ`d9X<_I{|^rw_2Z ztn4wnxBj)&gJMJbu#GoRO>Rz5(YgxE;7z9G^PlGgyJrFm0e@sfuZ zw0P;t4p%K9G?+DyB^0&K7ZNR={OE4qdV$)oA(`={422jjMyOobCwtkkNX_J>OOjp4 zIq$tW`+=xTeXE4rpvv^=isvRqL1CfURDnD~#pbg6!($`M=SW;$zUMLB`>1KR%4Jvi z;&2gHPfzcUNX|1fz4`0cC%$lKLveBOS8W3de-S0bL0*|Mf&3`qI?;UcEnx)ms;OCy zF5*~_CvzMlbo9PVyFwMA&6}I40Jh)0%FWFU|Mrbjxa{+F=`EiY&5+8W?2t*(<}qU% zTU|9+_3q)td{2*hqQ>_NcJC!^PSnXgyoE|ZSGSid7{_1t;C*?e&G#N(mrhaX@YhHl zdh$_RuTS<++5OA3nDQc|yYEPu{YKrZ6dptJ`5Ov=x>N>Wj_O6Zf=HTtUAx4Uffv;? zgv@$1&lOWyr4K&xTK?w(XDU!N!^u#Wz#xQ zEM>CJx8&KM^U3K~I;H33KH)H*55MvyCl6F@&fA?m^@E0-53U$W-jI`5s)5E0Xol=X zb)dp}_8MsOy@j3cbph3)tA46}x*`yQ1xvCJG)$SQLG84Aw=x)~V3vg>BnG@ys31 zyQ&(Yq*9M+c#LN`vtd-LvlOLj2K5@TEa`^r*iJti-P(SrX1Lz?wu=?b#C9a9U>8tl zJ&EoCSsiQbaKBomxl9ciq1x?AaXFx38F)K&*R~<;gAgDkus^#`wrD%>udDSkA*uU3 zht9HeA=P`w?F-FA_t`b*P?3+<^-ym89r7?VFPA|P=)e-a&Dk;UyRzks--!0&u+KMR z92zcn+LbJAz%GWMwN_@I*?#~I!`sU&`J(g_UK0GQy1fmdUM@w-6m_A%jBMq(?}A(# zZs9?xsd3(&WmO4yT+S;A1dMKRUPX1@u}EWz$Cpl0i&V7_X2l zxaVa|9;5WNoMZBoA1EtgB_SLXI(X_-m)E3>a5<>MK+AaAA7`5oks;ad1a zo?ZJcAFjMC{*Vo1f0RxCjN?J~ z&}D1X8Y}DA4{@3ywAy&mX{2_f6$$_3v25wZOGIZu%tmLt6+5Ms;6Ud3+jja5>`+E{ za}_!Glf7mMz**pI&eXZ%=taP=mY>ePCV%r)Mih_NrAQ5<6QvLl2Nvp#`n}tZuzLYG zny1tcB_D-xeW;!A2s>hWy{AIi`@<5GPzcRBWYY1Bc)&%|OT1moqSQDWcH_x6L}7$7 z+ARZcp`A7v(A#c>ok&mIsi=jnzMh%lvDZf&T$_>qR})%FQ5TERV;axLv>3h2Mdheo zPloG*A$`UGkX?wmC`26h!o=mr$c0IK$U{e$FvdTjFb^EmHQW|AM?B$SfOa?tl&Mzo#$o+2GUeJs78hmb}Z$G-C-{m^{ZKTWvN z^#Cg*Iq439PDE@kIkEYR(MxUN(F_Xe(x1_KEi{bYYV@$@sJO&?C}n4d6t5qzeZXTC zw;U5j*NZdS{t8&HHJ^g+=OfBtfx#@2E%p#wm~R*nl6iI03}jM^%4$Wbyh@?uy^P!)Nu!?QW;JMV=v%C{n#`BQ^1WQN`kyT*;lH<_;gXz)@bnak zcOuKU^)5y8(09;36zL=VxF|v(9eULOpD9jb z6tKt8M9B;`vrGayuL>DOj=1xy_F7a1azRQSFc1|N^!r~u}G^S@SZUru? z)Diptl~A4CLs{ZE%5|?p4?`1n{e2Zeg;5({b@SPl*zuZ(4MjoACl;eWeR$Ecx=pwI z8R(oj`?DMynK=E{fH}SiIRUWy zb@&N<*u}h_)f3>UUU0wni>fMhw;7Ha5;laK)(O~&;P~Y{A9|w7rxh}nB zqEEEVccL05a=rT4R4_%Y6a4!^aY3}}a({lG2O@%nr3{xEE4F7FVoD*uo!(tQs6Cl^ zJ}9OzcTE*4#wR2^qeqC;AC0}X@n}pL|4TY3DUczdASZ`iSX5MmaI`Q%RW&urIcyxY zX|;D1{-yad)%kAT3i?Lxj1f-~uuPAl>4S@DfiHTlMteIF-OY}>NN$}n>R!dU}z3mwFD-cTlds` zW^i!&mXzkA->h!N`Xk!D+8wSTwAyD|&_xV~awnKw`QQQsvrIm3J1>Ya zEzvhUBY_dz$}qO)q^@9{-9c#?IC@Q3NB1&VDdMmDSCiyi6I);r+@E8J>gzJqXmn{U;V?r z^$jbBlXJ&4-5?D}3qG%z>n_$iWJ^M@ebb>{pOo|_LS%zDyl9I02;#Ad*VKOy$=2Rk zq?GY?H9V}CAE6P)`A48XQ&%l(s5DzAo4Ewv771UGP>4+sVH5e9TUOCBVvW;ML3kWn z_2|*6KQ7Q>tUHjBqd2GzCKu@%b~-DQeo+JEN4?KVJ?Wg73m)*_(sq4N< ztz76Unjh!QPR8cyK^QkhopllJa>(&68}uDL^WjUK1s2l{Y1w5KN!9BKP%lw$(CP_iJm zq#LnIm%yozcN>Gbp_s7Aa$1oM?z8(7wj2K{L(TkF9eW>qMsAHbHy4qSz6tx@aJYq; zk9=_T-Ik8-)|V>pj~&b8IL8YOWuOUaR=DLdA{UPOE&8jmva(^}DF!WhNpMdw)msD& zQNM@u<20_ecMDpR&aM9UxsF3lBUduk4K@ zj?mp=q!#^xuXx;j+bTHEV7wC9&>SN|kzKWvv+{{Xpb424&(rdo`Pfi~wq&v>WyDS+Dv9G#00Q)|x2 zEHZEBIl;te`wdk@x#A5l31z|FHMJQPg^Hq9R;VqJ5*nj8c&yV=L zt#{7$&8~w-wqe<9CjFMlnnlpBtma&aL0nc+nDnf|G|sfpNwI~+0!zu$c|VG`UhD6q zE{`$ADr#93DnE1B%yD0b)1Zk|W{>tST@zqW{vC*&V#&zSHh6=khahKZZT4K6i}!~NsS3<4>UwrlMWl_{2&!p@24M|}@o z+f@o>Hqbzlu`^xVkLp)1$7OO16dhYuzGO`wXni7vp9=cFUTnr*{@G$QE}iHzIW_uT z&1x*O4$8rR=41YKw5eh8Mh(48ew>fzc04Z2W;$7|y|S9nVV-D=9y@*5clw(W73VSV@CX>al%rr8!e#_gyXK?y|8` zrL{)i`+xlF&ph&YLGGpbp#ulS>^sb_Qa7t($R^cTMCwUH5mVWnhem~ZcUF6E0fn#o z0SD)Bl&%jJT4-PUvu=7O)3a$lbJ@h6E5Xwb8|h5Rvq9OK8Pik!nvwH#4O|&KsFx|~ z_|m*|sy?K4dj7!!DpeVS;fXFOJ(u$i4Ru=~uE8;5^dvMr7b%Ar=#+nE&N}rvOIm82 z_w!^q@{;ReaCkM>pSJ9nu?GQd3DrI3h(Q*V_gdZP%4e0%`O-Jn`Nsb4c9@OIYVydV zk}Bir3-;)BeMMJ;$3PZ$x&aRx_x)u0hVwHn^l&cBSWs zkgr6h@oUr(Fwuo{4?t(WcpHkZ8l+?Nk%#u?S44=1yiyANM`GXVoA{ zX0H_hlggvPzM+#21x6r%l}sj~t|?Tv|0e9$FfV0G6=_Va8k?tDDnXx%7-J3I> z?hiz0I{q_k1pg{8Sjc5^B>C`}j79gcAU_Hbib}rH8@!H(0ID(x;B?7zlhT2Mt`{R8 z#`|V%@%U2{Ba-?iU%<}YIm3z6v-_5oM`^l1knEQLuxanZh4l4x zu`c@ygqlOgEK~GvW&BpOY-Xp`y7eBLScD+LI&DzE4;hcoaV=XVlAx>)RdN8Mo@C|p z9X{JqIG7{|HZtDPT&g8_=W6uPw&w<`>JwmaUiGy9#}|rkaH7h{E8J2;;b^|QnI(Fw z5~$y2))fU1;JD1xG-<^fy>2CabWq3$h>F1YV8MMcTcu(s+_bua_r+kivebzMWe8*}7 z>r8HY3rR+O*!lzkt^|6u5R6+-z;tVc;E-F-JJ(KC@YkL7p89Qj zu{ZZfQY%Qi^Bp1A`Mi|;A@G59W=F29{XE;jSp!g(b8UY|ZLo!L6l`(&3gNr5h*$fU&kjo? zQepZe+sx4P7)DKlGi-zi_&;NY`}cX(It!v(g|yMHyTdh&vW|6`nBkX(ltCzucX5PE z>x|!WMW%VoQY04c*ODCN^iZ$l*tZ#4Otj!Ud13?m?KZK9de-VYVf1pO%?lfKmGrH) z{u{iO44R>s9@S`0h)nBlsV(G&Meg2kOQ}wcaK>Qkfb!U<;x-;e5ke=W9sNmFO!wOq z@&jhPf-TL$d9_~~X@uD5G17n|%O=e855w3WAW@=r_pNsrJBY=ro*3%y)qJ7n70aT!o z%f5}6o-$MEm&p)#K?VzxbkR6Nj`>00)ohPA#{MT7^7>T*@JR+_H$mprc6rf#K~_SM z$kN!|vI`<_=PUYyI!M*Ynt?Tj_T+46O4o8xH3xkK25nCQ#Ez~j5%N!rl1r7Pds(V( zQTE?K#yVdQqqO8ad7p`Z5e$+C1nZH3LWsy+HMZ>W!FY@1=&D_1OL&$%Hntw?_g)-1 zA1Z~3+Die(9`^o`F8`KPU)rdy&Ra0$SV}z~%Jaz9Z&gqI%DqRLGFlF04T0EtwfX%1 z-KWdR_5pYSi){F%#gf@aJ2x=ybs&|%($U9k!zgKzgUKh!xj2N@V$D{ks~jQ>s~mAg z^<+-t74Epjr9l=#)syWNFN~w^ZQ2Gkr_y*PHm&nyRAsf3WqUdz1g zZ6GjjNQs0haTDG(&=8tkaSOXD2p{$+(3wyKwIl6Pvos7g9_JbQCcO!6hk^+K3BFZg zGQ}7)C1jy`({^xj1{Y_RmuT;25@O>F-d%#WUWO>IIue-1#X5FLUEnE_3pBs7=pXB? zQCg&DZgW`3b~q=zMjh>Byjl3x>%}m1|3bdHV*nd4_>nz}J9c`n>2H(Wk7Ib6qbRbY zFf%nWE`yf>=^nm_(L+BiMSU~-rEE>hk03lQ@Y3u}Vrf>-4njIEJy%W$#JCapR6qnw zJM~8H3iv2^XzK*KHt)6_-l7H-4a9g2s|Cmu|Bv`Pf?Rg9=LAkv7Uw5XqCpqeW`h!R zCrj1lt{f%4LRWHzS7kZvGKXQmrOO|(;aVd1II_PLCWbYzK_>0{-4~)`xf$XN%o^-3 zCCW1KfG+5LH`8Hp6Qa$(I<|;U^6Fl2CmLJyMSt}<7=GN0#sY>(_13=BO^%NaGI*VK z5R`=}emH&-tEFI+3Jx#V^5iR%Dt9FPZ%0R|#2%*5prEQ$>D3)EtVbHC6cRPPjDSQb zvFTrh;R>qskwlUrJt;JywQ$zO+HCg;F*Cfw&*V6)M?BPeRwYTKa2ASjJwG1C_kuX2 zqZzaMQk>C`p(Z6pQWvWlSlB{FQHRRbAE2TxAWFa;OSfhZ&r+@#(y(RcVni3|_1eSX z#XKcZ5xCfy?!QAG*U3fAN~0wORz`wIj#NJxjm3yy^9m4|q%4`BQS>?(N4_jN(#Poi zI>7AmbZG)pN-lZK>3gD_ zn&Zp{j=o%Vt&N%VwD8~gGbN(o-YO5GoW2&?BmC=3uTD8igJcn$>hX311}>wM|d`xheKTqghw~!JcX9bT81=8aKu_; ztD&5kwI8>Lh)G2%Q}L;Mra4D4v13IZ+wpS0fNoBQs@;mz=eK#OY-m>m^lbe|4v-Pb zum6nVh{;YiS~9?VG&|O;m16KjU$*I}DnNFt(pn;}kq^1&P)Ok>rn9;2*9(`-lVO4E zT;1~r-{)F4O^s}{<&a2eO09sL%9nZ}WK1$b0(3_=F}i?FB8@ej!X#Q3i-bWKTiUyxJY-Y9Pdn?1L-0 zjJkl{wLg1O;MtBlXTE#*1nbgTX)%CyN1N`2iKUI?;u7N@@qYB5XHxz%W?u^um?IyYr4cZ1MQ(AbNc>2_#v0bFM6Rnc!#>m>d!J5v2{D#qsCI@=O-Zo)8 z_k^X#jIL&O0dSj}A@#;K6j2Y1)T)@|%fS6@wP(r$9%k-eBRv?!hi4qW972)9y*0~m z6?g-}ET~Lqe$cIhZrs~WFND|~y?7n^-iBsPJZI?*%uEh<^`_Q;c7RD%QThQ;QKmt* zlTJcP5?u;YN@la(@&w#a29n7^%pqXqza8${DQO`KOl=>1K@;JJOAg;!FF|iF>^q&M z-d;A9^?L(C^kZQ+yac0r&h=Xr5Z|ha2;#Zr|CF3KJa0#xObj+pzGW4@4~dQKS?=XN z6w(T`-EAq0?k;%2k+5r1Q``RRB-F09-Y=WpZi9WqamQvv5W=M^8>-(H5N`aViyV;X0P+Qalse5Lvl?A$sE-jU}72pj|=|sp0Zv zeF@L^I!N6ERyNea$atFr%2w%goZnJyJD>G^p#u`vZ_2lYyhFzONZo^%Y6f+sn)bP@k)Z9hF=E zrEDc-g&)$E0+=V!HN+q2MCnrC?o!$Q1Hnn!&Xtkw;R+v#&b-H||r zd4rJgAhJ?Ucl*sV1M?YG+`xvA0SB-A^K(wJgiJX-HtDjBNXh><$3gt-EVW{F!_C1Y zDJiLTfDNEa+e-S`vuDQ#b<0^jc=qW{|R;!7963Z7E?v9`UgnOo)_a9_@2KK z5f#OL^(rV$z&*T1Ozd1QcR~Ic2n1y7O@pMo>giS$!o`EkP^#?8psbae<*M=7B%tGF zkB=Vp=7KihgrJnYJ=2|J!HwUK|Ku7w$Q&aVgHq8Z~mS(oDBdx2%{u6Fd zQ57j%82P2(TTEx6lkF3IG2fzDX^F5&eOr!KKF{a>M4%*FHC+Eo1+hojV<8ysJ7f;f##EN}=8J#BKKZ3SP^zJ=>jL6a>de-G}5#LV@YT>2+}2lu1kZ)yM`BS0!36ZCubOkGf)koXJei-K{VWW(D= zAEJaf)mU(e8f;A11s{WW*$9W9l1<;~ko-w{^Xm z+yE%f%y0@Q-KK3Q@{3`V)a6pYL+ers(9rsc$nn)@%+fJkQ$^#f{!|<%>yEs=7jsvK z;`@Kr6I#IbvOV-8a6XW}wqqnE2qw$(?DYzyv@&Bq-Iu(bLhJb&=G!eIgva`9w_7LN z(NJg*mUoT}?igGb3+Lq+m3{y+#$;@o&ix<#7qwlE6&|+P-;!zNdQ}Gh z&%Hu-rMC);zY%6(%c!jcC|T~E7@1dUvbX{;lCT2(6A4P&d+;e)0i^|PpIG{CB_b;R zpGcmi_y3`0X{_@#;)syt*)*>E=;0s8W2olyGmZjIOfR8&TKa)^)QE5I zAyqCscU~7FFANM8RGixHh%Vj0?YQUp$5%efb*yAsI%lM~!9{wj8OPeDgO%!xAbO)_@5rzVaS3m<&J%M%>23;bH*x|MOqjN1&cam3kNf}EqB_P zYA?v^(~WPQIk89ms^8ny9hmRFsaHE>+vE4L=MfXcelvpw7xJzDL)me0PrTcsVc;7y zI;topE^fFroCYx1C?RADgCUQ+uSd%H5EUAYE$+y~?;0^HwhP?~<6L_E)sML{2~;#Rh>Fh~RUcbU``<~ot4hnr;93h-GvNnc z($l-8Xllv*eJ5Df_T@kd9mYl<-P5S5vyosg*a^bH!RdN!W!31qXI6j!km?wrt0kQK zT1p=fY=mnRn*ngQ#n!L6UgMKQ^>#<_%syt+?JY}gmz40w2acgC7SVAjl`0$I?AD(! zBsgsETGKdp_vZzVGr`A)P2cz9Jtk7i;2FWwdjL=fJ@w1@eVdcAN)sffS5keHZDhIe zqL^y#ZRXXW@|LBMAqZ zH%$NU{`3d+u<&pkYXAb5p7LrdCv_0d(or`Rk91CHcXsSMfWVOfKtnl$si@=VmA;)$ zDn+~r)TVii@vEy@xr)VAuKR>K7!X~JIPc)>il%ExC?=olLp9tG0^M? zD4i2gS6A9*H#DhItA*BO1p^rjyeNeI3y~jfz1+&lqup0;*t+gyco#RfSRWQ)Mt!6k z3*8iYcbZzb-$Pr9wXU7U!7%h<5Ee`6u8 z{IQ#C|8*J7MmMI~E&Z-;aJ*{85kiUH4Gz_<@U~e_{Eak1slUHi>rXuE89T``wcpJ8 zjP0$M(?&Zo(c6!oIvMp;pzn26)U=`iP_T)KNiRKWgLv-f)J;IMbgTjBi%qBbTY6$T z<^=Ca-&s=AUPjZ5-^;3@Tvaf>Rp<3s=MVahhz7PCzO|`UQJv@1zt~Aes^v`6kqNZST;r3NS^S+`7M56?<_PggFZ5@OA5#h6Y&6}TP5>ALoCh0z_hhWQgO(uVM)Yi9 z67NSQ!Zn8jY!XH!(4=o@>5DyHoGsz!j*gDZ6IaLYuRL|q@a~D4IRyIyVE+e2VM)Q>{E1x+07r_2&)gEh&Z;JJiX;Sp@=Oe}M%+(UbLPB>VOj}!Uay001 z@}a*<$vdz@CM@iHS@N|V$)9C#BZ{X>{P8uad9~Q^?0OIx0Vn$5M)T}w=_x=+^#1a} z7Y*jJNO1L&uj2IQocwEkIV^lT{V%^ZH5Zf^)2p798HxYf^{_3z4ex+T^w!Cf8tM^V zV&*pE3OG(^6ANoB5(UURdTw+yI?N0Y=4zNHUfiNM=MAnmg-K3mI~B{_z_8 z&IeU##1H7~h_lgVmoxv+FMawcRA-&ys zKYESCY6*%TCGwE_jtS6*n z1aFyPIa13opoq(6>Kjkw?cJ(cvE57K@raD<9G;NSxYoo9Hx47Yk>{={*gRXt^9Eac zuxQSmk%|cZ3!dgWR;e@2?XUHWYoLi9LUqFDtv5l})m5vFp*3PIIzqfCYfRC+kdXXI z|M)0XV|U&N?*~2);%Q~$O#v^&@j(N$_CAe}PakR*-J?$zKMAww_Om)aIhr0f+}l-k zF0cF5Nfw|Edn1uT<;WXRwWy;FRPFSM~?ykK4ooFKTWnreDRl)giza^hO4k8c_^VTxLf zLmU;Kn&|QJB_C37vF-UCY|$Q)_z2>U(~-1=*FZJyV702v%Nln7_>5_nrO@pQD{wwz zG%qHw9c$H)Izn$z%O1lspg}o2pJBl9I?!~fH)0>RURS?msWomxyq9Z8Eh!G1rJUxa z!1N;invsJY6ymuntp@@TKsQ|E<%$nnuQO6+ytyB9$r_c5jm!FUf7F>AD&rbNXr7Se zB^os326?uWxR4#IRJQnorq=a-!*L~eQS2BS$m#DWvbR|eK{2GBfIy9y4%j# z@2hTH8v}q~N4o{iCs@`6g*(%wDVZ3ms=aaFth!cOn*ne?WBiz3bnLrY=iNj>VN>l@ujPAipz8hWmGkaJ%XgM<WncCd>VOpv}g#*6qloMS0{KLiN! zi?aSVO2em465gW#1RAOdv0IP*?&Ua`pCI+LVz^vnN@aPqJBu$2sZj4C42q9McYOuK zAvj5Hr`8^QR$WqD$v^l!Y^!$M@Az}_{MBIw*-d|&1}Yag)zz<&WRp3_9Y>mt({G{v zV;Ch(a?X!fN=%l*Xlw!EO93nNuJD>$aE~O|Tmn5-2Sp)vW%T>g;{)t~^?g)%?+sP` zUI{0lBh`xvaX7!Tr0XQd!G#>)l~E|PSM@X`UVY&Tt*B!GbJZn0^yho<)uSQ}&4n5R zz0M0p!(+@3Dkmqewo1J>PTmB%ldt<7jvLx%GfS7lTODvj2WMJ*I^VppS&l-C;nv&? z0_%m$*zdV_vNbHBY@P z+QMoU>D90v@T-!G4FCW#43b`v_S#DJ<8H54k&dt308~LcE8wRep=mZM!3Qb`#|{9W zQJTUb_*BqTIPJKrNq$oWfDQk>@&SrXk;cpY)f>v{JibFbtsltT)E^sEL!V6?>s4i9 zrwa~FfBMv=82#c5is~q_z867@3|m$Z3+1gpJu^vZ@CRv;?5>Dpp=@`zN$RjTZYEfLaLrQ6~<(5~PodQz<^l0rj@w5AL$9 zOM6sP+$<->;~rp@Ec>EC7a=R<% z-BPe={1PTo@-NLw&y|Ce+mKKzwOd2B3YYNtm-(5ze^Jm^n%V+}Xk?c;=)4y^f~5Yc zfIzg{OCt@xBJWCJ3CgZZd3KDZjQL&1gfQ8fNb_I|8~xG7(< z$|ouvZ2Vm`E~Z+9dzfV<{Z8x#F$&BOa>qIpND?OaxCE|#RTnb5&bIzRgkci?;Xv8R z?{{!HmkHfpUaV(rg!7w-*mu<{$w13 z2iC0_=$9)vCivu)5pRDiLpF#7ll)`;O|!@nhGuI|lMMM&R~_C-EUBB=lcIm6f@U>o zve%cB`q6pWV<}Msun}5Ga5ES%m0BqkQ^#*~z%Qvg(f4#GjBmr+biPti`gd;aNoJ>6 z{g4Q7%bqbTpQ;Fsg8FW^@i@((tLbB=(XZaiTprdf zw?`4tN1|~Rxvh`jzDk9n=QIdxw056+2hRCjxoVS_ly!!;D5$ABJ-t|7!qOw(*Tt8P z8lS2=voO&lUe~pOsL4HDEwN7PMk@VW1mc_qmbX~^LR~BKS`v&8`b)Wm=+3>BkKHFQ zgE+@DGa5)BygN$;JN!>mK&iGE+6Rv?V(v@p1C*Ys%T!V@iv;6i@ip}MC~22c3Sldm zxAFsqOyxAS^EI`+m#x*PYX_|l?>wI20z|mYkhI_)d*+=OK7@*4;dkH5j=LH2#B$@0 z(;sH6Iq}fA)X!;Vz)16@9n@m$xgIq^S$-C$H7Dz0%rm z|E?h%R83FHMQMDzyNc&?rbO!m@_C9Ge*SOHVjW;`RYm2`Y`Xq3{t?fEw=T7HyPk#u ze^zfvMsI@paVRX5CsJu+89}IvW9amZfOX3_cs2AjDp38@?c9 z>vN19%*$+atI-yBmgpB3crxLL1sH#+qx89$y=zCD?e;Ce$L_I{ha+>gi5=Oz99;z|vc&m@z$Nni=Bfo#T9V{J_k zpSXWrM6U{vHfBP8|6Uu5|BdQCNA%8WWFti%w z>OJjksgN2B)>8fo+YH%x*#7g2M0>85bV#&w(Q8Xl_f1t*hep5{ka4Rkylu{2C9Rs+ zGDH)N|IwxFapkS<;ZhRQu?Mi@1@Ptd?Q&8|$r_j(8s?rQ`WX&G>++#zaEiMH*B$+{ zNnIs!{PAxWD_hH2L2ltHCt>CW-RURfU+e362`rg$CO{%)!H029hJUphh#(dsFpnX zzcn?rr*J9eL?-9!zpE%QIrs0h-KwgJ)U2FlU!VE&>t4`fRvn>HFY$U%VAIq3j=;8S zRS})Pt$vC9@|&OVX4f0a49w)v*H7nH=r#PmF`b6v?9VkXC!S|~Uh$3m&0x7ilCBU^ z$WFWonK4XHez{aX6GIVWFOax~jy}fH_D4gs$4j4~;Vk{t62q*r_nGIwvCEy(*q&^_ zH&bF(^9~~$U6UP}ocTMFp5cyiNT$`zfr$aBWo)`)V(OV5a;tAHKT_ zTV6@8hOfu z{PE&V(m#8KNB29W_Ue9p`{)<%Ik)cKmDdu5jX_HF5IM41>UYpaYfw`6YP2Dww-0nn zNM3v=+qA#N=kZJM8p8f&!zfT&*kJdLYC0vPU~ z*EpGf_|;w}n|;Hr&1MOT4@fB&*vy~2%7cgmPxkVf+N(RVf2gAx1V>JkYz9q;8T)RE zJWpyR2AZ0y4U$=x{MIol%KY0{n+*!1f6(mpv*$i^!8)Z~PyKeWQy>+z99Km#~1_$+vZ}Pjx zEyg(RXc+H5k+LyaoVVQz!tp_4E}0bZD^- z*8b|4tEI``j5+rc%Q+Uv{en6ZsEQ|X0*T}N2=^osGm_Qx64H_JwM>~a*bcf$SXYj+ z#I)QW^dkK2IAkGUSyAP=YN9M0x|7{+h`qJmf97c3@6a3O2;VT=ggY%hR-J!y2dLC7 zPP*z1S6inHvng@h$ug2@mr(rhqtz#@8eU;N8E{E_@#nWoVu+ytX`UtbAc&Av(?lt> zr6Cx9Ah((Nh1j8+1*A-fsV(t}9m<(%e12AmM;7Gm9C=Xl&Qo%oLtiJ>b0v#)YJq9~ zMPew(k?((#|QiA=Z&CGkv@N+~f-4cK& ztJUY(Zw6{ipmRm?u{WW@#hbY-p0pDOMy~6%|NThk-}C1w8ekd0oXB1$&bquUL=(4O zDdhV63G4=`%IjQxbo0=+#Ve+W^;^>ET`2a+esa z+2OOoK7aG!`U}c`GS#Q0N_X0vtF=u{yIiVOh}L!5!;)ub<{S2J70$c68sfczR_iJa zA;r!*BYm#MF#~K^=e_fvl4KM(YzUE(SrQI}+&p&t1@78=qRGrL%_wdIbqzN7b&85Z zw#x3;D)9DL;~(5>8<+)hg~0(tzj-qkLK0*QnWxJN>x;#SUG`^RVBb2cd&r1`6|S7Tv|Syd|I;gfcy$ zC|~m2PnDh-;ONsa5J{UCx&}ro;9N_4_?#So;zO-ZI?Pj>6It5>c{yz^9^&MpP zYv?Y~-U_|U_{lO@wo@6S{VHD&)1J^0j-z)jHvkG_SaCU^{2UQ@4_=|bV7ayNR=XGf z;PA*W`-ovk%mAzDZ%Vo^E$lWBZ=|EdV5Md`PRK}ChV017`7ImWCRc*!+3tv4R|H)) z)~jg*QUNzHkMJom{j`j3MwyjLn|^i@C!A%5d9o05tK#GSW(QII8nlxg4r1~$V#>P1 zVF0K%=TFtMKvY4p^Me9fn>6Ot>shmwZWjU&N;dPsRaat|tz?#|(( zb~dOgI~aY@wB7?+KR!~|vgQA>&KX#B)tS%Hgt`6tzQ){^AUpxJGI-s`!v0~-^R5WU znmVrSI$D~G$}&X?37O}THilhS}3#o`2O`=?7)&ZFsQ!Z~B| zW~QQamZ;cfyKf^)>XZaBcob-*DW^A1cWLAlhN9&SxZ)o2R2{{c{a1PE+w<;Jau{!S zAAB3}Y-=KWSd^t_J$2a+`aQ@(q(OPUi7`IRktwRti!~F0QekxV;WN6o`emZi(9AIT zgiEu5MrNaSk)3P^s7QpLF^y+`qagN={cng{kKJ{I`jnjIC0gl*ChL1`Ek^yKXDO$= zg)CFXzK}v)nQL90sKvy|-JVU)OzxR3NsvUG&fv*hn6F+TYns+INFa?mckVy|_dDaV z+VsLtba?f8=lqXY(`92@olQeiMp})i#v7T+GUgj{-TYe>xDg!M(MGZ7eiTL!unu{v`iRuiK%+y$hw8r`zfI4XFzDc|4d67n9C# zf3{Lh%KBS*Gs_WfPO`U=^~qqt7x`cnH}L>yelyyDs$^ewteUOk;rW(0DnI*-wJ z7@Di-3Wp2&1^>?PZJUQVw@WaeY20mzBq6O1@K#uf1vs|UZMWxi`n3cmF)o))1tt5N zn}s@Psrg2fw-C&Z#5Q&Jlr6CuuW;Wa+li>dE$#uZ_OMO{yn=DyQSUvtwC?F8B1Q5G4Ys(LIXj9%A48cN>o+Ec`D$ zJkPZPMYr4xD<^y{{}3dFwm_8?W5(Zg2Fl-5o9gop{dqOp%-VZ?GCyjh*&mW<8`Ztz zcs3IAZQaSPsc77INmxXo_Vhmf49);e7ThBI=Gyjj1EvUVdqiW5NOJDhqhUBtZlqzVHcRacXNnv~T4o z^ZEm{7MBQ<-HO^@)qB3TE5;#k#{AQsaQn^qFu3{d2^rbRn{?zo1piVAdLUJZGOxgV zIf-Sw^y9hKz(e?fMr`wqV}c1&r$HofLGyC27qQ0Hgjo5zo|9CTlZ{pqLJY0xEE&QM zk*~$N5B=Z zg1v1hsF2PAovc;GO|M`2oQpHJ&fcSUk-j^!dwX+!7+C>&V7}POvwhpwQPpM_a)M9t zrHwJ_=Z>pRjrYL)y^TyRsq!2o^M16cZinpjy(wS#DTHEV0jW>h<%6as@>lX(1TT%! z5AahA&;LOwZ3?UIP5%E-N`FUl{ST_|y{_o5_quBU0|UVDC$=7FMFDqN1t*5^&jQD4 zj4nqD>3<`~zaLrr{|#IPVs|A{AOZJpF7EF~0R}L7>)&M3-w)Ln{{>cue@PL-KmArp z_kVb>02oLQ=cq!-f9fMv_5b{K)(xcz190%QmIaO%|5-v-F!;Y36o9YF;vbd$9wsyaM*<{X-CAq->9#Sol&zTlLMpc;f;Z(*a|F8D?;#by%g-tFyI8M&a zj_bYH+b;ah%DW#;O><|%LzACvH2vbQv7N`izrB>y)FeD?xzw+G1w1a7$-fiIf=*AJ zD)a1ofew6RbaZi5RXkt-75y}DqEXUQO222(Ys90crw0b0;Q>Enzyl*Vnw;+BXRKyC z-qATZIXSF!AXdhQ_BOQo-Ws)kewqmK<@Y+4_)%zyvI-S0`)1ESp>D-Wc~c=b}KM^k;3YlY&GE*X452 zJ==D^78wn#iy9*M6<|{^p2(BitTo!5EHsiqHN7W)IDX-C+DB*fpQO;#i@$O=l{q=7 z+I+p4V$^5U5%{v+X#)kHNjor#Q~-{YEu(KSpDEP|`TiY8HUp$r!gX`Km4W`DvD$nj z9KJR1%cTjfEn=#YQ6zjugi+(#mxqgv+oO~@`T1brchqLe^aM)uTVB7@D8sXkh|Of2 z@*0GnbAfB@0MIqK)>QfvK8%WDQVIwVBOsvxgM31*B$C|SfIl_r12T63!RPCqh()IJwYHsMxO81OqYcjHUESSbG*nrQY{ork(HzQTtBcK^D!@Xpm3#qN64Y(> zz-DPV!$EKYzB3Z}Z(BgkKKbKSNG}on<2PEWB5R1?DRM9x5mo%>y_xd0089`T9Q38S zOy9D)Ig(-Dn<3yH^^^~g42i7&H^t(i6o`$BBRYlatKZEI9eiS7uqm+gvwY$EKC{+(dX>CSfKUP30nA%N-B^BE zs$C=E>Di!ZoO36T1xWSP`HVsL>uhGdMnbQ_-`c#Ia%+VMtLYr*4ogy1va1&7t3Lr(YocgAz2K7KT$C8S*Ep)NMWy&v*aHuj>RqC)YXeO+P1$`6G=B$buFYgVZ( ze%2Mm>>>sE%sMPIxgB%>0}$bZ7_IjC-S$J_!q6Fv-U&?c>z)h#@}(XL(Au7WFT6$+ zWsdWJhUdwrF~on?(Dy_vZ+mFe1Z=Ulkk{FJC8cOhcBHM?%rdz3e{gses?yp7ym#>9 zZQCQRHHjJ*#f%~XoTTt-e)++SW1;rcez(2-y|evG;MTeiTmBEwQJ7W|&v|b&wGk5# zd>9fU_IODL14{nC)&K^BtBH^fV-!HY3Y4?wcetzmK4=1}){=YAhc zxV$#H9n4XXNqbq%{j}VqSXk`_qhlJynF4k;G#TI2LV5#AdwqQ!jKSP*!D2mK@@owu zY?ny)6V5vYY#9D;;bXhsRk^)@9eaJzQc48xLbUSm@%3f%fAFbX*EdG#?e6OOwAknx zY)E&x|J!(5&H=DrU=2VO3zeTa^`~Y6jt08a;(f9nqmWfqrQEFD=4jE6^i@=an~Ws+ zJ1?i{+H}4Gc`C1?2;c(X+=Rn5vCeb=zY~EG_hCrMpH$e71hDX&&t?3tR$g>2 zBS}AO4y72O0;?&BrQAPihRJs-Mh|bFdv!YKPI+96 ziL~cUF??oBWhy0~3l(kiyYG4j*o4|LgSM!r2uMFFDzF~U4IYEq9?r{G<8A@~nd-$0 zRoT2#45qWN2@elHhK&dlpTdWdVi6Kr^zujm3Yliuiwu@620I1~tPCj)7{I95#ROreJl78JRz!SYHpTq=w{rfy%A|c@Lx%7Y^JHYym z9rV1{y?4CW*8+^^3c%R`H};`+q%=?R&w^9B9 zv^C&!divwup+EWqymZ}jH*kfP+F_ecr1!VbYw?=;)^@q%4G&&KTPydLTAF&5R62lY zt_Scii@=?yF#8vTRq|xn2JiEF0BRS9wAjf^Q9vx7GwIZF-aP_@c-T6Csu-UGc8X}u z*RI1(`Hz6SvI=!Nz5nkB%X z+S9@9v21kVK-Iiw9>9p(?z#C9{=Y+E0f_-FuAhGQUQ>Tn_~ia_nRqkY7z@zR1tl_C zuh)Sp&l~`zn@&KGSf(g+ee0}em^&Xs(232ign^AvOKcUcs;WYJEQkCjWGzCJwns3P z=e5QZJpR1$H2YLW%D}(?2;4$@Yu49IqMge!fqgoK!O$Pc1wATO9)TsOv6=K@bw2LF z78d?GU%1KnreE&vf&3bf&cxfR!u)hN$UStyd4{;G^7$Xx*4smY&c`_N@^8dJKnso* z2Pa2PNVMwPY3~xOkC-V-%V?MyzAw-NUHOWg)2*VlyM^Y1bf8=RSQ2c`QmmJHx_3}B>5P+t$+Yp zp#_+v`u6QxEE$RZ1s^~PapB%L-EkUN7~&r|-XT~H^3LFm;bcKvByF$6m>6C)gUR6)#wgEafO zkkmQ!o|J1fwC*&W5Gk1BAXL9H8Q4vg{ssH#*cZ9}SDoa5U%-ww2VJk@hAcS%LtG=- zpO_o%{`#}AVR|L36rkjW{88y|3(P$8s@BEG(qp zgJ7-03fKx6=e`nsD0T2JUkNoxiL9QP3NVE;!RZr2R$9nD+xMdR_|z8N&&#h)h1q8n zRl)<)-5aRz!xvNn=1`g+?toUDexL{5qtM=xLmrs}5NO=#Qx-u^r>Q{2KX)6+9Jgg~0#^E3w-TpSrdX3hf&_#9$fu^DSRDjDgn5eNaugCL*|$>7+p-D{m= zQ##bOqi_fr;lu#>h>f65jj)YEYdC;-hCvL0smwI{-kmLH<1$o$%UkEmVwa29{g^OYXs_xonC;RT63 zEI47_EPv)OmyMQR$efHPvJo0fu^8^WxII3=oN+J&=2+Z|y_Yu#AF4#as%sgn-_MLG zmoK@&ih~Pv4w|nMU}`F#UtM3HWCDAk2FCHxY4a08Z~*>05-2MG@r(J{^}FN!$MQur{F}+#O4=()Akn2P?*Z9z;3x74Dkjft*Yx!a~An3PuWv>C_ z9)!wo6~(i>3=xA2jXWC2PXmjY0giU!!v+425C3c)IXSG&D0COn5AKzdX%BtC%z{&> zPs@IE&opgH5A|SsnIs;+LpN!YVd15~A(*;;XaJjMQ?i*a`Q7O->vJmxYo)bINH{k? zIf;1KT(cUJ0Oeg%nALTxuTba%HBJRX6S5Tzqpa6#{XwrwrGy(h znNas_icqSFryHEEY-+lA%;49|a1@<7Xc>_|VT9+b@tFy2OK52N!RRUT#4XdzUUqr; zNqY9a$9pTCH_jGp z)~IFs>FfL$3b<#Z`lY%hm>E*`2^B};td1e29<K$fz$c&rosU{>E-54AFHc9awzLzcwli0-^K*P8K{y{{(wqN={cUgWd<&{IwQ_{yl zu3_5XBilC+t+x3)AOz0O_`b%czm=KN9?Cu#vHf)U$Mx0EVT3oUK6O?Qzu_qJY@b$d zp(l^#+(oJOYYTS|m}ecwS2exNjNPs=^RNuSUE19aE)cSf1UjFp3hv%X{W(Kvhn*d#Jepa?BS6*iLTYQMYAKXM;#C1DP) zXq=#MF~cpr66xp)jHzi|m@a}d`ysI2YFMh|KgsHTx) zw})*9J1ah*)vhZ|N3FPg+3=I`I^Y!m=#tRsGK%D-VIQw4$|sBF6@u510JMTnoO%+< zIVndYUrH3Pv|_(FZb|91njz85ei!AV>zmC4%?Z>0O61!uQI_gYuoePzDHQtXgOJh4 zS^9a%R`gm7QMT05rF$wq)Q;dCqWa9$A7D*jf!KlmJGN#6d4(6NpvpO1pao?VdgIfH z3i`4_c;wJ}4rge5>Ns!v6?C(YSnCY)zNMUW&{ti`;6gPVv2!8iEXw*j>QTlSO=ysF zNe>&Of2}(YD_|MwD5>}$pGOkCr>l$?+-1&3AJAO>o;-zKp22zbWIa_cY9z$U!5HKQ zYZNd8WxO$;GN2OhH~O3Tzl#HE@Zx}qzaVht3pQ>7&fl7%^1tuqYc~7Nj?ArVALFN` z{MZV|3sG+U<(A=O@KT2Q@xF!kDLMzsyTi6IM%}gVE7mKnYc*l5Xnl0*{ckHDx>Cj? ziSst#Lw$d@+DSK=TMXTvgbjVOaWnoAYafkghr*kHTaW zoPh3D**+N*8Qwn*%=W4BaT3>>wp(pd{WUDmT2R+-P0|S@c~vsvPLe zuW|*@L|!|`RvpAK^OD3m=^MWhF7_4A_h-?su2@WfaJu9gUy}^SP)_Y%tEx=EqfgJ` zk`g>?yEY*0+{p%%!KD7u*3}$!VUw^vX1xXGD~*Tyoc}x$7Fz=U5dKU}C$@wLXQDDp z|Ag_@&-PhJ!5gY9?feNXzmVdo>HS+E(gC_b_#x-u9~f?hcHTi6a!Lj zlg}5hli@57w-7WU_R_w+QFCIsXya-dCKz3g{yOl@CWUvOF~-(-@h$4rx+;H`+#YyY zY+QYwBkA&&bfOvem{_@Fo)yvh%uoOJLCoczw=i=b%S)ev__9)fgZÐ|9O0T8k{W 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 h9zKbV?>jVm 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μGgegSVa1*zu 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 for deep learning compiler optimization research. HloEnv transforms all graph rewrites into a common representation, providing a flexible interface to control and modify existing graph optimization passes. In this representation, an XLA pass is converted into a set of sequential rewrite decisions, which control when and if the rewrites are applied. + +*HloEnv* has the following major features: + +- **The alternative graph representation**: To generalize to any type of graph rewrite, and to enable joint consideration of multiple rewrite rules that potentially conflict with each other, HloEnv uses a general alternative graph representation. To achieve this, HloEnv introduces several changes to XLA's original implementation, which are compiled into a `patch `_. When a source graph is processed in a pass with *dry-mode* enabled, HloEnv captures each rewrite opportunity instead of applying them. It then augments the graph with the identified rewrite opportunities using a special *kAlternative* instruction, resulting in an alternative graph. This alternative graph serves as the state for the agent. After decisions are made on which input path to take for each *kAlternative* instruction in the reroute step, HloEnv applies a pruning step to remove all unused nodes and perform additional clean-up. + +.. image:: images/altgraph.png + :width: 800 + :align: center + :alt: Alternative Graph Representation + +- **Python interface for full XLA optimization passes and pipelines**: HloEnv's Python interface parses an HLO text file into an HLO graph and loads it into the frontend optimization environment. A user-specified set of XLA passes/pipelines is then applied to the HLO graph. HloEnv executes the original pass/pipeline directly if dry-mode is turned off, while it captures these rewrites without actually applying to the source graph when dry-mode is turned on. An augmented graph that contains both the source graph and all the rewrite opportunities is generated for the user. Using the augmented graph as an input, the user can develop various decision-making agents to decide which rewrites to apply (see :ref:`examples` for an example of a simple decision-making agent implementation). This process can be applied multiple times until the output HLO graphs stay unchanged (converge) or until a decision is made to end the optimization for that pass/pipeline. The user can then use XLA's backend APIs to generate the final device code. + +.. image:: images/sys.png + :width: 800 + :align: center + :alt: System Overview + +The design of HloEnv points to a potential future where deep learning compiler engineers only need to develop and maintain a simple set of rewrite rules and leave the complicated heuristics to machine learning-generated optimization strategies that generalize to both new deep learning models and new deep learning hardware. More details please refer to our paper. + +Installation +----------------- + +To run examples, you need to install the following dependencies in your python package: + + - `TensorFlow>=2.9 `_ + - NumPy + +To build HloEnv and evaluate HLO graph runtime, you need to install the following dependencies: + + - `Bazel `_ + - liblapack-dev + +To clone HloEnv and install Tensorflow, run the following command::: + + git clone git@github.com:sail-sg/hloenv.git + cd hloenv + python -m venv hloenv-env + source hloenv-env/bin/activate + python3 -m pip install tensorflow>=2.9.0 + +When met the minimum requirement, building HloEnv Python Wheels can be very simple. + +In the root directory of HloEnv, run the following command::: + + make build + +Will build the wheels file and put it under the folder *dist*, and::: + + make install + +Will install the freshly built Python Wheels and all the dependencies. + +HLO Dataset +----------- + +You can find the unoptimized HLO text files harvested from JAX implemented repositories on GitHub `here `_ + + +These HLO text files are harvested by setting the XLA\_DUMP\_TO flag while running the model in the repository. This flag dumps all the unoptimized HLO graphs generated during JAX's Just-In-Time (JIT) compilation process. The HLO text files in the dataset are additionally cleaned of metadata and deduplicated. + +Citations +--------- + +If you use *HloEnv* in your own research, please cite it using the following +BibTeX entry: + +.. code-block:: bibtex + + @inproceedings{HloEnv2022, + author = {Chin Yang Oh, Kunhao Zheng, Bingyi Kang, Xinyi Wan, Zhongwen Xu, Shuicheng Yan, Min Lin, Yangzihao Wang}, + title = {HloEnv: A Graph Rewrite Environment for Deep Learning Compiler Optimization Research}, + booktitle = {Workshop on ML for Systems at NeurIPS 2022}, + year = {2022}, + series = {NeurIPS '22}, + month = dec, + } diff --git a/docs/reference.rst b/docs/reference.rst new file mode 100644 index 0000000..1939eca --- /dev/null +++ b/docs/reference.rst @@ -0,0 +1,5 @@ +API Reference +============= + +.. automodule:: hloenv + :members: diff --git a/docs/release_notes.rst b/docs/release_notes.rst new file mode 100644 index 0000000..4105f3c --- /dev/null +++ b/docs/release_notes.rst @@ -0,0 +1,9 @@ +Release Notes +============= + +HloEnv 0.1.0 +------------- + +*Nov 1, 2022* + +- Initial release diff --git a/docs/xla_passes.rst b/docs/xla_passes.rst new file mode 100644 index 0000000..a27fc5f --- /dev/null +++ b/docs/xla_passes.rst @@ -0,0 +1,9 @@ +.. _xla_passes: + +List of Enabled XLA Hlo Passes +======================================== + +.. automodule:: hloenv.HloPass + :members: + :imported-members: + :undoc-members: diff --git a/examples/__init__.py b/examples/__init__.py new file mode 100644 index 0000000..0e30793 --- /dev/null +++ b/examples/__init__.py @@ -0,0 +1,13 @@ +# Copyright 2022 Garena Online Private Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. diff --git a/examples/always_pick_first.py b/examples/always_pick_first.py new file mode 100644 index 0000000..f284e7f --- /dev/null +++ b/examples/always_pick_first.py @@ -0,0 +1,86 @@ +# Copyright 2022 Garena Online Private Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# A demo to where we always pick the first alternative and compare the +# evaluation timing of the resulting hlo module to the one optimized by the +# original xla pipeline. + +import numpy as np +import os +from hloenv import AltPipeline, HloEnv, HloPass, Pass, Pipeline +from general_fusion_pipeline import GeneralFusionPipeline + +if __name__ == '__main__': + os.environ['CUDA_VISIBLE_DEVICES'] = '0' + os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' + + base_dir = os.path.dirname(os.path.realpath(__file__)) + hlo_base_dir = os.path.join(base_dir, "hlo_texts") + for root, dirs, files in os.walk(hlo_base_dir): + for file in files: + + filepath = os.path.join(root, file) + + hlo_env = HloEnv(filepath, "gpu") + general_fusion_pipeline = GeneralFusionPipeline(hlo_env) + instruction_count = hlo_env.get_hlo_module().instruction_count + + print("-------------------------------------------------") + print("Testing general fusion for file: " + filepath) + print(" num instructions = %d" % instruction_count) + + orig_hlo_module = hlo_env.clone_hlo() + # Original TF pipelines + hlo_env.optimize_hlo_module() + + ref_results = hlo_env.evaluate(100) + ref_timing = min(ref_results.durations) + + # Save reference copy of the module after a non dry-run RunHloPasses call + reference_hlo_module = hlo_env.clone_hlo() + hlo_env.load_hlo(orig_hlo_module) + + hlo_env.run(general_fusion_pipeline.pre_pass_optimizations) + num_alts = 1 + while num_alts > 0: + hlo_env.run(general_fusion_pipeline.pre_dry_pass_passes) + hlo_env.run(general_fusion_pipeline.pass_dry_run) + + hlo_graph = hlo_env.get_hlo_graph(do_hash_verification=False) + node_features = hlo_graph.node_features + num_operands = node_features.num_operands + num_alts = len(hlo_graph.alternative_indices) + + if num_alts > 0: + decisions = [] + for alt_idx in hlo_graph.alternative_indices: + node_uid = node_features.uids[alt_idx] + + # Always pick the first alternative available + decisions.append([node_uid, 1]) + + decisions = np.asarray(decisions) + hlo_env.apply_alternatives(decisions) + + hlo_env.run(general_fusion_pipeline.post_dry_pass_passes) + + hlo_env.run(general_fusion_pipeline.post_pass_optimizations) + + pick_one_results = hlo_env.evaluate(100) + pick_one_timing = min(pick_one_results.durations) + + print( + "Ref timing: %.2f, Pick one timing: %.2f" % + (ref_timing, pick_one_timing) + ) diff --git a/examples/general_fusion_pipeline.py b/examples/general_fusion_pipeline.py new file mode 100644 index 0000000..2a83280 --- /dev/null +++ b/examples/general_fusion_pipeline.py @@ -0,0 +1,434 @@ +# Copyright 2022 Garena Online Private Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from abc import ABC, abstractmethod, abstractproperty +from hloenv import HloEnv, HloModule, Pass, HloPass, AltPipeline, Pipeline, GpuBackend + + +class PassPipelines(ABC): + + @abstractproperty + def pre_pass_optimizations(self): + pass + + @abstractproperty + def post_pass_optimizations(self): + pass + + @abstractproperty + def pre_dry_pass_passes(self): + pass + + @abstractproperty + def post_dry_pass_passes(self): + pass + + @abstractproperty + def xla_passes(self): + pass + + @abstractproperty + def pass_dry_run(self): + pass + + +class SingleFusionPipeline(PassPipelines): + + def __init__(self, hlo_ir: HloEnv) -> None: + self._hlo_ir = hlo_ir + + hlo_module = self._hlo_ir.get_hlo_module() + config = hlo_module.config + debug_options = config.debug_options + + self.pre_fusion_optimizations = Pipeline("pre-fusion-optimizations") + + optimization_pipeline = Pipeline("optimization") + optimization_pipeline.add_pass(HloPass.AllToAllDecomposer()) + optimization_pipeline.add_pass(HloPass.OperandUpcaster()) + optimization_pipeline.add_pass(HloPass.ResultCaster()) + optimization_pipeline.add_pass(HloPass.RngExpander()) + optimization_pipeline.add_pass( + HloPass.RngBitGeneratorExpander( + HloPass.RngBitGeneratorExpander.RandomAlgorithm.RNG_PHILOX + ) + ) + optimization_pipeline.add_pass(HloPass.ComparisonExpander()) + optimization_pipeline.add_pass(HloPass.ZeroSizedHloElimination()) + + if debug_options.xla_gpu_deterministic_ops: + optimization_pipeline.add_pass( + HloPass.ScatterExpander( + HloPass.ScatterExpander.Mode.kEliminateAllScatters + ) + ) + else: + optimization_pipeline.add_pass(HloPass.GpuScatterExpander()) + + optimization_pipeline.add_pass(HloPass.QrExpander()) + optimization_pipeline.add_pass(HloPass.EighExpander()) + optimization_pipeline.add_pass(HloPass.DynamicIndexSplitter()) + optimization_pipeline.add_pass(HloPass.CallInliner()) + optimization_pipeline.add_pass(HloPass.DotDecomposer()) + optimization_pipeline.add_pass(HloPass.Convolution4DExpander()) + optimization_pipeline.add_pass(HloPass.StableSortExpander()) + + optimization_pipeline.add_pass(HloPass.BFloat16Normalization(True)) + optimization_pipeline.add_pass(HloPass.BatchNormExpander(True, True, True)) + optimization_pipeline.add_pass( + HloPass.LogisticExpander( + HloPass.LogisticExpander.LogisticExpansionType.kExp + ) + ) + optimization_pipeline.add_pass(HloPass.ConditionalCanonicalizer()) + optimization_pipeline.add_pass(HloPass.DynamicDimensionSimplifier()) + dp_options = { + "shape_check_mode": HloPass.DynamicPadder.ShapeCheckMode.kCompileTime + } + optimization_pipeline.add_pass(HloPass.DynamicPadder(dp_options)) + + # *********************************************************************** + + simplification_pipeline = Pipeline("simplification", loop_count=-1) + simplification_pipeline.add_pass(HloPass.ZeroSizedHloElimination()) + simplification_pipeline.add_pass( + HloPass.GatherExpander( + HloPass.GatherExpander.Mode.kEliminateSimpleGathers + ) + ) + simplification_pipeline.add_pass( + HloPass.ScatterExpander( + HloPass.ScatterExpander.Mode.kEliminateSimpleScatters + ) + ) + algebraic_config_options = { + "replace_transpose_with_bitcast": False, + "minmax_propagate_nan": debug_options.xla_gpu_enable_fast_min_max, + } + if (GpuBackend.stream_exec_platform == "ROCM"): + algebraic_config_options["enable_conv_operand_swap"] = False + + simplification_pipeline.add_pass( + HloPass.AlgebraicSimplifier(options=algebraic_config_options) + ) + + simplification_pipeline.add_pass(HloPass.BitcastDtypesExpander()) + simplification_pipeline.add_pass(HloPass.DotDecomposer()) + simplification_pipeline.add_pass( + HloPass.DotMerger(max_size_to_merge=16 << 20) + ) + simplification_pipeline.add_pass(HloPass.SortSimplifier()) + simplification_pipeline.add_pass(HloPass.TupleSimplifier()) + simplification_pipeline.add_pass(HloPass.WhileLoopConstantSinking()) + simplification_pipeline.add_pass(HloPass.WhileLoopSimplifier()) + simplification_pipeline.add_pass(HloPass.ReshapeMover()) + simplification_pipeline.add_pass(HloPass.HloConstantFolding()) + simplification_pipeline.add_pass(HloPass.ConditionalSimplifier()) + simplification_pipeline.add_pass(HloPass.RealImagExpander()) + simplification_pipeline.add_pass(HloPass.TransposeFolding()) + simplification_pipeline.add_pass(HloPass.HloCSE(is_layout_sensitive=False)) + simplification_pipeline.add_pass(HloPass.HloDCE()) + optimization_pipeline.add_pass(simplification_pipeline) + + # Run WhileLoopTripCountAnnotator at the end of the simplification + # pipeline, before layout assignment and fusion. This pass does some + # pattern-matching on while bodies/conditions, and this is where the HLO is + # "nicest". + # + # It's important that we don't make semantic changes (e.g. unrolling) to + # any `while` loops after this point, because otherwise the trip-count + # annotations added by this pass may not be correct after the + # modifications. + optimization_pipeline.add_pass(HloPass.WhileLoopTripCountAnnotator()) + # pre_fusion_pipeline.add_pass(optmiization_pipeline) + self.pre_fusion_optimizations.add_pass(optimization_pipeline) + + # -------------------------------------------- + # Collectives Pipeline + # -------------------------------------------- + + collectives_pipeline = Pipeline("collective-optimizations") + collectives_pipeline.add_pass(HloPass.AllReduceFolder()) + collectives_pipeline.add_pass(HloPass.ReduceScatterCreator()) + collectives_pipeline.add_pass(HloPass.AllReduceReassociate()) + algebraic_config_options = { + "replace_transpose_with_bitcast": False, + "enable_conv_operand_swap": False, + "minmax_propagate_nan": debug_options.xla_gpu_enable_fast_min_max, + } + collectives_pipeline.add_pass( + HloPass.AlgebraicSimplifier(options=algebraic_config_options) + ) + collectives_pipeline.add_pass(HloPass.AllGatherBroadcastReorder()) + self.pre_fusion_optimizations.add_pass(collectives_pipeline) + + # -------------------------------------------- + # Convolution Canonicalization Pipeline + # -------------------------------------------- + + # TODO(ohcy): Account for AMD GPU case + # Note, this is specific to Nvidia GPUs. For AMD GPUs, some of the passes, + # e.g. Cudnn passes should be excluded + conv_canon_pipeline = Pipeline("conv-canonicalization") + conv_canon_pipeline.add_pass(HloPass.GpusolverRewriter()) + conv_canon_pipeline.add_pass(HloPass.GpuConvRewriter()) + conv_canon_pipeline.add_pass(HloPass.CudnnFusedConvRewriter()) + conv_canon_pipeline.add_pass(HloPass.GpuConvPaddingLegalization()) + conv_canon_pipeline.add_pass(HloPass.CudnnPadForConvolutions()) + conv_canon_pipeline.add_pass(HloPass.CudnnVectorizeConvolutions()) + conv_canon_pipeline.add_pass(HloPass.CallInliner()) + conv_canon_pipeline.add_pass(HloPass.TupleSimplifier()) + algebraic_config_options = { + "replace_transpose_with_bitcast": False, + "enable_conv_operand_swap": False, + } + conv_canon_pipeline.add_pass( + HloPass.AlgebraicSimplifier(options=algebraic_config_options), + loop_count=-1 + ) + conv_canon_pipeline.add_pass(HloPass.HloConstantFolding()) + self.pre_fusion_optimizations.add_pass(conv_canon_pipeline) + + # -------------------------------------------- + # Layout Assignment Pipeline + # -------------------------------------------- + + layout_assignment_pipeline = Pipeline("layout-assignment") + layout_assignment_pipeline.add_pass(HloPass.FlattenCallGraph()) + layout_assignment_pipeline.add_pass( + HloPass.GpuLayoutAssignment(hlo_module) + ) + self.pre_fusion_optimizations.add_pass(layout_assignment_pipeline) + + # -------------------------------------------- + # Post Layout Assignment Pipeline + # -------------------------------------------- + + # ******************* + # NVIDIA GPU Specific Passes Stage 1 - START + post_layout_ass_pipeline_nv_pre = Pipeline("post-layout-assignment-nv-pre") + if (GpuBackend.cuda_is_at_least(GpuBackend.CudaComputeCapability.AMPERE)): + post_layout_ass_pipeline_nv_pre.add_pass( + HloPass.CublasPadForGemms( + datatype=HloPass.CublasPadForGemms.PrimitiveType.BF16, + pad_to_multiple_of=8 + ) + ) + + if (GpuBackend.cuda_is_at_least(GpuBackend.CudaComputeCapability.VOLTA)): + post_layout_ass_pipeline_nv_pre.add_pass( + HloPass.CublasPadForGemms( + datatype=HloPass.CublasPadForGemms.PrimitiveType.S8, + pad_to_multiple_of=4 + ) + ) + post_layout_ass_pipeline_nv_pre.add_pass( + HloPass.CublasPadForGemms( + datatype=HloPass.CublasPadForGemms.PrimitiveType.F16, + pad_to_multiple_of=8 + ) + ) + + post_layout_ass_pipeline_nv_pre.add_pass(HloPass.HloConstantFolding()) + # NVIDIA GPU Specific Passes Stage 1 - END + # ******************* + + post_layout_ass_pipeline = Pipeline("post-layout-assignment") + post_layout_ass_pipeline.add_pass(HloPass.ReductionDegenerateDimRemover()) + post_layout_ass_pipeline.add_pass(HloPass.ReductionLayoutNormalizer()) + post_layout_ass_pipeline.add_pass(HloPass.ReductionDimensionGrouper()) + post_layout_ass_pipeline.add_pass( + HloPass.ReductionSplitter(), loop_count=-1 + ) + post_layout_ass_pipeline.add_pass( + HloPass.GpuTreeReductionRewriter(), loop_count=-1 + ) + + algebraic_config_options = { + "is_layout_sensitive": True, + "replace_transpose_with_bitcast": False, + "enable_conv_operand_swap": False, + "minmax_propagate_nan": debug_options.xla_gpu_enable_fast_min_max, + } + post_layout_ass_pipeline.add_pass( + HloPass.AlgebraicSimplifier(algebraic_config_options), loop_count=-1 + ) + post_layout_ass_pipeline.add_pass(HloPass.TransposeFolding()) + post_layout_ass_pipeline.add_pass(HloPass.GemmRewriter()) + post_layout_ass_pipeline.add_pass(HloPass.GemmBroadcastFoldingRewriter()) + post_layout_ass_pipeline.add_pass(HloPass.BFloat16Normalization(False)) + post_layout_ass_pipeline.add_pass(HloPass.GpuConvAlgorithmPicker()) + post_layout_ass_pipeline.add_pass(HloPass.TupleSimplifier()) + post_layout_ass_pipeline.add_pass(HloPass.HloCSE(True)) + + # ******************* + # NVIDIA GPU Specific Passes Stage 2 - START + post_layout_ass_pipeline_nv_post = Pipeline( + "post-layout-assignment-nv-post" + ) + + post_layout_ass_pipeline_nv_post.add_pass(HloPass.GemmAlgorithmPicker()) + if (hlo_module.is_bef_enabled): + post_layout_ass_pipeline_nv_post.add_pass( + HloPass.TriangularSolveRewriter() + ) + # NVIDIA GPU Specific Passes Stage 2 - END + # ******************* + + self.pre_fusion_optimizations.add_pass(post_layout_ass_pipeline_nv_pre) + self.pre_fusion_optimizations.add_pass(post_layout_ass_pipeline) + self.pre_fusion_optimizations.add_pass(post_layout_ass_pipeline_nv_post) + + # ----------------------------------------------------------------------- + # FUSION PIPELINE + # ----------------------------------------------------------------------- + + # -------------------------------------------- + # Original Vertical Fusion Pipeline + # -------------------------------------------- + + self.vert_fusion_pipeline = Pipeline("vertical-fusion", loop_count=-1) + self.vert_fusion_pipeline.add_pass(HloPass.VariadicOpSplitter()) + self.vert_fusion_pipeline.add_pass(HloPass.GpuInstructionFusion(False)) + self.vert_fusion_pipeline.add_pass(HloPass.GpuInstructionFusion(True)) + self.vert_fusion_pipeline.add_pass(HloPass.FusionMerger()) + self.vert_fusion_pipeline.add_pass(HloPass.GpuMultiOutputFusion()) + self.vert_fusion_pipeline.add_pass(HloPass.HloCSE(True, True)) + self.vert_fusion_pipeline.add_pass(HloPass.HloDCE()) + + # -------------------------------------------- + # Vertical Fusion Pipeline + # -------------------------------------------- + + self.fusion_pipeline_pre = Pipeline("fusion-pre") + self.fusion_pipeline_pre.add_pass(HloPass.VariadicOpSplitter()) + + self.fusion_dry_pass = AltPipeline( + Pass( + HloPass.GpuInstructionFusion(True), # may_duplicate + ) + ) + + self.fusion_pipeline_post = Pipeline("fusion-post") + self.fusion_pipeline_post.add_pass(HloPass.FusionMerger()) + self.fusion_pipeline_post.add_pass(HloPass.GpuMultiOutputFusion()) + self.fusion_pipeline_post.add_pass(HloPass.HloCSE(True, True)) + self.fusion_pipeline_post.add_pass(HloPass.HloDCE()) + + # -------------------------------------------- + # Horizontal Fusion Pipeline + # -------------------------------------------- + self.post_fusion_optimizations = Pipeline("post-fusion-optimizations") + + hori_fusion_pipeline = Pipeline("horizontal-fusion", loop_count=-1) + hori_fusion_pipeline.add_pass(HloPass.GpuHorizontalLoopFusion()) + hori_fusion_pipeline.add_pass(HloPass.GpuHorizontalInputFusion()) + hori_fusion_pipeline.add_pass(HloPass.HloCSE(True, True)) + hori_fusion_pipeline.add_pass(HloPass.HloDCE()) + + self.post_fusion_optimizations.add_pass(hori_fusion_pipeline) + # ----------------------------------------------------------------------- + # POST PIPELINE + # ----------------------------------------------------------------------- + + post_fusion_pipeline = Pipeline("post-fusion") + + post_fusion_pipeline.add_pass( + HloPass.AllGatherCombiner( + combine_threshold_in_bytes=1024 * 1024 * 1024, + combine_threshold_count=256 + ) + ) + post_fusion_pipeline.add_pass( + HloPass.AllReduceCombiner( + combine_threshold_in_bytes=debug_options + .xla_gpu_all_reduce_combine_threshold_bytes, + combine_threshold_count=256 + ) + ) + post_fusion_pipeline.add_pass( + HloPass.ReduceScatterCombiner( + combine_threshold_in_bytes=30 * 1024 * 1024, + combine_threshold_count=256 + ) + ) + + if debug_options.xla_gpu_all_reduce_contiguous: + post_fusion_pipeline.add_pass(HloPass.AllReduceContiguous()) + + blueconnect_num_devices_per_host = debug_options.xla_gpu_all_reduce_blueconnect_num_devices_per_host + if (blueconnect_num_devices_per_host > 0): + post_fusion_pipeline.add_pass( + HloPass.AllReduceBlueConnect(blueconnect_num_devices_per_host) + ) + + if debug_options.xla_gpu_enable_async_all_reduce: + post_fusion_pipeline.add_pass(HloPass.AsyncCollectiveCreator()) + + post_fusion_pipeline.add_pass(HloPass.CollectivesScheduleLinearizer()) + algebraic_config_options = { + "is_layout_sensitive": True, + "replace_transpose_with_bitcast": False, + "enable_conv_operand_swap": False, + "minmax_propagate_nan": debug_options.xla_gpu_enable_fast_min_max, + } + post_fusion_pipeline.add_pass( + HloPass.AlgebraicSimplifier(algebraic_config_options) + ) + post_fusion_pipeline.add_pass(HloPass.OptimizationBarrierExpander()) + post_fusion_pipeline.add_pass(HloPass.TupleSimplifier()) + + self.post_fusion_optimizations.add_pass(post_fusion_pipeline) + + self.xla_pipeline = Pipeline("xla-pipeline") + self.xla_pipeline.add_pass(self.pre_fusion_optimizations) + self.xla_pipeline.add_pass(self.vert_fusion_pipeline) + self.xla_pipeline.add_pass(self.post_fusion_optimizations) + # ------------------------------------------- + + @property + def pre_pass_optimizations(self): + return self.pre_fusion_optimizations + + @property + def post_pass_optimizations(self): + return self.post_fusion_optimizations + + @property + def pre_dry_pass_passes(self): + return self.fusion_pipeline_pre + + @property + def post_dry_pass_passes(self): + return self.fusion_pipeline_post + + @property + def xla_passes(self): + return self.xla_pipeline + + @property + def pass_dry_run(self): + return self.fusion_dry_pass + + +class GeneralFusionPipeline(SingleFusionPipeline): + + def __init__(self, hlo_ir: HloEnv) -> None: + super(GeneralFusionPipeline, self).__init__(hlo_ir) + + self.fusion_dry_pass = AltPipeline(Pass(HloPass.GeneralFusion(),)) + self.fusion_pipeline_post = Pipeline("post-general-fusion") + # self.fusion_pipeline_post.add_pass(HloPass.GpuMultiOutputFusion()) + self.fusion_pipeline_post.add_pass(HloPass.HloCSE(True, True)) + self.fusion_pipeline_post.add_pass(HloPass.HloDCE()) diff --git a/examples/hlo_play.py b/examples/hlo_play.py new file mode 100644 index 0000000..6caa9d5 --- /dev/null +++ b/examples/hlo_play.py @@ -0,0 +1,83 @@ +# Copyright 2022 Garena Online Private Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# A demo to expose and play all the features (graph, node, edge) +# of a hlo module in python script. +# Usage: python hlo_play.py + +import os +import pathlib +import hloenv +import numpy as np +from hloenv import HloEnv + +if __name__ == '__main__': + os.environ['CUDA_VISIBLE_DEVICES'] = '0' + os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' + + hlo_path = os.path.join( + pathlib.Path(__file__).parent.absolute(), + "hlo_texts/jax-md/module_0013.jit__lambda_.7.before_optimizations.txt" + ) + + hlo_env = HloEnv(hlo_path, "gpu") + + # hlo_graph is the entry point of the features of hlo_env + hlo_graph = hlo_env.get_hlo_graph() + + print("=========graph_features==========") + print(hlo_graph.out_edge_offsets) + print(len(hlo_graph.out_edge_offsets)) + print(hlo_graph.out_edge_indices) + print(len(hlo_graph.out_edge_indices)) + print(hlo_graph.in_edge_offsets) + print(hlo_graph.in_edge_indices) + print(hlo_graph.alternative_indices) + print(hlo_graph.opcode_attr_counts) + print(hlo_graph.hash()) + + node_features = hlo_graph.node_features + in_edge_features = hlo_graph.in_edge_features + out_edge_features = hlo_graph.out_edge_features + + print("=========node_features==========") + print(node_features.uids) + print(node_features.gids) + print(node_features.num_users) + print(node_features.num_operands) + print(node_features.opcodes) + print(node_features.opcode_attrs) + print(node_features.num_opcode_attrs.reshape(-1, 2)) + print(node_features.is_alternative) + print(node_features.in_tensor_sizes) + print(node_features.out_tensor_sizes) + print(node_features.has_max_in_tensor) + print(node_features.has_max_out_tensor) + print(node_features.names) + + print("=========in_edge_features===========") + print(in_edge_features.uids) + print(in_edge_features.srcs) + print(in_edge_features.dsts) + print(in_edge_features.dims.reshape(-1, 8)) + print(in_edge_features.layouts.reshape(-1, 8)) + print(in_edge_features.dtypes) + + print("=========out_edge_features===========") + print(out_edge_features.uids) + print(out_edge_features.srcs) + print(out_edge_features.dsts) + print(np.array(out_edge_features.dims).reshape(-1, 8)) + print(np.array(out_edge_features.layouts).reshape(-1, 8)) + print(out_edge_features.dtypes) diff --git a/examples/hlo_texts/jax-md/module_0013.jit__lambda_.7.before_optimizations.txt b/examples/hlo_texts/jax-md/module_0013.jit__lambda_.7.before_optimizations.txt new file mode 100644 index 0000000..ab0ff65 --- /dev/null +++ b/examples/hlo_texts/jax-md/module_0013.jit__lambda_.7.before_optimizations.txt @@ -0,0 +1,16 @@ +HloModule jit__lambda_.7 + +ENTRY main.12 { + Arg_0.1 = f32[3,3]{1,0} parameter(0) + reshape.4 = f32[1,3,3]{2,1,0} reshape(Arg_0.1) + broadcast.5 = f32[1,3,3]{2,1,0} broadcast(reshape.4), dimensions={0,1,2} + reshape.6 = f32[3,3]{1,0} reshape(broadcast.5) + broadcast.7 = f32[3,3,3]{2,1,0} broadcast(reshape.6), dimensions={1,2} + Arg_1.2 = f32[3,3]{1,0} parameter(1) + reshape.3 = f32[3,1,3]{2,1,0} reshape(Arg_1.2) + broadcast.8 = f32[3,1,3]{2,1,0} broadcast(reshape.3), dimensions={0,1,2} + reshape.9 = f32[3,3]{1,0} reshape(broadcast.8) + broadcast.10 = f32[3,3,3]{2,1,0} broadcast(reshape.9), dimensions={0,2} + ROOT subtract.11 = f32[3,3,3]{2,1,0} subtract(broadcast.7, broadcast.10) +} + diff --git a/examples/hlo_texts/jax-md/module_0029.jit_safe_mask.15.before_optimizations.txt b/examples/hlo_texts/jax-md/module_0029.jit_safe_mask.15.before_optimizations.txt new file mode 100644 index 0000000..68d28d9 --- /dev/null +++ b/examples/hlo_texts/jax-md/module_0029.jit_safe_mask.15.before_optimizations.txt @@ -0,0 +1,29 @@ +HloModule jit_safe_mask.15 + +jit_vmap_vmap__where__.4 { + Arg_0.5 = pred[3,3]{1,0} parameter(0) + Arg_1.6 = f32[3,3]{1,0} parameter(1) + Arg_2.7 = s32[] parameter(2) + convert.8 = f32[] convert(Arg_2.7) + broadcast.9 = f32[3,3]{1,0} broadcast(convert.8), dimensions={} + ROOT select.10 = f32[3,3]{1,0} select(Arg_0.5, Arg_1.6, broadcast.9) +} + +jit_vmap_vmap__where___0.13 { + Arg_0.14 = pred[3,3]{1,0} parameter(0) + Arg_1.15 = f32[3,3]{1,0} parameter(1) + Arg_2.16 = s32[] parameter(2) + convert.17 = f32[] convert(Arg_2.16) + broadcast.18 = f32[3,3]{1,0} broadcast(convert.17), dimensions={} + ROOT select.19 = f32[3,3]{1,0} select(Arg_0.14, Arg_1.15, broadcast.18) +} + +ENTRY main.21 { + Arg_0.1 = pred[3,3]{1,0} parameter(0) + Arg_1.2 = f32[3,3]{1,0} parameter(1) + constant.3 = s32[] constant(0) + call.11 = f32[3,3]{1,0} call(Arg_0.1, Arg_1.2, constant.3), to_apply=jit_vmap_vmap__where__.4 + sqrt.12 = f32[3,3]{1,0} sqrt(call.11) + ROOT call.20 = f32[3,3]{1,0} call(Arg_0.1, sqrt.12, constant.3), to_apply=jit_vmap_vmap__where___0.13 +} + diff --git a/examples/hlo_texts/jax-md/module_0190.jit_safe_mask.61.before_optimizations.txt b/examples/hlo_texts/jax-md/module_0190.jit_safe_mask.61.before_optimizations.txt new file mode 100644 index 0000000..3e80e0a --- /dev/null +++ b/examples/hlo_texts/jax-md/module_0190.jit_safe_mask.61.before_optimizations.txt @@ -0,0 +1,53 @@ +HloModule jit_safe_mask.61 + +jit_jvp__where_.12 { + Arg_0.13 = pred[64,64]{1,0} parameter(0) + Arg_1.14 = f32[64,64]{1,0} parameter(1) + Arg_2.15 = s32[] parameter(2) + convert.18 = f32[] convert(Arg_2.15) + broadcast.19 = f32[64,64]{1,0} broadcast(convert.18), dimensions={} + select.20 = f32[64,64]{1,0} select(Arg_0.13, Arg_1.14, broadcast.19) + constant.16 = f32[] constant(0) + broadcast.17 = f32[64,64]{1,0} broadcast(constant.16), dimensions={} + ROOT tuple.21 = (f32[64,64]{1,0}, pred[64,64]{1,0}, f32[64,64]{1,0}) tuple(select.20, Arg_0.13, broadcast.17) +} + +jit_jvp__where__0.31 { + Arg_0.32 = pred[64,64]{1,0} parameter(0) + Arg_1.33 = f32[64,64]{1,0} parameter(1) + Arg_2.34 = f32[] parameter(2) + broadcast.37 = f32[64,64]{1,0} broadcast(Arg_2.34), dimensions={} + select.38 = f32[64,64]{1,0} select(Arg_0.32, Arg_1.33, broadcast.37) + constant.35 = f32[] constant(0) + broadcast.36 = f32[64,64]{1,0} broadcast(constant.35), dimensions={} + ROOT tuple.39 = (f32[64,64]{1,0}, pred[64,64]{1,0}, f32[64,64]{1,0}) tuple(select.38, Arg_0.32, broadcast.36) +} + +ENTRY main.45 { + Arg_0.1 = pred[64,64]{1,0} parameter(0) + constant.8 = f32[] constant(1) + broadcast.9 = f32[64,64]{1,0} broadcast(constant.8), dimensions={} + Arg_1.2 = f32[64,64]{1,0} parameter(1) + constant.11 = s32[] constant(0) + call.22 = (f32[64,64]{1,0}, pred[64,64]{1,0}, f32[64,64]{1,0}) call(Arg_0.1, Arg_1.2, constant.11), to_apply=jit_jvp__where_.12 + get-tuple-element.23 = f32[64,64]{1,0} get-tuple-element(call.22), index=0 + subtract.26 = f32[64,64]{1,0} subtract(broadcast.9, get-tuple-element.23) + constant.6 = f32[] constant(2) + broadcast.7 = f32[64,64]{1,0} broadcast(constant.6), dimensions={} + power.27 = f32[64,64]{1,0} power(subtract.26, broadcast.7) + constant.4 = f32[] constant(0.5) + broadcast.5 = f32[64,64]{1,0} broadcast(constant.4), dimensions={} + multiply.30 = f32[64,64]{1,0} multiply(power.27, broadcast.5) + Arg_2.3 = f32[] parameter(2) + call.40 = (f32[64,64]{1,0}, pred[64,64]{1,0}, f32[64,64]{1,0}) call(Arg_0.1, multiply.30, Arg_2.3), to_apply=jit_jvp__where__0.31 + get-tuple-element.41 = f32[64,64]{1,0} get-tuple-element(call.40), index=0 + get-tuple-element.42 = pred[64,64]{1,0} get-tuple-element(call.40), index=1 + get-tuple-element.43 = f32[64,64]{1,0} get-tuple-element(call.40), index=2 + constant.10 = f32[] constant(0.5) + power.28 = f32[64,64]{1,0} power(subtract.26, broadcast.9) + multiply.29 = f32[64,64]{1,0} multiply(power.28, broadcast.7) + get-tuple-element.24 = pred[64,64]{1,0} get-tuple-element(call.22), index=1 + get-tuple-element.25 = f32[64,64]{1,0} get-tuple-element(call.22), index=2 + ROOT tuple.44 = (f32[64,64]{1,0}, pred[64,64]{1,0}, f32[64,64]{1,0}, f32[], f32[64,64]{1,0}, /*index=5*/pred[64,64]{1,0}, f32[64,64]{1,0}) tuple(get-tuple-element.41, get-tuple-element.42, get-tuple-element.43, constant.10, multiply.29, get-tuple-element.24, get-tuple-element.25) +} + diff --git a/examples/uniform_policy.py b/examples/uniform_policy.py new file mode 100644 index 0000000..4f1d336 --- /dev/null +++ b/examples/uniform_policy.py @@ -0,0 +1,171 @@ +# Copyright 2022 Garena Online Private Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# A demo of applying uniform policy in a loop of optimization. +# Usage: python uniform_policy.py + +import os +import pathlib +import hloenv +import numpy as np +import tensorflow as tf +from hloenv import AltPipeline, HloEnv, HloPass, Pass, Pipeline +from general_fusion_pipeline import GeneralFusionPipeline +from typing import Tuple + + +def get_ragged_tensor_from_hlo( + hlo_graph +) -> Tuple[tf.RaggedTensor, tf.RaggedTensor]: + """Get the operands and users of each node from the hlo graph. + + Args: + hlo_graph: a hlo graph + + Returns: + a tuple of tf.RaggedTensor indicating the graph structure: + (operands, users) + operands: a dict in the form of raggedtensor, where the key is the node id, + and the value is a list of operand indices. + users: a dict in the form of raggedtensor, where the key is the node id, + and the value is a list of user indices. + """ + + in_edge_features = hlo_graph.in_edge_features + out_edge_features = hlo_graph.out_edge_features + + operands = tf.cast( + tf.RaggedTensor.from_row_splits( + values=in_edge_features.srcs, row_splits=hlo_graph.in_edge_offsets + ), tf.int64 + ) + + users = tf.cast( + tf.RaggedTensor.from_row_splits( + values=out_edge_features.dsts, row_splits=hlo_graph.out_edge_offsets + ), tf.int64 + ) + + return operands, users + + +def uniform_policy(hlo_graph) -> tf.RaggedTensor: + """Produce a uniform policy for the given hlo graph. + + Args: + hlo_graph: the hlo graph + + Returns: + a tf.RaggedTensor with shape [num_alt_idx, None]. The outer dimension + is the alternative index, and the inner dimension is the operand index. + Each row is a list of probability to operand indices for the + corresponding alternative. + """ + # get graph structures + operands, users = get_ragged_tensor_from_hlo(hlo_graph) + # get the indices of kAlternative nodes + alternative_idx = tf.convert_to_tensor(hlo_graph.alternative_indices) + # get the indices of operands for each kAlternative node + alt_oprnd_idx: tf.RaggedTensor = tf.gather(operands, alternative_idx) + + # assign random score to each operand + alt_oprnd_prob = tf.map_fn( + lambda x: tf.random.uniform(shape=x.shape, minval=0, maxval=1), + alt_oprnd_idx, + fn_output_signature=tf.RaggedTensorSpec(shape=[None], dtype=tf.float32) + ) + + return alt_oprnd_prob + + +def argmax_sample(probability: tf.RaggedTensor, hlo_graph) -> tf.Tensor: + """Select the operand with the highest score for each alternative. + + Args: + probability: a tf.RaggedTensor with shape [num_alt_idx, None]. + The outer dimension is the alternative index, and the inner + dimension is the operand index. + + hlo_graph: the hlo graph + + Returns: + a tf.Tensor with shape [num_alt_idx, 2], the 1st column is + the uids of alt_idx, the 2nd column is the operand_idx to be selected. + """ + alt_uids = hlo_graph.node_features.uids[hlo_graph.alternative_indices] + + alt_uids = tf.convert_to_tensor(alt_uids, dtype=tf.int64) + + alt_choice = tf.map_fn( + lambda x: tf.argmax(x, axis=0), + probability, + fn_output_signature=tf.TensorSpec(shape=[], dtype=tf.int64) + ) + + return tf.stack([alt_uids, alt_choice], axis=1) + + +if __name__ == "__main__": + os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' + + hlo_path = os.path.join( + pathlib.Path(__file__).parent.absolute(), + "hlo_texts/jax-md/module_0013.jit__lambda_.7.before_optimizations.txt" + ) + hlo_env = HloEnv(hlo_path, "gpu") + general_fusion_pipeline = GeneralFusionPipeline(hlo_env) + + hlo_env.run(general_fusion_pipeline.pre_pass_optimizations) + + num_alts = 1 + while num_alts > 0: + hlo_env.run(general_fusion_pipeline.pre_dry_pass_passes) + # Open up the action space + hlo_env.run(general_fusion_pipeline.pass_dry_run) + + # Get features from hlo_env + hlo_graph = hlo_env.get_hlo_graph(do_hash_verification=False) + num_alts = len(hlo_graph.alternative_indices) + + if num_alts > 0: + # Obtain a probablity distribution over the action space + probablity = uniform_policy(hlo_graph) + # Sample an action + decisions = argmax_sample(probablity, hlo_graph) + decisions = np.asarray(decisions) + # Apply action to the hlo_env + hlo_env.apply_alternatives(decisions) + hlo_env.run(general_fusion_pipeline.post_dry_pass_passes) + + hlo_env.run(general_fusion_pipeline.post_pass_optimizations) + + # Evaluate the runtime + results = hlo_env.evaluate(100) + timing = min(results.durations) + print(f"Uniform Policy Timing: {timing}") + + # Reload the original hlo graph. + hlo_env = HloEnv(hlo_path, "gpu") + # Run the original hlo_env and evaluate the runtime. + ref_results = hlo_env.evaluate(100) + ref_timing = min(ref_results.durations) + print(f"Reference (Original) Timing: {ref_timing}") + + # Run XLA against the original hlo_env. + hlo_env.optimize_hlo_module() + + # Evaluate the runtime + ref_results = hlo_env.evaluate(100) + ref_timing = min(ref_results.durations) + print(f"Reference (XLA) Timing: {ref_timing}") diff --git a/hloenv/BUILD b/hloenv/BUILD new file mode 100644 index 0000000..f10a9c9 --- /dev/null +++ b/hloenv/BUILD @@ -0,0 +1,148 @@ +# Copyright 2022 Garena Online Private Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +load("@org_tensorflow//tensorflow:tensorflow.bzl", "tf_cc_binary") + +package(default_visibility = ["//visibility:public"]) + +tf_cc_binary( + name = "xla_compile", + srcs = ["xla_compile.cc"], + copts = [ + "-fexceptions", + ], + deps = [ + ":hlo_graph", + "@org_tensorflow//tensorflow/compiler/jit:xla_gpu_jit", + "@org_tensorflow//tensorflow/compiler/xla:literal", + "@org_tensorflow//tensorflow/compiler/xla:literal_util", + "@org_tensorflow//tensorflow/compiler/xla:shape_util", + "@org_tensorflow//tensorflow/compiler/xla:status", + "@org_tensorflow//tensorflow/compiler/xla:statusor", + "@org_tensorflow//tensorflow/compiler/xla/pjrt:cpu_device", + "@org_tensorflow//tensorflow/compiler/xla/pjrt:gpu_device", + "@org_tensorflow//tensorflow/compiler/xla/pjrt:pjrt_client", + "@org_tensorflow//tensorflow/compiler/xla/service:hlo_pass_pipeline", + "@org_tensorflow//tensorflow/compiler/xla/service:hlo_proto_cc", + "@org_tensorflow//tensorflow/compiler/xla/tools:hlo_module_loader", + "@com_github_gflags_gflags//:gflags", + ], +) + +cc_library( + name = "hlo_graph", + srcs = ["hlo_graph.cc"], + hdrs = ["hlo_graph.h"], + deps = [ + "//hloenv/utils:hlo_utils", + "@org_tensorflow//tensorflow/compiler/xla/service:hlo", + "@org_tensorflow//tensorflow/compiler/xla:types", + "@org_tensorflow//tensorflow/compiler/xla:util", + "@org_tensorflow//tensorflow/core:lib", + "@org_tensorflow//tensorflow/core:lib_internal", + "@com_google_absl//absl/base", + "@com_google_absl//absl/container:flat_hash_map", + ], +) + + +cc_library( + name = "hlo_module", + srcs = ["hlo_module.h"], + deps = [ + "//hloenv/utils:hlo_utils", + "@org_tensorflow//tensorflow/compiler/xla/service:hlo", + "@org_tensorflow//tensorflow/compiler/xla/tools:hlo_module_loader", + ], +) + +cc_library( + name = "gpu_backend", + hdrs = ["gpu_backend.h"], + deps = [ + "@org_tensorflow//tensorflow/compiler/xla/service:hlo", + "@org_tensorflow//tensorflow/compiler/xla/pjrt:gpu_device", + "@org_tensorflow//tensorflow/compiler/xla/pjrt:pjrt_client", + "@org_tensorflow//tensorflow/compiler/xla/service:hlo_pass_pipeline", + "@org_tensorflow//tensorflow/compiler/xla/service:hlo_proto_cc", + "@org_tensorflow//tensorflow/compiler/xla/tools:hlo_module_loader", + ], +) + +cc_library( + name = "hlo_pass_defs", + hdrs = ["hlo_pass_defs.h"], + deps = [ + "@org_tensorflow//tensorflow/compiler/jit:xla_gpu_jit", + ], +) + +cc_library( + name = "schedule", + srcs = ["schedule.h"], + deps = [ + ":hlo_module", + "@org_tensorflow//tensorflow/compiler/xla/service:hlo", + "@org_tensorflow//tensorflow/compiler/xla/pjrt:cpu_device", + "@org_tensorflow//tensorflow/compiler/xla/pjrt:gpu_device", + "@org_tensorflow//tensorflow/compiler/xla/pjrt:pjrt_client", + ], +) + +cc_library( + name = "hlo_env", + srcs = ["hlo_env.cc"], + hdrs = ["hlo_env.h"], + deps = [ + ":gpu_backend", + ":hlo_graph", + ":hlo_module", + ":schedule", + "//hloenv/evaluation:evaluator", + "@com_google_absl//absl/hash", + "@org_tensorflow//tensorflow/compiler/jit:xla_cpu_jit", + "@org_tensorflow//tensorflow/compiler/jit:xla_gpu_jit", + "@org_tensorflow//tensorflow/compiler/xla:literal", + "@org_tensorflow//tensorflow/compiler/xla:literal_comparison", + "@org_tensorflow//tensorflow/compiler/xla:literal_util", + "@org_tensorflow//tensorflow/compiler/xla:shape_util", + "@org_tensorflow//tensorflow/compiler/xla:status", + "@org_tensorflow//tensorflow/compiler/xla:statusor", + "@org_tensorflow//tensorflow/compiler/xla/pjrt:cpu_device", + "@org_tensorflow//tensorflow/compiler/xla/pjrt:gpu_device", + "@org_tensorflow//tensorflow/compiler/xla/pjrt:pjrt_client", + "@org_tensorflow//tensorflow/compiler/xla/python:types", + "@org_tensorflow//tensorflow/compiler/xla/service:hlo_pass_pipeline", + "@org_tensorflow//tensorflow/compiler/xla/service:hlo_proto_cc", + "@org_tensorflow//tensorflow/compiler/xla/tools:hlo_module_loader", + # "@org_tensorflow//tensorflow/python:pybind11_lib", + ], +) + +genrule( + name = "gen_extract_subgraphs", + srcs = ["//hloenv/bin:extract_subgraphs"], + outs = ["extract_subgraphs"], + cmd = "cp $< $@ && chmod 755 $@", +) + +py_library( + name = "hloenv", + srcs = ["__init__.py"], + data = [ + "//hloenv/python:py_hlo_env.so", + ":gen_extract_subgraphs", + ], +) + diff --git a/hloenv/__init__.py b/hloenv/__init__.py new file mode 100644 index 0000000..eb12ccb --- /dev/null +++ b/hloenv/__init__.py @@ -0,0 +1,34 @@ +# Copyright 2022 Garena Online Private Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +__version__ = "0.0.1" +from .python.py_hlo_env import HloEnv # noqa F401,F403 +from .python.py_hlo_env import HloModule # noqa F401,F403 +from .python.py_hlo_env import AltPipeline # noqa F401,F403 +from .python.py_hlo_env import Pipeline # noqa F401,F403 +from .python.py_hlo_env import Pass # noqa F401,F403 +from .python.py_hlo_env import GpuBackend # noqa F401,F403 +from .python.py_hlo_env import EvaluationResult # noqa F401,F403 +from .python.py_hlo_env import hlo_pass as HloPass + +__all__ = [ + "HloEnv", + "HloModule", + "AltPipeline", + "Pipeline", + "Pass", + "HloPass", + "GpuBackend", + "EvaluationResult", +] diff --git a/hloenv/bin/BUILD b/hloenv/bin/BUILD new file mode 100644 index 0000000..ff22c74 --- /dev/null +++ b/hloenv/bin/BUILD @@ -0,0 +1,25 @@ +# Copyright 2022 Garena Online Private Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +package(default_visibility = ["//visibility:public"]) + +cc_binary( + name = "extract_subgraphs", + srcs = ["extract_subgraphs.cc"], + deps = [ + "//hloenv/utils:hlo_utils", + "@com_github_gflags_gflags//:gflags", + "@org_tensorflow//tensorflow/compiler/xla/tools:hlo_module_loader", + ], +) diff --git a/hloenv/bin/extract_subgraphs.cc b/hloenv/bin/extract_subgraphs.cc new file mode 100644 index 0000000..d9330d8 --- /dev/null +++ b/hloenv/bin/extract_subgraphs.cc @@ -0,0 +1,126 @@ +// Copyright 2022 Garena Online Private Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include + +#include +#include +#include +#include +#include +#include + +#include "hloenv/utils/hlo_utils.h" +#include "tensorflow/compiler/xla/tools/hlo_module_loader.h" +#include "tensorflow/core/platform/init_main.h" +#include "tensorflow/core/platform/logging.h" + +namespace xla { + +std::vector> ExtractSubgraphs( + const std::unique_ptr& module, int inst_count_lower_bound, + int inst_count_upper_bound) { + std::vector> ret; + if (module->instruction_count() < inst_count_lower_bound) { + return ret; + } + // Select a random instruction in a random computation. + auto comps = module->MakeComputationPostOrder(); + // Pick computation only when its instruction count is large enough. + auto filtered_comps = FilterComputations(comps, [&](HloComputation* c) { + return c->instruction_count() > inst_count_lower_bound; + }); + for (auto comp : filtered_comps) { + LOG(INFO) << "[Computation]: " << comp->name(); + for (auto inst : comp->instructions()) { + int hmin = 1; + int hmax = inst_count_lower_bound; + int h = 1; + while (true) { + auto submodule = ExtractModule(inst, h); + int new_inst_count = submodule->instruction_count(); + // update max & min + if (new_inst_count >= inst_count_lower_bound) { + hmax = h; + } else if (new_inst_count < inst_count_lower_bound) { + hmin = h; + } + // iterate to next + h = (hmin + hmax) / 2; + if (hmax - hmin <= 1) { + auto submodule = ExtractModule(inst, hmax); + int submodule_inst_count = submodule->instruction_count(); + if (submodule_inst_count >= inst_count_lower_bound && + submodule_inst_count < inst_count_upper_bound && + FindInstruction(submodule.get(), HloOpcode::kCall) == nullptr) { + LOG(INFO) << " [Root]: " << inst->name() + << " [Inst Count]: " << submodule_inst_count; + ret.push_back(std::move(submodule)); + } + break; + } + } + } + } + return ret; +} + +} // namespace xla + +template +std::string IntToHex(T i) { + std::stringstream stream; + stream << std::setfill('0') << std::setw(sizeof(T) * 2) << std::hex << i; + return stream.str(); +} + +DEFINE_string(hlo, "-", "hlo text file"); // by default read from stdin +DEFINE_int32(num_inst_lower_bound, 10, "lower bound of the instruction number"); +DEFINE_int32(num_inst_upper_bound, 20, "upper bound of the instruction number"); + +int main(int argc, char** argv) { + tensorflow::port::InitMain("", &argc, &argv); + gflags::ParseCommandLineFlags(&argc, &argv, true); + + // Load HloModule from file. + std::unique_ptr hlo_module; + std::function config_modifier_hook = + [](xla::HloModuleConfig* config) { config->set_seed(42); }; + + if (FLAGS_hlo == "-") { + std::stringstream ss; + std::string s; + while (std::getline(std::cin, s)) { + ss << s << "\n"; + } + hlo_module = LoadModuleFromData(ss.str(), "txt", + xla::hlo_module_loader_details::Config(), + config_modifier_hook) + .ValueOrDie(); + } else { + hlo_module = + LoadModuleFromFile(FLAGS_hlo, xla::hlo_module_loader_details::Config(), + "txt", config_modifier_hook) + .ValueOrDie(); + } + auto vec = xla::ExtractSubgraphs(hlo_module, FLAGS_num_inst_lower_bound, + FLAGS_num_inst_upper_bound); + for (auto& m : vec) { + auto name = IntToHex(absl::HashOf(*m)) + ".txt"; + std::ofstream file; + file.open(name); + file << m->ToString(); + file.close(); + } +} diff --git a/hloenv/evaluation/BUILD b/hloenv/evaluation/BUILD new file mode 100644 index 0000000..9398586 --- /dev/null +++ b/hloenv/evaluation/BUILD @@ -0,0 +1,58 @@ +# Copyright 2022 Garena Online Private Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +load( + "@org_tensorflow//tensorflow:tensorflow.bzl", + "tf_cc_binary", +) + +package(default_visibility = ["//visibility:public"]) + +tf_cc_binary( + name = "main", + srcs = ["main.cc"], + deps = [ + ":evaluator", + "@org_tensorflow//tensorflow/compiler/jit:xla_gpu_jit", + "@org_tensorflow//tensorflow/compiler/xla:literal", + "@org_tensorflow//tensorflow/compiler/xla:literal_util", + "@org_tensorflow//tensorflow/compiler/xla:shape_util", + "@org_tensorflow//tensorflow/compiler/xla:status", + "@org_tensorflow//tensorflow/compiler/xla:statusor", + "@org_tensorflow//tensorflow/compiler/xla/pjrt:cpu_device", + "@org_tensorflow//tensorflow/compiler/xla/pjrt:gpu_device", + "@org_tensorflow//tensorflow/compiler/xla/pjrt:pjrt_client", + "@org_tensorflow//tensorflow/compiler/xla/service:hlo_proto_cc", + "@org_tensorflow//tensorflow/compiler/xla/tools:hlo_module_loader", + "@org_tensorflow//tensorflow/core/platform:logging", + "@org_tensorflow//tensorflow/core/platform:platform_port", + ], +) + +cc_library( + name = "evaluator", + srcs = ["evaluator.cc"], + hdrs = ["evaluator.h"], + linkopts = ["-llapack", "-llapacke", "-lblas"], + deps = [ + "@jax//jaxlib:gpu_kernels", + "@jax//jaxlib:cpu_kernels", + "@org_tensorflow//tensorflow/compiler/xla:literal", + "@org_tensorflow//tensorflow/compiler/xla:literal_util", + "@org_tensorflow//tensorflow/compiler/xla/pjrt:pjrt_client", + "@org_tensorflow//tensorflow/compiler/xla/service:hlo", + ], +) + + diff --git a/hloenv/evaluation/evaluator.cc b/hloenv/evaluation/evaluator.cc new file mode 100644 index 0000000..34b0d05 --- /dev/null +++ b/hloenv/evaluation/evaluator.cc @@ -0,0 +1,165 @@ +// Copyright 2022 Garena Online Private Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "hloenv/evaluation/evaluator.h" + +#include +#include + +#include "tensorflow/compiler/xla/literal_util.h" + +#define NUM_RUNS_IGNORED 3 + +namespace hloenv { +namespace { +xla::Literal CreateRandomLiteral( + const xla::Shape& shape, + const std::function)>& generator) { + switch (shape.element_type()) { + case xla::F32: + return xla::LiteralUtil::CreateLiteralWithGenerator(shape, + generator) + .ValueOrDie(); + case xla::F64: + return xla::LiteralUtil::CreateLiteralWithGenerator(shape, + generator) + .ValueOrDie(); + case xla::TUPLE: { + std::vector tuple; + for (int i = 0; i < shape.tuple_shapes_size(); i++) { + tuple.push_back(CreateRandomLiteral(shape.tuple_shapes(i), generator)); + } + return xla::LiteralUtil::MakeTupleOwned(std::move(tuple)); + } + case xla::F16: { + std::function)> wrap = + [&generator](absl::Span args) { + return static_cast(generator(args)); + }; + return xla::LiteralUtil::CreateLiteralWithGenerator(shape, wrap) + .ValueOrDie(); + } + case xla::BF16: { + std::function)> wrap = + [&generator](absl::Span args) { + return static_cast(generator(args)); + }; + return xla::LiteralUtil::CreateLiteralWithGenerator(shape, + wrap) + .ValueOrDie(); + } + default: + // Zero init + return xla::Literal::CreateFromShape(shape); + } +} +} // namespace + +void Evaluator::Compile(const xla::HloModuleProto& hlo_module_proto, + bool rerun_hlo, xla::PjRtClient* client) { + xla::XlaComputation xla_computation(hlo_module_proto); + xla::CompileOptions compile_options; + if (!rerun_hlo) { + compile_options.executable_build_options.set_run_backend_only(true); + } + auto executable_status = client->Compile(xla_computation, compile_options); + executable_ = std::move(executable_status.ValueOrDie()); + this->GenerateParameters(); +} + +void Evaluator::GenerateParameters(int rand_seed) { + GenerateParametersImpl(*executable_->GetHloModules().ValueOrDie().front(), + rand_seed, executable_->client(), ¶meters_); +} + +void Evaluator::GenerateParametersImpl(const xla::HloModule& hlo_module, + int rand_seed, xla::PjRtClient* client, + BufferPack* parameters) { + parameters->clear(); + std::vector parameter_instructions = + hlo_module.entry_computation()->parameter_instructions(); + // We keep the literals in this pool to keep them alive until all parameters's + // BlockHostUntilReady + std::vector literal_pool; + parameters->emplace_back(); + std::minstd_rand0 engine; + engine.seed(rand_seed); + std::normal_distribution distribution(0.0, 1.0); + std::function)> generator = + [&distribution, &engine](absl::Span) { + return distribution(engine); + }; + for (xla::HloInstruction* parameter : parameter_instructions) { + xla::Shape shape = parameter->shape(); + literal_pool.emplace_back(CreateRandomLiteral(shape, generator)); + LOG(INFO) << "Assumed parameter(" << parameter->name() + << "): " << literal_pool.back().shape().ToString(); + parameters->back().push_back( + client + ->BufferFromHostLiteral(literal_pool.back(), + client->addressable_devices()[0]) + .ValueOrDie()); + } + for (auto& parameter : parameters->back()) { + parameter->BlockHostUntilReady(); + } +} + +Evaluator::EvaluationResult Evaluator::Evaluate(int times) { + if (!executable_) { + LOG(FATAL) << "Please asssign a hlomodule to evaluator first"; + } + EvaluationResult ret; + xla::ExecuteOptions execute_options; + std::vector> parameters; + for (auto& p : parameters_) { + parameters.emplace_back(); + for (auto& pp : p) { + parameters.back().push_back(pp.get()); + } + } + + absl::Time start; + BufferPack result; + for (int i = 0; i < times + NUM_RUNS_IGNORED; i++) { + start = absl::Now(); + // TODO(wanxy): Not sure whether this is async yet + // Might need to make sure the execution is complete after function returns + result = std::move( + executable_->Execute(parameters, execute_options).ValueOrDie()); + + for (auto& p : result) { + for (auto& pp : p) { + pp->BlockHostUntilReady(); + } + } + + if (i >= NUM_RUNS_IGNORED) { + ret.durations.push_back(executable_->async_exec_time_ns); + ret.full_durations.push_back(absl::Now() - start); + ret.compute_durations.push_back(executable_->compute_time_ns); + } + } + + for (auto& p : result) { + ret.output.emplace_back(); + for (auto& pp : p) { + ret.output.back().emplace_back(std::move(pp)); + } + } + ret.memory_consumed = 0; + return ret; +} + +} // namespace hloenv diff --git a/hloenv/evaluation/evaluator.h b/hloenv/evaluation/evaluator.h new file mode 100644 index 0000000..bc0a73d --- /dev/null +++ b/hloenv/evaluation/evaluator.h @@ -0,0 +1,59 @@ +// Copyright 2022 Garena Online Private Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef HLOENV_EVALUATION_EVALUATOR_H_ +#define HLOENV_EVALUATION_EVALUATOR_H_ + +#include +#include + +#include "absl/time/clock.h" +#include "tensorflow/compiler/xla/pjrt/pjrt_client.h" +#include "tensorflow/compiler/xla/service/hlo_module.h" + +namespace hloenv { + +class Evaluator { + public: + Evaluator() = default; + virtual ~Evaluator() = default; + + // Sets and compiles the target HloModule used for evaluation + void Compile(const xla::HloModuleProto& hlo_module_proto, bool rerun_hlo, + xla::PjRtClient* client); + + void GenerateParameters(int rand_seed = 53); + + typedef std::vector>> BufferPack; + struct EvaluationResult { + std::vector durations; + std::vector full_durations; + std::vector compute_durations; + + BufferPack output; + uint64_t memory_consumed; + }; + EvaluationResult Evaluate(int times = 1); + + private: + static void GenerateParametersImpl(const xla::HloModule& hlo_module, + int rand_seed, xla::PjRtClient* client, + BufferPack* parameters); + BufferPack parameters_; + std::unique_ptr executable_; +}; + +} // namespace hloenv + +#endif // HLOENV_EVALUATION_EVALUATOR_H_ diff --git a/hloenv/evaluation/main.cc b/hloenv/evaluation/main.cc new file mode 100644 index 0000000..e114dad --- /dev/null +++ b/hloenv/evaluation/main.cc @@ -0,0 +1,87 @@ +// Copyright 2022 Garena Online Private Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// An example for reading a HloModule from a HloProto file and execute the +// module on PJRT CPU client. +// +// To build a HloModule, +// +// $ python3 jax/tools/jax_to_hlo.py \ +// --fn examples.jax_cpp.prog.fn \ +// --input_shapes '[("x", "f32[2,2]"), ("y", "f32[2,2]")]' \ +// --constants '{"z": 2.0}' \ +// --hlo_text_dest /tmp/fn_hlo.txt \ +// --hlo_proto_dest /tmp/fn_hlo.pb +// +// To load and run the HloModule, +// +// $ bazel build examples/jax_cpp:main --experimental_repo_remote_exec +// --check_visibility=false $ bazel-bin/examples/jax_cpp/main 2021-01-12 +// 15:35:28.316880: I examples/jax_cpp/main.cc:65] result = ( f32[2,2] { +// { 1.5, 1.5 }, +// { 3.5, 3.5 } +// } +// ) + +#include +#include +#include + +#include "hloenv/evaluation/evaluator.h" +#include "tensorflow/compiler/xla/literal.h" +#include "tensorflow/compiler/xla/literal_util.h" +#include "tensorflow/compiler/xla/pjrt/cpu_device.h" +#include "tensorflow/compiler/xla/pjrt/gpu_device.h" +#include "tensorflow/compiler/xla/pjrt/pjrt_client.h" +#include "tensorflow/compiler/xla/status.h" +#include "tensorflow/compiler/xla/statusor.h" +#include "tensorflow/compiler/xla/tools/hlo_module_loader.h" +#include "tensorflow/core/platform/init_main.h" +#include "tensorflow/core/platform/logging.h" +#include "tensorflow/core/util/command_line_flags.h" + +int main(int argc, char** argv) { + std::string hlo_fn; + int times = 1; + bool gpu = false; + bool rerun_hlo = false; + const std::vector flag_list = { + tensorflow::Flag("hlo_fn", &hlo_fn, "HLO filename"), + tensorflow::Flag("times", ×, "Times of running"), + tensorflow::Flag("rerun_hlo", &rerun_hlo, + "Whether to rerun the hlo passes"), + tensorflow::Flag("gpu", &gpu, "Use gpu instead of cpu")}; + const std::string usage = tensorflow::Flags::Usage(argv[0], flag_list); + bool parse_ok = tensorflow::Flags::Parse(&argc, argv, flag_list); + tensorflow::port::InitMain(usage.c_str(), &argc, &argv); + QCHECK(parse_ok && argc == 1) << "\n" << usage; + + QCHECK(!hlo_fn.empty()) << "--hlo_fn is required"; + + std::function config_modifier_hook = + [](xla::HloModuleConfig* config) { config->set_seed(42); }; + std::unique_ptr test_module = + LoadModuleFromFile(hlo_fn, xla::hlo_module_loader_details::Config(), + "txt", config_modifier_hook) + .ValueOrDie(); + hloenv::Evaluator evaluator; + xla::GpuAllocatorConfig gpu_config; + auto client = + gpu ? xla::GetGpuClient(true, gpu_config, nullptr, 0).ValueOrDie() + : xla::GetCpuClient(true).ValueOrDie(); + evaluator.Compile(test_module->ToProto(), rerun_hlo, client.get()); + auto result = evaluator.Evaluate(times); + LOG(INFO) << "run time:" << result.durations << std::endl; + return 0; +} diff --git a/hloenv/gpu_backend.h b/hloenv/gpu_backend.h new file mode 100644 index 0000000..a958073 --- /dev/null +++ b/hloenv/gpu_backend.h @@ -0,0 +1,108 @@ +// Copyright 2022 Garena Online Private Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef HLOENV_GPU_BACKEND_H_ +#define HLOENV_GPU_BACKEND_H_ + +#include +#include +#include + +#include "tensorflow/compiler/xla/pjrt/gpu_device.h" +#include "tensorflow/compiler/xla/pjrt/pjrt_client.h" +#include "tensorflow/compiler/xla/service/gpu/gpu_compiler.h" +#include "tensorflow/compiler/xla/service/hlo_module.h" +#include "tensorflow/compiler/xla/service/hlo_module_config.h" +#include "tensorflow/compiler/xla/tools/hlo_module_loader.h" + +namespace hloenv { + +struct HloEnvGpuBackend { + static HloEnvGpuBackend& Instance() { + static HloEnvGpuBackend s; + return s; + } // instance + + HloEnvGpuBackend(const HloEnvGpuBackend&) = delete; + HloEnvGpuBackend& operator=(const HloEnvGpuBackend&) = delete; + + static xla::PjRtClient* PjRtClient() { return Instance().client.get(); } + static xla::gpu::GpuCompiler* GpuCompiler() { return Instance().compiler; } + static xla::se::StreamExecutor* StreamExecutor() { + return Instance().stream_exec; + } + static xla::se::DeviceMemoryAllocator* DeviceMemoryAllocator() { + return Instance().device_allocator; + } + + // TODO(ohcy): Consider pybinding StreamExec, StreamExec::Platform + // and StreamExec::CudaComputeCapability if more of these hooks are needed. + static const std::string& GetStreamExecPlatform() { + return StreamExecutor()->platform()->Name(); + } + static bool CudaComputeIsAtLeast(int other_major, int other_minor = 0) { + return StreamExecutor() + ->GetDeviceDescription() + .cuda_compute_capability() + .IsAtLeast(other_major, other_minor); + } + + private: + std::unique_ptr client; + xla::gpu::GpuCompiler* compiler; + xla::se::StreamExecutor* stream_exec; + xla::se::DeviceMemoryAllocator* device_allocator; + + HloEnvGpuBackend() { + std::function config_modifier_hook = + [](xla::HloModuleConfig* config) { config->set_seed(42); }; + + // Dummy empty Hlo Module + const std::string dummy_hlo_txt = + "HloModule dummy\nENTRY main.1 {ROOT Arg_0.1 = s32[] parameter(0)}"; + std::unique_ptr dummy_hlo_module = + LoadModuleFromData(dummy_hlo_txt, "txt", + xla::hlo_module_loader_details::Config(), + config_modifier_hook) + .ValueOrDie(); + + xla::GpuAllocatorConfig gpu_allocator_config = xla::GpuAllocatorConfig(); + // TODO(ohcy): Allow user to specify memory_fraction? I feel since + // we only have a single allocator, just leave to defaults for now. + // gpu_allocator_config.memory_fraction = memory_fraction; + // gpu_allocator_config.preallocate = preallocate; + + client = xla::GetGpuClient(/*asynchronous=*/true, gpu_allocator_config, + nullptr, 0) + .ValueOrDie(); + + // Compile XlaComputation to PjRtExecutable. + const xla::HloModuleProto hlo_module_proto = dummy_hlo_module->ToProto(); + xla::XlaComputation xla_computation(hlo_module_proto); + xla::CompileOptions compile_options; + try { + std::unique_ptr executable = + client->Compile(xla_computation, compile_options).ValueOrDie(); + } catch (xla::Intercept& gpu_intercept) { + compiler = gpu_intercept.compiler; + stream_exec = gpu_intercept.stream_exec; + device_allocator = gpu_intercept.options.device_allocator; + } + } + ~HloEnvGpuBackend() {} +}; // struct HloEnvGpuBackend + +} // namespace hloenv + +#endif // HLOENV_GPU_BACKEND_H_ diff --git a/hloenv/hlo_env.cc b/hloenv/hlo_env.cc new file mode 100644 index 0000000..0fd1f7b --- /dev/null +++ b/hloenv/hlo_env.cc @@ -0,0 +1,255 @@ +// Copyright 2022 Garena Online Private Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "hloenv/hlo_env.h" + +namespace hloenv { + +HloEnv::HloEnv(std::shared_ptr py_hlo_module, + const std::string& platform) + : platform_(platform) { + if (platform_ != "gpu") { + LOG(FATAL) << "HloEnv currently only supported for platform == 'cpu'"; + } + alt_hlo_module_ = py_hlo_module; +} + +HloEnv::HloEnv(const std::string& hlo_input, const std::string& format, + const std::string& platform) + : platform_(platform) { + if (platform_ != "gpu") { + LOG(FATAL) << "HloEnv currently only supported for platform == 'cpu'"; + } + alt_hlo_module_ = std::make_shared(hlo_input, format); +} + +bool HloEnv::HasEqualOutputAs(std::shared_ptr other_module, + int times) { + return HasEqualOutput(alt_hlo_module_, other_module, times); +} + +// Callback helper that prints the different literals when they are +// not equal +void OnMiscompare(const xla::LiteralSlice& expected, + const xla::LiteralSlice& actual, + const xla::LiteralSlice& mismatches, + const xla::ShapeIndex& /*shape_index*/) { + LOG(INFO) << "expected: " << xla::ShapeUtil::HumanString(expected.shape()) + << " " << xla::literal_comparison::ToStringTruncated(expected); + LOG(INFO) << "actual: " << xla::ShapeUtil::HumanString(actual.shape()) + << " " << xla::literal_comparison::ToStringTruncated(actual); +} + +bool HloEnv::HasEqualOutput(std::shared_ptr first_module, + std::shared_ptr second_module, + int times) { + if (platform_ == "gpu") { + HloEnvGpuBackend::GpuCompiler()->PrepareHloModuleForIrEmitting( + first_module->hlo_module_ptr()); + HloEnvGpuBackend::GpuCompiler()->PrepareHloModuleForIrEmitting( + second_module->hlo_module_ptr()); + + for (int run = 0; run < times; run++) { + evaluator_.Compile(first_module->hlo_module_ptr()->ToProto(), + /* rerun_hlo = */ false, + HloEnvGpuBackend::PjRtClient()); + auto first_ret = evaluator_.Evaluate(); + Evaluator::BufferPack& first_output = first_ret.output; + + evaluator_.Compile(second_module->hlo_module_ptr()->ToProto(), + /* rerun_hlo = */ false, + HloEnvGpuBackend::PjRtClient()); + auto second_ret = evaluator_.Evaluate(); + Evaluator::BufferPack& second_output = second_ret.output; + + if (first_output.size() != second_output.size()) { + LOG(ERROR) + << "Evaluation output length of compared HloModule is different!"; + return false; + } + + for (int i = 0; i < first_output.size(); i++) { + auto& first_buf_vector = first_output[i]; + auto& second_buf_vector = second_output[i]; + if (first_buf_vector.size() != second_buf_vector.size()) { + LOG(ERROR) << "Evaluation output (internal vector) of compared " + "HloModule length is different!"; + return false; + } + + for (int j = 0; j < first_buf_vector.size(); j++) { + auto first_literal = std::make_shared( + first_buf_vector[j]->on_device_shape()); + auto second_literal = std::make_shared( + second_buf_vector[j]->on_device_shape()); + + first_buf_vector[j]->ToLiteralSync(first_literal.get()); + second_buf_vector[j]->ToLiteralSync(second_literal.get()); + + xla::ErrorSpec error_spec(static_cast(1e-6), + static_cast(1e-6)); + + xla::Status comparison_res = xla::literal_comparison::Near( + /*expected=*/*first_literal, + /*actual=*/*second_literal, + /*error=*/error_spec, + /*detailed_message=*/true, &OnMiscompare); + + return comparison_res.ok(); + } + } + } + return true; + } else if (platform_ == "cpu") { + LOG(FATAL) << "HloEnv currently not enabled for platform == cpu"; + } +} + +HloEnv::EvaluationResult HloEnv::Evaluate(int times, + bool do_not_prep_for_eval) { + HloEnv::EvaluationResult result; + result.durations.reserve(times); + result.full_durations.reserve(times); + result.compute_durations.reserve(times); + + if (platform_ == "gpu") { + if (!do_not_prep_for_eval) { + HloEnvGpuBackend::GpuCompiler()->PrepareHloModuleForIrEmitting( + alt_hlo_module_->hlo_module_ptr()); + } + + evaluator_.Compile(alt_hlo_module_->hlo_module_ptr()->ToProto(), + /* rerun_hlo = */ false, HloEnvGpuBackend::PjRtClient()); + auto ret = evaluator_.Evaluate(times); + + Evaluator::BufferPack& output = ret.output; + + for (auto& pjrt_buf_vector : output) { + result.output.push_back(std::vector()); + for (auto& pjrt_buf_ptr : pjrt_buf_vector) { + std::shared_ptr literal = + pjrt_buf_ptr->ToLiteralSync().ValueOrDie(); + result.output.back().push_back( + std::move(xla::LiteralToPython(literal).ValueOrDie())); + } + } + std::transform(ret.full_durations.begin(), ret.full_durations.end(), + std::back_inserter(result.full_durations), + [](absl::Duration duration) -> uint64_t { + return duration / absl::Nanoseconds(1); + }); + result.durations = ret.durations; + result.compute_durations = ret.compute_durations; + + } else if (platform_ == "cpu") { + LOG(FATAL) << "HloEnv currently not enabled for platform == cpu"; + } + return result; +} + +std::shared_ptr HloEnv::CloneHloModule() { + return alt_hlo_module_->Clone(); +} + +void HloEnv::LoadHloModule(std::shared_ptr saved_hlo_module) { + alt_hlo_module_ = saved_hlo_module; +} + +void HloEnv::LoadHloModule(const std::string& hlo_input, + const std::string& format) { + alt_hlo_module_ = std::make_shared(hlo_input, format); +} + +std::string HloEnv::ExportHloModuleToStr() { + return alt_hlo_module_->ToString(); +} + +void HloEnv::PrepareForEvaluation() { + if (platform_ == "gpu") { + HloEnvGpuBackend::GpuCompiler()->PrepareHloModuleForIrEmitting( + alt_hlo_module_->hlo_module_ptr()); + } else if (platform_ == "cpu") { + LOG(FATAL) << "HloEnv currently not enabled for platform == cpu"; + } +} + +void HloEnv::OriginalOptimizeHloModule() { + if (platform_ == "gpu") { + HloEnvGpuBackend::GpuCompiler()->OptimizeHloModule( + alt_hlo_module_->hlo_module_ptr(), HloEnvGpuBackend::StreamExecutor(), + HloEnvGpuBackend::DeviceMemoryAllocator()); + } else if (platform_ == "cpu") { + LOG(FATAL) << "HloEnv currently not enabled for platform == cpu"; + } +} + +// Returns whether or not the pass is run to completion or has stopped in the +// middle (due to completing a dry_run pass, and needing apply alternatives) +bool HloEnv::Run(std::shared_ptr pass) { + if (platform_ == "gpu") { + return pass->Run(alt_hlo_module_->hlo_module_ptr()); + } else if (platform_ == "cpu") { + LOG(FATAL) << "HloEnv currently not enabled for platform == cpu"; + } +} + +std::shared_ptr HloEnv::GetHloModule() { return alt_hlo_module_; } + +void HloEnv::ApplyAlternatives(py::array_t decisions) { + if (platform_ == "gpu") { + HloGraph hlo_graph = HloGraph(alt_hlo_module_->hlo_module_ptr(), false); + const NodeFeats& node_feats = hlo_graph.get_node_feats(); + + py::buffer_info decisions_buf = decisions.request(); + size_t* decisions_ptr = static_cast(decisions_buf.ptr); + int num_decisions = decisions_buf.shape[0]; + + if (decisions_buf.shape[0] != + hlo_graph.get_alternative_indices_ptr()->size()) { + LOG(FATAL) << "Decisions length != num alternatives length!"; + } + if (decisions_buf.shape[1] != 2) { + LOG(FATAL) << "Incorrect decisions shape!"; + } + + absl::flat_hash_map& uid_to_inst = + hlo_graph.get_uid_to_inst(); + for (size_t decisions_idx = 0; decisions_idx < num_decisions; + decisions_idx++) { + size_t node_uid = decisions_ptr[decisions_idx * 2]; + size_t decision = decisions_ptr[decisions_idx * 2 + 1]; + + xla::HloInstruction* instruction = uid_to_inst.at(node_uid); + + if (instruction->opcode() != xla::HloOpcode::kAlternatives) { + LOG(FATAL) << "Applying alternatives to non-kAlternatives node -> " + << decisions_ptr[decisions_idx * 2] << " -> " + << instruction->name(); + } + static_cast(instruction)->Select(decision); + } + + alt_hlo_module_->hlo_module_ptr()->Prune(); + // Remove unused computations created during fusion + alt_hlo_module_->hlo_module_ptr()->RemoveUnusedComputations(); + alt_hlo_module_->hlo_module_ptr()->Cleanup(); + + } else if (platform_ == "cpu") { + LOG(FATAL) << "HloEnv currently not enabled for platform == cpu"; + } +} + +uint64_t HloEnv::GetHloModuleHash() { return alt_hlo_module_->Hash(); } + +} // namespace hloenv diff --git a/hloenv/hlo_env.h b/hloenv/hlo_env.h new file mode 100644 index 0000000..4098d60 --- /dev/null +++ b/hloenv/hlo_env.h @@ -0,0 +1,117 @@ +// Copyright 2022 Garena Online Private Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef HLOENV_HLO_ENV_H_ +#define HLOENV_HLO_ENV_H_ + +#include +#include +#include +#include +#include +#include +#include + +#include "absl/hash/hash.h" +#include "hloenv/evaluation/evaluator.h" +#include "hloenv/gpu_backend.h" +#include "hloenv/hlo_graph.h" +#include "hloenv/hlo_module.h" +#include "hloenv/schedule.h" +#include "tensorflow/compiler/xla/literal.h" +#include "tensorflow/compiler/xla/literal_comparison.h" +#include "tensorflow/compiler/xla/literal_util.h" +#include "tensorflow/compiler/xla/pjrt/cpu_device.h" +#include "tensorflow/compiler/xla/pjrt/gpu_device.h" +#include "tensorflow/compiler/xla/pjrt/pjrt_client.h" +#include "tensorflow/compiler/xla/python/types.h" +#include "tensorflow/compiler/xla/service/cpu/cpu_compiler.h" +#include "tensorflow/compiler/xla/service/gpu/gpu_compiler.h" +#include "tensorflow/compiler/xla/service/hlo_instructions.h" +#include "tensorflow/compiler/xla/status.h" +#include "tensorflow/compiler/xla/statusor.h" +#include "tensorflow/compiler/xla/tools/hlo_module_loader.h" +#include "tensorflow/core/platform/init_main.h" +#include "tensorflow/core/platform/logging.h" + +namespace hloenv { + +class HloEnv { + public: + struct EvaluationResult { + std::vector durations; + std::vector full_durations; + std::vector compute_durations; + std::vector> output; + }; + + private: + std::shared_ptr alt_hlo_module_; + const std::string platform_; + Evaluator evaluator_; + + public: + // Currently, JAX automatically preallocates 90% of the currently-available + // GPU memory when the first JAX op is run. Setting preallocate to false will + // disable this, though it might result in more allocation overhead and + // memory fragmentation. Conversely, setting it to true may cause out of + // memory errors. + // + // memory_fraction can be used to control the percentage of + // currently available GPU memory that is preallocated. However if preallocat + // is set to false, this parameter will be ignored. + explicit HloEnv(std::shared_ptr, const std::string& platform); + + explicit HloEnv(const std::string& hlo_filepath, const std::string& format, + const std::string& platform); + + explicit HloEnv(const std::string& hlo_filepath, const std::string& platform) + : HloEnv(hlo_filepath, "path", platform) {} + + void Init(bool preallocate, double memory_fraction); + + std::shared_ptr CloneHloModule(); + + void LoadHloModule(std::shared_ptr saved_hlo_module); + + void LoadHloModule(const std::string& hlo_input, const std::string& format); + + std::string ExportHloModuleToStr(); + + void PrepareForEvaluation(); + + EvaluationResult Evaluate(int times, bool do_not_prep_for_eval = false); + + bool HasEqualOutputAs(std::shared_ptr other_module, + int times = 1); + + bool HasEqualOutput(std::shared_ptr first_module, + std::shared_ptr second_module, + int times = 1); + + bool Run(std::shared_ptr pass); + + // TODO(ohcy): Move to utility/AltHloModule + uint64_t GetHloModuleHash(); + + std::shared_ptr GetHloModule(); + + void ApplyAlternatives(py::array_t decisions); + + void OriginalOptimizeHloModule(); +}; + +} // namespace hloenv + +#endif // HLOENV_HLO_ENV_H_ diff --git a/hloenv/hlo_graph.cc b/hloenv/hlo_graph.cc new file mode 100644 index 0000000..6558766 --- /dev/null +++ b/hloenv/hlo_graph.cc @@ -0,0 +1,583 @@ +// Copyright 2022 Garena Online Private Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "hloenv/hlo_graph.h" + +#include +#include + +#include "absl/base/casts.h" +#include "hloenv/utils/hlo_utils.h" +#include "tensorflow/compiler/xla/map_util.h" +#include "tensorflow/compiler/xla/service/hlo_opcode.h" +#include "tensorflow/compiler/xla/types.h" +#include "tensorflow/core/lib/core/status.h" +#include "tensorflow/core/lib/hash/hash.h" +#include "tensorflow/core/platform/types.h" + +namespace hloenv { + +HloGraph::HloGraph(const xla::HloModule* m, bool debug, bool inline_fused_comp, + bool do_hash_verification) + : graph_load_errors_(0), + kNumOpcodes(xla::HloOpcodeCount()), + parent_hlo_module_(const_cast(m)), + uid_(m->unique_id()), + name_(m->name()) { + user_list_offsets_ = std::make_shared>(); + user_list_indices_ = std::make_shared>(); + operand_list_offsets_ = std::make_shared>(); + operand_list_indices_ = std::make_shared>(); + opcode_attr_counts_ = std::make_shared>(); + alternative_indices_ = std::make_shared>(); + + Build(m, debug, inline_fused_comp, do_hash_verification); +} + +void HloGraph::Clear() { + node_feats_.Clear(); + in_edge_feats_.Clear(); + out_edge_feats_.Clear(); + + user_list_offsets_->clear(); + operand_list_offsets_->clear(); + user_list_indices_->clear(); + operand_list_indices_->clear(); + opcode_attr_counts_->clear(); + alternative_indices_->clear(); + + inst_list_.clear(); + uid_to_node_idx_.clear(); + uid_to_inst_.clear(); + in_edge_lists_.clear(); + out_edge_lists_.clear(); + called_comp_lists_.clear(); +} + +void HloGraph::BuildGraphTopology(const xla::HloComputation* c, int gid, + bool is_fusion_comp) { + // build in/out edge lists with toposort order. + int num_group_inst = c->instruction_count(); + float normalized_num_group_inst = 0; + if (gid > 0 && num_group_inst > 0) { + normalized_num_group_inst = 1.0 / num_group_inst; + } + for (auto inst : c->MakeInstructionPostOrder()) { + int uid = inst->unique_id(); + + // add into in edge lists + for (auto operand : inst->unique_operands()) { + size_t op_uid = operand->unique_id(); + in_edge_lists_[uid].push_back(op_uid); + } + + // add into out edge lists + for (auto user : inst->users()) { + size_t user_uid = user->unique_id(); + out_edge_lists_[uid].push_back(user_uid); + } + + inst_list_.push_back(inst); + std::string name = inst->name(); + int opcode = static_cast(inst->opcode()); + // Add to basic node_feats_ + node_feats_.uids->push_back(uid); + node_feats_.names->push_back(name); + node_feats_.gids->push_back(gid); + node_feats_.is_in_fusion->push_back(is_fusion_comp); + node_feats_.opcodes->push_back(opcode); + node_feats_.normalized_num_group_inst->push_back(normalized_num_group_inst); + std::vector opcode_attrs; + std::vector opcode_attr_counts; + GetInstructionAttributesAndCounts(inst, &opcode_attrs, &opcode_attr_counts); + node_feats_.opcode_attrs->insert(node_feats_.opcode_attrs->end(), + opcode_attrs.begin(), opcode_attrs.end()); + node_feats_.num_opcode_attrs->insert(node_feats_.num_opcode_attrs->end(), + opcode_attr_counts.begin(), + opcode_attr_counts.end()); + uid_to_inst_.insert({uid, inst}); + } + + return; +} + +void HloGraph::SetFusedCompId( + const absl::flat_hash_map& comp_id_map) { + int num_nodes = node_feats_.uids->size(); + for (int ii = 0; ii < num_nodes; ++ii) { + int uid = node_feats_.uids->at(ii); + uid_to_node_idx_[uid] = ii; + auto instruction = uid_to_inst_[uid]; + // For fusion instruction, record the computation id of its fused + // computation; For all non-fusion instructions, set their fused_comp_ids to + // zero. + auto called_comps = instruction->called_computations(); + if (!called_comps.empty()) { + for (auto comp : called_comps) { + int comp_id = comp_id_map.at(comp); + called_comp_lists_[ii].push_back(comp_id); + } + } + } +} + +std::vector HloGraph::FindInstIndicesOfFusedComp(int fused_comp_id) { + std::vector indices; + auto gid_vector = node_feats_.gids.get(); + auto it = gid_vector->begin(); + while ((it = std::find_if(it, gid_vector->end(), [&](size_t const& e) { + return e == fused_comp_id; + })) != gid_vector->end()) { + indices.push_back(std::distance(gid_vector->begin(), it)); + it++; + } + return indices; +} + +bool HloGraph::ShouldInline(int inst_idx, xla::HloInstruction* inst) { + return (!called_comp_lists_[inst_idx].empty() && + !(inst->opcode() == xla::HloOpcode::kReduce || + inst->opcode() == xla::HloOpcode::kReduceWindow || + inst->opcode() == xla::HloOpcode::kScatter || + inst->opcode() == xla::HloOpcode::kSelectAndScatter || + inst->opcode() == xla::HloOpcode::kSort)); +} + +void HloGraph::FusedComputationInlining() { + int num_nodes = node_feats_.uids->size(); + for (int ii = 0; ii < num_nodes; ++ii) { + // get fusion instruction's uid and fused computation id it points to. + int uid = node_feats_.uids->at(ii); + auto current_instruction = uid_to_inst_[uid]; + LOG(ERROR) << "considering: " << current_instruction->name(); + int operand_fusion; + if (ShouldInline(ii, current_instruction)) { + for (int fused_comp_id : called_comp_lists_[ii]) { + // If instruction is fusion, we inline the fused computation. + auto instr_indices = FindInstIndicesOfFusedComp(fused_comp_id); + if (node_feats_.normalized_num_group_inst->at(ii) == 0) { + // update fusion node's normalized_num_group_inst to be the same as + // instruction's normalized_num_group_inst in the sub computation. + node_feats_.normalized_num_group_inst->at(ii) = + node_feats_.normalized_num_group_inst->at(instr_indices[1]); + } + for (int idx_instr_indices = 0; + idx_instr_indices < instr_indices.size(); ++idx_instr_indices) { + // Iterate over all instructions in the fused computation. + int fused_comp_uid = + node_feats_.uids->at(instr_indices[idx_instr_indices]); + auto instruction = uid_to_inst_[fused_comp_uid]; + if (instruction->opcode() == xla::HloOpcode::kParameter) { + // param of fused comp instructions, we rewire fusion + // instruction's operand to params inside fused computation + operand_fusion = in_edge_lists_[uid].front(); + in_edge_lists_[uid].erase(in_edge_lists_[uid].begin()); + if (fused_comp_id != called_comp_lists_[ii].back()) { + // if not the last comp, add operand_fusion back as it will be + // needed for the next comp too. + in_edge_lists_[uid].push_back(operand_fusion); + } + in_edge_lists_[fused_comp_uid].push_back(operand_fusion); + // remove fusion instruction from user list of its operand. + auto& operand_oel = out_edge_lists_[operand_fusion]; + if (fused_comp_id == called_comp_lists_[ii].back()) { + operand_oel.erase( + std::remove(operand_oel.begin(), operand_oel.end(), uid), + operand_oel.end()); + } + operand_oel.push_back(fused_comp_uid); + } + if (instruction->IsRoot()) { + // root instruction of fused comp, we set user of fused + // computation root to fusion instruction. + out_edge_lists_[fused_comp_uid].push_back(uid); + in_edge_lists_[uid].push_back(fused_comp_uid); + // For fusion instruction, set their gids to the computation id it + // points to. + node_feats_.gids->at(ii) = + node_feats_.gids->at(instr_indices[idx_instr_indices]); + } + } + } + } + } +} + +bool HloGraph::HasCycleForward_(int idx, std::vector* visited, + std::vector* stack) { + if (!visited->at(idx)) { + visited->at(idx) = true; + stack->at(idx) = true; + + int uid = node_feats_.uids->at(idx); + for (int neighbor_uid : out_edge_lists_[uid]) { + int new_idx = uid_to_node_idx_[neighbor_uid]; + if (!visited->at(new_idx) && HasCycleForward_(new_idx, visited, stack)) { + auto current_instruction = uid_to_inst_[uid]; + auto neighbor_instruction = uid_to_inst_[neighbor_uid]; + LOG(INFO) << "passing cycle between: " << current_instruction->name(); + LOG(INFO) << "and: " << neighbor_instruction->name(); + return true; + } else if (stack->at(new_idx)) { + auto current_instruction = uid_to_inst_[uid]; + auto neighbor_instruction = uid_to_inst_[neighbor_uid]; + LOG(INFO) << "source cycle between: " << current_instruction->name(); + LOG(INFO) << "and: " << neighbor_instruction->name(); + return true; + } + } + } + stack->at(idx) = false; + return false; +} + +bool HloGraph::HasCycleBackward_(int idx, std::vector* visited, + std::vector* stack) { + if (!visited->at(idx)) { + visited->at(idx) = true; + stack->at(idx) = true; + + int uid = node_feats_.uids->at(idx); + for (int neighbor_uid : in_edge_lists_[uid]) { + int new_idx = uid_to_node_idx_[neighbor_uid]; + if (!visited->at(new_idx) && HasCycleBackward_(new_idx, visited, stack)) { + return true; + } else if (stack->at(new_idx)) { + return true; + } + } + } + stack->at(idx) = false; + return false; +} + +bool HloGraph::HasCycle() { + int num_nodes = node_feats_.uids->size(); + std::vector visited(num_nodes, false); + std::vector stack(num_nodes, false); + for (int idx = 0; idx < num_nodes; ++idx) { + if (!visited[idx] && HasCycleForward_(idx, &visited, &stack)) { + return true; + } + } + std::fill(visited.begin(), visited.end(), false); + std::fill(stack.begin(), stack.end(), false); + for (int idx = 0; idx < num_nodes; ++idx) { + if (!visited[idx] && HasCycleBackward_(idx, &visited, &stack)) { + return true; + } + } + return false; +} + +void HloGraph::BuildRaggedTensors( + const absl::flat_hash_map& comp_id_map) { + int num_nodes = node_feats_.uids->size(); + // Resize offsets arrays (need one extra space at the end) + user_list_offsets_->resize(num_nodes + 1); + operand_list_offsets_->resize(num_nodes + 1); + + user_list_offsets_->at(0) = 0; + operand_list_offsets_->at(0) = 0; + for (int i = 1; i <= node_feats_.uids->size(); ++i) { + // build offset arrays + int uid = node_feats_.uids->at(i - 1); + int ucount = (out_edge_lists_.find(uid) == out_edge_lists_.end()) + ? 0 + : out_edge_lists_[uid].size(); + int opcount = (in_edge_lists_.find(uid) == in_edge_lists_.end()) + ? 0 + : in_edge_lists_[uid].size(); + + operand_list_offsets_->at(i) = operand_list_offsets_->at(i - 1) + opcount; + user_list_offsets_->at(i) = user_list_offsets_->at(i - 1) + ucount; + // build indices arrays + if (ucount > 0) { + for (int neighbor_uid : out_edge_lists_[uid]) { + user_list_indices_->push_back(uid_to_node_idx_[neighbor_uid]); + } + } + if (opcount > 0) { + for (int neighbor_uid : in_edge_lists_[uid]) { + operand_list_indices_->push_back(uid_to_node_idx_[neighbor_uid]); + } + } + } +} + +void HloGraph::PrepareFeatures() { + // combines uid of source and destination node into a int64. + auto genuid = [](int src_uid, int dst_uid) -> int64_t { + int64_t suid = absl::bit_cast(src_uid); + int64_t duid = absl::bit_cast(dst_uid); + return (suid << 32) | duid; + }; + + int num_nodes = inst_list_.size(); + node_feats_.has_max_in_tensor->assign(num_nodes, false); + node_feats_.has_max_out_tensor->assign(num_nodes, false); + node_feats_.is_alternative->assign(num_nodes, false); + for (int i = 0; i < num_nodes; ++i) { + size_t user_offset = user_list_offsets_->at(i); + size_t operand_offset = operand_list_offsets_->at(i); + int ucount = user_list_offsets_->at(i + 1) - user_offset; + int opcount = operand_list_offsets_->at(i + 1) - operand_offset; + int cur_uid = node_feats_.uids->at(i); + auto cur_inst = uid_to_inst_[cur_uid]; + + // add to node features + if (cur_inst->opcode() == xla::HloOpcode::kAlternatives) { + node_feats_.is_alternative->at(i) = true; + alternative_indices_->push_back(i); + } + node_feats_.num_users->push_back(ucount); + node_feats_.num_operands->push_back(opcount); + + // add to out edge features + int64_t out_tensor_size = 0; + for (int s = user_offset; s < user_list_offsets_->at(i + 1); ++s) { + int user_node_idx = user_list_indices_->at(s); + int user_uid = node_feats_.uids->at(user_node_idx); + + int64_t euid = genuid(cur_uid, user_uid); + out_edge_feats_.uids->push_back(euid); + uid_to_out_edge_idx_.insert({euid, s}); + out_edge_feats_.srcs->push_back(i); + out_edge_feats_.dsts->push_back(user_node_idx); + int src_gid = node_feats_.gids->at(i); + int dst_gid = node_feats_.gids->at(user_node_idx); + // edge_type: + // outside any fusion, 0 + // inside fusion, 1 + // cross fusion, 2 + uint8_t edge_type = (src_gid == dst_gid) ? ((src_gid == 0) ? 0 : 1) : 2; + out_edge_feats_.types->push_back(edge_type); + // put in shapes, layouts, lehmer codes, and dtypes for cur_inst + xla::Shape shape = cur_inst->shape(); + auto minor_to_major = shape.layout().minor_to_major(); + int dim_size = shape.dimensions_size(); + for (int k = 0; k < 8; ++k) { + if (k < dim_size) { + out_edge_feats_.dims->push_back(shape.dimensions(k)); + out_edge_feats_.layouts->push_back(minor_to_major[k]); + int lehmer = 0; + for (int l = 0; l < k; ++l) { + lehmer += (minor_to_major[l] > minor_to_major[k]); + } + out_edge_feats_.lehmercodes->push_back(lehmer); + } else { + out_edge_feats_.dims->push_back(-1); + out_edge_feats_.layouts->push_back(-1); + out_edge_feats_.lehmercodes->push_back(0); + } + } + out_tensor_size += out_edge_feats_.GetTensorSize(s); + out_edge_feats_.dtypes->push_back(static_cast(shape.element_type())); + } + node_feats_.out_tensor_sizes->push_back(out_tensor_size); + + // add to in edge features + int64_t in_tensor_size = 0; + for (int s = operand_offset; s < operand_list_offsets_->at(i + 1); ++s) { + int operand_node_idx = operand_list_indices_->at(s); + int operand_uid = node_feats_.uids->at(operand_node_idx); + auto operand_inst = uid_to_inst_[operand_uid]; + + int64_t euid = genuid(operand_uid, cur_uid); + in_edge_feats_.uids->push_back(euid); + uid_to_in_edge_idx_.insert({euid, s}); + in_edge_feats_.srcs->push_back(operand_node_idx); + in_edge_feats_.dsts->push_back(i); + int src_gid = node_feats_.gids->at(operand_node_idx); + int dst_gid = node_feats_.gids->at(i); + // edge_type: + // outside any fusion, 0 + // inside fusion, 1 + // cross fusion, 2 + uint8_t edge_type = (src_gid == dst_gid) ? ((src_gid == 0) ? 0 : 1) : 2; + in_edge_feats_.types->push_back(edge_type); + // put in shapes, layouts, and dtypes for operand_inst + xla::Shape shape = operand_inst->shape(); + auto minor_to_major = shape.layout().minor_to_major(); + int dim_size = shape.dimensions_size(); + for (int k = 0; k < 8; ++k) { + if (k < dim_size) { + in_edge_feats_.dims->push_back(shape.dimensions(k)); + in_edge_feats_.layouts->push_back(minor_to_major[k]); + int lehmer = 0; + for (int l = 0; l < k; ++l) { + lehmer += (minor_to_major[l] > minor_to_major[k]); + } + in_edge_feats_.lehmercodes->push_back(lehmer); + } else { + in_edge_feats_.dims->push_back(-1); + in_edge_feats_.layouts->push_back(-1); + in_edge_feats_.lehmercodes->push_back(0); + } + } + in_tensor_size += in_edge_feats_.GetTensorSize(s); + in_edge_feats_.dtypes->push_back(static_cast(shape.element_type())); + } + node_feats_.in_tensor_sizes->push_back(in_tensor_size); + } + auto max_input_tensor_size = std::max_element( + node_feats_.in_tensor_sizes->begin(), node_feats_.in_tensor_sizes->end()); + auto max_output_tensor_size = + std::max_element(node_feats_.out_tensor_sizes->begin(), + node_feats_.out_tensor_sizes->end()); + for (int i = 0; i < num_nodes; ++i) { + if (node_feats_.in_tensor_sizes->at(i) == *max_input_tensor_size) { + node_feats_.has_max_in_tensor->at(i) = true; + } + if (node_feats_.out_tensor_sizes->at(i) == *max_output_tensor_size) { + node_feats_.has_max_out_tensor->at(i) = true; + } + } +} + +bool HloGraph::Build(const xla::HloModule* m, bool debug, + bool inline_fused_comp, bool do_hash_verification) { + parent_hlo_module_ = const_cast(m); + uid_ = m->unique_id(); + name_ = m->name(); + + // Clear to rebuild. + Clear(); + GenOpcodeAttrCounts(); + + // For each sub computation, build its graph topology. + auto post_order_comps = m->MakeComputationPostOrder(); + int gid = 0; + absl::flat_hash_map fused_comp_id_map; + while (!post_order_comps.empty()) { + // We iterate in reverse post order, so remove from the back of the + // vector. + xla::HloComputation* comp = post_order_comps.back(); + post_order_comps.pop_back(); + fused_comp_id_map[comp] = gid; + bool is_fusion = comp->IsFusionComputation(); + BuildGraphTopology(comp, gid++, is_fusion); + } + + // Inline fused computation. + SetFusedCompId(fused_comp_id_map); + if (inline_fused_comp) { + FusedComputationInlining(); + } + + if (debug && HasCycle()) { + LOG(FATAL) << "ERROR: Detected cycles in graph!"; + return false; + } + + // Fill in content of node/edge features. + BuildRaggedTensors(fused_comp_id_map); + PrepareFeatures(); + + // Final touch, add the root_index_ + int entry_root_uid = m->entry_computation()->root_instruction()->unique_id(); + root_index_ = uid_to_node_idx_[entry_root_uid]; + + LOG(INFO) << "HloGraph build finished"; + + // Optionally do hash verification. + if (do_hash_verification) { + uint64_t hlograph_hash = Hash(); + uint64_t hlomodule_hash = parent_hlo_module_->CalledComputationHash(); + // TODO(wangyzh/ohcy) Rewrite the HloGraph::Hash according to the new + // mechanism. + if (hlograph_hash == hlomodule_hash) { + LOG(INFO) << "HloGraph build verified."; + return true; + } else { + LOG(INFO) << "HloGraph hash NOT verified."; + return false; + } + } + + return true; +} + +uint64_t HloGraph::Hash() { + // only consider if cross-computation edges are correctly built. + // Since all operands and users are added properly by calling + // xla::HloInstruction's operands() and users() function. + uint64_t hash_value = absl::HashOf(parent_hlo_module_); + for (int i = 0; i < in_edge_feats_.uids->size(); ++i) { + // add euid of cross computation edge to hash_value + int src = in_edge_feats_.srcs->at(i); + int dst = in_edge_feats_.dsts->at(i); + if (node_feats_.gids->at(src) != node_feats_.gids->at(dst)) { + hash_value = tensorflow::Hash64CombineUnordered( + hash_value, in_edge_feats_.uids->at(i)); + } + } + for (int i = 0; i < out_edge_feats_.uids->size(); ++i) { + // add euid of cross computation edge to hash_value + int src = out_edge_feats_.srcs->at(i); + int dst = out_edge_feats_.dsts->at(i); + if (node_feats_.gids->at(src) != node_feats_.gids->at(dst)) { + hash_value = tensorflow::Hash64CombineUnordered( + hash_value, out_edge_feats_.uids->at(i)); + } + } + return hash_value; +} + +// TODO(wangyzh): Ideally this could be a static member for the HloGraph. +void HloGraph::GenOpcodeAttrCounts() { + opcode_attr_counts_->resize(kNumOpcodes * 2, 0); + auto update_opcode_attr_counts = [&](int idx, int int_count, int enum_count) { + opcode_attr_counts_->at(idx * 2) = int_count; + opcode_attr_counts_->at(idx * 2 + 1) = enum_count; + }; + + update_opcode_attr_counts(static_cast(xla::HloOpcode::kBroadcast), 0, + 6 * 7); + update_opcode_attr_counts(static_cast(xla::HloOpcode::kSetDimensionSize), + 0, 6 * 7); + update_opcode_attr_counts(static_cast(xla::HloOpcode::kConcatenate), 0, + 6 * 7); + update_opcode_attr_counts(static_cast(xla::HloOpcode::kReduce), 0, + 6 * 7); + update_opcode_attr_counts(static_cast(xla::HloOpcode::kReverse), 0, + 6 * 7); + update_opcode_attr_counts(static_cast(xla::HloOpcode::kTranspose), 0, + 6 * 7); + update_opcode_attr_counts(static_cast(xla::HloOpcode::kCompare), 0, + 6 + 4); + update_opcode_attr_counts(static_cast(xla::HloOpcode::kConvolution), 16, + 24 * 7); + update_opcode_attr_counts(static_cast(xla::HloOpcode::kDot), 0, + 24 * 7 + 3); + update_opcode_attr_counts(static_cast(xla::HloOpcode::kDynamicSlice), 6, + 0); + update_opcode_attr_counts(static_cast(xla::HloOpcode::kGather), 7, + 18 * 7 + 2); + update_opcode_attr_counts(static_cast(xla::HloOpcode::kGetTupleElement), + 1, 0); + update_opcode_attr_counts(static_cast(xla::HloOpcode::kIota), 0, 7); + update_opcode_attr_counts(static_cast(xla::HloOpcode::kPad), 18, 0); + update_opcode_attr_counts(static_cast(xla::HloOpcode::kScatter), 1, + 18 * 7 + 2 * 2); + update_opcode_attr_counts(static_cast(xla::HloOpcode::kSlice), 18, 0); + update_opcode_attr_counts(static_cast(xla::HloOpcode::kSort), 0, 7 + 2); + update_opcode_attr_counts(static_cast(xla::HloOpcode::kTriangularSolve), + 0, 2 * 3 + 4); + update_opcode_attr_counts(static_cast(xla::HloOpcode::kCustomCall), 0, + 1 * 13); + return; +} + +} // namespace hloenv diff --git a/hloenv/hlo_graph.h b/hloenv/hlo_graph.h new file mode 100644 index 0000000..9db5202 --- /dev/null +++ b/hloenv/hlo_graph.h @@ -0,0 +1,352 @@ +// Copyright 2021 Garena Online Private Limited + +#ifndef HLOENV_HLO_GRAPH_H_ +#define HLOENV_HLO_GRAPH_H_ + +#include +#include +#include +#include +#include +#include +#include + +#include "absl/container/flat_hash_map.h" +#include "absl/container/flat_hash_set.h" +#include "absl/container/inlined_vector.h" +#include "tensorflow/compiler/xla/service/hlo_computation.h" +#include "tensorflow/compiler/xla/service/hlo_instruction.h" +#include "tensorflow/compiler/xla/service/hlo_module.h" +#include "tensorflow/compiler/xla/service/hlo_opcode.h" + +namespace hloenv { + +// NodeFeatures holds all tensors with #node length +// uids: unique_id of HloInstruction +// names: opcode in string +// gids: sub-computation id HloInstruction belongs to +// fused_comp_ids: called-computation id instruction points to +// 0: not pointing to a called-computation +// other positive integers: fused computation id +// num_users: number of outgoing edges (users and called computations) +// num_operands: number of incoming edges (operands) +// opcodes: enumerator of opcodes in HLO +// opcode_attrs: integers that represent opcode's attributes +// num_opcode_attrs: two consecutive integers represent count +// of integer attrs and count of enumerator attrs. +// is_alternative: whether the node is kAlternative +// is_in_fusion: whether the node is in a fused computation +// in_tensor_sizes: sum of input tensor sizes +// out_tensor_sizes: sum of output tensor sizes +// has_max_in_tensor: if has the largest input tensor size +// has_max_out_tensor: if has the largest output tensor size +// normalized_num_group_inst: computed as 1/#instruction in the group. +struct NodeFeats { + // basic node feats + std::shared_ptr> uids; + std::shared_ptr> names; + std::shared_ptr> gids; + std::shared_ptr> fused_comp_ids; + + // advanced node feats + std::shared_ptr> num_users; + std::shared_ptr> num_operands; + // opcode enum is defined here: + // https://github.com/tensorflow/tensorflow/blob/master/tensorflow/compiler/xla/hlo/ir/hlo_opcode.h#L50 + std::shared_ptr> opcodes; + std::shared_ptr> opcode_attrs; + std::shared_ptr> num_opcode_attrs; + std::shared_ptr> is_alternative; + std::shared_ptr> is_in_fusion; + std::shared_ptr> in_tensor_sizes; + std::shared_ptr> out_tensor_sizes; + std::shared_ptr> has_max_in_tensor; + std::shared_ptr> has_max_out_tensor; + std::shared_ptr> normalized_num_group_inst; + + NodeFeats() { + uids = std::make_shared>(); + names = std::make_shared>(); + gids = std::make_shared>(); + num_users = std::make_shared>(); + num_operands = std::make_shared>(); + opcodes = std::make_shared>(); + opcode_attrs = std::make_shared>(); + num_opcode_attrs = std::make_shared>(); + is_alternative = std::make_shared>(); + is_in_fusion = std::make_shared>(); + in_tensor_sizes = std::make_shared>(); + out_tensor_sizes = std::make_shared>(); + has_max_in_tensor = std::make_shared>(); + has_max_out_tensor = std::make_shared>(); + normalized_num_group_inst = std::make_shared>(); + } + + void Clear() { + uids->clear(); + names->clear(); + gids->clear(); + num_users->clear(); + num_operands->clear(); + opcodes->clear(); + opcode_attrs->clear(); + num_opcode_attrs->clear(); + is_alternative->clear(); + is_in_fusion->clear(); + in_tensor_sizes->clear(); + out_tensor_sizes->clear(); + has_max_in_tensor->clear(); + has_max_out_tensor->clear(); + normalized_num_group_inst->clear(); + } +}; + +// EdgeFeatures holds all tensors with #edge length +// uids: unique_id of both src and dst node. +// srcs: indices of source nodes +// dsts: indices of destination nodes +// dims: a fixed-length (8) array to present tensor shape +// layouts: a fixed-length (8) array to present tensor layout +// lehmercodes: a fixed-length (8) array to present lehmer code of layout +// dtypes: tensor dtype, integer mapping to xla_data primitivetype: +// enum PrimitiveType { +// PRIMITIVE_TYPE_INVALID = 0, +// PRED, +// S8, +// S16, +// S32, +// S64, +// U8, +// U16, +// U32, +// U64, +// F16, +// F32, +// F64, +// TUPLE, +// OPAQUE_TYPE, +// C64, +// BF16, +// TOKEN, +// C128 +// }; +struct EdgeFeats { + std::shared_ptr> uids; + std::shared_ptr> srcs; + std::shared_ptr> dsts; + std::shared_ptr> dims; + std::shared_ptr> layouts; + std::shared_ptr> lehmercodes; + std::shared_ptr> types; + // PrimitiveType as is defined in xla_data.proto. + std::shared_ptr> dtypes; + + EdgeFeats() { + uids = std::make_shared>(); + srcs = std::make_shared>(); + dsts = std::make_shared>(); + dims = std::make_shared>(); + layouts = std::make_shared>(); + lehmercodes = std::make_shared>(); + types = std::make_shared>(); + dtypes = std::make_shared>(); + } + + void Clear() { + uids->clear(); + srcs->clear(); + dsts->clear(); + dims->clear(); + layouts->clear(); + lehmercodes->clear(); + types->clear(); + dtypes->clear(); + } + + int64_t GetTensorSize(size_t idx) { + int64_t res = 1; + for (int i = idx * 8; i < idx * 8 + 8; ++i) { + res *= dims->at(i); + } + return abs(res); + } +}; + +// A class for representing a HLO graph in the module +// To make things simpler, only string, f32, i32, and i64 are allowed as dtype. +class HloGraph { + public: + HloGraph() : kNumOpcodes(xla::HloOpcodeCount()) {} + explicit HloGraph(const xla::HloModule* m, bool debug = false, + bool inline_fused_comp = false, + bool do_hash_verification = false); + + bool Build(const xla::HloModule* m, bool debug = false, + bool inline_fused_comp = false, bool do_hash_verification = false); + + void Clear(); + + uint64_t Hash(); + + // return CSR/CSC + std::shared_ptr> get_out_edge_offsets_ptr() { + return user_list_offsets_; + } + std::shared_ptr> get_out_edge_indices_ptr() { + return user_list_indices_; + } + std::shared_ptr> get_in_edge_offsets_ptr() { + return operand_list_offsets_; + } + std::shared_ptr> get_in_edge_indices_ptr() { + return operand_list_indices_; + } + std::shared_ptr> get_opcode_attr_counts_ptr() { + return opcode_attr_counts_; + } + + // return node features. + const std::vector& get_node_uids() { return *node_feats_.uids; } + const std::vector& get_node_names() { + return *node_feats_.names; + } + const std::vector& get_gids() { return *node_feats_.gids; } + const std::vector& get_user_counts() { return *node_feats_.num_users; } + const std::vector& get_operand_counts() { + return *node_feats_.num_operands; + } + const std::vector& get_opcodes() { return *node_feats_.opcodes; } + const std::vector& get_opcode_attrs() { + return *node_feats_.opcode_attrs; + } + const std::vector& get_num_opcode_attrs() { + return *node_feats_.num_opcode_attrs; + } + + // return edge features. + const std::vector& get_in_edge_uids() { + return *in_edge_feats_.uids; + } + const std::vector& get_in_edge_srcs() { return *in_edge_feats_.srcs; } + const std::vector& get_in_edge_dsts() { return *in_edge_feats_.dsts; } + const std::vector& get_in_edge_dims() { + return *in_edge_feats_.dims; + } + const std::vector& get_in_edge_layouts() { + return *in_edge_feats_.layouts; + } + const std::vector& get_in_edge_lehmercodes() { + return *in_edge_feats_.lehmercodes; + } + const std::vector& get_in_edge_dtypes() { + return *in_edge_feats_.dtypes; + } + + const std::vector& get_out_edge_uids() { + return *out_edge_feats_.uids; + } + const std::vector& get_out_edge_srcs() { return *out_edge_feats_.srcs; } + const std::vector& get_out_edge_dsts() { return *out_edge_feats_.dsts; } + const std::vector& get_out_edge_dims() { + return *out_edge_feats_.dims; + } + const std::vector& get_out_edge_layouts() { + return *out_edge_feats_.layouts; + } + const std::vector& get_out_edge_lehmercodes() { + return *out_edge_feats_.lehmercodes; + } + const std::vector& get_out_edge_dtypes() { + return *out_edge_feats_.dtypes; + } + + const NodeFeats& get_node_feats() { return node_feats_; } + const EdgeFeats& get_in_edge_feats() { return in_edge_feats_; } + const EdgeFeats& get_out_edge_feats() { return out_edge_feats_; } + + std::shared_ptr> get_alternative_indices_ptr() { + return alternative_indices_; + } + absl::flat_hash_map& get_uid_to_inst() { + return uid_to_inst_; + } + + protected: + // For each computation, build in/out edge lists for all instructions. + void BuildGraphTopology(const xla::HloComputation* c, int gid, + bool is_fusion_comp); + + // Inlining all fused computations into entry computation. + void FusedComputationInlining(); + + // Fill content of each in/out edge lists according to topology. + void BuildRaggedTensors( + const absl::flat_hash_map& comp_id_map); + + // Fill the rest of contents in node/edge features. + void PrepareFeatures(); + + int graph_load_errors_; + + private: + // Internal function call to set fused_comp_ids for each instruction. + void SetFusedCompId( + const absl::flat_hash_map& comp_id_map); + + // Internal function that returns indices of instructions from one specific + // fused computation. + std::vector FindInstIndicesOfFusedComp(int fused_comp_id); + + // Internal function that generate attribute count for each opcode. + void GenOpcodeAttrCounts(); + + bool HasCycleForward_(int idx, std::vector* visited, + std::vector* stack); + bool HasCycleBackward_(int idx, std::vector* visited, + std::vector* stack); + + bool HasCycle(); + + bool ShouldInline(int inst_idx, xla::HloInstruction* inst); + + const int kNumOpcodes; + xla::HloModule* parent_hlo_module_; + int uid_; + std::string name_; + + std::vector inst_list_; + absl::flat_hash_map> in_edge_lists_; + absl::flat_hash_map> out_edge_lists_; + absl::flat_hash_map> called_comp_lists_; + + // Ignore control deps for now + // utility to lookup node and its neighbor + absl::flat_hash_map uid_to_node_idx_; + absl::flat_hash_map uid_to_inst_; + absl::flat_hash_map uid_to_in_edge_idx_; + absl::flat_hash_map uid_to_out_edge_idx_; + + // Use CSR to represent graph (and CSC inverse graph) topology + std::shared_ptr> user_list_offsets_; + std::shared_ptr> user_list_indices_; + std::shared_ptr> operand_list_offsets_; + std::shared_ptr> operand_list_indices_; + std::shared_ptr> opcode_attr_counts_; + + // Indices of alternative nodes + std::shared_ptr> alternative_indices_; + + // index of root instruction of entry computation + int root_index_; + + // Node features + NodeFeats node_feats_; + + // Edge features + EdgeFeats in_edge_feats_; + EdgeFeats out_edge_feats_; +}; + +} // namespace hloenv + +#endif // HLOENV_HLO_GRAPH_H_ diff --git a/hloenv/hlo_module.h b/hloenv/hlo_module.h new file mode 100644 index 0000000..334a3d1 --- /dev/null +++ b/hloenv/hlo_module.h @@ -0,0 +1,147 @@ +// Copyright 2022 Garena Online Private Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef HLOENV_HLO_MODULE_H_ +#define HLOENV_HLO_MODULE_H_ + +#include + +#include +#include +#include +#include + +#include "hloenv/utils/hlo_utils.h" +#include "tensorflow/compiler/xla/service/hlo_cost_analysis.h" +#include "tensorflow/compiler/xla/service/hlo_module.h" +#include "tensorflow/compiler/xla/service/hlo_module_config.h" +#include "tensorflow/compiler/xla/tools/hlo_module_loader.h" + +namespace py = pybind11; + +namespace hloenv { + +class AltHloModule { + public: + explicit AltHloModule(std::unique_ptr hlo_module) { + hlo_module_ = std::move(hlo_module); + } + + explicit AltHloModule(const std::string& input, + const std::string& format = "path") { + std::function config_modifier_hook = + [](xla::HloModuleConfig* config) { config->set_seed(42); }; + + if (format == "path") { + hlo_module_ = std::move( + LoadModuleFromFile(input, xla::hlo_module_loader_details::Config(), + "txt", config_modifier_hook) + .ValueOrDie()); + } else if (format == "txt") { + hlo_module_ = + std::move(LoadModuleFromData(input, format, + xla::hlo_module_loader_details::Config(), + config_modifier_hook) + .ValueOrDie()); + } else { + LOG(FATAL) << "Unrecognized HloModule format, use 'path' or 'txt'."; + } + } + + explicit AltHloModule(AltHloModule&& other) { + hlo_module_ = std::move(other.hlo_module_); + } + AltHloModule& operator=(AltHloModule&& other) { + if (this != &other) { + hlo_module_ = std::move(other.hlo_module_); + } + return *this; + } + + virtual ~AltHloModule() {} + + xla::HloModule* hlo_module_ptr() { return hlo_module_.get(); } + + std::shared_ptr Clone() { + std::unique_ptr saved_hlo_module = std::move(hlo_module_); + hlo_module_ = std::move(saved_hlo_module->Clone()); + return std::make_shared(std::move(saved_hlo_module)); + } + + std::string ToString() { return hlo_module_->ToString(); } + + uint64_t Hash() { return xla::HloModuleHash(hlo_module_.get()); } + + std::shared_ptr ExtractRandomSubmodule( + int instruction_count_threshold, int height) { + auto returned_submodule = xla::ExtractRandomSubmodule( + hlo_module_, instruction_count_threshold, height); + return returned_submodule == nullptr + ? nullptr + : std::make_shared(std::move(returned_submodule)); + } + + // TODO(wanxy): Might need a better reprensentation for HloInstruction besides + // serialized string + std::vector>> + ExtractInstructionsAsModule(int repeat = 1000) { + std::vector>> ret; + for (auto& ins : xla::ExtractInstructionsAsModule(*hlo_module_, repeat)) { + ret.emplace_back(std::make_pair( + ins.first->ToString(), + std::make_shared(std::move(ins.second)))); + } + return ret; + } + + std::vector> ExtractFusionsAsModule( + int repeat = 1000) { + std::vector> ret; + for (auto& module : xla::ExtractFusionsAsModule(*hlo_module_, repeat)) { + ret.emplace_back(std::make_shared(std::move(module))); + } + return ret; + } + + xla::HloModuleProto ToProto() { return hlo_module_->ToProto(); } + + bool IsBefEnabled() { return xla::gpu::IsBefEnabled(hlo_module_->config()); } + + const xla::HloModuleConfig& config() const { return hlo_module_->config(); } + + void SetHloProfiling(bool enabled) { + xla::HloModuleConfig& hlo_module_config = hlo_module_->config(); + xla::DebugOptions options = xla::GetDebugOptionsFromFlags(); + options.set_xla_hlo_profile(enabled); + hlo_module_config.set_debug_options(options); + } + + xla::HloCostAnalysis::Properties CostAnalysis() { + auto analysis = + HloEnvGpuBackend::PjRtClient()->GetHloCostAnalysis().ValueOrDie(); + hlo_module_->entry_computation()->Accept(analysis.get()); + return analysis->properties(); + } + + int64_t InstructionCount() { return hlo_module_->instruction_count(); } + + int64_t ComputationCount() { return hlo_module_->computation_count(); } + + private: + std::unique_ptr hlo_module_; +}; + +} // namespace hloenv + +#endif // HLOENV_HLO_MODULE_H_ diff --git a/hloenv/hlo_pass_defs.h b/hloenv/hlo_pass_defs.h new file mode 100644 index 0000000..49553a4 --- /dev/null +++ b/hloenv/hlo_pass_defs.h @@ -0,0 +1,182 @@ +// Copyright 2022 Garena Online Private Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef HLOENV_HLO_PASS_DEFS_H_ +#define HLOENV_HLO_PASS_DEFS_H_ + +// ------------------------------------- +// GPU PASSES +// ------------------------------------- +#include "tensorflow/compiler/xla/service/algebraic_simplifier.h" +#include "tensorflow/compiler/xla/service/all_gather_broadcast_reorder.h" +#include "tensorflow/compiler/xla/service/all_gather_combiner.h" +#include "tensorflow/compiler/xla/service/all_reduce_combiner.h" +#include "tensorflow/compiler/xla/service/all_reduce_contiguous.h" +#include "tensorflow/compiler/xla/service/all_reduce_folder.h" +#include "tensorflow/compiler/xla/service/all_reduce_reassociate.h" +#include "tensorflow/compiler/xla/service/all_to_all_decomposer.h" +#include "tensorflow/compiler/xla/service/async_collective_creator.h" +#include "tensorflow/compiler/xla/service/batchnorm_expander.h" +#include "tensorflow/compiler/xla/service/bfloat16_normalization.h" +#include "tensorflow/compiler/xla/service/bitcast_dtypes_expander.h" +#include "tensorflow/compiler/xla/service/call_inliner.h" +#include "tensorflow/compiler/xla/service/collectives_schedule_linearizer.h" +#include "tensorflow/compiler/xla/service/comparison_expander.h" +#include "tensorflow/compiler/xla/service/conditional_canonicalizer.h" +#include "tensorflow/compiler/xla/service/conditional_simplifier.h" +#include "tensorflow/compiler/xla/service/convolution_4d_expander.h" +#include "tensorflow/compiler/xla/service/dot_decomposer.h" +#include "tensorflow/compiler/xla/service/dot_merger.h" +#include "tensorflow/compiler/xla/service/dynamic_dimension_simplifier.h" +#include "tensorflow/compiler/xla/service/dynamic_index_splitter.h" +#include "tensorflow/compiler/xla/service/dynamic_padder.h" +#include "tensorflow/compiler/xla/service/eigh_expander.h" +#include "tensorflow/compiler/xla/service/flatten_call_graph.h" +#include "tensorflow/compiler/xla/service/gather_expander.h" +#include "tensorflow/compiler/xla/service/gpu/all_reduce_blueconnect.h" +#include "tensorflow/compiler/xla/service/gpu/cublas_pad_for_gemms.h" +#include "tensorflow/compiler/xla/service/gpu/cudnn_fused_conv_rewriter.h" +#include "tensorflow/compiler/xla/service/gpu/cudnn_pad_for_convolutions.h" +#include "tensorflow/compiler/xla/service/gpu/cudnn_vectorize_convolutions.h" +#include "tensorflow/compiler/xla/service/gpu/cusolver_rewriter.h" +#include "tensorflow/compiler/xla/service/gpu/fusion_bitcast_lift.h" +#include "tensorflow/compiler/xla/service/gpu/fusion_merger.h" +#include "tensorflow/compiler/xla/service/gpu/gemm_algorithm_picker.h" +#include "tensorflow/compiler/xla/service/gpu/gemm_broadcast_folding_rewriter.h" +#include "tensorflow/compiler/xla/service/gpu/gemm_rewriter.h" +#include "tensorflow/compiler/xla/service/gpu/general_fusion.h" +#include "tensorflow/compiler/xla/service/gpu/gpu_conv_algorithm_picker.h" +#include "tensorflow/compiler/xla/service/gpu/gpu_conv_padding_legalization.h" +#include "tensorflow/compiler/xla/service/gpu/gpu_conv_rewriter.h" +#include "tensorflow/compiler/xla/service/gpu/gpu_layout_assignment.h" +#include "tensorflow/compiler/xla/service/gpu/gpu_reduce_scatter_creator.h" +#include "tensorflow/compiler/xla/service/gpu/gpu_scatter_expander.h" +#include "tensorflow/compiler/xla/service/gpu/horizontal_input_fusion.h" +#include "tensorflow/compiler/xla/service/gpu/horizontal_loop_fusion.h" +#include "tensorflow/compiler/xla/service/gpu/instruction_fusion.h" +#include "tensorflow/compiler/xla/service/gpu/multi_output_fusion.h" +#include "tensorflow/compiler/xla/service/gpu/reduction_degenerate_dim_remover.h" +#include "tensorflow/compiler/xla/service/gpu/reduction_dimension_grouper.h" +#include "tensorflow/compiler/xla/service/gpu/reduction_layout_normalizer.h" +#include "tensorflow/compiler/xla/service/gpu/reduction_splitter.h" +#include "tensorflow/compiler/xla/service/gpu/tree_reduction_rewriter.h" +#include "tensorflow/compiler/xla/service/gpu/triangular_solve_rewriter.h" +#include "tensorflow/compiler/xla/service/gpu/variadic_op_splitter.h" +#include "tensorflow/compiler/xla/service/hlo_constant_folding.h" +#include "tensorflow/compiler/xla/service/hlo_cse.h" +#include "tensorflow/compiler/xla/service/hlo_dce.h" +#include "tensorflow/compiler/xla/service/hlo_verifier.h" +#include "tensorflow/compiler/xla/service/logistic_expander.h" +#include "tensorflow/compiler/xla/service/operand_upcaster.h" +#include "tensorflow/compiler/xla/service/optimization_barrier_expander.h" +#include "tensorflow/compiler/xla/service/qr_expander.h" +#include "tensorflow/compiler/xla/service/real_imag_expander.h" +#include "tensorflow/compiler/xla/service/reduce_scatter_combiner.h" +#include "tensorflow/compiler/xla/service/reshape_mover.h" +#include "tensorflow/compiler/xla/service/result_caster.h" +#include "tensorflow/compiler/xla/service/rng_bit_generator_expander.h" +#include "tensorflow/compiler/xla/service/rng_expander.h" +#include "tensorflow/compiler/xla/service/scatter_expander.h" +#include "tensorflow/compiler/xla/service/sharding_propagation.h" +#include "tensorflow/compiler/xla/service/sharding_remover.h" +#include "tensorflow/compiler/xla/service/slice_sinker.h" +#include "tensorflow/compiler/xla/service/sort_simplifier.h" +#include "tensorflow/compiler/xla/service/spmd/stateful_rng_spmd_partitioner.h" +#include "tensorflow/compiler/xla/service/stable_sort_expander.h" +#include "tensorflow/compiler/xla/service/transpose_folding.h" +#include "tensorflow/compiler/xla/service/tuple_simplifier.h" +#include "tensorflow/compiler/xla/service/while_loop_constant_sinking.h" +#include "tensorflow/compiler/xla/service/while_loop_simplifier.h" +#include "tensorflow/compiler/xla/service/while_loop_trip_count_annotator.h" +#include "tensorflow/compiler/xla/service/zero_sized_hlo_elimination.h" + +// // ------------------------------------- +// // OTHERS - ARG INCLUDES +// // ------------------------------------- +// #include "tensorflow/compiler/xla/service/all_gather_decomposer.h" +// #include "tensorflow/compiler/xla/service/all_reduce_simplifier.h" +// #include "tensorflow/compiler/xla/service/ar_crs_combiner.h" +// #include "tensorflow/compiler/xla/service/bfloat16_propagation.h" +// #include "tensorflow/compiler/xla/service/conditional_code_motion.h" +// #include "tensorflow/compiler/xla/service/convolution_group_converter.h" +// #include "tensorflow/compiler/xla/service/copy_insertion.h" +// #include "tensorflow/compiler/xla/service/hlo_domain_isolator.h" +// #include "tensorflow/compiler/xla/service/hlo_domain_remover.h" +// #include "tensorflow/compiler/xla/service/hlo_domain_verifier.h" +// #include "tensorflow/compiler/xla/service/hlo_element_type_converter.h" +// #include "tensorflow/compiler/xla/service/hlo_memory_scheduler.h" +// #include "tensorflow/compiler/xla/service/hlo_rematerialization.h" +// #include "tensorflow/compiler/xla/service/instruction_fusion.h" +// #include "tensorflow/compiler/xla/service/layout_assignment.h" +// #include "tensorflow/compiler/xla/service/layout_assignment_test.cc" +// #include "tensorflow/compiler/xla/service/cpu/cpu_layout_assignment.h" +// #include "tensorflow/compiler/xla/service/triangular_solve_expander.h" +// #include "tensorflow/compiler/xla/service/space_to_batch_converter.h" +// #include "tensorflow/compiler/xla/service/topk_rewriter.h" +// #include "tensorflow/compiler/xla/service/tree_reduction_rewriter.h" +// #include "tensorflow/compiler/xla/service/while_loop_concat_code_motion.h" +// #include +// "tensorflow/compiler/xla/service/while_loop_expensive_invariant_code_motion.h" +// #include "tensorflow/compiler/xla/service/while_loop_invariant_code_motion.h" +// #include "tensorflow/compiler/xla/service/cpu/conv_canonicalization.h" +// #include "tensorflow/compiler/xla/service/cpu/parallel_task_assignment.h" +// #include +// "tensorflow/compiler/xla/service/spmd/schedule_aware_collective_ops_cse.h" +// #include "tensorflow/compiler/xla/service/spmd/spmd_partitioner.h" +// // ------------------------------------- +// // OTHERS - EMPTY INCLUDES +// // ------------------------------------- +// #include "tensorflow/compiler/xla/service/all_gather_decomposer.h" +// #include "tensorflow/compiler/xla/service/batch_dot_simplification.h" +// #include "tensorflow/compiler/xla/service/bfloat16_conversion_folding.h" +// #include "tensorflow/compiler/xla/service/bfloat16_normalization.h" +// #include "tensorflow/compiler/xla/service/conditional_to_select.h" +// #include "tensorflow/compiler/xla/service/copy_insertion.h" +// #include "tensorflow/compiler/xla/service/defuser.h" +// #include "tensorflow/compiler/xla/service/despecializer.h" +// #include "tensorflow/compiler/xla/service/despecializer.h" +// #include "tensorflow/compiler/xla/service/dry_mode.h" +// #include "tensorflow/compiler/xla/service/dry_mode.h" +// #include "tensorflow/compiler/xla/service/hlo_get_dimension_size_rewriter.h" +// #include "tensorflow/compiler/xla/service/hlo_memory_scheduler.h" +// #include "tensorflow/compiler/xla/service/hlo_memory_scheduler.h" +// #include "tensorflow/compiler/xla/service/hlo_module_dce.h" +// #include "tensorflow/compiler/xla/service/hlo_pass_pipeline_test.cc" +// #include "tensorflow/compiler/xla/service/hlo_pass_pipeline_test.cc" +// #include "tensorflow/compiler/xla/service/hlo_subcomputation_unification.h" +// #include "tensorflow/compiler/xla/service/indexed_array_analysis.h" +// #include "tensorflow/compiler/xla/service/cpu/cpu_instruction_fusion.h" +// #include "tensorflow/compiler/xla/service/instruction_fusion_test.cc" +// #include "tensorflow/compiler/xla/service/loop_schedule_linearizer.h" +// #include "tensorflow/compiler/xla/service/map_inliner.h" +// #include "tensorflow/compiler/xla/service/memory_space_propagation.h" +// #include "tensorflow/compiler/xla/service/multi_output_fusion.h" +// #include "tensorflow/compiler/xla/service/op_expander_pass.h" +// #include "tensorflow/compiler/xla/service/cholesky_expander.h" +// #include "tensorflow/compiler/xla/service/convert_operand_folding.h" +// #include "tensorflow/compiler/xla/service/triangular_solve_expander.h" +// #include +// "tensorflow/compiler/xla/service/optimize_input_output_buffer_alias.h" +// #include "tensorflow/compiler/xla/service/reduce_scatter_decomposer.h" +// #include "tensorflow/compiler/xla/service/root_instruction_sinker.h" +// #include "tensorflow/compiler/xla/service/tree_reduction_rewriter.h" +// #include +// "tensorflow/compiler/xla/service/while_loop_all_reduce_code_motion.h" +// #include "tensorflow/compiler/xla/service/while_loop_invariant_code_motion.h" +// #include "tensorflow/compiler/xla/service/gpu/alias_passthrough_params.h" +// #include "tensorflow/compiler/xla/service/gpu/gpu_sanitize_constant_names.h" +// #include +// "tensorflow/compiler/xla/service/spmd/canonicalize_all_gather_for_cse.h" + +#endif // HLOENV_HLO_PASS_DEFS_H_ diff --git a/hloenv/pip.bzl b/hloenv/pip.bzl new file mode 100644 index 0000000..8ef450d --- /dev/null +++ b/hloenv/pip.bzl @@ -0,0 +1,28 @@ +# Copyright 2022 Garena Online Private Limited +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""HloEnv pip requirements initialization, this is loaded in WORKSPACE.""" + +load("@rules_python//python:pip.bzl", "pip_install") + +def workspace(): + """Configure pip requirements.""" + + if "pip_requirements" not in native.existing_rules().keys(): + pip_install( + name = "pip_requirements", + python_interpreter = "python3", + quiet = False, + requirements = "//third_party/pip_requirements:requirements.txt", + ) diff --git a/hloenv/python/BUILD b/hloenv/python/BUILD new file mode 100644 index 0000000..dc2c588 --- /dev/null +++ b/hloenv/python/BUILD @@ -0,0 +1,54 @@ +# Copyright 2022 Garena Online Private Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +load("@org_tensorflow//tensorflow:tensorflow.bzl", "pybind_extension") +load("@pybind11_bazel//:build_defs.bzl", "pybind_library") + +pybind_library( + name = "py_hlo_graph", + srcs = ["py_hlo_graph.h"], + deps = [ + "//hloenv:hlo_graph", + ], +) + +pybind_library( + name = "py_hlo_pass", + srcs = ["py_hlo_passes.cc"], + hdrs = ["py_hlo_passes.h"], + deps = [ + "//hloenv:gpu_backend", + "//hloenv:hlo_module", + "//hloenv:hlo_pass_defs", + ], +) + +pybind_extension( + name = "py_hlo_env", + srcs = ["py_hlo_env.cc"], + hdrs = ["py_hlo_env.h"], + copts = [ + "-fexceptions", + ], + link_in_framework = False, + linkopts = [ + ], + module_name = "py_hlo_env", + visibility = ["//visibility:public"], + deps = [ + ":py_hlo_graph", + ":py_hlo_pass", + "//hloenv:hlo_env", + ], +) diff --git a/hloenv/python/__init__.py b/hloenv/python/__init__.py new file mode 100644 index 0000000..0e30793 --- /dev/null +++ b/hloenv/python/__init__.py @@ -0,0 +1,13 @@ +# Copyright 2022 Garena Online Private Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. diff --git a/hloenv/python/py_hlo_env.cc b/hloenv/python/py_hlo_env.cc new file mode 100644 index 0000000..cfd08b0 --- /dev/null +++ b/hloenv/python/py_hlo_env.cc @@ -0,0 +1,493 @@ +// Copyright 2022 Garena Online Private Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "hloenv/python/py_hlo_env.h" + +namespace hloenv { + +PYBIND11_MODULE(py_hlo_env, m) { + // TODO(ohcy) Change PyHloGraph and PyHloEnv names to remove the Py prefix + py::class_ py_hlo_graph( + m, "HloGraph", + "The graph representation of a HloModule the describes its structure and " + "individual instructions features. See :ref:`Playing with HLO graph " + "features` for more details."); + + py_hlo_graph.def(py::init()) + .def("hash", &PyHloGraph::py_hash) + .def("get_graph_load_errors", &PyHloGraph::py_get_graph_load_errors) + .DEF_PYBIND_READONLY(PyHloGraph, out_edge_offsets) + .DEF_PYBIND_READONLY(PyHloGraph, out_edge_indices) + .DEF_PYBIND_READONLY(PyHloGraph, in_edge_offsets) + .DEF_PYBIND_READONLY(PyHloGraph, in_edge_indices) + .DEF_PYBIND_READONLY(PyHloGraph, alternative_indices) + .DEF_PYBIND_READONLY(PyHloGraph, opcode_attr_counts) + .DEF_PYBIND_READONLY(PyHloGraph, node_features) + .DEF_PYBIND_READONLY(PyHloGraph, in_edge_features) + .DEF_PYBIND_READONLY(PyHloGraph, out_edge_features); + + // TODO(ohcy): write this without copy as nparray + py::class_(m, "NodeFeats") + .DEF_PYBIND_READONLY(PyNodeFeats, uids) + .DEF_PYBIND_READONLY(PyNodeFeats, names) + .DEF_PYBIND_READONLY(PyNodeFeats, gids) + .DEF_PYBIND_READONLY(PyNodeFeats, fused_comp_ids) + .DEF_PYBIND_READONLY(PyNodeFeats, num_users) + .DEF_PYBIND_READONLY(PyNodeFeats, num_operands) + .DEF_PYBIND_READONLY(PyNodeFeats, opcodes) + .DEF_PYBIND_READONLY(PyNodeFeats, opcode_attrs) + .DEF_PYBIND_READONLY(PyNodeFeats, num_opcode_attrs) + .DEF_PYBIND_READONLY(PyNodeFeats, is_alternative) + .DEF_PYBIND_READONLY(PyNodeFeats, is_in_fusion) + .DEF_PYBIND_READONLY(PyNodeFeats, in_tensor_sizes) + .DEF_PYBIND_READONLY(PyNodeFeats, out_tensor_sizes) + .DEF_PYBIND_READONLY(PyNodeFeats, has_max_in_tensor) + .DEF_PYBIND_READONLY(PyNodeFeats, has_max_out_tensor) + .DEF_PYBIND_READONLY(PyNodeFeats, normalized_num_group_inst); + + // TODO(ohcy): write this without copy as nparray + py::class_(m, "EdgeFeats") + .def("get_tensor_size", &PyEdgeFeats::GetTensorSize) + .DEF_PYBIND_READONLY(PyEdgeFeats, uids) + .DEF_PYBIND_READONLY(PyEdgeFeats, srcs) + .DEF_PYBIND_READONLY(PyEdgeFeats, dsts) + .DEF_PYBIND_READONLY(PyEdgeFeats, dims) + .DEF_PYBIND_READONLY(PyEdgeFeats, layouts) + .DEF_PYBIND_READONLY(PyEdgeFeats, lehmercodes) + .DEF_PYBIND_READONLY(PyEdgeFeats, types) + .DEF_PYBIND_READONLY(PyEdgeFeats, dtypes); + + py::class_( + m, "EvaluationResult", + "A structure containing the duration and output of the HloModule " + "evaluation.") + .def_readonly( + "durations", &PyHloEnv::EvaluationResult::durations, + "The default duration in nanoseconds. This returns the execution " + "duration as measured within the Tensorflow evaluation code, " + "starting from the point when the executable has been enqueued on " + "the compute stream till the completion of the executable.") + .def_readonly("compute_durations", + &PyHloEnv::EvaluationResult::compute_durations, + "The duration in nanoseconds of the computation, without " + "data transfer, as measured on the device.") + .def_readonly( + "full_durations", &PyHloEnv::EvaluationResult::full_durations, + "The full duration in nanoseconds as measured within " + "HloEnv.evaluate(). This captures the entire execution process " + "including processes such as enqueueing the computation on the " + "compute stream, and is hence more subject to timing noise.") + .def_readonly("output", &PyHloEnv::EvaluationResult::output, + "The output of the HloModule."); + + py::class_(m, "DebugOptions") + .def_property_readonly( + "xla_llvm_enable_alias_scope_metadata", + &xla::DebugOptions::xla_llvm_enable_alias_scope_metadata) + .def_property_readonly( + "xla_llvm_enable_noalias_metadata", + &xla::DebugOptions::xla_llvm_enable_noalias_metadata) + .def_property_readonly( + "xla_llvm_enable_invariant_load_metadata", + &xla::DebugOptions::xla_llvm_enable_invariant_load_metadata) + .def_property_readonly( + "xla_llvm_disable_expensive_passes", + &xla::DebugOptions::xla_llvm_disable_expensive_passes) + .def_property_readonly("xla_backend_optimization_level", + &xla::DebugOptions::xla_backend_optimization_level) + .def_property_readonly("xla_gpu_deterministic_ops", + &xla::DebugOptions::xla_gpu_deterministic_ops) + .def_property_readonly("xla_gpu_autotune_level", + &xla::DebugOptions::xla_gpu_autotune_level) + .def_property_readonly("xla_cpu_multi_thread_eigen", + &xla::DebugOptions::xla_cpu_multi_thread_eigen) + .def_property_readonly("xla_gpu_cuda_data_dir", + &xla::DebugOptions::xla_gpu_cuda_data_dir) + .def_property_readonly("xla_gpu_asm_extra_flags", + &xla::DebugOptions::xla_gpu_asm_extra_flags) + .def_property_readonly( + "xla_eliminate_hlo_implicit_broadcast", + &xla::DebugOptions::xla_eliminate_hlo_implicit_broadcast) + .def_property_readonly("xla_dump_hlo_as_html", + &xla::DebugOptions::xla_dump_hlo_as_html) + .def_property_readonly("xla_dump_fusion_visualization", + &xla::DebugOptions::xla_dump_fusion_visualization) + .def_property_readonly("xla_dump_include_timestamp", + &xla::DebugOptions::xla_dump_include_timestamp) + .def_property_readonly("xla_dump_max_hlo_modules", + &xla::DebugOptions::xla_dump_max_hlo_modules) + .def_property_readonly("xla_dump_module_metadata", + &xla::DebugOptions::xla_dump_module_metadata) + .def_property_readonly("xla_dump_hlo_as_long_text", + &xla::DebugOptions::xla_dump_hlo_as_long_text) + .def_property_readonly("xla_cpu_use_mkl_dnn", + &xla::DebugOptions::xla_cpu_use_mkl_dnn) + .def_property_readonly( + "xla_gpu_max_kernel_unroll_factor", + &xla::DebugOptions::xla_gpu_max_kernel_unroll_factor) + .def_property_readonly( + "xla_gpu_disable_multi_streaming", + &xla::DebugOptions::xla_gpu_disable_multi_streaming) + .def_property_readonly("xla_cpu_enable_fast_math", + &xla::DebugOptions::xla_cpu_enable_fast_math) + .def_property_readonly("xla_cpu_fast_math_honor_nans", + &xla::DebugOptions::xla_cpu_fast_math_honor_nans) + .def_property_readonly("xla_cpu_fast_math_honor_infs", + &xla::DebugOptions::xla_cpu_fast_math_honor_infs) + .def_property_readonly( + "xla_cpu_fast_math_honor_functions", + &xla::DebugOptions::xla_cpu_fast_math_honor_functions) + .def_property_readonly( + "xla_cpu_fast_math_honor_division", + &xla::DebugOptions::xla_cpu_fast_math_honor_division) + .def_property_readonly("xla_cpu_enable_fast_min_max", + &xla::DebugOptions::xla_cpu_enable_fast_min_max) + .def_property_readonly("xla_gpu_enable_cudnn_frontend", + &xla::DebugOptions::xla_gpu_enable_cudnn_frontend) + .def_property_readonly("xla_gpu_enable_fast_min_max", + &xla::DebugOptions::xla_gpu_enable_fast_min_max) + .def_property_readonly( + "xla_gpu_strict_conv_algorithm_picker", + &xla::DebugOptions::xla_gpu_strict_conv_algorithm_picker) + .def_property_readonly("xla_allow_excess_precision", + &xla::DebugOptions::xla_allow_excess_precision) + .def_property_readonly( + "xla_force_host_platform_device_count", + &xla::DebugOptions::xla_force_host_platform_device_count) + .def_property_readonly( + "xla_gpu_all_reduce_combine_threshold_bytes", + &xla::DebugOptions::xla_gpu_all_reduce_combine_threshold_bytes) + .def_property_readonly("xla_gpu_all_reduce_contiguous", + &xla::DebugOptions::xla_gpu_all_reduce_contiguous) + .def_property_readonly( + "xla_gpu_all_reduce_blueconnect_num_devices_per_host", + &xla::DebugOptions:: + xla_gpu_all_reduce_blueconnect_num_devices_per_host) + .def_property_readonly( + "xla_gpu_enable_async_all_reduce", + &xla::DebugOptions::xla_gpu_enable_async_all_reduce) + .def_property_readonly("xla_cpu_enable_xprof_traceme", + &xla::DebugOptions::xla_cpu_enable_xprof_traceme) + .def_property_readonly( + "xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found", + &xla::DebugOptions:: + xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found) + .def_property_readonly( + "xla_multiheap_size_constraint_per_heap", + &xla::DebugOptions::xla_multiheap_size_constraint_per_heap) + .def_property_readonly( + "xla_detailed_logging_and_dumping", + &xla::DebugOptions::xla_detailed_logging_and_dumping) + .def_property_readonly("xla_gpu_bef_executable", + &xla::DebugOptions::xla_gpu_bef_executable) + .def_property_readonly("xla_gpu_bef_thunk", + &xla::DebugOptions::xla_gpu_bef_thunk) + .def_property_readonly( + "xla_gpu_nccl_termination_timeout_seconds", + &xla::DebugOptions::xla_gpu_nccl_termination_timeout_seconds) + .def_property_readonly( + "xla_gpu_enable_shared_constants", + &xla::DebugOptions::xla_gpu_enable_shared_constants) + .def_property_readonly( + "xla_gpu_redzone_scratch_max_megabytes", + &xla::DebugOptions::xla_gpu_redzone_scratch_max_megabytes); + + py::class_(m, "HloModuleConfig") + .def(py::init<>()) + .def_property_readonly("debug_options", + &xla::HloModuleConfig::debug_options) + .def_property_readonly("seed", &xla::HloModuleConfig::seed) + .def_property_readonly("launch_id", &xla::HloModuleConfig::launch_id) + .def_property_readonly("replica_count", + &xla::HloModuleConfig::replica_count) + .def_property_readonly("num_partitions", + &xla::HloModuleConfig::num_partitions) + .def_property_readonly("use_spmd_partitioning", + &xla::HloModuleConfig::use_spmd_partitioning) + .def_property_readonly("use_auto_spmd_partitioning", + &xla::HloModuleConfig::use_auto_spmd_partitioning) + .def_property_readonly("deduplicate_hlo", + &xla::HloModuleConfig::deduplicate_hlo) + .def_property_readonly( + "intra_op_parallelism_threads", + &xla::HloModuleConfig::intra_op_parallelism_threads) + .def_property_readonly( + "has_static_device_assignment", + &xla::HloModuleConfig::has_static_device_assignment) + .def_property_readonly("alias_passthrough_params", + &xla::HloModuleConfig::alias_passthrough_params) + .def_property_readonly( + "content_aware_computation_sorting", + &xla::HloModuleConfig::content_aware_computation_sorting) + .def_property_readonly("phase_index", &xla::HloModuleConfig::phase_index) + .def_property_readonly( + "allow_spmd_sharding_propagation_to_output", + &xla::HloModuleConfig::allow_spmd_sharding_propagation_to_output); + + py::class_(m, "CostAnalysisProperties"); + + py::class_>( + m, "HloModule", + "The class representing an XLA HloModule. Each HloModule can be loaded " + "into the :class:`HloEnv`, where we can evaluate it, obtain its hash, or " + "run specific :class:`Pass` and :class:`Pipeline` on it ") + .def(py::init(), + R"hloenvdoc( +Creates a :class:`HloEnv` and loads in a HloModule from a specified filepath. + +Args: + input (str): The Hlo text input in the form of a string or filepath. + format (str, optional): The format of the input. Can be either "path" for a filepath to a Hlo text file, or "txt" for the raw Hlo text string. Defaults to "path". + )hloenvdoc", + py::arg("input"), py::arg("format") = "path") + .def("to_string", &AltHloModule::ToString, + "Converts the HloModule to a string representation. This string " + "representation can also used to initialize a new HloEnv or loaded " + "into an existing one.") + .def_property_readonly("config", &AltHloModule::config, + "The config options of the HloModule") + .def("hash", &AltHloModule::Hash, + "The DAGHash of the HloModule. This DAGHash is a custom hash " + "implementation that differs from Tensorflow's existing HloModule " + "hash implementation to better account for the structure and " + "parameters of the Hlo Instructions.") + .def("extract_random_submodule", &AltHloModule::ExtractRandomSubmodule) + .def("extract_instructions_as_module", + &AltHloModule::ExtractInstructionsAsModule) + .def("extract_fusions_as_module", &AltHloModule::ExtractFusionsAsModule) + .def("is_bef_enabled", &AltHloModule::IsBefEnabled, + "Returns whethe Binary Executable Format (BEF) is enabled for the " + "executable.") + .def_property_readonly("instruction_count", + &AltHloModule::InstructionCount, + "The number of instructions in the HloModule.") + .def_property_readonly("computation_count", + &AltHloModule::ComputationCount, + "The number of computations in the HloModule.") + .def("cost_analysis", &AltHloModule::CostAnalysis, + "Returns a dictionary containing the flops, transcendentals, bytes " + "accessed and optimal seconds of the Hlo Module.") + .def("clone", &AltHloModule::Clone, "Clones the HloModule."); + + py::class_( + m, "HloEnv", + "The class representing the HloEnv. Each HloEnv instance can be loaded " + "with a single HloModule, and used to run Passes/Pipelines on that " + "module, as well as extract features, evaluate and obtain the graph " + "features for that HloModule.") + .def(py::init(), + R"hloenvdoc( +Creates a :class:`HloEnv` and loads in a HloModule from a specified filepath. + +Args: + hlo_filepath (str): The path of the HloModule text file + platform (str): The platform we wish to run the HloModule on. Currently only 'gpu' is supported + )hloenvdoc", + py::arg("hlo_filepath"), py::arg("platform")) + .def(py::init(), + R"hloenvdoc( +Creates a :class:`HloEnv` and loads in a HloModule from its string representation. + +Args: + hlo_data (str): The HloModule string + platform (str): The platform we wish to run the HloModule on. Currently only 'gpu' is supported + )hloenvdoc", + py::arg("hlo_data"), py::arg("format"), py::arg("platform")) + .def(py::init, const std::string&>(), + R"hloenvdoc( +Creates a :class:`HloEnv` and loads in a HloModule from an existing HloModule object. + +Args: + alt_hlo_module (:class:`HloModule`): The HloModule object + platform (str): The platform we wish to run the HloModule on. Currently only 'gpu' is supported + )hloenvdoc", + py::arg("alt_hlo_module"), py::arg("platform")) + .def("evaluate", &PyHloEnv::Evaluate, + R"hloenvdoc( + Evaluates the :class:`HloModule` loaded into the environment N times and returns both the output and the duration of each evaluation. + + Args: + times (int): The number of evaluations to perform + do_not_prep_for_eval (bool, optional): Whether to prepare the HloModule for evaluation. This can result in changes to the HloModule (e.g. insertion of Copy instructions), so set this to True if the HloModule has already gone through this process. Defaults to false. + + Returns: + :class:`EvaluationResult`: The structure containing the durations and output of the evaluation + )hloenvdoc", + py::arg("times") = 20, py::arg("do_not_prep_for_eval") = false) + .def("has_equal_output", &PyHloEnv::HasEqualOutput, + py::arg("first_module"), py::arg("second_module"), + py::arg("times") = 1) + .def("has_equal_output_as", &PyHloEnv::HasEqualOutputAs, + py::arg("other_module"), py::arg("times") = 1) + .def("clone_hlo", &PyHloEnv::CloneHloModule, + "Clones the currently loaded :class:`HloModule` and returns it.") + .def("load_hlo", + static_cast)>( + &PyHloEnv::LoadHloModule), + R"hloenvdoc( + Loads in a new :class:`HloModule` from an existing :class:`HloModule` object. + + Args: + hlo_module (:class:`HloModule`): The HloModule to be loaded in. + )hloenvdoc", + py::arg("hlo_module")) + .def("load_hlo", + static_cast( + &PyHloEnv::LoadHloModule), + R"hloenvdoc( + Loads in a new :class:`HloModule` from text data. + + Args: + hlo_data (str): The HloModule data to be loaded in in the form of a filepath or raw Hlo text string. + format (str, optional): The format of the Hlo data. Defaults to "path". + )hloenvdoc", + py::arg("hlo_data"), py::arg("format") = "path") + .def("export_hlo_to_str", &PyHloEnv::ExportHloModuleToStr, + "Exports the currently loaded :class:`HloModule` into its text " + "representation. This text can be loaded by the HloEnv.") + .def("get_hlo_module", &PyHloEnv::GetHloModule, + "Get the :class:`HloModule` object loaded in the :class:`HloEnv`") + .def("get_hlo_graph", &PyHloEnv::GetHloGraph, py::arg("debug") = false, + "Converts the :class:`HloModule` into a :class:'HloGraph' object " + "that describes the features and structure of the HloModule.", + py::arg("inline_fused_comp") = false, + py::arg("do_hash_verification") = false) + .def("optimize_hlo_module", &PyHloEnv::OriginalOptimizeHloModule, + "Runs the original Xla Optimization Pipeline on the HloModule to " + "obtain a baseline reference against XLA.") + .def("prepare_for_eval", &PyHloEnv::PrepareForEvaluation, + "Prepare the HloModule for IR emitting and evaluation. This step is " + "automatically run during HloEnv.evaluate, unless the " + "do_not_prep_for_eval parameter is set to True, hence in most cases " + "you will not have to run this function.") + .def("run", &PyHloEnv::Run, + R"hloenvdoc( + Runs the specified :class:`Pass` or :class:`Pipeline` on the :class:`HloModule` loaded in the environment. + + Args: + pass_pipeline (Union[:class:`Pass`, :class:`Pipeline`]): The Pass or Pipeline we wish to run on the :class:`HloModule` loaded in the environment. + + Returns: + bool: True if alternatives were generated (i.e. the pass or one of the passes in the pipeline is an AltPipeline), False otherwise. Note that if this returns True, it indicates that an apply_alternatives call must be run to pick the decisions at each alternative before the HloModule can be evaluated. + )hloenvdoc", + py::arg("pass_pipeline")) + .def("get_hlo_module_hash", &PyHloEnv::GetHloModuleHash, + "Returns the HloDagHash of the class:`HloModule` loaded in the " + "environment.") + .def("apply_alternatives", &PyHloEnv::ApplyAlternatives, + R"hloenvdoc( + Applies the specified decisions to the alternative nodes in the HloModule graph, and prunes the resulting graph. + + Args: + decisions (ndarray): 2D array of (node_uid, decision) pairs where decision = i indicates that we wish to select the ith alternative at the alternative node corresponding to node_uid. + )hloenvdoc", + py::arg("decisions")); + + py::class_> + gpu_backend(m, "GpuBackend"); + gpu_backend + .def(py::init([]() { + return std::unique_ptr( + &HloEnvGpuBackend::Instance()); + })) + .def_property_readonly_static( + "stream_exec_platform", + [](py::object /* self */) { + return HloEnvGpuBackend::GetStreamExecPlatform(); + }) + .def_static("cuda_is_at_least", &HloEnvGpuBackend::CudaComputeIsAtLeast, + py::arg("other_major"), py::arg("other_minor") = 1); + py::enum_( + gpu_backend, "CudaComputeCapability") + .value("PASCAL", + xla::se::CudaComputeCapability::CudaComputeCapabilities::PASCAL_) + .value("VOLTA", + xla::se::CudaComputeCapability::CudaComputeCapabilities::VOLTA) + .value("AMPERE", + xla::se::CudaComputeCapability::CudaComputeCapabilities::AMPERE) + .export_values(); + + py::class_>(m, "Literal") + .def("__repr__", &xla::Literal::ToString); + + // Bindings for Hlo Passes + py::module hlo_passes_m = m.def_submodule("hlo_pass", "Hlo Pass definitions"); + py_init_hlo_passes(hlo_passes_m); + + // General pipeline interface + + py::class_>(m, "PassInterface") + .def("Run", + static_cast)>( + &PassInterface::Run), + py::arg("hlo_pass")) + .def_property_readonly("name", &PassInterface::name); + + py::class_>(m, "Pass") + .def(py::init, int>(), + R"hloenvdoc( + Creates a new Pipeline. + + Args: + hlo_pass (:class:`HloPassInterface`): The XLA Pass/Pipeline we wish to run. See :ref:`List of currently enabled XLA Hlo Passes` for more details. + name (loop_count): The number of times to run this Pipeline. Set this to -1 to run it until no further changes to the HloModule occur, up to a maximum of 25 times. Defaults to 1. + + Examples: + fusion_pass = hloenv.HloPass.GpuInstructionFusion(may_duplicate=True) + )hloenvdoc", + py::arg("hlo_pass"), py::arg("loop_count") = 1) + .def_property_readonly("changed", &Pass::changed) + .def_property_readonly("name", &Pass::name); + + py::class_>(m, "Pipeline") + .def(py::init(), + R"hloenvdoc( + Creates a new Pipeline. + + Args: + name (str): The name of this Pipeline. + loop_count (int, optional): The number of times to run this Pipeline. Set this to -1 to run it until no further changes to the HloModule occur, up to a maximum of 25 times. Defaults to 1. + )hloenvdoc", + py::arg("name"), py::arg("loop_count") = 1) + .def( + "add_pass", + static_cast, + int)>(&Pipeline::AddPass), + py::arg("hlo_pass"), py::arg("loop_count") = 1) + .def("add_pass", + static_cast)>( + &Pipeline::AddPass), + "Add a :class:`Pass` or :class:`Pipeline` to this Pipeline.") + .def("add_invariant_checker", + static_cast)>( + &Pipeline::AddInvariantChecker), + py::arg("hlo_pass")) + .def("add_invariant_checker", + static_cast)>( + &Pipeline::AddInvariantChecker)) + .def_property_readonly("name", &Pipeline::name) + .def_property_readonly("changed", &Pipeline::changed); + + py::class_>( + m, "AltPipeline") + .def(py::init, int>(), py::arg("pass"), + py::arg("loop_count") = 1) + .def_property_readonly("name", &AltPipeline::name) + .def_property_readonly("changed", &AltPipeline::changed); +} + +} // namespace hloenv diff --git a/hloenv/python/py_hlo_env.h b/hloenv/python/py_hlo_env.h new file mode 100644 index 0000000..21d549f --- /dev/null +++ b/hloenv/python/py_hlo_env.h @@ -0,0 +1,53 @@ +// Copyright 2022 Garena Online Private Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef HLOENV_PYTHON_PY_HLO_ENV_H_ +#define HLOENV_PYTHON_PY_HLO_ENV_H_ + +#include + +#include +#include + +#include "hloenv/hlo_env.h" +#include "hloenv/python/py_hlo_graph.h" +#include "hloenv/python/py_hlo_passes.h" + +namespace py = pybind11; + +namespace hloenv { + +class PyHloEnv : public HloEnv { + public: + PyHloEnv(std::shared_ptr alt_hlo_module, + const std::string& platform) + : HloEnv(alt_hlo_module, platform) {} + + PyHloEnv(const std::string& hlo_input, const std::string& format, + const std::string& platform) + : HloEnv(hlo_input, format, platform) {} + + PyHloEnv(const std::string& hlo_filepath, const std::string& platform) + : HloEnv(hlo_filepath, "path", platform) {} + + PyHloGraph GetHloGraph(bool debug, bool inline_fused_comp, + bool do_hash_verification) { + return PyHloGraph(GetHloModule()->hlo_module_ptr(), debug, + inline_fused_comp, do_hash_verification); + } +}; + +} // namespace hloenv + +#endif // HLOENV_PYTHON_PY_HLO_ENV_H_ diff --git a/hloenv/python/py_hlo_graph.h b/hloenv/python/py_hlo_graph.h new file mode 100644 index 0000000..4826cc3 --- /dev/null +++ b/hloenv/python/py_hlo_graph.h @@ -0,0 +1,124 @@ +// Copyright 2022 Garena Online Private Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef HLOENV_PYTHON_PY_HLO_GRAPH_H_ +#define HLOENV_PYTHON_PY_HLO_GRAPH_H_ + +#include +#include +#include + +#include +#include +#include +#include + +#include "hloenv/hlo_graph.h" + +namespace py = pybind11; + +namespace hloenv { + +// Capsule stores a copy of the shared_ptr to the data +// will delete the shared_ptr when it goes out of scope in python +template +inline py::array_t as_pyarray( + std::shared_ptr s_ptr) { + return py::array_t{ + s_ptr->size(), s_ptr->data(), py::capsule(new auto(s_ptr), [](void* p) { + delete reinterpret_cast(p); + })}; +} + +#define SHARED_VEC_TO_PYARRAY(NAME, TYPE, SHARED_PTR) \ + py::array_t py_get_##NAME() { return as_pyarray(SHARED_PTR); } + +#define DEF_PYBIND_READONLY(CLASS, NAME) \ + def_property_readonly(#NAME, &CLASS::py_get_##NAME) + +struct PyNodeFeats : public NodeFeats { + // Expose to pybind interface in py_hlo_env.cc using DEF_PYBIND_READONLY macro + SHARED_VEC_TO_PYARRAY(uids, int, uids) + SHARED_VEC_TO_PYARRAY(gids, size_t, gids) + SHARED_VEC_TO_PYARRAY(fused_comp_ids, size_t, fused_comp_ids) + SHARED_VEC_TO_PYARRAY(num_users, int, num_users) + SHARED_VEC_TO_PYARRAY(num_operands, int, num_operands) + SHARED_VEC_TO_PYARRAY(opcodes, int, opcodes) + SHARED_VEC_TO_PYARRAY(opcode_attrs, int, opcode_attrs) + SHARED_VEC_TO_PYARRAY(num_opcode_attrs, int, num_opcode_attrs) + SHARED_VEC_TO_PYARRAY(is_alternative, uint8_t, is_alternative) + SHARED_VEC_TO_PYARRAY(is_in_fusion, uint8_t, is_in_fusion) + SHARED_VEC_TO_PYARRAY(in_tensor_sizes, int64_t, in_tensor_sizes) + SHARED_VEC_TO_PYARRAY(out_tensor_sizes, int64_t, out_tensor_sizes) + SHARED_VEC_TO_PYARRAY(has_max_in_tensor, uint8_t, has_max_in_tensor) + SHARED_VEC_TO_PYARRAY(has_max_out_tensor, uint8_t, has_max_out_tensor) + SHARED_VEC_TO_PYARRAY(normalized_num_group_inst, float, + normalized_num_group_inst) + std::vector& py_get_names() { return *names; } + + PyNodeFeats() {} + explicit PyNodeFeats(const NodeFeats& node_feats) : NodeFeats(node_feats) {} +}; + +struct PyEdgeFeats : public EdgeFeats { + // Expose to pybind interface in py_hlo_env.cc using DEF_PYBIND_READONLY macro + SHARED_VEC_TO_PYARRAY(uids, int64_t, uids); + SHARED_VEC_TO_PYARRAY(srcs, int, srcs); + SHARED_VEC_TO_PYARRAY(dsts, int, dsts); + SHARED_VEC_TO_PYARRAY(dims, int64_t, dims); + SHARED_VEC_TO_PYARRAY(layouts, int64_t, layouts); + SHARED_VEC_TO_PYARRAY(lehmercodes, int64_t, lehmercodes); + SHARED_VEC_TO_PYARRAY(types, uint8_t, types); + SHARED_VEC_TO_PYARRAY(dtypes, int, dtypes); + + PyEdgeFeats() {} + explicit PyEdgeFeats(const EdgeFeats& edge_feats) : EdgeFeats(edge_feats) {} +}; + +class PyHloGraph : public HloGraph { + public: + // Expose to pybind interface in py_hlo_env.cc using DEF_PYBIND_READONLY macro + SHARED_VEC_TO_PYARRAY(out_edge_offsets, size_t, get_out_edge_offsets_ptr()); + SHARED_VEC_TO_PYARRAY(out_edge_indices, size_t, get_out_edge_indices_ptr()); + SHARED_VEC_TO_PYARRAY(in_edge_offsets, size_t, get_in_edge_offsets_ptr()); + SHARED_VEC_TO_PYARRAY(in_edge_indices, size_t, get_in_edge_indices_ptr()); + SHARED_VEC_TO_PYARRAY(opcode_attr_counts, int, get_opcode_attr_counts_ptr()); + SHARED_VEC_TO_PYARRAY(alternative_indices, int, + get_alternative_indices_ptr()); + int py_get_graph_load_errors() { return graph_load_errors_; } + + PyNodeFeats node_features_; + PyEdgeFeats in_edge_features_; + PyEdgeFeats out_edge_features_; + + PyHloGraph() {} + explicit PyHloGraph(const xla::HloModule* m, bool debug = false, + bool inline_fused_comp = false, + bool do_hash_verification = false) + : HloGraph(m, debug, inline_fused_comp, do_hash_verification) { + node_features_ = PyNodeFeats(get_node_feats()); + in_edge_features_ = PyEdgeFeats(get_in_edge_feats()); + out_edge_features_ = PyEdgeFeats(get_out_edge_feats()); + } + + PyNodeFeats& py_get_node_features() { return node_features_; } + PyEdgeFeats& py_get_in_edge_features() { return in_edge_features_; } + PyEdgeFeats& py_get_out_edge_features() { return out_edge_features_; } + + uint64_t py_hash() { return Hash(); } +}; + +} // namespace hloenv + +#endif // HLOENV_PYTHON_PY_HLO_GRAPH_H_ diff --git a/hloenv/python/py_hlo_passes.cc b/hloenv/python/py_hlo_passes.cc new file mode 100644 index 0000000..1159634 --- /dev/null +++ b/hloenv/python/py_hlo_passes.cc @@ -0,0 +1,992 @@ +// Copyright 2022 Garena Online Private Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "hloenv/python/py_hlo_passes.h" + +namespace hloenv { + +void py_init_hlo_passes(const py::module& m) { + py::class_>( + m, "HloPassInterface"); + + // GPU PASSES: + py::class_, xla::HloPassInterface>( + m, "AlgebraicSimplifier") + // TODO(ohcy): Change this to use protobuf + .def( + py::init([](py::dict options_dict) { + xla::AlgebraicSimplifierOptions options; + for (auto item : options_dict) { + const std::string option = item.first.cast(); + + if (option == "is_layout_sensitive") { + options.set_is_layout_sensitive(item.second.cast()); + } else if (option == "enable_dot_strength_reduction") { + options.set_enable_dot_strength_reduction( + item.second.cast()); + } else if (option == "enable_dot_to_multiply_rewrite") { + options.set_enable_dot_to_multiply_rewrite( + item.second.cast()); + } else if (option == "enable_conv_simplification") { + options.set_enable_conv_simplification( + item.second.cast()); + } else if (option == "enable_conv_operand_swap") { + options.set_enable_conv_operand_swap(item.second.cast()); + } else if (option == "enable_scalar_multiply_reduction") { + options.set_enable_scalar_multiply_reduction( + item.second.cast()); + } else if (option == "enable_floats_are_real") { + options.set_enable_floats_are_real(item.second.cast()); + } else if (option == + "enable_window_reduce_to_reduce_replacement") { + options.set_enable_window_reduce_to_reduce_replacement( + item.second.cast()); + } else if (option == "very_small_gather_size") { + options.set_very_small_gather_size(item.second.cast()); + } else if (option == + "cudnn_batchnorm_forward_training_metadata") { + options.set_cudnn_batchnorm_forward_training_metadata( + item.second.cast()); + } else if (option == "enable_reduce_of_reshape") { + options.set_enable_reduce_of_reshape(item.second.cast()); + } else if (option == "enable_negative_padding_replacement") { + options.set_enable_negative_padding_replacement( + item.second.cast()); + } else if (option == "enable_sink_broadcast") { + options.set_enable_sink_broadcast(item.second.cast()); + } else if (option == "replace_transpose_with_bitcast") { + options.set_replace_transpose_with_bitcast( + item.second.cast()); + } else if (option == "minmax_propagate_nan") { + options.set_minmax_propagate_nan(item.second.cast()); + } else { + LOG(FATAL) << "Option '" << option + << "' not an option for AlgebraicSimplifierOptions"; + } + } + return std::make_shared(options); + }), + py::arg("options")); + + py::class_, + xla::HloPassInterface>(m, "AllGatherBroadcastReorder") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "AllGatherCombiner") + .def(py::init(), py::arg("combine_threshold_in_bytes"), + py::arg("combine_threshold_count")); + + py::class_, + xla::HloPassInterface>(m, "AllReduceCombiner") + .def(py::init(), py::arg("combine_threshold_in_bytes"), + py::arg("combine_threshold_count")); + + py::class_, xla::HloPassInterface>( + m, "AllReduceContiguous") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "AllReduceFolder") + .def(py::init<>()); + + py::class_, xla::HloPassInterface>( + m, "AllReduceReassociate") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "AsyncCollectiveCreator") + .def(py::init([]() { + // TODO(ohcy): Currently this specialization uses the function defined + // in gpu_compiler.h:OptimizeHloModule + xla::AsyncCollectiveCreator::CollectiveCreatorConfig config; + config.convert_all_reduce = [](const xla::HloInstruction*) { + return true; + }; + return std::make_shared(config); + })); + + py::class_, + xla::HloPassInterface>(m, "BatchNormExpander") + .def(py::init(), py::arg("rewrite_training_op") = false, + py::arg("rewrite_inference_op") = false, + py::arg("rewrite_grad_op") = false); + + py::class_, + xla::HloPassInterface>(m, "BFloat16Normalization") + .def(py::init([](bool supports_matrix_multiplication) { + // TODO(ohcy): Would be better to change it to take a unique_ptr and + // let the TF side manage the lifetime of the support object, but that + // requires more changes to TF. KIV + xla::gpu::GpuBfloat16Support* bf16 = new xla::gpu::GpuBfloat16Support( + supports_matrix_multiplication, HloEnvGpuBackend::StreamExecutor()); + auto deleter = [](xla::BFloat16Normalization* pass) { + delete pass->bfloat16_support(); + }; + + return std::shared_ptr( + new xla::BFloat16Normalization{bf16}, deleter); + })); + + py::class_, + xla::HloPassInterface>(m, "CallInliner") + .def(py::init(), py::arg("single_call_site") = false, + py::arg("update_domain") = false); + + py::class_, + xla::HloPassInterface>(m, "CollectivesScheduleLinearizer") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "ConditionalCanonicalizer") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "ConditionalSimplifier") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "DotDecomposer") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "DotMerger") + .def(py::init(), py::arg("max_size_to_merge")); + + py::class_, + xla::HloPassInterface>(m, "DynamicDimensionSimplifier") + .def(py::init<>()); + + py::class_, xla::HloPassInterface>( + m, "DynamicIndexSplitter") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface> + dynamic_padder(m, "DynamicPadder"); + dynamic_padder.def(py::init([](py::dict options_dict) { + auto options = xla::DynamicPadderOptions(); + for (auto item : options_dict) { + const std::string option = item.first.cast(); + + if (option == "slice_dynamic_output") { + options.slice_dynamic_output = item.second.cast(); + } else if (option == "shape_check_mode") { + options.slice_dynamic_output = + item.second.cast(); + } else if (option == "op_supports_dynamism_handler") { + // TODO(ohcy) + LOG(FATAL) << "op_supports_dynamism_handler not yet handled for " + "DynamicPadderOptions"; + } else if (option == "custom_call_handler") { + // TODO(ohcy) + LOG(FATAL) << "custom_call_handler not yet handled for " + "DynamicPadderOptions"; + } else { + LOG(FATAL) << "Option '" << option + << "' not an option for DynamicPadderOptions"; + } + } + return std::make_shared(options); + })); + py::enum_(dynamic_padder, + "ShapeCheckMode") + .value("kInvalid", + xla::DynamicDimensionInference::ShapeCheckMode::kInvalid) + .value("kCompileTime", + xla::DynamicDimensionInference::ShapeCheckMode::kCompileTime) + .value("kRuntimeTime", + xla::DynamicDimensionInference::ShapeCheckMode::kRuntimeTime) + .value("kIgnore", xla::DynamicDimensionInference::ShapeCheckMode::kIgnore) + .export_values(); + + py::class_, + xla::HloPassInterface>(m, "FlattenCallGraph") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "HloConstantFolding") + .def(py::init<>()); + + py::class_, xla::HloPassInterface>( + m, "HloCSE") + .def(py::init(), py::arg("is_layout_sensitive"), + py::arg("only_fusion_computations") = false); + + py::class_, xla::HloPassInterface>( + m, "HloDCE") + .def(py::init<>()) + .def(py::init(), py::arg("remove_cross_partition_collective_ops")); + + py::class_, + xla::HloPassInterface>(m, "GpuInstructionFusion") + .def(py::init(), py::arg("may_duplicate")); + + py::class_, + xla::HloPassInterface>(m, "GpuLayoutAssignment") + // .def(py::init(), + // py::arg("entry_computation_layout"), py::arg("stream_executor"), + // py::arg("channel_constraints") = nullptr); + .def(py::init([](std::shared_ptr alt_hlo_module) { + // TODO(ohcy): Currently we just default to normal LayoutConstraints, + // we do not have the ability to add more LayoutConstraints + xla::ChannelLayoutConstraints layout_constraints; + return std::make_shared( + alt_hlo_module->hlo_module_ptr() + ->mutable_entry_computation_layout(), + HloEnvGpuBackend::StreamExecutor(), &layout_constraints); + })); + + py::class_, + xla::HloPassInterface>(m, "AllToAllDecomposer") + .def(py::init(), py::arg("decompose_to_tuple") = true, + py::arg("min_array_rank") = 0); + + py::class_, + xla::HloPassInterface>(m, "BitcastDtypesExpander") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "ComparisonExpander") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "Convolution4DExpander") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "EighExpander") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface> + gather_expander(m, "GatherExpander"); + gather_expander.def(py::init(), py::arg("m")); + py::enum_(gather_expander, "Mode") + .value("kEliminateAllGathers", + xla::GatherExpander::Mode::kEliminateAllGathers) + .value("kEliminateSimpleGathers", + xla::GatherExpander::Mode::kEliminateSimpleGathers) + .export_values(); + + py::class_, + xla::HloPassInterface> + logistic_expander(m, "LogisticExpander"); + logistic_expander.def(py::init(), + py::arg("expansion_type")); + py::enum_(logistic_expander, + "LogisticExpansionType") + .value("kTanh", xla::LogisticExpansionType::kTanh) + .value("kExp", xla::LogisticExpansionType::kExp) + .export_values(); + + py::class_, + xla::HloPassInterface>(m, "OperandUpcaster") + // .def(py::init(), py::arg("extra_filter") = + // nullptr); + .def(py::init([]() { + // TODO(ohcy): Currently this specialization uses the function defined + // in gpu_compiler.h:OptimizeHloModule + xla::OpExpanderPass::PatternExtraFilter upcaster_filter = + [&](const xla::HloInstruction* instr) { + return !(HloEnvGpuBackend::StreamExecutor() + ->GetDeviceDescription() + .cuda_compute_capability() + .IsAtLeast(xla::se::CudaComputeCapability::VOLTA)) || + !xla::gpu::IsMatrixMultiplication(*instr); + }; + return std::make_shared(upcaster_filter); + })); + + py::class_, + xla::HloPassInterface>(m, "OptimizationBarrierExpander") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "QrExpander") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "RealImagExpander") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "ResultCaster") + // .def(py::init(), py::arg("extra_filter") = + // nullptr); + .def(py::init([]() { + // TODO(ohcy): Currently this specialization uses the function defined + // in gpu_compiler.h:OptimizeHloModule + xla::OpExpanderPass::PatternExtraFilter upcaster_filter = + [&](const xla::HloInstruction* instr) { + return !(HloEnvGpuBackend::StreamExecutor() + ->GetDeviceDescription() + .cuda_compute_capability() + .IsAtLeast(xla::se::CudaComputeCapability::VOLTA)) || + !xla::gpu::IsMatrixMultiplication(*instr); + }; + return std::make_shared(upcaster_filter); + })); + + py::class_, + xla::HloPassInterface> + rng_bit_generator_expander(m, "RngBitGeneratorExpander"); + rng_bit_generator_expander.def(py::init(), + py::arg("default_algorithm")); + py::enum_(rng_bit_generator_expander, "RandomAlgorithm") + .value("RNG_DEFAULT", xla::RandomAlgorithm::RNG_DEFAULT) + .value("RNG_THREE_FRY", xla::RandomAlgorithm::RNG_THREE_FRY) + .value("RNG_PHILOX", xla::RandomAlgorithm::RNG_PHILOX) + .export_values(); + + py::class_, + xla::HloPassInterface>(m, "RngExpander") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface> + scatter_expander(m, "ScatterExpander"); + scatter_expander.def(py::init(), py::arg("m")); + py::enum_(scatter_expander, "Mode") + .value("kEliminateAllScatters", + xla::ScatterExpander::Mode::kEliminateAllScatters) + .value("kEliminateSimpleScatters", + xla::ScatterExpander::Mode::kEliminateSimpleScatters) + .export_values(); + + py::class_, + xla::HloPassInterface>(m, "GpuScatterExpander") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "StableSortExpander") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "ReduceScatterCombiner") + .def(py::init(), py::arg("combine_threshold_in_bytes"), + py::arg("combine_threshold_count")); + + py::class_, + xla::HloPassInterface>(m, "ReshapeMover") + .def(py::init<>()); + + py::class_, xla::HloPassInterface>( + m, "ShardingPropagation") + .def(py::init(), py::arg("is_spmd") = false, + py::arg("propagate_metadata") = false, + py::arg("allow_spmd_sharding_propagation_to_output") = false, + py::arg("cse_prevention_only") = false); + + py::class_, + xla::HloPassInterface>(m, "ShardingRemover") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "SliceSinker") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "SortSimplifier") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "TransposeFolding") + .def(py::init([]() { + // TODO(ohcy): Currently this specialization uses the function defined + // in gpu_compiler.h:OptimizeHloModule + // TODO(ohcy): Does not modify default transposable_conv_operands + xla::TransposeFolding::TransposableGemmOperandsFn + transposable_gemm_operands = + [](const xla::HloInstruction& dot, + const xla::TransposeFolding::OperandIndices& + candidate_operands) { + return xla::gpu::IsMatrixMultiplication(dot) + ? candidate_operands + : xla::TransposeFolding::OperandIndices{}; + }; + return std::make_shared( + transposable_gemm_operands); + })); + + py::class_, + xla::HloPassInterface>(m, "TupleSimplifier") + .def(py::init<>()) + .def(py::init(), py::arg("exclude_entry_computation")); + + py::class_, + xla::HloPassInterface>(m, "WhileLoopConstantSinking") + .def(py::init<>()); + + py::class_, xla::HloPassInterface>( + m, "WhileLoopSimplifier") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "WhileLoopTripCountAnnotator") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "ZeroSizedHloElimination") + .def(py::init<>()); + + py::class_, xla::HloPassInterface>( + m, "AllReduceBlueConnect") + .def(py::init(), py::arg("num_devices_per_host")); + + py::class_, + xla::HloPassInterface>(m, "FusionBitcastLift") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "FusionMerger") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "GeneralFusion") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "ReduceScatterCreator") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "GpuHorizontalInputFusion") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "GpuHorizontalLoopFusion") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "GpuMultiOutputFusion") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "VariadicOpSplitter") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "StatefulRngSpmdPartitioner") + .def(py::init(), py::arg("num_partitions"), + py::arg("num_replicas")); + + py::class_, + xla::HloPassInterface>(m, "CudnnFusedConvRewriter") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "CudnnPadForConvolutions") + .def(py::init([]() { + return std::make_shared( + HloEnvGpuBackend::StreamExecutor() + ->GetDeviceDescription() + .cuda_compute_capability()); + })); + + py::class_, + xla::HloPassInterface>(m, "CudnnVectorizeConvolutions") + .def(py::init([]() { + return std::make_shared( + HloEnvGpuBackend::StreamExecutor() + ->GetDeviceDescription() + .cuda_compute_capability()); + })); + + py::class_, + xla::HloPassInterface> + cublas_pad_for_gemms(m, "CublasPadForGemms"); + cublas_pad_for_gemms.def(py::init(), + py::arg("datatype"), py::arg("pad_to_multiple_of")); + py::enum_(cublas_pad_for_gemms, "PrimitiveType") + .value("PRIMITIVE_TYPE_INVALID", + xla::PrimitiveType::PRIMITIVE_TYPE_INVALID) + .value("PRED", xla::PrimitiveType::PRED) + .value("S8", xla::PrimitiveType::S8) + .value("S16", xla::PrimitiveType::S16) + .value("S32", xla::PrimitiveType::S32) + .value("S64", xla::PrimitiveType::S64) + .value("U8", xla::PrimitiveType::U8) + .value("U16", xla::PrimitiveType::U16) + .value("U32", xla::PrimitiveType::U32) + .value("U64", xla::PrimitiveType::U64) + .value("F16", xla::PrimitiveType::F16) + .value("F32", xla::PrimitiveType::F32) + .value("BF16", xla::PrimitiveType::BF16) + .value("F64", xla::PrimitiveType::F64) + .value("C64", xla::PrimitiveType::C64) + .value("C128", xla::PrimitiveType::C128) + .value("TUPLE", xla::PrimitiveType::TUPLE) + .value("OPAQUE_TYPE", xla::PrimitiveType::OPAQUE_TYPE) + .value("TOKEN", xla::PrimitiveType::TOKEN) + .export_values(); + + py::class_, + xla::HloPassInterface>(m, "GemmAlgorithmPicker") + .def(py::init([]() { + return std::make_shared( + HloEnvGpuBackend::StreamExecutor(), + HloEnvGpuBackend::DeviceMemoryAllocator()); + })); + + py::class_, + xla::HloPassInterface>(m, "GpuTreeReductionRewriter") + .def(py::init([]() { + return std::make_shared( + HloEnvGpuBackend::StreamExecutor() + ->GetDeviceDescription() + .cuda_compute_capability()); + })); + + py::class_, + xla::HloPassInterface>(m, "GemmBroadcastFoldingRewriter") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "GemmRewriter") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "GpuConvAlgorithmPicker") + .def(py::init([]() { + return std::make_shared( + HloEnvGpuBackend::StreamExecutor(), + HloEnvGpuBackend::DeviceMemoryAllocator()); + })); + + py::class_, + xla::HloPassInterface>(m, "GpusolverRewriter") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "GpuConvPaddingLegalization") + .def(py::init<>()); + + py::class_, xla::HloPassInterface>( + m, "GpuConvRewriter") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "ReductionDegenerateDimRemover") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "ReductionDimensionGrouper") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "ReductionLayoutNormalizer") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "ReductionSplitter") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "TriangularSolveRewriter") + .def(py::init<>()); + + py::class_, + xla::HloPassInterface>(m, "HloVerifier") + .def(py::init(), py::arg("layout_sensitive"), + py::arg("allow_mixed_precision")); + + // // OTHER PASSES (EMPTY CONSTRUCTOR) + + // py::class_, xla::HloPassInterface>(m, + // "BatchDotSimplification") + // .def(py::init<>()); + + // py::class_, xla::HloPassInterface>(m, + // "BFloat16ConversionFolding") + // .def(py::init<>()); + + // py::class_, + // xla::HloPassInterface>(m, "BFloat16MixedPrecisionRemoval") + // .def(py::init<>()); + + // py::class_, xla::HloPassInterface>(m, + // "ConditionalToSelect") + // .def(py::init<>()); + + // py::class_, + // xla::HloPassInterface>(m, "Defuser") + // .def(py::init<>()); + + // py::class_, + // xla::HloPassInterface>(m, "Despecializer") + // .def(py::init<>()); + + // py::class_, + // xla::HloPassInterface>(m, "ControlDepRemover") + // .def(py::init<>()); + + // py::class_, + // xla::HloPassInterface>(m, "DryModeOn") + // .def(py::init<>()); + + // py::class_, + // xla::HloPassInterface>(m, "DryModeOff") + // .def(py::init<>()); + + // py::class_, + // xla::HloPassInterface>(m, "HloGetDimensionSizeRewriter") + // .def(py::init<>()); + + // py::class_, xla::HloPassInterface>(m, + // "HloTrivialScheduler") + // .def(py::init<>()); + + // py::class_, + // xla::HloPassInterface>(m, "HloDescheduler") + // .def(py::init<>()); + + // py::class_, + // xla::HloPassInterface>(m, "HloModuleDCE") + // .def(py::init<>()); + + // py::class_, xla::HloPassInterface>(m, + // "FooToBarModulePass") + // .def(py::init<>()); + + // py::class_, + // xla::HloPassInterface>(m, "BarBlowerUpper") + // .def(py::init<>()); + + // py::class_, + // xla::HloPassInterface>(m, "HloSubcomputationUnification") + // .def(py::init<>()); + + // py::class_, + // xla::HloPassInterface>(m, "IndexedArrayAnalysisPrinterPass") + // .def(py::init<>()); + + // py::class_, CpuInstructionFusion, + // xla::HloPassInterface>(m, "CpuInstructionFusion") + // .def(py::init<>()); + + // py::class_, + // xla::HloPassInterface>(m, "InstructionFusionForTesting") + // .def(py::init<>()); + + // py::class_, xla::HloPassInterface>(m, + // "LoopScheduleLinearizer") + // .def(py::init<>()); + + // py::class_, + // xla::HloPassInterface>(m, "MapInliner") + // .def(py::init<>()); + + // py::class_, xla::HloPassInterface>(m, + // "MemorySpacePropagation") + // .def(py::init<>()); + + // py::class_, + // xla::HloPassInterface>(m, "MultiOutputFusion") + // .def(py::init<>()); + + // py::class_, + // xla::HloPassInterface>(m, "OpExpanderPass") + // .def(py::init<>()); + + // py::class_, + // xla::HloPassInterface>(m, "CholeskyExpander") + // .def(py::init<>()); + + // py::class_, xla::HloPassInterface>(m, + // "ConvertOperandFolding") + // .def(py::init<>()); + + // py::class_, + // xla::HloPassInterface>(m, "OptimizeInputOutputBufferAlias") + // .def(py::init<>()); + + // py::class_, xla::HloPassInterface>(m, + // "ReduceScatterDecomposer") + // .def(py::init<>()); + + // py::class_, xla::HloPassInterface>(m, + // "RootInstructionSinker") + // .def(py::init<>()); + + // py::class_, + // xla::HloPassInterface>(m, "WhileLoopAllReduceCodeMotion") + // .def(py::init<>()); + + // py::class_, + // xla::HloPassInterface>(m, "AliasPassthroughParams") + // .def(py::init<>()); + + // py::class_, + // xla::HloPassInterface>(m, "GpuSanitizeConstantNames") + // .def(py::init<>()); + + // py::class_, + // CanonicalizeAllGatherForCSE, xla::HloPassInterface>(m, + // "CanonicalizeAllGatherForCSE") + // .def(py::init<>()); + + // // OTHER PASSES: + + // py::class_, xla::HloPassInterface>(m, + // "AllGatherDecomposer") + // .def(py::init>(), + // py::arg("should_decompose")) .def(py::init<>()); + + // py::class_, xla::HloPassInterface>(m, + // "AllReduceSimplifier") + // .def(py::init(), py::arg("replica_count")); + + // py::class_, + // xla::HloPassInterface>(m, "ArCrsCombiner") + // .def(py::init(), py::arg("num_spatial_partitions"), + // py::arg("spmd_partition")); + + // py::class_, xla::HloPassInterface>(m, + // "BFloat16Propagation") + // .def(py::init(), py::arg("bfloat16_support")); + + // py::class_, xla::HloPassInterface>(m, + // "ConditionalCodeMotion") + // .def(py::init(), py::arg("is_layout_sensitive"), + // py::arg("pursue_full_conditional_code_motion"), + // py::arg("search_config") = 0); + + // py::class_, xla::HloPassInterface>(m, + // "ConvolutionGroupConverter") + // .def(py::init, + // std::function, bool, bool>(), + // py::arg("should_expand"), py::arg("is_cost_viable"), + // py::arg("convert_batch_groups_only"), py::arg("filter_expansion") = + // true); + + // py::class_, + // xla::HloPassInterface>(m, "CopyInsertion") + // .def(py::init(), + // py::arg("can_share_buffer") = nullptr, + // py::arg("use_region_based_live_range_analysis") = + // kUseRegionAnalysisLimit); + + // py::class_, + // xla::HloPassInterface>(m, "HloDomainIsolator") + // .def(py::init(), py::arg("creator_factory_")); + + // py::class_, + // xla::HloPassInterface>(m, "HloDomainRemover") + // .def(py::init(), py::arg("kind"), + // py::arg("DomainMetadata::Domain&"), py::arg("metadata")); + + // py::class_, + // xla::HloPassInterface>(m, "HloDomainVerifier") + // .def(py::init>(), py::arg("kinds")); + + // py::class_, xla::HloPassInterface>(m, + // "HloElementTypeConverter") + // .def(py::init(), + // py::arg("eliminate_type"), py::arg("replace_with_type")); + + // py::class_, xla::HloPassInterface>(m, + // "HloMemoryScheduler") + // .def(py::init(), py::arg("size_function"), + // py::arg("algorithm") = {}); + + // py::class_, xla::HloPassInterface>(m, + // "HloRematerialization") + // .def(py::init(), + // py::arg("size_function"), py::arg("memory_limit_bytes"), + // py::arg("sizes"), py::arg("pass_location"), + // py::arg("block_size_limit"), py::arg("block_rematerialization_factor"), + // py::arg("compact_shape_function") = nullptr, py::arg("mode") = + // RematerializationMode::kRecomputeAndCompress, py::arg("min_remat_size") + // = 0); + + // py::class_, + // xla::HloPassInterface>(m, "InstructionFusion") + // .def(py::init, + // bool, FusionConfigCollection>(), py::arg("is_expensive"), + // py::arg("may_duplicate") = true, py::arg("config_collection_mode") = + // FusionConfigCollection::kOff); + + // py::class_, + // xla::HloPassInterface>(m, "LayoutAssignment") + // .def(py::init(), + // py::arg("entry_computation_layout"), py::arg("channel_constraints") = + // nullptr, py::arg("reverse_computation_order") = false); + + // py::class_, + // xla::HloPassInterface>(m, "OperandsMustBeTheSameLayoutAssignment") + // .def(py::init(), + // py::arg("entry_computation_layout")); + + // py::class_, CpuLayoutAssignment, + // xla::HloPassInterface>(m, "CpuLayoutAssignment") + // .def(py::init(), py::arg("entry_computation_layout"), + // py::arg("target_machine_features"), py::arg("channel_constraints") = + // nullptr); + + // py::class_, xla::HloPassInterface>(m, + // "TriangularSolveExpander") + // .def(py::init(), py::arg("block_size") = 128); + + // py::class_, xla::HloPassInterface>(m, + // "SpaceToBatchConverter") + // .def(py::init(), py::arg("ctrl")); + + // py::class_, + // xla::HloPassInterface>(m, "TopkRewriter") + // .def(py::init>(), + // py::arg("HloSortInstruction*"), py::arg("is_profitable_to_convert")); + + // py::class_, xla::HloPassInterface>(m, + // "TreeReductionRewriter") + // .def(py::init(), py::arg("reduce_window_size") = 32); + + // py::class_, xla::HloPassInterface>(m, + // "WhileLoopConcatCodeMotion") + // .def(py::init(), py::arg("min_operand_count_to_optimize")); + + // py::class_, + // xla::HloPassInterface>(m, "WhileLoopExpensiveInvariantCodeMotion") + // .def(py::init, + // ShapeSizeFunction>(), py::arg("worth_hoisting_individually"), + // py::arg("shape_size_function") = ShapeUtil::ByteSizeOfElements); + + // py::class_, + // xla::HloPassInterface>(m, "WhileLoopInvariantCodeMotion") + // .def(py::init, + // ShapeSizeFunction>(), py::arg("hoist_constants") = false, + // py::arg("hoist_reshapes") = false, py::arg("hoist_other") = true, + // py::arg("hoist_size_inflation_ratio") = absl::nullopt, + // py::arg("shape_size_function") = ShapeUtil::ByteSizeOfElements); + + // py::class_, ConvCanonicalization, + // xla::HloPassInterface>(m, "ConvCanonicalization") + // .def(py::init(), + // py::arg("target_machine_features")); + + // py::class_, ParallelTaskAssigner, + // xla::HloPassInterface>(m, "ParallelTaskAssigner") + // .def(py::init(), py::arg("max_parallelism"), + // py::arg("shape_size"), py::arg("target_machine_features")); + + // py::class_, + // ScheduleAwareCollectiveOpsCSE, xla::HloPassInterface>(m, + // "ScheduleAwareCollectiveOpsCSE") + // .def(py::init(), py::arg("distance_threshold"), + // py::arg("for_replicas")); + + // py::class_, SpmdPartitioner, + // xla::HloPassInterface>(m, "SpmdPartitioner") + // .def(py::init(), + // py::arg("num_partitions"), py::arg("num_replicas"), py::arg("options")) + // .def(py::init(), py::arg("num_partitions"), + // py::arg("num_replicas"), py::arg("options"), + // py::arg("collective_ops_creator")); + + // py::class_, xla::HloPassInterface>(m, + // "HloControlFlowFlattening") + // .def(py::init(), py::arg("options")); +} // NOLINT(readability/fn_size) + +} // namespace hloenv diff --git a/hloenv/python/py_hlo_passes.h b/hloenv/python/py_hlo_passes.h new file mode 100644 index 0000000..310d7c7 --- /dev/null +++ b/hloenv/python/py_hlo_passes.h @@ -0,0 +1,35 @@ +// Copyright 2022 Garena Online Private Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef HLOENV_PYTHON_PY_HLO_PASSES_H_ +#define HLOENV_PYTHON_PY_HLO_PASSES_H_ + +#include + +#include +#include + +#include "hloenv/gpu_backend.h" +#include "hloenv/hlo_module.h" +#include "hloenv/hlo_pass_defs.h" + +namespace py = pybind11; + +namespace hloenv { + +void py_init_hlo_passes(const py::module& m); + +} // namespace hloenv + +#endif // HLOENV_PYTHON_PY_HLO_PASSES_H_ diff --git a/hloenv/schedule.h b/hloenv/schedule.h new file mode 100644 index 0000000..f1fff0c --- /dev/null +++ b/hloenv/schedule.h @@ -0,0 +1,258 @@ +// Copyright 2022 Garena Online Private Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef HLOENV_SCHEDULE_H_ +#define HLOENV_SCHEDULE_H_ + +#include +#include +#include +#include + +#include "hloenv/hlo_module.h" +#include "tensorflow/compiler/xla/service/gpu/gpu_compiler.h" +#include "tensorflow/compiler/xla/service/hlo_computation.h" +#include "tensorflow/compiler/xla/service/hlo_instruction.h" +#include "tensorflow/compiler/xla/service/hlo_module.h" +#include "tensorflow/compiler/xla/service/hlo_pass_interface.h" + +namespace hloenv { + +#define CASE_NO_ARG_PASS(PASS_NAME, NAMESPACE) \ + case PassType::PASS_NAME: \ + pass_ = std::make_unique(); \ + break; + +#define FIXED_ITERATION_LIMIT 25 + +class PassInterface { + public: + virtual ~PassInterface() = default; + + explicit PassInterface(const std::string name, int loop_count = 1) + : name_(name), loop_count_(loop_count) {} + + const std::string& name() const { return name_; } + + bool changed() const { return changed_; } + + bool complete() const { return complete_; } + + int loop_count() const { return loop_count_; } + + virtual bool IsPipeline() = 0; + + bool Run(std::shared_ptr alt_hlo_module) { + return Run(alt_hlo_module->hlo_module_ptr()); + } + + // Returns true if alternatives are generated, else false if a normal graph + // is generated) + bool Run(xla::HloModule* hlo_module) { + // If loop_count_ == -1, run until there are no longer any changes + // to the hlo_module, up to FIXED_ITERATION_LIMIT times + bool fixed = loop_count_ == -1; + int loop_count = fixed ? FIXED_ITERATION_LIMIT : loop_count_; + + if (complete_) { + LOG(ERROR) << "Running pass/pipeline: " << name() << ", fixed = " << fixed + << ", loop_count_ = " << loop_count + << ", loop_iteration_count_ = " << loop_iteration_count_; + complete_ = false; + changed_ = false; + loop_iteration_count_ = 0; + } else { + LOG(ERROR) << " Continuing pass/pipeline: " << name(); + } + + bool inner_pass_has_alts; + bool changed_this_run; + bool pass_completed; + for (int i = loop_iteration_count_; i < loop_count; i++) { + RunHelperResults run_results = RunHelper(hlo_module); + inner_pass_has_alts = run_results.generated_alts; + changed_this_run = run_results.changed; + pass_completed = run_results.completed; + + if (pass_completed) { + loop_iteration_count_++; + changed_ |= changed_this_run; + complete_ = loop_iteration_count_ >= loop_count; + } + + // Pass generated alts, hand control back to user to apply alts + if (inner_pass_has_alts) { + return true; + } + + if (!changed_this_run && fixed) { + break; + } + hlo_module->Cleanup(); + } + + complete_ = true; + return false; // If we get here, no alts were generated + } + + struct RunHelperResults { + bool generated_alts; + bool changed; + bool completed; + }; + + private: + // Run the pass on the given HLO module. Returns whether it generated alts + // and whether it changed the hlo_module. + virtual RunHelperResults RunHelper(xla::HloModule* hlo_module) = 0; + + const std::string name_; + int loop_count_; + + int loop_iteration_count_ = 0; + bool changed_ = false; + bool complete_ = true; +}; + +class Pass : public PassInterface { + public: + explicit Pass(std::shared_ptr hlo_pass, + int loop_count = 1) + : PassInterface(std::string(hlo_pass->name()), loop_count), + hlo_pass_(std::move(hlo_pass)) {} + + bool IsPipeline() override { return false; }; + + private: + RunHelperResults RunHelper(xla::HloModule* hlo_module) override { + // Single pass never creates alternatives, that's done in the outer Run loop + return {false, hlo_pass_->Run(hlo_module).ValueOrDie(), true}; + } + + std::shared_ptr hlo_pass_; +}; + +class Pipeline : public PassInterface { + public: + explicit Pipeline(const std::string pipeline_name, int loop_count) + : PassInterface(pipeline_name, loop_count) { + passes_ = std::vector>(0); + } + + bool IsPipeline() override { return true; }; + + void AddPass(std::shared_ptr hlo_pass, int count = 1) { + std::shared_ptr pass = std::make_shared(hlo_pass, count); + passes_.push_back(std::move(pass)); + } + + void AddPass(std::shared_ptr pass) { + passes_.push_back(std::move(pass)); + } + + void AddInvariantChecker(std::shared_ptr hlo_pass) { + std::shared_ptr pass = + std::make_shared(hlo_pass, /*loop_count*/ 1); + invariant_checkers_.push_back(std::move(pass)); + } + + void AddInvariantChecker(std::shared_ptr pass) { + invariant_checkers_.push_back(std::move(pass)); + } + + void RunInvariantCheckers(xla::HloModule* hlo_module) { + for (auto invariant_checker : invariant_checkers_) { + invariant_checker->Run(hlo_module); + if (invariant_checker->changed()) { + LOG(FATAL) << "ERROR: Invariant checker must not change the graph!"; + } + } + } + + RunHelperResults RunHelper(xla::HloModule* hlo_module) override { + // New run + if (current_pass_idx_ == 0) { + changed_this_run_ = false; + RunInvariantCheckers(hlo_module); + LOG(ERROR) << "Starting new run of Pipeline " << name(); + } + + bool completed = false; + for (int pass_idx = current_pass_idx_; pass_idx < passes_.size(); + pass_idx++) { + auto& pass = passes_.at(pass_idx); + bool inner_pass_has_alts = pass->Run(hlo_module); + + if (pass->complete()) { + changed_this_run_ |= pass->changed(); + current_pass_idx_ = pass_idx + 1; + completed = current_pass_idx_ >= passes_.size(); + } + if (inner_pass_has_alts) { + // Hand control back to user to apply alts + return {true, changed_this_run_, completed}; + } + } + current_pass_idx_ = 0; + RunInvariantCheckers(hlo_module); + return {false, changed_this_run_, true}; + } + + std::vector>& passes() { return passes_; } + + protected: + bool changed_this_run_ = false; + std::vector> passes_; + + private: + int current_pass_idx_ = 0; + std::vector> invariant_checkers_; +}; + +class AltPipeline : public Pipeline { + public: + explicit AltPipeline(std::shared_ptr pass, int loop_count = 1) + : Pipeline("alt_" + std::string(pass->name()), loop_count) { + flatten_and_copy(std::move(pass)); + } + + void flatten_and_copy(std::shared_ptr pass) { + if (pass->IsPipeline()) { + Pipeline* pipeline = dynamic_cast(pass.get()); + for (auto& sub_pass : pipeline->passes()) { + flatten_and_copy(std::move(sub_pass)); + } + } else { + // Make a copy here, since we may want to run the original + // pass/pipeline separate of this AltPipeline + passes_.push_back(pass); + } + } + + RunHelperResults RunHelper(xla::HloModule* hlo_module) override { + changed_this_run_ = false; + hlo_module->SetDry(true); + for (auto& pass : passes_) { + pass->Run(hlo_module); + changed_this_run_ |= pass->changed(); + } + hlo_module->SetDry(false); + bool generated_alts = changed_this_run_; + return {generated_alts, changed_this_run_, true}; + } +}; + +} // namespace hloenv + +#endif // HLOENV_SCHEDULE_H_ diff --git a/hloenv/utils/BUILD b/hloenv/utils/BUILD new file mode 100644 index 0000000..9dffb33 --- /dev/null +++ b/hloenv/utils/BUILD @@ -0,0 +1,30 @@ +# Copyright 2022 Garena Online Private Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +package(default_visibility = ["//visibility:public"]) + +cc_library( + name = "hlo_utils", + srcs = ["hlo_utils.cc"], + hdrs = ["hlo_utils.h"], + deps = [ + "@com_google_absl//absl/base", + "@com_google_absl//absl/container:flat_hash_map", + "@org_tensorflow//tensorflow/compiler/xla:types", + "@org_tensorflow//tensorflow/compiler/xla:util", + "@org_tensorflow//tensorflow/compiler/xla/service:hlo", + "@org_tensorflow//tensorflow/compiler/xla/tools:hlo_extractor", + "@org_tensorflow//tensorflow/core:lib", + "@org_tensorflow//tensorflow/core:lib_internal", + ], +) diff --git a/hloenv/utils/hlo_utils.cc b/hloenv/utils/hlo_utils.cc new file mode 100644 index 0000000..3a644ae --- /dev/null +++ b/hloenv/utils/hlo_utils.cc @@ -0,0 +1,648 @@ +// Copyright 2022 Garena Online Private Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#include "hloenv/utils/hlo_utils.h" + +#include + +namespace xla { +void GetInstructionAttributesAndCounts(HloInstruction* inst, + std::vector* attrs, + std::vector* attr_counts) { + auto add_enum = [&attrs](int item, int count) { + std::vector one_hot(count, 0); + one_hot[item] = 1; + attrs->insert(attrs->end(), one_hot.begin(), one_hot.end()); + }; + auto add_attr_counts = [&attr_counts](int int_count, int enum_count) { + attr_counts->push_back(int_count); + attr_counts->push_back(enum_count); + }; + attrs->clear(); + attr_counts->clear(); + // We cap the max possible number of dim at 6. + // Covers 99.99% time. + const int kInvalidDim = 6; + // set dim enum size to be 6 + 1 invalid dim + const int kDimEnumSize = 7; + switch (inst->opcode()) { + // dimension indices + case HloOpcode::kBroadcast: + case HloOpcode::kConcatenate: + case HloOpcode::kReduce: + case HloOpcode::kReverse: + case HloOpcode::kTranspose: { + // counts: 0,6 + // pad to six to keep a fixed size + for (int i = 0; i < std::min(6, inst->dimensions().size()); ++i) { + add_enum(/*item=*/inst->dimensions()[i], /*count=*/kDimEnumSize); + } + for (int i = 0; i < std::max(0, (6 - inst->dimensions().size())); + ++i) { + add_enum(/*item=*/kInvalidDim, /*count=*/kDimEnumSize); + } + add_attr_counts(/*int_count=*/0, /*enum_count=*/6 * 7); + break; + } + case HloOpcode::kCompare: { + // counts: 0,2 + auto comp_inst = dynamic_cast(inst); + add_enum(/*item=*/static_cast(comp_inst->direction()), /*count=*/6); + add_enum(/*item=*/static_cast(comp_inst->type()), /*count=*/4); + add_attr_counts(/*int_count=*/0, /*enum_count=*/6 + 4); + break; + } + case HloOpcode::kConvolution: { + // counts: 16,24 + auto conv_inst = dynamic_cast(inst); + // window + auto w_dims = conv_inst->window().dimensions(); + if (w_dims.size() == 2) { + // greped all conv in current hlo dataset + // boldly assume only one 2D window for convolution + // to make sure feature size for kConv is fixed. + for (int d = 0; d < w_dims.size(); ++d) { + attrs->push_back(w_dims[d].size()); + attrs->push_back(w_dims[d].stride()); + attrs->push_back(w_dims[d].padding_low()); + attrs->push_back(w_dims[d].padding_high()); + attrs->push_back(w_dims[d].base_dilation()); + attrs->push_back(w_dims[d].window_dilation()); + attrs->push_back(w_dims[d].window_reversal()); + } + } else { + attrs->resize(14, 0); + } + // feature group count and batch group count + attrs->push_back(inst->feature_group_count()); + attrs->push_back(inst->batch_group_count()); + // dim_labels + auto conv_dims = conv_inst->convolution_dimension_numbers(); + add_enum(/*item=*/conv_dims.input_batch_dimension(), + /*count=*/kDimEnumSize); + add_enum(/*item=*/conv_dims.input_feature_dimension(), + /*count=*/kDimEnumSize); + for (auto input_spatial_dim : conv_dims.input_spatial_dimensions()) { + add_enum(/*item=*/input_spatial_dim, /*count=*/kDimEnumSize); + } + for (int i = 0; i < 6 - conv_dims.input_spatial_dimensions().size(); + ++i) { + add_enum(/*item=*/kInvalidDim, /*count=*/kDimEnumSize); + } + add_enum(/*item=*/conv_dims.kernel_input_feature_dimension(), + /*count=*/kDimEnumSize); + add_enum(/*item=*/conv_dims.kernel_output_feature_dimension(), + /*count=*/kDimEnumSize); + for (auto kernel_spatial_dim : conv_dims.kernel_spatial_dimensions()) { + add_enum(/*item=*/kernel_spatial_dim, /*count=*/kDimEnumSize); + } + for (int i = 0; i < 6 - conv_dims.kernel_spatial_dimensions().size(); + ++i) { + add_enum(/*item=*/kInvalidDim, /*count=*/kDimEnumSize); + } + add_enum(/*item=*/conv_dims.output_batch_dimension(), + /*count=*/kDimEnumSize); + add_enum(/*item=*/conv_dims.output_feature_dimension(), + /*count=*/kDimEnumSize); + for (auto output_spatial_dim : conv_dims.output_spatial_dimensions()) { + add_enum(/*item=*/output_spatial_dim, /*count=*/kDimEnumSize); + } + for (int i = 0; i < 6 - conv_dims.output_spatial_dimensions().size(); + ++i) { + add_enum(/*item=*/kInvalidDim, /*count=*/kDimEnumSize); + } + add_attr_counts(/*int_count=*/16, /*enum_count=*/24 * 7); + break; + } + case HloOpcode::kDot: { + // counts: 0,25 + auto dot_inst = dynamic_cast(inst); + auto dot_dims = dot_inst->dot_dimension_numbers(); + for (auto lhs_batch_dim : dot_dims.lhs_batch_dimensions()) { + add_enum(/*item=*/lhs_batch_dim, /*count=*/kDimEnumSize); + } + for (int i = 0; i < 6 - dot_dims.lhs_batch_dimensions().size(); ++i) { + add_enum(/*item=*/kInvalidDim, /*count=*/kDimEnumSize); + } + for (auto lhs_c_dim : dot_dims.lhs_contracting_dimensions()) { + add_enum(/*item=*/lhs_c_dim, /*count=*/kDimEnumSize); + } + for (int i = 0; i < 6 - dot_dims.lhs_contracting_dimensions().size(); + ++i) { + add_enum(/*item=*/kInvalidDim, /*count=*/kDimEnumSize); + } + for (auto rhs_batch_dim : dot_dims.rhs_batch_dimensions()) { + add_enum(/*item=*/rhs_batch_dim, /*count=*/kDimEnumSize); + } + for (int i = 0; i < 6 - dot_dims.rhs_batch_dimensions().size(); ++i) { + add_enum(/*item=*/kInvalidDim, /*count=*/kDimEnumSize); + } + for (auto rhs_c_dim : dot_dims.rhs_contracting_dimensions()) { + add_enum(/*item=*/rhs_c_dim, /*count=*/kDimEnumSize); + } + for (int i = 0; i < 6 - dot_dims.rhs_contracting_dimensions().size(); + ++i) { + add_enum(/*item=*/kInvalidDim, /*count=*/kDimEnumSize); + } + // we force to take only one precision config. 0 is default, 1 and 2 are + // high and highest separately. + auto operand_precision = dot_inst->precision_config().operand_precision(); + if (operand_precision.size() > 0) { + add_enum(/*item=*/static_cast(operand_precision[0]), /*count=*/3); + } else { + add_enum(/*item=*/0, /*count=*/3); + } + add_attr_counts(/*int_count=*/0, /*enum_count=*/24 * 7 + 3); + break; + } + case HloOpcode::kDynamicSlice: { + // counts: 6,0 + auto ds_inst = dynamic_cast(inst); + attrs->resize(6, -1); + int idx = 0; + for (auto d : ds_inst->dynamic_slice_sizes()) { + attrs->at(idx++) = d; + } + add_attr_counts(/*int_count=*/6, /*enum_count=*/0); + break; + } + case HloOpcode::kGather: { + // counts: 7,19 + auto gather_inst = dynamic_cast(inst); + auto gather_dims = gather_inst->gather_dimension_numbers(); + attrs->resize(7, -1); + int idx = 0; + attrs->at(idx++) = gather_dims.index_vector_dim(); + for (auto d : gather_inst->gather_slice_sizes()) { + attrs->at(idx++) = d; + } + for (auto offset_dim : gather_dims.offset_dims()) { + add_enum(/*item=*/offset_dim, /*count=*/kDimEnumSize); + } + for (int i = 0; i < 6 - gather_dims.offset_dims().size(); ++i) { + add_enum(/*item=*/kInvalidDim, /*count=*/kDimEnumSize); + } + + for (auto cs_dim : gather_dims.collapsed_slice_dims()) { + add_enum(/*item=*/cs_dim, /*count=*/kDimEnumSize); + } + for (int i = 0; i < 6 - gather_dims.collapsed_slice_dims().size(); ++i) { + add_enum(/*item=*/kInvalidDim, /*count=*/kDimEnumSize); + } + + for (auto s_dim : gather_dims.start_index_map()) { + add_enum(/*item=*/s_dim, /*count=*/kDimEnumSize); + } + for (int i = 0; i < 6 - gather_dims.start_index_map().size(); ++i) { + add_enum(/*item=*/kInvalidDim, /*count=*/kDimEnumSize); + } + add_enum(/*item=*/gather_inst->indices_are_sorted(), /*count=*/2); + add_attr_counts(/*int_count=*/7, /*enum_count=*/18 * 7 + 2); + break; + } + case HloOpcode::kGetTupleElement: { + // counts: 1,0 + auto gte_inst = dynamic_cast(inst); + attrs->push_back(gte_inst->tuple_index()); + add_attr_counts(/*int_count=*/1, /*enum_count=*/0); + break; + } + case HloOpcode::kIota: { + // counts: 0,1 + auto iota_inst = dynamic_cast(inst); + add_enum(/*item=*/std::min(6, iota_inst->iota_dimension()), + /*count=*/kDimEnumSize); + add_attr_counts(/*int_count=*/0, /*enum_count=*/7); + break; + } + case HloOpcode::kPad: { + // counts: 18,0 + auto pad_inst = dynamic_cast(inst); + auto pad_dims = pad_inst->padding_config().dimensions(); + for (auto dim : pad_dims) { + attrs->push_back(dim.edge_padding_low()); + attrs->push_back(dim.edge_padding_high()); + attrs->push_back(dim.interior_padding()); + } + for (int i = 0; i < 6 - pad_dims.size(); ++i) { + attrs->push_back(-1); + attrs->push_back(-1); + attrs->push_back(-1); + } + add_attr_counts(/*int_count=*/18, /*enum_count=*/0); + break; + } + case HloOpcode::kScatter: { + // counts: 1,20 + auto sc_inst = dynamic_cast(inst); + auto scatter_dims = sc_inst->scatter_dimension_numbers(); + attrs->push_back(scatter_dims.index_vector_dim()); + for (auto uw_dim : scatter_dims.update_window_dims()) { + add_enum(/*item=*/uw_dim, /*count=*/kDimEnumSize); + } + for (int i = 0; i < 6 - scatter_dims.update_window_dims().size(); ++i) { + add_enum(/*item=*/kInvalidDim, /*count=*/kDimEnumSize); + } + for (auto iw_dim : scatter_dims.inserted_window_dims()) { + add_enum(/*item=*/iw_dim, /*count=*/kDimEnumSize); + } + for (int i = 0; i < 6 - scatter_dims.inserted_window_dims().size(); ++i) { + add_enum(/*item=*/kInvalidDim, /*count=*/kDimEnumSize); + } + for (auto sd2od_dim : scatter_dims.scatter_dims_to_operand_dims()) { + add_enum(/*item=*/sd2od_dim, /*count=*/kDimEnumSize); + } + for (int i = 0; + i < 6 - scatter_dims.scatter_dims_to_operand_dims().size(); ++i) { + add_enum(/*item=*/kInvalidDim, /*count=*/kDimEnumSize); + } + add_enum(/*item=*/sc_inst->indices_are_sorted(), /*count=*/2); + add_enum(/*item=*/sc_inst->unique_indices(), /*count=*/2); + add_attr_counts(/*int_count=*/1, /*enum_count=*/18 * 7 + 2 * 2); + break; + } + case HloOpcode::kSlice: { + // counts: 18,0 + auto slice_inst = dynamic_cast(inst); + auto slice_starts = slice_inst->slice_starts(); + auto slice_limits = slice_inst->slice_limits(); + auto slice_strides = slice_inst->slice_strides(); + for (int i = 0; i < slice_starts.size(); ++i) { + attrs->push_back(slice_starts[i]); + attrs->push_back(slice_limits[i]); + attrs->push_back(slice_strides[i]); + } + for (int i = 0; i < 6 - slice_starts.size(); ++i) { + attrs->push_back(-1); + attrs->push_back(-1); + attrs->push_back(-1); + } + add_attr_counts(/*int_count=*/18, /*enum_count=*/0); + break; + } + case HloOpcode::kSort: { + // counts: 0,2 + auto sort_inst = dynamic_cast(inst); + add_enum(/*item=*/sort_inst->sort_dimension(), /*count=*/kDimEnumSize); + add_enum(/*item=*/sort_inst->is_stable(), /*count=*/2); + add_attr_counts(/*int_count=*/0, /*enum_count=*/7 + 2); + break; + } + case HloOpcode::kTriangularSolve: { + // counts: 0,4 + auto tri_inst = dynamic_cast(inst); + auto trisol_options = tri_inst->triangular_solve_options(); + add_enum(/*item=*/trisol_options.left_side(), /*count=*/2); + add_enum(/*item=*/trisol_options.lower(), /*count=*/2); + add_enum(/*item=*/trisol_options.unit_diagonal(), /*count=*/2); + add_enum(/*item=*/static_cast(trisol_options.transpose_a()), + /*count=*/4); + add_attr_counts(/*int_count=*/0, /*enum_count=*/2 * 3 + 4); + break; + } + case HloOpcode::kCustomCall: { + // counts: 0,1 + auto cc_inst = dynamic_cast(inst); + auto cc_target = cc_inst->custom_call_target(); + CustomCallTargetType cc_target_enum = + CustomCallTargetStringToEnum(cc_target); + add_enum(/*item=*/cc_target_enum, /*count=*/13); + add_attr_counts(/*int_count=*/0, /*enum_count=*/1 * 13); + break; + } + default: { + // counts: 0,0 + add_attr_counts(/*int_count=*/0, /*enum_count=*/0); + break; + } + } +} + +bool isCommutative(xla::HloInstruction* inst) { + using xla::HloOpcode; + switch (inst->opcode()) { + // nullary ops + case HloOpcode::kConstant: + case HloOpcode::kIota: + case HloOpcode::kParameter: + case HloOpcode::kPartitionId: + case HloOpcode::kReplicaId: + case HloOpcode::kRngGetAndUpdateState: + // unary ops + case HloOpcode::kAbs: + case HloOpcode::kAllGatherDone: + case HloOpcode::kAllReduceDone: + case HloOpcode::kAsyncUpdate: + case HloOpcode::kAsyncDone: + case HloOpcode::kBitcast: + case HloOpcode::kBitcastConvert: + case HloOpcode::kBroadcast: + case HloOpcode::kCeil: + case HloOpcode::kCholesky: + case HloOpcode::kCollectivePermuteDone: + case HloOpcode::kClz: + case HloOpcode::kConvert: + case HloOpcode::kCopy: + case HloOpcode::kCopyDone: + case HloOpcode::kCopyStart: + case HloOpcode::kCos: + case HloOpcode::kDomain: + case HloOpcode::kExp: + case HloOpcode::kExpm1: + case HloOpcode::kFft: + case HloOpcode::kFloor: + case HloOpcode::kGetDimensionSize: + case HloOpcode::kGetTupleElement: + case HloOpcode::kImag: + case HloOpcode::kInfeed: + case HloOpcode::kIsFinite: + case HloOpcode::kLog: + case HloOpcode::kLog1p: + case HloOpcode::kLogistic: + case HloOpcode::kNot: + case HloOpcode::kOptimizationBarrier: + case HloOpcode::kNegate: + case HloOpcode::kPopulationCount: + case HloOpcode::kReal: + case HloOpcode::kRecv: + case HloOpcode::kRecvDone: + case HloOpcode::kReducePrecision: + case HloOpcode::kReshape: + case HloOpcode::kReverse: + case HloOpcode::kRngBitGenerator: + case HloOpcode::kRoundNearestAfz: + case HloOpcode::kRsqrt: + case HloOpcode::kSendDone: + case HloOpcode::kSign: + case HloOpcode::kSin: + case HloOpcode::kSlice: + case HloOpcode::kSqrt: + case HloOpcode::kCbrt: + case HloOpcode::kTanh: + case HloOpcode::kTrace: + case HloOpcode::kTranspose: + case HloOpcode::kWhile: + return true; + + // COMMUTATIVE: + case HloOpcode::kAdd: + case HloOpcode::kAnd: + case HloOpcode::kOr: + case HloOpcode::kXor: + case HloOpcode::kMaximum: + case HloOpcode::kMinimum: + case HloOpcode::kMultiply: + case HloOpcode::kDot: + case HloOpcode::kSort: + case HloOpcode::kAlternatives: + return true; + + // NOT COMMUTATIVE: + case HloOpcode::kAtan2: + case HloOpcode::kDivide: + case HloOpcode::kShiftLeft: + case HloOpcode::kShiftRightArithmetic: + case HloOpcode::kShiftRightLogical: + case HloOpcode::kSubtract: + return false; + + // UNSURE: + // TODO(ohcy): Confirm whether these are not commutative + // binary ops + case HloOpcode::kAddDependency: + case HloOpcode::kCompare: + case HloOpcode::kComplex: + case HloOpcode::kConvolution: + case HloOpcode::kGather: + case HloOpcode::kSetDimensionSize: + case HloOpcode::kOutfeed: + case HloOpcode::kPad: + case HloOpcode::kPower: + case HloOpcode::kRemainder: + case HloOpcode::kSend: + case HloOpcode::kTriangularSolve: + // ternary ops + case HloOpcode::kBatchNormTraining: + case HloOpcode::kClamp: + case HloOpcode::kScatter: + case HloOpcode::kSelect: + case HloOpcode::kSelectAndScatter: + case HloOpcode::kTupleSelect: + // quinary ops + case HloOpcode::kBatchNormGrad: + case HloOpcode::kBatchNormInference: + // variadic ops + case HloOpcode::kAfterAll: + case HloOpcode::kAllGather: + case HloOpcode::kAllGatherStart: + case HloOpcode::kAllReduce: + case HloOpcode::kAllReduceStart: + case HloOpcode::kAllToAll: + case HloOpcode::kAsyncStart: + case HloOpcode::kCall: + case HloOpcode::kCollectivePermute: + case HloOpcode::kCollectivePermuteStart: + case HloOpcode::kConcatenate: + case HloOpcode::kConditional: + case HloOpcode::kCustomCall: + case HloOpcode::kDynamicSlice: + case HloOpcode::kDynamicUpdateSlice: + case HloOpcode::kFusion: + case HloOpcode::kMap: + case HloOpcode::kReduce: + case HloOpcode::kReduceScatter: + case HloOpcode::kReduceWindow: + case HloOpcode::kDynamicReshape: + case HloOpcode::kRng: + case HloOpcode::kTuple: + return false; + default: + // We should not get here + LOG(FATAL) << "Unrecognized Hlo Instruction: " << inst->opcode(); + } + return false; +} + +uint64_t HloModuleHash(xla::HloModule* module) { + HloModuleHashWrapper hash_wrapper = HloModuleHashWrapper(module); + return absl::HashOf(hash_wrapper); +} + +// Note that calling FindInstruction() on a large/full hlo module is not +// the intended way to use this function. +HloInstruction* FindInstruction(HloModule* module, HloOpcode opcode) { + for (const HloComputation* c : module->computations()) { + auto instructions = c->instructions(); + auto it = absl::c_find_if( + instructions, [&](HloInstruction* i) { return i->opcode() == opcode; }); + if (it != instructions.end()) { + return *it; + } + } + return nullptr; +} + +std::unique_ptr ExtractRandomSubmodule( + const std::unique_ptr& module, int instruction_count_threshold, + int height) { + // Return nullptr if total instruction count is too small + // or instruction count threshold is larger than the total + // instruction count. + const int kInstructionCountThreshold = 10; + if (module->instruction_count() < kInstructionCountThreshold || + instruction_count_threshold > module->instruction_count()) { + return nullptr; + } + // Select a random instruction in a random computation. + auto comps = module->MakeComputationPostOrder(); + // Pick computation only when its instruction count is large enough. + auto filtered_comps = FilterComputations(comps, [](HloComputation* c) { + return c->instruction_count() > kInstructionCountThreshold; + }); + if (filtered_comps.empty()) { + LOG(ERROR) << "no submodule generated!"; + return nullptr; + } + std::random_device device; + std::mt19937 generator(device()); + std::uniform_int_distribution rand_comp(0, filtered_comps.size() - 1); + auto instructions = + filtered_comps[rand_comp(generator)]->MakeInstructionPostOrder(); + std::uniform_int_distribution rand_inst(0, instructions.size() - 1); + auto inst = instructions[rand_inst(generator)]; + auto submodule = ExtractModule(inst, height); + const int kRetry = 10; + int tried = 1; + while (FindInstruction(submodule.get(), HloOpcode::kCall) != nullptr || + submodule->instruction_count() < instruction_count_threshold) { + // Resample + inst = instructions[rand_inst(generator)]; + submodule = ExtractModule(inst, height); + tried++; + if (tried == kRetry) { + LOG(ERROR) << "no submodule generated!"; + return nullptr; + } + } + return submodule; +} + +std::vector>> +ExtractInstructionsAsModule(const HloModule& module, int repeat) { + std::vector>> ret; + for (xla::HloComputation* computation : module.computations()) { + for (auto instruction : computation->instructions()) { + auto instruction_proto = instruction->ToProto(); + // We skip instructions that calls other computations, like call, reduce, + // etc + if (!instruction->called_computations().empty()) { + continue; + } + + // Skip trivial ops + std::unordered_set uninterested_ops = { + xla::HloOpcode::kParameter}; + if (uninterested_ops.count( + xla::StringToHloOpcode(instruction_proto.opcode()) + .ValueOrDie())) { + continue; + } + + absl::flat_hash_map id_to_params; + xla::HloComputation::Builder computation_builder("new_computation"); + + int param_num = 0; + // Build params + for (int i = 0; i < instruction->operand_count(); i++) { + auto parameter = xla::HloInstruction::CreateParameter( + param_num++, instruction->operand(i)->shape(), + "param" + std::to_string(i)); + id_to_params.try_emplace(instruction->operand(i)->unique_id(), + parameter.get()); + computation_builder.AddInstruction(std::move(parameter)); + } + // Build instructions + xla::HloInstruction* last_instruction = nullptr; + for (int rep = 0; rep < repeat; rep++) { + auto new_instruction = xla::HloInstruction::CreateFromProto( + instruction_proto, id_to_params, {}) + .ValueOrDie(); + new_instruction->ClearUniqueIdInternal(); + if (last_instruction != nullptr) { + // old must run before new instruction + CHECK(last_instruction->AddControlDependencyTo(new_instruction.get()) + .ok()); + } + last_instruction = new_instruction.get(); + computation_builder.AddInstruction(std::move(new_instruction)); + } + auto new_computation = computation_builder.Build(last_instruction); + + xla::HloModuleConfig config; + std::unique_ptr module = + std::make_unique("module", config); + module->AddEntryComputation(std::move(new_computation)); + ret.emplace_back(std::make_pair(last_instruction, std::move(module))); + } + } + return ret; +} + +std::vector> ExtractFusionsAsModule( + const HloModule& module, int repeat) { + std::vector> ret; + xla::HloComputation* computation = module.entry_computation(); + for (auto instruction : computation->instructions()) { + // find fusion instructions + if (instruction->opcode() == xla::HloOpcode::kFusion) { + std::vector params; + xla::HloComputation::Builder computation_builder("fused_comp"); + + int param_num = 0; + // Build params + for (int i = 0; i < instruction->operand_count(); i++) { + auto parameter = xla::HloInstruction::CreateParameter( + param_num++, instruction->operand(i)->shape(), + "param" + std::to_string(i)); + params.emplace_back(parameter.get()); + computation_builder.AddInstruction(std::move(parameter)); + } + xla::HloModuleConfig config; + std::unique_ptr module = + std::make_unique("module", config); + // Repeat repeat times, add control dependency + xla::HloInstruction* last_fusion = nullptr; + for (int rep = 0; rep < repeat; rep++) { + // Add fusion itself and fused_computation (clone) + auto new_fused_computation = module->AddEmbeddedComputation( + instruction->fused_instructions_computation()->Clone("clone")); + auto cloned_fusion = absl::make_unique( + instruction->shape(), instruction->fusion_kind(), params, + new_fused_computation); + if (last_fusion != nullptr) { + // old must run before new instruction + CHECK(last_fusion->AddControlDependencyTo(cloned_fusion.get()).ok()); + } + last_fusion = cloned_fusion.get(); + computation_builder.AddInstruction(std::move(cloned_fusion)); + } + auto new_computation = computation_builder.Build(last_fusion); + module->AddEntryComputation(std::move(new_computation)); + // emplace_back to vector + ret.emplace_back(std::move(module)); + } + } + return ret; +} + +} // namespace xla diff --git a/hloenv/utils/hlo_utils.h b/hloenv/utils/hlo_utils.h new file mode 100644 index 0000000..ccebaf5 --- /dev/null +++ b/hloenv/utils/hlo_utils.h @@ -0,0 +1,318 @@ +// Copyright 2022 Garena Online Private Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef HLOENV_UTILS_HLO_UTILS_H_ +#define HLOENV_UTILS_HLO_UTILS_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "absl/container/flat_hash_map.h" +#include "absl/container/flat_hash_set.h" +#include "absl/container/inlined_vector.h" +#include "absl/hash/hash.h" +#include "tensorflow/compiler/xla/service/hlo_computation.h" +#include "tensorflow/compiler/xla/service/hlo_instruction.h" +#include "tensorflow/compiler/xla/service/hlo_instructions.h" +#include "tensorflow/compiler/xla/service/hlo_module.h" +#include "tensorflow/compiler/xla/service/hlo_opcode.h" +#include "tensorflow/compiler/xla/tools/hlo_extractor.h" + +namespace xla { + +enum CustomCallTargetType { + kCublasGemm, + kCublasTriSolve, + kCudnnConvBackwardFilter, + kCudnnConvBackwardInput, + kCudnnConvBiasActivationFwd, + kCudnnConvForward, + kCublasTrsmBatched, + kCudaLuPivotsToPerm, + kCudaThreefry, + kCusolverGetrf, + kCusolverPotrf, + kCusolverSyevd, + kUnknownCustomCallTarget, +}; + +inline CustomCallTargetType CustomCallTargetStringToEnum(const std::string& v) { + if (v == "__cublas$gemm") { + return kCublasGemm; + } else if (v == "__cublas$triangularSolve") { + return kCublasTriSolve; + } else if (v == "__cudnn$convBackwardFilter") { + return kCudnnConvBackwardFilter; + } else if (v == "__cudnn$convBackwardInput") { + return kCudnnConvBackwardInput; + } else if (v == "__cudnn$convBiasActivationForward") { + return kCudnnConvBiasActivationFwd; + } else if (v == "__cudnn$convForward") { + return kCudnnConvForward; + } else if (v == "cublas_trsm_batched") { + return kCublasTrsmBatched; + } else if (v == "cuda_lu_pivots_to_permutation") { + return kCudaLuPivotsToPerm; + } else if (v == "cuda_threefry2x32") { + return kCudaThreefry; + } else if (v == "cusolver_getrf") { + return kCusolverGetrf; + } else if (v == "cusolver_potrf") { + return kCusolverPotrf; + } else if (v == "cusolver_syevd") { + return kCusolverSyevd; + } else { + return kUnknownCustomCallTarget; + } +} + +// given an instruction, return its attributes (int vector) +// and attribute counts: +// {2,3,4}, {LE} (out of enum {LE, EQ, GE}), {SAME} (out of {PADDING,SAME}) will +// results: attrs: 2,3,0,3,1,2 attr_counts: 3,2 we assume all dimensions has +// size 6, if less than 6 will pad -1 +// TODO(wangyzh): handle custom-call, custom_call_target, api_version, +// backend_config +void GetInstructionAttributesAndCounts(HloInstruction* inst, + std::vector* attrs, + std::vector* attr_counts); + +bool isCommutative(xla::HloInstruction* inst); + +class HloComputationHashWrapper; + +class HloInstructionHashWrapper { + public: + explicit HloInstructionHashWrapper( + xla::HloInstruction* inst, + std::shared_ptr> operand_hashes, + std::unordered_map* inst_hash_map, + std::unordered_map* comp_hash_map) + : inst_(inst), + operand_hashes_(operand_hashes), + inst_hash_map_(inst_hash_map), + comp_hash_map_(comp_hash_map) {} + + template + friend H AbslHashValue(H h, const HloInstructionHashWrapper& inst_wrapper) { + xla::HloInstruction* inst = inst_wrapper.inst_; + + std::shared_ptr> operand_hashes = + inst_wrapper.operand_hashes_; + std::unordered_map* inst_hash_map = + inst_wrapper.inst_hash_map_; + std::unordered_map* comp_hash_map = + inst_wrapper.comp_hash_map_; + + std::vector opcode_attrs; + std::vector opcode_attr_counts; + GetInstructionAttributesAndCounts(inst, &opcode_attrs, &opcode_attr_counts); + + // Base instruction hash + h = H::combine(std::move(h), inst->opcode(), inst->shape()); + if (inst->opcode() == HloOpcode::kFusion) { + h = H::combine(std::move(h), *inst->fused_expression_root(), + inst->fusion_kind(), inst->fused_instruction_count(), + inst->fused_parameters().size()); + } else if (inst->opcode() == HloOpcode::kConstant) { + // For constants, hash in the literal value + h = H::combine(std::move(h), inst->literal()); + } + + // Hash in instruction attributes + h = H::combine(std::move(h), *inst); + h = H::combine(std::move(h), opcode_attrs, opcode_attr_counts); + + // TODO(ohcy) -> Do we need to handle the special case of + // inst->IsCrossModuleAllReduce()? + + // Add the hash of the computations if it has called_computations + if (inst->called_computations().size() > 0) { + for (xla::HloComputation* comp : inst->called_computations()) { + auto iter = comp_hash_map->find(comp); + uint64_t comp_hash; + // cache the hash of the same computation + if (iter == comp_hash_map->end()) { + HloComputationHashWrapper comp_hash_wrapper = + HloComputationHashWrapper(comp, inst_hash_map, comp_hash_map); + comp_hash = absl::HashOf(comp_hash_wrapper); + comp_hash_map->insert({comp, comp_hash}); + } else { + comp_hash = iter->second; + } + + h = H::combine(std::move(h), comp_hash); + } + } + + // Hash in operand hashes + if (inst->opcode() == HloOpcode::kAlternatives) { + h = H::combine_unordered(std::move(h), operand_hashes->begin(), + operand_hashes->end()); + } else { + for (uint64_t operand_hash : *operand_hashes) { + h = H::combine(std::move(h), operand_hash); + } + // h = H::combine_contiguous(std::move(h), operand_hashes->data(), + // operand_hashes->size()); + } + h = H::combine(std::move(h), operand_hashes->size()); + return h; + } + + private: + xla::HloInstruction* inst_; + std::shared_ptr> operand_hashes_; + std::unordered_map* inst_hash_map_; + std::unordered_map* comp_hash_map_; +}; + +class HloComputationHashWrapper { + public: + explicit HloComputationHashWrapper( + xla::HloComputation* computation, + std::unordered_map* inst_hash_map, + std::unordered_map* comp_hash_map) + : computation_(computation), + inst_hash_map_(inst_hash_map), + comp_hash_map_(comp_hash_map) {} + + template + friend H AbslHashValue(H h, const HloComputationHashWrapper& comp_wrapper) { + std::unordered_map* inst_hash_map = + comp_wrapper.inst_hash_map_; + std::unordered_map* comp_hash_map = + comp_wrapper.comp_hash_map_; + + HloComputation* computation = comp_wrapper.computation_; + + std::vector>>> + stack; + std::shared_ptr> root_operand_hashes = + std::make_shared>(0); + stack.push_back( + {computation->root_instruction(), std::move(root_operand_hashes)}); + + while (!stack.empty()) { + std::tuple>>& + inst_op_pair = stack.back(); + HloInstruction* inst = std::get<0>(inst_op_pair); + std::shared_ptr> operand_hashes = + std::get<1>(inst_op_pair); + size_t operand_hash_count = operand_hashes->size(); + // if this instruction is ready to compute hash + if (operand_hash_count == + inst->operand_count() + inst->control_predecessors().size()) { + // pop it out + stack.pop_back(); + // compute the instruction hash + HloInstructionHashWrapper inst_hash_wrapper = HloInstructionHashWrapper( + inst, operand_hashes, inst_hash_map, comp_hash_map); + uint64_t inst_hash = absl::HashOf(inst_hash_wrapper); + // cache the instruction hash once computed + inst_hash_map->insert({inst, inst_hash}); + // add to its users (which should be the next element in the stack) + if (stack.empty()) { + return H::combine(std::move(h), inst_hash); + } else { + std::get<1>(stack.back())->push_back(inst_hash); + } + } else { + // If the inst is not ready to compute hash + // get its next operand in the row + xla::HloInstruction* operand; + if (operand_hash_count < inst->operand_count()) { + operand = inst->mutable_operand(operand_hash_count); + } else { + operand = inst->control_predecessors().at(operand_hash_count - + inst->operand_count()); + } + auto iter = inst_hash_map->find(operand); + if (iter == inst_hash_map->end()) { + // Push the operand to the end of the stack if its hash doesn't exist + std::shared_ptr> new_operand_hashes = + std::make_shared>(0); + stack.push_back({operand, std::move(new_operand_hashes)}); + } else { + // If operand already has hash cached + operand_hashes->push_back(iter->second); + } + } + } + } + + private: + xla::HloComputation* computation_; + std::unordered_map* inst_hash_map_; + std::unordered_map* comp_hash_map_; +}; + +class HloModuleHashWrapper { + public: + explicit HloModuleHashWrapper(xla::HloModule* module) : module_(module) {} + + template + friend H AbslHashValue(H h, const HloModuleHashWrapper& module_wrapper) { + xla::HloModule* module = module_wrapper.module_; + + std::unordered_map inst_hash_map; + std::unordered_map comp_hash_map; + + h = H::combine(std::move(h), module->entry_computation_layout()); + + xla::HloComputation* entry_computation = module->entry_computation(); + HloComputationHashWrapper comp_hash_wrapper = HloComputationHashWrapper( + entry_computation, &inst_hash_map, &comp_hash_map); + h = H::combine(std::move(h), absl::HashOf(comp_hash_wrapper)); + return h; + } + + private: + xla::HloModule* module_; +}; + +uint64_t HloModuleHash(xla::HloModule* module); + +HloInstruction* FindInstruction(HloModule* module, HloOpcode opcode); + +template +T FilterComputations(const T& comps, Pred predicate) { + T result; + std::copy_if(comps.begin(), comps.end(), std::back_inserter(result), + predicate); + return result; +} + +std::unique_ptr ExtractRandomSubmodule( + const std::unique_ptr& module, int instruction_count_threshold, + int height); + +std::vector>> +ExtractInstructionsAsModule(const HloModule& module, int repeat = 1000); + +std::vector> ExtractFusionsAsModule( + const HloModule& module, int repeat = 1000); + +} // namespace xla + +#endif // HLOENV_UTILS_HLO_UTILS_H_ diff --git a/hloenv/xla_compile.cc b/hloenv/xla_compile.cc new file mode 100644 index 0000000..cdab78a --- /dev/null +++ b/hloenv/xla_compile.cc @@ -0,0 +1,117 @@ +// Copyright 2022 Garena Online Private Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// An example for reading a HloModule from a HloProto file and execute the +// module on PJRT CPU client. + +#include + +#include +#include +#include +#include +#include + +#include "hloenv/hlo_graph.h" +#include "tensorflow/compiler/xla/literal.h" +#include "tensorflow/compiler/xla/literal_util.h" +#include "tensorflow/compiler/xla/pjrt/cpu_device.h" +#include "tensorflow/compiler/xla/pjrt/gpu_device.h" +#include "tensorflow/compiler/xla/pjrt/pjrt_client.h" +#include "tensorflow/compiler/xla/service/cpu/cpu_compiler.h" +#include "tensorflow/compiler/xla/service/gpu/gpu_compiler.h" +#include "tensorflow/compiler/xla/service/hlo_pass_pipeline.h" +#include "tensorflow/compiler/xla/status.h" +#include "tensorflow/compiler/xla/statusor.h" +#include "tensorflow/compiler/xla/tools/hlo_module_loader.h" +#include "tensorflow/core/platform/init_main.h" +#include "tensorflow/core/platform/logging.h" + +DEFINE_string(hlo, "-", "hlo text file"); // by default read from stdin +DEFINE_string(dry, "", "which pass to dry run"); +DEFINE_string(platform, "gpu", "gpu or cpu, defaults to gpu"); + +int main(int argc, char** argv) { + tensorflow::port::InitMain("", &argc, &argv); + gflags::ParseCommandLineFlags(&argc, &argv, true); + + setenv("DRY", FLAGS_dry.c_str(), 1); + xla::HloPassPipeline::dry_sandwich_set = + xla::HloPassPipeline::ExtractDrySandwichSetFromEnv(); + + xla::Intercept cpu_intercept; + xla::Intercept gpu_intercept; + + std::function config_modifier_hook = + [](xla::HloModuleConfig* config) { config->set_seed(42); }; + + // Load HloModule from file. + std::unique_ptr hlo_module; + if (FLAGS_hlo == "-") { + std::stringstream ss; + std::string s; + while (std::getline(std::cin, s)) { + ss << s << "\n"; + } + hlo_module = LoadModuleFromData(ss.str(), "txt", + xla::hlo_module_loader_details::Config(), + config_modifier_hook) + .ValueOrDie(); + } else { + hlo_module = + LoadModuleFromFile(FLAGS_hlo, xla::hlo_module_loader_details::Config(), + "txt", config_modifier_hook) + .ValueOrDie(); + } + const xla::HloModuleProto hlo_module_proto = hlo_module->ToProto(); + + // Run it using JAX C++ Runtime (PJRT). + // Get a CPU client. + + std::unique_ptr client; + if (FLAGS_platform == "gpu") { + client = xla::GetGpuClient(/*asynchronous=*/true, xla::GpuAllocatorConfig(), + nullptr, 0) + .ValueOrDie(); + } else if (FLAGS_platform == "cpu") { + client = xla::GetCpuClient(/*asynchronous=*/true).ValueOrDie(); + } else { + LOG(FATAL) << "Unknown platform " << FLAGS_platform; + } + + // Compile XlaComputation to PjRtExecutable. + xla::XlaComputation xla_computation(hlo_module_proto); + xla::CompileOptions compile_options; + + try { + std::unique_ptr executable = + client->Compile(xla_computation, compile_options).ValueOrDie(); + } catch (xla::Intercept& e) { + cpu_intercept = std::move(e); + } catch (xla::Intercept& e) { + gpu_intercept = std::move(e); + hloenv::HloGraph graph(gpu_intercept.module.get()); + graph.ShowStats(); + gpu_intercept.compiler->RunHloPasses(gpu_intercept.module.get(), + gpu_intercept.stream_exec, + gpu_intercept.options); + } + + // intercept.compiler->RunHloPasses(intercept.module.get(), + // intercept.stream_exec, intercept.options); + + /// There's a very long chain here + /// pjrtclient -> local_client -> local_service -> service -> BuildExecutable + /// -> backend->compiler->RunHloPasses +} diff --git a/setup.cfg b/setup.cfg new file mode 100644 index 0000000..984b42c --- /dev/null +++ b/setup.cfg @@ -0,0 +1,41 @@ +[metadata] +name = hloenv +version = 0.0.1 +author = "sail developers" +author_email = "sail@sea.com" +description = "hloenv" +long_description = file: README.md +long_description_content_type = text/markdown +url = https://github.com/sail-sg/hloenv.git +project_urls = + Bug Tracker = https://github.com/sail-sg/hloenv/issues +classifiers = + Programming Language :: Python :: 3 + License :: OSI Approved :: MIT License + Operating System :: OS Independent + +scripts = hloenv/extract_subgraph + +[options] +packages = find: +python_requires = >=3.6 +install_requires = + +[options.packages.find] +include = hloenv* + +[options.package_data] +hloenv = python/*.so + * + +[yapf] +based_on_style = yapf +spaces_before_comment = 2 +dedent_closing_brackets = true +column_limit = 79 +continuation_indent_width = 2 + +[flake8] +exclude = + .git +indent_size = 2 diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..510d457 --- /dev/null +++ b/setup.py @@ -0,0 +1,34 @@ +#!/usr/bin/env python3 + +from setuptools import setup +from setuptools.command.install import install +from setuptools.dist import Distribution + +import os + +class InstallPlatlib(install): + """Fix auditwheel error, https://github.com/google/or-tools/issues/616""" + + def finalize_options(self) -> None: + install.finalize_options(self) + if self.distribution.has_ext_modules(): + self.install_lib = self.install_platlib + + +class BinaryDistribution(Distribution): + + def is_pure(self) -> bool: + return False + + def has_ext_modules(foo) -> bool: + return True + +def get_version() -> str: + # https://packaging.python.org/guides/single-sourcing-package-version/ + with open(os.path.join(".", "hloenv", "__init__.py"), "r") as f: + init = f.read().split() + return init[init.index("__version__") + 2][1:-1] + +if __name__ == '__main__': + setup(distclass=BinaryDistribution, cmdclass={'install': InstallPlatlib}, + version=get_version()) diff --git a/tests/BUILD b/tests/BUILD new file mode 100644 index 0000000..382a184 --- /dev/null +++ b/tests/BUILD @@ -0,0 +1,73 @@ +load("@org_tensorflow//tensorflow:tensorflow.bzl", "tf_cc_test") +# load("@locked_deps//:requirements.bzl", "requirement") + +py_test( + name = "hlo_env_test", + srcs = ["hlo_env_test.py"], + data = [":test_data"], + deps = [ + "//hloenv", + requirement("absl-py"), + ], +) + +tf_cc_test( + name = "hlo_graph_test", + srcs = ["hlo_graph_test.cc"], + linkstatic = 1, + deps = [ + "//hloenv:hlo_graph", + "@com_google_googletest//:gtest_main", + "@org_tensorflow//tensorflow/compiler/xla:literal", + "@org_tensorflow//tensorflow/compiler/xla:literal_util", + "@org_tensorflow//tensorflow/compiler/xla:shape_util", + ], +) + +tf_cc_test( + name = "evaluator_test", + srcs = ["evaluator_test.cc"], + data = [ + ":test_data", + ], + linkstatic = 1, + deps = [ + "//hloenv/evaluation:evaluator", + "@com_google_googletest//:gtest_main", + "@org_tensorflow//tensorflow/compiler/xla/pjrt:cpu_device", + "@org_tensorflow//tensorflow/compiler/xla/service:hlo", + "@org_tensorflow//tensorflow/compiler/xla/tools:hlo_module_loader", + ], +) + +tf_cc_test( + name = "cycle_detection_test", + srcs = ["cycle_detection_test.cc"], + linkstatic = 1, + deps = [ + "@com_google_googletest//:gtest_main", + "@org_tensorflow//tensorflow/compiler/xla/service:hlo", + ], +) + + +filegroup( + name = "test_data", + srcs = glob([ + "*.txt", + "hlo_texts/*.txt", + "hlo_texts/test_hlos/**/*.txt", + ]), +) + +sh_test( + name = "extract_test", + srcs = ["extract_test.sh"], + args = [ + "$(rootpath //hloenv/bin:extract_subgraphs)", + ], + data = [ + ":test_data", + "//hloenv/bin:extract_subgraphs", + ], +) diff --git a/tests/cycle_detection_test.cc b/tests/cycle_detection_test.cc new file mode 100644 index 0000000..63f3165 --- /dev/null +++ b/tests/cycle_detection_test.cc @@ -0,0 +1,44 @@ + +#include "tensorflow/compiler/xla/service/hlo_reachability.h" +#include "gtest/gtest.h" +#include "tensorflow/compiler/xla/service/hlo_instruction.h" +#include "tensorflow/compiler/xla/literal_util.h" + +namespace xla { +namespace { + +std::unique_ptr CreateNewVerifiedModule() { + HloModuleConfig config; + return absl::make_unique("test_module", config); +} + +TEST(CycleDetectionTestBase, Basic) { + Shape r0f32 = ShapeUtil::MakeShape(F32, {}); + auto builder = HloComputation::Builder("CycleDetection"); + auto constant1 = builder.AddInstruction( + HloInstruction::CreateConstant(LiteralUtil::CreateR0(2.0f))); + auto add1 = builder.AddInstruction(HloInstruction::CreateBinary( + r0f32, HloOpcode::kAdd, constant1, constant1)); + auto add2 = builder.AddInstruction( + HloInstruction::CreateBinary(r0f32, HloOpcode::kAdd, add1, add1)); + auto add3 = builder.AddInstruction( + HloInstruction::CreateBinary(r0f32, HloOpcode::kAdd, add2, add2)); + auto add4 = builder.AddInstruction( + HloInstruction::CreateBinary(r0f32, HloOpcode::kAdd, add3, add3)); + // Create cycle + add1->ReplaceOperandWith(0, add3); + + auto module = CreateNewVerifiedModule(); + auto computation = + module->AddEntryComputation(builder.Build(/*root_instruction=*/add4)); + + std::cout << computation->ToString() << std::endl; + + EXPECT_TRUE(computation->HasCycle()); + EXPECT_TRUE(computation->HasCycle(add1)); + EXPECT_TRUE(computation->HasCycle(add2)); + EXPECT_TRUE(computation->HasCycle(add3)); +} + +} +} // namespace xla diff --git a/tests/evaluator_test.cc b/tests/evaluator_test.cc new file mode 100644 index 0000000..f6ae9fb --- /dev/null +++ b/tests/evaluator_test.cc @@ -0,0 +1,66 @@ +// Copyright 2022 Garena Online Private Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "hloenv/evaluation/evaluator.h" + +#include +#include +#include +#include + +#include "gtest/gtest.h" +#include "tensorflow/compiler/xla/pjrt/cpu_device.h" +#include "tensorflow/compiler/xla/tools/hlo_module_loader.h" + +namespace xla { +namespace { + +std::unique_ptr GetHloModule(const std::string& fn) { + std::string hlo_filename = "tests/" + fn; + std::function config_modifier_hook = + [](xla::HloModuleConfig* config) { config->set_seed(42); }; + std::unique_ptr ret = + LoadModuleFromFile(hlo_filename, xla::hlo_module_loader_details::Config(), + "txt", config_modifier_hook) + .ValueOrDie(); + return ret; +} + +TEST(EvaluatorTestBase, Basic) { + std::unique_ptr hlo = GetHloModule("hlo_texts/fn_hlo.txt"); + hloenv::Evaluator evaluator; + auto client = xla::GetCpuClient(true).ValueOrDie(); + evaluator.Compile(hlo->ToProto(), /* rerun_hlo = */ false, client.get()); + + std::vector seeds = {1, 10086, 1, 2, 10086}; + std::unordered_map> seed_to_results; + for (int seed : seeds) { + evaluator.GenerateParameters(seed); + auto result = evaluator.Evaluate(); + for (absl::Duration duration : result.durations) { + EXPECT_GT(duration, absl::Nanoseconds(1)); + } + auto literal = result.output[0][0]->ToLiteralSync().ValueOrDie(); + if (seed_to_results.count(seed)) { + EXPECT_EQ(*literal, *seed_to_results[seed]); + } else { + seed_to_results[seed] = literal; + } + } + EXPECT_NE(*seed_to_results[1], *seed_to_results[10086]); + EXPECT_NE(*seed_to_results[2], *seed_to_results[10086]); +} + +} // namespace +} // namespace xla diff --git a/tests/extract_test.sh b/tests/extract_test.sh new file mode 100755 index 0000000..7b9deb5 --- /dev/null +++ b/tests/extract_test.sh @@ -0,0 +1,3 @@ +#!/usr/bin/env bash + +find tests/hlo_texts -name "*.txt" | xargs -I{} sh -c "$1 --hlo {} || exit 255" diff --git a/tests/hlo_env_test.py b/tests/hlo_env_test.py new file mode 100644 index 0000000..9d44566 --- /dev/null +++ b/tests/hlo_env_test.py @@ -0,0 +1,1739 @@ +# Copyright 2022 Garena Online Private Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +import random + +from absl import logging +from absl.testing import absltest + +from pass_pipelines import SingleFusionPipeline, GeneralFusionPipeline + +# We consider hlos with more instructions than this number to be "large" +# For these hlos, we should no allow selecting original +LARGE_HLO_INSTRUCTION_MIN = 100 + +SELECT_ORIGINAL_CHANCE = 0.05 + + +def get_rand_action(num_operands, allow_original=True): + select_original = random.random() <= SELECT_ORIGINAL_CHANCE + if select_original and allow_original: + return 0 + else: + return random.randrange(1, num_operands) + + +class HloEnvTest(absltest.TestCase): + """Placeholder for some real tests + """ + + def setUp(self) -> None: + logging.set_verbosity(logging.INFO) + logging.info("setting up") + dir_path = os.path.dirname(os.path.realpath(__file__)) + "/hlo_texts" + + self.hlo_main_test_file = dir_path + "/hlo_test.txt" + + def test_import(self) -> None: + import hloenv + + import tensorflow + logging.info("hloenv module imported at %s", hloenv) + + @absltest.skipIf(("GITLAB_CI" in os.environ), "Running in gitlab ci") + def test_graph_interfaces(self) -> None: + from hloenv import HloEnv + hlo_env = HloEnv(self.hlo_main_test_file, "gpu") + hlo_graph = hlo_env.get_hlo_graph() + + assert (len(hlo_graph.out_edge_offsets) > 0) + assert (len(hlo_graph.out_edge_indices) > 0) + assert (len(hlo_graph.in_edge_offsets) > 0) + assert (len(hlo_graph.in_edge_indices) > 0) + + _ = hlo_graph.alternative_indices + _ = hlo_graph.hash() + node_features = hlo_graph.node_features + in_edge_features = hlo_graph.in_edge_features + out_edge_features = hlo_graph.out_edge_features + + num_nodes = len(node_features.uids) + assert (num_nodes > 0) + assert (len(hlo_graph.opcode_attr_counts) == 236) + assert ( + len(node_features.opcode_attrs) == sum(node_features.num_opcode_attrs) + ) + assert (len(node_features.names) == num_nodes) + assert (len(node_features.gids) == num_nodes) + assert (len(node_features.num_users) == num_nodes) + assert (len(node_features.num_operands) == num_nodes) + assert (len(node_features.opcodes) == num_nodes) + assert (len(node_features.is_alternative) == num_nodes) + assert (len(node_features.is_in_fusion) == num_nodes) + assert (len(node_features.normalized_num_group_inst) == num_nodes) + assert (len(node_features.in_tensor_sizes) == num_nodes) + assert (len(node_features.out_tensor_sizes) == num_nodes) + _ = node_features.has_max_in_tensor + _ = node_features.has_max_out_tensor + + num_in_edges = len(in_edge_features.uids) + assert (num_in_edges > 0) + assert (len(in_edge_features.srcs) == num_in_edges) + assert (len(in_edge_features.dsts) == num_in_edges) + assert (len(in_edge_features.dims) == num_in_edges * 8) + assert (len(in_edge_features.layouts) == num_in_edges * 8) + assert (len(in_edge_features.lehmercodes) == num_in_edges * 8) + assert (len(in_edge_features.dtypes) == num_in_edges) + assert (len(in_edge_features.types) == num_in_edges) + _ = in_edge_features.get_tensor_size(0) + + num_out_edges = len(out_edge_features.uids) + assert (len(out_edge_features.srcs) == num_out_edges) + assert (len(out_edge_features.dsts) == num_out_edges) + assert (len(out_edge_features.dims) == num_out_edges * 8) + assert (len(out_edge_features.layouts) == num_out_edges * 8) + assert (len(out_edge_features.lehmercodes) == num_out_edges * 8) + assert (len(out_edge_features.dtypes) == num_out_edges) + assert (len(in_edge_features.types) == num_out_edges) + + @absltest.skipIf(("GITLAB_CI" in os.environ), "Running in gitlab ci") + def test_alt_hlo_module(self) -> None: + from random import randrange + + import numpy as np + from hloenv import HloEnv, HloModule + + import tensorflow + + hlo_env = HloEnv(self.hlo_main_test_file, "gpu") + + hlo_module_ref = HloModule(self.hlo_main_test_file) + hlo_module_str_ref = hlo_module_ref.to_string() + hlo_module_hash_ref = hlo_module_ref.hash() + + hlo_module_from_ir = hlo_env.get_hlo_module() + hlo_module_from_ir_str = hlo_module_from_ir.to_string() + hlo_module_from_ir_hash = hlo_module_from_ir.hash() + + hlo_env_hlo_str = hlo_env.export_hlo_to_str() + hlo_env_hlo_hash = hlo_env.get_hlo_module_hash() + + assert (hlo_module_str_ref == hlo_module_from_ir_str == hlo_env_hlo_str) + assert (hlo_module_hash_ref == hlo_module_from_ir_hash == hlo_env_hlo_hash) + + @absltest.skipIf(("GITLAB_CI" in os.environ), "Running in gitlab ci") + def test_basic(self) -> None: + from random import randrange + + import numpy as np + from hloenv import HloEnv + + import tensorflow + + hlo_env = HloEnv(self.hlo_main_test_file, "gpu") + fusion_pipeline = SingleFusionPipeline(hlo_env) + + hlo_env.run(fusion_pipeline.pre_pass_optimizations) + + num_alts = 1 + count = 1 + while num_alts > 0: + logging.info("\n*****************************************") + logging.info("Pass: %d" % count) + logging.info("Running fusion dry run") + hlo_env.run(fusion_pipeline.pre_dry_pass_passes) + hlo_env.run(fusion_pipeline.pass_dry_run) + hlo_graph = hlo_env.get_hlo_graph(do_hash_verification=False) + node_features = hlo_graph.node_features + num_operands = node_features.num_operands + num_alts = len(hlo_graph.alternative_indices) + + if num_alts > 0: + logging.info("Generating decisions...") + decisions = [] + for alt_idx in hlo_graph.alternative_indices: + node_uid = node_features.uids[alt_idx] + decisions.append([node_uid, get_rand_action(num_operands[alt_idx])]) + + decisions = np.asarray(decisions) + # pass the decision back to compilerp + logging.info("Applying alternatives...") + hlo_env.apply_alternatives(decisions) + hlo_env.run(fusion_pipeline.post_dry_pass_passes) + else: + logging.info("No more alternatives, ending run...") + eval_result = hlo_env.evaluate(1) + total_time = 0 + for eval_time_ns in eval_result.durations: + assert eval_time_ns > 0 + total_time += eval_time_ns + logging.info("Running time estimation: %d ns", total_time / 10) + + count += 1 + + assert (count > 1) + + logging.info("Running fusion_pipeline.post_pass_optimizations...") + hlo_env.run(fusion_pipeline.post_pass_optimizations) + + @absltest.skipIf(("GITLAB_CI" in os.environ), "Running in gitlab ci") + def test_create_from_module_handle(self) -> None: + from random import randrange + + import numpy as np + from hloenv import HloEnv, HloModule + + import tensorflow + + hlo_module = HloModule(self.hlo_main_test_file) + + hlo_env = HloEnv(hlo_module, "gpu") + fusion_pipeline = SingleFusionPipeline(hlo_env) + hlo_env.run(fusion_pipeline.pre_pass_optimizations) + + num_alts = 1 + count = 1 + while num_alts > 0: + logging.info("\n*****************************************") + logging.info("Pass: %d" % count) + logging.info("Running fusion dry run") + hlo_env.run(fusion_pipeline.pre_dry_pass_passes) + hlo_env.run(fusion_pipeline.pass_dry_run) + + saved_hlo_module = hlo_env.clone_hlo() + hlo_env = HloEnv(saved_hlo_module, "gpu") + fusion_pipeline = SingleFusionPipeline(hlo_env) + + hlo_graph = hlo_env.get_hlo_graph(do_hash_verification=False) + node_features = hlo_graph.node_features + num_operands = node_features.num_operands + num_alts = len(hlo_graph.alternative_indices) + + if num_alts > 0: + logging.info("Generating decisions...") + decisions = [] + for alt_idx in hlo_graph.alternative_indices: + node_uid = node_features.uids[alt_idx] + decisions.append([node_uid, get_rand_action(num_operands[alt_idx])]) + + decisions = np.asarray(decisions) + # pass the decision back to compilerp + logging.info("Applying alternatives...") + hlo_env.apply_alternatives(decisions) + hlo_env.run(fusion_pipeline.post_dry_pass_passes) + else: + logging.info("No more alternatives, ending run...") + eval_result = hlo_env.evaluate(1) + for eval_time_ns in eval_result.durations: + assert eval_time_ns > 0 + logging.info("Running time estimation: %d ns", eval_time_ns) + + count += 1 + + assert (count > 1) + logging.info("Running fusion_pipeline.post_pass_optimizations...") + hlo_env.run(fusion_pipeline.post_pass_optimizations) + eval_result = hlo_env.evaluate(1) + for eval_time_ns in eval_result.durations: + assert eval_time_ns > 0 + logging.info("Running time estimation: %d ns", eval_time_ns) + + @absltest.skipIf(("GITLAB_CI" in os.environ), "Running in gitlab ci") + def test_may_duplicate(self) -> None: + from random import randrange + + import numpy as np + from hloenv import HloEnv, AltPipeline, Pass, HloPass + + import tensorflow + + hlo_env = HloEnv(self.hlo_main_test_file, "gpu") + fusion_pipeline = SingleFusionPipeline(hlo_env) + + hlo_env.run(fusion_pipeline.pre_pass_optimizations) + fusion_dry_pass_duplicate = AltPipeline( + Pass(HloPass.GpuInstructionFusion(may_duplicate=True),) + ) + fusion_dry_pass_no_duplicate = AltPipeline( + Pass(HloPass.GpuInstructionFusion(may_duplicate=False),) + ) + + num_alts = 1 + count = 1 + while num_alts > 0: + may_duplicate = count % 2 == 0 + logging.info("\n*****************************************") + logging.info("Pass: %d" % count) + logging.info( + "Running fusion dry run, may_duplicate = %s" % (may_duplicate) + ) + + if may_duplicate: + hlo_env.run(fusion_dry_pass_duplicate) + else: + hlo_env.run(fusion_dry_pass_no_duplicate) + + hlo_graph = hlo_env.get_hlo_graph(do_hash_verification=False) + node_features = hlo_graph.node_features + num_operands = node_features.num_operands + num_alts = len(hlo_graph.alternative_indices) + + if num_alts > 0: + logging.info("Generating decisions...") + decisions = [] + for alt_idx in hlo_graph.alternative_indices: + node_uid = node_features.uids[alt_idx] + decisions.append([node_uid, get_rand_action(num_operands[alt_idx])]) + + decisions = np.asarray(decisions) + # pass the decision back to compilerp + logging.info("Applying alternatives...") + hlo_env.apply_alternatives(decisions) + hlo_env.run(fusion_pipeline.post_dry_pass_passes) + else: + logging.info("No more alternatives, ending run...") + count += 1 + + logging.info("Running fusion_pipeline.post_pass_optimizations...") + hlo_env.run(fusion_pipeline.post_pass_optimizations) + hlo_env.evaluate(1) + + @absltest.skipIf(("GITLAB_CI" in os.environ), "Running in gitlab ci") + def test_save_load(self) -> None: + from hloenv import HloEnv + + # Test normal save/loading + hlo_env = HloEnv(self.hlo_main_test_file, "gpu") + fusion_pipeline = SingleFusionPipeline(hlo_env) + + init_hlo_str = hlo_env.export_hlo_to_str() + init_hlo_hash = hlo_env.get_hlo_module_hash() + saved_hlo_module = hlo_env.clone_hlo() + hlo_env.run(fusion_pipeline.pre_pass_optimizations) + post_fusion_hlo_str = hlo_env.export_hlo_to_str() + post_fusion_hlo_hash = hlo_env.get_hlo_module_hash() + hlo_env.load_hlo(saved_hlo_module) + restored_hlo_hash = hlo_env.get_hlo_module_hash() + restored_hlo_str = hlo_env.export_hlo_to_str() + assert (init_hlo_str != post_fusion_hlo_str) + assert (init_hlo_hash != post_fusion_hlo_hash) + assert (init_hlo_str == restored_hlo_str) + assert (init_hlo_hash == restored_hlo_hash) + + # Test loading from string + hlo_env = HloEnv(self.hlo_main_test_file, "gpu") + fusion_pipeline = SingleFusionPipeline(hlo_env) + + init_hlo_str = hlo_env.export_hlo_to_str() + init_hlo_hash = hlo_env.get_hlo_module_hash() + saved_hlo_module = hlo_env.clone_hlo() + hlo_env.run(fusion_pipeline.pre_pass_optimizations) + post_fusion_hlo_str = hlo_env.export_hlo_to_str() + post_fusion_hlo_hash = hlo_env.get_hlo_module_hash() + hlo_env.load_hlo(init_hlo_str, "txt") + restored_hlo_hash = hlo_env.get_hlo_module_hash() + restored_hlo_str = hlo_env.export_hlo_to_str() + assert (init_hlo_str != post_fusion_hlo_str) + assert (init_hlo_hash != post_fusion_hlo_hash) + assert (init_hlo_str == restored_hlo_str) + assert (init_hlo_hash == restored_hlo_hash) + + @absltest.skipIf(("GITLAB_CI" in os.environ), "Running in gitlab ci") + def test_evaluation(self) -> None: + from random import randrange + + import numpy as np + from hloenv import HloEnv + + hlo_env = HloEnv(self.hlo_main_test_file, "gpu") + fusion_pipeline = SingleFusionPipeline(hlo_env) + + hlo_env.run(fusion_pipeline.pre_pass_optimizations) + saved_hlo_module = hlo_env.clone_hlo() + # Restore back to original, where we only did pre_fusion_optimizations + hlo_env.run(fusion_pipeline.post_pass_optimizations) + + orig_res = hlo_env.evaluate(1) + orig_post_opt_module = hlo_env.clone_hlo() + + hlo_env.load_hlo(saved_hlo_module) + + num_alts = 1 + while num_alts > 0: + hlo_env.run(fusion_pipeline.pre_dry_pass_passes) + hlo_env.run(fusion_pipeline.pass_dry_run) + hlo_graph = hlo_env.get_hlo_graph(do_hash_verification=False) + node_features = hlo_graph.node_features + num_operands = node_features.num_operands + num_alts = len(hlo_graph.alternative_indices) + + if num_alts > 0: + decisions = [] + for alt_idx in hlo_graph.alternative_indices: + node_uid = node_features.uids[alt_idx] + decisions.append([node_uid, get_rand_action(num_operands[alt_idx])]) + + decisions = np.asarray(decisions) + hlo_env.apply_alternatives(decisions) + hlo_env.run(fusion_pipeline.post_dry_pass_passes) + + hlo_env.run(fusion_pipeline.post_pass_optimizations) + mod_res = hlo_env.evaluate(1) + assert (hlo_env.has_equal_output_as(orig_post_opt_module)) + + est_time_orig = sum(orig_res.durations) / len(orig_res.durations) + est_time_mod = sum(mod_res.durations) / len(mod_res.durations) + + logging.info( + "Running time estimation: orig: %d ns, hloenv: %d ns", est_time_orig, + est_time_mod + ) + + assert (len(orig_res.output) == len(mod_res.output)) + for i in range(len(orig_res.output)): + assert (len(orig_res.output[i]) == len(mod_res.output[i])) + for j in range(len(orig_res.output[i])): + assert (len(orig_res.output[i][j]) == len(mod_res.output[i][j])) + for k in range(len(orig_res.output[i][j])): + assert ( + np.allclose(mod_res.output[i][j][k], orig_res.output[i][j][k]) + ) + + @absltest.skipIf(("GITLAB_CI" in os.environ), "Running in gitlab ci") + def test_validation(self) -> None: + from random import randrange + + import numpy as np + from hloenv import HloEnv + + base_dir = os.path.dirname(os.path.realpath(__file__)) + hlo_base_dir = base_dir + "/hlo_texts/test_hlos" + for root, dirs, files in os.walk(hlo_base_dir): + for file in files: + + filepath = os.path.join(root, file) + logging.info("Testing validation for file: " + filepath) + + hlo_env = HloEnv(filepath, "gpu") + fusion_pipeline = SingleFusionPipeline(hlo_env) + instruction_count = hlo_env.get_hlo_module().instruction_count + is_large = instruction_count > LARGE_HLO_INSTRUCTION_MIN + # We can skip this test for large files, since it does not involve + # General Fusion, and is just meant to test alternative generation + if (is_large): + continue + + saved_hlo_module = hlo_env.clone_hlo() + # Original TF pipelines + hlo_env.optimize_hlo_module() + + # Save reference copy of the module after a non dry-run RunHloPasses call + reference_hlo_module = hlo_env.clone_hlo() + hlo_env.load_hlo(saved_hlo_module) + + hlo_env.run(fusion_pipeline.pre_pass_optimizations) + num_alts = 1 + while num_alts > 0: + hlo_env.run(fusion_pipeline.pre_dry_pass_passes) + hlo_env.run(fusion_pipeline.pass_dry_run) + hlo_graph = hlo_env.get_hlo_graph(do_hash_verification=False) + node_features = hlo_graph.node_features + num_operands = node_features.num_operands + num_alts = len(hlo_graph.alternative_indices) + + if num_alts > 0: + decisions = [] + for alt_idx in hlo_graph.alternative_indices: + node_uid = node_features.uids[alt_idx] + decisions.append( + [node_uid, + get_rand_action(num_operands[alt_idx], False)] + ) + + decisions = np.asarray(decisions) + hlo_env.apply_alternatives(decisions) + hlo_env.run(fusion_pipeline.post_dry_pass_passes) + + hlo_env.run(fusion_pipeline.post_pass_optimizations) + post_fusion_module = hlo_env.clone_hlo() + + assert ( + hlo_env.has_equal_output(post_fusion_module, reference_hlo_module) + ) + + @absltest.skipIf(("GITLAB_CI" in os.environ), "Running in gitlab ci") + def test_load_from_string(self) -> None: + from random import randrange + + import numpy as np + from hloenv import HloEnv + + import tensorflow + + def check_load_from_string(hlo_env): + hlo_string = hlo_env.export_hlo_to_str() + hlo_env_loaded_from_str = HloEnv(hlo_string, "txt", "gpu") + assert ( + hlo_env.get_hlo_module_hash() == + hlo_env_loaded_from_str.get_hlo_module_hash() + ) + + base_dir = os.path.dirname(os.path.realpath(__file__)) + hlo_base_dir = base_dir + "/hlo_texts/test_hlos" + + hlo_env = HloEnv( + hlo_base_dir + + "/brax/module_0215.jit__uniform.30.before_optimizations.txt", "gpu" + ) + fusion_pipeline = SingleFusionPipeline(hlo_env) + logging.info( + "Checking load_from_string after: hlo_env = HloEnv(%s, %s)" % + (self.hlo_main_test_file, "gpu") + ) + check_load_from_string(hlo_env) + + hlo_string = hlo_env.export_hlo_to_str() + hlo_env = HloEnv(hlo_string, "txt", "gpu") + fusion_pipeline = SingleFusionPipeline(hlo_env) + + hlo_env.run(fusion_pipeline.pre_pass_optimizations) + logging.info( + "Checking load_from_string after: hlo_env.run(fusion_pipeline.pre_pass_optimizations)" + ) + check_load_from_string(hlo_env) + + num_alts = 1 + count = 1 + while num_alts > 0: + logging.info("\n*****************************************") + logging.info("Pass: %d" % count) + logging.info("Running fusion dry run") + hlo_env.run(fusion_pipeline.pre_dry_pass_passes) + hlo_env.run(fusion_pipeline.pass_dry_run) + logging.info( + "Checking load_from_string after: hlo_env.run(fusion_pipeline.fusion_dry_run)" + ) + check_load_from_string(hlo_env) + + hlo_graph = hlo_env.get_hlo_graph(do_hash_verification=False) + node_features = hlo_graph.node_features + num_operands = node_features.num_operands + num_alts = len(hlo_graph.alternative_indices) + + if num_alts > 0: + logging.info("Generating decisions...") + decisions = [] + for alt_idx in hlo_graph.alternative_indices: + node_uid = node_features.uids[alt_idx] + decisions.append([node_uid, get_rand_action(num_operands[alt_idx])]) + + decisions = np.asarray(decisions) + # pass the decision back to compilerp + logging.info("Applying alternatives...") + hlo_env.apply_alternatives(decisions) + hlo_env.run(fusion_pipeline.post_dry_pass_passes) + logging.info( + "Checking load_from_string after: hlo_env.apply_alternatives" + ) + check_load_from_string(hlo_env) + + else: + logging.info("No more alternatives, ending run...") + count += 1 + + assert (count > 1) + + logging.info("Running fusion_pipeline.post_pass_optimizations...") + hlo_env.run(fusion_pipeline.post_pass_optimizations) + logging.info( + "Checking load_from_string after: hlo_env.run(fusion_pipeline.post_pass_optimizations)" + ) + check_load_from_string(hlo_env) + + @absltest.skipIf(("GITLAB_CI" in os.environ), "Running in gitlab ci") + def test_hash(self) -> None: + from random import randrange + + import numpy as np + from hloenv import HloEnv + + base_dir = os.path.dirname(os.path.realpath(__file__)) + hlo_base_dir = base_dir + "/hlo_texts/test_hlos" + for root, dirs, files in os.walk(hlo_base_dir): + for file in files: + + filepath = os.path.join(root, file) + logging.info("Testing hash for file: " + filepath) + + hlo_env = HloEnv(filepath, "gpu") + fusion_pipeline = SingleFusionPipeline(hlo_env) + + saved_hlo_module = hlo_env.clone_hlo() + cloned_hash = saved_hlo_module.hash() + original_hash = hlo_env.get_hlo_module_hash() + assert (cloned_hash == original_hash) + hlo_env.load_hlo(saved_hlo_module) + + hlo_env.run(fusion_pipeline.pre_pass_optimizations) + saved_hlo_module = hlo_env.clone_hlo() + cloned_hash = saved_hlo_module.hash() + original_hash = hlo_env.get_hlo_module_hash() + assert (cloned_hash == original_hash) + hlo_env.load_hlo(saved_hlo_module) + + num_alts = 1 + while num_alts > 0: + prev_hash = hlo_env.get_hlo_module_hash() + hlo_env.run(fusion_pipeline.pre_dry_pass_passes) + hlo_env.run(fusion_pipeline.pass_dry_run) + + hlo_graph = hlo_env.get_hlo_graph(do_hash_verification=False) + node_features = hlo_graph.node_features + num_operands = node_features.num_operands + num_alts = len(hlo_graph.alternative_indices) + + if num_alts > 0: + # Test that hash changes after run(fusion_pipeline.fusion_dry_run + new_hash = hlo_env.get_hlo_module_hash() + saved_hlo_module = hlo_env.clone_hlo() + cloned_hash = saved_hlo_module.hash() + assert (cloned_hash == new_hash) + assert (prev_hash != new_hash) + hlo_env.load_hlo(saved_hlo_module) + + # Test that hash changes after apply_alternatives + prev_hash = hlo_env.get_hlo_module_hash() + decisions = [] + for alt_idx in hlo_graph.alternative_indices: + node_uid = node_features.uids[alt_idx] + decisions.append( + [node_uid, get_rand_action(num_operands[alt_idx])] + ) + + decisions = np.asarray(decisions) + hlo_env.apply_alternatives(decisions) + new_hash = hlo_env.get_hlo_module_hash() + hlo_env.run(fusion_pipeline.post_dry_pass_passes) + assert (prev_hash != new_hash) + + hlo_env.run(fusion_pipeline.post_pass_optimizations) + + # Test that if we choose the original nodes, graph and graph hash + # stays constant + @absltest.skipIf(("GITLAB_CI" in os.environ), "Running in gitlab ci") + def test_apply_original(self) -> None: + from random import randrange + + import numpy as np + from hloenv import HloEnv + + base_dir = os.path.dirname(os.path.realpath(__file__)) + hlo_base_dir = base_dir + "/hlo_texts/test_hlos" + for root, dirs, files in os.walk(hlo_base_dir): + for file in files: + + filepath = os.path.join(root, file) + logging.info("Testing hash for file: " + filepath) + + hlo_env = HloEnv(filepath, "gpu") + fusion_pipeline = SingleFusionPipeline(hlo_env) + hlo_env.run(fusion_pipeline.pre_pass_optimizations) + + num_alts = 1 + while num_alts > 0: + prev_hash = hlo_env.get_hlo_module_hash() + hlo_env.run(fusion_pipeline.pre_dry_pass_passes) + original_hash = hlo_env.get_hlo_module_hash() + hlo_env.run(fusion_pipeline.pass_dry_run) + + hlo_graph = hlo_env.get_hlo_graph(do_hash_verification=False) + node_features = hlo_graph.node_features + num_operands = node_features.num_operands + num_alts = len(hlo_graph.alternative_indices) + + if num_alts > 0: + # Test that hash does not change after apply_alternatives zero + decisions = [] + for alt_idx in hlo_graph.alternative_indices: + node_uid = node_features.uids[alt_idx] + decisions.append([node_uid, 0]) + + decisions = np.asarray(decisions) + hlo_env.apply_alternatives(decisions) + new_hash = hlo_env.get_hlo_module_hash() + assert (original_hash == new_hash) + + break + + @absltest.skipIf(("GITLAB_CI" in os.environ), "Running in gitlab ci") + def test_extract_instruction(self) -> None: + from hloenv import HloEnv, HloModule + + hlo_env = HloEnv(self.hlo_main_test_file, "gpu") + for (instruction, hlo_graph + ) in hlo_env.get_hlo_module().extract_instructions_as_module(10): + assert (len(instruction) > 0) + assert (len(hlo_graph.to_string()) > 0) + logging.info(instruction) + logging.info(hlo_graph.to_string()) + + @absltest.skipIf(("GITLAB_CI" in os.environ), "Running in gitlab ci") + def test_extract_fusions(self) -> None: + from hloenv import HloEnv, HloModule + + hlo_env = HloEnv(self.hlo_main_test_file, "gpu") + fusion_pipeline = SingleFusionPipeline(hlo_env) + hlo_env.run(fusion_pipeline.pre_pass_optimizations) + hlo_env.run(fusion_pipeline.pre_dry_pass_passes) + hlo_env.run(fusion_pipeline.pass_dry_run) + m = hlo_env.get_hlo_module() + fusions = m.extract_fusions_as_module(10) + assert (len(fusions) > 0) + assert (len(fusions[0].to_string()) > 0) + logging.info(fusions[0].to_string()) + + # Test general pipeline + @absltest.skipIf(("GITLAB_CI" in os.environ), "Running in gitlab ci") + def test_general_pipeline_main(self) -> None: + from random import randrange + + import numpy as np + from hloenv import AltPipeline, HloEnv, HloPass, Pass, Pipeline + + hlo_env = HloEnv(self.hlo_main_test_file, "gpu") + fusion_pipeline = SingleFusionPipeline(hlo_env) + hlo_env.run(fusion_pipeline.pre_pass_optimizations) + + num_alts = 1 + count = 0 + + fusion_pre_pipeline = Pipeline("fusion_pre") + + fusion_pre_pipeline.add_pass(HloPass.VariadicOpSplitter()) + # Note you have to make an Pass, cannot just run the HloPass directly. + fusion_dry_pass = AltPipeline( + Pass( + HloPass.GpuInstructionFusion(True), # may_duplicate + ) + ) + + fusion_post_pipeline = Pipeline(name="fusion_pre") + fusion_post_pipeline.add_pass(HloPass.FusionMerger(), loop_count=1) + # Note: default values for dry_mode is false, loop_count is 1 + fusion_post_pipeline.add_pass(HloPass.GpuMultiOutputFusion()) + fusion_post_pipeline.add_pass(HloPass.HloCSE(True, True)) + + fusion_example_pipeline = Pipeline(name="fusion_pre_hlo_dce") + fusion_example_pipeline.add_pass(HloPass.HloDCE()) + # Note, a pipeline can be added as a pass to a pipeline (can nest this) + fusion_post_pipeline.add_pass(fusion_example_pipeline) + + init_hlo = hlo_env.clone_hlo() + while num_alts > 0: + hlo_env.run(fusion_pre_pipeline) + + # You can run a pass on it's own + hlo_env.run(fusion_dry_pass) + + hlo_graph = hlo_env.get_hlo_graph(do_hash_verification=False) + node_features = hlo_graph.node_features + num_operands = node_features.num_operands + num_alts = len(hlo_graph.alternative_indices) + + if num_alts > 0: + decisions = [] + for alt_idx in hlo_graph.alternative_indices: + node_uid = node_features.uids[alt_idx] + decisions.append([node_uid, min(1, num_operands[alt_idx])]) + + decisions = np.asarray(decisions) + # pass the decision back to compilerp + hlo_env.apply_alternatives(decisions) + hlo_env.run(fusion_post_pipeline) + + count += 1 + + general_count = count + general_pipeline_hlo = hlo_env.clone_hlo() + + hlo_env.load_hlo(init_hlo) + + num_alts = 1 + count = 0 + while num_alts > 0: + logging.info(count) + hlo_env.run(fusion_pipeline.pre_dry_pass_passes) + hlo_env.run(fusion_pipeline.pass_dry_run) + + hlo_graph = hlo_env.get_hlo_graph(do_hash_verification=False) + node_features = hlo_graph.node_features + num_operands = node_features.num_operands + num_alts = len(hlo_graph.alternative_indices) + + if num_alts > 0: + decisions = [] + for alt_idx in hlo_graph.alternative_indices: + node_uid = node_features.uids[alt_idx] + decisions.append([node_uid, min(1, num_operands[alt_idx])]) + + hlo_env.apply_alternatives(decisions) + hlo_env.run(fusion_pipeline.post_dry_pass_passes) + count += 1 + + original_count = count + original_pipeline_hlo = hlo_env.clone_hlo() + + assert (original_count == general_count) + assert ( + hlo_env.has_equal_output(original_pipeline_hlo, general_pipeline_hlo) + ) + + # Test general pipeline run till next dry pass functionality + @absltest.skipIf(("GITLAB_CI" in os.environ), "Running in gitlab ci") + def test_general_pipeline_run_to_dry(self) -> None: + from random import randrange + + import numpy as np + from hloenv import AltPipeline, HloEnv, HloPass, Pass, Pipeline + + hlo_env = HloEnv(self.hlo_main_test_file, "gpu") + fusion_pipeline = SingleFusionPipeline(hlo_env) + hlo_env.run(fusion_pipeline.pre_pass_optimizations) + + num_alts = 1 + count = 0 + + custom_fusion_pipeline = Pipeline("fusion") + + custom_fusion_pipeline.add_pass(HloPass.VariadicOpSplitter()) + fusion_dry_pass = AltPipeline( + Pass( + HloPass.GpuInstructionFusion(may_duplicate=True + ), # Test named arguments + ) + ) + custom_fusion_pipeline.add_pass(fusion_dry_pass) + custom_fusion_pipeline.add_pass(HloPass.FusionMerger()) + custom_fusion_pipeline.add_pass(HloPass.GpuMultiOutputFusion()) + custom_fusion_pipeline.add_pass( + HloPass.HloCSE(True, only_fusion_computations=True) + ) + custom_fusion_pipeline.add_pass(HloPass.HloDCE()) + + init_hlo = hlo_env.clone_hlo() + has_alt = True + while has_alt: + has_alt = hlo_env.run(custom_fusion_pipeline) + logging.info("COUNT: %d, HAS_ALT:%s" % (count, has_alt)) + # We hit a dry run pass + if has_alt: + hlo_graph = hlo_env.get_hlo_graph(do_hash_verification=False) + node_features = hlo_graph.node_features + num_operands = node_features.num_operands + num_alts = len(hlo_graph.alternative_indices) + assert (num_alts > 0) + if num_alts > 0: + decisions = [] + for alt_idx in hlo_graph.alternative_indices: + node_uid = node_features.uids[alt_idx] + decisions.append([node_uid, min(1, num_operands[alt_idx])]) + + decisions = np.asarray(decisions) + # pass the decision back to compilerp + hlo_env.apply_alternatives(decisions) + count += 1 + + # Continue running the rest of the fusion_pipeline + rest_has_alt = hlo_env.run(custom_fusion_pipeline) + # We should have no alts now, since the rest of the passes are not dry + assert (not rest_has_alt) + + general_count = count + general_pipeline_hlo = hlo_env.clone_hlo() + hlo_env.load_hlo(init_hlo) + + num_alts = 1 + count = 0 + while num_alts > 0: + hlo_env.run(fusion_pipeline.pre_dry_pass_passes) + hlo_env.run(fusion_pipeline.pass_dry_run) + + hlo_graph = hlo_env.get_hlo_graph(do_hash_verification=False) + node_features = hlo_graph.node_features + num_operands = node_features.num_operands + num_alts = len(hlo_graph.alternative_indices) + + if num_alts > 0: + decisions = [] + for alt_idx in hlo_graph.alternative_indices: + node_uid = node_features.uids[alt_idx] + decisions.append([node_uid, min(1, num_operands[alt_idx])]) + + hlo_env.apply_alternatives(decisions) + hlo_env.run(fusion_pipeline.post_dry_pass_passes) + count += 1 + + original_count = count + original_pipeline_hlo = hlo_env.clone_hlo() + + assert (original_count == general_count) + assert ( + hlo_env.has_equal_output(original_pipeline_hlo, general_pipeline_hlo) + ) + + # Test general pipeline fixed pipeline functionality + @absltest.skipIf(("GITLAB_CI" in os.environ), "Running in gitlab ci") + def test_general_pipeline_fixed(self) -> None: + from random import randrange + + import numpy as np + from hloenv import AltPipeline, HloEnv, HloPass, Pass, Pipeline + + hlo_env = HloEnv(self.hlo_main_test_file, "gpu") + fusion_pipeline = SingleFusionPipeline(hlo_env) + hlo_env.run(fusion_pipeline.pre_pass_optimizations) + + num_alts = 1 + count = 0 + + custom_fusion_pipeline = Pipeline("fusion-pipeline", loop_count=-1) + + custom_fusion_pipeline.add_pass(HloPass.VariadicOpSplitter()) + fusion_dry_pass = AltPipeline(Pass(HloPass.GpuInstructionFusion(True))) + custom_fusion_pipeline.add_pass(fusion_dry_pass) + custom_fusion_pipeline.add_pass(HloPass.FusionMerger()) + custom_fusion_pipeline.add_pass(HloPass.GpuMultiOutputFusion()) + custom_fusion_pipeline.add_pass(HloPass.HloCSE(True, True)) + custom_fusion_pipeline.add_pass(HloPass.HloDCE()) + + init_hlo = hlo_env.clone_hlo() + has_alt = True + # Since the pipeline is fixed, it will run till there are no changes + while has_alt: + has_alt = hlo_env.run(custom_fusion_pipeline) + # We hit a dry run pass + if has_alt: + hlo_graph = hlo_env.get_hlo_graph(do_hash_verification=False) + node_features = hlo_graph.node_features + num_operands = node_features.num_operands + num_alts = len(hlo_graph.alternative_indices) + if num_alts > 0: + decisions = [] + for alt_idx in hlo_graph.alternative_indices: + node_uid = node_features.uids[alt_idx] + decisions.append([node_uid, min(1, num_operands[alt_idx])]) + + decisions = np.asarray(decisions) + # pass the decision back to compilerp + hlo_env.apply_alternatives(decisions) + count += 1 + + general_count = count + general_pipeline_hlo = hlo_env.clone_hlo() + + hlo_env.load_hlo(init_hlo) + + num_alts = 1 + count = 0 + while num_alts > 0: + hlo_env.run(fusion_pipeline.pre_dry_pass_passes) + hlo_env.run(fusion_pipeline.pass_dry_run) + + hlo_graph = hlo_env.get_hlo_graph(do_hash_verification=False) + node_features = hlo_graph.node_features + num_operands = node_features.num_operands + num_alts = len(hlo_graph.alternative_indices) + + if num_alts > 0: + decisions = [] + for alt_idx in hlo_graph.alternative_indices: + node_uid = node_features.uids[alt_idx] + decisions.append([node_uid, min(1, num_operands[alt_idx])]) + + hlo_env.apply_alternatives(decisions) + hlo_env.run(fusion_pipeline.post_dry_pass_passes) + count += 1 + + original_count = count + original_pipeline_hlo = hlo_env.clone_hlo() + + assert (original_count == general_count) + assert ( + hlo_env.has_equal_output(original_pipeline_hlo, general_pipeline_hlo) + ) + + # Test general pipeline fixed single pass functionality + @absltest.skipIf(("GITLAB_CI" in os.environ), "Running in gitlab ci") + def test_general_pipeline_loop_count(self) -> None: + import numpy as np + from hloenv import AltPipeline, HloEnv, HloPass, Pass, Pipeline + + hlo_env = HloEnv(self.hlo_main_test_file, "gpu") + fusion_pipeline = SingleFusionPipeline(hlo_env) + hlo_env.run(fusion_pipeline.pre_pass_optimizations) + + num_alts = 1 + count = 0 + loop_count = 7 + + fusion_dry_pass = AltPipeline( + Pass(HloPass.GpuInstructionFusion(may_duplicate=True),), + loop_count=loop_count + ) + + init_hlo = hlo_env.clone_hlo() + has_alt = True + while (has_alt): + hlo_env.run(fusion_pipeline.pre_dry_pass_passes) + has_alt = hlo_env.run(fusion_dry_pass) + # We hit a dry run pass + if has_alt: + hlo_graph = hlo_env.get_hlo_graph(do_hash_verification=False) + node_features = hlo_graph.node_features + num_operands = node_features.num_operands + num_alts = len(hlo_graph.alternative_indices) + + # Since pass is not complete, there must be a change, i.e. + # num_alts > 0 + assert (num_alts > 0) + decisions = [] + for alt_idx in hlo_graph.alternative_indices: + node_uid = node_features.uids[alt_idx] + decisions.append([node_uid, min(1, num_operands[alt_idx])]) + + decisions = np.asarray(decisions) + # pass the decision back to compilerp + hlo_env.apply_alternatives(decisions) + hlo_env.run(fusion_pipeline.post_dry_pass_passes) + + count += 1 + + assert (count == loop_count) + assert (hlo_env.has_equal_output_as(init_hlo)) + + # Test general pipeline fixed single pass functionality + @absltest.skipIf(("GITLAB_CI" in os.environ), "Running in gitlab ci") + def test_general_pipeline_fixed_pass(self) -> None: + import numpy as np + from hloenv import AltPipeline, HloEnv, HloPass, Pass, Pipeline + + hlo_env = HloEnv(self.hlo_main_test_file, "gpu") + fusion_pipeline = SingleFusionPipeline(hlo_env) + hlo_env.run(fusion_pipeline.pre_pass_optimizations) + + num_alts = 1 + count = 0 + + fusion_dry_pass = AltPipeline( + Pass(HloPass.GpuInstructionFusion(may_duplicate=True), loop_count=-1) + ) + + init_hlo = hlo_env.clone_hlo() + has_alt = True + while (has_alt): + logging.info(count) + hlo_env.run(fusion_pipeline.pre_dry_pass_passes) + has_alt = hlo_env.run(fusion_dry_pass) + # We hit a dry run pass + if has_alt: + hlo_graph = hlo_env.get_hlo_graph(do_hash_verification=False) + node_features = hlo_graph.node_features + num_operands = node_features.num_operands + num_alts = len(hlo_graph.alternative_indices) + + # Since pass is not complete, there must be a change, i.e. + # num_alts > 0 + assert (num_alts > 0) + decisions = [] + for alt_idx in hlo_graph.alternative_indices: + node_uid = node_features.uids[alt_idx] + decisions.append([node_uid, min(1, num_operands[alt_idx])]) + + decisions = np.asarray(decisions) + # pass the decision back to compilerp + hlo_env.apply_alternatives(decisions) + hlo_env.run(fusion_pipeline.post_dry_pass_passes) + + count += 1 + + assert (count > 1) + assert (hlo_env.has_equal_output_as(init_hlo)) + + # Test general pipeline + @absltest.skipIf(("GITLAB_CI" in os.environ), "Running in gitlab ci") + def test_general_pipeline_identical_hash(self) -> None: + from random import randrange + + import numpy as np + from hloenv import AltPipeline, HloEnv, HloPass, Pass, Pipeline + + hlo_env = HloEnv(self.hlo_main_test_file, "gpu") + fusion_pipeline = SingleFusionPipeline(hlo_env) + hlo_env.run(fusion_pipeline.pre_pass_optimizations) + + num_alts = 1 + count = 0 + + fusion_pre_pipeline = Pipeline("fusion_pre") + + fusion_pre_pipeline.add_pass(HloPass.VariadicOpSplitter()) + # Note you have to make an Pass, cannot just run the HloPass directly. + fusion_dry_pass = AltPipeline( + Pass( + HloPass.GpuInstructionFusion(True), # may_duplicate + ) + ) + + fusion_post_pipeline = Pipeline(name="fusion_pre") + fusion_post_pipeline.add_pass(HloPass.FusionMerger(), loop_count=1) + # Note: default values for dry_mode is false, loop_count is 1 + # We ignore GpuMultiOutputFusion since its changes are undeterministic + # fusion_post_pipeline.add_pass(HloPass.GpuMultiOutputFusion()) + fusion_post_pipeline.add_pass(HloPass.HloCSE(True, True)) + fusion_post_pipeline.add_pass(HloPass.HloDCE()) + + init_hlo = hlo_env.clone_hlo() + while num_alts > 0: + hlo_env.run(fusion_pre_pipeline) + + # You can run a pass on it's own + hlo_env.run(fusion_dry_pass) + + hlo_graph = hlo_env.get_hlo_graph(do_hash_verification=False) + node_features = hlo_graph.node_features + num_operands = node_features.num_operands + num_alts = len(hlo_graph.alternative_indices) + + if num_alts > 0: + decisions = [] + for alt_idx in hlo_graph.alternative_indices: + node_uid = node_features.uids[alt_idx] + decisions.append([node_uid, min(1, num_operands[alt_idx])]) + + decisions = np.asarray(decisions) + # pass the decision back to compilerp + hlo_env.apply_alternatives(decisions) + hlo_env.run(fusion_post_pipeline) + + count += 1 + + general_count = count + general_pipeline_hash = hlo_env.get_hlo_module_hash() + + hlo_env.load_hlo(init_hlo) + + num_alts = 1 + count = 0 + while num_alts > 0: + logging.info(count) + hlo_env.run(fusion_pipeline.pre_dry_pass_passes) + hlo_env.run(fusion_pipeline.pass_dry_run) + + hlo_graph = hlo_env.get_hlo_graph(do_hash_verification=False) + node_features = hlo_graph.node_features + num_operands = node_features.num_operands + num_alts = len(hlo_graph.alternative_indices) + + if num_alts > 0: + decisions = [] + for alt_idx in hlo_graph.alternative_indices: + node_uid = node_features.uids[alt_idx] + decisions.append([node_uid, min(1, num_operands[alt_idx])]) + + hlo_env.apply_alternatives(decisions) + hlo_env.run(fusion_post_pipeline) # So as to exclude MultiOutputFusion + + count += 1 + + original_count = count + original_pipeline_hash = hlo_env.get_hlo_module_hash() + + assert (original_count == general_count) + assert (original_pipeline_hash == general_pipeline_hash) + + # Test general pipeline reproducing the full OptimizeHloModule pipeline + @absltest.skipIf(("GITLAB_CI" in os.environ), "Running in gitlab ci") + def test_general_pipeline_full_optimize_hlo(self) -> None: + from hloenv import AltPipeline, GpuBackend, HloEnv, HloPass, Pass, Pipeline + + hlo_env = HloEnv(self.hlo_main_test_file, "gpu") + hlo_module = hlo_env.get_hlo_module() + config = hlo_module.config + debug_options = config.debug_options + + # ----------------------------------------------------------------------- + # PRE FUSION PIPELINE + # ----------------------------------------------------------------------- + + pre_fusion_pipeline = Pipeline("pre-fusion") + + # -------------------------------------------- + # SPMD Paritioning Pipeline + # -------------------------------------------- + + if (config.use_spmd_partitioning): + spmd_pipeline = Pipeline("spmd-partitioner") + num_partitions = config.num_partitions + if (num_partitions > 1): + spmd_pipeline.add_invariant_checker(HloPass.HloVerifier(False, False)) + + spmd_pipeline.add_pass(HloPass.CallInliner()) + spmd_pipeline.add_pass(HloPass.ZeroSizedHloElimination()) + spmd_pipeline.add_pass(HloPass.ConditionalCanonicalizer()) + + spmd_simplify_pipeline = Pipeline("spmd-simplify", loop_count=-1) + algebraic_config_options = { + "replace_transpose_with_bitcast": False, + "enable_conv_operand_swap": False, + "minmax_propagate_nan": debug_options.xla_gpu_enable_fast_min_max, + } + spmd_simplify_pipeline.add_pass( + HloPass.AlgebraicSimplifier(options=algebraic_config_options) + ) + spmd_simplify_pipeline.add_pass(HloPass.SortSimplifier()) + spmd_simplify_pipeline.add_pass(HloPass.TupleSimplifier()) + spmd_simplify_pipeline.add_pass( + HloPass.ScatterExpander( + HloPass.ScatterExpander.Mode.kEliminateSimpleScatters + ) + ) + spmd_simplify_pipeline.add_pass( + HloPass.GatherExpander( + HloPass.GatherExpander.Mode.kEliminateSimpleGathers + ) + ) + spmd_simplify_pipeline.add_pass(HloPass.WhileLoopConstantSinking()) + spmd_simplify_pipeline.add_pass(HloPass.WhileLoopSimplifier()) + spmd_simplify_pipeline.add_pass(HloPass.ReshapeMover()) + spmd_simplify_pipeline.add_pass(HloPass.HloConstantFolding()) + spmd_simplify_pipeline.add_pass(HloPass.ConditionalSimplifier()) + spmd_simplify_pipeline.add_pass(HloPass.HloDCE()) + spmd_pipeline.add_pass(spmd_simplify_pipeline) + + spmd_pipeline.add_pass(HloPass.ShardingPropagation(True)) + spmd_pipeline.add_pass( + HloPass.StatefulRngSpmdPartitioner( + num_partitions, config.replica_count + ) + ) + else: + spmd_simplify_pipeline.add_pass(HloPass.ShardingRemover()) + spmd_simplify_pipeline.add_pass(HloPass.HloDCE()) + + pre_fusion_pipeline.add_pass(spmd_pipeline) + + # -------------------------------------------- + # Optimization Pipeline + # -------------------------------------------- + + optimization_pipeline = Pipeline("optimization") + optimization_pipeline.add_invariant_checker( + HloPass.HloVerifier(False, False) + ) + + optimization_pipeline.add_pass(HloPass.AllToAllDecomposer()) + optimization_pipeline.add_pass(HloPass.OperandUpcaster()) + optimization_pipeline.add_pass(HloPass.ResultCaster()) + optimization_pipeline.add_pass(HloPass.RngExpander()) + optimization_pipeline.add_pass( + HloPass.RngBitGeneratorExpander( + HloPass.RngBitGeneratorExpander.RandomAlgorithm.RNG_PHILOX + ) + ) + optimization_pipeline.add_pass(HloPass.ComparisonExpander()) + optimization_pipeline.add_pass(HloPass.ZeroSizedHloElimination()) + + if debug_options.xla_gpu_deterministic_ops: + optimization_pipeline.add_pass( + HloPass.ScatterExpander( + HloPass.ScatterExpander.Mode.kEliminateAllScatters + ) + ) + else: + optimization_pipeline.add_pass(HloPass.GpuScatterExpander()) + + optimization_pipeline.add_pass(HloPass.QrExpander()) + optimization_pipeline.add_pass(HloPass.EighExpander()) + optimization_pipeline.add_pass(HloPass.DynamicIndexSplitter()) + optimization_pipeline.add_pass(HloPass.CallInliner()) + optimization_pipeline.add_pass(HloPass.DotDecomposer()) + optimization_pipeline.add_pass(HloPass.Convolution4DExpander()) + optimization_pipeline.add_pass(HloPass.StableSortExpander()) + + optimization_pipeline.add_pass(HloPass.BFloat16Normalization(True)) + optimization_pipeline.add_pass(HloPass.BatchNormExpander(True, True, True)) + optimization_pipeline.add_pass( + HloPass.LogisticExpander( + HloPass.LogisticExpander.LogisticExpansionType.kExp + ) + ) + optimization_pipeline.add_pass(HloPass.ConditionalCanonicalizer()) + optimization_pipeline.add_pass(HloPass.DynamicDimensionSimplifier()) + dp_options = { + "shape_check_mode": HloPass.DynamicPadder.ShapeCheckMode.kCompileTime + } + optimization_pipeline.add_pass(HloPass.DynamicPadder(dp_options)) + + simplification_pipeline = Pipeline("simplification", loop_count=-1) + simplification_pipeline.add_pass(HloPass.ZeroSizedHloElimination()) + simplification_pipeline.add_pass( + HloPass.GatherExpander( + HloPass.GatherExpander.Mode.kEliminateSimpleGathers + ) + ) + simplification_pipeline.add_pass( + HloPass.ScatterExpander( + HloPass.ScatterExpander.Mode.kEliminateSimpleScatters + ) + ) + algebraic_config_options = { + "replace_transpose_with_bitcast": False, + "minmax_propagate_nan": debug_options.xla_gpu_enable_fast_min_max, + } + if (GpuBackend.stream_exec_platform == "ROCM"): + algebraic_config_options["enable_conv_operand_swap"] = False + simplification_pipeline.add_pass( + HloPass.AlgebraicSimplifier(options=algebraic_config_options) + ) + simplification_pipeline.add_pass(HloPass.BitcastDtypesExpander()) + simplification_pipeline.add_pass(HloPass.DotDecomposer()) + simplification_pipeline.add_pass( + HloPass.DotMerger(max_size_to_merge=16 << 20) + ) + simplification_pipeline.add_pass(HloPass.SortSimplifier()) + simplification_pipeline.add_pass(HloPass.TupleSimplifier()) + simplification_pipeline.add_pass(HloPass.WhileLoopConstantSinking()) + simplification_pipeline.add_pass(HloPass.WhileLoopSimplifier()) + simplification_pipeline.add_pass(HloPass.ReshapeMover()) + simplification_pipeline.add_pass(HloPass.HloConstantFolding()) + simplification_pipeline.add_pass(HloPass.ConditionalSimplifier()) + simplification_pipeline.add_pass(HloPass.RealImagExpander()) + simplification_pipeline.add_pass(HloPass.TransposeFolding()) + simplification_pipeline.add_pass(HloPass.HloCSE(is_layout_sensitive=False)) + simplification_pipeline.add_pass(HloPass.HloDCE()) + optimization_pipeline.add_pass(simplification_pipeline) + + # Run WhileLoopTripCountAnnotator at the end of the simplification + # pipeline, before layout assignment and fusion. This pass does some + # pattern-matching on while bodies/conditions, and this is where the HLO is + # "nicest". + # + # It's important that we don't make semantic changes (e.g. unrolling) to + # any `while` loops after this point, because otherwise the trip-count + # annotations added by this pass may not be correct after the + # modifications. + optimization_pipeline.add_pass(HloPass.WhileLoopTripCountAnnotator()) + pre_fusion_pipeline.add_pass(optimization_pipeline) + + # -------------------------------------------- + # Collectives Pipeline + # -------------------------------------------- + + collectives_pipeline = Pipeline("collective-optimizations") + collectives_pipeline.add_pass(HloPass.AllReduceFolder()) + collectives_pipeline.add_pass(HloPass.ReduceScatterCreator()) + collectives_pipeline.add_pass(HloPass.AllReduceReassociate()) + algebraic_config_options = { + "replace_transpose_with_bitcast": False, + "enable_conv_operand_swap": False, + "minmax_propagate_nan": debug_options.xla_gpu_enable_fast_min_max, + } + collectives_pipeline.add_pass( + HloPass.AlgebraicSimplifier(options=algebraic_config_options) + ) + collectives_pipeline.add_pass(HloPass.AllGatherBroadcastReorder()) + # pre_fusion_pipeline.add_pass(collectives_pipeline) + + # -------------------------------------------- + # Convolution Canonicalization Pipeline + # -------------------------------------------- + + # TODO(ohcy): Account for AMD GPU case + # Note, this is specific to Nvidia GPUs. For AMD GPUs, some of the passes, + # e.g. Cudnn passes should be excluded + conv_canon_pipeline = Pipeline("conv-canonicalization") + conv_canon_pipeline.add_pass(HloPass.GpusolverRewriter()) + conv_canon_pipeline.add_pass(HloPass.GpuConvRewriter()) + conv_canon_pipeline.add_pass(HloPass.CudnnFusedConvRewriter()) + conv_canon_pipeline.add_pass(HloPass.GpuConvPaddingLegalization()) + conv_canon_pipeline.add_pass(HloPass.CudnnPadForConvolutions()) + conv_canon_pipeline.add_pass(HloPass.CudnnVectorizeConvolutions()) + conv_canon_pipeline.add_pass(HloPass.CallInliner()) + conv_canon_pipeline.add_pass(HloPass.TupleSimplifier()) + algebraic_config_options = { + "replace_transpose_with_bitcast": False, + "enable_conv_operand_swap": False, + } + conv_canon_pipeline.add_pass( + HloPass.AlgebraicSimplifier(options=algebraic_config_options), + loop_count=-1 + ) + conv_canon_pipeline.add_pass(HloPass.HloConstantFolding()) + pre_fusion_pipeline.add_pass(conv_canon_pipeline) + + # -------------------------------------------- + # Layout Assignment Pipeline + # -------------------------------------------- + + layout_assignment_pipeline = Pipeline("layout-assignment") + layout_assignment_pipeline.add_pass(HloPass.FlattenCallGraph()) + layout_assignment_pipeline.add_pass( + HloPass.GpuLayoutAssignment(hlo_module) + ) + pre_fusion_pipeline.add_pass(layout_assignment_pipeline) + + # -------------------------------------------- + # Post Layout Assignment Pipeline + # -------------------------------------------- + + # ******************* + # NVIDIA GPU Specific Passes Stage 1 - START + post_layout_ass_pipeline_nv_pre = Pipeline("post-layout-assignment-nv-pre") + if (GpuBackend.cuda_is_at_least(GpuBackend.CudaComputeCapability.AMPERE)): + post_layout_ass_pipeline_nv_pre.add_pass( + HloPass.CublasPadForGemms( + datatype=HloPass.CublasPadForGemms.PrimitiveType.BF16, + pad_to_multiple_of=8 + ) + ) + + if (GpuBackend.cuda_is_at_least(GpuBackend.CudaComputeCapability.VOLTA)): + post_layout_ass_pipeline_nv_pre.add_pass( + HloPass.CublasPadForGemms( + datatype=HloPass.CublasPadForGemms.PrimitiveType.S8, + pad_to_multiple_of=4 + ) + ) + post_layout_ass_pipeline_nv_pre.add_pass( + HloPass.CublasPadForGemms( + datatype=HloPass.CublasPadForGemms.PrimitiveType.F16, + pad_to_multiple_of=8 + ) + ) + + post_layout_ass_pipeline_nv_pre.add_pass(HloPass.HloConstantFolding()) + # NVIDIA GPU Specific Passes Stage 1 - END + # ******************* + + post_layout_ass_pipeline = Pipeline("post-layout-assignment") + post_layout_ass_pipeline.add_pass(HloPass.ReductionDegenerateDimRemover()) + post_layout_ass_pipeline.add_pass(HloPass.ReductionLayoutNormalizer()) + post_layout_ass_pipeline.add_pass(HloPass.ReductionDimensionGrouper()) + post_layout_ass_pipeline.add_pass( + HloPass.ReductionSplitter(), loop_count=-1 + ) + post_layout_ass_pipeline.add_pass( + HloPass.GpuTreeReductionRewriter(), loop_count=-1 + ) + + algebraic_config_options = { + "is_layout_sensitive": True, + "replace_transpose_with_bitcast": False, + "enable_conv_operand_swap": False, + "minmax_propagate_nan": debug_options.xla_gpu_enable_fast_min_max, + } + post_layout_ass_pipeline.add_pass( + HloPass.AlgebraicSimplifier(algebraic_config_options), loop_count=-1 + ) + post_layout_ass_pipeline.add_pass(HloPass.TransposeFolding()) + post_layout_ass_pipeline.add_pass(HloPass.GemmRewriter()) + post_layout_ass_pipeline.add_pass(HloPass.GemmBroadcastFoldingRewriter()) + post_layout_ass_pipeline.add_pass(HloPass.BFloat16Normalization(False)) + post_layout_ass_pipeline.add_pass(HloPass.GpuConvAlgorithmPicker()) + post_layout_ass_pipeline.add_pass(HloPass.TupleSimplifier()) + post_layout_ass_pipeline.add_pass(HloPass.HloCSE(True)) + + # ******************* + # NVIDIA GPU Specific Passes Stage 2 - START + post_layout_ass_pipeline_nv_post = Pipeline( + "post-layout-assignment-nv-post" + ) + + post_layout_ass_pipeline_nv_post.add_pass(HloPass.GemmAlgorithmPicker()) + if (hlo_module.is_bef_enabled): + post_layout_ass_pipeline_nv_post.add_pass( + HloPass.TriangularSolveRewriter() + ) + # NVIDIA GPU Specific Passes Stage 2 - END + # ******************* + + pre_fusion_pipeline.add_pass(post_layout_ass_pipeline_nv_pre) + pre_fusion_pipeline.add_pass(post_layout_ass_pipeline) + pre_fusion_pipeline.add_pass(post_layout_ass_pipeline_nv_post) + + # ----------------------------------------------------------------------- + # FUSION PIPELINE + # ----------------------------------------------------------------------- + + fusion_pipeline = Pipeline("fusion") + + # -------------------------------------------- + # Vertical Fusion Pipeline + # -------------------------------------------- + + vert_fusion_pipeline = Pipeline("vertical-fusion", loop_count=-1) + vert_fusion_pipeline.add_pass(HloPass.VariadicOpSplitter()) + vert_fusion_pipeline.add_pass(HloPass.GpuInstructionFusion(False)) + vert_fusion_pipeline.add_pass(HloPass.GpuInstructionFusion(True)) + vert_fusion_pipeline.add_pass(HloPass.FusionMerger()) + vert_fusion_pipeline.add_pass(HloPass.GpuMultiOutputFusion()) + vert_fusion_pipeline.add_pass(HloPass.HloCSE(True, True)) + vert_fusion_pipeline.add_pass(HloPass.HloDCE()) + + # -------------------------------------------- + # Horizontal Fusion Pipeline + # -------------------------------------------- + + hori_fusion_pipeline = Pipeline("horizontal-fusion", loop_count=-1) + hori_fusion_pipeline.add_pass(HloPass.GpuHorizontalLoopFusion()) + hori_fusion_pipeline.add_pass(HloPass.GpuHorizontalInputFusion()) + hori_fusion_pipeline.add_pass(HloPass.HloCSE(True, True)) + hori_fusion_pipeline.add_pass(HloPass.HloDCE()) + + fusion_pipeline.add_pass(vert_fusion_pipeline) + fusion_pipeline.add_pass(hori_fusion_pipeline) + + # ----------------------------------------------------------------------- + # POST PIPELINE + # ----------------------------------------------------------------------- + + post_fusion_pipeline = Pipeline("fusion") + + post_fusion_pipeline.add_pass( + HloPass.AllGatherCombiner( + combine_threshold_in_bytes=1024 * 1024 * 1024, + combine_threshold_count=256 + ) + ) + post_fusion_pipeline.add_pass( + HloPass.AllReduceCombiner( + combine_threshold_in_bytes=debug_options + .xla_gpu_all_reduce_combine_threshold_bytes, + combine_threshold_count=256 + ) + ) + post_fusion_pipeline.add_pass( + HloPass.ReduceScatterCombiner( + combine_threshold_in_bytes=30 * 1024 * 1024, + combine_threshold_count=256 + ) + ) + + if debug_options.xla_gpu_all_reduce_contiguous: + post_fusion_pipeline.add_pass(HloPass.AllReduceContiguous()) + + blueconnect_num_devices_per_host = debug_options.xla_gpu_all_reduce_blueconnect_num_devices_per_host + if (blueconnect_num_devices_per_host > 0): + post_fusion_pipeline.add_pass( + HloPass.AllReduceBlueConnect(blueconnect_num_devices_per_host) + ) + + if debug_options.xla_gpu_enable_async_all_reduce: + post_fusion_pipeline.add_pass(HloPass.AsyncCollectiveCreator()) + + post_fusion_pipeline.add_pass(HloPass.CollectivesScheduleLinearizer()) + + algebraic_config_options = { + "is_layout_sensitive": True, + "replace_transpose_with_bitcast": False, + "enable_conv_operand_swap": False, + "minmax_propagate_nan": debug_options.xla_gpu_enable_fast_min_max, + } + post_fusion_pipeline.add_pass( + HloPass.AlgebraicSimplifier(algebraic_config_options) + ) + post_fusion_pipeline.add_pass(HloPass.OptimizationBarrierExpander()) + post_fusion_pipeline.add_pass(HloPass.TupleSimplifier()) + + # ----------------------------------------------------------------------- + # FULL OPTIMIZE HLO MODULE PIPELINE + # ----------------------------------------------------------------------- + + optimize_hlo_pipeline = Pipeline("fusion") + + optimize_hlo_pipeline.add_pass(pre_fusion_pipeline) + optimize_hlo_pipeline.add_pass(fusion_pipeline) + optimize_hlo_pipeline.add_pass(post_fusion_pipeline) + + hlo_env.run(optimize_hlo_pipeline) + general_pipeline_hash = hlo_env.get_hlo_module_hash() + + hlo_env = HloEnv(self.hlo_main_test_file, "gpu") + hlo_env.optimize_hlo_module() + original_pipeline_hash = hlo_env.get_hlo_module_hash() + + assert (general_pipeline_hash == original_pipeline_hash) + + @absltest.skipIf(("GITLAB_CI" in os.environ), "Running in gitlab ci") + def test_general_fusion(self) -> None: + from random import randrange + from timeit import default_timer as timer + + import numpy as np + from hloenv import AltPipeline, HloEnv, HloPass, Pass, Pipeline + + base_dir = os.path.dirname(os.path.realpath(__file__)) + hlo_base_dir = base_dir + "/hlo_texts/test_hlos" + for root, dirs, files in os.walk(hlo_base_dir): + for file in files: + + filepath = os.path.join(root, file) + + hlo_env = HloEnv(filepath, "gpu") + general_fusion_pipeline = GeneralFusionPipeline(hlo_env) + instruction_count = hlo_env.get_hlo_module().instruction_count + is_large = instruction_count > LARGE_HLO_INSTRUCTION_MIN + + logging.info("-------------------------------------------------") + logging.info("Testing general fusion for file: " + filepath) + logging.info(" num instructions = %d" % instruction_count) + logging.info(" num is_large = %s" % is_large) + + saved_hlo_module = hlo_env.clone_hlo() + # Original TF pipelines + hlo_env.optimize_hlo_module() + + # Save reference copy of the module after a non dry-run RunHloPasses call + reference_hlo_module = hlo_env.clone_hlo() + hlo_env.load_hlo(saved_hlo_module) + + start = timer() + + hlo_env.run(general_fusion_pipeline.pre_pass_optimizations) + num_alts = 1 + while num_alts > 0: + hlo_env.run(general_fusion_pipeline.pre_dry_pass_passes) + hlo_env.run(general_fusion_pipeline.pass_dry_run) + + hlo_graph = hlo_env.get_hlo_graph(do_hash_verification=False) + node_features = hlo_graph.node_features + num_operands = node_features.num_operands + num_alts = len(hlo_graph.alternative_indices) + + if num_alts > 0: + decisions = [] + for alt_idx in hlo_graph.alternative_indices: + node_uid = node_features.uids[alt_idx] + if is_large: + decisions.append([node_uid, 1]) + else: + decisions.append( + [node_uid, get_rand_action(num_operands[alt_idx])] + ) + + decisions = np.asarray(decisions) + hlo_env.apply_alternatives(decisions) + + hlo_env.run(general_fusion_pipeline.post_dry_pass_passes) + + hlo_env.run(general_fusion_pipeline.post_pass_optimizations) + post_fusion_module = hlo_env.clone_hlo() + + end = timer() + logging.info(" Time taken for fusion: %f" % (end - start)) + start = timer() + assert ( + hlo_env.has_equal_output(post_fusion_module, reference_hlo_module) + ) + end = timer() + logging.info(" Time taken for eval: %f" % (end - start)) + + logging.info("-------------------------------------------------") + + @absltest.skipIf(("GITLAB_CI" in os.environ), "Running in gitlab ci") + def test_deterministic_node_ids(self) -> None: + from random import randrange + + import numpy as np + from hloenv import AltPipeline, HloEnv, HloPass, Pass, Pipeline + + # filepath = "./hlo_texts/large_hlo.txt" + filepath = "hlo_texts/test_hlos/maml_flax/module_0082.jit_divmod.28.before_optimizations.txt" + logging.info("Testing general fusion for file: " + filepath) + + all_alt_indices = [] + all_alt_ids = [] + all_dag_hashes = [] + + for i in range(10): + hlo_env = HloEnv(self.hlo_main_test_file, "gpu") + general_fusion_pipeline = GeneralFusionPipeline(hlo_env) + + run_alt_indices = [] + run_alt_ids = [] + + hashes = [] + hashes.append(hlo_env.get_hlo_module_hash()) + + hlo_env.run(general_fusion_pipeline.pre_pass_optimizations) + hashes.append(hlo_env.get_hlo_module_hash()) + + num_alts = 1 + while num_alts > 0: + hlo_env.run(general_fusion_pipeline.pre_dry_pass_passes) + hashes.append(hlo_env.get_hlo_module_hash()) + + hlo_env.run(general_fusion_pipeline.pass_dry_run) + hashes.append(hlo_env.get_hlo_module_hash()) + + hlo_graph = hlo_env.get_hlo_graph(do_hash_verification=False) + node_features = hlo_graph.node_features + num_operands = node_features.num_operands + num_alts = len(hlo_graph.alternative_indices) + + alt_ids = [ + node_features.uids[idx] for idx in hlo_graph.alternative_indices + ] + run_alt_indices += list(hlo_graph.alternative_indices) + run_alt_ids += alt_ids + + if num_alts > 0: + decisions = [] + for alt_idx in hlo_graph.alternative_indices: + node_uid = node_features.uids[alt_idx] + decisions.append([node_uid, 1]) + + decisions = np.asarray(decisions) + hlo_env.apply_alternatives(decisions) + hashes.append(hlo_env.get_hlo_module_hash()) + + hlo_env.run(general_fusion_pipeline.post_dry_pass_passes) + hashes.append(hlo_env.get_hlo_module_hash()) + + hlo_env.run(general_fusion_pipeline.post_pass_optimizations) + hashes.append(hlo_env.get_hlo_module_hash()) + all_dag_hashes.append(hashes) + all_alt_indices.append(run_alt_indices) + all_alt_ids.append(run_alt_ids) + + assert (all_alt_indices.count(all_alt_indices[0]) == len(all_alt_indices)) + assert (all_alt_ids.count(all_alt_ids[0]) == len(all_alt_ids)) + assert (all_dag_hashes.count(all_dag_hashes[0]) == len(all_dag_hashes)) + + logging.info("---------IDX--------") + for alt_idx in all_alt_indices: + logging.info(alt_idx[:25]) + + logging.info("--------IDS---------") + for alt_id in all_alt_ids: + logging.info(alt_id[:25]) + + logging.info("-------HASH--------") + for dag_hash in all_dag_hashes: + logging.info(dag_hash) + + +if __name__ == "__main__": + absltest.main() diff --git a/tests/hlo_graph_test.cc b/tests/hlo_graph_test.cc new file mode 100644 index 0000000..4aad96e --- /dev/null +++ b/tests/hlo_graph_test.cc @@ -0,0 +1,79 @@ +/* Copyright 2017 The TensorFlow Authors. All Rights Reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +==============================================================================*/ + +#include "hloenv/hlo_graph.h" + +#include "gtest/gtest.h" +#include "tensorflow/compiler/xla/literal.h" +#include "tensorflow/compiler/xla/literal_util.h" +#include "tensorflow/compiler/xla/service/hlo_computation.h" +#include "tensorflow/compiler/xla/service/hlo_instruction.h" +#include "tensorflow/compiler/xla/shape_util.h" +#include "tensorflow/compiler/xla/xla_data.pb.h" + +namespace xla { + +namespace { + +Shape r0f32_ = ShapeUtil::MakeShape(F32, {}); + +std::unique_ptr CreateNewVerifiedModule() { + HloModuleConfig config; + return absl::make_unique("test_module", config); +} + +// Create a computation which returns a constant. +std::unique_ptr CreateConstantComputation() { + auto builder = HloComputation::Builder("Constant"); + builder.AddInstruction( + HloInstruction::CreateConstant(LiteralUtil::CreateR0(42.0f))); + return builder.Build(); +} + +// Creates a computation which calls the given zero-parameter computations. +std::unique_ptr CreateCallComputation( + absl::Span computations) { + auto builder = HloComputation::Builder("Call"); + for (auto computation : computations) { + builder.AddInstruction(HloInstruction::CreateCall(r0f32_, {}, computation)); + } + return builder.Build(); +} + +TEST(HloGraphTest, OneComputationPostOrder) { + // Create a module with a single computation. + auto module = CreateNewVerifiedModule(); + auto computation = module->AddEntryComputation(CreateConstantComputation()); + hloenv::HloGraph graph(module.get()); + + // TODO(ohcy, wangyzh) Restore tests once hash is updated + // EXPECT_EQ(graph.Hash(), module->CalledComputationHash()); +} + +TEST(HloGraphTest, TwoComputationsPostOrder) { + // Create a module with two unconnected computations. + auto module = CreateNewVerifiedModule(); + auto computation1 = module->AddEntryComputation(CreateConstantComputation()); + auto computation2 = + module->AddEmbeddedComputation(CreateConstantComputation()); + hloenv::HloGraph graph(module.get()); + + // TODO(ohcy, wangyzh) Restore tests once hash is updated + // EXPECT_EQ(graph.Hash(), module->CalledComputationHash()); +} + +} // namespace + +} // namespace xla diff --git a/tests/hlo_texts/fn_hlo.txt b/tests/hlo_texts/fn_hlo.txt new file mode 100644 index 0000000..f7ddd9e --- /dev/null +++ b/tests/hlo_texts/fn_hlo.txt @@ -0,0 +1,13 @@ +HloModule xla_computation_ordered_wrapper.9 + +ENTRY xla_computation_ordered_wrapper.9 { + constant.3 = pred[] constant(false) + parameter.2 = f32[2,2]{1,0} parameter(1) + parameter.1 = f32[2,2]{1,0} parameter(0) + dot.4 = f32[2,2]{1,0} dot(parameter.2, parameter.1), lhs_contracting_dims={1}, rhs_contracting_dims={0} + constant.5 = f32[] constant(3.14159) + broadcast.6 = f32[2,2]{1,0} broadcast(constant.5), dimensions={} + divide.7 = f32[2,2]{1,0} divide(dot.4, broadcast.6) + ROOT tuple.8 = (f32[2,2]{1,0}) tuple(divide.7) +} + diff --git a/tests/hlo_texts/hlo_test.txt b/tests/hlo_texts/hlo_test.txt new file mode 100644 index 0000000..8c00b23 --- /dev/null +++ b/tests/hlo_texts/hlo_test.txt @@ -0,0 +1,169 @@ +HloModule jit_train_step.151 + +%primitive_computation_add__6.23 (parameter.24: f32[], parameter.25: f32[]) -> f32[] { + %constant.26 = pred[] constant(false) + %parameter.24 = f32[] parameter(0) + %parameter.25 = f32[] parameter(1) + ROOT %add.27 = f32[] add(f32[] %parameter.24, f32[] %parameter.25) +} + +%primitive_computation_add__7.36 (parameter.37: f32[], parameter.38: f32[]) -> f32[] { + %constant.39 = pred[] constant(false) + %parameter.37 = f32[] parameter(0) + %parameter.38 = f32[] parameter(1) + ROOT %add.40 = f32[] add(f32[] %parameter.37, f32[] %parameter.38) +} + +%primitive_computation_add__8.48 (parameter.49: f32[], parameter.50: f32[]) -> f32[] { + %constant.51 = pred[] constant(false) + %parameter.49 = f32[] parameter(0) + %parameter.50 = f32[] parameter(1) + ROOT %add.52 = f32[] add(f32[] %parameter.49, f32[] %parameter.50) +} + +%primitive_computation_add__9.60 (parameter.61: f32[], parameter.62: f32[]) -> f32[] { + %constant.63 = pred[] constant(false) + %parameter.61 = f32[] parameter(0) + %parameter.62 = f32[] parameter(1) + ROOT %add.64 = f32[] add(f32[] %parameter.61, f32[] %parameter.62) +} + +%primitive_computation_add__10.75 (parameter.76: f32[], parameter.77: f32[]) -> f32[] { + %constant.78 = pred[] constant(false) + %parameter.76 = f32[] parameter(0) + %parameter.77 = f32[] parameter(1) + ROOT %add.79 = f32[] add(f32[] %parameter.76, f32[] %parameter.77) +} + +%primitive_computation_add__11.108 (parameter.109: f32[], parameter.110: f32[]) -> f32[] { + %constant.111 = pred[] constant(false) + %parameter.109 = f32[] parameter(0) + %parameter.110 = f32[] parameter(1) + ROOT %add.112 = f32[] add(f32[] %parameter.109, f32[] %parameter.110) +} + +%primitive_computation_add__12.124 (parameter.125: f32[], parameter.126: f32[]) -> f32[] { + %constant.127 = pred[] constant(false) + %parameter.125 = f32[] parameter(0) + %parameter.126 = f32[] parameter(1) + ROOT %add.128 = f32[] add(f32[] %parameter.125, f32[] %parameter.126) +} + +ENTRY %jit_train_step.151 (parameter.1: f32[128], parameter.2: f32[1,128], parameter.3: f32[1], parameter.4: f32[128,1], parameter.5: f32[200,1], parameter.6: f32[200,1]) -> (f32[128], f32[1,128], f32[1], f32[128,1]) { + %constant.7 = pred[] constant(false) + %parameter.5 = f32[200,1]{1,0} parameter(4) + %parameter.2 = f32[1,128]{1,0} parameter(1) + %dot.8 = f32[200,128]{1,0} dot(f32[200,1]{1,0} %parameter.5, f32[1,128]{1,0} %parameter.2), lhs_contracting_dims={1}, rhs_contracting_dims={0} + %parameter.1 = f32[128]{0} parameter(0) + %broadcast.9 = f32[200,128]{1,0} broadcast(f32[128]{0} %parameter.1), dimensions={1} + %add.10 = f32[200,128]{1,0} add(f32[200,128]{1,0} %dot.8, f32[200,128]{1,0} %broadcast.9) + %tanh.11 = f32[200,128]{1,0} tanh(f32[200,128]{1,0} %add.10) + %parameter.4 = f32[128,1]{1,0} parameter(3) + %dot.15 = f32[200,1]{1,0} dot(f32[200,128]{1,0} %tanh.11, f32[128,1]{1,0} %parameter.4), lhs_contracting_dims={1}, rhs_contracting_dims={0} + %parameter.3 = f32[1]{0} parameter(2) + %broadcast.16 = f32[200,1]{1,0} broadcast(f32[1]{0} %parameter.3), dimensions={1} + %add.17 = f32[200,1]{1,0} add(f32[200,1]{1,0} %dot.15, f32[200,1]{1,0} %broadcast.16) + %parameter.6 = f32[200,1]{1,0} parameter(5) + %subtract.69 = f32[200,1]{1,0} subtract(f32[200,1]{1,0} %add.17, f32[200,1]{1,0} %parameter.6) + %multiply.70 = f32[200,1]{1,0} multiply(f32[200,1]{1,0} %subtract.69, f32[200,1]{1,0} %subtract.69) + %constant.74 = f32[] constant(0) + %reduce.80 = f32[] reduce(f32[200,1]{1,0} %multiply.70, f32[] %constant.74), dimensions={0,1}, to_apply=%primitive_computation_add__10.75 + %constant.81 = f32[] constant(200) + %divide.82 = f32[] divide(f32[] %reduce.80, f32[] %constant.81) + %negate.83 = f32[] negate(f32[] %divide.82) + %constant.84 = f32[] constant(0.5) + %divide.85 = f32[] divide(f32[] %negate.83, f32[] %constant.84) + %multiply.18 = f32[128]{0} multiply(f32[128]{0} %parameter.1, f32[128]{0} %parameter.1) + %constant.22 = f32[] constant(0) + %reduce.28 = f32[] reduce(f32[128]{0} %multiply.18, f32[] %constant.22), dimensions={0}, to_apply=%primitive_computation_add__6.23 + %constant.29 = f32[] constant(0) + %add.30 = f32[] add(f32[] %reduce.28, f32[] %constant.29) + %multiply.31 = f32[1,128]{1,0} multiply(f32[1,128]{1,0} %parameter.2, f32[1,128]{1,0} %parameter.2) + %constant.35 = f32[] constant(0) + %reduce.41 = f32[] reduce(f32[1,128]{1,0} %multiply.31, f32[] %constant.35), dimensions={0,1}, to_apply=%primitive_computation_add__7.36 + %add.42 = f32[] add(f32[] %add.30, f32[] %reduce.41) + %multiply.43 = f32[1]{0} multiply(f32[1]{0} %parameter.3, f32[1]{0} %parameter.3) + %constant.47 = f32[] constant(0) + %reduce.53 = f32[] reduce(f32[1]{0} %multiply.43, f32[] %constant.47), dimensions={0}, to_apply=%primitive_computation_add__8.48 + %add.54 = f32[] add(f32[] %add.42, f32[] %reduce.53) + %multiply.55 = f32[128,1]{1,0} multiply(f32[128,1]{1,0} %parameter.4, f32[128,1]{1,0} %parameter.4) + %constant.59 = f32[] constant(0) + %reduce.65 = f32[] reduce(f32[128,1]{1,0} %multiply.55, f32[] %constant.59), dimensions={0,1}, to_apply=%primitive_computation_add__9.60 + %add.66 = f32[] add(f32[] %add.54, f32[] %reduce.65) + %constant.67 = f32[] constant(-0) + %multiply.68 = f32[] multiply(f32[] %add.66, f32[] %constant.67) + %add.86 = f32[] add(f32[] %divide.85, f32[] %multiply.68) + %negate.87 = f32[] negate(f32[] %add.86) + %constant.88 = f32[] constant(1) + %negate.89 = f32[] negate(f32[] %constant.88) + %constant.90 = f32[] constant(-0) + %multiply.91 = f32[] multiply(f32[] %negate.89, f32[] %constant.90) + %broadcast.98 = f32[128]{0} broadcast(f32[] %multiply.91), dimensions={} + %constant.19 = f32[] constant(2) + %broadcast.20 = f32[128]{0} broadcast(f32[] %constant.19), dimensions={} + %multiply.21 = f32[128]{0} multiply(f32[128]{0} %broadcast.20, f32[128]{0} %parameter.1) + %multiply.99 = f32[128]{0} multiply(f32[128]{0} %broadcast.98, f32[128]{0} %multiply.21) + %constant.100 = f32[] constant(0.5) + %divide.101 = f32[] divide(f32[] %negate.89, f32[] %constant.100) + %negate.102 = f32[] negate(f32[] %divide.101) + %constant.103 = f32[] constant(200) + %divide.104 = f32[] divide(f32[] %negate.102, f32[] %constant.103) + %broadcast.105 = f32[200,1]{1,0} broadcast(f32[] %divide.104), dimensions={} + %constant.71 = f32[] constant(2) + %broadcast.72 = f32[200,1]{1,0} broadcast(f32[] %constant.71), dimensions={} + %multiply.73 = f32[200,1]{1,0} multiply(f32[200,1]{1,0} %broadcast.72, f32[200,1]{1,0} %subtract.69) + %multiply.106 = f32[200,1]{1,0} multiply(f32[200,1]{1,0} %broadcast.105, f32[200,1]{1,0} %multiply.73) + %dot.118 = f32[200,128]{1,0} dot(f32[200,1]{1,0} %multiply.106, f32[128,1]{1,0} %parameter.4), lhs_contracting_dims={1}, rhs_contracting_dims={1} + %constant.12 = f32[] constant(1) + %broadcast.13 = f32[200,128]{1,0} broadcast(f32[] %constant.12), dimensions={} + %subtract.14 = f32[200,128]{1,0} subtract(f32[200,128]{1,0} %broadcast.13, f32[200,128]{1,0} %tanh.11) + %multiply.120 = f32[200,128]{1,0} multiply(f32[200,128]{1,0} %dot.118, f32[200,128]{1,0} %subtract.14) + %multiply.121 = f32[200,128]{1,0} multiply(f32[200,128]{1,0} %multiply.120, f32[200,128]{1,0} %tanh.11) + %add.122 = f32[200,128]{1,0} add(f32[200,128]{1,0} %multiply.120, f32[200,128]{1,0} %multiply.121) + %constant.123 = f32[] constant(0) + %reduce.129 = f32[128]{0} reduce(f32[200,128]{1,0} %add.122, f32[] %constant.123), dimensions={0}, to_apply=%primitive_computation_add__12.124 + %add.130 = f32[128]{0} add(f32[128]{0} %multiply.99, f32[128]{0} %reduce.129) + %constant.134 = f32[] constant(0.001) + %broadcast.135 = f32[128]{0} broadcast(f32[] %constant.134), dimensions={} + %multiply.136 = f32[128]{0} multiply(f32[128]{0} %add.130, f32[128]{0} %broadcast.135) + %subtract.137 = f32[128]{0} subtract(f32[128]{0} %parameter.1, f32[128]{0} %multiply.136) + %broadcast.96 = f32[1,128]{1,0} broadcast(f32[] %multiply.91), dimensions={} + %constant.32 = f32[] constant(2) + %broadcast.33 = f32[1,128]{1,0} broadcast(f32[] %constant.32), dimensions={} + %multiply.34 = f32[1,128]{1,0} multiply(f32[1,128]{1,0} %broadcast.33, f32[1,128]{1,0} %parameter.2) + %multiply.97 = f32[1,128]{1,0} multiply(f32[1,128]{1,0} %broadcast.96, f32[1,128]{1,0} %multiply.34) + %dot.131 = f32[128,1]{1,0} dot(f32[200,128]{1,0} %add.122, f32[200,1]{1,0} %parameter.5), lhs_contracting_dims={0}, rhs_contracting_dims={0} + %transpose.132 = f32[1,128]{0,1} transpose(f32[128,1]{1,0} %dot.131), dimensions={1,0} + %add.133 = f32[1,128]{1,0} add(f32[1,128]{1,0} %multiply.97, f32[1,128]{0,1} %transpose.132) + %constant.138 = f32[] constant(0.001) + %broadcast.139 = f32[1,128]{1,0} broadcast(f32[] %constant.138), dimensions={} + %multiply.140 = f32[1,128]{1,0} multiply(f32[1,128]{1,0} %add.133, f32[1,128]{1,0} %broadcast.139) + %subtract.141 = f32[1,128]{1,0} subtract(f32[1,128]{1,0} %parameter.2, f32[1,128]{1,0} %multiply.140) + %broadcast.94 = f32[1]{0} broadcast(f32[] %multiply.91), dimensions={} + %constant.44 = f32[] constant(2) + %broadcast.45 = f32[1]{0} broadcast(f32[] %constant.44), dimensions={} + %multiply.46 = f32[1]{0} multiply(f32[1]{0} %broadcast.45, f32[1]{0} %parameter.3) + %multiply.95 = f32[1]{0} multiply(f32[1]{0} %broadcast.94, f32[1]{0} %multiply.46) + %constant.107 = f32[] constant(0) + %reduce.113 = f32[] reduce(f32[200,1]{1,0} %multiply.106, f32[] %constant.107), dimensions={0,1}, to_apply=%primitive_computation_add__11.108 + %broadcast.114 = f32[1]{0} broadcast(f32[] %reduce.113), dimensions={} + %add.115 = f32[1]{0} add(f32[1]{0} %multiply.95, f32[1]{0} %broadcast.114) + %constant.142 = f32[] constant(0.001) + %broadcast.143 = f32[1]{0} broadcast(f32[] %constant.142), dimensions={} + %multiply.144 = f32[1]{0} multiply(f32[1]{0} %add.115, f32[1]{0} %broadcast.143) + %subtract.145 = f32[1]{0} subtract(f32[1]{0} %parameter.3, f32[1]{0} %multiply.144) + %broadcast.92 = f32[128,1]{1,0} broadcast(f32[] %multiply.91), dimensions={} + %constant.56 = f32[] constant(2) + %broadcast.57 = f32[128,1]{1,0} broadcast(f32[] %constant.56), dimensions={} + %multiply.58 = f32[128,1]{1,0} multiply(f32[128,1]{1,0} %broadcast.57, f32[128,1]{1,0} %parameter.4) + %multiply.93 = f32[128,1]{1,0} multiply(f32[128,1]{1,0} %broadcast.92, f32[128,1]{1,0} %multiply.58) + %dot.116 = f32[1,128]{1,0} dot(f32[200,1]{1,0} %multiply.106, f32[200,128]{1,0} %tanh.11), lhs_contracting_dims={0}, rhs_contracting_dims={0} + %transpose.117 = f32[128,1]{0,1} transpose(f32[1,128]{1,0} %dot.116), dimensions={1,0} + %add.119 = f32[128,1]{1,0} add(f32[128,1]{1,0} %multiply.93, f32[128,1]{0,1} %transpose.117) + %constant.146 = f32[] constant(0.001) + %broadcast.147 = f32[128,1]{1,0} broadcast(f32[] %constant.146), dimensions={} + %multiply.148 = f32[128,1]{1,0} multiply(f32[128,1]{1,0} %add.119, f32[128,1]{1,0} %broadcast.147) + %subtract.149 = f32[128,1]{1,0} subtract(f32[128,1]{1,0} %parameter.4, f32[128,1]{1,0} %multiply.148) + ROOT %tuple.150 = (f32[128]{0}, f32[1,128]{1,0}, f32[1]{0}, f32[128,1]{1,0}) tuple(f32[128]{0} %subtract.137, f32[1,128]{1,0} %subtract.141, f32[1]{0} %subtract.145, f32[128,1]{1,0} %subtract.149) +} + diff --git a/tests/hlo_texts/test_hlos/BayesNewton/1649161870141180.module_1898.jit__cho_solve__38.9.before_optimizations.txt b/tests/hlo_texts/test_hlos/BayesNewton/1649161870141180.module_1898.jit__cho_solve__38.9.before_optimizations.txt new file mode 100644 index 0000000..5b63b62 --- /dev/null +++ b/tests/hlo_texts/test_hlos/BayesNewton/1649161870141180.module_1898.jit__cho_solve__38.9.before_optimizations.txt @@ -0,0 +1,13 @@ +HloModule jit__cho_solve__38.9 + +ENTRY %jit__cho_solve__38.9 (parameter.1: f64[20,20,20], parameter.2: f64[20,20,20]) -> (f64[20,20,20]) { + %constant.3 = pred[] constant(false) + %parameter.1 = f64[20,20,20]{2,1,0} parameter(0) + %parameter.2 = f64[20,20,20]{2,1,0} parameter(1) + %custom-call.4 = (f64[20,20,20]{1,2,0}, s8[160]{0}, s8[160]{0}) custom-call(f64[20,20,20]{2,1,0} %parameter.1, f64[20,20,20]{2,1,0} %parameter.2), custom_call_target="cublas_trsm_batched", operand_layout_constraints={f64[20,20,20]{1,2,0}, f64[20,20,20]{1,2,0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\001\000\000\000\024\000\000\000\024\000\000\000\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" + %get-tuple-element.5 = f64[20,20,20]{1,2,0} get-tuple-element((f64[20,20,20]{1,2,0}, s8[160]{0}, s8[160]{0}) %custom-call.4), index=0 + %custom-call.6 = (f64[20,20,20]{1,2,0}, s8[160]{0}, s8[160]{0}) custom-call(f64[20,20,20]{2,1,0} %parameter.1, f64[20,20,20]{1,2,0} %get-tuple-element.5), custom_call_target="cublas_trsm_batched", operand_layout_constraints={f64[20,20,20]{1,2,0}, f64[20,20,20]{1,2,0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\001\000\000\000\024\000\000\000\024\000\000\000\024\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000" + %get-tuple-element.7 = f64[20,20,20]{1,2,0} get-tuple-element((f64[20,20,20]{1,2,0}, s8[160]{0}, s8[160]{0}) %custom-call.6), index=0 + ROOT %tuple.8 = (f64[20,20,20]{1,2,0}) tuple(f64[20,20,20]{1,2,0} %get-tuple-element.7) +} + diff --git a/tests/hlo_texts/test_hlos/BayesNewton/1649161872771469.module_1959.jit_searchsorted.120.before_optimizations.txt b/tests/hlo_texts/test_hlos/BayesNewton/1649161872771469.module_1959.jit_searchsorted.120.before_optimizations.txt new file mode 100644 index 0000000..2d16cb1 --- /dev/null +++ b/tests/hlo_texts/test_hlos/BayesNewton/1649161872771469.module_1959.jit_searchsorted.120.before_optimizations.txt @@ -0,0 +1,136 @@ +HloModule jit_searchsorted.120 + +%jit_vmap__where___50.12 (parameter.13: pred[20], parameter.14: s64[20], parameter.15: s64[20]) -> (s64[20]) { + %constant.16 = pred[] constant(false) + %parameter.13 = pred[20]{0} parameter(0) + %parameter.14 = s64[20]{0} parameter(1) + %parameter.15 = s64[20]{0} parameter(2) + %convert.17 = s64[20]{0} convert(s64[20]{0} %parameter.15) + %select.18 = s64[20]{0} select(pred[20]{0} %parameter.13, s64[20]{0} %parameter.14, s64[20]{0} %convert.17) + ROOT %tuple.19 = (s64[20]{0}) tuple(s64[20]{0} %select.18) +} + +%jit_vmap_floor_divide_.20 (parameter.21: s64[20], parameter.22: s64[]) -> (s64[20]) { + %constant.23 = pred[] constant(false) + %parameter.21 = s64[20]{0} parameter(0) + %sign.26 = s64[20]{0} sign(s64[20]{0} %parameter.21) + %parameter.22 = s64[] parameter(1) + %sign.27 = s64[] sign(s64[] %parameter.22) + %broadcast.28 = s64[20]{0} broadcast(s64[] %sign.27), dimensions={} + %compare.29 = pred[20]{0} compare(s64[20]{0} %sign.26, s64[20]{0} %broadcast.28), direction=NE + %broadcast.30 = s64[20]{0} broadcast(s64[] %parameter.22), dimensions={} + %remainder.31 = s64[20]{0} remainder(s64[20]{0} %parameter.21, s64[20]{0} %broadcast.30) + %constant.32 = s64[] constant(0) + %broadcast.33 = s64[20]{0} broadcast(s64[] %constant.32), dimensions={} + %compare.34 = pred[20]{0} compare(s64[20]{0} %remainder.31, s64[20]{0} %broadcast.33), direction=NE + %and.35 = pred[20]{0} and(pred[20]{0} %compare.29, pred[20]{0} %compare.34) + %broadcast.24 = s64[20]{0} broadcast(s64[] %parameter.22), dimensions={} + %divide.25 = s64[20]{0} divide(s64[20]{0} %parameter.21, s64[20]{0} %broadcast.24) + %convert.36 = s64[20]{0} convert(s64[20]{0} %divide.25) + %constant.37 = s64[] constant(1) + %broadcast.38 = s64[20]{0} broadcast(s64[] %constant.37), dimensions={} + %subtract.39 = s64[20]{0} subtract(s64[20]{0} %convert.36, s64[20]{0} %broadcast.38) + %call.40 = (s64[20]{0}) call(pred[20]{0} %and.35, s64[20]{0} %subtract.39, s64[20]{0} %divide.25), to_apply=%jit_vmap__where___50.12 + %get-tuple-element.41 = s64[20]{0} get-tuple-element((s64[20]{0}) %call.40), index=0 + ROOT %tuple.42 = (s64[20]{0}) tuple(s64[20]{0} %get-tuple-element.41) +} + +%jit_vmap__where___51.43 (parameter.44: pred[20], parameter.45: s64[20], parameter.46: s64[20]) -> (s64[20]) { + %constant.47 = pred[] constant(false) + %parameter.44 = pred[20]{0} parameter(0) + %parameter.45 = s64[20]{0} parameter(1) + %convert.48 = s64[20]{0} convert(s64[20]{0} %parameter.45) + %parameter.46 = s64[20]{0} parameter(2) + %select.49 = s64[20]{0} select(pred[20]{0} %parameter.44, s64[20]{0} %convert.48, s64[20]{0} %parameter.46) + ROOT %tuple.50 = (s64[20]{0}) tuple(s64[20]{0} %select.49) +} + +%jit_vmap__where___52.51 (parameter.52: pred[20], parameter.53: s64[20], parameter.54: s64[20]) -> (s64[20]) { + %constant.55 = pred[] constant(false) + %parameter.52 = pred[20]{0} parameter(0) + %parameter.53 = s64[20]{0} parameter(1) + %parameter.54 = s64[20]{0} parameter(2) + %convert.56 = s64[20]{0} convert(s64[20]{0} %parameter.54) + %select.57 = s64[20]{0} select(pred[20]{0} %parameter.52, s64[20]{0} %parameter.53, s64[20]{0} %convert.56) + ROOT %tuple.58 = (s64[20]{0}) tuple(s64[20]{0} %select.57) +} + +%body_computation.59 (parameter.60: (f64[22], f64[20], s64[], s64[], s64[20], /*index=5*/s64[20])) -> (f64[22], f64[20], s64[], s64[], s64[20], /*index=5*/s64[20]) { + %constant.67 = pred[] constant(false) + %parameter.60 = (f64[22]{0}, f64[20]{0}, s64[], s64[], s64[20]{0}, /*index=5*/s64[20]{0}) parameter(0) + %get-tuple-element.61 = f64[22]{0} get-tuple-element((f64[22]{0}, f64[20]{0}, s64[], s64[], s64[20]{0}, /*index=5*/s64[20]{0}) %parameter.60), index=0 + %get-tuple-element.62 = f64[20]{0} get-tuple-element((f64[22]{0}, f64[20]{0}, s64[], s64[], s64[20]{0}, /*index=5*/s64[20]{0}) %parameter.60), index=1 + %get-tuple-element.63 = s64[] get-tuple-element((f64[22]{0}, f64[20]{0}, s64[], s64[], s64[20]{0}, /*index=5*/s64[20]{0}) %parameter.60), index=2 + %constant.89 = s64[] constant(1) + %add.90 = s64[] add(s64[] %get-tuple-element.63, s64[] %constant.89) + %get-tuple-element.64 = s64[] get-tuple-element((f64[22]{0}, f64[20]{0}, s64[], s64[], s64[20]{0}, /*index=5*/s64[20]{0}) %parameter.60), index=3 + %constant.68 = s64[] constant(1) + %add.69 = s64[] add(s64[] %get-tuple-element.64, s64[] %constant.68) + %get-tuple-element.65 = s64[20]{0} get-tuple-element((f64[22]{0}, f64[20]{0}, s64[], s64[], s64[20]{0}, /*index=5*/s64[20]{0}) %parameter.60), index=4 + %get-tuple-element.66 = s64[20]{0} get-tuple-element((f64[22]{0}, f64[20]{0}, s64[], s64[], s64[20]{0}, /*index=5*/s64[20]{0}) %parameter.60), index=5 + %add.70 = s64[20]{0} add(s64[20]{0} %get-tuple-element.65, s64[20]{0} %get-tuple-element.66) + %constant.71 = s64[] constant(2) + %call.72 = (s64[20]{0}) call(s64[20]{0} %add.70, s64[] %constant.71), to_apply=%jit_vmap_floor_divide_.20 + %get-tuple-element.73 = s64[20]{0} get-tuple-element((s64[20]{0}) %call.72), index=0 + %constant.74 = s64[] constant(0) + %broadcast.75 = s64[20]{0} broadcast(s64[] %constant.74), dimensions={} + %compare.76 = pred[20]{0} compare(s64[20]{0} %get-tuple-element.73, s64[20]{0} %broadcast.75), direction=LT + %constant.77 = s64[] constant(22) + %broadcast.78 = s64[20]{0} broadcast(s64[] %constant.77), dimensions={} + %add.79 = s64[20]{0} add(s64[20]{0} %get-tuple-element.73, s64[20]{0} %broadcast.78) + %select.80 = s64[20]{0} select(pred[20]{0} %compare.76, s64[20]{0} %add.79, s64[20]{0} %get-tuple-element.73) + %convert.81 = s32[20]{0} convert(s64[20]{0} %select.80) + %broadcast.82 = s32[20,1]{1,0} broadcast(s32[20]{0} %convert.81), dimensions={0} + %gather.83 = f64[20]{0} gather(f64[22]{0} %get-tuple-element.61, s32[20,1]{1,0} %broadcast.82), offset_dims={}, collapsed_slice_dims={0}, start_index_map={0}, index_vector_dim=1, slice_sizes={1} + %compare.84 = pred[20]{0} compare(f64[20]{0} %get-tuple-element.62, f64[20]{0} %gather.83), direction=LE + %call.85 = (s64[20]{0}) call(pred[20]{0} %compare.84, s64[20]{0} %get-tuple-element.65, s64[20]{0} %get-tuple-element.73), to_apply=%jit_vmap__where___51.43 + %get-tuple-element.86 = s64[20]{0} get-tuple-element((s64[20]{0}) %call.85), index=0 + %call.87 = (s64[20]{0}) call(pred[20]{0} %compare.84, s64[20]{0} %get-tuple-element.73, s64[20]{0} %get-tuple-element.66), to_apply=%jit_vmap__where___52.51 + %get-tuple-element.88 = s64[20]{0} get-tuple-element((s64[20]{0}) %call.87), index=0 + ROOT %tuple.91 = (f64[22]{0}, f64[20]{0}, s64[], s64[], s64[20]{0}, /*index=5*/s64[20]{0}) tuple(f64[22]{0} %get-tuple-element.61, f64[20]{0} %get-tuple-element.62, s64[] %add.90, s64[] %add.69, s64[20]{0} %get-tuple-element.86, /*index=5*/s64[20]{0} %get-tuple-element.88) +} + +%cond_computation.92 (parameter.93: (f64[22], f64[20], s64[], s64[], s64[20], /*index=5*/s64[20])) -> pred[] { + %parameter.93 = (f64[22]{0}, f64[20]{0}, s64[], s64[], s64[20]{0}, /*index=5*/s64[20]{0}) parameter(0) + %get-tuple-element.94 = f64[22]{0} get-tuple-element((f64[22]{0}, f64[20]{0}, s64[], s64[], s64[20]{0}, /*index=5*/s64[20]{0}) %parameter.93), index=0 + %get-tuple-element.95 = f64[20]{0} get-tuple-element((f64[22]{0}, f64[20]{0}, s64[], s64[], s64[20]{0}, /*index=5*/s64[20]{0}) %parameter.93), index=1 + %get-tuple-element.97 = s64[] get-tuple-element((f64[22]{0}, f64[20]{0}, s64[], s64[], s64[20]{0}, /*index=5*/s64[20]{0}) %parameter.93), index=3 + %get-tuple-element.98 = s64[20]{0} get-tuple-element((f64[22]{0}, f64[20]{0}, s64[], s64[], s64[20]{0}, /*index=5*/s64[20]{0}) %parameter.93), index=4 + %get-tuple-element.99 = s64[20]{0} get-tuple-element((f64[22]{0}, f64[20]{0}, s64[], s64[], s64[20]{0}, /*index=5*/s64[20]{0}) %parameter.93), index=5 + %constant.100 = pred[] constant(false) + %get-tuple-element.96 = s64[] get-tuple-element((f64[22]{0}, f64[20]{0}, s64[], s64[], s64[20]{0}, /*index=5*/s64[20]{0}) %parameter.93), index=2 + %constant.101 = s64[] constant(5) + ROOT %compare.102 = pred[] compare(s64[] %get-tuple-element.96, s64[] %constant.101), direction=LT +} + +ENTRY %jit_searchsorted.120 (parameter.1: f64[22], parameter.2: f64[20]) -> (s64[20]) { + %constant.3 = pred[] constant(false) + %constant.9 = pred[] constant(false) + %parameter.1 = f64[22]{0} parameter(0) + %parameter.2 = f64[20]{0} parameter(1) + %constant.10 = s64[] constant(0) + %constant.8 = s64[] constant(0) + %constant.4 = s64[] constant(0) + %broadcast.5 = s64[20]{0} broadcast(s64[] %constant.4), dimensions={} + %constant.6 = s64[] constant(22) + %broadcast.7 = s64[20]{0} broadcast(s64[] %constant.6), dimensions={} + %tuple.11 = (f64[22]{0}, f64[20]{0}, s64[], s64[], s64[20]{0}, /*index=5*/s64[20]{0}) tuple(f64[22]{0} %parameter.1, f64[20]{0} %parameter.2, s64[] %constant.10, s64[] %constant.8, s64[20]{0} %broadcast.5, /*index=5*/s64[20]{0} %broadcast.7) + %while.103 = (f64[22]{0}, f64[20]{0}, s64[], s64[], s64[20]{0}, /*index=5*/s64[20]{0}) while((f64[22]{0}, f64[20]{0}, s64[], s64[], s64[20]{0}, /*index=5*/s64[20]{0}) %tuple.11), condition=%cond_computation.92, body=%body_computation.59 + %get-tuple-element.104 = f64[22]{0} get-tuple-element((f64[22]{0}, f64[20]{0}, s64[], s64[], s64[20]{0}, /*index=5*/s64[20]{0}) %while.103), index=0 + %get-tuple-element.105 = f64[20]{0} get-tuple-element((f64[22]{0}, f64[20]{0}, s64[], s64[], s64[20]{0}, /*index=5*/s64[20]{0}) %while.103), index=1 + %get-tuple-element.106 = s64[] get-tuple-element((f64[22]{0}, f64[20]{0}, s64[], s64[], s64[20]{0}, /*index=5*/s64[20]{0}) %while.103), index=2 + %get-tuple-element.107 = s64[] get-tuple-element((f64[22]{0}, f64[20]{0}, s64[], s64[], s64[20]{0}, /*index=5*/s64[20]{0}) %while.103), index=3 + %get-tuple-element.108 = s64[20]{0} get-tuple-element((f64[22]{0}, f64[20]{0}, s64[], s64[], s64[20]{0}, /*index=5*/s64[20]{0}) %while.103), index=4 + %get-tuple-element.109 = s64[20]{0} get-tuple-element((f64[22]{0}, f64[20]{0}, s64[], s64[], s64[20]{0}, /*index=5*/s64[20]{0}) %while.103), index=5 + %tuple.110 = (s64[], s64[], s64[20]{0}, s64[20]{0}) tuple(s64[] %get-tuple-element.106, s64[] %get-tuple-element.107, s64[20]{0} %get-tuple-element.108, s64[20]{0} %get-tuple-element.109) + %get-tuple-element.111 = s64[] get-tuple-element((s64[], s64[], s64[20]{0}, s64[20]{0}) %tuple.110), index=0 + %get-tuple-element.112 = s64[] get-tuple-element((s64[], s64[], s64[20]{0}, s64[20]{0}) %tuple.110), index=1 + %get-tuple-element.113 = s64[20]{0} get-tuple-element((s64[], s64[], s64[20]{0}, s64[20]{0}) %tuple.110), index=2 + %get-tuple-element.114 = s64[20]{0} get-tuple-element((s64[], s64[], s64[20]{0}, s64[20]{0}) %tuple.110), index=3 + %tuple.115 = (s64[], s64[20]{0}, s64[20]{0}) tuple(s64[] %get-tuple-element.112, s64[20]{0} %get-tuple-element.113, s64[20]{0} %get-tuple-element.114) + %get-tuple-element.116 = s64[] get-tuple-element((s64[], s64[20]{0}, s64[20]{0}) %tuple.115), index=0 + %get-tuple-element.117 = s64[20]{0} get-tuple-element((s64[], s64[20]{0}, s64[20]{0}) %tuple.115), index=1 + %get-tuple-element.118 = s64[20]{0} get-tuple-element((s64[], s64[20]{0}, s64[20]{0}) %tuple.115), index=2 + ROOT %tuple.119 = (s64[20]{0}) tuple(s64[20]{0} %get-tuple-element.118) +} + diff --git a/tests/hlo_texts/test_hlos/BayesNewton/1649162002058928.module_0001.jit__unique1d_sorted_mask.54.before_optimizations.txt b/tests/hlo_texts/test_hlos/BayesNewton/1649162002058928.module_0001.jit__unique1d_sorted_mask.54.before_optimizations.txt new file mode 100644 index 0000000..0767861 --- /dev/null +++ b/tests/hlo_texts/test_hlos/BayesNewton/1649162002058928.module_0001.jit__unique1d_sorted_mask.54.before_optimizations.txt @@ -0,0 +1,64 @@ +HloModule jit__unique1d_sorted_mask.54 + +%sort_lt_comparator.4 (parameter.5: f64[], parameter.6: f64[]) -> pred[] { + %constant.7 = pred[] constant(false) + %parameter.5 = f64[] parameter(0) + %bitcast-convert.8 = s64[] bitcast-convert(f64[] %parameter.5) + %constant.13 = s64[] constant(0) + %compare.14 = pred[] compare(s64[] %bitcast-convert.8, s64[] %constant.13), direction=LT + %constant.10 = u64[] constant(9223372036854775807) + %bitcast-convert.9 = u64[] bitcast-convert(f64[] %parameter.5) + %subtract.11 = u64[] subtract(u64[] %constant.10, u64[] %bitcast-convert.9) + %bitcast-convert.12 = s64[] bitcast-convert(u64[] %subtract.11) + %select.15 = s64[] select(pred[] %compare.14, s64[] %bitcast-convert.12, s64[] %bitcast-convert.8) + %parameter.6 = f64[] parameter(1) + %bitcast-convert.16 = s64[] bitcast-convert(f64[] %parameter.6) + %constant.21 = s64[] constant(0) + %compare.22 = pred[] compare(s64[] %bitcast-convert.16, s64[] %constant.21), direction=LT + %constant.18 = u64[] constant(9223372036854775807) + %bitcast-convert.17 = u64[] bitcast-convert(f64[] %parameter.6) + %subtract.19 = u64[] subtract(u64[] %constant.18, u64[] %bitcast-convert.17) + %bitcast-convert.20 = s64[] bitcast-convert(u64[] %subtract.19) + %select.23 = s64[] select(pred[] %compare.22, s64[] %bitcast-convert.20, s64[] %bitcast-convert.16) + ROOT %compare.24 = pred[] compare(s64[] %select.15, s64[] %select.23), direction=LT +} + +%jit_sort.25 (parameter.26: f64[500]) -> (f64[500]) { + %constant.27 = pred[] constant(false) + %parameter.26 = f64[500]{0} parameter(0) + %sort.28 = f64[500]{0} sort(f64[500]{0} %parameter.26), dimensions={0}, is_stable=true, to_apply=%sort_lt_comparator.4 + %tuple.29 = (f64[500]{0}) tuple(f64[500]{0} %sort.28) + %get-tuple-element.30 = f64[500]{0} get-tuple-element((f64[500]{0}) %tuple.29), index=0 + ROOT %tuple.31 = (f64[500]{0}) tuple(f64[500]{0} %get-tuple-element.30) +} + +%reduction_computation.48 (parameter.49: pred[], parameter.50: pred[]) -> pred[] { + %parameter.49 = pred[] parameter(0) + ROOT %parameter.50 = pred[] parameter(1) + %constant.51 = pred[] constant(false) +} + +ENTRY %jit__unique1d_sorted_mask.54 (parameter.2: f64[500]) -> (f64[500], pred[500], s64[0]) { + %constant.3 = pred[] constant(false) + %constant.47 = pred[] constant(false) + %parameter.2 = f64[500]{0} parameter(0) + %call.32 = (f64[500]{0}) call(f64[500]{0} %parameter.2), to_apply=%jit_sort.25 + %get-tuple-element.33 = f64[500]{0} get-tuple-element((f64[500]{0}) %call.32), index=0 + %constant.34 = pred[] constant(true) + %broadcast.35 = pred[500]{0} broadcast(pred[] %constant.34), dimensions={} + %constant.45 = s32[] constant(1) + %broadcast.46 = s32[1]{0} broadcast(s32[] %constant.45), dimensions={} + %constant.36 = s32[] constant(1) + %broadcast.37 = s32[1]{0} broadcast(s32[] %constant.36), dimensions={} + %gather.38 = f64[499]{0} gather(f64[500]{0} %get-tuple-element.33, s32[1]{0} %broadcast.37), offset_dims={0}, collapsed_slice_dims={}, start_index_map={0}, index_vector_dim=0, slice_sizes={499}, indices_are_sorted=true + %broadcast.39 = f64[499]{0} broadcast(f64[499]{0} %gather.38), dimensions={0} + %constant.40 = s32[] constant(0) + %broadcast.41 = s32[1]{0} broadcast(s32[] %constant.40), dimensions={} + %gather.42 = f64[499]{0} gather(f64[500]{0} %get-tuple-element.33, s32[1]{0} %broadcast.41), offset_dims={0}, collapsed_slice_dims={}, start_index_map={0}, index_vector_dim=0, slice_sizes={499}, indices_are_sorted=true + %broadcast.43 = f64[499]{0} broadcast(f64[499]{0} %gather.42), dimensions={0} + %compare.44 = pred[499]{0} compare(f64[499]{0} %broadcast.39, f64[499]{0} %broadcast.43), direction=NE + %scatter.52 = pred[500]{0} scatter(pred[500]{0} %broadcast.35, s32[1]{0} %broadcast.46, pred[499]{0} %compare.44), update_window_dims={0}, inserted_window_dims={}, scatter_dims_to_operand_dims={0}, index_vector_dim=0, indices_are_sorted=true, unique_indices=true, to_apply=%reduction_computation.48 + %constant.1 = s64[0]{0} constant({}) + ROOT %tuple.53 = (f64[500]{0}, pred[500]{0}, s64[0]{0}) tuple(f64[500]{0} %get-tuple-element.33, pred[500]{0} %scatter.52, s64[0]{0} %constant.1) +} + diff --git a/tests/hlo_texts/test_hlos/BayesNewton/1649162245014652.module_2517.jit_matmul__15.6.before_optimizations.txt b/tests/hlo_texts/test_hlos/BayesNewton/1649162245014652.module_2517.jit_matmul__15.6.before_optimizations.txt new file mode 100644 index 0000000..6e5bee6 --- /dev/null +++ b/tests/hlo_texts/test_hlos/BayesNewton/1649162245014652.module_2517.jit_matmul__15.6.before_optimizations.txt @@ -0,0 +1,10 @@ +HloModule jit_matmul__15.6 + +ENTRY %jit_matmul__15.6 (parameter.1: f64[125,3,3], parameter.2: f64[125,3,1]) -> (f64[125,3,1]) { + %constant.3 = pred[] constant(false) + %parameter.1 = f64[125,3,3]{2,1,0} parameter(0) + %parameter.2 = f64[125,3,1]{2,1,0} parameter(1) + %dot.4 = f64[125,3,1]{2,1,0} dot(f64[125,3,3]{2,1,0} %parameter.1, f64[125,3,1]{2,1,0} %parameter.2), lhs_batch_dims={0}, lhs_contracting_dims={2}, rhs_batch_dims={0}, rhs_contracting_dims={1} + ROOT %tuple.5 = (f64[125,3,1]{2,1,0}) tuple(f64[125,3,1]{2,1,0} %dot.4) +} + diff --git a/tests/hlo_texts/test_hlos/BayesNewton/1649162750550487.module_0785.jit__cholesky__4.58.before_optimizations.txt b/tests/hlo_texts/test_hlos/BayesNewton/1649162750550487.module_0785.jit__cholesky__4.58.before_optimizations.txt new file mode 100644 index 0000000..0767861 --- /dev/null +++ b/tests/hlo_texts/test_hlos/BayesNewton/1649162750550487.module_0785.jit__cholesky__4.58.before_optimizations.txt @@ -0,0 +1,64 @@ +HloModule jit__unique1d_sorted_mask.54 + +%sort_lt_comparator.4 (parameter.5: f64[], parameter.6: f64[]) -> pred[] { + %constant.7 = pred[] constant(false) + %parameter.5 = f64[] parameter(0) + %bitcast-convert.8 = s64[] bitcast-convert(f64[] %parameter.5) + %constant.13 = s64[] constant(0) + %compare.14 = pred[] compare(s64[] %bitcast-convert.8, s64[] %constant.13), direction=LT + %constant.10 = u64[] constant(9223372036854775807) + %bitcast-convert.9 = u64[] bitcast-convert(f64[] %parameter.5) + %subtract.11 = u64[] subtract(u64[] %constant.10, u64[] %bitcast-convert.9) + %bitcast-convert.12 = s64[] bitcast-convert(u64[] %subtract.11) + %select.15 = s64[] select(pred[] %compare.14, s64[] %bitcast-convert.12, s64[] %bitcast-convert.8) + %parameter.6 = f64[] parameter(1) + %bitcast-convert.16 = s64[] bitcast-convert(f64[] %parameter.6) + %constant.21 = s64[] constant(0) + %compare.22 = pred[] compare(s64[] %bitcast-convert.16, s64[] %constant.21), direction=LT + %constant.18 = u64[] constant(9223372036854775807) + %bitcast-convert.17 = u64[] bitcast-convert(f64[] %parameter.6) + %subtract.19 = u64[] subtract(u64[] %constant.18, u64[] %bitcast-convert.17) + %bitcast-convert.20 = s64[] bitcast-convert(u64[] %subtract.19) + %select.23 = s64[] select(pred[] %compare.22, s64[] %bitcast-convert.20, s64[] %bitcast-convert.16) + ROOT %compare.24 = pred[] compare(s64[] %select.15, s64[] %select.23), direction=LT +} + +%jit_sort.25 (parameter.26: f64[500]) -> (f64[500]) { + %constant.27 = pred[] constant(false) + %parameter.26 = f64[500]{0} parameter(0) + %sort.28 = f64[500]{0} sort(f64[500]{0} %parameter.26), dimensions={0}, is_stable=true, to_apply=%sort_lt_comparator.4 + %tuple.29 = (f64[500]{0}) tuple(f64[500]{0} %sort.28) + %get-tuple-element.30 = f64[500]{0} get-tuple-element((f64[500]{0}) %tuple.29), index=0 + ROOT %tuple.31 = (f64[500]{0}) tuple(f64[500]{0} %get-tuple-element.30) +} + +%reduction_computation.48 (parameter.49: pred[], parameter.50: pred[]) -> pred[] { + %parameter.49 = pred[] parameter(0) + ROOT %parameter.50 = pred[] parameter(1) + %constant.51 = pred[] constant(false) +} + +ENTRY %jit__unique1d_sorted_mask.54 (parameter.2: f64[500]) -> (f64[500], pred[500], s64[0]) { + %constant.3 = pred[] constant(false) + %constant.47 = pred[] constant(false) + %parameter.2 = f64[500]{0} parameter(0) + %call.32 = (f64[500]{0}) call(f64[500]{0} %parameter.2), to_apply=%jit_sort.25 + %get-tuple-element.33 = f64[500]{0} get-tuple-element((f64[500]{0}) %call.32), index=0 + %constant.34 = pred[] constant(true) + %broadcast.35 = pred[500]{0} broadcast(pred[] %constant.34), dimensions={} + %constant.45 = s32[] constant(1) + %broadcast.46 = s32[1]{0} broadcast(s32[] %constant.45), dimensions={} + %constant.36 = s32[] constant(1) + %broadcast.37 = s32[1]{0} broadcast(s32[] %constant.36), dimensions={} + %gather.38 = f64[499]{0} gather(f64[500]{0} %get-tuple-element.33, s32[1]{0} %broadcast.37), offset_dims={0}, collapsed_slice_dims={}, start_index_map={0}, index_vector_dim=0, slice_sizes={499}, indices_are_sorted=true + %broadcast.39 = f64[499]{0} broadcast(f64[499]{0} %gather.38), dimensions={0} + %constant.40 = s32[] constant(0) + %broadcast.41 = s32[1]{0} broadcast(s32[] %constant.40), dimensions={} + %gather.42 = f64[499]{0} gather(f64[500]{0} %get-tuple-element.33, s32[1]{0} %broadcast.41), offset_dims={0}, collapsed_slice_dims={}, start_index_map={0}, index_vector_dim=0, slice_sizes={499}, indices_are_sorted=true + %broadcast.43 = f64[499]{0} broadcast(f64[499]{0} %gather.42), dimensions={0} + %compare.44 = pred[499]{0} compare(f64[499]{0} %broadcast.39, f64[499]{0} %broadcast.43), direction=NE + %scatter.52 = pred[500]{0} scatter(pred[500]{0} %broadcast.35, s32[1]{0} %broadcast.46, pred[499]{0} %compare.44), update_window_dims={0}, inserted_window_dims={}, scatter_dims_to_operand_dims={0}, index_vector_dim=0, indices_are_sorted=true, unique_indices=true, to_apply=%reduction_computation.48 + %constant.1 = s64[0]{0} constant({}) + ROOT %tuple.53 = (f64[500]{0}, pred[500]{0}, s64[0]{0}) tuple(f64[500]{0} %get-tuple-element.33, pred[500]{0} %scatter.52, s64[0]{0} %constant.1) +} + diff --git a/tests/hlo_texts/test_hlos/GANs-JAX/module_0014.jit__unstack.6.before_optimizations.txt b/tests/hlo_texts/test_hlos/GANs-JAX/module_0014.jit__unstack.6.before_optimizations.txt new file mode 100644 index 0000000..385794c --- /dev/null +++ b/tests/hlo_texts/test_hlos/GANs-JAX/module_0014.jit__unstack.6.before_optimizations.txt @@ -0,0 +1,15 @@ +HloModule jit__unstack.6 + +ENTRY main.11 { + Arg_0.1 = u32[4,2]{1,0} parameter(0) + slice.2 = u32[1,2]{1,0} slice(Arg_0.1), slice={[0:1], [0:2]} + reshape.3 = u32[2]{0} reshape(slice.2) + slice.4 = u32[1,2]{1,0} slice(Arg_0.1), slice={[1:2], [0:2]} + reshape.5 = u32[2]{0} reshape(slice.4) + slice.6 = u32[1,2]{1,0} slice(Arg_0.1), slice={[2:3], [0:2]} + reshape.7 = u32[2]{0} reshape(slice.6) + slice.8 = u32[1,2]{1,0} slice(Arg_0.1), slice={[3:4], [0:2]} + reshape.9 = u32[2]{0} reshape(slice.8) + ROOT tuple.10 = (u32[2]{0}, u32[2]{0}, u32[2]{0}, u32[2]{0}) tuple(reshape.3, reshape.5, reshape.7, reshape.9) +} + diff --git a/tests/hlo_texts/test_hlos/GANs-JAX/module_0029.jit__one_hot.13.before_optimizations.txt b/tests/hlo_texts/test_hlos/GANs-JAX/module_0029.jit__one_hot.13.before_optimizations.txt new file mode 100644 index 0000000..602ae2c --- /dev/null +++ b/tests/hlo_texts/test_hlos/GANs-JAX/module_0029.jit__one_hot.13.before_optimizations.txt @@ -0,0 +1,17 @@ +HloModule jit__one_hot.13 + +ENTRY main.13 { + Arg_0.1 = s32[100]{0} parameter(0) + reshape.2 = s32[100,1]{1,0} reshape(Arg_0.1) + broadcast.5 = s32[100,1]{1,0} broadcast(reshape.2), dimensions={0,1} + reshape.6 = s32[100]{0} reshape(broadcast.5) + broadcast.7 = s32[100,10]{1,0} broadcast(reshape.6), dimensions={0} + iota.3 = s32[10]{0} iota(), iota_dimension=0 + reshape.4 = s32[1,10]{1,0} reshape(iota.3) + broadcast.8 = s32[1,10]{1,0} broadcast(reshape.4), dimensions={0,1} + reshape.9 = s32[10]{0} reshape(broadcast.8) + broadcast.10 = s32[100,10]{1,0} broadcast(reshape.9), dimensions={1} + compare.11 = pred[100,10]{1,0} compare(broadcast.7, broadcast.10), direction=EQ + ROOT convert.12 = f32[100,10]{1,0} convert(compare.11) +} + diff --git a/tests/hlo_texts/test_hlos/GANs-JAX/module_0034.jit__normal.12.before_optimizations.txt b/tests/hlo_texts/test_hlos/GANs-JAX/module_0034.jit__normal.12.before_optimizations.txt new file mode 100644 index 0000000..ac9af6b --- /dev/null +++ b/tests/hlo_texts/test_hlos/GANs-JAX/module_0034.jit__normal.12.before_optimizations.txt @@ -0,0 +1,154 @@ +HloModule jit__normal.12 + +xla_fallback_threefry2x32.21 { + Arg_0.22 = u32[] parameter(0) + broadcast.26 = u32[73728]{0} broadcast(Arg_0.22), dimensions={} + Arg_1.23 = u32[] parameter(1) + broadcast.27 = u32[73728]{0} broadcast(Arg_1.23), dimensions={} + Arg_2.24 = u32[73728]{0} parameter(2) + Arg_3.25 = u32[73728]{0} parameter(3) + ROOT custom-call.28 = (u32[73728]{0}, u32[73728]{0}) custom-call(broadcast.26, broadcast.27, Arg_2.24, Arg_3.25), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[73728]{0}, u32[73728]{0}, u32[73728]{0}, u32[73728]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\000 \001\000\000\000\000\000" +} + +threefry2x32.29 { + Arg_0.30 = u32[] parameter(0) + Arg_1.31 = u32[] parameter(1) + Arg_2.32 = u32[73728]{0} parameter(2) + Arg_3.33 = u32[73728]{0} parameter(3) + call.34 = (u32[73728]{0}, u32[73728]{0}) call(Arg_0.30, Arg_1.31, Arg_2.32, Arg_3.33), to_apply=xla_fallback_threefry2x32.21 + get-tuple-element.35 = u32[73728]{0} get-tuple-element(call.34), index=0 + get-tuple-element.36 = u32[73728]{0} get-tuple-element(call.34), index=1 + ROOT tuple.37 = (u32[73728]{0}, u32[73728]{0}) tuple(get-tuple-element.35, get-tuple-element.36) +} + +xla_fallback_erf_inv.50 { + Arg_0.51 = f32[3,3,64,256]{3,2,1,0} parameter(0) + abs.98 = f32[3,3,64,256]{3,2,1,0} abs(Arg_0.51) + constant.96 = f32[] constant(1) + broadcast.97 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.96), dimensions={} + compare.99 = pred[3,3,64,256]{3,2,1,0} compare(abs.98, broadcast.97), direction=EQ + constant.94 = f32[] constant(inf) + broadcast.95 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.94), dimensions={} + multiply.100 = f32[3,3,64,256]{3,2,1,0} multiply(Arg_0.51, broadcast.95) + negate.101 = f32[3,3,64,256]{3,2,1,0} negate(Arg_0.51) + multiply.102 = f32[3,3,64,256]{3,2,1,0} multiply(negate.101, Arg_0.51) + log-plus-one.103 = f32[3,3,64,256]{3,2,1,0} log-plus-one(multiply.102) + negate.104 = f32[3,3,64,256]{3,2,1,0} negate(log-plus-one.103) + constant.92 = f32[] constant(5) + broadcast.93 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.92), dimensions={} + compare.105 = pred[3,3,64,256]{3,2,1,0} compare(negate.104, broadcast.93), direction=LT + constant.90 = f32[] constant(1.50140941) + broadcast.91 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.90), dimensions={} + constant.88 = f32[] constant(2.83297682) + broadcast.89 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.88), dimensions={} + select.106 = f32[3,3,64,256]{3,2,1,0} select(compare.105, broadcast.91, broadcast.89) + constant.86 = f32[] constant(0.246640727) + broadcast.87 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.86), dimensions={} + constant.84 = f32[] constant(1.00167406) + broadcast.85 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.84), dimensions={} + select.107 = f32[3,3,64,256]{3,2,1,0} select(compare.105, broadcast.87, broadcast.85) + constant.82 = f32[] constant(-0.00417768164) + broadcast.83 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.82), dimensions={} + constant.80 = f32[] constant(0.00943887047) + broadcast.81 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.80), dimensions={} + select.108 = f32[3,3,64,256]{3,2,1,0} select(compare.105, broadcast.83, broadcast.81) + constant.78 = f32[] constant(-0.00125372503) + broadcast.79 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.78), dimensions={} + constant.76 = f32[] constant(-0.0076224613) + broadcast.77 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.76), dimensions={} + select.109 = f32[3,3,64,256]{3,2,1,0} select(compare.105, broadcast.79, broadcast.77) + constant.74 = f32[] constant(0.00021858087) + broadcast.75 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.74), dimensions={} + constant.72 = f32[] constant(0.00573950773) + broadcast.73 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.72), dimensions={} + select.110 = f32[3,3,64,256]{3,2,1,0} select(compare.105, broadcast.75, broadcast.73) + constant.70 = f32[] constant(-4.39150654e-06) + broadcast.71 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.70), dimensions={} + constant.68 = f32[] constant(-0.00367342844) + broadcast.69 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.68), dimensions={} + select.111 = f32[3,3,64,256]{3,2,1,0} select(compare.105, broadcast.71, broadcast.69) + constant.66 = f32[] constant(-3.5233877e-06) + broadcast.67 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.66), dimensions={} + constant.64 = f32[] constant(0.00134934322) + broadcast.65 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.64), dimensions={} + select.112 = f32[3,3,64,256]{3,2,1,0} select(compare.105, broadcast.67, broadcast.65) + constant.62 = f32[] constant(3.43273939e-07) + broadcast.63 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.62), dimensions={} + constant.60 = f32[] constant(0.000100950558) + broadcast.61 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.60), dimensions={} + select.113 = f32[3,3,64,256]{3,2,1,0} select(compare.105, broadcast.63, broadcast.61) + constant.58 = f32[] constant(2.81022636e-08) + broadcast.59 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.58), dimensions={} + constant.56 = f32[] constant(-0.000200214257) + broadcast.57 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.56), dimensions={} + select.114 = f32[3,3,64,256]{3,2,1,0} select(compare.105, broadcast.59, broadcast.57) + constant.54 = f32[] constant(2.5) + broadcast.55 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.54), dimensions={} + subtract.115 = f32[3,3,64,256]{3,2,1,0} subtract(negate.104, broadcast.55) + sqrt.116 = f32[3,3,64,256]{3,2,1,0} sqrt(negate.104) + constant.52 = f32[] constant(3) + broadcast.53 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.52), dimensions={} + subtract.117 = f32[3,3,64,256]{3,2,1,0} subtract(sqrt.116, broadcast.53) + select.118 = f32[3,3,64,256]{3,2,1,0} select(compare.105, subtract.115, subtract.117) + multiply.119 = f32[3,3,64,256]{3,2,1,0} multiply(select.114, select.118) + add.120 = f32[3,3,64,256]{3,2,1,0} add(select.113, multiply.119) + multiply.121 = f32[3,3,64,256]{3,2,1,0} multiply(add.120, select.118) + add.122 = f32[3,3,64,256]{3,2,1,0} add(select.112, multiply.121) + multiply.123 = f32[3,3,64,256]{3,2,1,0} multiply(add.122, select.118) + add.124 = f32[3,3,64,256]{3,2,1,0} add(select.111, multiply.123) + multiply.125 = f32[3,3,64,256]{3,2,1,0} multiply(add.124, select.118) + add.126 = f32[3,3,64,256]{3,2,1,0} add(select.110, multiply.125) + multiply.127 = f32[3,3,64,256]{3,2,1,0} multiply(add.126, select.118) + add.128 = f32[3,3,64,256]{3,2,1,0} add(select.109, multiply.127) + multiply.129 = f32[3,3,64,256]{3,2,1,0} multiply(add.128, select.118) + add.130 = f32[3,3,64,256]{3,2,1,0} add(select.108, multiply.129) + multiply.131 = f32[3,3,64,256]{3,2,1,0} multiply(add.130, select.118) + add.132 = f32[3,3,64,256]{3,2,1,0} add(select.107, multiply.131) + multiply.133 = f32[3,3,64,256]{3,2,1,0} multiply(add.132, select.118) + add.134 = f32[3,3,64,256]{3,2,1,0} add(select.106, multiply.133) + multiply.135 = f32[3,3,64,256]{3,2,1,0} multiply(add.134, Arg_0.51) + ROOT select.136 = f32[3,3,64,256]{3,2,1,0} select(compare.99, multiply.100, multiply.135) +} + +erf_inv.137 { + Arg_0.138 = f32[3,3,64,256]{3,2,1,0} parameter(0) + ROOT call.139 = f32[3,3,64,256]{3,2,1,0} call(Arg_0.138), to_apply=xla_fallback_erf_inv.50 +} + +ENTRY main.142 { + Arg_0.1 = u32[2]{0} parameter(0) + slice.15 = u32[1]{0} slice(Arg_0.1), slice={[0:1]} + reshape.16 = u32[] reshape(slice.15) + slice.17 = u32[1]{0} slice(Arg_0.1), slice={[1:2]} + reshape.18 = u32[] reshape(slice.17) + iota.14 = u32[147456]{0} iota(), iota_dimension=0 + slice.19 = u32[73728]{0} slice(iota.14), slice={[0:73728]} + slice.20 = u32[73728]{0} slice(iota.14), slice={[73728:147456]} + call.38 = (u32[73728]{0}, u32[73728]{0}) call(reshape.16, reshape.18, slice.19, slice.20), to_apply=threefry2x32.29 + get-tuple-element.39 = u32[73728]{0} get-tuple-element(call.38), index=0 + get-tuple-element.40 = u32[73728]{0} get-tuple-element(call.38), index=1 + concatenate.41 = u32[147456]{0} concatenate(get-tuple-element.39, get-tuple-element.40), dimensions={0} + reshape.42 = u32[3,3,64,256]{3,2,1,0} reshape(concatenate.41) + constant.12 = u32[] constant(9) + broadcast.13 = u32[3,3,64,256]{3,2,1,0} broadcast(constant.12), dimensions={} + shift-right-logical.43 = u32[3,3,64,256]{3,2,1,0} shift-right-logical(reshape.42, broadcast.13) + constant.10 = u32[] constant(1065353216) + broadcast.11 = u32[3,3,64,256]{3,2,1,0} broadcast(constant.10), dimensions={} + or.44 = u32[3,3,64,256]{3,2,1,0} or(shift-right-logical.43, broadcast.11) + bitcast-convert.45 = f32[3,3,64,256]{3,2,1,0} bitcast-convert(or.44) + constant.8 = f32[] constant(1) + broadcast.9 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.8), dimensions={} + subtract.46 = f32[3,3,64,256]{3,2,1,0} subtract(bitcast-convert.45, broadcast.9) + constant.6 = f32[] constant(2) + broadcast.7 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.6), dimensions={} + multiply.47 = f32[3,3,64,256]{3,2,1,0} multiply(subtract.46, broadcast.7) + constant.4 = f32[] constant(-0.99999994) + broadcast.5 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.4), dimensions={} + add.48 = f32[3,3,64,256]{3,2,1,0} add(multiply.47, broadcast.5) + maximum.49 = f32[3,3,64,256]{3,2,1,0} maximum(add.48, broadcast.5) + call.140 = f32[3,3,64,256]{3,2,1,0} call(maximum.49), to_apply=erf_inv.137 + constant.2 = f32[] constant(1.41421354) + broadcast.3 = f32[3,3,64,256]{3,2,1,0} broadcast(constant.2), dimensions={} + ROOT multiply.141 = f32[3,3,64,256]{3,2,1,0} multiply(call.140, broadcast.3) +} + diff --git a/tests/hlo_texts/test_hlos/NuX/1648647389204864.module_0018.jit__randint.109.before_optimizations.txt b/tests/hlo_texts/test_hlos/NuX/1648647389204864.module_0018.jit__randint.109.before_optimizations.txt new file mode 100644 index 0000000..ad33ca4 --- /dev/null +++ b/tests/hlo_texts/test_hlos/NuX/1648647389204864.module_0018.jit__randint.109.before_optimizations.txt @@ -0,0 +1,113 @@ +HloModule jit__randint.109 + +ENTRY %jit__randint.109 (parameter.1: u32[2], parameter.2: s32[], parameter.3: s32[]) -> (s32[16]) { + %constant.4 = pred[] constant(false) + %constant.14 = s32[] constant(2147483647) + %constant.12 = s32[] constant(-2147483648) + %parameter.2 = s32[] parameter(1) + %convert.11 = s32[] convert(s32[] %parameter.2) + %maximum.13 = s32[] maximum(s32[] %constant.12, s32[] %convert.11) + %minimum.15 = s32[] minimum(s32[] %constant.14, s32[] %maximum.13) + %broadcast.21 = s32[1]{0} broadcast(s32[] %minimum.15), dimensions={} + %reshape.105 = s32[] reshape(s32[1]{0} %broadcast.21) + %broadcast.106 = s32[16]{0} broadcast(s32[] %reshape.105), dimensions={} + %parameter.1 = u32[2]{0} parameter(0) + %slice.24 = u32[1]{0} slice(u32[2]{0} %parameter.1), slice={[0:1]} + %reshape.25 = u32[] reshape(u32[1]{0} %slice.24) + %broadcast.30 = u32[2]{0} broadcast(u32[] %reshape.25), dimensions={} + %slice.26 = u32[1]{0} slice(u32[2]{0} %parameter.1), slice={[1:2]} + %reshape.27 = u32[] reshape(u32[1]{0} %slice.26) + %broadcast.31 = u32[2]{0} broadcast(u32[] %reshape.27), dimensions={} + %iota.23 = u32[4] iota(), iota_dimension=0 + %slice.28 = u32[2]{0} slice(u32[4] %iota.23), slice={[0:2]} + %broadcast.32 = u32[2]{0} broadcast(u32[2]{0} %slice.28), dimensions={0} + %slice.29 = u32[2]{0} slice(u32[4] %iota.23), slice={[2:4]} + %broadcast.33 = u32[2]{0} broadcast(u32[2]{0} %slice.29), dimensions={0} + %custom-call.34 = (u32[2]{0}, u32[2]{0}) custom-call(u32[2]{0} %broadcast.30, u32[2]{0} %broadcast.31, u32[2]{0} %broadcast.32, u32[2]{0} %broadcast.33), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[2]{0}, u32[2]{0}, u32[2]{0}, u32[2]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\002\000\000\000\000\000\000\000" + %get-tuple-element.35 = u32[2]{0} get-tuple-element((u32[2]{0}, u32[2]{0}) %custom-call.34), index=0 + %get-tuple-element.36 = u32[2]{0} get-tuple-element((u32[2]{0}, u32[2]{0}) %custom-call.34), index=1 + %concatenate.37 = u32[4]{0} concatenate(u32[2]{0} %get-tuple-element.35, u32[2]{0} %get-tuple-element.36), dimensions={0} + %reshape.38 = u32[2,2]{1,0} reshape(u32[4]{0} %concatenate.37) + %slice.39 = u32[1,2]{1,0} slice(u32[2,2]{1,0} %reshape.38), slice={[0:1], [0:2]} + %reshape.40 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.39) + %slice.44 = u32[1]{0} slice(u32[2]{0} %reshape.40), slice={[0:1]} + %reshape.45 = u32[] reshape(u32[1]{0} %slice.44) + %broadcast.50 = u32[8]{0} broadcast(u32[] %reshape.45), dimensions={} + %slice.46 = u32[1]{0} slice(u32[2]{0} %reshape.40), slice={[1:2]} + %reshape.47 = u32[] reshape(u32[1]{0} %slice.46) + %broadcast.51 = u32[8]{0} broadcast(u32[] %reshape.47), dimensions={} + %iota.43 = u32[16] iota(), iota_dimension=0 + %slice.48 = u32[8]{0} slice(u32[16] %iota.43), slice={[0:8]} + %broadcast.52 = u32[8]{0} broadcast(u32[8]{0} %slice.48), dimensions={0} + %slice.49 = u32[8]{0} slice(u32[16] %iota.43), slice={[8:16]} + %broadcast.53 = u32[8]{0} broadcast(u32[8]{0} %slice.49), dimensions={0} + %custom-call.54 = (u32[8]{0}, u32[8]{0}) custom-call(u32[8]{0} %broadcast.50, u32[8]{0} %broadcast.51, u32[8]{0} %broadcast.52, u32[8]{0} %broadcast.53), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[8]{0}, u32[8]{0}, u32[8]{0}, u32[8]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\010\000\000\000\000\000\000\000" + %get-tuple-element.55 = u32[8]{0} get-tuple-element((u32[8]{0}, u32[8]{0}) %custom-call.54), index=0 + %get-tuple-element.56 = u32[8]{0} get-tuple-element((u32[8]{0}, u32[8]{0}) %custom-call.54), index=1 + %concatenate.57 = u32[16]{0} concatenate(u32[8]{0} %get-tuple-element.55, u32[8]{0} %get-tuple-element.56), dimensions={0} + %parameter.3 = s32[] parameter(2) + %constant.8 = s32[] constant(2147483647) + %constant.5 = s32[] constant(-2147483648) + %constant.6 = s32[] constant(2147483647) + %maximum.7 = s32[] maximum(s32[] %constant.5, s32[] %constant.6) + %minimum.9 = s32[] minimum(s32[] %constant.8, s32[] %maximum.7) + %compare.10 = pred[] compare(s32[] %parameter.3, s32[] %minimum.9), direction=GT + %broadcast.80 = pred[1]{0} broadcast(pred[] %compare.10), dimensions={} + %constant.19 = s32[] constant(2147483647) + %constant.17 = s32[] constant(-2147483648) + %convert.16 = s32[] convert(s32[] %parameter.3) + %maximum.18 = s32[] maximum(s32[] %constant.17, s32[] %convert.16) + %minimum.20 = s32[] minimum(s32[] %constant.19, s32[] %maximum.18) + %broadcast.22 = s32[1]{0} broadcast(s32[] %minimum.20), dimensions={} + %compare.79 = pred[1]{0} compare(s32[1]{0} %broadcast.22, s32[1]{0} %broadcast.21), direction=GT + %and.81 = pred[1]{0} and(pred[1]{0} %broadcast.80, pred[1]{0} %compare.79) + %compare.75 = pred[1]{0} compare(s32[1]{0} %broadcast.22, s32[1]{0} %broadcast.21), direction=LE + %constant.76 = u32[] constant(1) + %broadcast.77 = u32[1]{0} broadcast(u32[] %constant.76), dimensions={} + %subtract.73 = s32[1]{0} subtract(s32[1]{0} %broadcast.22, s32[1]{0} %broadcast.21) + %convert.74 = u32[1]{0} convert(s32[1]{0} %subtract.73) + %select.78 = u32[1]{0} select(pred[1]{0} %compare.75, u32[1]{0} %broadcast.77, u32[1]{0} %convert.74) + %constant.82 = u32[] constant(1) + %broadcast.83 = u32[1]{0} broadcast(u32[] %constant.82), dimensions={} + %add.84 = u32[1]{0} add(u32[1]{0} %select.78, u32[1]{0} %broadcast.83) + %select.85 = u32[1]{0} select(pred[1]{0} %and.81, u32[1]{0} %add.84, u32[1]{0} %select.78) + %reshape.91 = u32[] reshape(u32[1]{0} %select.85) + %broadcast.92 = u32[16]{0} broadcast(u32[] %reshape.91), dimensions={} + %remainder.93 = u32[16]{0} remainder(u32[16]{0} %concatenate.57, u32[16]{0} %broadcast.92) + %constant.86 = u32[] constant(65536) + %broadcast.87 = u32[1]{0} broadcast(u32[] %constant.86), dimensions={} + %remainder.88 = u32[1]{0} remainder(u32[1]{0} %broadcast.87, u32[1]{0} %select.85) + %multiply.89 = u32[1]{0} multiply(u32[1]{0} %remainder.88, u32[1]{0} %remainder.88) + %remainder.90 = u32[1]{0} remainder(u32[1]{0} %multiply.89, u32[1]{0} %select.85) + %reshape.94 = u32[] reshape(u32[1]{0} %remainder.90) + %broadcast.95 = u32[16]{0} broadcast(u32[] %reshape.94), dimensions={} + %multiply.96 = u32[16]{0} multiply(u32[16]{0} %remainder.93, u32[16]{0} %broadcast.95) + %slice.41 = u32[1,2]{1,0} slice(u32[2,2]{1,0} %reshape.38), slice={[1:2], [0:2]} + %reshape.42 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.41) + %slice.59 = u32[1]{0} slice(u32[2]{0} %reshape.42), slice={[0:1]} + %reshape.60 = u32[] reshape(u32[1]{0} %slice.59) + %broadcast.65 = u32[8]{0} broadcast(u32[] %reshape.60), dimensions={} + %slice.61 = u32[1]{0} slice(u32[2]{0} %reshape.42), slice={[1:2]} + %reshape.62 = u32[] reshape(u32[1]{0} %slice.61) + %broadcast.66 = u32[8]{0} broadcast(u32[] %reshape.62), dimensions={} + %iota.58 = u32[16] iota(), iota_dimension=0 + %slice.63 = u32[8]{0} slice(u32[16] %iota.58), slice={[0:8]} + %broadcast.67 = u32[8]{0} broadcast(u32[8]{0} %slice.63), dimensions={0} + %slice.64 = u32[8]{0} slice(u32[16] %iota.58), slice={[8:16]} + %broadcast.68 = u32[8]{0} broadcast(u32[8]{0} %slice.64), dimensions={0} + %custom-call.69 = (u32[8]{0}, u32[8]{0}) custom-call(u32[8]{0} %broadcast.65, u32[8]{0} %broadcast.66, u32[8]{0} %broadcast.67, u32[8]{0} %broadcast.68), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[8]{0}, u32[8]{0}, u32[8]{0}, u32[8]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\010\000\000\000\000\000\000\000" + %get-tuple-element.70 = u32[8]{0} get-tuple-element((u32[8]{0}, u32[8]{0}) %custom-call.69), index=0 + %get-tuple-element.71 = u32[8]{0} get-tuple-element((u32[8]{0}, u32[8]{0}) %custom-call.69), index=1 + %concatenate.72 = u32[16]{0} concatenate(u32[8]{0} %get-tuple-element.70, u32[8]{0} %get-tuple-element.71), dimensions={0} + %reshape.97 = u32[] reshape(u32[1]{0} %select.85) + %broadcast.98 = u32[16]{0} broadcast(u32[] %reshape.97), dimensions={} + %remainder.99 = u32[16]{0} remainder(u32[16]{0} %concatenate.72, u32[16]{0} %broadcast.98) + %add.100 = u32[16]{0} add(u32[16]{0} %multiply.96, u32[16]{0} %remainder.99) + %reshape.101 = u32[] reshape(u32[1]{0} %select.85) + %broadcast.102 = u32[16]{0} broadcast(u32[] %reshape.101), dimensions={} + %remainder.103 = u32[16]{0} remainder(u32[16]{0} %add.100, u32[16]{0} %broadcast.102) + %convert.104 = s32[16]{0} convert(u32[16]{0} %remainder.103) + %add.107 = s32[16]{0} add(s32[16]{0} %broadcast.106, s32[16]{0} %convert.104) + ROOT %tuple.108 = (s32[16]{0}) tuple(s32[16]{0} %add.107) +} + diff --git a/tests/hlo_texts/test_hlos/NuX/1648647389777040.module_0026.primitive_computation_lt.5.before_optimizations.txt b/tests/hlo_texts/test_hlos/NuX/1648647389777040.module_0026.primitive_computation_lt.5.before_optimizations.txt new file mode 100644 index 0000000..6402aaf --- /dev/null +++ b/tests/hlo_texts/test_hlos/NuX/1648647389777040.module_0026.primitive_computation_lt.5.before_optimizations.txt @@ -0,0 +1,9 @@ +HloModule primitive_computation_lt.5 + +ENTRY %primitive_computation_lt.5 (parameter.1: s32[16], parameter.2: s32[]) -> pred[16] { + %parameter.1 = s32[16]{0} parameter(0) + %parameter.2 = s32[] parameter(1) + %broadcast.3 = s32[16]{0} broadcast(s32[] %parameter.2), dimensions={} + ROOT %compare.4 = pred[16]{0} compare(s32[16]{0} %parameter.1, s32[16]{0} %broadcast.3), direction=LT +} + diff --git a/tests/hlo_texts/test_hlos/NuX/1648647393457587.module_0054.jit__threefry_split__2.20.before_optimizations.txt b/tests/hlo_texts/test_hlos/NuX/1648647393457587.module_0054.jit__threefry_split__2.20.before_optimizations.txt new file mode 100644 index 0000000..fad2aaf --- /dev/null +++ b/tests/hlo_texts/test_hlos/NuX/1648647393457587.module_0054.jit__threefry_split__2.20.before_optimizations.txt @@ -0,0 +1,24 @@ +HloModule jit__threefry_split__2.20 + +ENTRY %jit__threefry_split__2.20 (parameter.1: u32[2]) -> (u32[3,2]) { + %constant.2 = pred[] constant(false) + %parameter.1 = u32[2]{0} parameter(0) + %slice.4 = u32[1]{0} slice(u32[2]{0} %parameter.1), slice={[0:1]} + %reshape.5 = u32[] reshape(u32[1]{0} %slice.4) + %broadcast.10 = u32[3]{0} broadcast(u32[] %reshape.5), dimensions={} + %slice.6 = u32[1]{0} slice(u32[2]{0} %parameter.1), slice={[1:2]} + %reshape.7 = u32[] reshape(u32[1]{0} %slice.6) + %broadcast.11 = u32[3]{0} broadcast(u32[] %reshape.7), dimensions={} + %iota.3 = u32[6] iota(), iota_dimension=0 + %slice.8 = u32[3]{0} slice(u32[6] %iota.3), slice={[0:3]} + %broadcast.12 = u32[3]{0} broadcast(u32[3]{0} %slice.8), dimensions={0} + %slice.9 = u32[3]{0} slice(u32[6] %iota.3), slice={[3:6]} + %broadcast.13 = u32[3]{0} broadcast(u32[3]{0} %slice.9), dimensions={0} + %custom-call.14 = (u32[3]{0}, u32[3]{0}) custom-call(u32[3]{0} %broadcast.10, u32[3]{0} %broadcast.11, u32[3]{0} %broadcast.12, u32[3]{0} %broadcast.13), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[3]{0}, u32[3]{0}, u32[3]{0}, u32[3]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\003\000\000\000\000\000\000\000" + %get-tuple-element.15 = u32[3]{0} get-tuple-element((u32[3]{0}, u32[3]{0}) %custom-call.14), index=0 + %get-tuple-element.16 = u32[3]{0} get-tuple-element((u32[3]{0}, u32[3]{0}) %custom-call.14), index=1 + %concatenate.17 = u32[6]{0} concatenate(u32[3]{0} %get-tuple-element.15, u32[3]{0} %get-tuple-element.16), dimensions={0} + %reshape.18 = u32[3,2]{1,0} reshape(u32[6]{0} %concatenate.17) + ROOT %tuple.19 = (u32[3,2]{1,0}) tuple(u32[3,2]{1,0} %reshape.18) +} + diff --git a/tests/hlo_texts/test_hlos/NuX/1648647409115717.module_0337.jit_loss.9581.before_optimizations.txt b/tests/hlo_texts/test_hlos/NuX/1648647409115717.module_0337.jit_loss.9581.before_optimizations.txt new file mode 100644 index 0000000..39ee1cf --- /dev/null +++ b/tests/hlo_texts/test_hlos/NuX/1648647409115717.module_0337.jit_loss.9581.before_optimizations.txt @@ -0,0 +1,9809 @@ +HloModule jit_loss.9581 + +%primitive_computation_add__1.114 (parameter.115: f32[], parameter.116: f32[]) -> f32[] { + %parameter.115 = f32[] parameter(0) + %parameter.116 = f32[] parameter(1) + ROOT %add.117 = f32[] add(f32[] %parameter.115, f32[] %parameter.116) +} + +%primitive_computation_add__1.249 (parameter.250: f32[], parameter.251: f32[]) -> f32[] { + %parameter.250 = f32[] parameter(0) + %parameter.251 = f32[] parameter(1) + ROOT %add.252 = f32[] add(f32[] %parameter.250, f32[] %parameter.251) +} + +%primitive_computation_add__1.253 (parameter.254: f32[], parameter.255: f32[]) -> f32[] { + %parameter.254 = f32[] parameter(0) + %parameter.255 = f32[] parameter(1) + ROOT %add.256 = f32[] add(f32[] %parameter.254, f32[] %parameter.255) +} + +%primitive_computation_add__1.257 (parameter.258: f32[], parameter.259: f32[]) -> f32[] { + %parameter.258 = f32[] parameter(0) + %parameter.259 = f32[] parameter(1) + ROOT %add.260 = f32[] add(f32[] %parameter.258, f32[] %parameter.259) +} + +%primitive_computation_add__1.261 (parameter.262: f32[], parameter.263: f32[]) -> f32[] { + %parameter.262 = f32[] parameter(0) + %parameter.263 = f32[] parameter(1) + ROOT %add.264 = f32[] add(f32[] %parameter.262, f32[] %parameter.263) +} + +%body_computation.265 (parameter.266: (u32[2,2], f32[2,16], f32[2,16], f32[2,3,3,8,16], f32[2,16], /*index=5*/f32[2,16], f32[2,1,1,16,16], f32[2,8], f32[2,8], s32[], /*index=10*/f32[16,32,32,8], pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,3,3,8,16], /*index=25*/f32[2,16,32,32,8], f32[2,1,1,1,16], f32[2,3,3,8,16], f32[2,16], f32[2,1,1,1,16], /*index=30*/f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], /*index=35*/f32[2,1,1,16,16], f32[2,16,32,32,16], f32[2,1,1,1,16], f32[2,1,1,16,16], f32[2,16], /*index=40*/f32[2,1,1,1,16], f32[2,16,32,32,16], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], /*index=45*/f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,1,1,8], f32[2,16,32,32,8], /*index=50*/f32[2,16,1024,8], f32[2,16,8], f32[2,16,8], f32[2,1,1,1,8], f32[2,16,32,32,8])) -> (u32[2,2], f32[2,16], f32[2,16], f32[2,3,3,8,16], f32[2,16], /*index=5*/f32[2,16], f32[2,1,1,16,16], f32[2,8], f32[2,8], s32[], /*index=10*/f32[16,32,32,8], pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,3,3,8,16], /*index=25*/f32[2,16,32,32,8], f32[2,1,1,1,16], f32[2,3,3,8,16], f32[2,16], f32[2,1,1,1,16], /*index=30*/f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], /*index=35*/f32[2,1,1,16,16], f32[2,16,32,32,16], f32[2,1,1,1,16], f32[2,1,1,16,16], f32[2,16], /*index=40*/f32[2,1,1,1,16], f32[2,16,32,32,16], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], /*index=45*/f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,1,1,8], f32[2,16,32,32,8], /*index=50*/f32[2,16,1024,8], f32[2,16,8], f32[2,16,8], f32[2,1,1,1,8], f32[2,16,32,32,8]) { + %parameter.266 = (u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) parameter(0) + %get-tuple-element.278 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=11 + %get-tuple-element.279 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=12 + %get-tuple-element.280 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=13 + %get-tuple-element.281 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=14 + %get-tuple-element.282 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=15 + %get-tuple-element.283 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=16 + %get-tuple-element.284 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=17 + %get-tuple-element.285 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=18 + %get-tuple-element.286 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=19 + %constant.322 = pred[] constant(false) + %get-tuple-element.267 = u32[2,2]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=0 + %get-tuple-element.276 = s32[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=9 + %constant.323 = s32[] constant(0) + %compare.324 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.323), direction=LT + %constant.325 = s32[] constant(2) + %add.326 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.325) + %select.327 = s32[] select(pred[] %compare.324, s32[] %add.326, s32[] %get-tuple-element.276) + %constant.328 = s32[] constant(0) + %constant.329 = s32[] constant(0) + %compare.330 = pred[] compare(s32[] %constant.328, s32[] %constant.329), direction=LT + %constant.331 = s32[] constant(0) + %constant.332 = s32[] constant(2) + %add.333 = s32[] add(s32[] %constant.331, s32[] %constant.332) + %constant.334 = s32[] constant(0) + %select.335 = s32[] select(pred[] %compare.330, s32[] %add.333, s32[] %constant.334) + %dynamic-slice.336 = u32[1,2]{1,0} dynamic-slice(u32[2,2]{1,0} %get-tuple-element.267, s32[] %select.327, s32[] %select.335), dynamic_slice_sizes={1,2} + %reshape.337 = u32[2]{0} reshape(u32[1,2]{1,0} %dynamic-slice.336) + %get-tuple-element.268 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=1 + %get-tuple-element.269 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=2 + %get-tuple-element.270 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=3 + %get-tuple-element.271 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=4 + %get-tuple-element.272 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=5 + %get-tuple-element.273 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=6 + %get-tuple-element.274 = f32[2,8]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=7 + %get-tuple-element.275 = f32[2,8]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=8 + %constant.1932 = s32[] constant(1) + %add.1933 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1932) + %get-tuple-element.277 = f32[16,32,32,8]{3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=10 + %multiply.506 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %get-tuple-element.277, f32[16,32,32,8]{3,2,1,0} %get-tuple-element.277) + %constant.507 = f32[] constant(2) + %broadcast.508 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[] %constant.507), dimensions={} + %add.509 = f32[16,32,32,8]{3,2,1,0} add(f32[16,32,32,8]{3,2,1,0} %multiply.506, f32[16,32,32,8]{3,2,1,0} %broadcast.508) + %rsqrt.510 = f32[16,32,32,8]{3,2,1,0} rsqrt(f32[16,32,32,8]{3,2,1,0} %add.509) + %multiply.511 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %multiply.506, f32[16,32,32,8]{3,2,1,0} %rsqrt.510) + %add.512 = f32[16,32,32,8]{3,2,1,0} add(f32[16,32,32,8]{3,2,1,0} %get-tuple-element.277, f32[16,32,32,8]{3,2,1,0} %multiply.511) + %constant.513 = f32[] constant(0.5) + %broadcast.514 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[] %constant.513), dimensions={} + %multiply.515 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %add.512, f32[16,32,32,8]{3,2,1,0} %broadcast.514) + %constant.368 = s32[] constant(0) + %compare.369 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.368), direction=LT + %constant.370 = s32[] constant(2) + %add.371 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.370) + %select.372 = s32[] select(pred[] %compare.369, s32[] %add.371, s32[] %get-tuple-element.276) + %constant.373 = s32[] constant(0) + %constant.374 = s32[] constant(0) + %compare.375 = pred[] compare(s32[] %constant.373, s32[] %constant.374), direction=LT + %constant.376 = s32[] constant(0) + %constant.377 = s32[] constant(3) + %add.378 = s32[] add(s32[] %constant.376, s32[] %constant.377) + %constant.379 = s32[] constant(0) + %select.380 = s32[] select(pred[] %compare.375, s32[] %add.378, s32[] %constant.379) + %constant.381 = s32[] constant(0) + %constant.382 = s32[] constant(0) + %compare.383 = pred[] compare(s32[] %constant.381, s32[] %constant.382), direction=LT + %constant.384 = s32[] constant(0) + %constant.385 = s32[] constant(3) + %add.386 = s32[] add(s32[] %constant.384, s32[] %constant.385) + %constant.387 = s32[] constant(0) + %select.388 = s32[] select(pred[] %compare.383, s32[] %add.386, s32[] %constant.387) + %constant.389 = s32[] constant(0) + %constant.390 = s32[] constant(0) + %compare.391 = pred[] compare(s32[] %constant.389, s32[] %constant.390), direction=LT + %constant.392 = s32[] constant(0) + %constant.393 = s32[] constant(8) + %add.394 = s32[] add(s32[] %constant.392, s32[] %constant.393) + %constant.395 = s32[] constant(0) + %select.396 = s32[] select(pred[] %compare.391, s32[] %add.394, s32[] %constant.395) + %constant.397 = s32[] constant(0) + %constant.398 = s32[] constant(0) + %compare.399 = pred[] compare(s32[] %constant.397, s32[] %constant.398), direction=LT + %constant.400 = s32[] constant(0) + %constant.401 = s32[] constant(16) + %add.402 = s32[] add(s32[] %constant.400, s32[] %constant.401) + %constant.403 = s32[] constant(0) + %select.404 = s32[] select(pred[] %compare.399, s32[] %add.402, s32[] %constant.403) + %dynamic-slice.405 = f32[1,3,3,8,16]{4,3,2,1,0} dynamic-slice(f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.270, s32[] %select.372, s32[] %select.380, s32[] %select.388, s32[] %select.396, /*index=5*/s32[] %select.404), dynamic_slice_sizes={1,3,3,8,16} + %reshape.406 = f32[3,3,8,16]{3,2,1,0} reshape(f32[1,3,3,8,16]{4,3,2,1,0} %dynamic-slice.405) + %multiply.516 = f32[3,3,8,16]{3,2,1,0} multiply(f32[3,3,8,16]{3,2,1,0} %reshape.406, f32[3,3,8,16]{3,2,1,0} %reshape.406) + %constant.517 = f32[] constant(0) + %reduce.518 = f32[16]{0} reduce(f32[3,3,8,16]{3,2,1,0} %multiply.516, f32[] %constant.517), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.249 + %rsqrt.519 = f32[16]{0} rsqrt(f32[16]{0} %reduce.518) + %broadcast.520 = f32[1,1,1,16]{3,2,1,0} broadcast(f32[16]{0} %rsqrt.519), dimensions={3} + %reshape.521 = f32[16]{0} reshape(f32[1,1,1,16]{3,2,1,0} %broadcast.520) + %broadcast.522 = f32[3,3,8,16]{3,2,1,0} broadcast(f32[16]{0} %reshape.521), dimensions={3} + %multiply.523 = f32[3,3,8,16]{3,2,1,0} multiply(f32[3,3,8,16]{3,2,1,0} %reshape.406, f32[3,3,8,16]{3,2,1,0} %broadcast.522) + %convolution.524 = f32[16,32,32,16]{3,2,1,0} convolution(f32[16,32,32,8]{3,2,1,0} %multiply.515, f32[3,3,8,16]{3,2,1,0} %multiply.523), window={size=3x3 pad=1_1x1_1}, dim_labels=b01f_01io->b01f + %constant.353 = s32[] constant(0) + %compare.354 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.353), direction=LT + %constant.355 = s32[] constant(2) + %add.356 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.355) + %select.357 = s32[] select(pred[] %compare.354, s32[] %add.356, s32[] %get-tuple-element.276) + %constant.358 = s32[] constant(0) + %constant.359 = s32[] constant(0) + %compare.360 = pred[] compare(s32[] %constant.358, s32[] %constant.359), direction=LT + %constant.361 = s32[] constant(0) + %constant.362 = s32[] constant(16) + %add.363 = s32[] add(s32[] %constant.361, s32[] %constant.362) + %constant.364 = s32[] constant(0) + %select.365 = s32[] select(pred[] %compare.360, s32[] %add.363, s32[] %constant.364) + %dynamic-slice.366 = f32[1,16]{1,0} dynamic-slice(f32[2,16]{1,0} %get-tuple-element.269, s32[] %select.357, s32[] %select.365), dynamic_slice_sizes={1,16} + %reshape.367 = f32[16]{0} reshape(f32[1,16]{1,0} %dynamic-slice.366) + %broadcast.525 = f32[1,1,1,16]{3,2,1,0} broadcast(f32[16]{0} %reshape.367), dimensions={3} + %reshape.526 = f32[16]{0} reshape(f32[1,1,1,16]{3,2,1,0} %broadcast.525) + %broadcast.527 = f32[16,32,32,16]{3,2,1,0} broadcast(f32[16]{0} %reshape.526), dimensions={3} + %multiply.528 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %convolution.524, f32[16,32,32,16]{3,2,1,0} %broadcast.527) + %constant.338 = s32[] constant(0) + %compare.339 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.338), direction=LT + %constant.340 = s32[] constant(2) + %add.341 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.340) + %select.342 = s32[] select(pred[] %compare.339, s32[] %add.341, s32[] %get-tuple-element.276) + %constant.343 = s32[] constant(0) + %constant.344 = s32[] constant(0) + %compare.345 = pred[] compare(s32[] %constant.343, s32[] %constant.344), direction=LT + %constant.346 = s32[] constant(0) + %constant.347 = s32[] constant(16) + %add.348 = s32[] add(s32[] %constant.346, s32[] %constant.347) + %constant.349 = s32[] constant(0) + %select.350 = s32[] select(pred[] %compare.345, s32[] %add.348, s32[] %constant.349) + %dynamic-slice.351 = f32[1,16]{1,0} dynamic-slice(f32[2,16]{1,0} %get-tuple-element.268, s32[] %select.342, s32[] %select.350), dynamic_slice_sizes={1,16} + %reshape.352 = f32[16]{0} reshape(f32[1,16]{1,0} %dynamic-slice.351) + %broadcast.529 = f32[1,1,1,16]{3,2,1,0} broadcast(f32[16]{0} %reshape.352), dimensions={3} + %reshape.530 = f32[16]{0} reshape(f32[1,1,1,16]{3,2,1,0} %broadcast.529) + %broadcast.531 = f32[16,32,32,16]{3,2,1,0} broadcast(f32[16]{0} %reshape.530), dimensions={3} + %add.532 = f32[16,32,32,16]{3,2,1,0} add(f32[16,32,32,16]{3,2,1,0} %multiply.528, f32[16,32,32,16]{3,2,1,0} %broadcast.531) + %multiply.533 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %add.532, f32[16,32,32,16]{3,2,1,0} %add.532) + %constant.534 = f32[] constant(2) + %broadcast.535 = f32[16,32,32,16]{3,2,1,0} broadcast(f32[] %constant.534), dimensions={} + %add.536 = f32[16,32,32,16]{3,2,1,0} add(f32[16,32,32,16]{3,2,1,0} %multiply.533, f32[16,32,32,16]{3,2,1,0} %broadcast.535) + %rsqrt.537 = f32[16,32,32,16]{3,2,1,0} rsqrt(f32[16,32,32,16]{3,2,1,0} %add.536) + %multiply.538 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %multiply.533, f32[16,32,32,16]{3,2,1,0} %rsqrt.537) + %add.539 = f32[16,32,32,16]{3,2,1,0} add(f32[16,32,32,16]{3,2,1,0} %add.532, f32[16,32,32,16]{3,2,1,0} %multiply.538) + %constant.540 = f32[] constant(0.5) + %broadcast.541 = f32[16,32,32,16]{3,2,1,0} broadcast(f32[] %constant.540), dimensions={} + %multiply.542 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %add.539, f32[16,32,32,16]{3,2,1,0} %broadcast.541) + %constant.437 = s32[] constant(0) + %compare.438 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.437), direction=LT + %constant.439 = s32[] constant(2) + %add.440 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.439) + %select.441 = s32[] select(pred[] %compare.438, s32[] %add.440, s32[] %get-tuple-element.276) + %constant.442 = s32[] constant(0) + %constant.443 = s32[] constant(0) + %compare.444 = pred[] compare(s32[] %constant.442, s32[] %constant.443), direction=LT + %constant.445 = s32[] constant(0) + %constant.446 = s32[] constant(1) + %add.447 = s32[] add(s32[] %constant.445, s32[] %constant.446) + %constant.448 = s32[] constant(0) + %select.449 = s32[] select(pred[] %compare.444, s32[] %add.447, s32[] %constant.448) + %constant.450 = s32[] constant(0) + %constant.451 = s32[] constant(0) + %compare.452 = pred[] compare(s32[] %constant.450, s32[] %constant.451), direction=LT + %constant.453 = s32[] constant(0) + %constant.454 = s32[] constant(1) + %add.455 = s32[] add(s32[] %constant.453, s32[] %constant.454) + %constant.456 = s32[] constant(0) + %select.457 = s32[] select(pred[] %compare.452, s32[] %add.455, s32[] %constant.456) + %constant.458 = s32[] constant(0) + %constant.459 = s32[] constant(0) + %compare.460 = pred[] compare(s32[] %constant.458, s32[] %constant.459), direction=LT + %constant.461 = s32[] constant(0) + %constant.462 = s32[] constant(16) + %add.463 = s32[] add(s32[] %constant.461, s32[] %constant.462) + %constant.464 = s32[] constant(0) + %select.465 = s32[] select(pred[] %compare.460, s32[] %add.463, s32[] %constant.464) + %constant.466 = s32[] constant(0) + %constant.467 = s32[] constant(0) + %compare.468 = pred[] compare(s32[] %constant.466, s32[] %constant.467), direction=LT + %constant.469 = s32[] constant(0) + %constant.470 = s32[] constant(16) + %add.471 = s32[] add(s32[] %constant.469, s32[] %constant.470) + %constant.472 = s32[] constant(0) + %select.473 = s32[] select(pred[] %compare.468, s32[] %add.471, s32[] %constant.472) + %dynamic-slice.474 = f32[1,1,1,16,16]{4,3,2,1,0} dynamic-slice(f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.273, s32[] %select.441, s32[] %select.449, s32[] %select.457, s32[] %select.465, /*index=5*/s32[] %select.473), dynamic_slice_sizes={1,1,1,16,16} + %reshape.475 = f32[1,1,16,16]{3,2,1,0} reshape(f32[1,1,1,16,16]{4,3,2,1,0} %dynamic-slice.474) + %multiply.543 = f32[1,1,16,16]{3,2,1,0} multiply(f32[1,1,16,16]{3,2,1,0} %reshape.475, f32[1,1,16,16]{3,2,1,0} %reshape.475) + %constant.544 = f32[] constant(0) + %reduce.545 = f32[16]{0} reduce(f32[1,1,16,16]{3,2,1,0} %multiply.543, f32[] %constant.544), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.253 + %rsqrt.546 = f32[16]{0} rsqrt(f32[16]{0} %reduce.545) + %broadcast.547 = f32[1,1,1,16]{3,2,1,0} broadcast(f32[16]{0} %rsqrt.546), dimensions={3} + %reshape.548 = f32[1,1,16]{2,1,0} reshape(f32[1,1,1,16]{3,2,1,0} %broadcast.547) + %broadcast.549 = f32[1,1,16,16]{3,2,1,0} broadcast(f32[1,1,16]{2,1,0} %reshape.548), dimensions={0,1,3} + %multiply.550 = f32[1,1,16,16]{3,2,1,0} multiply(f32[1,1,16,16]{3,2,1,0} %reshape.475, f32[1,1,16,16]{3,2,1,0} %broadcast.549) + %convolution.551 = f32[16,32,32,16]{3,2,1,0} convolution(f32[16,32,32,16]{3,2,1,0} %multiply.542, f32[1,1,16,16]{3,2,1,0} %multiply.550), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.422 = s32[] constant(0) + %compare.423 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.422), direction=LT + %constant.424 = s32[] constant(2) + %add.425 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.424) + %select.426 = s32[] select(pred[] %compare.423, s32[] %add.425, s32[] %get-tuple-element.276) + %constant.427 = s32[] constant(0) + %constant.428 = s32[] constant(0) + %compare.429 = pred[] compare(s32[] %constant.427, s32[] %constant.428), direction=LT + %constant.430 = s32[] constant(0) + %constant.431 = s32[] constant(16) + %add.432 = s32[] add(s32[] %constant.430, s32[] %constant.431) + %constant.433 = s32[] constant(0) + %select.434 = s32[] select(pred[] %compare.429, s32[] %add.432, s32[] %constant.433) + %dynamic-slice.435 = f32[1,16]{1,0} dynamic-slice(f32[2,16]{1,0} %get-tuple-element.272, s32[] %select.426, s32[] %select.434), dynamic_slice_sizes={1,16} + %reshape.436 = f32[16]{0} reshape(f32[1,16]{1,0} %dynamic-slice.435) + %broadcast.552 = f32[1,1,1,16]{3,2,1,0} broadcast(f32[16]{0} %reshape.436), dimensions={3} + %reshape.553 = f32[16]{0} reshape(f32[1,1,1,16]{3,2,1,0} %broadcast.552) + %broadcast.554 = f32[16,32,32,16]{3,2,1,0} broadcast(f32[16]{0} %reshape.553), dimensions={3} + %multiply.555 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %convolution.551, f32[16,32,32,16]{3,2,1,0} %broadcast.554) + %constant.407 = s32[] constant(0) + %compare.408 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.407), direction=LT + %constant.409 = s32[] constant(2) + %add.410 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.409) + %select.411 = s32[] select(pred[] %compare.408, s32[] %add.410, s32[] %get-tuple-element.276) + %constant.412 = s32[] constant(0) + %constant.413 = s32[] constant(0) + %compare.414 = pred[] compare(s32[] %constant.412, s32[] %constant.413), direction=LT + %constant.415 = s32[] constant(0) + %constant.416 = s32[] constant(16) + %add.417 = s32[] add(s32[] %constant.415, s32[] %constant.416) + %constant.418 = s32[] constant(0) + %select.419 = s32[] select(pred[] %compare.414, s32[] %add.417, s32[] %constant.418) + %dynamic-slice.420 = f32[1,16]{1,0} dynamic-slice(f32[2,16]{1,0} %get-tuple-element.271, s32[] %select.411, s32[] %select.419), dynamic_slice_sizes={1,16} + %reshape.421 = f32[16]{0} reshape(f32[1,16]{1,0} %dynamic-slice.420) + %broadcast.556 = f32[1,1,1,16]{3,2,1,0} broadcast(f32[16]{0} %reshape.421), dimensions={3} + %reshape.557 = f32[16]{0} reshape(f32[1,1,1,16]{3,2,1,0} %broadcast.556) + %broadcast.558 = f32[16,32,32,16]{3,2,1,0} broadcast(f32[16]{0} %reshape.557), dimensions={3} + %add.559 = f32[16,32,32,16]{3,2,1,0} add(f32[16,32,32,16]{3,2,1,0} %multiply.555, f32[16,32,32,16]{3,2,1,0} %broadcast.558) + %slice.560 = f32[16,32,32,8]{3,2,1,0} slice(f32[16,32,32,16]{3,2,1,0} %add.559), slice={[0:16], [0:32], [0:32], [0:8]} + %slice.561 = f32[16,32,32,8]{3,2,1,0} slice(f32[16,32,32,16]{3,2,1,0} %add.559), slice={[0:16], [0:32], [0:32], [8:16]} + %multiply.562 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %slice.561, f32[16,32,32,8]{3,2,1,0} %slice.561) + %constant.563 = f32[] constant(2) + %broadcast.564 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[] %constant.563), dimensions={} + %add.565 = f32[16,32,32,8]{3,2,1,0} add(f32[16,32,32,8]{3,2,1,0} %multiply.562, f32[16,32,32,8]{3,2,1,0} %broadcast.564) + %rsqrt.566 = f32[16,32,32,8]{3,2,1,0} rsqrt(f32[16,32,32,8]{3,2,1,0} %add.565) + %multiply.567 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %slice.561, f32[16,32,32,8]{3,2,1,0} %rsqrt.566) + %constant.568 = f32[] constant(1) + %broadcast.569 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[] %constant.568), dimensions={} + %add.570 = f32[16,32,32,8]{3,2,1,0} add(f32[16,32,32,8]{3,2,1,0} %multiply.567, f32[16,32,32,8]{3,2,1,0} %broadcast.569) + %constant.571 = f32[] constant(0.5) + %broadcast.572 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[] %constant.571), dimensions={} + %multiply.573 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %add.570, f32[16,32,32,8]{3,2,1,0} %broadcast.572) + %multiply.574 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %slice.560, f32[16,32,32,8]{3,2,1,0} %multiply.573) + %add.575 = f32[16,32,32,8]{3,2,1,0} add(f32[16,32,32,8]{3,2,1,0} %get-tuple-element.277, f32[16,32,32,8]{3,2,1,0} %multiply.574) + %reshape.576 = f32[16,1024,8]{2,1,0} reshape(f32[16,32,32,8]{3,2,1,0} %add.575) + %constant.577 = f32[] constant(0) + %reduce.578 = f32[16,8]{1,0} reduce(f32[16,1024,8]{2,1,0} %reshape.576, f32[] %constant.577), dimensions={1}, to_apply=%primitive_computation_add__1.257 + %constant.579 = f32[] constant(1024) + %broadcast.580 = f32[16,8]{1,0} broadcast(f32[] %constant.579), dimensions={} + %divide.581 = f32[16,8]{1,0} divide(f32[16,8]{1,0} %reduce.578, f32[16,8]{1,0} %broadcast.580) + %broadcast.582 = f32[16,1,1,8]{3,2,1,0} broadcast(f32[16,8]{1,0} %divide.581), dimensions={0,3} + %reshape.583 = f32[16,8]{1,0} reshape(f32[16,1,1,8]{3,2,1,0} %broadcast.582) + %broadcast.584 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[16,8]{1,0} %reshape.583), dimensions={0,3} + %subtract.585 = f32[16,32,32,8]{3,2,1,0} subtract(f32[16,32,32,8]{3,2,1,0} %add.575, f32[16,32,32,8]{3,2,1,0} %broadcast.584) + %multiply.586 = f32[16,1024,8]{2,1,0} multiply(f32[16,1024,8]{2,1,0} %reshape.576, f32[16,1024,8]{2,1,0} %reshape.576) + %constant.587 = f32[] constant(0) + %reduce.588 = f32[16,8]{1,0} reduce(f32[16,1024,8]{2,1,0} %multiply.586, f32[] %constant.587), dimensions={1}, to_apply=%primitive_computation_add__1.261 + %constant.589 = f32[] constant(1024) + %broadcast.590 = f32[16,8]{1,0} broadcast(f32[] %constant.589), dimensions={} + %divide.591 = f32[16,8]{1,0} divide(f32[16,8]{1,0} %reduce.588, f32[16,8]{1,0} %broadcast.590) + %multiply.592 = f32[16,8]{1,0} multiply(f32[16,8]{1,0} %divide.581, f32[16,8]{1,0} %divide.581) + %subtract.593 = f32[16,8]{1,0} subtract(f32[16,8]{1,0} %divide.591, f32[16,8]{1,0} %multiply.592) + %constant.594 = f32[] constant(1e-06) + %broadcast.595 = f32[16,8]{1,0} broadcast(f32[] %constant.594), dimensions={} + %add.596 = f32[16,8]{1,0} add(f32[16,8]{1,0} %subtract.593, f32[16,8]{1,0} %broadcast.595) + %rsqrt.597 = f32[16,8]{1,0} rsqrt(f32[16,8]{1,0} %add.596) + %broadcast.598 = f32[16,1,1,8]{3,2,1,0} broadcast(f32[16,8]{1,0} %rsqrt.597), dimensions={0,3} + %reshape.599 = f32[16,8]{1,0} reshape(f32[16,1,1,8]{3,2,1,0} %broadcast.598) + %broadcast.600 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[16,8]{1,0} %reshape.599), dimensions={0,3} + %multiply.601 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %subtract.585, f32[16,32,32,8]{3,2,1,0} %broadcast.600) + %constant.491 = s32[] constant(0) + %compare.492 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.491), direction=LT + %constant.493 = s32[] constant(2) + %add.494 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.493) + %select.495 = s32[] select(pred[] %compare.492, s32[] %add.494, s32[] %get-tuple-element.276) + %constant.496 = s32[] constant(0) + %constant.497 = s32[] constant(0) + %compare.498 = pred[] compare(s32[] %constant.496, s32[] %constant.497), direction=LT + %constant.499 = s32[] constant(0) + %constant.500 = s32[] constant(8) + %add.501 = s32[] add(s32[] %constant.499, s32[] %constant.500) + %constant.502 = s32[] constant(0) + %select.503 = s32[] select(pred[] %compare.498, s32[] %add.501, s32[] %constant.502) + %dynamic-slice.504 = f32[1,8]{1,0} dynamic-slice(f32[2,8]{1,0} %get-tuple-element.275, s32[] %select.495, s32[] %select.503), dynamic_slice_sizes={1,8} + %reshape.505 = f32[8]{0} reshape(f32[1,8]{1,0} %dynamic-slice.504) + %broadcast.602 = f32[1,1,1,8]{3,2,1,0} broadcast(f32[8]{0} %reshape.505), dimensions={3} + %reshape.603 = f32[8]{0} reshape(f32[1,1,1,8]{3,2,1,0} %broadcast.602) + %broadcast.604 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[8]{0} %reshape.603), dimensions={3} + %multiply.605 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %multiply.601, f32[16,32,32,8]{3,2,1,0} %broadcast.604) + %constant.476 = s32[] constant(0) + %compare.477 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.476), direction=LT + %constant.478 = s32[] constant(2) + %add.479 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.478) + %select.480 = s32[] select(pred[] %compare.477, s32[] %add.479, s32[] %get-tuple-element.276) + %constant.481 = s32[] constant(0) + %constant.482 = s32[] constant(0) + %compare.483 = pred[] compare(s32[] %constant.481, s32[] %constant.482), direction=LT + %constant.484 = s32[] constant(0) + %constant.485 = s32[] constant(8) + %add.486 = s32[] add(s32[] %constant.484, s32[] %constant.485) + %constant.487 = s32[] constant(0) + %select.488 = s32[] select(pred[] %compare.483, s32[] %add.486, s32[] %constant.487) + %dynamic-slice.489 = f32[1,8]{1,0} dynamic-slice(f32[2,8]{1,0} %get-tuple-element.274, s32[] %select.480, s32[] %select.488), dynamic_slice_sizes={1,8} + %reshape.490 = f32[8]{0} reshape(f32[1,8]{1,0} %dynamic-slice.489) + %broadcast.606 = f32[1,1,1,8]{3,2,1,0} broadcast(f32[8]{0} %reshape.490), dimensions={3} + %reshape.607 = f32[8]{0} reshape(f32[1,1,1,8]{3,2,1,0} %broadcast.606) + %broadcast.608 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[8]{0} %reshape.607), dimensions={3} + %add.609 = f32[16,32,32,8]{3,2,1,0} add(f32[16,32,32,8]{3,2,1,0} %multiply.605, f32[16,32,32,8]{3,2,1,0} %broadcast.608) + %constant.1934 = pred[] constant(false) + %constant.1935 = pred[] constant(false) + %constant.1936 = pred[] constant(false) + %constant.1937 = pred[] constant(false) + %constant.1938 = pred[] constant(false) + %constant.1939 = pred[] constant(false) + %constant.1940 = pred[] constant(false) + %constant.1941 = pred[] constant(false) + %constant.1942 = pred[] constant(false) + %get-tuple-element.287 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=20 + %constant.610 = f32[] constant(2) + %broadcast.611 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[] %constant.610), dimensions={} + %multiply.612 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %broadcast.611, f32[16,32,32,8]{3,2,1,0} %get-tuple-element.277) + %broadcast.655 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %multiply.612), dimensions={1,2,3,4} + %constant.656 = s32[] constant(0) + %compare.657 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.656), direction=LT + %constant.658 = s32[] constant(2) + %add.659 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.658) + %select.660 = s32[] select(pred[] %compare.657, s32[] %add.659, s32[] %get-tuple-element.276) + %constant.661 = s32[] constant(0) + %constant.662 = s32[] constant(0) + %compare.663 = pred[] compare(s32[] %constant.661, s32[] %constant.662), direction=LT + %constant.664 = s32[] constant(0) + %constant.665 = s32[] constant(16) + %add.666 = s32[] add(s32[] %constant.664, s32[] %constant.665) + %constant.667 = s32[] constant(0) + %select.668 = s32[] select(pred[] %compare.663, s32[] %add.666, s32[] %constant.667) + %constant.669 = s32[] constant(0) + %constant.670 = s32[] constant(0) + %compare.671 = pred[] compare(s32[] %constant.669, s32[] %constant.670), direction=LT + %constant.672 = s32[] constant(0) + %constant.673 = s32[] constant(32) + %add.674 = s32[] add(s32[] %constant.672, s32[] %constant.673) + %constant.675 = s32[] constant(0) + %select.676 = s32[] select(pred[] %compare.671, s32[] %add.674, s32[] %constant.675) + %constant.677 = s32[] constant(0) + %constant.678 = s32[] constant(0) + %compare.679 = pred[] compare(s32[] %constant.677, s32[] %constant.678), direction=LT + %constant.680 = s32[] constant(0) + %constant.681 = s32[] constant(32) + %add.682 = s32[] add(s32[] %constant.680, s32[] %constant.681) + %constant.683 = s32[] constant(0) + %select.684 = s32[] select(pred[] %compare.679, s32[] %add.682, s32[] %constant.683) + %constant.685 = s32[] constant(0) + %constant.686 = s32[] constant(0) + %compare.687 = pred[] compare(s32[] %constant.685, s32[] %constant.686), direction=LT + %constant.688 = s32[] constant(0) + %constant.689 = s32[] constant(8) + %add.690 = s32[] add(s32[] %constant.688, s32[] %constant.689) + %constant.691 = s32[] constant(0) + %select.692 = s32[] select(pred[] %compare.687, s32[] %add.690, s32[] %constant.691) + %dynamic-update-slice.693 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.287, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.655, s32[] %select.660, s32[] %select.668, s32[] %select.676, /*index=5*/s32[] %select.684, s32[] %select.692) + %get-tuple-element.288 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=21 + %broadcast.694 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %rsqrt.510), dimensions={1,2,3,4} + %constant.695 = s32[] constant(0) + %compare.696 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.695), direction=LT + %constant.697 = s32[] constant(2) + %add.698 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.697) + %select.699 = s32[] select(pred[] %compare.696, s32[] %add.698, s32[] %get-tuple-element.276) + %constant.700 = s32[] constant(0) + %constant.701 = s32[] constant(0) + %compare.702 = pred[] compare(s32[] %constant.700, s32[] %constant.701), direction=LT + %constant.703 = s32[] constant(0) + %constant.704 = s32[] constant(16) + %add.705 = s32[] add(s32[] %constant.703, s32[] %constant.704) + %constant.706 = s32[] constant(0) + %select.707 = s32[] select(pred[] %compare.702, s32[] %add.705, s32[] %constant.706) + %constant.708 = s32[] constant(0) + %constant.709 = s32[] constant(0) + %compare.710 = pred[] compare(s32[] %constant.708, s32[] %constant.709), direction=LT + %constant.711 = s32[] constant(0) + %constant.712 = s32[] constant(32) + %add.713 = s32[] add(s32[] %constant.711, s32[] %constant.712) + %constant.714 = s32[] constant(0) + %select.715 = s32[] select(pred[] %compare.710, s32[] %add.713, s32[] %constant.714) + %constant.716 = s32[] constant(0) + %constant.717 = s32[] constant(0) + %compare.718 = pred[] compare(s32[] %constant.716, s32[] %constant.717), direction=LT + %constant.719 = s32[] constant(0) + %constant.720 = s32[] constant(32) + %add.721 = s32[] add(s32[] %constant.719, s32[] %constant.720) + %constant.722 = s32[] constant(0) + %select.723 = s32[] select(pred[] %compare.718, s32[] %add.721, s32[] %constant.722) + %constant.724 = s32[] constant(0) + %constant.725 = s32[] constant(0) + %compare.726 = pred[] compare(s32[] %constant.724, s32[] %constant.725), direction=LT + %constant.727 = s32[] constant(0) + %constant.728 = s32[] constant(8) + %add.729 = s32[] add(s32[] %constant.727, s32[] %constant.728) + %constant.730 = s32[] constant(0) + %select.731 = s32[] select(pred[] %compare.726, s32[] %add.729, s32[] %constant.730) + %dynamic-update-slice.732 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.288, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.694, s32[] %select.699, s32[] %select.707, s32[] %select.715, /*index=5*/s32[] %select.723, s32[] %select.731) + %get-tuple-element.289 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=22 + %broadcast.733 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %multiply.506), dimensions={1,2,3,4} + %constant.734 = s32[] constant(0) + %compare.735 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.734), direction=LT + %constant.736 = s32[] constant(2) + %add.737 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.736) + %select.738 = s32[] select(pred[] %compare.735, s32[] %add.737, s32[] %get-tuple-element.276) + %constant.739 = s32[] constant(0) + %constant.740 = s32[] constant(0) + %compare.741 = pred[] compare(s32[] %constant.739, s32[] %constant.740), direction=LT + %constant.742 = s32[] constant(0) + %constant.743 = s32[] constant(16) + %add.744 = s32[] add(s32[] %constant.742, s32[] %constant.743) + %constant.745 = s32[] constant(0) + %select.746 = s32[] select(pred[] %compare.741, s32[] %add.744, s32[] %constant.745) + %constant.747 = s32[] constant(0) + %constant.748 = s32[] constant(0) + %compare.749 = pred[] compare(s32[] %constant.747, s32[] %constant.748), direction=LT + %constant.750 = s32[] constant(0) + %constant.751 = s32[] constant(32) + %add.752 = s32[] add(s32[] %constant.750, s32[] %constant.751) + %constant.753 = s32[] constant(0) + %select.754 = s32[] select(pred[] %compare.749, s32[] %add.752, s32[] %constant.753) + %constant.755 = s32[] constant(0) + %constant.756 = s32[] constant(0) + %compare.757 = pred[] compare(s32[] %constant.755, s32[] %constant.756), direction=LT + %constant.758 = s32[] constant(0) + %constant.759 = s32[] constant(32) + %add.760 = s32[] add(s32[] %constant.758, s32[] %constant.759) + %constant.761 = s32[] constant(0) + %select.762 = s32[] select(pred[] %compare.757, s32[] %add.760, s32[] %constant.761) + %constant.763 = s32[] constant(0) + %constant.764 = s32[] constant(0) + %compare.765 = pred[] compare(s32[] %constant.763, s32[] %constant.764), direction=LT + %constant.766 = s32[] constant(0) + %constant.767 = s32[] constant(8) + %add.768 = s32[] add(s32[] %constant.766, s32[] %constant.767) + %constant.769 = s32[] constant(0) + %select.770 = s32[] select(pred[] %compare.765, s32[] %add.768, s32[] %constant.769) + %dynamic-update-slice.771 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.289, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.733, s32[] %select.738, s32[] %select.746, s32[] %select.754, /*index=5*/s32[] %select.762, s32[] %select.770) + %get-tuple-element.290 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=23 + %constant.614 = f32[] constant(-0.5) + %broadcast.615 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[] %constant.614), dimensions={} + %divide.613 = f32[16,32,32,8]{3,2,1,0} divide(f32[16,32,32,8]{3,2,1,0} %rsqrt.510, f32[16,32,32,8]{3,2,1,0} %add.509) + %multiply.616 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %broadcast.615, f32[16,32,32,8]{3,2,1,0} %divide.613) + %broadcast.772 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %multiply.616), dimensions={1,2,3,4} + %constant.773 = s32[] constant(0) + %compare.774 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.773), direction=LT + %constant.775 = s32[] constant(2) + %add.776 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.775) + %select.777 = s32[] select(pred[] %compare.774, s32[] %add.776, s32[] %get-tuple-element.276) + %constant.778 = s32[] constant(0) + %constant.779 = s32[] constant(0) + %compare.780 = pred[] compare(s32[] %constant.778, s32[] %constant.779), direction=LT + %constant.781 = s32[] constant(0) + %constant.782 = s32[] constant(16) + %add.783 = s32[] add(s32[] %constant.781, s32[] %constant.782) + %constant.784 = s32[] constant(0) + %select.785 = s32[] select(pred[] %compare.780, s32[] %add.783, s32[] %constant.784) + %constant.786 = s32[] constant(0) + %constant.787 = s32[] constant(0) + %compare.788 = pred[] compare(s32[] %constant.786, s32[] %constant.787), direction=LT + %constant.789 = s32[] constant(0) + %constant.790 = s32[] constant(32) + %add.791 = s32[] add(s32[] %constant.789, s32[] %constant.790) + %constant.792 = s32[] constant(0) + %select.793 = s32[] select(pred[] %compare.788, s32[] %add.791, s32[] %constant.792) + %constant.794 = s32[] constant(0) + %constant.795 = s32[] constant(0) + %compare.796 = pred[] compare(s32[] %constant.794, s32[] %constant.795), direction=LT + %constant.797 = s32[] constant(0) + %constant.798 = s32[] constant(32) + %add.799 = s32[] add(s32[] %constant.797, s32[] %constant.798) + %constant.800 = s32[] constant(0) + %select.801 = s32[] select(pred[] %compare.796, s32[] %add.799, s32[] %constant.800) + %constant.802 = s32[] constant(0) + %constant.803 = s32[] constant(0) + %compare.804 = pred[] compare(s32[] %constant.802, s32[] %constant.803), direction=LT + %constant.805 = s32[] constant(0) + %constant.806 = s32[] constant(8) + %add.807 = s32[] add(s32[] %constant.805, s32[] %constant.806) + %constant.808 = s32[] constant(0) + %select.809 = s32[] select(pred[] %compare.804, s32[] %add.807, s32[] %constant.808) + %dynamic-update-slice.810 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.290, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.772, s32[] %select.777, s32[] %select.785, s32[] %select.793, /*index=5*/s32[] %select.801, s32[] %select.809) + %get-tuple-element.291 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=24 + %broadcast.811 = f32[1,3,3,8,16]{4,3,2,1,0} broadcast(f32[3,3,8,16]{3,2,1,0} %multiply.523), dimensions={1,2,3,4} + %constant.812 = s32[] constant(0) + %compare.813 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.812), direction=LT + %constant.814 = s32[] constant(2) + %add.815 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.814) + %select.816 = s32[] select(pred[] %compare.813, s32[] %add.815, s32[] %get-tuple-element.276) + %constant.817 = s32[] constant(0) + %constant.818 = s32[] constant(0) + %compare.819 = pred[] compare(s32[] %constant.817, s32[] %constant.818), direction=LT + %constant.820 = s32[] constant(0) + %constant.821 = s32[] constant(3) + %add.822 = s32[] add(s32[] %constant.820, s32[] %constant.821) + %constant.823 = s32[] constant(0) + %select.824 = s32[] select(pred[] %compare.819, s32[] %add.822, s32[] %constant.823) + %constant.825 = s32[] constant(0) + %constant.826 = s32[] constant(0) + %compare.827 = pred[] compare(s32[] %constant.825, s32[] %constant.826), direction=LT + %constant.828 = s32[] constant(0) + %constant.829 = s32[] constant(3) + %add.830 = s32[] add(s32[] %constant.828, s32[] %constant.829) + %constant.831 = s32[] constant(0) + %select.832 = s32[] select(pred[] %compare.827, s32[] %add.830, s32[] %constant.831) + %constant.833 = s32[] constant(0) + %constant.834 = s32[] constant(0) + %compare.835 = pred[] compare(s32[] %constant.833, s32[] %constant.834), direction=LT + %constant.836 = s32[] constant(0) + %constant.837 = s32[] constant(8) + %add.838 = s32[] add(s32[] %constant.836, s32[] %constant.837) + %constant.839 = s32[] constant(0) + %select.840 = s32[] select(pred[] %compare.835, s32[] %add.838, s32[] %constant.839) + %constant.841 = s32[] constant(0) + %constant.842 = s32[] constant(0) + %compare.843 = pred[] compare(s32[] %constant.841, s32[] %constant.842), direction=LT + %constant.844 = s32[] constant(0) + %constant.845 = s32[] constant(16) + %add.846 = s32[] add(s32[] %constant.844, s32[] %constant.845) + %constant.847 = s32[] constant(0) + %select.848 = s32[] select(pred[] %compare.843, s32[] %add.846, s32[] %constant.847) + %dynamic-update-slice.849 = f32[2,3,3,8,16]{4,3,2,1,0} dynamic-update-slice(f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.291, f32[1,3,3,8,16]{4,3,2,1,0} %broadcast.811, s32[] %select.816, s32[] %select.824, s32[] %select.832, /*index=5*/s32[] %select.840, s32[] %select.848) + %get-tuple-element.292 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=25 + %broadcast.850 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %multiply.515), dimensions={1,2,3,4} + %constant.851 = s32[] constant(0) + %compare.852 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.851), direction=LT + %constant.853 = s32[] constant(2) + %add.854 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.853) + %select.855 = s32[] select(pred[] %compare.852, s32[] %add.854, s32[] %get-tuple-element.276) + %constant.856 = s32[] constant(0) + %constant.857 = s32[] constant(0) + %compare.858 = pred[] compare(s32[] %constant.856, s32[] %constant.857), direction=LT + %constant.859 = s32[] constant(0) + %constant.860 = s32[] constant(16) + %add.861 = s32[] add(s32[] %constant.859, s32[] %constant.860) + %constant.862 = s32[] constant(0) + %select.863 = s32[] select(pred[] %compare.858, s32[] %add.861, s32[] %constant.862) + %constant.864 = s32[] constant(0) + %constant.865 = s32[] constant(0) + %compare.866 = pred[] compare(s32[] %constant.864, s32[] %constant.865), direction=LT + %constant.867 = s32[] constant(0) + %constant.868 = s32[] constant(32) + %add.869 = s32[] add(s32[] %constant.867, s32[] %constant.868) + %constant.870 = s32[] constant(0) + %select.871 = s32[] select(pred[] %compare.866, s32[] %add.869, s32[] %constant.870) + %constant.872 = s32[] constant(0) + %constant.873 = s32[] constant(0) + %compare.874 = pred[] compare(s32[] %constant.872, s32[] %constant.873), direction=LT + %constant.875 = s32[] constant(0) + %constant.876 = s32[] constant(32) + %add.877 = s32[] add(s32[] %constant.875, s32[] %constant.876) + %constant.878 = s32[] constant(0) + %select.879 = s32[] select(pred[] %compare.874, s32[] %add.877, s32[] %constant.878) + %constant.880 = s32[] constant(0) + %constant.881 = s32[] constant(0) + %compare.882 = pred[] compare(s32[] %constant.880, s32[] %constant.881), direction=LT + %constant.883 = s32[] constant(0) + %constant.884 = s32[] constant(8) + %add.885 = s32[] add(s32[] %constant.883, s32[] %constant.884) + %constant.886 = s32[] constant(0) + %select.887 = s32[] select(pred[] %compare.882, s32[] %add.885, s32[] %constant.886) + %dynamic-update-slice.888 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.292, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.850, s32[] %select.855, s32[] %select.863, s32[] %select.871, /*index=5*/s32[] %select.879, s32[] %select.887) + %get-tuple-element.293 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=26 + %broadcast.889 = f32[1,1,1,1,16]{4,3,2,1,0} broadcast(f32[1,1,1,16]{3,2,1,0} %broadcast.520), dimensions={1,2,3,4} + %constant.890 = s32[] constant(0) + %compare.891 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.890), direction=LT + %constant.892 = s32[] constant(2) + %add.893 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.892) + %select.894 = s32[] select(pred[] %compare.891, s32[] %add.893, s32[] %get-tuple-element.276) + %constant.895 = s32[] constant(0) + %constant.896 = s32[] constant(0) + %compare.897 = pred[] compare(s32[] %constant.895, s32[] %constant.896), direction=LT + %constant.898 = s32[] constant(0) + %constant.899 = s32[] constant(1) + %add.900 = s32[] add(s32[] %constant.898, s32[] %constant.899) + %constant.901 = s32[] constant(0) + %select.902 = s32[] select(pred[] %compare.897, s32[] %add.900, s32[] %constant.901) + %constant.903 = s32[] constant(0) + %constant.904 = s32[] constant(0) + %compare.905 = pred[] compare(s32[] %constant.903, s32[] %constant.904), direction=LT + %constant.906 = s32[] constant(0) + %constant.907 = s32[] constant(1) + %add.908 = s32[] add(s32[] %constant.906, s32[] %constant.907) + %constant.909 = s32[] constant(0) + %select.910 = s32[] select(pred[] %compare.905, s32[] %add.908, s32[] %constant.909) + %constant.911 = s32[] constant(0) + %constant.912 = s32[] constant(0) + %compare.913 = pred[] compare(s32[] %constant.911, s32[] %constant.912), direction=LT + %constant.914 = s32[] constant(0) + %constant.915 = s32[] constant(1) + %add.916 = s32[] add(s32[] %constant.914, s32[] %constant.915) + %constant.917 = s32[] constant(0) + %select.918 = s32[] select(pred[] %compare.913, s32[] %add.916, s32[] %constant.917) + %constant.919 = s32[] constant(0) + %constant.920 = s32[] constant(0) + %compare.921 = pred[] compare(s32[] %constant.919, s32[] %constant.920), direction=LT + %constant.922 = s32[] constant(0) + %constant.923 = s32[] constant(16) + %add.924 = s32[] add(s32[] %constant.922, s32[] %constant.923) + %constant.925 = s32[] constant(0) + %select.926 = s32[] select(pred[] %compare.921, s32[] %add.924, s32[] %constant.925) + %dynamic-update-slice.927 = f32[2,1,1,1,16]{4,3,2,1,0} dynamic-update-slice(f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.293, f32[1,1,1,1,16]{4,3,2,1,0} %broadcast.889, s32[] %select.894, s32[] %select.902, s32[] %select.910, /*index=5*/s32[] %select.918, s32[] %select.926) + %get-tuple-element.294 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=27 + %constant.617 = f32[] constant(2) + %broadcast.618 = f32[3,3,8,16]{3,2,1,0} broadcast(f32[] %constant.617), dimensions={} + %multiply.619 = f32[3,3,8,16]{3,2,1,0} multiply(f32[3,3,8,16]{3,2,1,0} %broadcast.618, f32[3,3,8,16]{3,2,1,0} %reshape.406) + %broadcast.928 = f32[1,3,3,8,16]{4,3,2,1,0} broadcast(f32[3,3,8,16]{3,2,1,0} %multiply.619), dimensions={1,2,3,4} + %constant.929 = s32[] constant(0) + %compare.930 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.929), direction=LT + %constant.931 = s32[] constant(2) + %add.932 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.931) + %select.933 = s32[] select(pred[] %compare.930, s32[] %add.932, s32[] %get-tuple-element.276) + %constant.934 = s32[] constant(0) + %constant.935 = s32[] constant(0) + %compare.936 = pred[] compare(s32[] %constant.934, s32[] %constant.935), direction=LT + %constant.937 = s32[] constant(0) + %constant.938 = s32[] constant(3) + %add.939 = s32[] add(s32[] %constant.937, s32[] %constant.938) + %constant.940 = s32[] constant(0) + %select.941 = s32[] select(pred[] %compare.936, s32[] %add.939, s32[] %constant.940) + %constant.942 = s32[] constant(0) + %constant.943 = s32[] constant(0) + %compare.944 = pred[] compare(s32[] %constant.942, s32[] %constant.943), direction=LT + %constant.945 = s32[] constant(0) + %constant.946 = s32[] constant(3) + %add.947 = s32[] add(s32[] %constant.945, s32[] %constant.946) + %constant.948 = s32[] constant(0) + %select.949 = s32[] select(pred[] %compare.944, s32[] %add.947, s32[] %constant.948) + %constant.950 = s32[] constant(0) + %constant.951 = s32[] constant(0) + %compare.952 = pred[] compare(s32[] %constant.950, s32[] %constant.951), direction=LT + %constant.953 = s32[] constant(0) + %constant.954 = s32[] constant(8) + %add.955 = s32[] add(s32[] %constant.953, s32[] %constant.954) + %constant.956 = s32[] constant(0) + %select.957 = s32[] select(pred[] %compare.952, s32[] %add.955, s32[] %constant.956) + %constant.958 = s32[] constant(0) + %constant.959 = s32[] constant(0) + %compare.960 = pred[] compare(s32[] %constant.958, s32[] %constant.959), direction=LT + %constant.961 = s32[] constant(0) + %constant.962 = s32[] constant(16) + %add.963 = s32[] add(s32[] %constant.961, s32[] %constant.962) + %constant.964 = s32[] constant(0) + %select.965 = s32[] select(pred[] %compare.960, s32[] %add.963, s32[] %constant.964) + %dynamic-update-slice.966 = f32[2,3,3,8,16]{4,3,2,1,0} dynamic-update-slice(f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.294, f32[1,3,3,8,16]{4,3,2,1,0} %broadcast.928, s32[] %select.933, s32[] %select.941, s32[] %select.949, /*index=5*/s32[] %select.957, s32[] %select.965) + %get-tuple-element.295 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=28 + %constant.621 = f32[] constant(-0.5) + %broadcast.622 = f32[16]{0} broadcast(f32[] %constant.621), dimensions={} + %divide.620 = f32[16]{0} divide(f32[16]{0} %rsqrt.519, f32[16]{0} %reduce.518) + %multiply.623 = f32[16]{0} multiply(f32[16]{0} %broadcast.622, f32[16]{0} %divide.620) + %broadcast.967 = f32[1,16]{1,0} broadcast(f32[16]{0} %multiply.623), dimensions={1} + %constant.968 = s32[] constant(0) + %compare.969 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.968), direction=LT + %constant.970 = s32[] constant(2) + %add.971 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.970) + %select.972 = s32[] select(pred[] %compare.969, s32[] %add.971, s32[] %get-tuple-element.276) + %constant.973 = s32[] constant(0) + %constant.974 = s32[] constant(0) + %compare.975 = pred[] compare(s32[] %constant.973, s32[] %constant.974), direction=LT + %constant.976 = s32[] constant(0) + %constant.977 = s32[] constant(16) + %add.978 = s32[] add(s32[] %constant.976, s32[] %constant.977) + %constant.979 = s32[] constant(0) + %select.980 = s32[] select(pred[] %compare.975, s32[] %add.978, s32[] %constant.979) + %dynamic-update-slice.981 = f32[2,16]{1,0} dynamic-update-slice(f32[2,16]{1,0} %get-tuple-element.295, f32[1,16]{1,0} %broadcast.967, s32[] %select.972, s32[] %select.980) + %get-tuple-element.296 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=29 + %broadcast.982 = f32[1,1,1,1,16]{4,3,2,1,0} broadcast(f32[1,1,1,16]{3,2,1,0} %broadcast.525), dimensions={1,2,3,4} + %constant.983 = s32[] constant(0) + %compare.984 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.983), direction=LT + %constant.985 = s32[] constant(2) + %add.986 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.985) + %select.987 = s32[] select(pred[] %compare.984, s32[] %add.986, s32[] %get-tuple-element.276) + %constant.988 = s32[] constant(0) + %constant.989 = s32[] constant(0) + %compare.990 = pred[] compare(s32[] %constant.988, s32[] %constant.989), direction=LT + %constant.991 = s32[] constant(0) + %constant.992 = s32[] constant(1) + %add.993 = s32[] add(s32[] %constant.991, s32[] %constant.992) + %constant.994 = s32[] constant(0) + %select.995 = s32[] select(pred[] %compare.990, s32[] %add.993, s32[] %constant.994) + %constant.996 = s32[] constant(0) + %constant.997 = s32[] constant(0) + %compare.998 = pred[] compare(s32[] %constant.996, s32[] %constant.997), direction=LT + %constant.999 = s32[] constant(0) + %constant.1000 = s32[] constant(1) + %add.1001 = s32[] add(s32[] %constant.999, s32[] %constant.1000) + %constant.1002 = s32[] constant(0) + %select.1003 = s32[] select(pred[] %compare.998, s32[] %add.1001, s32[] %constant.1002) + %constant.1004 = s32[] constant(0) + %constant.1005 = s32[] constant(0) + %compare.1006 = pred[] compare(s32[] %constant.1004, s32[] %constant.1005), direction=LT + %constant.1007 = s32[] constant(0) + %constant.1008 = s32[] constant(1) + %add.1009 = s32[] add(s32[] %constant.1007, s32[] %constant.1008) + %constant.1010 = s32[] constant(0) + %select.1011 = s32[] select(pred[] %compare.1006, s32[] %add.1009, s32[] %constant.1010) + %constant.1012 = s32[] constant(0) + %constant.1013 = s32[] constant(0) + %compare.1014 = pred[] compare(s32[] %constant.1012, s32[] %constant.1013), direction=LT + %constant.1015 = s32[] constant(0) + %constant.1016 = s32[] constant(16) + %add.1017 = s32[] add(s32[] %constant.1015, s32[] %constant.1016) + %constant.1018 = s32[] constant(0) + %select.1019 = s32[] select(pred[] %compare.1014, s32[] %add.1017, s32[] %constant.1018) + %dynamic-update-slice.1020 = f32[2,1,1,1,16]{4,3,2,1,0} dynamic-update-slice(f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.296, f32[1,1,1,1,16]{4,3,2,1,0} %broadcast.982, s32[] %select.987, s32[] %select.995, s32[] %select.1003, /*index=5*/s32[] %select.1011, s32[] %select.1019) + %get-tuple-element.297 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=30 + %broadcast.1021 = f32[1,16,32,32,16]{4,3,2,1,0} broadcast(f32[16,32,32,16]{3,2,1,0} %convolution.524), dimensions={1,2,3,4} + %constant.1022 = s32[] constant(0) + %compare.1023 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1022), direction=LT + %constant.1024 = s32[] constant(2) + %add.1025 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1024) + %select.1026 = s32[] select(pred[] %compare.1023, s32[] %add.1025, s32[] %get-tuple-element.276) + %constant.1027 = s32[] constant(0) + %constant.1028 = s32[] constant(0) + %compare.1029 = pred[] compare(s32[] %constant.1027, s32[] %constant.1028), direction=LT + %constant.1030 = s32[] constant(0) + %constant.1031 = s32[] constant(16) + %add.1032 = s32[] add(s32[] %constant.1030, s32[] %constant.1031) + %constant.1033 = s32[] constant(0) + %select.1034 = s32[] select(pred[] %compare.1029, s32[] %add.1032, s32[] %constant.1033) + %constant.1035 = s32[] constant(0) + %constant.1036 = s32[] constant(0) + %compare.1037 = pred[] compare(s32[] %constant.1035, s32[] %constant.1036), direction=LT + %constant.1038 = s32[] constant(0) + %constant.1039 = s32[] constant(32) + %add.1040 = s32[] add(s32[] %constant.1038, s32[] %constant.1039) + %constant.1041 = s32[] constant(0) + %select.1042 = s32[] select(pred[] %compare.1037, s32[] %add.1040, s32[] %constant.1041) + %constant.1043 = s32[] constant(0) + %constant.1044 = s32[] constant(0) + %compare.1045 = pred[] compare(s32[] %constant.1043, s32[] %constant.1044), direction=LT + %constant.1046 = s32[] constant(0) + %constant.1047 = s32[] constant(32) + %add.1048 = s32[] add(s32[] %constant.1046, s32[] %constant.1047) + %constant.1049 = s32[] constant(0) + %select.1050 = s32[] select(pred[] %compare.1045, s32[] %add.1048, s32[] %constant.1049) + %constant.1051 = s32[] constant(0) + %constant.1052 = s32[] constant(0) + %compare.1053 = pred[] compare(s32[] %constant.1051, s32[] %constant.1052), direction=LT + %constant.1054 = s32[] constant(0) + %constant.1055 = s32[] constant(16) + %add.1056 = s32[] add(s32[] %constant.1054, s32[] %constant.1055) + %constant.1057 = s32[] constant(0) + %select.1058 = s32[] select(pred[] %compare.1053, s32[] %add.1056, s32[] %constant.1057) + %dynamic-update-slice.1059 = f32[2,16,32,32,16]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.297, f32[1,16,32,32,16]{4,3,2,1,0} %broadcast.1021, s32[] %select.1026, s32[] %select.1034, s32[] %select.1042, /*index=5*/s32[] %select.1050, s32[] %select.1058) + %get-tuple-element.298 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=31 + %constant.624 = f32[] constant(2) + %broadcast.625 = f32[16,32,32,16]{3,2,1,0} broadcast(f32[] %constant.624), dimensions={} + %multiply.626 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %broadcast.625, f32[16,32,32,16]{3,2,1,0} %add.532) + %broadcast.1060 = f32[1,16,32,32,16]{4,3,2,1,0} broadcast(f32[16,32,32,16]{3,2,1,0} %multiply.626), dimensions={1,2,3,4} + %constant.1061 = s32[] constant(0) + %compare.1062 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1061), direction=LT + %constant.1063 = s32[] constant(2) + %add.1064 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1063) + %select.1065 = s32[] select(pred[] %compare.1062, s32[] %add.1064, s32[] %get-tuple-element.276) + %constant.1066 = s32[] constant(0) + %constant.1067 = s32[] constant(0) + %compare.1068 = pred[] compare(s32[] %constant.1066, s32[] %constant.1067), direction=LT + %constant.1069 = s32[] constant(0) + %constant.1070 = s32[] constant(16) + %add.1071 = s32[] add(s32[] %constant.1069, s32[] %constant.1070) + %constant.1072 = s32[] constant(0) + %select.1073 = s32[] select(pred[] %compare.1068, s32[] %add.1071, s32[] %constant.1072) + %constant.1074 = s32[] constant(0) + %constant.1075 = s32[] constant(0) + %compare.1076 = pred[] compare(s32[] %constant.1074, s32[] %constant.1075), direction=LT + %constant.1077 = s32[] constant(0) + %constant.1078 = s32[] constant(32) + %add.1079 = s32[] add(s32[] %constant.1077, s32[] %constant.1078) + %constant.1080 = s32[] constant(0) + %select.1081 = s32[] select(pred[] %compare.1076, s32[] %add.1079, s32[] %constant.1080) + %constant.1082 = s32[] constant(0) + %constant.1083 = s32[] constant(0) + %compare.1084 = pred[] compare(s32[] %constant.1082, s32[] %constant.1083), direction=LT + %constant.1085 = s32[] constant(0) + %constant.1086 = s32[] constant(32) + %add.1087 = s32[] add(s32[] %constant.1085, s32[] %constant.1086) + %constant.1088 = s32[] constant(0) + %select.1089 = s32[] select(pred[] %compare.1084, s32[] %add.1087, s32[] %constant.1088) + %constant.1090 = s32[] constant(0) + %constant.1091 = s32[] constant(0) + %compare.1092 = pred[] compare(s32[] %constant.1090, s32[] %constant.1091), direction=LT + %constant.1093 = s32[] constant(0) + %constant.1094 = s32[] constant(16) + %add.1095 = s32[] add(s32[] %constant.1093, s32[] %constant.1094) + %constant.1096 = s32[] constant(0) + %select.1097 = s32[] select(pred[] %compare.1092, s32[] %add.1095, s32[] %constant.1096) + %dynamic-update-slice.1098 = f32[2,16,32,32,16]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.298, f32[1,16,32,32,16]{4,3,2,1,0} %broadcast.1060, s32[] %select.1065, s32[] %select.1073, s32[] %select.1081, /*index=5*/s32[] %select.1089, s32[] %select.1097) + %get-tuple-element.299 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=32 + %broadcast.1099 = f32[1,16,32,32,16]{4,3,2,1,0} broadcast(f32[16,32,32,16]{3,2,1,0} %rsqrt.537), dimensions={1,2,3,4} + %constant.1100 = s32[] constant(0) + %compare.1101 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1100), direction=LT + %constant.1102 = s32[] constant(2) + %add.1103 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1102) + %select.1104 = s32[] select(pred[] %compare.1101, s32[] %add.1103, s32[] %get-tuple-element.276) + %constant.1105 = s32[] constant(0) + %constant.1106 = s32[] constant(0) + %compare.1107 = pred[] compare(s32[] %constant.1105, s32[] %constant.1106), direction=LT + %constant.1108 = s32[] constant(0) + %constant.1109 = s32[] constant(16) + %add.1110 = s32[] add(s32[] %constant.1108, s32[] %constant.1109) + %constant.1111 = s32[] constant(0) + %select.1112 = s32[] select(pred[] %compare.1107, s32[] %add.1110, s32[] %constant.1111) + %constant.1113 = s32[] constant(0) + %constant.1114 = s32[] constant(0) + %compare.1115 = pred[] compare(s32[] %constant.1113, s32[] %constant.1114), direction=LT + %constant.1116 = s32[] constant(0) + %constant.1117 = s32[] constant(32) + %add.1118 = s32[] add(s32[] %constant.1116, s32[] %constant.1117) + %constant.1119 = s32[] constant(0) + %select.1120 = s32[] select(pred[] %compare.1115, s32[] %add.1118, s32[] %constant.1119) + %constant.1121 = s32[] constant(0) + %constant.1122 = s32[] constant(0) + %compare.1123 = pred[] compare(s32[] %constant.1121, s32[] %constant.1122), direction=LT + %constant.1124 = s32[] constant(0) + %constant.1125 = s32[] constant(32) + %add.1126 = s32[] add(s32[] %constant.1124, s32[] %constant.1125) + %constant.1127 = s32[] constant(0) + %select.1128 = s32[] select(pred[] %compare.1123, s32[] %add.1126, s32[] %constant.1127) + %constant.1129 = s32[] constant(0) + %constant.1130 = s32[] constant(0) + %compare.1131 = pred[] compare(s32[] %constant.1129, s32[] %constant.1130), direction=LT + %constant.1132 = s32[] constant(0) + %constant.1133 = s32[] constant(16) + %add.1134 = s32[] add(s32[] %constant.1132, s32[] %constant.1133) + %constant.1135 = s32[] constant(0) + %select.1136 = s32[] select(pred[] %compare.1131, s32[] %add.1134, s32[] %constant.1135) + %dynamic-update-slice.1137 = f32[2,16,32,32,16]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.299, f32[1,16,32,32,16]{4,3,2,1,0} %broadcast.1099, s32[] %select.1104, s32[] %select.1112, s32[] %select.1120, /*index=5*/s32[] %select.1128, s32[] %select.1136) + %get-tuple-element.300 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=33 + %broadcast.1138 = f32[1,16,32,32,16]{4,3,2,1,0} broadcast(f32[16,32,32,16]{3,2,1,0} %multiply.533), dimensions={1,2,3,4} + %constant.1139 = s32[] constant(0) + %compare.1140 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1139), direction=LT + %constant.1141 = s32[] constant(2) + %add.1142 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1141) + %select.1143 = s32[] select(pred[] %compare.1140, s32[] %add.1142, s32[] %get-tuple-element.276) + %constant.1144 = s32[] constant(0) + %constant.1145 = s32[] constant(0) + %compare.1146 = pred[] compare(s32[] %constant.1144, s32[] %constant.1145), direction=LT + %constant.1147 = s32[] constant(0) + %constant.1148 = s32[] constant(16) + %add.1149 = s32[] add(s32[] %constant.1147, s32[] %constant.1148) + %constant.1150 = s32[] constant(0) + %select.1151 = s32[] select(pred[] %compare.1146, s32[] %add.1149, s32[] %constant.1150) + %constant.1152 = s32[] constant(0) + %constant.1153 = s32[] constant(0) + %compare.1154 = pred[] compare(s32[] %constant.1152, s32[] %constant.1153), direction=LT + %constant.1155 = s32[] constant(0) + %constant.1156 = s32[] constant(32) + %add.1157 = s32[] add(s32[] %constant.1155, s32[] %constant.1156) + %constant.1158 = s32[] constant(0) + %select.1159 = s32[] select(pred[] %compare.1154, s32[] %add.1157, s32[] %constant.1158) + %constant.1160 = s32[] constant(0) + %constant.1161 = s32[] constant(0) + %compare.1162 = pred[] compare(s32[] %constant.1160, s32[] %constant.1161), direction=LT + %constant.1163 = s32[] constant(0) + %constant.1164 = s32[] constant(32) + %add.1165 = s32[] add(s32[] %constant.1163, s32[] %constant.1164) + %constant.1166 = s32[] constant(0) + %select.1167 = s32[] select(pred[] %compare.1162, s32[] %add.1165, s32[] %constant.1166) + %constant.1168 = s32[] constant(0) + %constant.1169 = s32[] constant(0) + %compare.1170 = pred[] compare(s32[] %constant.1168, s32[] %constant.1169), direction=LT + %constant.1171 = s32[] constant(0) + %constant.1172 = s32[] constant(16) + %add.1173 = s32[] add(s32[] %constant.1171, s32[] %constant.1172) + %constant.1174 = s32[] constant(0) + %select.1175 = s32[] select(pred[] %compare.1170, s32[] %add.1173, s32[] %constant.1174) + %dynamic-update-slice.1176 = f32[2,16,32,32,16]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.300, f32[1,16,32,32,16]{4,3,2,1,0} %broadcast.1138, s32[] %select.1143, s32[] %select.1151, s32[] %select.1159, /*index=5*/s32[] %select.1167, s32[] %select.1175) + %get-tuple-element.301 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=34 + %constant.628 = f32[] constant(-0.5) + %broadcast.629 = f32[16,32,32,16]{3,2,1,0} broadcast(f32[] %constant.628), dimensions={} + %divide.627 = f32[16,32,32,16]{3,2,1,0} divide(f32[16,32,32,16]{3,2,1,0} %rsqrt.537, f32[16,32,32,16]{3,2,1,0} %add.536) + %multiply.630 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %broadcast.629, f32[16,32,32,16]{3,2,1,0} %divide.627) + %broadcast.1177 = f32[1,16,32,32,16]{4,3,2,1,0} broadcast(f32[16,32,32,16]{3,2,1,0} %multiply.630), dimensions={1,2,3,4} + %constant.1178 = s32[] constant(0) + %compare.1179 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1178), direction=LT + %constant.1180 = s32[] constant(2) + %add.1181 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1180) + %select.1182 = s32[] select(pred[] %compare.1179, s32[] %add.1181, s32[] %get-tuple-element.276) + %constant.1183 = s32[] constant(0) + %constant.1184 = s32[] constant(0) + %compare.1185 = pred[] compare(s32[] %constant.1183, s32[] %constant.1184), direction=LT + %constant.1186 = s32[] constant(0) + %constant.1187 = s32[] constant(16) + %add.1188 = s32[] add(s32[] %constant.1186, s32[] %constant.1187) + %constant.1189 = s32[] constant(0) + %select.1190 = s32[] select(pred[] %compare.1185, s32[] %add.1188, s32[] %constant.1189) + %constant.1191 = s32[] constant(0) + %constant.1192 = s32[] constant(0) + %compare.1193 = pred[] compare(s32[] %constant.1191, s32[] %constant.1192), direction=LT + %constant.1194 = s32[] constant(0) + %constant.1195 = s32[] constant(32) + %add.1196 = s32[] add(s32[] %constant.1194, s32[] %constant.1195) + %constant.1197 = s32[] constant(0) + %select.1198 = s32[] select(pred[] %compare.1193, s32[] %add.1196, s32[] %constant.1197) + %constant.1199 = s32[] constant(0) + %constant.1200 = s32[] constant(0) + %compare.1201 = pred[] compare(s32[] %constant.1199, s32[] %constant.1200), direction=LT + %constant.1202 = s32[] constant(0) + %constant.1203 = s32[] constant(32) + %add.1204 = s32[] add(s32[] %constant.1202, s32[] %constant.1203) + %constant.1205 = s32[] constant(0) + %select.1206 = s32[] select(pred[] %compare.1201, s32[] %add.1204, s32[] %constant.1205) + %constant.1207 = s32[] constant(0) + %constant.1208 = s32[] constant(0) + %compare.1209 = pred[] compare(s32[] %constant.1207, s32[] %constant.1208), direction=LT + %constant.1210 = s32[] constant(0) + %constant.1211 = s32[] constant(16) + %add.1212 = s32[] add(s32[] %constant.1210, s32[] %constant.1211) + %constant.1213 = s32[] constant(0) + %select.1214 = s32[] select(pred[] %compare.1209, s32[] %add.1212, s32[] %constant.1213) + %dynamic-update-slice.1215 = f32[2,16,32,32,16]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.301, f32[1,16,32,32,16]{4,3,2,1,0} %broadcast.1177, s32[] %select.1182, s32[] %select.1190, s32[] %select.1198, /*index=5*/s32[] %select.1206, s32[] %select.1214) + %get-tuple-element.302 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=35 + %broadcast.1216 = f32[1,1,1,16,16]{4,3,2,1,0} broadcast(f32[1,1,16,16]{3,2,1,0} %multiply.550), dimensions={1,2,3,4} + %constant.1217 = s32[] constant(0) + %compare.1218 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1217), direction=LT + %constant.1219 = s32[] constant(2) + %add.1220 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1219) + %select.1221 = s32[] select(pred[] %compare.1218, s32[] %add.1220, s32[] %get-tuple-element.276) + %constant.1222 = s32[] constant(0) + %constant.1223 = s32[] constant(0) + %compare.1224 = pred[] compare(s32[] %constant.1222, s32[] %constant.1223), direction=LT + %constant.1225 = s32[] constant(0) + %constant.1226 = s32[] constant(1) + %add.1227 = s32[] add(s32[] %constant.1225, s32[] %constant.1226) + %constant.1228 = s32[] constant(0) + %select.1229 = s32[] select(pred[] %compare.1224, s32[] %add.1227, s32[] %constant.1228) + %constant.1230 = s32[] constant(0) + %constant.1231 = s32[] constant(0) + %compare.1232 = pred[] compare(s32[] %constant.1230, s32[] %constant.1231), direction=LT + %constant.1233 = s32[] constant(0) + %constant.1234 = s32[] constant(1) + %add.1235 = s32[] add(s32[] %constant.1233, s32[] %constant.1234) + %constant.1236 = s32[] constant(0) + %select.1237 = s32[] select(pred[] %compare.1232, s32[] %add.1235, s32[] %constant.1236) + %constant.1238 = s32[] constant(0) + %constant.1239 = s32[] constant(0) + %compare.1240 = pred[] compare(s32[] %constant.1238, s32[] %constant.1239), direction=LT + %constant.1241 = s32[] constant(0) + %constant.1242 = s32[] constant(16) + %add.1243 = s32[] add(s32[] %constant.1241, s32[] %constant.1242) + %constant.1244 = s32[] constant(0) + %select.1245 = s32[] select(pred[] %compare.1240, s32[] %add.1243, s32[] %constant.1244) + %constant.1246 = s32[] constant(0) + %constant.1247 = s32[] constant(0) + %compare.1248 = pred[] compare(s32[] %constant.1246, s32[] %constant.1247), direction=LT + %constant.1249 = s32[] constant(0) + %constant.1250 = s32[] constant(16) + %add.1251 = s32[] add(s32[] %constant.1249, s32[] %constant.1250) + %constant.1252 = s32[] constant(0) + %select.1253 = s32[] select(pred[] %compare.1248, s32[] %add.1251, s32[] %constant.1252) + %dynamic-update-slice.1254 = f32[2,1,1,16,16]{4,3,2,1,0} dynamic-update-slice(f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.302, f32[1,1,1,16,16]{4,3,2,1,0} %broadcast.1216, s32[] %select.1221, s32[] %select.1229, s32[] %select.1237, /*index=5*/s32[] %select.1245, s32[] %select.1253) + %get-tuple-element.303 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=36 + %broadcast.1255 = f32[1,16,32,32,16]{4,3,2,1,0} broadcast(f32[16,32,32,16]{3,2,1,0} %multiply.542), dimensions={1,2,3,4} + %constant.1256 = s32[] constant(0) + %compare.1257 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1256), direction=LT + %constant.1258 = s32[] constant(2) + %add.1259 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1258) + %select.1260 = s32[] select(pred[] %compare.1257, s32[] %add.1259, s32[] %get-tuple-element.276) + %constant.1261 = s32[] constant(0) + %constant.1262 = s32[] constant(0) + %compare.1263 = pred[] compare(s32[] %constant.1261, s32[] %constant.1262), direction=LT + %constant.1264 = s32[] constant(0) + %constant.1265 = s32[] constant(16) + %add.1266 = s32[] add(s32[] %constant.1264, s32[] %constant.1265) + %constant.1267 = s32[] constant(0) + %select.1268 = s32[] select(pred[] %compare.1263, s32[] %add.1266, s32[] %constant.1267) + %constant.1269 = s32[] constant(0) + %constant.1270 = s32[] constant(0) + %compare.1271 = pred[] compare(s32[] %constant.1269, s32[] %constant.1270), direction=LT + %constant.1272 = s32[] constant(0) + %constant.1273 = s32[] constant(32) + %add.1274 = s32[] add(s32[] %constant.1272, s32[] %constant.1273) + %constant.1275 = s32[] constant(0) + %select.1276 = s32[] select(pred[] %compare.1271, s32[] %add.1274, s32[] %constant.1275) + %constant.1277 = s32[] constant(0) + %constant.1278 = s32[] constant(0) + %compare.1279 = pred[] compare(s32[] %constant.1277, s32[] %constant.1278), direction=LT + %constant.1280 = s32[] constant(0) + %constant.1281 = s32[] constant(32) + %add.1282 = s32[] add(s32[] %constant.1280, s32[] %constant.1281) + %constant.1283 = s32[] constant(0) + %select.1284 = s32[] select(pred[] %compare.1279, s32[] %add.1282, s32[] %constant.1283) + %constant.1285 = s32[] constant(0) + %constant.1286 = s32[] constant(0) + %compare.1287 = pred[] compare(s32[] %constant.1285, s32[] %constant.1286), direction=LT + %constant.1288 = s32[] constant(0) + %constant.1289 = s32[] constant(16) + %add.1290 = s32[] add(s32[] %constant.1288, s32[] %constant.1289) + %constant.1291 = s32[] constant(0) + %select.1292 = s32[] select(pred[] %compare.1287, s32[] %add.1290, s32[] %constant.1291) + %dynamic-update-slice.1293 = f32[2,16,32,32,16]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.303, f32[1,16,32,32,16]{4,3,2,1,0} %broadcast.1255, s32[] %select.1260, s32[] %select.1268, s32[] %select.1276, /*index=5*/s32[] %select.1284, s32[] %select.1292) + %get-tuple-element.304 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=37 + %broadcast.1294 = f32[1,1,1,1,16]{4,3,2,1,0} broadcast(f32[1,1,1,16]{3,2,1,0} %broadcast.547), dimensions={1,2,3,4} + %constant.1295 = s32[] constant(0) + %compare.1296 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1295), direction=LT + %constant.1297 = s32[] constant(2) + %add.1298 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1297) + %select.1299 = s32[] select(pred[] %compare.1296, s32[] %add.1298, s32[] %get-tuple-element.276) + %constant.1300 = s32[] constant(0) + %constant.1301 = s32[] constant(0) + %compare.1302 = pred[] compare(s32[] %constant.1300, s32[] %constant.1301), direction=LT + %constant.1303 = s32[] constant(0) + %constant.1304 = s32[] constant(1) + %add.1305 = s32[] add(s32[] %constant.1303, s32[] %constant.1304) + %constant.1306 = s32[] constant(0) + %select.1307 = s32[] select(pred[] %compare.1302, s32[] %add.1305, s32[] %constant.1306) + %constant.1308 = s32[] constant(0) + %constant.1309 = s32[] constant(0) + %compare.1310 = pred[] compare(s32[] %constant.1308, s32[] %constant.1309), direction=LT + %constant.1311 = s32[] constant(0) + %constant.1312 = s32[] constant(1) + %add.1313 = s32[] add(s32[] %constant.1311, s32[] %constant.1312) + %constant.1314 = s32[] constant(0) + %select.1315 = s32[] select(pred[] %compare.1310, s32[] %add.1313, s32[] %constant.1314) + %constant.1316 = s32[] constant(0) + %constant.1317 = s32[] constant(0) + %compare.1318 = pred[] compare(s32[] %constant.1316, s32[] %constant.1317), direction=LT + %constant.1319 = s32[] constant(0) + %constant.1320 = s32[] constant(1) + %add.1321 = s32[] add(s32[] %constant.1319, s32[] %constant.1320) + %constant.1322 = s32[] constant(0) + %select.1323 = s32[] select(pred[] %compare.1318, s32[] %add.1321, s32[] %constant.1322) + %constant.1324 = s32[] constant(0) + %constant.1325 = s32[] constant(0) + %compare.1326 = pred[] compare(s32[] %constant.1324, s32[] %constant.1325), direction=LT + %constant.1327 = s32[] constant(0) + %constant.1328 = s32[] constant(16) + %add.1329 = s32[] add(s32[] %constant.1327, s32[] %constant.1328) + %constant.1330 = s32[] constant(0) + %select.1331 = s32[] select(pred[] %compare.1326, s32[] %add.1329, s32[] %constant.1330) + %dynamic-update-slice.1332 = f32[2,1,1,1,16]{4,3,2,1,0} dynamic-update-slice(f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.304, f32[1,1,1,1,16]{4,3,2,1,0} %broadcast.1294, s32[] %select.1299, s32[] %select.1307, s32[] %select.1315, /*index=5*/s32[] %select.1323, s32[] %select.1331) + %get-tuple-element.305 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=38 + %constant.631 = f32[] constant(2) + %broadcast.632 = f32[1,1,16,16]{3,2,1,0} broadcast(f32[] %constant.631), dimensions={} + %multiply.633 = f32[1,1,16,16]{3,2,1,0} multiply(f32[1,1,16,16]{3,2,1,0} %broadcast.632, f32[1,1,16,16]{3,2,1,0} %reshape.475) + %broadcast.1333 = f32[1,1,1,16,16]{4,3,2,1,0} broadcast(f32[1,1,16,16]{3,2,1,0} %multiply.633), dimensions={1,2,3,4} + %constant.1334 = s32[] constant(0) + %compare.1335 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1334), direction=LT + %constant.1336 = s32[] constant(2) + %add.1337 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1336) + %select.1338 = s32[] select(pred[] %compare.1335, s32[] %add.1337, s32[] %get-tuple-element.276) + %constant.1339 = s32[] constant(0) + %constant.1340 = s32[] constant(0) + %compare.1341 = pred[] compare(s32[] %constant.1339, s32[] %constant.1340), direction=LT + %constant.1342 = s32[] constant(0) + %constant.1343 = s32[] constant(1) + %add.1344 = s32[] add(s32[] %constant.1342, s32[] %constant.1343) + %constant.1345 = s32[] constant(0) + %select.1346 = s32[] select(pred[] %compare.1341, s32[] %add.1344, s32[] %constant.1345) + %constant.1347 = s32[] constant(0) + %constant.1348 = s32[] constant(0) + %compare.1349 = pred[] compare(s32[] %constant.1347, s32[] %constant.1348), direction=LT + %constant.1350 = s32[] constant(0) + %constant.1351 = s32[] constant(1) + %add.1352 = s32[] add(s32[] %constant.1350, s32[] %constant.1351) + %constant.1353 = s32[] constant(0) + %select.1354 = s32[] select(pred[] %compare.1349, s32[] %add.1352, s32[] %constant.1353) + %constant.1355 = s32[] constant(0) + %constant.1356 = s32[] constant(0) + %compare.1357 = pred[] compare(s32[] %constant.1355, s32[] %constant.1356), direction=LT + %constant.1358 = s32[] constant(0) + %constant.1359 = s32[] constant(16) + %add.1360 = s32[] add(s32[] %constant.1358, s32[] %constant.1359) + %constant.1361 = s32[] constant(0) + %select.1362 = s32[] select(pred[] %compare.1357, s32[] %add.1360, s32[] %constant.1361) + %constant.1363 = s32[] constant(0) + %constant.1364 = s32[] constant(0) + %compare.1365 = pred[] compare(s32[] %constant.1363, s32[] %constant.1364), direction=LT + %constant.1366 = s32[] constant(0) + %constant.1367 = s32[] constant(16) + %add.1368 = s32[] add(s32[] %constant.1366, s32[] %constant.1367) + %constant.1369 = s32[] constant(0) + %select.1370 = s32[] select(pred[] %compare.1365, s32[] %add.1368, s32[] %constant.1369) + %dynamic-update-slice.1371 = f32[2,1,1,16,16]{4,3,2,1,0} dynamic-update-slice(f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.305, f32[1,1,1,16,16]{4,3,2,1,0} %broadcast.1333, s32[] %select.1338, s32[] %select.1346, s32[] %select.1354, /*index=5*/s32[] %select.1362, s32[] %select.1370) + %get-tuple-element.306 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=39 + %constant.635 = f32[] constant(-0.5) + %broadcast.636 = f32[16]{0} broadcast(f32[] %constant.635), dimensions={} + %divide.634 = f32[16]{0} divide(f32[16]{0} %rsqrt.546, f32[16]{0} %reduce.545) + %multiply.637 = f32[16]{0} multiply(f32[16]{0} %broadcast.636, f32[16]{0} %divide.634) + %broadcast.1372 = f32[1,16]{1,0} broadcast(f32[16]{0} %multiply.637), dimensions={1} + %constant.1373 = s32[] constant(0) + %compare.1374 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1373), direction=LT + %constant.1375 = s32[] constant(2) + %add.1376 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1375) + %select.1377 = s32[] select(pred[] %compare.1374, s32[] %add.1376, s32[] %get-tuple-element.276) + %constant.1378 = s32[] constant(0) + %constant.1379 = s32[] constant(0) + %compare.1380 = pred[] compare(s32[] %constant.1378, s32[] %constant.1379), direction=LT + %constant.1381 = s32[] constant(0) + %constant.1382 = s32[] constant(16) + %add.1383 = s32[] add(s32[] %constant.1381, s32[] %constant.1382) + %constant.1384 = s32[] constant(0) + %select.1385 = s32[] select(pred[] %compare.1380, s32[] %add.1383, s32[] %constant.1384) + %dynamic-update-slice.1386 = f32[2,16]{1,0} dynamic-update-slice(f32[2,16]{1,0} %get-tuple-element.306, f32[1,16]{1,0} %broadcast.1372, s32[] %select.1377, s32[] %select.1385) + %get-tuple-element.307 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=40 + %broadcast.1387 = f32[1,1,1,1,16]{4,3,2,1,0} broadcast(f32[1,1,1,16]{3,2,1,0} %broadcast.552), dimensions={1,2,3,4} + %constant.1388 = s32[] constant(0) + %compare.1389 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1388), direction=LT + %constant.1390 = s32[] constant(2) + %add.1391 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1390) + %select.1392 = s32[] select(pred[] %compare.1389, s32[] %add.1391, s32[] %get-tuple-element.276) + %constant.1393 = s32[] constant(0) + %constant.1394 = s32[] constant(0) + %compare.1395 = pred[] compare(s32[] %constant.1393, s32[] %constant.1394), direction=LT + %constant.1396 = s32[] constant(0) + %constant.1397 = s32[] constant(1) + %add.1398 = s32[] add(s32[] %constant.1396, s32[] %constant.1397) + %constant.1399 = s32[] constant(0) + %select.1400 = s32[] select(pred[] %compare.1395, s32[] %add.1398, s32[] %constant.1399) + %constant.1401 = s32[] constant(0) + %constant.1402 = s32[] constant(0) + %compare.1403 = pred[] compare(s32[] %constant.1401, s32[] %constant.1402), direction=LT + %constant.1404 = s32[] constant(0) + %constant.1405 = s32[] constant(1) + %add.1406 = s32[] add(s32[] %constant.1404, s32[] %constant.1405) + %constant.1407 = s32[] constant(0) + %select.1408 = s32[] select(pred[] %compare.1403, s32[] %add.1406, s32[] %constant.1407) + %constant.1409 = s32[] constant(0) + %constant.1410 = s32[] constant(0) + %compare.1411 = pred[] compare(s32[] %constant.1409, s32[] %constant.1410), direction=LT + %constant.1412 = s32[] constant(0) + %constant.1413 = s32[] constant(1) + %add.1414 = s32[] add(s32[] %constant.1412, s32[] %constant.1413) + %constant.1415 = s32[] constant(0) + %select.1416 = s32[] select(pred[] %compare.1411, s32[] %add.1414, s32[] %constant.1415) + %constant.1417 = s32[] constant(0) + %constant.1418 = s32[] constant(0) + %compare.1419 = pred[] compare(s32[] %constant.1417, s32[] %constant.1418), direction=LT + %constant.1420 = s32[] constant(0) + %constant.1421 = s32[] constant(16) + %add.1422 = s32[] add(s32[] %constant.1420, s32[] %constant.1421) + %constant.1423 = s32[] constant(0) + %select.1424 = s32[] select(pred[] %compare.1419, s32[] %add.1422, s32[] %constant.1423) + %dynamic-update-slice.1425 = f32[2,1,1,1,16]{4,3,2,1,0} dynamic-update-slice(f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.307, f32[1,1,1,1,16]{4,3,2,1,0} %broadcast.1387, s32[] %select.1392, s32[] %select.1400, s32[] %select.1408, /*index=5*/s32[] %select.1416, s32[] %select.1424) + %get-tuple-element.308 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=41 + %broadcast.1426 = f32[1,16,32,32,16]{4,3,2,1,0} broadcast(f32[16,32,32,16]{3,2,1,0} %convolution.551), dimensions={1,2,3,4} + %constant.1427 = s32[] constant(0) + %compare.1428 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1427), direction=LT + %constant.1429 = s32[] constant(2) + %add.1430 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1429) + %select.1431 = s32[] select(pred[] %compare.1428, s32[] %add.1430, s32[] %get-tuple-element.276) + %constant.1432 = s32[] constant(0) + %constant.1433 = s32[] constant(0) + %compare.1434 = pred[] compare(s32[] %constant.1432, s32[] %constant.1433), direction=LT + %constant.1435 = s32[] constant(0) + %constant.1436 = s32[] constant(16) + %add.1437 = s32[] add(s32[] %constant.1435, s32[] %constant.1436) + %constant.1438 = s32[] constant(0) + %select.1439 = s32[] select(pred[] %compare.1434, s32[] %add.1437, s32[] %constant.1438) + %constant.1440 = s32[] constant(0) + %constant.1441 = s32[] constant(0) + %compare.1442 = pred[] compare(s32[] %constant.1440, s32[] %constant.1441), direction=LT + %constant.1443 = s32[] constant(0) + %constant.1444 = s32[] constant(32) + %add.1445 = s32[] add(s32[] %constant.1443, s32[] %constant.1444) + %constant.1446 = s32[] constant(0) + %select.1447 = s32[] select(pred[] %compare.1442, s32[] %add.1445, s32[] %constant.1446) + %constant.1448 = s32[] constant(0) + %constant.1449 = s32[] constant(0) + %compare.1450 = pred[] compare(s32[] %constant.1448, s32[] %constant.1449), direction=LT + %constant.1451 = s32[] constant(0) + %constant.1452 = s32[] constant(32) + %add.1453 = s32[] add(s32[] %constant.1451, s32[] %constant.1452) + %constant.1454 = s32[] constant(0) + %select.1455 = s32[] select(pred[] %compare.1450, s32[] %add.1453, s32[] %constant.1454) + %constant.1456 = s32[] constant(0) + %constant.1457 = s32[] constant(0) + %compare.1458 = pred[] compare(s32[] %constant.1456, s32[] %constant.1457), direction=LT + %constant.1459 = s32[] constant(0) + %constant.1460 = s32[] constant(16) + %add.1461 = s32[] add(s32[] %constant.1459, s32[] %constant.1460) + %constant.1462 = s32[] constant(0) + %select.1463 = s32[] select(pred[] %compare.1458, s32[] %add.1461, s32[] %constant.1462) + %dynamic-update-slice.1464 = f32[2,16,32,32,16]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.308, f32[1,16,32,32,16]{4,3,2,1,0} %broadcast.1426, s32[] %select.1431, s32[] %select.1439, s32[] %select.1447, /*index=5*/s32[] %select.1455, s32[] %select.1463) + %get-tuple-element.309 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=42 + %broadcast.1465 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %multiply.573), dimensions={1,2,3,4} + %constant.1466 = s32[] constant(0) + %compare.1467 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1466), direction=LT + %constant.1468 = s32[] constant(2) + %add.1469 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1468) + %select.1470 = s32[] select(pred[] %compare.1467, s32[] %add.1469, s32[] %get-tuple-element.276) + %constant.1471 = s32[] constant(0) + %constant.1472 = s32[] constant(0) + %compare.1473 = pred[] compare(s32[] %constant.1471, s32[] %constant.1472), direction=LT + %constant.1474 = s32[] constant(0) + %constant.1475 = s32[] constant(16) + %add.1476 = s32[] add(s32[] %constant.1474, s32[] %constant.1475) + %constant.1477 = s32[] constant(0) + %select.1478 = s32[] select(pred[] %compare.1473, s32[] %add.1476, s32[] %constant.1477) + %constant.1479 = s32[] constant(0) + %constant.1480 = s32[] constant(0) + %compare.1481 = pred[] compare(s32[] %constant.1479, s32[] %constant.1480), direction=LT + %constant.1482 = s32[] constant(0) + %constant.1483 = s32[] constant(32) + %add.1484 = s32[] add(s32[] %constant.1482, s32[] %constant.1483) + %constant.1485 = s32[] constant(0) + %select.1486 = s32[] select(pred[] %compare.1481, s32[] %add.1484, s32[] %constant.1485) + %constant.1487 = s32[] constant(0) + %constant.1488 = s32[] constant(0) + %compare.1489 = pred[] compare(s32[] %constant.1487, s32[] %constant.1488), direction=LT + %constant.1490 = s32[] constant(0) + %constant.1491 = s32[] constant(32) + %add.1492 = s32[] add(s32[] %constant.1490, s32[] %constant.1491) + %constant.1493 = s32[] constant(0) + %select.1494 = s32[] select(pred[] %compare.1489, s32[] %add.1492, s32[] %constant.1493) + %constant.1495 = s32[] constant(0) + %constant.1496 = s32[] constant(0) + %compare.1497 = pred[] compare(s32[] %constant.1495, s32[] %constant.1496), direction=LT + %constant.1498 = s32[] constant(0) + %constant.1499 = s32[] constant(8) + %add.1500 = s32[] add(s32[] %constant.1498, s32[] %constant.1499) + %constant.1501 = s32[] constant(0) + %select.1502 = s32[] select(pred[] %compare.1497, s32[] %add.1500, s32[] %constant.1501) + %dynamic-update-slice.1503 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.309, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.1465, s32[] %select.1470, s32[] %select.1478, s32[] %select.1486, /*index=5*/s32[] %select.1494, s32[] %select.1502) + %get-tuple-element.310 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=43 + %broadcast.1504 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %slice.560), dimensions={1,2,3,4} + %constant.1505 = s32[] constant(0) + %compare.1506 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1505), direction=LT + %constant.1507 = s32[] constant(2) + %add.1508 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1507) + %select.1509 = s32[] select(pred[] %compare.1506, s32[] %add.1508, s32[] %get-tuple-element.276) + %constant.1510 = s32[] constant(0) + %constant.1511 = s32[] constant(0) + %compare.1512 = pred[] compare(s32[] %constant.1510, s32[] %constant.1511), direction=LT + %constant.1513 = s32[] constant(0) + %constant.1514 = s32[] constant(16) + %add.1515 = s32[] add(s32[] %constant.1513, s32[] %constant.1514) + %constant.1516 = s32[] constant(0) + %select.1517 = s32[] select(pred[] %compare.1512, s32[] %add.1515, s32[] %constant.1516) + %constant.1518 = s32[] constant(0) + %constant.1519 = s32[] constant(0) + %compare.1520 = pred[] compare(s32[] %constant.1518, s32[] %constant.1519), direction=LT + %constant.1521 = s32[] constant(0) + %constant.1522 = s32[] constant(32) + %add.1523 = s32[] add(s32[] %constant.1521, s32[] %constant.1522) + %constant.1524 = s32[] constant(0) + %select.1525 = s32[] select(pred[] %compare.1520, s32[] %add.1523, s32[] %constant.1524) + %constant.1526 = s32[] constant(0) + %constant.1527 = s32[] constant(0) + %compare.1528 = pred[] compare(s32[] %constant.1526, s32[] %constant.1527), direction=LT + %constant.1529 = s32[] constant(0) + %constant.1530 = s32[] constant(32) + %add.1531 = s32[] add(s32[] %constant.1529, s32[] %constant.1530) + %constant.1532 = s32[] constant(0) + %select.1533 = s32[] select(pred[] %compare.1528, s32[] %add.1531, s32[] %constant.1532) + %constant.1534 = s32[] constant(0) + %constant.1535 = s32[] constant(0) + %compare.1536 = pred[] compare(s32[] %constant.1534, s32[] %constant.1535), direction=LT + %constant.1537 = s32[] constant(0) + %constant.1538 = s32[] constant(8) + %add.1539 = s32[] add(s32[] %constant.1537, s32[] %constant.1538) + %constant.1540 = s32[] constant(0) + %select.1541 = s32[] select(pred[] %compare.1536, s32[] %add.1539, s32[] %constant.1540) + %dynamic-update-slice.1542 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.310, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.1504, s32[] %select.1509, s32[] %select.1517, s32[] %select.1525, /*index=5*/s32[] %select.1533, s32[] %select.1541) + %get-tuple-element.311 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=44 + %broadcast.1543 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %rsqrt.566), dimensions={1,2,3,4} + %constant.1544 = s32[] constant(0) + %compare.1545 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1544), direction=LT + %constant.1546 = s32[] constant(2) + %add.1547 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1546) + %select.1548 = s32[] select(pred[] %compare.1545, s32[] %add.1547, s32[] %get-tuple-element.276) + %constant.1549 = s32[] constant(0) + %constant.1550 = s32[] constant(0) + %compare.1551 = pred[] compare(s32[] %constant.1549, s32[] %constant.1550), direction=LT + %constant.1552 = s32[] constant(0) + %constant.1553 = s32[] constant(16) + %add.1554 = s32[] add(s32[] %constant.1552, s32[] %constant.1553) + %constant.1555 = s32[] constant(0) + %select.1556 = s32[] select(pred[] %compare.1551, s32[] %add.1554, s32[] %constant.1555) + %constant.1557 = s32[] constant(0) + %constant.1558 = s32[] constant(0) + %compare.1559 = pred[] compare(s32[] %constant.1557, s32[] %constant.1558), direction=LT + %constant.1560 = s32[] constant(0) + %constant.1561 = s32[] constant(32) + %add.1562 = s32[] add(s32[] %constant.1560, s32[] %constant.1561) + %constant.1563 = s32[] constant(0) + %select.1564 = s32[] select(pred[] %compare.1559, s32[] %add.1562, s32[] %constant.1563) + %constant.1565 = s32[] constant(0) + %constant.1566 = s32[] constant(0) + %compare.1567 = pred[] compare(s32[] %constant.1565, s32[] %constant.1566), direction=LT + %constant.1568 = s32[] constant(0) + %constant.1569 = s32[] constant(32) + %add.1570 = s32[] add(s32[] %constant.1568, s32[] %constant.1569) + %constant.1571 = s32[] constant(0) + %select.1572 = s32[] select(pred[] %compare.1567, s32[] %add.1570, s32[] %constant.1571) + %constant.1573 = s32[] constant(0) + %constant.1574 = s32[] constant(0) + %compare.1575 = pred[] compare(s32[] %constant.1573, s32[] %constant.1574), direction=LT + %constant.1576 = s32[] constant(0) + %constant.1577 = s32[] constant(8) + %add.1578 = s32[] add(s32[] %constant.1576, s32[] %constant.1577) + %constant.1579 = s32[] constant(0) + %select.1580 = s32[] select(pred[] %compare.1575, s32[] %add.1578, s32[] %constant.1579) + %dynamic-update-slice.1581 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.311, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.1543, s32[] %select.1548, s32[] %select.1556, s32[] %select.1564, /*index=5*/s32[] %select.1572, s32[] %select.1580) + %get-tuple-element.312 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=45 + %broadcast.1582 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %slice.561), dimensions={1,2,3,4} + %constant.1583 = s32[] constant(0) + %compare.1584 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1583), direction=LT + %constant.1585 = s32[] constant(2) + %add.1586 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1585) + %select.1587 = s32[] select(pred[] %compare.1584, s32[] %add.1586, s32[] %get-tuple-element.276) + %constant.1588 = s32[] constant(0) + %constant.1589 = s32[] constant(0) + %compare.1590 = pred[] compare(s32[] %constant.1588, s32[] %constant.1589), direction=LT + %constant.1591 = s32[] constant(0) + %constant.1592 = s32[] constant(16) + %add.1593 = s32[] add(s32[] %constant.1591, s32[] %constant.1592) + %constant.1594 = s32[] constant(0) + %select.1595 = s32[] select(pred[] %compare.1590, s32[] %add.1593, s32[] %constant.1594) + %constant.1596 = s32[] constant(0) + %constant.1597 = s32[] constant(0) + %compare.1598 = pred[] compare(s32[] %constant.1596, s32[] %constant.1597), direction=LT + %constant.1599 = s32[] constant(0) + %constant.1600 = s32[] constant(32) + %add.1601 = s32[] add(s32[] %constant.1599, s32[] %constant.1600) + %constant.1602 = s32[] constant(0) + %select.1603 = s32[] select(pred[] %compare.1598, s32[] %add.1601, s32[] %constant.1602) + %constant.1604 = s32[] constant(0) + %constant.1605 = s32[] constant(0) + %compare.1606 = pred[] compare(s32[] %constant.1604, s32[] %constant.1605), direction=LT + %constant.1607 = s32[] constant(0) + %constant.1608 = s32[] constant(32) + %add.1609 = s32[] add(s32[] %constant.1607, s32[] %constant.1608) + %constant.1610 = s32[] constant(0) + %select.1611 = s32[] select(pred[] %compare.1606, s32[] %add.1609, s32[] %constant.1610) + %constant.1612 = s32[] constant(0) + %constant.1613 = s32[] constant(0) + %compare.1614 = pred[] compare(s32[] %constant.1612, s32[] %constant.1613), direction=LT + %constant.1615 = s32[] constant(0) + %constant.1616 = s32[] constant(8) + %add.1617 = s32[] add(s32[] %constant.1615, s32[] %constant.1616) + %constant.1618 = s32[] constant(0) + %select.1619 = s32[] select(pred[] %compare.1614, s32[] %add.1617, s32[] %constant.1618) + %dynamic-update-slice.1620 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.312, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.1582, s32[] %select.1587, s32[] %select.1595, s32[] %select.1603, /*index=5*/s32[] %select.1611, s32[] %select.1619) + %get-tuple-element.313 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=46 + %constant.638 = f32[] constant(2) + %broadcast.639 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[] %constant.638), dimensions={} + %multiply.640 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %broadcast.639, f32[16,32,32,8]{3,2,1,0} %slice.561) + %broadcast.1621 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %multiply.640), dimensions={1,2,3,4} + %constant.1622 = s32[] constant(0) + %compare.1623 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1622), direction=LT + %constant.1624 = s32[] constant(2) + %add.1625 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1624) + %select.1626 = s32[] select(pred[] %compare.1623, s32[] %add.1625, s32[] %get-tuple-element.276) + %constant.1627 = s32[] constant(0) + %constant.1628 = s32[] constant(0) + %compare.1629 = pred[] compare(s32[] %constant.1627, s32[] %constant.1628), direction=LT + %constant.1630 = s32[] constant(0) + %constant.1631 = s32[] constant(16) + %add.1632 = s32[] add(s32[] %constant.1630, s32[] %constant.1631) + %constant.1633 = s32[] constant(0) + %select.1634 = s32[] select(pred[] %compare.1629, s32[] %add.1632, s32[] %constant.1633) + %constant.1635 = s32[] constant(0) + %constant.1636 = s32[] constant(0) + %compare.1637 = pred[] compare(s32[] %constant.1635, s32[] %constant.1636), direction=LT + %constant.1638 = s32[] constant(0) + %constant.1639 = s32[] constant(32) + %add.1640 = s32[] add(s32[] %constant.1638, s32[] %constant.1639) + %constant.1641 = s32[] constant(0) + %select.1642 = s32[] select(pred[] %compare.1637, s32[] %add.1640, s32[] %constant.1641) + %constant.1643 = s32[] constant(0) + %constant.1644 = s32[] constant(0) + %compare.1645 = pred[] compare(s32[] %constant.1643, s32[] %constant.1644), direction=LT + %constant.1646 = s32[] constant(0) + %constant.1647 = s32[] constant(32) + %add.1648 = s32[] add(s32[] %constant.1646, s32[] %constant.1647) + %constant.1649 = s32[] constant(0) + %select.1650 = s32[] select(pred[] %compare.1645, s32[] %add.1648, s32[] %constant.1649) + %constant.1651 = s32[] constant(0) + %constant.1652 = s32[] constant(0) + %compare.1653 = pred[] compare(s32[] %constant.1651, s32[] %constant.1652), direction=LT + %constant.1654 = s32[] constant(0) + %constant.1655 = s32[] constant(8) + %add.1656 = s32[] add(s32[] %constant.1654, s32[] %constant.1655) + %constant.1657 = s32[] constant(0) + %select.1658 = s32[] select(pred[] %compare.1653, s32[] %add.1656, s32[] %constant.1657) + %dynamic-update-slice.1659 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.313, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.1621, s32[] %select.1626, s32[] %select.1634, s32[] %select.1642, /*index=5*/s32[] %select.1650, s32[] %select.1658) + %get-tuple-element.314 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=47 + %constant.642 = f32[] constant(-0.5) + %broadcast.643 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[] %constant.642), dimensions={} + %divide.641 = f32[16,32,32,8]{3,2,1,0} divide(f32[16,32,32,8]{3,2,1,0} %rsqrt.566, f32[16,32,32,8]{3,2,1,0} %add.565) + %multiply.644 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %broadcast.643, f32[16,32,32,8]{3,2,1,0} %divide.641) + %broadcast.1660 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %multiply.644), dimensions={1,2,3,4} + %constant.1661 = s32[] constant(0) + %compare.1662 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1661), direction=LT + %constant.1663 = s32[] constant(2) + %add.1664 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1663) + %select.1665 = s32[] select(pred[] %compare.1662, s32[] %add.1664, s32[] %get-tuple-element.276) + %constant.1666 = s32[] constant(0) + %constant.1667 = s32[] constant(0) + %compare.1668 = pred[] compare(s32[] %constant.1666, s32[] %constant.1667), direction=LT + %constant.1669 = s32[] constant(0) + %constant.1670 = s32[] constant(16) + %add.1671 = s32[] add(s32[] %constant.1669, s32[] %constant.1670) + %constant.1672 = s32[] constant(0) + %select.1673 = s32[] select(pred[] %compare.1668, s32[] %add.1671, s32[] %constant.1672) + %constant.1674 = s32[] constant(0) + %constant.1675 = s32[] constant(0) + %compare.1676 = pred[] compare(s32[] %constant.1674, s32[] %constant.1675), direction=LT + %constant.1677 = s32[] constant(0) + %constant.1678 = s32[] constant(32) + %add.1679 = s32[] add(s32[] %constant.1677, s32[] %constant.1678) + %constant.1680 = s32[] constant(0) + %select.1681 = s32[] select(pred[] %compare.1676, s32[] %add.1679, s32[] %constant.1680) + %constant.1682 = s32[] constant(0) + %constant.1683 = s32[] constant(0) + %compare.1684 = pred[] compare(s32[] %constant.1682, s32[] %constant.1683), direction=LT + %constant.1685 = s32[] constant(0) + %constant.1686 = s32[] constant(32) + %add.1687 = s32[] add(s32[] %constant.1685, s32[] %constant.1686) + %constant.1688 = s32[] constant(0) + %select.1689 = s32[] select(pred[] %compare.1684, s32[] %add.1687, s32[] %constant.1688) + %constant.1690 = s32[] constant(0) + %constant.1691 = s32[] constant(0) + %compare.1692 = pred[] compare(s32[] %constant.1690, s32[] %constant.1691), direction=LT + %constant.1693 = s32[] constant(0) + %constant.1694 = s32[] constant(8) + %add.1695 = s32[] add(s32[] %constant.1693, s32[] %constant.1694) + %constant.1696 = s32[] constant(0) + %select.1697 = s32[] select(pred[] %compare.1692, s32[] %add.1695, s32[] %constant.1696) + %dynamic-update-slice.1698 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.314, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.1660, s32[] %select.1665, s32[] %select.1673, s32[] %select.1681, /*index=5*/s32[] %select.1689, s32[] %select.1697) + %get-tuple-element.315 = f32[2,16,1,1,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=48 + %broadcast.1699 = f32[1,16,1,1,8]{4,3,2,1,0} broadcast(f32[16,1,1,8]{3,2,1,0} %broadcast.598), dimensions={1,2,3,4} + %constant.1700 = s32[] constant(0) + %compare.1701 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1700), direction=LT + %constant.1702 = s32[] constant(2) + %add.1703 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1702) + %select.1704 = s32[] select(pred[] %compare.1701, s32[] %add.1703, s32[] %get-tuple-element.276) + %constant.1705 = s32[] constant(0) + %constant.1706 = s32[] constant(0) + %compare.1707 = pred[] compare(s32[] %constant.1705, s32[] %constant.1706), direction=LT + %constant.1708 = s32[] constant(0) + %constant.1709 = s32[] constant(16) + %add.1710 = s32[] add(s32[] %constant.1708, s32[] %constant.1709) + %constant.1711 = s32[] constant(0) + %select.1712 = s32[] select(pred[] %compare.1707, s32[] %add.1710, s32[] %constant.1711) + %constant.1713 = s32[] constant(0) + %constant.1714 = s32[] constant(0) + %compare.1715 = pred[] compare(s32[] %constant.1713, s32[] %constant.1714), direction=LT + %constant.1716 = s32[] constant(0) + %constant.1717 = s32[] constant(1) + %add.1718 = s32[] add(s32[] %constant.1716, s32[] %constant.1717) + %constant.1719 = s32[] constant(0) + %select.1720 = s32[] select(pred[] %compare.1715, s32[] %add.1718, s32[] %constant.1719) + %constant.1721 = s32[] constant(0) + %constant.1722 = s32[] constant(0) + %compare.1723 = pred[] compare(s32[] %constant.1721, s32[] %constant.1722), direction=LT + %constant.1724 = s32[] constant(0) + %constant.1725 = s32[] constant(1) + %add.1726 = s32[] add(s32[] %constant.1724, s32[] %constant.1725) + %constant.1727 = s32[] constant(0) + %select.1728 = s32[] select(pred[] %compare.1723, s32[] %add.1726, s32[] %constant.1727) + %constant.1729 = s32[] constant(0) + %constant.1730 = s32[] constant(0) + %compare.1731 = pred[] compare(s32[] %constant.1729, s32[] %constant.1730), direction=LT + %constant.1732 = s32[] constant(0) + %constant.1733 = s32[] constant(8) + %add.1734 = s32[] add(s32[] %constant.1732, s32[] %constant.1733) + %constant.1735 = s32[] constant(0) + %select.1736 = s32[] select(pred[] %compare.1731, s32[] %add.1734, s32[] %constant.1735) + %dynamic-update-slice.1737 = f32[2,16,1,1,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,1,1,8]{4,3,2,1,0} %get-tuple-element.315, f32[1,16,1,1,8]{4,3,2,1,0} %broadcast.1699, s32[] %select.1704, s32[] %select.1712, s32[] %select.1720, /*index=5*/s32[] %select.1728, s32[] %select.1736) + %get-tuple-element.316 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=49 + %broadcast.1738 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %subtract.585), dimensions={1,2,3,4} + %constant.1739 = s32[] constant(0) + %compare.1740 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1739), direction=LT + %constant.1741 = s32[] constant(2) + %add.1742 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1741) + %select.1743 = s32[] select(pred[] %compare.1740, s32[] %add.1742, s32[] %get-tuple-element.276) + %constant.1744 = s32[] constant(0) + %constant.1745 = s32[] constant(0) + %compare.1746 = pred[] compare(s32[] %constant.1744, s32[] %constant.1745), direction=LT + %constant.1747 = s32[] constant(0) + %constant.1748 = s32[] constant(16) + %add.1749 = s32[] add(s32[] %constant.1747, s32[] %constant.1748) + %constant.1750 = s32[] constant(0) + %select.1751 = s32[] select(pred[] %compare.1746, s32[] %add.1749, s32[] %constant.1750) + %constant.1752 = s32[] constant(0) + %constant.1753 = s32[] constant(0) + %compare.1754 = pred[] compare(s32[] %constant.1752, s32[] %constant.1753), direction=LT + %constant.1755 = s32[] constant(0) + %constant.1756 = s32[] constant(32) + %add.1757 = s32[] add(s32[] %constant.1755, s32[] %constant.1756) + %constant.1758 = s32[] constant(0) + %select.1759 = s32[] select(pred[] %compare.1754, s32[] %add.1757, s32[] %constant.1758) + %constant.1760 = s32[] constant(0) + %constant.1761 = s32[] constant(0) + %compare.1762 = pred[] compare(s32[] %constant.1760, s32[] %constant.1761), direction=LT + %constant.1763 = s32[] constant(0) + %constant.1764 = s32[] constant(32) + %add.1765 = s32[] add(s32[] %constant.1763, s32[] %constant.1764) + %constant.1766 = s32[] constant(0) + %select.1767 = s32[] select(pred[] %compare.1762, s32[] %add.1765, s32[] %constant.1766) + %constant.1768 = s32[] constant(0) + %constant.1769 = s32[] constant(0) + %compare.1770 = pred[] compare(s32[] %constant.1768, s32[] %constant.1769), direction=LT + %constant.1771 = s32[] constant(0) + %constant.1772 = s32[] constant(8) + %add.1773 = s32[] add(s32[] %constant.1771, s32[] %constant.1772) + %constant.1774 = s32[] constant(0) + %select.1775 = s32[] select(pred[] %compare.1770, s32[] %add.1773, s32[] %constant.1774) + %dynamic-update-slice.1776 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.316, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.1738, s32[] %select.1743, s32[] %select.1751, s32[] %select.1759, /*index=5*/s32[] %select.1767, s32[] %select.1775) + %get-tuple-element.317 = f32[2,16,1024,8]{3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=50 + %constant.645 = f32[] constant(2) + %broadcast.646 = f32[16,1024,8]{2,1,0} broadcast(f32[] %constant.645), dimensions={} + %multiply.647 = f32[16,1024,8]{2,1,0} multiply(f32[16,1024,8]{2,1,0} %broadcast.646, f32[16,1024,8]{2,1,0} %reshape.576) + %broadcast.1777 = f32[1,16,1024,8]{3,2,1,0} broadcast(f32[16,1024,8]{2,1,0} %multiply.647), dimensions={1,2,3} + %constant.1778 = s32[] constant(0) + %compare.1779 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1778), direction=LT + %constant.1780 = s32[] constant(2) + %add.1781 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1780) + %select.1782 = s32[] select(pred[] %compare.1779, s32[] %add.1781, s32[] %get-tuple-element.276) + %constant.1783 = s32[] constant(0) + %constant.1784 = s32[] constant(0) + %compare.1785 = pred[] compare(s32[] %constant.1783, s32[] %constant.1784), direction=LT + %constant.1786 = s32[] constant(0) + %constant.1787 = s32[] constant(16) + %add.1788 = s32[] add(s32[] %constant.1786, s32[] %constant.1787) + %constant.1789 = s32[] constant(0) + %select.1790 = s32[] select(pred[] %compare.1785, s32[] %add.1788, s32[] %constant.1789) + %constant.1791 = s32[] constant(0) + %constant.1792 = s32[] constant(0) + %compare.1793 = pred[] compare(s32[] %constant.1791, s32[] %constant.1792), direction=LT + %constant.1794 = s32[] constant(0) + %constant.1795 = s32[] constant(1024) + %add.1796 = s32[] add(s32[] %constant.1794, s32[] %constant.1795) + %constant.1797 = s32[] constant(0) + %select.1798 = s32[] select(pred[] %compare.1793, s32[] %add.1796, s32[] %constant.1797) + %constant.1799 = s32[] constant(0) + %constant.1800 = s32[] constant(0) + %compare.1801 = pred[] compare(s32[] %constant.1799, s32[] %constant.1800), direction=LT + %constant.1802 = s32[] constant(0) + %constant.1803 = s32[] constant(8) + %add.1804 = s32[] add(s32[] %constant.1802, s32[] %constant.1803) + %constant.1805 = s32[] constant(0) + %select.1806 = s32[] select(pred[] %compare.1801, s32[] %add.1804, s32[] %constant.1805) + %dynamic-update-slice.1807 = f32[2,16,1024,8]{3,2,1,0} dynamic-update-slice(f32[2,16,1024,8]{3,2,1,0} %get-tuple-element.317, f32[1,16,1024,8]{3,2,1,0} %broadcast.1777, s32[] %select.1782, s32[] %select.1790, s32[] %select.1798, /*index=5*/s32[] %select.1806) + %get-tuple-element.318 = f32[2,16,8]{2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=51 + %constant.648 = f32[] constant(2) + %broadcast.649 = f32[16,8]{1,0} broadcast(f32[] %constant.648), dimensions={} + %multiply.650 = f32[16,8]{1,0} multiply(f32[16,8]{1,0} %broadcast.649, f32[16,8]{1,0} %divide.581) + %broadcast.1808 = f32[1,16,8]{2,1,0} broadcast(f32[16,8]{1,0} %multiply.650), dimensions={1,2} + %constant.1809 = s32[] constant(0) + %compare.1810 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1809), direction=LT + %constant.1811 = s32[] constant(2) + %add.1812 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1811) + %select.1813 = s32[] select(pred[] %compare.1810, s32[] %add.1812, s32[] %get-tuple-element.276) + %constant.1814 = s32[] constant(0) + %constant.1815 = s32[] constant(0) + %compare.1816 = pred[] compare(s32[] %constant.1814, s32[] %constant.1815), direction=LT + %constant.1817 = s32[] constant(0) + %constant.1818 = s32[] constant(16) + %add.1819 = s32[] add(s32[] %constant.1817, s32[] %constant.1818) + %constant.1820 = s32[] constant(0) + %select.1821 = s32[] select(pred[] %compare.1816, s32[] %add.1819, s32[] %constant.1820) + %constant.1822 = s32[] constant(0) + %constant.1823 = s32[] constant(0) + %compare.1824 = pred[] compare(s32[] %constant.1822, s32[] %constant.1823), direction=LT + %constant.1825 = s32[] constant(0) + %constant.1826 = s32[] constant(8) + %add.1827 = s32[] add(s32[] %constant.1825, s32[] %constant.1826) + %constant.1828 = s32[] constant(0) + %select.1829 = s32[] select(pred[] %compare.1824, s32[] %add.1827, s32[] %constant.1828) + %dynamic-update-slice.1830 = f32[2,16,8]{2,1,0} dynamic-update-slice(f32[2,16,8]{2,1,0} %get-tuple-element.318, f32[1,16,8]{2,1,0} %broadcast.1808, s32[] %select.1813, s32[] %select.1821, s32[] %select.1829) + %get-tuple-element.319 = f32[2,16,8]{2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=52 + %constant.652 = f32[] constant(-0.5) + %broadcast.653 = f32[16,8]{1,0} broadcast(f32[] %constant.652), dimensions={} + %divide.651 = f32[16,8]{1,0} divide(f32[16,8]{1,0} %rsqrt.597, f32[16,8]{1,0} %add.596) + %multiply.654 = f32[16,8]{1,0} multiply(f32[16,8]{1,0} %broadcast.653, f32[16,8]{1,0} %divide.651) + %broadcast.1831 = f32[1,16,8]{2,1,0} broadcast(f32[16,8]{1,0} %multiply.654), dimensions={1,2} + %constant.1832 = s32[] constant(0) + %compare.1833 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1832), direction=LT + %constant.1834 = s32[] constant(2) + %add.1835 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1834) + %select.1836 = s32[] select(pred[] %compare.1833, s32[] %add.1835, s32[] %get-tuple-element.276) + %constant.1837 = s32[] constant(0) + %constant.1838 = s32[] constant(0) + %compare.1839 = pred[] compare(s32[] %constant.1837, s32[] %constant.1838), direction=LT + %constant.1840 = s32[] constant(0) + %constant.1841 = s32[] constant(16) + %add.1842 = s32[] add(s32[] %constant.1840, s32[] %constant.1841) + %constant.1843 = s32[] constant(0) + %select.1844 = s32[] select(pred[] %compare.1839, s32[] %add.1842, s32[] %constant.1843) + %constant.1845 = s32[] constant(0) + %constant.1846 = s32[] constant(0) + %compare.1847 = pred[] compare(s32[] %constant.1845, s32[] %constant.1846), direction=LT + %constant.1848 = s32[] constant(0) + %constant.1849 = s32[] constant(8) + %add.1850 = s32[] add(s32[] %constant.1848, s32[] %constant.1849) + %constant.1851 = s32[] constant(0) + %select.1852 = s32[] select(pred[] %compare.1847, s32[] %add.1850, s32[] %constant.1851) + %dynamic-update-slice.1853 = f32[2,16,8]{2,1,0} dynamic-update-slice(f32[2,16,8]{2,1,0} %get-tuple-element.319, f32[1,16,8]{2,1,0} %broadcast.1831, s32[] %select.1836, s32[] %select.1844, s32[] %select.1852) + %get-tuple-element.320 = f32[2,1,1,1,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=53 + %broadcast.1854 = f32[1,1,1,1,8]{4,3,2,1,0} broadcast(f32[1,1,1,8]{3,2,1,0} %broadcast.602), dimensions={1,2,3,4} + %constant.1855 = s32[] constant(0) + %compare.1856 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1855), direction=LT + %constant.1857 = s32[] constant(2) + %add.1858 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1857) + %select.1859 = s32[] select(pred[] %compare.1856, s32[] %add.1858, s32[] %get-tuple-element.276) + %constant.1860 = s32[] constant(0) + %constant.1861 = s32[] constant(0) + %compare.1862 = pred[] compare(s32[] %constant.1860, s32[] %constant.1861), direction=LT + %constant.1863 = s32[] constant(0) + %constant.1864 = s32[] constant(1) + %add.1865 = s32[] add(s32[] %constant.1863, s32[] %constant.1864) + %constant.1866 = s32[] constant(0) + %select.1867 = s32[] select(pred[] %compare.1862, s32[] %add.1865, s32[] %constant.1866) + %constant.1868 = s32[] constant(0) + %constant.1869 = s32[] constant(0) + %compare.1870 = pred[] compare(s32[] %constant.1868, s32[] %constant.1869), direction=LT + %constant.1871 = s32[] constant(0) + %constant.1872 = s32[] constant(1) + %add.1873 = s32[] add(s32[] %constant.1871, s32[] %constant.1872) + %constant.1874 = s32[] constant(0) + %select.1875 = s32[] select(pred[] %compare.1870, s32[] %add.1873, s32[] %constant.1874) + %constant.1876 = s32[] constant(0) + %constant.1877 = s32[] constant(0) + %compare.1878 = pred[] compare(s32[] %constant.1876, s32[] %constant.1877), direction=LT + %constant.1879 = s32[] constant(0) + %constant.1880 = s32[] constant(1) + %add.1881 = s32[] add(s32[] %constant.1879, s32[] %constant.1880) + %constant.1882 = s32[] constant(0) + %select.1883 = s32[] select(pred[] %compare.1878, s32[] %add.1881, s32[] %constant.1882) + %constant.1884 = s32[] constant(0) + %constant.1885 = s32[] constant(0) + %compare.1886 = pred[] compare(s32[] %constant.1884, s32[] %constant.1885), direction=LT + %constant.1887 = s32[] constant(0) + %constant.1888 = s32[] constant(8) + %add.1889 = s32[] add(s32[] %constant.1887, s32[] %constant.1888) + %constant.1890 = s32[] constant(0) + %select.1891 = s32[] select(pred[] %compare.1886, s32[] %add.1889, s32[] %constant.1890) + %dynamic-update-slice.1892 = f32[2,1,1,1,8]{4,3,2,1,0} dynamic-update-slice(f32[2,1,1,1,8]{4,3,2,1,0} %get-tuple-element.320, f32[1,1,1,1,8]{4,3,2,1,0} %broadcast.1854, s32[] %select.1859, s32[] %select.1867, s32[] %select.1875, /*index=5*/s32[] %select.1883, s32[] %select.1891) + %get-tuple-element.321 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.266), index=54 + %broadcast.1893 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %multiply.601), dimensions={1,2,3,4} + %constant.1894 = s32[] constant(0) + %compare.1895 = pred[] compare(s32[] %get-tuple-element.276, s32[] %constant.1894), direction=LT + %constant.1896 = s32[] constant(2) + %add.1897 = s32[] add(s32[] %get-tuple-element.276, s32[] %constant.1896) + %select.1898 = s32[] select(pred[] %compare.1895, s32[] %add.1897, s32[] %get-tuple-element.276) + %constant.1899 = s32[] constant(0) + %constant.1900 = s32[] constant(0) + %compare.1901 = pred[] compare(s32[] %constant.1899, s32[] %constant.1900), direction=LT + %constant.1902 = s32[] constant(0) + %constant.1903 = s32[] constant(16) + %add.1904 = s32[] add(s32[] %constant.1902, s32[] %constant.1903) + %constant.1905 = s32[] constant(0) + %select.1906 = s32[] select(pred[] %compare.1901, s32[] %add.1904, s32[] %constant.1905) + %constant.1907 = s32[] constant(0) + %constant.1908 = s32[] constant(0) + %compare.1909 = pred[] compare(s32[] %constant.1907, s32[] %constant.1908), direction=LT + %constant.1910 = s32[] constant(0) + %constant.1911 = s32[] constant(32) + %add.1912 = s32[] add(s32[] %constant.1910, s32[] %constant.1911) + %constant.1913 = s32[] constant(0) + %select.1914 = s32[] select(pred[] %compare.1909, s32[] %add.1912, s32[] %constant.1913) + %constant.1915 = s32[] constant(0) + %constant.1916 = s32[] constant(0) + %compare.1917 = pred[] compare(s32[] %constant.1915, s32[] %constant.1916), direction=LT + %constant.1918 = s32[] constant(0) + %constant.1919 = s32[] constant(32) + %add.1920 = s32[] add(s32[] %constant.1918, s32[] %constant.1919) + %constant.1921 = s32[] constant(0) + %select.1922 = s32[] select(pred[] %compare.1917, s32[] %add.1920, s32[] %constant.1921) + %constant.1923 = s32[] constant(0) + %constant.1924 = s32[] constant(0) + %compare.1925 = pred[] compare(s32[] %constant.1923, s32[] %constant.1924), direction=LT + %constant.1926 = s32[] constant(0) + %constant.1927 = s32[] constant(8) + %add.1928 = s32[] add(s32[] %constant.1926, s32[] %constant.1927) + %constant.1929 = s32[] constant(0) + %select.1930 = s32[] select(pred[] %compare.1925, s32[] %add.1928, s32[] %constant.1929) + %dynamic-update-slice.1931 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.321, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.1893, s32[] %select.1898, s32[] %select.1906, s32[] %select.1914, /*index=5*/s32[] %select.1922, s32[] %select.1930) + ROOT %tuple.1943 = (u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) tuple(u32[2,2]{1,0} %get-tuple-element.267, f32[2,16]{1,0} %get-tuple-element.268, f32[2,16]{1,0} %get-tuple-element.269, f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.270, f32[2,16]{1,0} %get-tuple-element.271, /*index=5*/f32[2,16]{1,0} %get-tuple-element.272, f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.273, f32[2,8]{1,0} %get-tuple-element.274, f32[2,8]{1,0} %get-tuple-element.275, s32[] %add.1933, /*index=10*/f32[16,32,32,8]{3,2,1,0} %add.609, pred[] %constant.1934, pred[] %constant.1935, pred[] %constant.1936, pred[] %constant.1937, /*index=15*/pred[] %constant.1938, pred[] %constant.1939, pred[] %constant.1940, pred[] %constant.1941, pred[] %constant.1942, /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.693, f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.732, f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.771, f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.810, f32[2,3,3,8,16]{4,3,2,1,0} %dynamic-update-slice.849, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.888, f32[2,1,1,1,16]{4,3,2,1,0} %dynamic-update-slice.927, f32[2,3,3,8,16]{4,3,2,1,0} %dynamic-update-slice.966, f32[2,16]{1,0} %dynamic-update-slice.981, f32[2,1,1,1,16]{4,3,2,1,0} %dynamic-update-slice.1020, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0} %dynamic-update-slice.1059, f32[2,16,32,32,16]{4,3,2,1,0} %dynamic-update-slice.1098, f32[2,16,32,32,16]{4,3,2,1,0} %dynamic-update-slice.1137, f32[2,16,32,32,16]{4,3,2,1,0} %dynamic-update-slice.1176, f32[2,16,32,32,16]{4,3,2,1,0} %dynamic-update-slice.1215, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0} %dynamic-update-slice.1254, f32[2,16,32,32,16]{4,3,2,1,0} %dynamic-update-slice.1293, f32[2,1,1,1,16]{4,3,2,1,0} %dynamic-update-slice.1332, f32[2,1,1,16,16]{4,3,2,1,0} %dynamic-update-slice.1371, f32[2,16]{1,0} %dynamic-update-slice.1386, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0} %dynamic-update-slice.1425, f32[2,16,32,32,16]{4,3,2,1,0} %dynamic-update-slice.1464, f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.1503, f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.1542, f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.1581, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.1620, f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.1659, f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.1698, f32[2,16,1,1,8]{4,3,2,1,0} %dynamic-update-slice.1737, f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.1776, /*index=50*/f32[2,16,1024,8]{3,2,1,0} %dynamic-update-slice.1807, f32[2,16,8]{2,1,0} %dynamic-update-slice.1830, f32[2,16,8]{2,1,0} %dynamic-update-slice.1853, f32[2,1,1,1,8]{4,3,2,1,0} %dynamic-update-slice.1892, f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.1931) +} + +%cond_computation.1944 (parameter.1945: (u32[2,2], f32[2,16], f32[2,16], f32[2,3,3,8,16], f32[2,16], /*index=5*/f32[2,16], f32[2,1,1,16,16], f32[2,8], f32[2,8], s32[], /*index=10*/f32[16,32,32,8], pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,3,3,8,16], /*index=25*/f32[2,16,32,32,8], f32[2,1,1,1,16], f32[2,3,3,8,16], f32[2,16], f32[2,1,1,1,16], /*index=30*/f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], /*index=35*/f32[2,1,1,16,16], f32[2,16,32,32,16], f32[2,1,1,1,16], f32[2,1,1,16,16], f32[2,16], /*index=40*/f32[2,1,1,1,16], f32[2,16,32,32,16], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], /*index=45*/f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,1,1,8], f32[2,16,32,32,8], /*index=50*/f32[2,16,1024,8], f32[2,16,8], f32[2,16,8], f32[2,1,1,1,8], f32[2,16,32,32,8])) -> pred[] { + %parameter.1945 = (u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) parameter(0) + %get-tuple-element.1946 = u32[2,2]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=0 + %get-tuple-element.1947 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=1 + %get-tuple-element.1948 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=2 + %get-tuple-element.1949 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=3 + %get-tuple-element.1950 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=4 + %get-tuple-element.1951 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=5 + %get-tuple-element.1952 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=6 + %get-tuple-element.1953 = f32[2,8]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=7 + %get-tuple-element.1954 = f32[2,8]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=8 + %get-tuple-element.1956 = f32[16,32,32,8]{3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=10 + %get-tuple-element.1957 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=11 + %get-tuple-element.1958 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=12 + %get-tuple-element.1959 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=13 + %get-tuple-element.1960 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=14 + %get-tuple-element.1961 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=15 + %get-tuple-element.1962 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=16 + %get-tuple-element.1963 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=17 + %get-tuple-element.1964 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=18 + %get-tuple-element.1965 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=19 + %get-tuple-element.1966 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=20 + %get-tuple-element.1967 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=21 + %get-tuple-element.1968 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=22 + %get-tuple-element.1969 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=23 + %get-tuple-element.1970 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=24 + %get-tuple-element.1971 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=25 + %get-tuple-element.1972 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=26 + %get-tuple-element.1973 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=27 + %get-tuple-element.1974 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=28 + %get-tuple-element.1975 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=29 + %get-tuple-element.1976 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=30 + %get-tuple-element.1977 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=31 + %get-tuple-element.1978 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=32 + %get-tuple-element.1979 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=33 + %get-tuple-element.1980 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=34 + %get-tuple-element.1981 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=35 + %get-tuple-element.1982 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=36 + %get-tuple-element.1983 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=37 + %get-tuple-element.1984 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=38 + %get-tuple-element.1985 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=39 + %get-tuple-element.1986 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=40 + %get-tuple-element.1987 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=41 + %get-tuple-element.1988 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=42 + %get-tuple-element.1989 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=43 + %get-tuple-element.1990 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=44 + %get-tuple-element.1991 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=45 + %get-tuple-element.1992 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=46 + %get-tuple-element.1993 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=47 + %get-tuple-element.1994 = f32[2,16,1,1,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=48 + %get-tuple-element.1995 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=49 + %get-tuple-element.1996 = f32[2,16,1024,8]{3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=50 + %get-tuple-element.1997 = f32[2,16,8]{2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=51 + %get-tuple-element.1998 = f32[2,16,8]{2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=52 + %get-tuple-element.1999 = f32[2,1,1,1,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=53 + %get-tuple-element.2000 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=54 + %constant.2001 = pred[] constant(false) + %get-tuple-element.1955 = s32[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.1945), index=9 + %constant.2002 = s32[] constant(2) + ROOT %compare.2003 = pred[] compare(s32[] %get-tuple-element.1955, s32[] %constant.2002), direction=LT +} + +%primitive_computation_add__1.2158 (parameter.2159: f32[], parameter.2160: f32[]) -> f32[] { + %parameter.2159 = f32[] parameter(0) + %parameter.2160 = f32[] parameter(1) + ROOT %add.2161 = f32[] add(f32[] %parameter.2159, f32[] %parameter.2160) +} + +%primitive_computation_add__1.2229 (parameter.2230: f32[], parameter.2231: f32[]) -> f32[] { + %parameter.2230 = f32[] parameter(0) + %parameter.2231 = f32[] parameter(1) + ROOT %add.2232 = f32[] add(f32[] %parameter.2230, f32[] %parameter.2231) +} + +%jit__where__3.2244 (parameter.2245: pred[3,3], parameter.2246: f32[3,3], parameter.2247: f32[3,3]) -> (f32[3,3]) { + %constant.2248 = pred[] constant(false) + %parameter.2245 = pred[3,3]{1,0} parameter(0) + %parameter.2246 = f32[3,3]{1,0} parameter(1) + %parameter.2247 = f32[3,3]{1,0} parameter(2) + %select.2249 = f32[3,3]{1,0} select(pred[3,3]{1,0} %parameter.2245, f32[3,3]{1,0} %parameter.2246, f32[3,3]{1,0} %parameter.2247) + ROOT %tuple.2250 = (f32[3,3]{1,0}) tuple(f32[3,3]{1,0} %select.2249) +} + +%primitive_computation_add__1.2251 (parameter.2252: f32[], parameter.2253: f32[]) -> f32[] { + %parameter.2252 = f32[] parameter(0) + %parameter.2253 = f32[] parameter(1) + ROOT %add.2254 = f32[] add(f32[] %parameter.2252, f32[] %parameter.2253) +} + +%primitive_computation_or.2255 (parameter.2256: pred[], parameter.2257: pred[]) -> pred[] { + %parameter.2256 = pred[] parameter(0) + %parameter.2257 = pred[] parameter(1) + ROOT %or.2258 = pred[] or(pred[] %parameter.2256, pred[] %parameter.2257) +} + +%primitive_computation_add__2.2259 (parameter.2260: s32[], parameter.2261: s32[]) -> s32[] { + %parameter.2260 = s32[] parameter(0) + %parameter.2261 = s32[] parameter(1) + ROOT %add.2262 = s32[] add(s32[] %parameter.2260, s32[] %parameter.2261) +} + +%primitive_computation_add__2.2263 (parameter.2264: s32[], parameter.2265: s32[]) -> s32[] { + %parameter.2264 = s32[] parameter(0) + %parameter.2265 = s32[] parameter(1) + ROOT %add.2266 = s32[] add(s32[] %parameter.2264, s32[] %parameter.2265) +} + +%jit_remainder__1.2267 (parameter.2268: s32[], parameter.2269: s32[]) -> (s32[]) { + %constant.2270 = pred[] constant(false) + %parameter.2268 = s32[] parameter(0) + %parameter.2269 = s32[] parameter(1) + %convert.2271 = s32[] convert(s32[] %parameter.2269) + %remainder.2272 = s32[] remainder(s32[] %parameter.2268, s32[] %convert.2271) + %constant.2275 = s32[] constant(0) + %compare.2276 = pred[] compare(s32[] %remainder.2272, s32[] %constant.2275), direction=LT + %constant.2277 = s32[] constant(0) + %compare.2278 = pred[] compare(s32[] %convert.2271, s32[] %constant.2277), direction=LT + %compare.2279 = pred[] compare(pred[] %compare.2276, pred[] %compare.2278), direction=NE + %constant.2273 = s32[] constant(0) + %compare.2274 = pred[] compare(s32[] %remainder.2272, s32[] %constant.2273), direction=NE + %and.2280 = pred[] and(pred[] %compare.2279, pred[] %compare.2274) + %add.2281 = s32[] add(s32[] %remainder.2272, s32[] %convert.2271) + %select.2282 = s32[] select(pred[] %and.2280, s32[] %add.2281, s32[] %remainder.2272) + ROOT %tuple.2283 = (s32[]) tuple(s32[] %select.2282) +} + +%jit__where__4.2284 (parameter.2285: pred[], parameter.2286: f32[], parameter.2287: f32[]) -> (f32[]) { + %constant.2288 = pred[] constant(false) + %parameter.2285 = pred[] parameter(0) + %parameter.2286 = f32[] parameter(1) + %parameter.2287 = f32[] parameter(2) + %select.2289 = f32[] select(pred[] %parameter.2285, f32[] %parameter.2286, f32[] %parameter.2287) + ROOT %tuple.2290 = (f32[]) tuple(f32[] %select.2289) +} + +%primitive_computation_add__1.2291 (parameter.2292: f32[], parameter.2293: f32[]) -> f32[] { + %parameter.2292 = f32[] parameter(0) + %parameter.2293 = f32[] parameter(1) + ROOT %add.2294 = f32[] add(f32[] %parameter.2292, f32[] %parameter.2293) +} + +%jit__where__5.2295 (parameter.2296: pred[], parameter.2297: f32[], parameter.2298: f32[]) -> (f32[]) { + %constant.2299 = pred[] constant(false) + %parameter.2296 = pred[] parameter(0) + %parameter.2297 = f32[] parameter(1) + %parameter.2298 = f32[] parameter(2) + %select.2300 = f32[] select(pred[] %parameter.2296, f32[] %parameter.2297, f32[] %parameter.2298) + ROOT %tuple.2301 = (f32[]) tuple(f32[] %select.2300) +} + +%jit_slogdet__1.2302 (parameter.2303: f32[3,3]) -> (f32[], f32[]) { + %constant.2304 = pred[] constant(false) + %constant.2323 = pred[] constant(false) + %parameter.2303 = f32[3,3]{1,0} parameter(0) + %custom-call.2305 = (f32[3,3]{0,1}, s32[3]{0}, s32[], f32[4512]{0}) custom-call(f32[3,3]{1,0} %parameter.2303), custom_call_target="cusolver_getrf", operand_layout_constraints={f32[3,3]{0,1}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\000\000\000\000\001\000\000\000\003\000\000\000\003\000\000\000" + %get-tuple-element.2308 = s32[] get-tuple-element((f32[3,3]{0,1}, s32[3]{0}, s32[], f32[4512]{0}) %custom-call.2305), index=2 + %constant.2312 = s32[] constant(0) + %compare.2313 = pred[] compare(s32[] %get-tuple-element.2308, s32[] %constant.2312), direction=GE + %reshape.2314 = pred[1,1]{1,0} reshape(pred[] %compare.2313) + %broadcast.2317 = pred[1,1]{1,0} broadcast(pred[1,1]{1,0} %reshape.2314), dimensions={0,1} + %reshape.2318 = pred[] reshape(pred[1,1]{1,0} %broadcast.2317) + %broadcast.2319 = pred[3,3]{1,0} broadcast(pred[] %reshape.2318), dimensions={} + %get-tuple-element.2306 = f32[3,3]{0,1} get-tuple-element((f32[3,3]{0,1}, s32[3]{0}, s32[], f32[4512]{0}) %custom-call.2305), index=0 + %broadcast.2320 = f32[3,3]{1,0} broadcast(f32[3,3]{0,1} %get-tuple-element.2306), dimensions={0,1} + %constant.2315 = f32[] constant(nan) + %broadcast.2316 = f32[3,3]{1,0} broadcast(f32[] %constant.2315), dimensions={} + %broadcast.2321 = f32[3,3]{1,0} broadcast(f32[3,3]{1,0} %broadcast.2316), dimensions={0,1} + %select.2322 = f32[3,3]{1,0} select(pred[3,3]{1,0} %broadcast.2319, f32[3,3]{1,0} %broadcast.2320, f32[3,3]{1,0} %broadcast.2321) + %get-tuple-element.2307 = s32[3]{0} get-tuple-element((f32[3,3]{0,1}, s32[3]{0}, s32[], f32[4512]{0}) %custom-call.2305), index=1 + %constant.2309 = s32[] constant(1) + %broadcast.2310 = s32[3]{0} broadcast(s32[] %constant.2309), dimensions={} + %subtract.2311 = s32[3]{0} subtract(s32[3]{0} %get-tuple-element.2307, s32[3]{0} %broadcast.2310) + %custom-call.2324 = s32[3]{0} custom-call(s32[3]{0} %subtract.2311), custom_call_target="cuda_lu_pivots_to_permutation", operand_layout_constraints={s32[3]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\001\000\000\000\000\000\000\000\003\000\000\000\003\000\000\000" + %tuple.2325 = (f32[3,3]{1,0}, s32[3]{0}, s32[3]{0}) tuple(f32[3,3]{1,0} %select.2322, s32[3]{0} %subtract.2311, s32[3]{0} %custom-call.2324) + %get-tuple-element.2328 = s32[3]{0} get-tuple-element((f32[3,3]{1,0}, s32[3]{0}, s32[3]{0}) %tuple.2325), index=2 + %iota.2329 = s32[3,3] iota(), iota_dimension=0 + %constant.2330 = s32[] constant(0) + %broadcast.2331 = s32[3,3]{1,0} broadcast(s32[] %constant.2330), dimensions={} + %add.2332 = s32[3,3]{1,0} add(s32[3,3] %iota.2329, s32[3,3]{1,0} %broadcast.2331) + %iota.2333 = s32[3,3] iota(), iota_dimension=1 + %compare.2334 = pred[3,3]{1,0} compare(s32[3,3]{1,0} %add.2332, s32[3,3] %iota.2333), direction=EQ + %convert.2335 = pred[3,3]{1,0} convert(pred[3,3]{1,0} %compare.2334) + %get-tuple-element.2326 = f32[3,3]{1,0} get-tuple-element((f32[3,3]{1,0}, s32[3]{0}, s32[3]{0}) %tuple.2325), index=0 + %constant.2336 = f32[] constant(0) + %broadcast.2337 = f32[3,3]{1,0} broadcast(f32[] %constant.2336), dimensions={} + %call.2338 = (f32[3,3]{1,0}) call(pred[3,3]{1,0} %convert.2335, f32[3,3]{1,0} %get-tuple-element.2326, f32[3,3]{1,0} %broadcast.2337), to_apply=%jit__where__3.2244 + %get-tuple-element.2339 = f32[3,3]{1,0} get-tuple-element((f32[3,3]{1,0}) %call.2338), index=0 + %constant.2340 = f32[] constant(0) + %reduce.2341 = f32[3]{0} reduce(f32[3,3]{1,0} %get-tuple-element.2339, f32[] %constant.2340), dimensions={1}, to_apply=%primitive_computation_add__1.2251 + %slice.2342 = f32[3]{0} slice(f32[3]{0} %reduce.2341), slice={[0:3]} + %constant.2343 = f32[] constant(0) + %broadcast.2344 = f32[3]{0} broadcast(f32[] %constant.2343), dimensions={} + %compare.2345 = pred[3]{0} compare(f32[3]{0} %slice.2342, f32[3]{0} %broadcast.2344), direction=EQ + %constant.2346 = pred[] constant(false) + %reduce.2347 = pred[] reduce(pred[3]{0} %compare.2345, pred[] %constant.2346), dimensions={0}, to_apply=%primitive_computation_or.2255 + %constant.2376 = f32[] constant(0) + %constant.2374 = f32[] constant(1) + %get-tuple-element.2327 = s32[3]{0} get-tuple-element((f32[3,3]{1,0}, s32[3]{0}, s32[3]{0}) %tuple.2325), index=1 + %iota.2348 = s32[3] iota(), iota_dimension=0 + %compare.2349 = pred[3]{0} compare(s32[3]{0} %get-tuple-element.2327, s32[3] %iota.2348), direction=NE + %constant.2350 = pred[] constant(false) + %broadcast.2351 = pred[3]{0} broadcast(pred[] %constant.2350), dimensions={} + %compare.2352 = pred[3]{0} compare(pred[3]{0} %compare.2349, pred[3]{0} %broadcast.2351), direction=NE + %convert.2353 = s32[3]{0} convert(pred[3]{0} %compare.2352) + %constant.2354 = s32[] constant(0) + %reduce.2355 = s32[] reduce(s32[3]{0} %convert.2353, s32[] %constant.2354), dimensions={0}, to_apply=%primitive_computation_add__2.2259 + %constant.2356 = f32[] constant(0) + %broadcast.2357 = f32[3]{0} broadcast(f32[] %constant.2356), dimensions={} + %compare.2358 = pred[3]{0} compare(f32[3]{0} %slice.2342, f32[3]{0} %broadcast.2357), direction=LT + %constant.2359 = pred[] constant(false) + %broadcast.2360 = pred[3]{0} broadcast(pred[] %constant.2359), dimensions={} + %compare.2361 = pred[3]{0} compare(pred[3]{0} %compare.2358, pred[3]{0} %broadcast.2360), direction=NE + %convert.2362 = s32[3]{0} convert(pred[3]{0} %compare.2361) + %constant.2363 = s32[] constant(0) + %reduce.2364 = s32[] reduce(s32[3]{0} %convert.2362, s32[] %constant.2363), dimensions={0}, to_apply=%primitive_computation_add__2.2263 + %add.2365 = s32[] add(s32[] %reduce.2355, s32[] %reduce.2364) + %constant.2366 = s32[] constant(2) + %call.2367 = (s32[]) call(s32[] %add.2365, s32[] %constant.2366), to_apply=%jit_remainder__1.2267 + %get-tuple-element.2368 = s32[] get-tuple-element((s32[]) %call.2367), index=0 + %constant.2369 = s32[] constant(-2) + %multiply.2370 = s32[] multiply(s32[] %get-tuple-element.2368, s32[] %constant.2369) + %constant.2371 = s32[] constant(1) + %add.2372 = s32[] add(s32[] %multiply.2370, s32[] %constant.2371) + %convert.2373 = f32[] convert(s32[] %add.2372) + %multiply.2375 = f32[] multiply(f32[] %constant.2374, f32[] %convert.2373) + %call.2377 = (f32[]) call(pred[] %reduce.2347, f32[] %constant.2376, f32[] %multiply.2375), to_apply=%jit__where__4.2284 + %get-tuple-element.2378 = f32[] get-tuple-element((f32[]) %call.2377), index=0 + %constant.2383 = f32[] constant(-inf) + %abs.2379 = f32[3]{0} abs(f32[3]{0} %slice.2342) + %log.2380 = f32[3]{0} log(f32[3]{0} %abs.2379) + %constant.2381 = f32[] constant(0) + %reduce.2382 = f32[] reduce(f32[3]{0} %log.2380, f32[] %constant.2381), dimensions={0}, to_apply=%primitive_computation_add__1.2291 + %call.2384 = (f32[]) call(pred[] %reduce.2347, f32[] %constant.2383, f32[] %reduce.2382), to_apply=%jit__where__5.2295 + %get-tuple-element.2385 = f32[] get-tuple-element((f32[]) %call.2384), index=0 + ROOT %tuple.2386 = (f32[], f32[]) tuple(f32[] %get-tuple-element.2378, f32[] %get-tuple-element.2385) +} + +%jit_solve.2394 (parameter.2395: f32[3,3], parameter.2396: pred[]) -> (pred[], f32[3,3], f32[3,3], s32[3]) { + %parameter.2396 = pred[] parameter(1) + %constant.2397 = pred[] constant(false) + %constant.2416 = pred[] constant(false) + %parameter.2395 = f32[3,3]{1,0} parameter(0) + %custom-call.2398 = (f32[3,3]{0,1}, s32[3]{0}, s32[], f32[4512]{0}) custom-call(f32[3,3]{1,0} %parameter.2395), custom_call_target="cusolver_getrf", operand_layout_constraints={f32[3,3]{0,1}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\000\000\000\000\001\000\000\000\003\000\000\000\003\000\000\000" + %get-tuple-element.2401 = s32[] get-tuple-element((f32[3,3]{0,1}, s32[3]{0}, s32[], f32[4512]{0}) %custom-call.2398), index=2 + %constant.2405 = s32[] constant(0) + %compare.2406 = pred[] compare(s32[] %get-tuple-element.2401, s32[] %constant.2405), direction=GE + %reshape.2407 = pred[1,1]{1,0} reshape(pred[] %compare.2406) + %broadcast.2410 = pred[1,1]{1,0} broadcast(pred[1,1]{1,0} %reshape.2407), dimensions={0,1} + %reshape.2411 = pred[] reshape(pred[1,1]{1,0} %broadcast.2410) + %broadcast.2412 = pred[3,3]{1,0} broadcast(pred[] %reshape.2411), dimensions={} + %get-tuple-element.2399 = f32[3,3]{0,1} get-tuple-element((f32[3,3]{0,1}, s32[3]{0}, s32[], f32[4512]{0}) %custom-call.2398), index=0 + %broadcast.2413 = f32[3,3]{1,0} broadcast(f32[3,3]{0,1} %get-tuple-element.2399), dimensions={0,1} + %constant.2408 = f32[] constant(nan) + %broadcast.2409 = f32[3,3]{1,0} broadcast(f32[] %constant.2408), dimensions={} + %broadcast.2414 = f32[3,3]{1,0} broadcast(f32[3,3]{1,0} %broadcast.2409), dimensions={0,1} + %select.2415 = f32[3,3]{1,0} select(pred[3,3]{1,0} %broadcast.2412, f32[3,3]{1,0} %broadcast.2413, f32[3,3]{1,0} %broadcast.2414) + %get-tuple-element.2400 = s32[3]{0} get-tuple-element((f32[3,3]{0,1}, s32[3]{0}, s32[], f32[4512]{0}) %custom-call.2398), index=1 + %constant.2402 = s32[] constant(1) + %broadcast.2403 = s32[3]{0} broadcast(s32[] %constant.2402), dimensions={} + %subtract.2404 = s32[3]{0} subtract(s32[3]{0} %get-tuple-element.2400, s32[3]{0} %broadcast.2403) + %custom-call.2417 = s32[3]{0} custom-call(s32[3]{0} %subtract.2404), custom_call_target="cuda_lu_pivots_to_permutation", operand_layout_constraints={s32[3]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\001\000\000\000\000\000\000\000\003\000\000\000\003\000\000\000" + %tuple.2418 = (f32[3,3]{1,0}, s32[3]{0}, s32[3]{0}) tuple(f32[3,3]{1,0} %select.2415, s32[3]{0} %subtract.2404, s32[3]{0} %custom-call.2417) + %get-tuple-element.2420 = s32[3]{0} get-tuple-element((f32[3,3]{1,0}, s32[3]{0}, s32[3]{0}) %tuple.2418), index=1 + %constant.2422 = pred[] constant(false) + %get-tuple-element.2419 = f32[3,3]{1,0} get-tuple-element((f32[3,3]{1,0}, s32[3]{0}, s32[3]{0}) %tuple.2418), index=0 + %get-tuple-element.2421 = s32[3]{0} get-tuple-element((f32[3,3]{1,0}, s32[3]{0}, s32[3]{0}) %tuple.2418), index=2 + ROOT %tuple.2423 = (pred[], f32[3,3]{1,0}, f32[3,3]{1,0}, s32[3]{0}) tuple(pred[] %constant.2422, f32[3,3]{1,0} %parameter.2395, f32[3,3]{1,0} %get-tuple-element.2419, s32[3]{0} %get-tuple-element.2421) +} + +%jit__where__6.2439 (parameter.2440: pred[3,3], parameter.2441: pred[], parameter.2442: f32[3,3]) -> (pred[], pred[3,3], f32[3,3]) { + %parameter.2441 = pred[] parameter(1) + %constant.2443 = pred[] constant(false) + %constant.2444 = pred[] constant(false) + %parameter.2440 = pred[3,3]{1,0} parameter(0) + %parameter.2442 = f32[3,3]{1,0} parameter(2) + ROOT %tuple.2445 = (pred[], pred[3,3]{1,0}, f32[3,3]{1,0}) tuple(pred[] %constant.2444, pred[3,3]{1,0} %parameter.2440, f32[3,3]{1,0} %parameter.2442) +} + +%primitive_computation_add__1.2514 (parameter.2515: f32[], parameter.2516: f32[]) -> f32[] { + %parameter.2515 = f32[] parameter(0) + %parameter.2516 = f32[] parameter(1) + ROOT %add.2517 = f32[] add(f32[] %parameter.2515, f32[] %parameter.2516) +} + +%primitive_computation_add__1.2649 (parameter.2650: f32[], parameter.2651: f32[]) -> f32[] { + %parameter.2650 = f32[] parameter(0) + %parameter.2651 = f32[] parameter(1) + ROOT %add.2652 = f32[] add(f32[] %parameter.2650, f32[] %parameter.2651) +} + +%primitive_computation_add__1.2653 (parameter.2654: f32[], parameter.2655: f32[]) -> f32[] { + %parameter.2654 = f32[] parameter(0) + %parameter.2655 = f32[] parameter(1) + ROOT %add.2656 = f32[] add(f32[] %parameter.2654, f32[] %parameter.2655) +} + +%primitive_computation_add__1.2657 (parameter.2658: f32[], parameter.2659: f32[]) -> f32[] { + %parameter.2658 = f32[] parameter(0) + %parameter.2659 = f32[] parameter(1) + ROOT %add.2660 = f32[] add(f32[] %parameter.2658, f32[] %parameter.2659) +} + +%primitive_computation_add__1.2661 (parameter.2662: f32[], parameter.2663: f32[]) -> f32[] { + %parameter.2662 = f32[] parameter(0) + %parameter.2663 = f32[] parameter(1) + ROOT %add.2664 = f32[] add(f32[] %parameter.2662, f32[] %parameter.2663) +} + +%body_computation__1.2665 (parameter.2666: (u32[2,2], f32[2,16], f32[2,16], f32[2,3,3,8,16], f32[2,16], /*index=5*/f32[2,16], f32[2,1,1,16,16], f32[2,8], f32[2,8], s32[], /*index=10*/f32[16,32,32,8], pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,3,3,8,16], /*index=25*/f32[2,16,32,32,8], f32[2,1,1,1,16], f32[2,3,3,8,16], f32[2,16], f32[2,1,1,1,16], /*index=30*/f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], /*index=35*/f32[2,1,1,16,16], f32[2,16,32,32,16], f32[2,1,1,1,16], f32[2,1,1,16,16], f32[2,16], /*index=40*/f32[2,1,1,1,16], f32[2,16,32,32,16], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], /*index=45*/f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,1,1,8], f32[2,16,32,32,8], /*index=50*/f32[2,16,1024,8], f32[2,16,8], f32[2,16,8], f32[2,1,1,1,8], f32[2,16,32,32,8])) -> (u32[2,2], f32[2,16], f32[2,16], f32[2,3,3,8,16], f32[2,16], /*index=5*/f32[2,16], f32[2,1,1,16,16], f32[2,8], f32[2,8], s32[], /*index=10*/f32[16,32,32,8], pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,3,3,8,16], /*index=25*/f32[2,16,32,32,8], f32[2,1,1,1,16], f32[2,3,3,8,16], f32[2,16], f32[2,1,1,1,16], /*index=30*/f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], /*index=35*/f32[2,1,1,16,16], f32[2,16,32,32,16], f32[2,1,1,1,16], f32[2,1,1,16,16], f32[2,16], /*index=40*/f32[2,1,1,1,16], f32[2,16,32,32,16], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], /*index=45*/f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,1,1,8], f32[2,16,32,32,8], /*index=50*/f32[2,16,1024,8], f32[2,16,8], f32[2,16,8], f32[2,1,1,1,8], f32[2,16,32,32,8]) { + %parameter.2666 = (u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) parameter(0) + %get-tuple-element.2678 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=11 + %get-tuple-element.2679 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=12 + %get-tuple-element.2680 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=13 + %get-tuple-element.2681 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=14 + %get-tuple-element.2682 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=15 + %get-tuple-element.2683 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=16 + %get-tuple-element.2684 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=17 + %get-tuple-element.2685 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=18 + %get-tuple-element.2686 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=19 + %constant.2722 = pred[] constant(false) + %get-tuple-element.2667 = u32[2,2]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=0 + %get-tuple-element.2676 = s32[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=9 + %constant.2723 = s32[] constant(0) + %compare.2724 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.2723), direction=LT + %constant.2725 = s32[] constant(2) + %add.2726 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.2725) + %select.2727 = s32[] select(pred[] %compare.2724, s32[] %add.2726, s32[] %get-tuple-element.2676) + %constant.2728 = s32[] constant(0) + %constant.2729 = s32[] constant(0) + %compare.2730 = pred[] compare(s32[] %constant.2728, s32[] %constant.2729), direction=LT + %constant.2731 = s32[] constant(0) + %constant.2732 = s32[] constant(2) + %add.2733 = s32[] add(s32[] %constant.2731, s32[] %constant.2732) + %constant.2734 = s32[] constant(0) + %select.2735 = s32[] select(pred[] %compare.2730, s32[] %add.2733, s32[] %constant.2734) + %dynamic-slice.2736 = u32[1,2]{1,0} dynamic-slice(u32[2,2]{1,0} %get-tuple-element.2667, s32[] %select.2727, s32[] %select.2735), dynamic_slice_sizes={1,2} + %reshape.2737 = u32[2]{0} reshape(u32[1,2]{1,0} %dynamic-slice.2736) + %get-tuple-element.2668 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=1 + %get-tuple-element.2669 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=2 + %get-tuple-element.2670 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=3 + %get-tuple-element.2671 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=4 + %get-tuple-element.2672 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=5 + %get-tuple-element.2673 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=6 + %get-tuple-element.2674 = f32[2,8]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=7 + %get-tuple-element.2675 = f32[2,8]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=8 + %constant.4332 = s32[] constant(1) + %add.4333 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.4332) + %get-tuple-element.2677 = f32[16,32,32,8]{3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=10 + %multiply.2906 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %get-tuple-element.2677, f32[16,32,32,8]{3,2,1,0} %get-tuple-element.2677) + %constant.2907 = f32[] constant(2) + %broadcast.2908 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[] %constant.2907), dimensions={} + %add.2909 = f32[16,32,32,8]{3,2,1,0} add(f32[16,32,32,8]{3,2,1,0} %multiply.2906, f32[16,32,32,8]{3,2,1,0} %broadcast.2908) + %rsqrt.2910 = f32[16,32,32,8]{3,2,1,0} rsqrt(f32[16,32,32,8]{3,2,1,0} %add.2909) + %multiply.2911 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %multiply.2906, f32[16,32,32,8]{3,2,1,0} %rsqrt.2910) + %add.2912 = f32[16,32,32,8]{3,2,1,0} add(f32[16,32,32,8]{3,2,1,0} %get-tuple-element.2677, f32[16,32,32,8]{3,2,1,0} %multiply.2911) + %constant.2913 = f32[] constant(0.5) + %broadcast.2914 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[] %constant.2913), dimensions={} + %multiply.2915 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %add.2912, f32[16,32,32,8]{3,2,1,0} %broadcast.2914) + %constant.2768 = s32[] constant(0) + %compare.2769 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.2768), direction=LT + %constant.2770 = s32[] constant(2) + %add.2771 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.2770) + %select.2772 = s32[] select(pred[] %compare.2769, s32[] %add.2771, s32[] %get-tuple-element.2676) + %constant.2773 = s32[] constant(0) + %constant.2774 = s32[] constant(0) + %compare.2775 = pred[] compare(s32[] %constant.2773, s32[] %constant.2774), direction=LT + %constant.2776 = s32[] constant(0) + %constant.2777 = s32[] constant(3) + %add.2778 = s32[] add(s32[] %constant.2776, s32[] %constant.2777) + %constant.2779 = s32[] constant(0) + %select.2780 = s32[] select(pred[] %compare.2775, s32[] %add.2778, s32[] %constant.2779) + %constant.2781 = s32[] constant(0) + %constant.2782 = s32[] constant(0) + %compare.2783 = pred[] compare(s32[] %constant.2781, s32[] %constant.2782), direction=LT + %constant.2784 = s32[] constant(0) + %constant.2785 = s32[] constant(3) + %add.2786 = s32[] add(s32[] %constant.2784, s32[] %constant.2785) + %constant.2787 = s32[] constant(0) + %select.2788 = s32[] select(pred[] %compare.2783, s32[] %add.2786, s32[] %constant.2787) + %constant.2789 = s32[] constant(0) + %constant.2790 = s32[] constant(0) + %compare.2791 = pred[] compare(s32[] %constant.2789, s32[] %constant.2790), direction=LT + %constant.2792 = s32[] constant(0) + %constant.2793 = s32[] constant(8) + %add.2794 = s32[] add(s32[] %constant.2792, s32[] %constant.2793) + %constant.2795 = s32[] constant(0) + %select.2796 = s32[] select(pred[] %compare.2791, s32[] %add.2794, s32[] %constant.2795) + %constant.2797 = s32[] constant(0) + %constant.2798 = s32[] constant(0) + %compare.2799 = pred[] compare(s32[] %constant.2797, s32[] %constant.2798), direction=LT + %constant.2800 = s32[] constant(0) + %constant.2801 = s32[] constant(16) + %add.2802 = s32[] add(s32[] %constant.2800, s32[] %constant.2801) + %constant.2803 = s32[] constant(0) + %select.2804 = s32[] select(pred[] %compare.2799, s32[] %add.2802, s32[] %constant.2803) + %dynamic-slice.2805 = f32[1,3,3,8,16]{4,3,2,1,0} dynamic-slice(f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.2670, s32[] %select.2772, s32[] %select.2780, s32[] %select.2788, s32[] %select.2796, /*index=5*/s32[] %select.2804), dynamic_slice_sizes={1,3,3,8,16} + %reshape.2806 = f32[3,3,8,16]{3,2,1,0} reshape(f32[1,3,3,8,16]{4,3,2,1,0} %dynamic-slice.2805) + %multiply.2916 = f32[3,3,8,16]{3,2,1,0} multiply(f32[3,3,8,16]{3,2,1,0} %reshape.2806, f32[3,3,8,16]{3,2,1,0} %reshape.2806) + %constant.2917 = f32[] constant(0) + %reduce.2918 = f32[16]{0} reduce(f32[3,3,8,16]{3,2,1,0} %multiply.2916, f32[] %constant.2917), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.2649 + %rsqrt.2919 = f32[16]{0} rsqrt(f32[16]{0} %reduce.2918) + %broadcast.2920 = f32[1,1,1,16]{3,2,1,0} broadcast(f32[16]{0} %rsqrt.2919), dimensions={3} + %reshape.2921 = f32[16]{0} reshape(f32[1,1,1,16]{3,2,1,0} %broadcast.2920) + %broadcast.2922 = f32[3,3,8,16]{3,2,1,0} broadcast(f32[16]{0} %reshape.2921), dimensions={3} + %multiply.2923 = f32[3,3,8,16]{3,2,1,0} multiply(f32[3,3,8,16]{3,2,1,0} %reshape.2806, f32[3,3,8,16]{3,2,1,0} %broadcast.2922) + %convolution.2924 = f32[16,32,32,16]{3,2,1,0} convolution(f32[16,32,32,8]{3,2,1,0} %multiply.2915, f32[3,3,8,16]{3,2,1,0} %multiply.2923), window={size=3x3 pad=1_1x1_1}, dim_labels=b01f_01io->b01f + %constant.2753 = s32[] constant(0) + %compare.2754 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.2753), direction=LT + %constant.2755 = s32[] constant(2) + %add.2756 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.2755) + %select.2757 = s32[] select(pred[] %compare.2754, s32[] %add.2756, s32[] %get-tuple-element.2676) + %constant.2758 = s32[] constant(0) + %constant.2759 = s32[] constant(0) + %compare.2760 = pred[] compare(s32[] %constant.2758, s32[] %constant.2759), direction=LT + %constant.2761 = s32[] constant(0) + %constant.2762 = s32[] constant(16) + %add.2763 = s32[] add(s32[] %constant.2761, s32[] %constant.2762) + %constant.2764 = s32[] constant(0) + %select.2765 = s32[] select(pred[] %compare.2760, s32[] %add.2763, s32[] %constant.2764) + %dynamic-slice.2766 = f32[1,16]{1,0} dynamic-slice(f32[2,16]{1,0} %get-tuple-element.2669, s32[] %select.2757, s32[] %select.2765), dynamic_slice_sizes={1,16} + %reshape.2767 = f32[16]{0} reshape(f32[1,16]{1,0} %dynamic-slice.2766) + %broadcast.2925 = f32[1,1,1,16]{3,2,1,0} broadcast(f32[16]{0} %reshape.2767), dimensions={3} + %reshape.2926 = f32[16]{0} reshape(f32[1,1,1,16]{3,2,1,0} %broadcast.2925) + %broadcast.2927 = f32[16,32,32,16]{3,2,1,0} broadcast(f32[16]{0} %reshape.2926), dimensions={3} + %multiply.2928 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %convolution.2924, f32[16,32,32,16]{3,2,1,0} %broadcast.2927) + %constant.2738 = s32[] constant(0) + %compare.2739 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.2738), direction=LT + %constant.2740 = s32[] constant(2) + %add.2741 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.2740) + %select.2742 = s32[] select(pred[] %compare.2739, s32[] %add.2741, s32[] %get-tuple-element.2676) + %constant.2743 = s32[] constant(0) + %constant.2744 = s32[] constant(0) + %compare.2745 = pred[] compare(s32[] %constant.2743, s32[] %constant.2744), direction=LT + %constant.2746 = s32[] constant(0) + %constant.2747 = s32[] constant(16) + %add.2748 = s32[] add(s32[] %constant.2746, s32[] %constant.2747) + %constant.2749 = s32[] constant(0) + %select.2750 = s32[] select(pred[] %compare.2745, s32[] %add.2748, s32[] %constant.2749) + %dynamic-slice.2751 = f32[1,16]{1,0} dynamic-slice(f32[2,16]{1,0} %get-tuple-element.2668, s32[] %select.2742, s32[] %select.2750), dynamic_slice_sizes={1,16} + %reshape.2752 = f32[16]{0} reshape(f32[1,16]{1,0} %dynamic-slice.2751) + %broadcast.2929 = f32[1,1,1,16]{3,2,1,0} broadcast(f32[16]{0} %reshape.2752), dimensions={3} + %reshape.2930 = f32[16]{0} reshape(f32[1,1,1,16]{3,2,1,0} %broadcast.2929) + %broadcast.2931 = f32[16,32,32,16]{3,2,1,0} broadcast(f32[16]{0} %reshape.2930), dimensions={3} + %add.2932 = f32[16,32,32,16]{3,2,1,0} add(f32[16,32,32,16]{3,2,1,0} %multiply.2928, f32[16,32,32,16]{3,2,1,0} %broadcast.2931) + %multiply.2933 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %add.2932, f32[16,32,32,16]{3,2,1,0} %add.2932) + %constant.2934 = f32[] constant(2) + %broadcast.2935 = f32[16,32,32,16]{3,2,1,0} broadcast(f32[] %constant.2934), dimensions={} + %add.2936 = f32[16,32,32,16]{3,2,1,0} add(f32[16,32,32,16]{3,2,1,0} %multiply.2933, f32[16,32,32,16]{3,2,1,0} %broadcast.2935) + %rsqrt.2937 = f32[16,32,32,16]{3,2,1,0} rsqrt(f32[16,32,32,16]{3,2,1,0} %add.2936) + %multiply.2938 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %multiply.2933, f32[16,32,32,16]{3,2,1,0} %rsqrt.2937) + %add.2939 = f32[16,32,32,16]{3,2,1,0} add(f32[16,32,32,16]{3,2,1,0} %add.2932, f32[16,32,32,16]{3,2,1,0} %multiply.2938) + %constant.2940 = f32[] constant(0.5) + %broadcast.2941 = f32[16,32,32,16]{3,2,1,0} broadcast(f32[] %constant.2940), dimensions={} + %multiply.2942 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %add.2939, f32[16,32,32,16]{3,2,1,0} %broadcast.2941) + %constant.2837 = s32[] constant(0) + %compare.2838 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.2837), direction=LT + %constant.2839 = s32[] constant(2) + %add.2840 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.2839) + %select.2841 = s32[] select(pred[] %compare.2838, s32[] %add.2840, s32[] %get-tuple-element.2676) + %constant.2842 = s32[] constant(0) + %constant.2843 = s32[] constant(0) + %compare.2844 = pred[] compare(s32[] %constant.2842, s32[] %constant.2843), direction=LT + %constant.2845 = s32[] constant(0) + %constant.2846 = s32[] constant(1) + %add.2847 = s32[] add(s32[] %constant.2845, s32[] %constant.2846) + %constant.2848 = s32[] constant(0) + %select.2849 = s32[] select(pred[] %compare.2844, s32[] %add.2847, s32[] %constant.2848) + %constant.2850 = s32[] constant(0) + %constant.2851 = s32[] constant(0) + %compare.2852 = pred[] compare(s32[] %constant.2850, s32[] %constant.2851), direction=LT + %constant.2853 = s32[] constant(0) + %constant.2854 = s32[] constant(1) + %add.2855 = s32[] add(s32[] %constant.2853, s32[] %constant.2854) + %constant.2856 = s32[] constant(0) + %select.2857 = s32[] select(pred[] %compare.2852, s32[] %add.2855, s32[] %constant.2856) + %constant.2858 = s32[] constant(0) + %constant.2859 = s32[] constant(0) + %compare.2860 = pred[] compare(s32[] %constant.2858, s32[] %constant.2859), direction=LT + %constant.2861 = s32[] constant(0) + %constant.2862 = s32[] constant(16) + %add.2863 = s32[] add(s32[] %constant.2861, s32[] %constant.2862) + %constant.2864 = s32[] constant(0) + %select.2865 = s32[] select(pred[] %compare.2860, s32[] %add.2863, s32[] %constant.2864) + %constant.2866 = s32[] constant(0) + %constant.2867 = s32[] constant(0) + %compare.2868 = pred[] compare(s32[] %constant.2866, s32[] %constant.2867), direction=LT + %constant.2869 = s32[] constant(0) + %constant.2870 = s32[] constant(16) + %add.2871 = s32[] add(s32[] %constant.2869, s32[] %constant.2870) + %constant.2872 = s32[] constant(0) + %select.2873 = s32[] select(pred[] %compare.2868, s32[] %add.2871, s32[] %constant.2872) + %dynamic-slice.2874 = f32[1,1,1,16,16]{4,3,2,1,0} dynamic-slice(f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.2673, s32[] %select.2841, s32[] %select.2849, s32[] %select.2857, s32[] %select.2865, /*index=5*/s32[] %select.2873), dynamic_slice_sizes={1,1,1,16,16} + %reshape.2875 = f32[1,1,16,16]{3,2,1,0} reshape(f32[1,1,1,16,16]{4,3,2,1,0} %dynamic-slice.2874) + %multiply.2943 = f32[1,1,16,16]{3,2,1,0} multiply(f32[1,1,16,16]{3,2,1,0} %reshape.2875, f32[1,1,16,16]{3,2,1,0} %reshape.2875) + %constant.2944 = f32[] constant(0) + %reduce.2945 = f32[16]{0} reduce(f32[1,1,16,16]{3,2,1,0} %multiply.2943, f32[] %constant.2944), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.2653 + %rsqrt.2946 = f32[16]{0} rsqrt(f32[16]{0} %reduce.2945) + %broadcast.2947 = f32[1,1,1,16]{3,2,1,0} broadcast(f32[16]{0} %rsqrt.2946), dimensions={3} + %reshape.2948 = f32[1,1,16]{2,1,0} reshape(f32[1,1,1,16]{3,2,1,0} %broadcast.2947) + %broadcast.2949 = f32[1,1,16,16]{3,2,1,0} broadcast(f32[1,1,16]{2,1,0} %reshape.2948), dimensions={0,1,3} + %multiply.2950 = f32[1,1,16,16]{3,2,1,0} multiply(f32[1,1,16,16]{3,2,1,0} %reshape.2875, f32[1,1,16,16]{3,2,1,0} %broadcast.2949) + %convolution.2951 = f32[16,32,32,16]{3,2,1,0} convolution(f32[16,32,32,16]{3,2,1,0} %multiply.2942, f32[1,1,16,16]{3,2,1,0} %multiply.2950), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.2822 = s32[] constant(0) + %compare.2823 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.2822), direction=LT + %constant.2824 = s32[] constant(2) + %add.2825 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.2824) + %select.2826 = s32[] select(pred[] %compare.2823, s32[] %add.2825, s32[] %get-tuple-element.2676) + %constant.2827 = s32[] constant(0) + %constant.2828 = s32[] constant(0) + %compare.2829 = pred[] compare(s32[] %constant.2827, s32[] %constant.2828), direction=LT + %constant.2830 = s32[] constant(0) + %constant.2831 = s32[] constant(16) + %add.2832 = s32[] add(s32[] %constant.2830, s32[] %constant.2831) + %constant.2833 = s32[] constant(0) + %select.2834 = s32[] select(pred[] %compare.2829, s32[] %add.2832, s32[] %constant.2833) + %dynamic-slice.2835 = f32[1,16]{1,0} dynamic-slice(f32[2,16]{1,0} %get-tuple-element.2672, s32[] %select.2826, s32[] %select.2834), dynamic_slice_sizes={1,16} + %reshape.2836 = f32[16]{0} reshape(f32[1,16]{1,0} %dynamic-slice.2835) + %broadcast.2952 = f32[1,1,1,16]{3,2,1,0} broadcast(f32[16]{0} %reshape.2836), dimensions={3} + %reshape.2953 = f32[16]{0} reshape(f32[1,1,1,16]{3,2,1,0} %broadcast.2952) + %broadcast.2954 = f32[16,32,32,16]{3,2,1,0} broadcast(f32[16]{0} %reshape.2953), dimensions={3} + %multiply.2955 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %convolution.2951, f32[16,32,32,16]{3,2,1,0} %broadcast.2954) + %constant.2807 = s32[] constant(0) + %compare.2808 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.2807), direction=LT + %constant.2809 = s32[] constant(2) + %add.2810 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.2809) + %select.2811 = s32[] select(pred[] %compare.2808, s32[] %add.2810, s32[] %get-tuple-element.2676) + %constant.2812 = s32[] constant(0) + %constant.2813 = s32[] constant(0) + %compare.2814 = pred[] compare(s32[] %constant.2812, s32[] %constant.2813), direction=LT + %constant.2815 = s32[] constant(0) + %constant.2816 = s32[] constant(16) + %add.2817 = s32[] add(s32[] %constant.2815, s32[] %constant.2816) + %constant.2818 = s32[] constant(0) + %select.2819 = s32[] select(pred[] %compare.2814, s32[] %add.2817, s32[] %constant.2818) + %dynamic-slice.2820 = f32[1,16]{1,0} dynamic-slice(f32[2,16]{1,0} %get-tuple-element.2671, s32[] %select.2811, s32[] %select.2819), dynamic_slice_sizes={1,16} + %reshape.2821 = f32[16]{0} reshape(f32[1,16]{1,0} %dynamic-slice.2820) + %broadcast.2956 = f32[1,1,1,16]{3,2,1,0} broadcast(f32[16]{0} %reshape.2821), dimensions={3} + %reshape.2957 = f32[16]{0} reshape(f32[1,1,1,16]{3,2,1,0} %broadcast.2956) + %broadcast.2958 = f32[16,32,32,16]{3,2,1,0} broadcast(f32[16]{0} %reshape.2957), dimensions={3} + %add.2959 = f32[16,32,32,16]{3,2,1,0} add(f32[16,32,32,16]{3,2,1,0} %multiply.2955, f32[16,32,32,16]{3,2,1,0} %broadcast.2958) + %slice.2960 = f32[16,32,32,8]{3,2,1,0} slice(f32[16,32,32,16]{3,2,1,0} %add.2959), slice={[0:16], [0:32], [0:32], [0:8]} + %slice.2961 = f32[16,32,32,8]{3,2,1,0} slice(f32[16,32,32,16]{3,2,1,0} %add.2959), slice={[0:16], [0:32], [0:32], [8:16]} + %multiply.2962 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %slice.2961, f32[16,32,32,8]{3,2,1,0} %slice.2961) + %constant.2963 = f32[] constant(2) + %broadcast.2964 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[] %constant.2963), dimensions={} + %add.2965 = f32[16,32,32,8]{3,2,1,0} add(f32[16,32,32,8]{3,2,1,0} %multiply.2962, f32[16,32,32,8]{3,2,1,0} %broadcast.2964) + %rsqrt.2966 = f32[16,32,32,8]{3,2,1,0} rsqrt(f32[16,32,32,8]{3,2,1,0} %add.2965) + %multiply.2967 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %slice.2961, f32[16,32,32,8]{3,2,1,0} %rsqrt.2966) + %constant.2968 = f32[] constant(1) + %broadcast.2969 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[] %constant.2968), dimensions={} + %add.2970 = f32[16,32,32,8]{3,2,1,0} add(f32[16,32,32,8]{3,2,1,0} %multiply.2967, f32[16,32,32,8]{3,2,1,0} %broadcast.2969) + %constant.2971 = f32[] constant(0.5) + %broadcast.2972 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[] %constant.2971), dimensions={} + %multiply.2973 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %add.2970, f32[16,32,32,8]{3,2,1,0} %broadcast.2972) + %multiply.2974 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %slice.2960, f32[16,32,32,8]{3,2,1,0} %multiply.2973) + %add.2975 = f32[16,32,32,8]{3,2,1,0} add(f32[16,32,32,8]{3,2,1,0} %get-tuple-element.2677, f32[16,32,32,8]{3,2,1,0} %multiply.2974) + %reshape.2976 = f32[16,1024,8]{2,1,0} reshape(f32[16,32,32,8]{3,2,1,0} %add.2975) + %constant.2977 = f32[] constant(0) + %reduce.2978 = f32[16,8]{1,0} reduce(f32[16,1024,8]{2,1,0} %reshape.2976, f32[] %constant.2977), dimensions={1}, to_apply=%primitive_computation_add__1.2657 + %constant.2979 = f32[] constant(1024) + %broadcast.2980 = f32[16,8]{1,0} broadcast(f32[] %constant.2979), dimensions={} + %divide.2981 = f32[16,8]{1,0} divide(f32[16,8]{1,0} %reduce.2978, f32[16,8]{1,0} %broadcast.2980) + %broadcast.2982 = f32[16,1,1,8]{3,2,1,0} broadcast(f32[16,8]{1,0} %divide.2981), dimensions={0,3} + %reshape.2983 = f32[16,8]{1,0} reshape(f32[16,1,1,8]{3,2,1,0} %broadcast.2982) + %broadcast.2984 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[16,8]{1,0} %reshape.2983), dimensions={0,3} + %subtract.2985 = f32[16,32,32,8]{3,2,1,0} subtract(f32[16,32,32,8]{3,2,1,0} %add.2975, f32[16,32,32,8]{3,2,1,0} %broadcast.2984) + %multiply.2986 = f32[16,1024,8]{2,1,0} multiply(f32[16,1024,8]{2,1,0} %reshape.2976, f32[16,1024,8]{2,1,0} %reshape.2976) + %constant.2987 = f32[] constant(0) + %reduce.2988 = f32[16,8]{1,0} reduce(f32[16,1024,8]{2,1,0} %multiply.2986, f32[] %constant.2987), dimensions={1}, to_apply=%primitive_computation_add__1.2661 + %constant.2989 = f32[] constant(1024) + %broadcast.2990 = f32[16,8]{1,0} broadcast(f32[] %constant.2989), dimensions={} + %divide.2991 = f32[16,8]{1,0} divide(f32[16,8]{1,0} %reduce.2988, f32[16,8]{1,0} %broadcast.2990) + %multiply.2992 = f32[16,8]{1,0} multiply(f32[16,8]{1,0} %divide.2981, f32[16,8]{1,0} %divide.2981) + %subtract.2993 = f32[16,8]{1,0} subtract(f32[16,8]{1,0} %divide.2991, f32[16,8]{1,0} %multiply.2992) + %constant.2994 = f32[] constant(1e-06) + %broadcast.2995 = f32[16,8]{1,0} broadcast(f32[] %constant.2994), dimensions={} + %add.2996 = f32[16,8]{1,0} add(f32[16,8]{1,0} %subtract.2993, f32[16,8]{1,0} %broadcast.2995) + %rsqrt.2997 = f32[16,8]{1,0} rsqrt(f32[16,8]{1,0} %add.2996) + %broadcast.2998 = f32[16,1,1,8]{3,2,1,0} broadcast(f32[16,8]{1,0} %rsqrt.2997), dimensions={0,3} + %reshape.2999 = f32[16,8]{1,0} reshape(f32[16,1,1,8]{3,2,1,0} %broadcast.2998) + %broadcast.3000 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[16,8]{1,0} %reshape.2999), dimensions={0,3} + %multiply.3001 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %subtract.2985, f32[16,32,32,8]{3,2,1,0} %broadcast.3000) + %constant.2891 = s32[] constant(0) + %compare.2892 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.2891), direction=LT + %constant.2893 = s32[] constant(2) + %add.2894 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.2893) + %select.2895 = s32[] select(pred[] %compare.2892, s32[] %add.2894, s32[] %get-tuple-element.2676) + %constant.2896 = s32[] constant(0) + %constant.2897 = s32[] constant(0) + %compare.2898 = pred[] compare(s32[] %constant.2896, s32[] %constant.2897), direction=LT + %constant.2899 = s32[] constant(0) + %constant.2900 = s32[] constant(8) + %add.2901 = s32[] add(s32[] %constant.2899, s32[] %constant.2900) + %constant.2902 = s32[] constant(0) + %select.2903 = s32[] select(pred[] %compare.2898, s32[] %add.2901, s32[] %constant.2902) + %dynamic-slice.2904 = f32[1,8]{1,0} dynamic-slice(f32[2,8]{1,0} %get-tuple-element.2675, s32[] %select.2895, s32[] %select.2903), dynamic_slice_sizes={1,8} + %reshape.2905 = f32[8]{0} reshape(f32[1,8]{1,0} %dynamic-slice.2904) + %broadcast.3002 = f32[1,1,1,8]{3,2,1,0} broadcast(f32[8]{0} %reshape.2905), dimensions={3} + %reshape.3003 = f32[8]{0} reshape(f32[1,1,1,8]{3,2,1,0} %broadcast.3002) + %broadcast.3004 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[8]{0} %reshape.3003), dimensions={3} + %multiply.3005 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %multiply.3001, f32[16,32,32,8]{3,2,1,0} %broadcast.3004) + %constant.2876 = s32[] constant(0) + %compare.2877 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.2876), direction=LT + %constant.2878 = s32[] constant(2) + %add.2879 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.2878) + %select.2880 = s32[] select(pred[] %compare.2877, s32[] %add.2879, s32[] %get-tuple-element.2676) + %constant.2881 = s32[] constant(0) + %constant.2882 = s32[] constant(0) + %compare.2883 = pred[] compare(s32[] %constant.2881, s32[] %constant.2882), direction=LT + %constant.2884 = s32[] constant(0) + %constant.2885 = s32[] constant(8) + %add.2886 = s32[] add(s32[] %constant.2884, s32[] %constant.2885) + %constant.2887 = s32[] constant(0) + %select.2888 = s32[] select(pred[] %compare.2883, s32[] %add.2886, s32[] %constant.2887) + %dynamic-slice.2889 = f32[1,8]{1,0} dynamic-slice(f32[2,8]{1,0} %get-tuple-element.2674, s32[] %select.2880, s32[] %select.2888), dynamic_slice_sizes={1,8} + %reshape.2890 = f32[8]{0} reshape(f32[1,8]{1,0} %dynamic-slice.2889) + %broadcast.3006 = f32[1,1,1,8]{3,2,1,0} broadcast(f32[8]{0} %reshape.2890), dimensions={3} + %reshape.3007 = f32[8]{0} reshape(f32[1,1,1,8]{3,2,1,0} %broadcast.3006) + %broadcast.3008 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[8]{0} %reshape.3007), dimensions={3} + %add.3009 = f32[16,32,32,8]{3,2,1,0} add(f32[16,32,32,8]{3,2,1,0} %multiply.3005, f32[16,32,32,8]{3,2,1,0} %broadcast.3008) + %constant.4334 = pred[] constant(false) + %constant.4335 = pred[] constant(false) + %constant.4336 = pred[] constant(false) + %constant.4337 = pred[] constant(false) + %constant.4338 = pred[] constant(false) + %constant.4339 = pred[] constant(false) + %constant.4340 = pred[] constant(false) + %constant.4341 = pred[] constant(false) + %constant.4342 = pred[] constant(false) + %get-tuple-element.2687 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=20 + %constant.3010 = f32[] constant(2) + %broadcast.3011 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[] %constant.3010), dimensions={} + %multiply.3012 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %broadcast.3011, f32[16,32,32,8]{3,2,1,0} %get-tuple-element.2677) + %broadcast.3055 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %multiply.3012), dimensions={1,2,3,4} + %constant.3056 = s32[] constant(0) + %compare.3057 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3056), direction=LT + %constant.3058 = s32[] constant(2) + %add.3059 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3058) + %select.3060 = s32[] select(pred[] %compare.3057, s32[] %add.3059, s32[] %get-tuple-element.2676) + %constant.3061 = s32[] constant(0) + %constant.3062 = s32[] constant(0) + %compare.3063 = pred[] compare(s32[] %constant.3061, s32[] %constant.3062), direction=LT + %constant.3064 = s32[] constant(0) + %constant.3065 = s32[] constant(16) + %add.3066 = s32[] add(s32[] %constant.3064, s32[] %constant.3065) + %constant.3067 = s32[] constant(0) + %select.3068 = s32[] select(pred[] %compare.3063, s32[] %add.3066, s32[] %constant.3067) + %constant.3069 = s32[] constant(0) + %constant.3070 = s32[] constant(0) + %compare.3071 = pred[] compare(s32[] %constant.3069, s32[] %constant.3070), direction=LT + %constant.3072 = s32[] constant(0) + %constant.3073 = s32[] constant(32) + %add.3074 = s32[] add(s32[] %constant.3072, s32[] %constant.3073) + %constant.3075 = s32[] constant(0) + %select.3076 = s32[] select(pred[] %compare.3071, s32[] %add.3074, s32[] %constant.3075) + %constant.3077 = s32[] constant(0) + %constant.3078 = s32[] constant(0) + %compare.3079 = pred[] compare(s32[] %constant.3077, s32[] %constant.3078), direction=LT + %constant.3080 = s32[] constant(0) + %constant.3081 = s32[] constant(32) + %add.3082 = s32[] add(s32[] %constant.3080, s32[] %constant.3081) + %constant.3083 = s32[] constant(0) + %select.3084 = s32[] select(pred[] %compare.3079, s32[] %add.3082, s32[] %constant.3083) + %constant.3085 = s32[] constant(0) + %constant.3086 = s32[] constant(0) + %compare.3087 = pred[] compare(s32[] %constant.3085, s32[] %constant.3086), direction=LT + %constant.3088 = s32[] constant(0) + %constant.3089 = s32[] constant(8) + %add.3090 = s32[] add(s32[] %constant.3088, s32[] %constant.3089) + %constant.3091 = s32[] constant(0) + %select.3092 = s32[] select(pred[] %compare.3087, s32[] %add.3090, s32[] %constant.3091) + %dynamic-update-slice.3093 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2687, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.3055, s32[] %select.3060, s32[] %select.3068, s32[] %select.3076, /*index=5*/s32[] %select.3084, s32[] %select.3092) + %get-tuple-element.2688 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=21 + %broadcast.3094 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %rsqrt.2910), dimensions={1,2,3,4} + %constant.3095 = s32[] constant(0) + %compare.3096 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3095), direction=LT + %constant.3097 = s32[] constant(2) + %add.3098 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3097) + %select.3099 = s32[] select(pred[] %compare.3096, s32[] %add.3098, s32[] %get-tuple-element.2676) + %constant.3100 = s32[] constant(0) + %constant.3101 = s32[] constant(0) + %compare.3102 = pred[] compare(s32[] %constant.3100, s32[] %constant.3101), direction=LT + %constant.3103 = s32[] constant(0) + %constant.3104 = s32[] constant(16) + %add.3105 = s32[] add(s32[] %constant.3103, s32[] %constant.3104) + %constant.3106 = s32[] constant(0) + %select.3107 = s32[] select(pred[] %compare.3102, s32[] %add.3105, s32[] %constant.3106) + %constant.3108 = s32[] constant(0) + %constant.3109 = s32[] constant(0) + %compare.3110 = pred[] compare(s32[] %constant.3108, s32[] %constant.3109), direction=LT + %constant.3111 = s32[] constant(0) + %constant.3112 = s32[] constant(32) + %add.3113 = s32[] add(s32[] %constant.3111, s32[] %constant.3112) + %constant.3114 = s32[] constant(0) + %select.3115 = s32[] select(pred[] %compare.3110, s32[] %add.3113, s32[] %constant.3114) + %constant.3116 = s32[] constant(0) + %constant.3117 = s32[] constant(0) + %compare.3118 = pred[] compare(s32[] %constant.3116, s32[] %constant.3117), direction=LT + %constant.3119 = s32[] constant(0) + %constant.3120 = s32[] constant(32) + %add.3121 = s32[] add(s32[] %constant.3119, s32[] %constant.3120) + %constant.3122 = s32[] constant(0) + %select.3123 = s32[] select(pred[] %compare.3118, s32[] %add.3121, s32[] %constant.3122) + %constant.3124 = s32[] constant(0) + %constant.3125 = s32[] constant(0) + %compare.3126 = pred[] compare(s32[] %constant.3124, s32[] %constant.3125), direction=LT + %constant.3127 = s32[] constant(0) + %constant.3128 = s32[] constant(8) + %add.3129 = s32[] add(s32[] %constant.3127, s32[] %constant.3128) + %constant.3130 = s32[] constant(0) + %select.3131 = s32[] select(pred[] %compare.3126, s32[] %add.3129, s32[] %constant.3130) + %dynamic-update-slice.3132 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2688, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.3094, s32[] %select.3099, s32[] %select.3107, s32[] %select.3115, /*index=5*/s32[] %select.3123, s32[] %select.3131) + %get-tuple-element.2689 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=22 + %broadcast.3133 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %multiply.2906), dimensions={1,2,3,4} + %constant.3134 = s32[] constant(0) + %compare.3135 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3134), direction=LT + %constant.3136 = s32[] constant(2) + %add.3137 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3136) + %select.3138 = s32[] select(pred[] %compare.3135, s32[] %add.3137, s32[] %get-tuple-element.2676) + %constant.3139 = s32[] constant(0) + %constant.3140 = s32[] constant(0) + %compare.3141 = pred[] compare(s32[] %constant.3139, s32[] %constant.3140), direction=LT + %constant.3142 = s32[] constant(0) + %constant.3143 = s32[] constant(16) + %add.3144 = s32[] add(s32[] %constant.3142, s32[] %constant.3143) + %constant.3145 = s32[] constant(0) + %select.3146 = s32[] select(pred[] %compare.3141, s32[] %add.3144, s32[] %constant.3145) + %constant.3147 = s32[] constant(0) + %constant.3148 = s32[] constant(0) + %compare.3149 = pred[] compare(s32[] %constant.3147, s32[] %constant.3148), direction=LT + %constant.3150 = s32[] constant(0) + %constant.3151 = s32[] constant(32) + %add.3152 = s32[] add(s32[] %constant.3150, s32[] %constant.3151) + %constant.3153 = s32[] constant(0) + %select.3154 = s32[] select(pred[] %compare.3149, s32[] %add.3152, s32[] %constant.3153) + %constant.3155 = s32[] constant(0) + %constant.3156 = s32[] constant(0) + %compare.3157 = pred[] compare(s32[] %constant.3155, s32[] %constant.3156), direction=LT + %constant.3158 = s32[] constant(0) + %constant.3159 = s32[] constant(32) + %add.3160 = s32[] add(s32[] %constant.3158, s32[] %constant.3159) + %constant.3161 = s32[] constant(0) + %select.3162 = s32[] select(pred[] %compare.3157, s32[] %add.3160, s32[] %constant.3161) + %constant.3163 = s32[] constant(0) + %constant.3164 = s32[] constant(0) + %compare.3165 = pred[] compare(s32[] %constant.3163, s32[] %constant.3164), direction=LT + %constant.3166 = s32[] constant(0) + %constant.3167 = s32[] constant(8) + %add.3168 = s32[] add(s32[] %constant.3166, s32[] %constant.3167) + %constant.3169 = s32[] constant(0) + %select.3170 = s32[] select(pred[] %compare.3165, s32[] %add.3168, s32[] %constant.3169) + %dynamic-update-slice.3171 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2689, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.3133, s32[] %select.3138, s32[] %select.3146, s32[] %select.3154, /*index=5*/s32[] %select.3162, s32[] %select.3170) + %get-tuple-element.2690 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=23 + %constant.3014 = f32[] constant(-0.5) + %broadcast.3015 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[] %constant.3014), dimensions={} + %divide.3013 = f32[16,32,32,8]{3,2,1,0} divide(f32[16,32,32,8]{3,2,1,0} %rsqrt.2910, f32[16,32,32,8]{3,2,1,0} %add.2909) + %multiply.3016 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %broadcast.3015, f32[16,32,32,8]{3,2,1,0} %divide.3013) + %broadcast.3172 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %multiply.3016), dimensions={1,2,3,4} + %constant.3173 = s32[] constant(0) + %compare.3174 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3173), direction=LT + %constant.3175 = s32[] constant(2) + %add.3176 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3175) + %select.3177 = s32[] select(pred[] %compare.3174, s32[] %add.3176, s32[] %get-tuple-element.2676) + %constant.3178 = s32[] constant(0) + %constant.3179 = s32[] constant(0) + %compare.3180 = pred[] compare(s32[] %constant.3178, s32[] %constant.3179), direction=LT + %constant.3181 = s32[] constant(0) + %constant.3182 = s32[] constant(16) + %add.3183 = s32[] add(s32[] %constant.3181, s32[] %constant.3182) + %constant.3184 = s32[] constant(0) + %select.3185 = s32[] select(pred[] %compare.3180, s32[] %add.3183, s32[] %constant.3184) + %constant.3186 = s32[] constant(0) + %constant.3187 = s32[] constant(0) + %compare.3188 = pred[] compare(s32[] %constant.3186, s32[] %constant.3187), direction=LT + %constant.3189 = s32[] constant(0) + %constant.3190 = s32[] constant(32) + %add.3191 = s32[] add(s32[] %constant.3189, s32[] %constant.3190) + %constant.3192 = s32[] constant(0) + %select.3193 = s32[] select(pred[] %compare.3188, s32[] %add.3191, s32[] %constant.3192) + %constant.3194 = s32[] constant(0) + %constant.3195 = s32[] constant(0) + %compare.3196 = pred[] compare(s32[] %constant.3194, s32[] %constant.3195), direction=LT + %constant.3197 = s32[] constant(0) + %constant.3198 = s32[] constant(32) + %add.3199 = s32[] add(s32[] %constant.3197, s32[] %constant.3198) + %constant.3200 = s32[] constant(0) + %select.3201 = s32[] select(pred[] %compare.3196, s32[] %add.3199, s32[] %constant.3200) + %constant.3202 = s32[] constant(0) + %constant.3203 = s32[] constant(0) + %compare.3204 = pred[] compare(s32[] %constant.3202, s32[] %constant.3203), direction=LT + %constant.3205 = s32[] constant(0) + %constant.3206 = s32[] constant(8) + %add.3207 = s32[] add(s32[] %constant.3205, s32[] %constant.3206) + %constant.3208 = s32[] constant(0) + %select.3209 = s32[] select(pred[] %compare.3204, s32[] %add.3207, s32[] %constant.3208) + %dynamic-update-slice.3210 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2690, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.3172, s32[] %select.3177, s32[] %select.3185, s32[] %select.3193, /*index=5*/s32[] %select.3201, s32[] %select.3209) + %get-tuple-element.2691 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=24 + %broadcast.3211 = f32[1,3,3,8,16]{4,3,2,1,0} broadcast(f32[3,3,8,16]{3,2,1,0} %multiply.2923), dimensions={1,2,3,4} + %constant.3212 = s32[] constant(0) + %compare.3213 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3212), direction=LT + %constant.3214 = s32[] constant(2) + %add.3215 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3214) + %select.3216 = s32[] select(pred[] %compare.3213, s32[] %add.3215, s32[] %get-tuple-element.2676) + %constant.3217 = s32[] constant(0) + %constant.3218 = s32[] constant(0) + %compare.3219 = pred[] compare(s32[] %constant.3217, s32[] %constant.3218), direction=LT + %constant.3220 = s32[] constant(0) + %constant.3221 = s32[] constant(3) + %add.3222 = s32[] add(s32[] %constant.3220, s32[] %constant.3221) + %constant.3223 = s32[] constant(0) + %select.3224 = s32[] select(pred[] %compare.3219, s32[] %add.3222, s32[] %constant.3223) + %constant.3225 = s32[] constant(0) + %constant.3226 = s32[] constant(0) + %compare.3227 = pred[] compare(s32[] %constant.3225, s32[] %constant.3226), direction=LT + %constant.3228 = s32[] constant(0) + %constant.3229 = s32[] constant(3) + %add.3230 = s32[] add(s32[] %constant.3228, s32[] %constant.3229) + %constant.3231 = s32[] constant(0) + %select.3232 = s32[] select(pred[] %compare.3227, s32[] %add.3230, s32[] %constant.3231) + %constant.3233 = s32[] constant(0) + %constant.3234 = s32[] constant(0) + %compare.3235 = pred[] compare(s32[] %constant.3233, s32[] %constant.3234), direction=LT + %constant.3236 = s32[] constant(0) + %constant.3237 = s32[] constant(8) + %add.3238 = s32[] add(s32[] %constant.3236, s32[] %constant.3237) + %constant.3239 = s32[] constant(0) + %select.3240 = s32[] select(pred[] %compare.3235, s32[] %add.3238, s32[] %constant.3239) + %constant.3241 = s32[] constant(0) + %constant.3242 = s32[] constant(0) + %compare.3243 = pred[] compare(s32[] %constant.3241, s32[] %constant.3242), direction=LT + %constant.3244 = s32[] constant(0) + %constant.3245 = s32[] constant(16) + %add.3246 = s32[] add(s32[] %constant.3244, s32[] %constant.3245) + %constant.3247 = s32[] constant(0) + %select.3248 = s32[] select(pred[] %compare.3243, s32[] %add.3246, s32[] %constant.3247) + %dynamic-update-slice.3249 = f32[2,3,3,8,16]{4,3,2,1,0} dynamic-update-slice(f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.2691, f32[1,3,3,8,16]{4,3,2,1,0} %broadcast.3211, s32[] %select.3216, s32[] %select.3224, s32[] %select.3232, /*index=5*/s32[] %select.3240, s32[] %select.3248) + %get-tuple-element.2692 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=25 + %broadcast.3250 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %multiply.2915), dimensions={1,2,3,4} + %constant.3251 = s32[] constant(0) + %compare.3252 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3251), direction=LT + %constant.3253 = s32[] constant(2) + %add.3254 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3253) + %select.3255 = s32[] select(pred[] %compare.3252, s32[] %add.3254, s32[] %get-tuple-element.2676) + %constant.3256 = s32[] constant(0) + %constant.3257 = s32[] constant(0) + %compare.3258 = pred[] compare(s32[] %constant.3256, s32[] %constant.3257), direction=LT + %constant.3259 = s32[] constant(0) + %constant.3260 = s32[] constant(16) + %add.3261 = s32[] add(s32[] %constant.3259, s32[] %constant.3260) + %constant.3262 = s32[] constant(0) + %select.3263 = s32[] select(pred[] %compare.3258, s32[] %add.3261, s32[] %constant.3262) + %constant.3264 = s32[] constant(0) + %constant.3265 = s32[] constant(0) + %compare.3266 = pred[] compare(s32[] %constant.3264, s32[] %constant.3265), direction=LT + %constant.3267 = s32[] constant(0) + %constant.3268 = s32[] constant(32) + %add.3269 = s32[] add(s32[] %constant.3267, s32[] %constant.3268) + %constant.3270 = s32[] constant(0) + %select.3271 = s32[] select(pred[] %compare.3266, s32[] %add.3269, s32[] %constant.3270) + %constant.3272 = s32[] constant(0) + %constant.3273 = s32[] constant(0) + %compare.3274 = pred[] compare(s32[] %constant.3272, s32[] %constant.3273), direction=LT + %constant.3275 = s32[] constant(0) + %constant.3276 = s32[] constant(32) + %add.3277 = s32[] add(s32[] %constant.3275, s32[] %constant.3276) + %constant.3278 = s32[] constant(0) + %select.3279 = s32[] select(pred[] %compare.3274, s32[] %add.3277, s32[] %constant.3278) + %constant.3280 = s32[] constant(0) + %constant.3281 = s32[] constant(0) + %compare.3282 = pred[] compare(s32[] %constant.3280, s32[] %constant.3281), direction=LT + %constant.3283 = s32[] constant(0) + %constant.3284 = s32[] constant(8) + %add.3285 = s32[] add(s32[] %constant.3283, s32[] %constant.3284) + %constant.3286 = s32[] constant(0) + %select.3287 = s32[] select(pred[] %compare.3282, s32[] %add.3285, s32[] %constant.3286) + %dynamic-update-slice.3288 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2692, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.3250, s32[] %select.3255, s32[] %select.3263, s32[] %select.3271, /*index=5*/s32[] %select.3279, s32[] %select.3287) + %get-tuple-element.2693 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=26 + %broadcast.3289 = f32[1,1,1,1,16]{4,3,2,1,0} broadcast(f32[1,1,1,16]{3,2,1,0} %broadcast.2920), dimensions={1,2,3,4} + %constant.3290 = s32[] constant(0) + %compare.3291 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3290), direction=LT + %constant.3292 = s32[] constant(2) + %add.3293 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3292) + %select.3294 = s32[] select(pred[] %compare.3291, s32[] %add.3293, s32[] %get-tuple-element.2676) + %constant.3295 = s32[] constant(0) + %constant.3296 = s32[] constant(0) + %compare.3297 = pred[] compare(s32[] %constant.3295, s32[] %constant.3296), direction=LT + %constant.3298 = s32[] constant(0) + %constant.3299 = s32[] constant(1) + %add.3300 = s32[] add(s32[] %constant.3298, s32[] %constant.3299) + %constant.3301 = s32[] constant(0) + %select.3302 = s32[] select(pred[] %compare.3297, s32[] %add.3300, s32[] %constant.3301) + %constant.3303 = s32[] constant(0) + %constant.3304 = s32[] constant(0) + %compare.3305 = pred[] compare(s32[] %constant.3303, s32[] %constant.3304), direction=LT + %constant.3306 = s32[] constant(0) + %constant.3307 = s32[] constant(1) + %add.3308 = s32[] add(s32[] %constant.3306, s32[] %constant.3307) + %constant.3309 = s32[] constant(0) + %select.3310 = s32[] select(pred[] %compare.3305, s32[] %add.3308, s32[] %constant.3309) + %constant.3311 = s32[] constant(0) + %constant.3312 = s32[] constant(0) + %compare.3313 = pred[] compare(s32[] %constant.3311, s32[] %constant.3312), direction=LT + %constant.3314 = s32[] constant(0) + %constant.3315 = s32[] constant(1) + %add.3316 = s32[] add(s32[] %constant.3314, s32[] %constant.3315) + %constant.3317 = s32[] constant(0) + %select.3318 = s32[] select(pred[] %compare.3313, s32[] %add.3316, s32[] %constant.3317) + %constant.3319 = s32[] constant(0) + %constant.3320 = s32[] constant(0) + %compare.3321 = pred[] compare(s32[] %constant.3319, s32[] %constant.3320), direction=LT + %constant.3322 = s32[] constant(0) + %constant.3323 = s32[] constant(16) + %add.3324 = s32[] add(s32[] %constant.3322, s32[] %constant.3323) + %constant.3325 = s32[] constant(0) + %select.3326 = s32[] select(pred[] %compare.3321, s32[] %add.3324, s32[] %constant.3325) + %dynamic-update-slice.3327 = f32[2,1,1,1,16]{4,3,2,1,0} dynamic-update-slice(f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.2693, f32[1,1,1,1,16]{4,3,2,1,0} %broadcast.3289, s32[] %select.3294, s32[] %select.3302, s32[] %select.3310, /*index=5*/s32[] %select.3318, s32[] %select.3326) + %get-tuple-element.2694 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=27 + %constant.3017 = f32[] constant(2) + %broadcast.3018 = f32[3,3,8,16]{3,2,1,0} broadcast(f32[] %constant.3017), dimensions={} + %multiply.3019 = f32[3,3,8,16]{3,2,1,0} multiply(f32[3,3,8,16]{3,2,1,0} %broadcast.3018, f32[3,3,8,16]{3,2,1,0} %reshape.2806) + %broadcast.3328 = f32[1,3,3,8,16]{4,3,2,1,0} broadcast(f32[3,3,8,16]{3,2,1,0} %multiply.3019), dimensions={1,2,3,4} + %constant.3329 = s32[] constant(0) + %compare.3330 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3329), direction=LT + %constant.3331 = s32[] constant(2) + %add.3332 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3331) + %select.3333 = s32[] select(pred[] %compare.3330, s32[] %add.3332, s32[] %get-tuple-element.2676) + %constant.3334 = s32[] constant(0) + %constant.3335 = s32[] constant(0) + %compare.3336 = pred[] compare(s32[] %constant.3334, s32[] %constant.3335), direction=LT + %constant.3337 = s32[] constant(0) + %constant.3338 = s32[] constant(3) + %add.3339 = s32[] add(s32[] %constant.3337, s32[] %constant.3338) + %constant.3340 = s32[] constant(0) + %select.3341 = s32[] select(pred[] %compare.3336, s32[] %add.3339, s32[] %constant.3340) + %constant.3342 = s32[] constant(0) + %constant.3343 = s32[] constant(0) + %compare.3344 = pred[] compare(s32[] %constant.3342, s32[] %constant.3343), direction=LT + %constant.3345 = s32[] constant(0) + %constant.3346 = s32[] constant(3) + %add.3347 = s32[] add(s32[] %constant.3345, s32[] %constant.3346) + %constant.3348 = s32[] constant(0) + %select.3349 = s32[] select(pred[] %compare.3344, s32[] %add.3347, s32[] %constant.3348) + %constant.3350 = s32[] constant(0) + %constant.3351 = s32[] constant(0) + %compare.3352 = pred[] compare(s32[] %constant.3350, s32[] %constant.3351), direction=LT + %constant.3353 = s32[] constant(0) + %constant.3354 = s32[] constant(8) + %add.3355 = s32[] add(s32[] %constant.3353, s32[] %constant.3354) + %constant.3356 = s32[] constant(0) + %select.3357 = s32[] select(pred[] %compare.3352, s32[] %add.3355, s32[] %constant.3356) + %constant.3358 = s32[] constant(0) + %constant.3359 = s32[] constant(0) + %compare.3360 = pred[] compare(s32[] %constant.3358, s32[] %constant.3359), direction=LT + %constant.3361 = s32[] constant(0) + %constant.3362 = s32[] constant(16) + %add.3363 = s32[] add(s32[] %constant.3361, s32[] %constant.3362) + %constant.3364 = s32[] constant(0) + %select.3365 = s32[] select(pred[] %compare.3360, s32[] %add.3363, s32[] %constant.3364) + %dynamic-update-slice.3366 = f32[2,3,3,8,16]{4,3,2,1,0} dynamic-update-slice(f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.2694, f32[1,3,3,8,16]{4,3,2,1,0} %broadcast.3328, s32[] %select.3333, s32[] %select.3341, s32[] %select.3349, /*index=5*/s32[] %select.3357, s32[] %select.3365) + %get-tuple-element.2695 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=28 + %constant.3021 = f32[] constant(-0.5) + %broadcast.3022 = f32[16]{0} broadcast(f32[] %constant.3021), dimensions={} + %divide.3020 = f32[16]{0} divide(f32[16]{0} %rsqrt.2919, f32[16]{0} %reduce.2918) + %multiply.3023 = f32[16]{0} multiply(f32[16]{0} %broadcast.3022, f32[16]{0} %divide.3020) + %broadcast.3367 = f32[1,16]{1,0} broadcast(f32[16]{0} %multiply.3023), dimensions={1} + %constant.3368 = s32[] constant(0) + %compare.3369 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3368), direction=LT + %constant.3370 = s32[] constant(2) + %add.3371 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3370) + %select.3372 = s32[] select(pred[] %compare.3369, s32[] %add.3371, s32[] %get-tuple-element.2676) + %constant.3373 = s32[] constant(0) + %constant.3374 = s32[] constant(0) + %compare.3375 = pred[] compare(s32[] %constant.3373, s32[] %constant.3374), direction=LT + %constant.3376 = s32[] constant(0) + %constant.3377 = s32[] constant(16) + %add.3378 = s32[] add(s32[] %constant.3376, s32[] %constant.3377) + %constant.3379 = s32[] constant(0) + %select.3380 = s32[] select(pred[] %compare.3375, s32[] %add.3378, s32[] %constant.3379) + %dynamic-update-slice.3381 = f32[2,16]{1,0} dynamic-update-slice(f32[2,16]{1,0} %get-tuple-element.2695, f32[1,16]{1,0} %broadcast.3367, s32[] %select.3372, s32[] %select.3380) + %get-tuple-element.2696 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=29 + %broadcast.3382 = f32[1,1,1,1,16]{4,3,2,1,0} broadcast(f32[1,1,1,16]{3,2,1,0} %broadcast.2925), dimensions={1,2,3,4} + %constant.3383 = s32[] constant(0) + %compare.3384 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3383), direction=LT + %constant.3385 = s32[] constant(2) + %add.3386 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3385) + %select.3387 = s32[] select(pred[] %compare.3384, s32[] %add.3386, s32[] %get-tuple-element.2676) + %constant.3388 = s32[] constant(0) + %constant.3389 = s32[] constant(0) + %compare.3390 = pred[] compare(s32[] %constant.3388, s32[] %constant.3389), direction=LT + %constant.3391 = s32[] constant(0) + %constant.3392 = s32[] constant(1) + %add.3393 = s32[] add(s32[] %constant.3391, s32[] %constant.3392) + %constant.3394 = s32[] constant(0) + %select.3395 = s32[] select(pred[] %compare.3390, s32[] %add.3393, s32[] %constant.3394) + %constant.3396 = s32[] constant(0) + %constant.3397 = s32[] constant(0) + %compare.3398 = pred[] compare(s32[] %constant.3396, s32[] %constant.3397), direction=LT + %constant.3399 = s32[] constant(0) + %constant.3400 = s32[] constant(1) + %add.3401 = s32[] add(s32[] %constant.3399, s32[] %constant.3400) + %constant.3402 = s32[] constant(0) + %select.3403 = s32[] select(pred[] %compare.3398, s32[] %add.3401, s32[] %constant.3402) + %constant.3404 = s32[] constant(0) + %constant.3405 = s32[] constant(0) + %compare.3406 = pred[] compare(s32[] %constant.3404, s32[] %constant.3405), direction=LT + %constant.3407 = s32[] constant(0) + %constant.3408 = s32[] constant(1) + %add.3409 = s32[] add(s32[] %constant.3407, s32[] %constant.3408) + %constant.3410 = s32[] constant(0) + %select.3411 = s32[] select(pred[] %compare.3406, s32[] %add.3409, s32[] %constant.3410) + %constant.3412 = s32[] constant(0) + %constant.3413 = s32[] constant(0) + %compare.3414 = pred[] compare(s32[] %constant.3412, s32[] %constant.3413), direction=LT + %constant.3415 = s32[] constant(0) + %constant.3416 = s32[] constant(16) + %add.3417 = s32[] add(s32[] %constant.3415, s32[] %constant.3416) + %constant.3418 = s32[] constant(0) + %select.3419 = s32[] select(pred[] %compare.3414, s32[] %add.3417, s32[] %constant.3418) + %dynamic-update-slice.3420 = f32[2,1,1,1,16]{4,3,2,1,0} dynamic-update-slice(f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.2696, f32[1,1,1,1,16]{4,3,2,1,0} %broadcast.3382, s32[] %select.3387, s32[] %select.3395, s32[] %select.3403, /*index=5*/s32[] %select.3411, s32[] %select.3419) + %get-tuple-element.2697 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=30 + %broadcast.3421 = f32[1,16,32,32,16]{4,3,2,1,0} broadcast(f32[16,32,32,16]{3,2,1,0} %convolution.2924), dimensions={1,2,3,4} + %constant.3422 = s32[] constant(0) + %compare.3423 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3422), direction=LT + %constant.3424 = s32[] constant(2) + %add.3425 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3424) + %select.3426 = s32[] select(pred[] %compare.3423, s32[] %add.3425, s32[] %get-tuple-element.2676) + %constant.3427 = s32[] constant(0) + %constant.3428 = s32[] constant(0) + %compare.3429 = pred[] compare(s32[] %constant.3427, s32[] %constant.3428), direction=LT + %constant.3430 = s32[] constant(0) + %constant.3431 = s32[] constant(16) + %add.3432 = s32[] add(s32[] %constant.3430, s32[] %constant.3431) + %constant.3433 = s32[] constant(0) + %select.3434 = s32[] select(pred[] %compare.3429, s32[] %add.3432, s32[] %constant.3433) + %constant.3435 = s32[] constant(0) + %constant.3436 = s32[] constant(0) + %compare.3437 = pred[] compare(s32[] %constant.3435, s32[] %constant.3436), direction=LT + %constant.3438 = s32[] constant(0) + %constant.3439 = s32[] constant(32) + %add.3440 = s32[] add(s32[] %constant.3438, s32[] %constant.3439) + %constant.3441 = s32[] constant(0) + %select.3442 = s32[] select(pred[] %compare.3437, s32[] %add.3440, s32[] %constant.3441) + %constant.3443 = s32[] constant(0) + %constant.3444 = s32[] constant(0) + %compare.3445 = pred[] compare(s32[] %constant.3443, s32[] %constant.3444), direction=LT + %constant.3446 = s32[] constant(0) + %constant.3447 = s32[] constant(32) + %add.3448 = s32[] add(s32[] %constant.3446, s32[] %constant.3447) + %constant.3449 = s32[] constant(0) + %select.3450 = s32[] select(pred[] %compare.3445, s32[] %add.3448, s32[] %constant.3449) + %constant.3451 = s32[] constant(0) + %constant.3452 = s32[] constant(0) + %compare.3453 = pred[] compare(s32[] %constant.3451, s32[] %constant.3452), direction=LT + %constant.3454 = s32[] constant(0) + %constant.3455 = s32[] constant(16) + %add.3456 = s32[] add(s32[] %constant.3454, s32[] %constant.3455) + %constant.3457 = s32[] constant(0) + %select.3458 = s32[] select(pred[] %compare.3453, s32[] %add.3456, s32[] %constant.3457) + %dynamic-update-slice.3459 = f32[2,16,32,32,16]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2697, f32[1,16,32,32,16]{4,3,2,1,0} %broadcast.3421, s32[] %select.3426, s32[] %select.3434, s32[] %select.3442, /*index=5*/s32[] %select.3450, s32[] %select.3458) + %get-tuple-element.2698 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=31 + %constant.3024 = f32[] constant(2) + %broadcast.3025 = f32[16,32,32,16]{3,2,1,0} broadcast(f32[] %constant.3024), dimensions={} + %multiply.3026 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %broadcast.3025, f32[16,32,32,16]{3,2,1,0} %add.2932) + %broadcast.3460 = f32[1,16,32,32,16]{4,3,2,1,0} broadcast(f32[16,32,32,16]{3,2,1,0} %multiply.3026), dimensions={1,2,3,4} + %constant.3461 = s32[] constant(0) + %compare.3462 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3461), direction=LT + %constant.3463 = s32[] constant(2) + %add.3464 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3463) + %select.3465 = s32[] select(pred[] %compare.3462, s32[] %add.3464, s32[] %get-tuple-element.2676) + %constant.3466 = s32[] constant(0) + %constant.3467 = s32[] constant(0) + %compare.3468 = pred[] compare(s32[] %constant.3466, s32[] %constant.3467), direction=LT + %constant.3469 = s32[] constant(0) + %constant.3470 = s32[] constant(16) + %add.3471 = s32[] add(s32[] %constant.3469, s32[] %constant.3470) + %constant.3472 = s32[] constant(0) + %select.3473 = s32[] select(pred[] %compare.3468, s32[] %add.3471, s32[] %constant.3472) + %constant.3474 = s32[] constant(0) + %constant.3475 = s32[] constant(0) + %compare.3476 = pred[] compare(s32[] %constant.3474, s32[] %constant.3475), direction=LT + %constant.3477 = s32[] constant(0) + %constant.3478 = s32[] constant(32) + %add.3479 = s32[] add(s32[] %constant.3477, s32[] %constant.3478) + %constant.3480 = s32[] constant(0) + %select.3481 = s32[] select(pred[] %compare.3476, s32[] %add.3479, s32[] %constant.3480) + %constant.3482 = s32[] constant(0) + %constant.3483 = s32[] constant(0) + %compare.3484 = pred[] compare(s32[] %constant.3482, s32[] %constant.3483), direction=LT + %constant.3485 = s32[] constant(0) + %constant.3486 = s32[] constant(32) + %add.3487 = s32[] add(s32[] %constant.3485, s32[] %constant.3486) + %constant.3488 = s32[] constant(0) + %select.3489 = s32[] select(pred[] %compare.3484, s32[] %add.3487, s32[] %constant.3488) + %constant.3490 = s32[] constant(0) + %constant.3491 = s32[] constant(0) + %compare.3492 = pred[] compare(s32[] %constant.3490, s32[] %constant.3491), direction=LT + %constant.3493 = s32[] constant(0) + %constant.3494 = s32[] constant(16) + %add.3495 = s32[] add(s32[] %constant.3493, s32[] %constant.3494) + %constant.3496 = s32[] constant(0) + %select.3497 = s32[] select(pred[] %compare.3492, s32[] %add.3495, s32[] %constant.3496) + %dynamic-update-slice.3498 = f32[2,16,32,32,16]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2698, f32[1,16,32,32,16]{4,3,2,1,0} %broadcast.3460, s32[] %select.3465, s32[] %select.3473, s32[] %select.3481, /*index=5*/s32[] %select.3489, s32[] %select.3497) + %get-tuple-element.2699 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=32 + %broadcast.3499 = f32[1,16,32,32,16]{4,3,2,1,0} broadcast(f32[16,32,32,16]{3,2,1,0} %rsqrt.2937), dimensions={1,2,3,4} + %constant.3500 = s32[] constant(0) + %compare.3501 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3500), direction=LT + %constant.3502 = s32[] constant(2) + %add.3503 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3502) + %select.3504 = s32[] select(pred[] %compare.3501, s32[] %add.3503, s32[] %get-tuple-element.2676) + %constant.3505 = s32[] constant(0) + %constant.3506 = s32[] constant(0) + %compare.3507 = pred[] compare(s32[] %constant.3505, s32[] %constant.3506), direction=LT + %constant.3508 = s32[] constant(0) + %constant.3509 = s32[] constant(16) + %add.3510 = s32[] add(s32[] %constant.3508, s32[] %constant.3509) + %constant.3511 = s32[] constant(0) + %select.3512 = s32[] select(pred[] %compare.3507, s32[] %add.3510, s32[] %constant.3511) + %constant.3513 = s32[] constant(0) + %constant.3514 = s32[] constant(0) + %compare.3515 = pred[] compare(s32[] %constant.3513, s32[] %constant.3514), direction=LT + %constant.3516 = s32[] constant(0) + %constant.3517 = s32[] constant(32) + %add.3518 = s32[] add(s32[] %constant.3516, s32[] %constant.3517) + %constant.3519 = s32[] constant(0) + %select.3520 = s32[] select(pred[] %compare.3515, s32[] %add.3518, s32[] %constant.3519) + %constant.3521 = s32[] constant(0) + %constant.3522 = s32[] constant(0) + %compare.3523 = pred[] compare(s32[] %constant.3521, s32[] %constant.3522), direction=LT + %constant.3524 = s32[] constant(0) + %constant.3525 = s32[] constant(32) + %add.3526 = s32[] add(s32[] %constant.3524, s32[] %constant.3525) + %constant.3527 = s32[] constant(0) + %select.3528 = s32[] select(pred[] %compare.3523, s32[] %add.3526, s32[] %constant.3527) + %constant.3529 = s32[] constant(0) + %constant.3530 = s32[] constant(0) + %compare.3531 = pred[] compare(s32[] %constant.3529, s32[] %constant.3530), direction=LT + %constant.3532 = s32[] constant(0) + %constant.3533 = s32[] constant(16) + %add.3534 = s32[] add(s32[] %constant.3532, s32[] %constant.3533) + %constant.3535 = s32[] constant(0) + %select.3536 = s32[] select(pred[] %compare.3531, s32[] %add.3534, s32[] %constant.3535) + %dynamic-update-slice.3537 = f32[2,16,32,32,16]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2699, f32[1,16,32,32,16]{4,3,2,1,0} %broadcast.3499, s32[] %select.3504, s32[] %select.3512, s32[] %select.3520, /*index=5*/s32[] %select.3528, s32[] %select.3536) + %get-tuple-element.2700 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=33 + %broadcast.3538 = f32[1,16,32,32,16]{4,3,2,1,0} broadcast(f32[16,32,32,16]{3,2,1,0} %multiply.2933), dimensions={1,2,3,4} + %constant.3539 = s32[] constant(0) + %compare.3540 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3539), direction=LT + %constant.3541 = s32[] constant(2) + %add.3542 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3541) + %select.3543 = s32[] select(pred[] %compare.3540, s32[] %add.3542, s32[] %get-tuple-element.2676) + %constant.3544 = s32[] constant(0) + %constant.3545 = s32[] constant(0) + %compare.3546 = pred[] compare(s32[] %constant.3544, s32[] %constant.3545), direction=LT + %constant.3547 = s32[] constant(0) + %constant.3548 = s32[] constant(16) + %add.3549 = s32[] add(s32[] %constant.3547, s32[] %constant.3548) + %constant.3550 = s32[] constant(0) + %select.3551 = s32[] select(pred[] %compare.3546, s32[] %add.3549, s32[] %constant.3550) + %constant.3552 = s32[] constant(0) + %constant.3553 = s32[] constant(0) + %compare.3554 = pred[] compare(s32[] %constant.3552, s32[] %constant.3553), direction=LT + %constant.3555 = s32[] constant(0) + %constant.3556 = s32[] constant(32) + %add.3557 = s32[] add(s32[] %constant.3555, s32[] %constant.3556) + %constant.3558 = s32[] constant(0) + %select.3559 = s32[] select(pred[] %compare.3554, s32[] %add.3557, s32[] %constant.3558) + %constant.3560 = s32[] constant(0) + %constant.3561 = s32[] constant(0) + %compare.3562 = pred[] compare(s32[] %constant.3560, s32[] %constant.3561), direction=LT + %constant.3563 = s32[] constant(0) + %constant.3564 = s32[] constant(32) + %add.3565 = s32[] add(s32[] %constant.3563, s32[] %constant.3564) + %constant.3566 = s32[] constant(0) + %select.3567 = s32[] select(pred[] %compare.3562, s32[] %add.3565, s32[] %constant.3566) + %constant.3568 = s32[] constant(0) + %constant.3569 = s32[] constant(0) + %compare.3570 = pred[] compare(s32[] %constant.3568, s32[] %constant.3569), direction=LT + %constant.3571 = s32[] constant(0) + %constant.3572 = s32[] constant(16) + %add.3573 = s32[] add(s32[] %constant.3571, s32[] %constant.3572) + %constant.3574 = s32[] constant(0) + %select.3575 = s32[] select(pred[] %compare.3570, s32[] %add.3573, s32[] %constant.3574) + %dynamic-update-slice.3576 = f32[2,16,32,32,16]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2700, f32[1,16,32,32,16]{4,3,2,1,0} %broadcast.3538, s32[] %select.3543, s32[] %select.3551, s32[] %select.3559, /*index=5*/s32[] %select.3567, s32[] %select.3575) + %get-tuple-element.2701 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=34 + %constant.3028 = f32[] constant(-0.5) + %broadcast.3029 = f32[16,32,32,16]{3,2,1,0} broadcast(f32[] %constant.3028), dimensions={} + %divide.3027 = f32[16,32,32,16]{3,2,1,0} divide(f32[16,32,32,16]{3,2,1,0} %rsqrt.2937, f32[16,32,32,16]{3,2,1,0} %add.2936) + %multiply.3030 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %broadcast.3029, f32[16,32,32,16]{3,2,1,0} %divide.3027) + %broadcast.3577 = f32[1,16,32,32,16]{4,3,2,1,0} broadcast(f32[16,32,32,16]{3,2,1,0} %multiply.3030), dimensions={1,2,3,4} + %constant.3578 = s32[] constant(0) + %compare.3579 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3578), direction=LT + %constant.3580 = s32[] constant(2) + %add.3581 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3580) + %select.3582 = s32[] select(pred[] %compare.3579, s32[] %add.3581, s32[] %get-tuple-element.2676) + %constant.3583 = s32[] constant(0) + %constant.3584 = s32[] constant(0) + %compare.3585 = pred[] compare(s32[] %constant.3583, s32[] %constant.3584), direction=LT + %constant.3586 = s32[] constant(0) + %constant.3587 = s32[] constant(16) + %add.3588 = s32[] add(s32[] %constant.3586, s32[] %constant.3587) + %constant.3589 = s32[] constant(0) + %select.3590 = s32[] select(pred[] %compare.3585, s32[] %add.3588, s32[] %constant.3589) + %constant.3591 = s32[] constant(0) + %constant.3592 = s32[] constant(0) + %compare.3593 = pred[] compare(s32[] %constant.3591, s32[] %constant.3592), direction=LT + %constant.3594 = s32[] constant(0) + %constant.3595 = s32[] constant(32) + %add.3596 = s32[] add(s32[] %constant.3594, s32[] %constant.3595) + %constant.3597 = s32[] constant(0) + %select.3598 = s32[] select(pred[] %compare.3593, s32[] %add.3596, s32[] %constant.3597) + %constant.3599 = s32[] constant(0) + %constant.3600 = s32[] constant(0) + %compare.3601 = pred[] compare(s32[] %constant.3599, s32[] %constant.3600), direction=LT + %constant.3602 = s32[] constant(0) + %constant.3603 = s32[] constant(32) + %add.3604 = s32[] add(s32[] %constant.3602, s32[] %constant.3603) + %constant.3605 = s32[] constant(0) + %select.3606 = s32[] select(pred[] %compare.3601, s32[] %add.3604, s32[] %constant.3605) + %constant.3607 = s32[] constant(0) + %constant.3608 = s32[] constant(0) + %compare.3609 = pred[] compare(s32[] %constant.3607, s32[] %constant.3608), direction=LT + %constant.3610 = s32[] constant(0) + %constant.3611 = s32[] constant(16) + %add.3612 = s32[] add(s32[] %constant.3610, s32[] %constant.3611) + %constant.3613 = s32[] constant(0) + %select.3614 = s32[] select(pred[] %compare.3609, s32[] %add.3612, s32[] %constant.3613) + %dynamic-update-slice.3615 = f32[2,16,32,32,16]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2701, f32[1,16,32,32,16]{4,3,2,1,0} %broadcast.3577, s32[] %select.3582, s32[] %select.3590, s32[] %select.3598, /*index=5*/s32[] %select.3606, s32[] %select.3614) + %get-tuple-element.2702 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=35 + %broadcast.3616 = f32[1,1,1,16,16]{4,3,2,1,0} broadcast(f32[1,1,16,16]{3,2,1,0} %multiply.2950), dimensions={1,2,3,4} + %constant.3617 = s32[] constant(0) + %compare.3618 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3617), direction=LT + %constant.3619 = s32[] constant(2) + %add.3620 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3619) + %select.3621 = s32[] select(pred[] %compare.3618, s32[] %add.3620, s32[] %get-tuple-element.2676) + %constant.3622 = s32[] constant(0) + %constant.3623 = s32[] constant(0) + %compare.3624 = pred[] compare(s32[] %constant.3622, s32[] %constant.3623), direction=LT + %constant.3625 = s32[] constant(0) + %constant.3626 = s32[] constant(1) + %add.3627 = s32[] add(s32[] %constant.3625, s32[] %constant.3626) + %constant.3628 = s32[] constant(0) + %select.3629 = s32[] select(pred[] %compare.3624, s32[] %add.3627, s32[] %constant.3628) + %constant.3630 = s32[] constant(0) + %constant.3631 = s32[] constant(0) + %compare.3632 = pred[] compare(s32[] %constant.3630, s32[] %constant.3631), direction=LT + %constant.3633 = s32[] constant(0) + %constant.3634 = s32[] constant(1) + %add.3635 = s32[] add(s32[] %constant.3633, s32[] %constant.3634) + %constant.3636 = s32[] constant(0) + %select.3637 = s32[] select(pred[] %compare.3632, s32[] %add.3635, s32[] %constant.3636) + %constant.3638 = s32[] constant(0) + %constant.3639 = s32[] constant(0) + %compare.3640 = pred[] compare(s32[] %constant.3638, s32[] %constant.3639), direction=LT + %constant.3641 = s32[] constant(0) + %constant.3642 = s32[] constant(16) + %add.3643 = s32[] add(s32[] %constant.3641, s32[] %constant.3642) + %constant.3644 = s32[] constant(0) + %select.3645 = s32[] select(pred[] %compare.3640, s32[] %add.3643, s32[] %constant.3644) + %constant.3646 = s32[] constant(0) + %constant.3647 = s32[] constant(0) + %compare.3648 = pred[] compare(s32[] %constant.3646, s32[] %constant.3647), direction=LT + %constant.3649 = s32[] constant(0) + %constant.3650 = s32[] constant(16) + %add.3651 = s32[] add(s32[] %constant.3649, s32[] %constant.3650) + %constant.3652 = s32[] constant(0) + %select.3653 = s32[] select(pred[] %compare.3648, s32[] %add.3651, s32[] %constant.3652) + %dynamic-update-slice.3654 = f32[2,1,1,16,16]{4,3,2,1,0} dynamic-update-slice(f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.2702, f32[1,1,1,16,16]{4,3,2,1,0} %broadcast.3616, s32[] %select.3621, s32[] %select.3629, s32[] %select.3637, /*index=5*/s32[] %select.3645, s32[] %select.3653) + %get-tuple-element.2703 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=36 + %broadcast.3655 = f32[1,16,32,32,16]{4,3,2,1,0} broadcast(f32[16,32,32,16]{3,2,1,0} %multiply.2942), dimensions={1,2,3,4} + %constant.3656 = s32[] constant(0) + %compare.3657 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3656), direction=LT + %constant.3658 = s32[] constant(2) + %add.3659 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3658) + %select.3660 = s32[] select(pred[] %compare.3657, s32[] %add.3659, s32[] %get-tuple-element.2676) + %constant.3661 = s32[] constant(0) + %constant.3662 = s32[] constant(0) + %compare.3663 = pred[] compare(s32[] %constant.3661, s32[] %constant.3662), direction=LT + %constant.3664 = s32[] constant(0) + %constant.3665 = s32[] constant(16) + %add.3666 = s32[] add(s32[] %constant.3664, s32[] %constant.3665) + %constant.3667 = s32[] constant(0) + %select.3668 = s32[] select(pred[] %compare.3663, s32[] %add.3666, s32[] %constant.3667) + %constant.3669 = s32[] constant(0) + %constant.3670 = s32[] constant(0) + %compare.3671 = pred[] compare(s32[] %constant.3669, s32[] %constant.3670), direction=LT + %constant.3672 = s32[] constant(0) + %constant.3673 = s32[] constant(32) + %add.3674 = s32[] add(s32[] %constant.3672, s32[] %constant.3673) + %constant.3675 = s32[] constant(0) + %select.3676 = s32[] select(pred[] %compare.3671, s32[] %add.3674, s32[] %constant.3675) + %constant.3677 = s32[] constant(0) + %constant.3678 = s32[] constant(0) + %compare.3679 = pred[] compare(s32[] %constant.3677, s32[] %constant.3678), direction=LT + %constant.3680 = s32[] constant(0) + %constant.3681 = s32[] constant(32) + %add.3682 = s32[] add(s32[] %constant.3680, s32[] %constant.3681) + %constant.3683 = s32[] constant(0) + %select.3684 = s32[] select(pred[] %compare.3679, s32[] %add.3682, s32[] %constant.3683) + %constant.3685 = s32[] constant(0) + %constant.3686 = s32[] constant(0) + %compare.3687 = pred[] compare(s32[] %constant.3685, s32[] %constant.3686), direction=LT + %constant.3688 = s32[] constant(0) + %constant.3689 = s32[] constant(16) + %add.3690 = s32[] add(s32[] %constant.3688, s32[] %constant.3689) + %constant.3691 = s32[] constant(0) + %select.3692 = s32[] select(pred[] %compare.3687, s32[] %add.3690, s32[] %constant.3691) + %dynamic-update-slice.3693 = f32[2,16,32,32,16]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2703, f32[1,16,32,32,16]{4,3,2,1,0} %broadcast.3655, s32[] %select.3660, s32[] %select.3668, s32[] %select.3676, /*index=5*/s32[] %select.3684, s32[] %select.3692) + %get-tuple-element.2704 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=37 + %broadcast.3694 = f32[1,1,1,1,16]{4,3,2,1,0} broadcast(f32[1,1,1,16]{3,2,1,0} %broadcast.2947), dimensions={1,2,3,4} + %constant.3695 = s32[] constant(0) + %compare.3696 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3695), direction=LT + %constant.3697 = s32[] constant(2) + %add.3698 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3697) + %select.3699 = s32[] select(pred[] %compare.3696, s32[] %add.3698, s32[] %get-tuple-element.2676) + %constant.3700 = s32[] constant(0) + %constant.3701 = s32[] constant(0) + %compare.3702 = pred[] compare(s32[] %constant.3700, s32[] %constant.3701), direction=LT + %constant.3703 = s32[] constant(0) + %constant.3704 = s32[] constant(1) + %add.3705 = s32[] add(s32[] %constant.3703, s32[] %constant.3704) + %constant.3706 = s32[] constant(0) + %select.3707 = s32[] select(pred[] %compare.3702, s32[] %add.3705, s32[] %constant.3706) + %constant.3708 = s32[] constant(0) + %constant.3709 = s32[] constant(0) + %compare.3710 = pred[] compare(s32[] %constant.3708, s32[] %constant.3709), direction=LT + %constant.3711 = s32[] constant(0) + %constant.3712 = s32[] constant(1) + %add.3713 = s32[] add(s32[] %constant.3711, s32[] %constant.3712) + %constant.3714 = s32[] constant(0) + %select.3715 = s32[] select(pred[] %compare.3710, s32[] %add.3713, s32[] %constant.3714) + %constant.3716 = s32[] constant(0) + %constant.3717 = s32[] constant(0) + %compare.3718 = pred[] compare(s32[] %constant.3716, s32[] %constant.3717), direction=LT + %constant.3719 = s32[] constant(0) + %constant.3720 = s32[] constant(1) + %add.3721 = s32[] add(s32[] %constant.3719, s32[] %constant.3720) + %constant.3722 = s32[] constant(0) + %select.3723 = s32[] select(pred[] %compare.3718, s32[] %add.3721, s32[] %constant.3722) + %constant.3724 = s32[] constant(0) + %constant.3725 = s32[] constant(0) + %compare.3726 = pred[] compare(s32[] %constant.3724, s32[] %constant.3725), direction=LT + %constant.3727 = s32[] constant(0) + %constant.3728 = s32[] constant(16) + %add.3729 = s32[] add(s32[] %constant.3727, s32[] %constant.3728) + %constant.3730 = s32[] constant(0) + %select.3731 = s32[] select(pred[] %compare.3726, s32[] %add.3729, s32[] %constant.3730) + %dynamic-update-slice.3732 = f32[2,1,1,1,16]{4,3,2,1,0} dynamic-update-slice(f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.2704, f32[1,1,1,1,16]{4,3,2,1,0} %broadcast.3694, s32[] %select.3699, s32[] %select.3707, s32[] %select.3715, /*index=5*/s32[] %select.3723, s32[] %select.3731) + %get-tuple-element.2705 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=38 + %constant.3031 = f32[] constant(2) + %broadcast.3032 = f32[1,1,16,16]{3,2,1,0} broadcast(f32[] %constant.3031), dimensions={} + %multiply.3033 = f32[1,1,16,16]{3,2,1,0} multiply(f32[1,1,16,16]{3,2,1,0} %broadcast.3032, f32[1,1,16,16]{3,2,1,0} %reshape.2875) + %broadcast.3733 = f32[1,1,1,16,16]{4,3,2,1,0} broadcast(f32[1,1,16,16]{3,2,1,0} %multiply.3033), dimensions={1,2,3,4} + %constant.3734 = s32[] constant(0) + %compare.3735 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3734), direction=LT + %constant.3736 = s32[] constant(2) + %add.3737 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3736) + %select.3738 = s32[] select(pred[] %compare.3735, s32[] %add.3737, s32[] %get-tuple-element.2676) + %constant.3739 = s32[] constant(0) + %constant.3740 = s32[] constant(0) + %compare.3741 = pred[] compare(s32[] %constant.3739, s32[] %constant.3740), direction=LT + %constant.3742 = s32[] constant(0) + %constant.3743 = s32[] constant(1) + %add.3744 = s32[] add(s32[] %constant.3742, s32[] %constant.3743) + %constant.3745 = s32[] constant(0) + %select.3746 = s32[] select(pred[] %compare.3741, s32[] %add.3744, s32[] %constant.3745) + %constant.3747 = s32[] constant(0) + %constant.3748 = s32[] constant(0) + %compare.3749 = pred[] compare(s32[] %constant.3747, s32[] %constant.3748), direction=LT + %constant.3750 = s32[] constant(0) + %constant.3751 = s32[] constant(1) + %add.3752 = s32[] add(s32[] %constant.3750, s32[] %constant.3751) + %constant.3753 = s32[] constant(0) + %select.3754 = s32[] select(pred[] %compare.3749, s32[] %add.3752, s32[] %constant.3753) + %constant.3755 = s32[] constant(0) + %constant.3756 = s32[] constant(0) + %compare.3757 = pred[] compare(s32[] %constant.3755, s32[] %constant.3756), direction=LT + %constant.3758 = s32[] constant(0) + %constant.3759 = s32[] constant(16) + %add.3760 = s32[] add(s32[] %constant.3758, s32[] %constant.3759) + %constant.3761 = s32[] constant(0) + %select.3762 = s32[] select(pred[] %compare.3757, s32[] %add.3760, s32[] %constant.3761) + %constant.3763 = s32[] constant(0) + %constant.3764 = s32[] constant(0) + %compare.3765 = pred[] compare(s32[] %constant.3763, s32[] %constant.3764), direction=LT + %constant.3766 = s32[] constant(0) + %constant.3767 = s32[] constant(16) + %add.3768 = s32[] add(s32[] %constant.3766, s32[] %constant.3767) + %constant.3769 = s32[] constant(0) + %select.3770 = s32[] select(pred[] %compare.3765, s32[] %add.3768, s32[] %constant.3769) + %dynamic-update-slice.3771 = f32[2,1,1,16,16]{4,3,2,1,0} dynamic-update-slice(f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.2705, f32[1,1,1,16,16]{4,3,2,1,0} %broadcast.3733, s32[] %select.3738, s32[] %select.3746, s32[] %select.3754, /*index=5*/s32[] %select.3762, s32[] %select.3770) + %get-tuple-element.2706 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=39 + %constant.3035 = f32[] constant(-0.5) + %broadcast.3036 = f32[16]{0} broadcast(f32[] %constant.3035), dimensions={} + %divide.3034 = f32[16]{0} divide(f32[16]{0} %rsqrt.2946, f32[16]{0} %reduce.2945) + %multiply.3037 = f32[16]{0} multiply(f32[16]{0} %broadcast.3036, f32[16]{0} %divide.3034) + %broadcast.3772 = f32[1,16]{1,0} broadcast(f32[16]{0} %multiply.3037), dimensions={1} + %constant.3773 = s32[] constant(0) + %compare.3774 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3773), direction=LT + %constant.3775 = s32[] constant(2) + %add.3776 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3775) + %select.3777 = s32[] select(pred[] %compare.3774, s32[] %add.3776, s32[] %get-tuple-element.2676) + %constant.3778 = s32[] constant(0) + %constant.3779 = s32[] constant(0) + %compare.3780 = pred[] compare(s32[] %constant.3778, s32[] %constant.3779), direction=LT + %constant.3781 = s32[] constant(0) + %constant.3782 = s32[] constant(16) + %add.3783 = s32[] add(s32[] %constant.3781, s32[] %constant.3782) + %constant.3784 = s32[] constant(0) + %select.3785 = s32[] select(pred[] %compare.3780, s32[] %add.3783, s32[] %constant.3784) + %dynamic-update-slice.3786 = f32[2,16]{1,0} dynamic-update-slice(f32[2,16]{1,0} %get-tuple-element.2706, f32[1,16]{1,0} %broadcast.3772, s32[] %select.3777, s32[] %select.3785) + %get-tuple-element.2707 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=40 + %broadcast.3787 = f32[1,1,1,1,16]{4,3,2,1,0} broadcast(f32[1,1,1,16]{3,2,1,0} %broadcast.2952), dimensions={1,2,3,4} + %constant.3788 = s32[] constant(0) + %compare.3789 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3788), direction=LT + %constant.3790 = s32[] constant(2) + %add.3791 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3790) + %select.3792 = s32[] select(pred[] %compare.3789, s32[] %add.3791, s32[] %get-tuple-element.2676) + %constant.3793 = s32[] constant(0) + %constant.3794 = s32[] constant(0) + %compare.3795 = pred[] compare(s32[] %constant.3793, s32[] %constant.3794), direction=LT + %constant.3796 = s32[] constant(0) + %constant.3797 = s32[] constant(1) + %add.3798 = s32[] add(s32[] %constant.3796, s32[] %constant.3797) + %constant.3799 = s32[] constant(0) + %select.3800 = s32[] select(pred[] %compare.3795, s32[] %add.3798, s32[] %constant.3799) + %constant.3801 = s32[] constant(0) + %constant.3802 = s32[] constant(0) + %compare.3803 = pred[] compare(s32[] %constant.3801, s32[] %constant.3802), direction=LT + %constant.3804 = s32[] constant(0) + %constant.3805 = s32[] constant(1) + %add.3806 = s32[] add(s32[] %constant.3804, s32[] %constant.3805) + %constant.3807 = s32[] constant(0) + %select.3808 = s32[] select(pred[] %compare.3803, s32[] %add.3806, s32[] %constant.3807) + %constant.3809 = s32[] constant(0) + %constant.3810 = s32[] constant(0) + %compare.3811 = pred[] compare(s32[] %constant.3809, s32[] %constant.3810), direction=LT + %constant.3812 = s32[] constant(0) + %constant.3813 = s32[] constant(1) + %add.3814 = s32[] add(s32[] %constant.3812, s32[] %constant.3813) + %constant.3815 = s32[] constant(0) + %select.3816 = s32[] select(pred[] %compare.3811, s32[] %add.3814, s32[] %constant.3815) + %constant.3817 = s32[] constant(0) + %constant.3818 = s32[] constant(0) + %compare.3819 = pred[] compare(s32[] %constant.3817, s32[] %constant.3818), direction=LT + %constant.3820 = s32[] constant(0) + %constant.3821 = s32[] constant(16) + %add.3822 = s32[] add(s32[] %constant.3820, s32[] %constant.3821) + %constant.3823 = s32[] constant(0) + %select.3824 = s32[] select(pred[] %compare.3819, s32[] %add.3822, s32[] %constant.3823) + %dynamic-update-slice.3825 = f32[2,1,1,1,16]{4,3,2,1,0} dynamic-update-slice(f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.2707, f32[1,1,1,1,16]{4,3,2,1,0} %broadcast.3787, s32[] %select.3792, s32[] %select.3800, s32[] %select.3808, /*index=5*/s32[] %select.3816, s32[] %select.3824) + %get-tuple-element.2708 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=41 + %broadcast.3826 = f32[1,16,32,32,16]{4,3,2,1,0} broadcast(f32[16,32,32,16]{3,2,1,0} %convolution.2951), dimensions={1,2,3,4} + %constant.3827 = s32[] constant(0) + %compare.3828 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3827), direction=LT + %constant.3829 = s32[] constant(2) + %add.3830 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3829) + %select.3831 = s32[] select(pred[] %compare.3828, s32[] %add.3830, s32[] %get-tuple-element.2676) + %constant.3832 = s32[] constant(0) + %constant.3833 = s32[] constant(0) + %compare.3834 = pred[] compare(s32[] %constant.3832, s32[] %constant.3833), direction=LT + %constant.3835 = s32[] constant(0) + %constant.3836 = s32[] constant(16) + %add.3837 = s32[] add(s32[] %constant.3835, s32[] %constant.3836) + %constant.3838 = s32[] constant(0) + %select.3839 = s32[] select(pred[] %compare.3834, s32[] %add.3837, s32[] %constant.3838) + %constant.3840 = s32[] constant(0) + %constant.3841 = s32[] constant(0) + %compare.3842 = pred[] compare(s32[] %constant.3840, s32[] %constant.3841), direction=LT + %constant.3843 = s32[] constant(0) + %constant.3844 = s32[] constant(32) + %add.3845 = s32[] add(s32[] %constant.3843, s32[] %constant.3844) + %constant.3846 = s32[] constant(0) + %select.3847 = s32[] select(pred[] %compare.3842, s32[] %add.3845, s32[] %constant.3846) + %constant.3848 = s32[] constant(0) + %constant.3849 = s32[] constant(0) + %compare.3850 = pred[] compare(s32[] %constant.3848, s32[] %constant.3849), direction=LT + %constant.3851 = s32[] constant(0) + %constant.3852 = s32[] constant(32) + %add.3853 = s32[] add(s32[] %constant.3851, s32[] %constant.3852) + %constant.3854 = s32[] constant(0) + %select.3855 = s32[] select(pred[] %compare.3850, s32[] %add.3853, s32[] %constant.3854) + %constant.3856 = s32[] constant(0) + %constant.3857 = s32[] constant(0) + %compare.3858 = pred[] compare(s32[] %constant.3856, s32[] %constant.3857), direction=LT + %constant.3859 = s32[] constant(0) + %constant.3860 = s32[] constant(16) + %add.3861 = s32[] add(s32[] %constant.3859, s32[] %constant.3860) + %constant.3862 = s32[] constant(0) + %select.3863 = s32[] select(pred[] %compare.3858, s32[] %add.3861, s32[] %constant.3862) + %dynamic-update-slice.3864 = f32[2,16,32,32,16]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2708, f32[1,16,32,32,16]{4,3,2,1,0} %broadcast.3826, s32[] %select.3831, s32[] %select.3839, s32[] %select.3847, /*index=5*/s32[] %select.3855, s32[] %select.3863) + %get-tuple-element.2709 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=42 + %broadcast.3865 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %multiply.2973), dimensions={1,2,3,4} + %constant.3866 = s32[] constant(0) + %compare.3867 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3866), direction=LT + %constant.3868 = s32[] constant(2) + %add.3869 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3868) + %select.3870 = s32[] select(pred[] %compare.3867, s32[] %add.3869, s32[] %get-tuple-element.2676) + %constant.3871 = s32[] constant(0) + %constant.3872 = s32[] constant(0) + %compare.3873 = pred[] compare(s32[] %constant.3871, s32[] %constant.3872), direction=LT + %constant.3874 = s32[] constant(0) + %constant.3875 = s32[] constant(16) + %add.3876 = s32[] add(s32[] %constant.3874, s32[] %constant.3875) + %constant.3877 = s32[] constant(0) + %select.3878 = s32[] select(pred[] %compare.3873, s32[] %add.3876, s32[] %constant.3877) + %constant.3879 = s32[] constant(0) + %constant.3880 = s32[] constant(0) + %compare.3881 = pred[] compare(s32[] %constant.3879, s32[] %constant.3880), direction=LT + %constant.3882 = s32[] constant(0) + %constant.3883 = s32[] constant(32) + %add.3884 = s32[] add(s32[] %constant.3882, s32[] %constant.3883) + %constant.3885 = s32[] constant(0) + %select.3886 = s32[] select(pred[] %compare.3881, s32[] %add.3884, s32[] %constant.3885) + %constant.3887 = s32[] constant(0) + %constant.3888 = s32[] constant(0) + %compare.3889 = pred[] compare(s32[] %constant.3887, s32[] %constant.3888), direction=LT + %constant.3890 = s32[] constant(0) + %constant.3891 = s32[] constant(32) + %add.3892 = s32[] add(s32[] %constant.3890, s32[] %constant.3891) + %constant.3893 = s32[] constant(0) + %select.3894 = s32[] select(pred[] %compare.3889, s32[] %add.3892, s32[] %constant.3893) + %constant.3895 = s32[] constant(0) + %constant.3896 = s32[] constant(0) + %compare.3897 = pred[] compare(s32[] %constant.3895, s32[] %constant.3896), direction=LT + %constant.3898 = s32[] constant(0) + %constant.3899 = s32[] constant(8) + %add.3900 = s32[] add(s32[] %constant.3898, s32[] %constant.3899) + %constant.3901 = s32[] constant(0) + %select.3902 = s32[] select(pred[] %compare.3897, s32[] %add.3900, s32[] %constant.3901) + %dynamic-update-slice.3903 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2709, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.3865, s32[] %select.3870, s32[] %select.3878, s32[] %select.3886, /*index=5*/s32[] %select.3894, s32[] %select.3902) + %get-tuple-element.2710 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=43 + %broadcast.3904 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %slice.2960), dimensions={1,2,3,4} + %constant.3905 = s32[] constant(0) + %compare.3906 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3905), direction=LT + %constant.3907 = s32[] constant(2) + %add.3908 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3907) + %select.3909 = s32[] select(pred[] %compare.3906, s32[] %add.3908, s32[] %get-tuple-element.2676) + %constant.3910 = s32[] constant(0) + %constant.3911 = s32[] constant(0) + %compare.3912 = pred[] compare(s32[] %constant.3910, s32[] %constant.3911), direction=LT + %constant.3913 = s32[] constant(0) + %constant.3914 = s32[] constant(16) + %add.3915 = s32[] add(s32[] %constant.3913, s32[] %constant.3914) + %constant.3916 = s32[] constant(0) + %select.3917 = s32[] select(pred[] %compare.3912, s32[] %add.3915, s32[] %constant.3916) + %constant.3918 = s32[] constant(0) + %constant.3919 = s32[] constant(0) + %compare.3920 = pred[] compare(s32[] %constant.3918, s32[] %constant.3919), direction=LT + %constant.3921 = s32[] constant(0) + %constant.3922 = s32[] constant(32) + %add.3923 = s32[] add(s32[] %constant.3921, s32[] %constant.3922) + %constant.3924 = s32[] constant(0) + %select.3925 = s32[] select(pred[] %compare.3920, s32[] %add.3923, s32[] %constant.3924) + %constant.3926 = s32[] constant(0) + %constant.3927 = s32[] constant(0) + %compare.3928 = pred[] compare(s32[] %constant.3926, s32[] %constant.3927), direction=LT + %constant.3929 = s32[] constant(0) + %constant.3930 = s32[] constant(32) + %add.3931 = s32[] add(s32[] %constant.3929, s32[] %constant.3930) + %constant.3932 = s32[] constant(0) + %select.3933 = s32[] select(pred[] %compare.3928, s32[] %add.3931, s32[] %constant.3932) + %constant.3934 = s32[] constant(0) + %constant.3935 = s32[] constant(0) + %compare.3936 = pred[] compare(s32[] %constant.3934, s32[] %constant.3935), direction=LT + %constant.3937 = s32[] constant(0) + %constant.3938 = s32[] constant(8) + %add.3939 = s32[] add(s32[] %constant.3937, s32[] %constant.3938) + %constant.3940 = s32[] constant(0) + %select.3941 = s32[] select(pred[] %compare.3936, s32[] %add.3939, s32[] %constant.3940) + %dynamic-update-slice.3942 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2710, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.3904, s32[] %select.3909, s32[] %select.3917, s32[] %select.3925, /*index=5*/s32[] %select.3933, s32[] %select.3941) + %get-tuple-element.2711 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=44 + %broadcast.3943 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %rsqrt.2966), dimensions={1,2,3,4} + %constant.3944 = s32[] constant(0) + %compare.3945 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3944), direction=LT + %constant.3946 = s32[] constant(2) + %add.3947 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3946) + %select.3948 = s32[] select(pred[] %compare.3945, s32[] %add.3947, s32[] %get-tuple-element.2676) + %constant.3949 = s32[] constant(0) + %constant.3950 = s32[] constant(0) + %compare.3951 = pred[] compare(s32[] %constant.3949, s32[] %constant.3950), direction=LT + %constant.3952 = s32[] constant(0) + %constant.3953 = s32[] constant(16) + %add.3954 = s32[] add(s32[] %constant.3952, s32[] %constant.3953) + %constant.3955 = s32[] constant(0) + %select.3956 = s32[] select(pred[] %compare.3951, s32[] %add.3954, s32[] %constant.3955) + %constant.3957 = s32[] constant(0) + %constant.3958 = s32[] constant(0) + %compare.3959 = pred[] compare(s32[] %constant.3957, s32[] %constant.3958), direction=LT + %constant.3960 = s32[] constant(0) + %constant.3961 = s32[] constant(32) + %add.3962 = s32[] add(s32[] %constant.3960, s32[] %constant.3961) + %constant.3963 = s32[] constant(0) + %select.3964 = s32[] select(pred[] %compare.3959, s32[] %add.3962, s32[] %constant.3963) + %constant.3965 = s32[] constant(0) + %constant.3966 = s32[] constant(0) + %compare.3967 = pred[] compare(s32[] %constant.3965, s32[] %constant.3966), direction=LT + %constant.3968 = s32[] constant(0) + %constant.3969 = s32[] constant(32) + %add.3970 = s32[] add(s32[] %constant.3968, s32[] %constant.3969) + %constant.3971 = s32[] constant(0) + %select.3972 = s32[] select(pred[] %compare.3967, s32[] %add.3970, s32[] %constant.3971) + %constant.3973 = s32[] constant(0) + %constant.3974 = s32[] constant(0) + %compare.3975 = pred[] compare(s32[] %constant.3973, s32[] %constant.3974), direction=LT + %constant.3976 = s32[] constant(0) + %constant.3977 = s32[] constant(8) + %add.3978 = s32[] add(s32[] %constant.3976, s32[] %constant.3977) + %constant.3979 = s32[] constant(0) + %select.3980 = s32[] select(pred[] %compare.3975, s32[] %add.3978, s32[] %constant.3979) + %dynamic-update-slice.3981 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2711, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.3943, s32[] %select.3948, s32[] %select.3956, s32[] %select.3964, /*index=5*/s32[] %select.3972, s32[] %select.3980) + %get-tuple-element.2712 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=45 + %broadcast.3982 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %slice.2961), dimensions={1,2,3,4} + %constant.3983 = s32[] constant(0) + %compare.3984 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.3983), direction=LT + %constant.3985 = s32[] constant(2) + %add.3986 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.3985) + %select.3987 = s32[] select(pred[] %compare.3984, s32[] %add.3986, s32[] %get-tuple-element.2676) + %constant.3988 = s32[] constant(0) + %constant.3989 = s32[] constant(0) + %compare.3990 = pred[] compare(s32[] %constant.3988, s32[] %constant.3989), direction=LT + %constant.3991 = s32[] constant(0) + %constant.3992 = s32[] constant(16) + %add.3993 = s32[] add(s32[] %constant.3991, s32[] %constant.3992) + %constant.3994 = s32[] constant(0) + %select.3995 = s32[] select(pred[] %compare.3990, s32[] %add.3993, s32[] %constant.3994) + %constant.3996 = s32[] constant(0) + %constant.3997 = s32[] constant(0) + %compare.3998 = pred[] compare(s32[] %constant.3996, s32[] %constant.3997), direction=LT + %constant.3999 = s32[] constant(0) + %constant.4000 = s32[] constant(32) + %add.4001 = s32[] add(s32[] %constant.3999, s32[] %constant.4000) + %constant.4002 = s32[] constant(0) + %select.4003 = s32[] select(pred[] %compare.3998, s32[] %add.4001, s32[] %constant.4002) + %constant.4004 = s32[] constant(0) + %constant.4005 = s32[] constant(0) + %compare.4006 = pred[] compare(s32[] %constant.4004, s32[] %constant.4005), direction=LT + %constant.4007 = s32[] constant(0) + %constant.4008 = s32[] constant(32) + %add.4009 = s32[] add(s32[] %constant.4007, s32[] %constant.4008) + %constant.4010 = s32[] constant(0) + %select.4011 = s32[] select(pred[] %compare.4006, s32[] %add.4009, s32[] %constant.4010) + %constant.4012 = s32[] constant(0) + %constant.4013 = s32[] constant(0) + %compare.4014 = pred[] compare(s32[] %constant.4012, s32[] %constant.4013), direction=LT + %constant.4015 = s32[] constant(0) + %constant.4016 = s32[] constant(8) + %add.4017 = s32[] add(s32[] %constant.4015, s32[] %constant.4016) + %constant.4018 = s32[] constant(0) + %select.4019 = s32[] select(pred[] %compare.4014, s32[] %add.4017, s32[] %constant.4018) + %dynamic-update-slice.4020 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2712, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.3982, s32[] %select.3987, s32[] %select.3995, s32[] %select.4003, /*index=5*/s32[] %select.4011, s32[] %select.4019) + %get-tuple-element.2713 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=46 + %constant.3038 = f32[] constant(2) + %broadcast.3039 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[] %constant.3038), dimensions={} + %multiply.3040 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %broadcast.3039, f32[16,32,32,8]{3,2,1,0} %slice.2961) + %broadcast.4021 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %multiply.3040), dimensions={1,2,3,4} + %constant.4022 = s32[] constant(0) + %compare.4023 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.4022), direction=LT + %constant.4024 = s32[] constant(2) + %add.4025 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.4024) + %select.4026 = s32[] select(pred[] %compare.4023, s32[] %add.4025, s32[] %get-tuple-element.2676) + %constant.4027 = s32[] constant(0) + %constant.4028 = s32[] constant(0) + %compare.4029 = pred[] compare(s32[] %constant.4027, s32[] %constant.4028), direction=LT + %constant.4030 = s32[] constant(0) + %constant.4031 = s32[] constant(16) + %add.4032 = s32[] add(s32[] %constant.4030, s32[] %constant.4031) + %constant.4033 = s32[] constant(0) + %select.4034 = s32[] select(pred[] %compare.4029, s32[] %add.4032, s32[] %constant.4033) + %constant.4035 = s32[] constant(0) + %constant.4036 = s32[] constant(0) + %compare.4037 = pred[] compare(s32[] %constant.4035, s32[] %constant.4036), direction=LT + %constant.4038 = s32[] constant(0) + %constant.4039 = s32[] constant(32) + %add.4040 = s32[] add(s32[] %constant.4038, s32[] %constant.4039) + %constant.4041 = s32[] constant(0) + %select.4042 = s32[] select(pred[] %compare.4037, s32[] %add.4040, s32[] %constant.4041) + %constant.4043 = s32[] constant(0) + %constant.4044 = s32[] constant(0) + %compare.4045 = pred[] compare(s32[] %constant.4043, s32[] %constant.4044), direction=LT + %constant.4046 = s32[] constant(0) + %constant.4047 = s32[] constant(32) + %add.4048 = s32[] add(s32[] %constant.4046, s32[] %constant.4047) + %constant.4049 = s32[] constant(0) + %select.4050 = s32[] select(pred[] %compare.4045, s32[] %add.4048, s32[] %constant.4049) + %constant.4051 = s32[] constant(0) + %constant.4052 = s32[] constant(0) + %compare.4053 = pred[] compare(s32[] %constant.4051, s32[] %constant.4052), direction=LT + %constant.4054 = s32[] constant(0) + %constant.4055 = s32[] constant(8) + %add.4056 = s32[] add(s32[] %constant.4054, s32[] %constant.4055) + %constant.4057 = s32[] constant(0) + %select.4058 = s32[] select(pred[] %compare.4053, s32[] %add.4056, s32[] %constant.4057) + %dynamic-update-slice.4059 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2713, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.4021, s32[] %select.4026, s32[] %select.4034, s32[] %select.4042, /*index=5*/s32[] %select.4050, s32[] %select.4058) + %get-tuple-element.2714 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=47 + %constant.3042 = f32[] constant(-0.5) + %broadcast.3043 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[] %constant.3042), dimensions={} + %divide.3041 = f32[16,32,32,8]{3,2,1,0} divide(f32[16,32,32,8]{3,2,1,0} %rsqrt.2966, f32[16,32,32,8]{3,2,1,0} %add.2965) + %multiply.3044 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %broadcast.3043, f32[16,32,32,8]{3,2,1,0} %divide.3041) + %broadcast.4060 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %multiply.3044), dimensions={1,2,3,4} + %constant.4061 = s32[] constant(0) + %compare.4062 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.4061), direction=LT + %constant.4063 = s32[] constant(2) + %add.4064 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.4063) + %select.4065 = s32[] select(pred[] %compare.4062, s32[] %add.4064, s32[] %get-tuple-element.2676) + %constant.4066 = s32[] constant(0) + %constant.4067 = s32[] constant(0) + %compare.4068 = pred[] compare(s32[] %constant.4066, s32[] %constant.4067), direction=LT + %constant.4069 = s32[] constant(0) + %constant.4070 = s32[] constant(16) + %add.4071 = s32[] add(s32[] %constant.4069, s32[] %constant.4070) + %constant.4072 = s32[] constant(0) + %select.4073 = s32[] select(pred[] %compare.4068, s32[] %add.4071, s32[] %constant.4072) + %constant.4074 = s32[] constant(0) + %constant.4075 = s32[] constant(0) + %compare.4076 = pred[] compare(s32[] %constant.4074, s32[] %constant.4075), direction=LT + %constant.4077 = s32[] constant(0) + %constant.4078 = s32[] constant(32) + %add.4079 = s32[] add(s32[] %constant.4077, s32[] %constant.4078) + %constant.4080 = s32[] constant(0) + %select.4081 = s32[] select(pred[] %compare.4076, s32[] %add.4079, s32[] %constant.4080) + %constant.4082 = s32[] constant(0) + %constant.4083 = s32[] constant(0) + %compare.4084 = pred[] compare(s32[] %constant.4082, s32[] %constant.4083), direction=LT + %constant.4085 = s32[] constant(0) + %constant.4086 = s32[] constant(32) + %add.4087 = s32[] add(s32[] %constant.4085, s32[] %constant.4086) + %constant.4088 = s32[] constant(0) + %select.4089 = s32[] select(pred[] %compare.4084, s32[] %add.4087, s32[] %constant.4088) + %constant.4090 = s32[] constant(0) + %constant.4091 = s32[] constant(0) + %compare.4092 = pred[] compare(s32[] %constant.4090, s32[] %constant.4091), direction=LT + %constant.4093 = s32[] constant(0) + %constant.4094 = s32[] constant(8) + %add.4095 = s32[] add(s32[] %constant.4093, s32[] %constant.4094) + %constant.4096 = s32[] constant(0) + %select.4097 = s32[] select(pred[] %compare.4092, s32[] %add.4095, s32[] %constant.4096) + %dynamic-update-slice.4098 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2714, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.4060, s32[] %select.4065, s32[] %select.4073, s32[] %select.4081, /*index=5*/s32[] %select.4089, s32[] %select.4097) + %get-tuple-element.2715 = f32[2,16,1,1,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=48 + %broadcast.4099 = f32[1,16,1,1,8]{4,3,2,1,0} broadcast(f32[16,1,1,8]{3,2,1,0} %broadcast.2998), dimensions={1,2,3,4} + %constant.4100 = s32[] constant(0) + %compare.4101 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.4100), direction=LT + %constant.4102 = s32[] constant(2) + %add.4103 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.4102) + %select.4104 = s32[] select(pred[] %compare.4101, s32[] %add.4103, s32[] %get-tuple-element.2676) + %constant.4105 = s32[] constant(0) + %constant.4106 = s32[] constant(0) + %compare.4107 = pred[] compare(s32[] %constant.4105, s32[] %constant.4106), direction=LT + %constant.4108 = s32[] constant(0) + %constant.4109 = s32[] constant(16) + %add.4110 = s32[] add(s32[] %constant.4108, s32[] %constant.4109) + %constant.4111 = s32[] constant(0) + %select.4112 = s32[] select(pred[] %compare.4107, s32[] %add.4110, s32[] %constant.4111) + %constant.4113 = s32[] constant(0) + %constant.4114 = s32[] constant(0) + %compare.4115 = pred[] compare(s32[] %constant.4113, s32[] %constant.4114), direction=LT + %constant.4116 = s32[] constant(0) + %constant.4117 = s32[] constant(1) + %add.4118 = s32[] add(s32[] %constant.4116, s32[] %constant.4117) + %constant.4119 = s32[] constant(0) + %select.4120 = s32[] select(pred[] %compare.4115, s32[] %add.4118, s32[] %constant.4119) + %constant.4121 = s32[] constant(0) + %constant.4122 = s32[] constant(0) + %compare.4123 = pred[] compare(s32[] %constant.4121, s32[] %constant.4122), direction=LT + %constant.4124 = s32[] constant(0) + %constant.4125 = s32[] constant(1) + %add.4126 = s32[] add(s32[] %constant.4124, s32[] %constant.4125) + %constant.4127 = s32[] constant(0) + %select.4128 = s32[] select(pred[] %compare.4123, s32[] %add.4126, s32[] %constant.4127) + %constant.4129 = s32[] constant(0) + %constant.4130 = s32[] constant(0) + %compare.4131 = pred[] compare(s32[] %constant.4129, s32[] %constant.4130), direction=LT + %constant.4132 = s32[] constant(0) + %constant.4133 = s32[] constant(8) + %add.4134 = s32[] add(s32[] %constant.4132, s32[] %constant.4133) + %constant.4135 = s32[] constant(0) + %select.4136 = s32[] select(pred[] %compare.4131, s32[] %add.4134, s32[] %constant.4135) + %dynamic-update-slice.4137 = f32[2,16,1,1,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,1,1,8]{4,3,2,1,0} %get-tuple-element.2715, f32[1,16,1,1,8]{4,3,2,1,0} %broadcast.4099, s32[] %select.4104, s32[] %select.4112, s32[] %select.4120, /*index=5*/s32[] %select.4128, s32[] %select.4136) + %get-tuple-element.2716 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=49 + %broadcast.4138 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %subtract.2985), dimensions={1,2,3,4} + %constant.4139 = s32[] constant(0) + %compare.4140 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.4139), direction=LT + %constant.4141 = s32[] constant(2) + %add.4142 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.4141) + %select.4143 = s32[] select(pred[] %compare.4140, s32[] %add.4142, s32[] %get-tuple-element.2676) + %constant.4144 = s32[] constant(0) + %constant.4145 = s32[] constant(0) + %compare.4146 = pred[] compare(s32[] %constant.4144, s32[] %constant.4145), direction=LT + %constant.4147 = s32[] constant(0) + %constant.4148 = s32[] constant(16) + %add.4149 = s32[] add(s32[] %constant.4147, s32[] %constant.4148) + %constant.4150 = s32[] constant(0) + %select.4151 = s32[] select(pred[] %compare.4146, s32[] %add.4149, s32[] %constant.4150) + %constant.4152 = s32[] constant(0) + %constant.4153 = s32[] constant(0) + %compare.4154 = pred[] compare(s32[] %constant.4152, s32[] %constant.4153), direction=LT + %constant.4155 = s32[] constant(0) + %constant.4156 = s32[] constant(32) + %add.4157 = s32[] add(s32[] %constant.4155, s32[] %constant.4156) + %constant.4158 = s32[] constant(0) + %select.4159 = s32[] select(pred[] %compare.4154, s32[] %add.4157, s32[] %constant.4158) + %constant.4160 = s32[] constant(0) + %constant.4161 = s32[] constant(0) + %compare.4162 = pred[] compare(s32[] %constant.4160, s32[] %constant.4161), direction=LT + %constant.4163 = s32[] constant(0) + %constant.4164 = s32[] constant(32) + %add.4165 = s32[] add(s32[] %constant.4163, s32[] %constant.4164) + %constant.4166 = s32[] constant(0) + %select.4167 = s32[] select(pred[] %compare.4162, s32[] %add.4165, s32[] %constant.4166) + %constant.4168 = s32[] constant(0) + %constant.4169 = s32[] constant(0) + %compare.4170 = pred[] compare(s32[] %constant.4168, s32[] %constant.4169), direction=LT + %constant.4171 = s32[] constant(0) + %constant.4172 = s32[] constant(8) + %add.4173 = s32[] add(s32[] %constant.4171, s32[] %constant.4172) + %constant.4174 = s32[] constant(0) + %select.4175 = s32[] select(pred[] %compare.4170, s32[] %add.4173, s32[] %constant.4174) + %dynamic-update-slice.4176 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2716, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.4138, s32[] %select.4143, s32[] %select.4151, s32[] %select.4159, /*index=5*/s32[] %select.4167, s32[] %select.4175) + %get-tuple-element.2717 = f32[2,16,1024,8]{3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=50 + %constant.3045 = f32[] constant(2) + %broadcast.3046 = f32[16,1024,8]{2,1,0} broadcast(f32[] %constant.3045), dimensions={} + %multiply.3047 = f32[16,1024,8]{2,1,0} multiply(f32[16,1024,8]{2,1,0} %broadcast.3046, f32[16,1024,8]{2,1,0} %reshape.2976) + %broadcast.4177 = f32[1,16,1024,8]{3,2,1,0} broadcast(f32[16,1024,8]{2,1,0} %multiply.3047), dimensions={1,2,3} + %constant.4178 = s32[] constant(0) + %compare.4179 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.4178), direction=LT + %constant.4180 = s32[] constant(2) + %add.4181 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.4180) + %select.4182 = s32[] select(pred[] %compare.4179, s32[] %add.4181, s32[] %get-tuple-element.2676) + %constant.4183 = s32[] constant(0) + %constant.4184 = s32[] constant(0) + %compare.4185 = pred[] compare(s32[] %constant.4183, s32[] %constant.4184), direction=LT + %constant.4186 = s32[] constant(0) + %constant.4187 = s32[] constant(16) + %add.4188 = s32[] add(s32[] %constant.4186, s32[] %constant.4187) + %constant.4189 = s32[] constant(0) + %select.4190 = s32[] select(pred[] %compare.4185, s32[] %add.4188, s32[] %constant.4189) + %constant.4191 = s32[] constant(0) + %constant.4192 = s32[] constant(0) + %compare.4193 = pred[] compare(s32[] %constant.4191, s32[] %constant.4192), direction=LT + %constant.4194 = s32[] constant(0) + %constant.4195 = s32[] constant(1024) + %add.4196 = s32[] add(s32[] %constant.4194, s32[] %constant.4195) + %constant.4197 = s32[] constant(0) + %select.4198 = s32[] select(pred[] %compare.4193, s32[] %add.4196, s32[] %constant.4197) + %constant.4199 = s32[] constant(0) + %constant.4200 = s32[] constant(0) + %compare.4201 = pred[] compare(s32[] %constant.4199, s32[] %constant.4200), direction=LT + %constant.4202 = s32[] constant(0) + %constant.4203 = s32[] constant(8) + %add.4204 = s32[] add(s32[] %constant.4202, s32[] %constant.4203) + %constant.4205 = s32[] constant(0) + %select.4206 = s32[] select(pred[] %compare.4201, s32[] %add.4204, s32[] %constant.4205) + %dynamic-update-slice.4207 = f32[2,16,1024,8]{3,2,1,0} dynamic-update-slice(f32[2,16,1024,8]{3,2,1,0} %get-tuple-element.2717, f32[1,16,1024,8]{3,2,1,0} %broadcast.4177, s32[] %select.4182, s32[] %select.4190, s32[] %select.4198, /*index=5*/s32[] %select.4206) + %get-tuple-element.2718 = f32[2,16,8]{2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=51 + %constant.3048 = f32[] constant(2) + %broadcast.3049 = f32[16,8]{1,0} broadcast(f32[] %constant.3048), dimensions={} + %multiply.3050 = f32[16,8]{1,0} multiply(f32[16,8]{1,0} %broadcast.3049, f32[16,8]{1,0} %divide.2981) + %broadcast.4208 = f32[1,16,8]{2,1,0} broadcast(f32[16,8]{1,0} %multiply.3050), dimensions={1,2} + %constant.4209 = s32[] constant(0) + %compare.4210 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.4209), direction=LT + %constant.4211 = s32[] constant(2) + %add.4212 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.4211) + %select.4213 = s32[] select(pred[] %compare.4210, s32[] %add.4212, s32[] %get-tuple-element.2676) + %constant.4214 = s32[] constant(0) + %constant.4215 = s32[] constant(0) + %compare.4216 = pred[] compare(s32[] %constant.4214, s32[] %constant.4215), direction=LT + %constant.4217 = s32[] constant(0) + %constant.4218 = s32[] constant(16) + %add.4219 = s32[] add(s32[] %constant.4217, s32[] %constant.4218) + %constant.4220 = s32[] constant(0) + %select.4221 = s32[] select(pred[] %compare.4216, s32[] %add.4219, s32[] %constant.4220) + %constant.4222 = s32[] constant(0) + %constant.4223 = s32[] constant(0) + %compare.4224 = pred[] compare(s32[] %constant.4222, s32[] %constant.4223), direction=LT + %constant.4225 = s32[] constant(0) + %constant.4226 = s32[] constant(8) + %add.4227 = s32[] add(s32[] %constant.4225, s32[] %constant.4226) + %constant.4228 = s32[] constant(0) + %select.4229 = s32[] select(pred[] %compare.4224, s32[] %add.4227, s32[] %constant.4228) + %dynamic-update-slice.4230 = f32[2,16,8]{2,1,0} dynamic-update-slice(f32[2,16,8]{2,1,0} %get-tuple-element.2718, f32[1,16,8]{2,1,0} %broadcast.4208, s32[] %select.4213, s32[] %select.4221, s32[] %select.4229) + %get-tuple-element.2719 = f32[2,16,8]{2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=52 + %constant.3052 = f32[] constant(-0.5) + %broadcast.3053 = f32[16,8]{1,0} broadcast(f32[] %constant.3052), dimensions={} + %divide.3051 = f32[16,8]{1,0} divide(f32[16,8]{1,0} %rsqrt.2997, f32[16,8]{1,0} %add.2996) + %multiply.3054 = f32[16,8]{1,0} multiply(f32[16,8]{1,0} %broadcast.3053, f32[16,8]{1,0} %divide.3051) + %broadcast.4231 = f32[1,16,8]{2,1,0} broadcast(f32[16,8]{1,0} %multiply.3054), dimensions={1,2} + %constant.4232 = s32[] constant(0) + %compare.4233 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.4232), direction=LT + %constant.4234 = s32[] constant(2) + %add.4235 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.4234) + %select.4236 = s32[] select(pred[] %compare.4233, s32[] %add.4235, s32[] %get-tuple-element.2676) + %constant.4237 = s32[] constant(0) + %constant.4238 = s32[] constant(0) + %compare.4239 = pred[] compare(s32[] %constant.4237, s32[] %constant.4238), direction=LT + %constant.4240 = s32[] constant(0) + %constant.4241 = s32[] constant(16) + %add.4242 = s32[] add(s32[] %constant.4240, s32[] %constant.4241) + %constant.4243 = s32[] constant(0) + %select.4244 = s32[] select(pred[] %compare.4239, s32[] %add.4242, s32[] %constant.4243) + %constant.4245 = s32[] constant(0) + %constant.4246 = s32[] constant(0) + %compare.4247 = pred[] compare(s32[] %constant.4245, s32[] %constant.4246), direction=LT + %constant.4248 = s32[] constant(0) + %constant.4249 = s32[] constant(8) + %add.4250 = s32[] add(s32[] %constant.4248, s32[] %constant.4249) + %constant.4251 = s32[] constant(0) + %select.4252 = s32[] select(pred[] %compare.4247, s32[] %add.4250, s32[] %constant.4251) + %dynamic-update-slice.4253 = f32[2,16,8]{2,1,0} dynamic-update-slice(f32[2,16,8]{2,1,0} %get-tuple-element.2719, f32[1,16,8]{2,1,0} %broadcast.4231, s32[] %select.4236, s32[] %select.4244, s32[] %select.4252) + %get-tuple-element.2720 = f32[2,1,1,1,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=53 + %broadcast.4254 = f32[1,1,1,1,8]{4,3,2,1,0} broadcast(f32[1,1,1,8]{3,2,1,0} %broadcast.3002), dimensions={1,2,3,4} + %constant.4255 = s32[] constant(0) + %compare.4256 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.4255), direction=LT + %constant.4257 = s32[] constant(2) + %add.4258 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.4257) + %select.4259 = s32[] select(pred[] %compare.4256, s32[] %add.4258, s32[] %get-tuple-element.2676) + %constant.4260 = s32[] constant(0) + %constant.4261 = s32[] constant(0) + %compare.4262 = pred[] compare(s32[] %constant.4260, s32[] %constant.4261), direction=LT + %constant.4263 = s32[] constant(0) + %constant.4264 = s32[] constant(1) + %add.4265 = s32[] add(s32[] %constant.4263, s32[] %constant.4264) + %constant.4266 = s32[] constant(0) + %select.4267 = s32[] select(pred[] %compare.4262, s32[] %add.4265, s32[] %constant.4266) + %constant.4268 = s32[] constant(0) + %constant.4269 = s32[] constant(0) + %compare.4270 = pred[] compare(s32[] %constant.4268, s32[] %constant.4269), direction=LT + %constant.4271 = s32[] constant(0) + %constant.4272 = s32[] constant(1) + %add.4273 = s32[] add(s32[] %constant.4271, s32[] %constant.4272) + %constant.4274 = s32[] constant(0) + %select.4275 = s32[] select(pred[] %compare.4270, s32[] %add.4273, s32[] %constant.4274) + %constant.4276 = s32[] constant(0) + %constant.4277 = s32[] constant(0) + %compare.4278 = pred[] compare(s32[] %constant.4276, s32[] %constant.4277), direction=LT + %constant.4279 = s32[] constant(0) + %constant.4280 = s32[] constant(1) + %add.4281 = s32[] add(s32[] %constant.4279, s32[] %constant.4280) + %constant.4282 = s32[] constant(0) + %select.4283 = s32[] select(pred[] %compare.4278, s32[] %add.4281, s32[] %constant.4282) + %constant.4284 = s32[] constant(0) + %constant.4285 = s32[] constant(0) + %compare.4286 = pred[] compare(s32[] %constant.4284, s32[] %constant.4285), direction=LT + %constant.4287 = s32[] constant(0) + %constant.4288 = s32[] constant(8) + %add.4289 = s32[] add(s32[] %constant.4287, s32[] %constant.4288) + %constant.4290 = s32[] constant(0) + %select.4291 = s32[] select(pred[] %compare.4286, s32[] %add.4289, s32[] %constant.4290) + %dynamic-update-slice.4292 = f32[2,1,1,1,8]{4,3,2,1,0} dynamic-update-slice(f32[2,1,1,1,8]{4,3,2,1,0} %get-tuple-element.2720, f32[1,1,1,1,8]{4,3,2,1,0} %broadcast.4254, s32[] %select.4259, s32[] %select.4267, s32[] %select.4275, /*index=5*/s32[] %select.4283, s32[] %select.4291) + %get-tuple-element.2721 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.2666), index=54 + %broadcast.4293 = f32[1,16,32,32,8]{4,3,2,1,0} broadcast(f32[16,32,32,8]{3,2,1,0} %multiply.3001), dimensions={1,2,3,4} + %constant.4294 = s32[] constant(0) + %compare.4295 = pred[] compare(s32[] %get-tuple-element.2676, s32[] %constant.4294), direction=LT + %constant.4296 = s32[] constant(2) + %add.4297 = s32[] add(s32[] %get-tuple-element.2676, s32[] %constant.4296) + %select.4298 = s32[] select(pred[] %compare.4295, s32[] %add.4297, s32[] %get-tuple-element.2676) + %constant.4299 = s32[] constant(0) + %constant.4300 = s32[] constant(0) + %compare.4301 = pred[] compare(s32[] %constant.4299, s32[] %constant.4300), direction=LT + %constant.4302 = s32[] constant(0) + %constant.4303 = s32[] constant(16) + %add.4304 = s32[] add(s32[] %constant.4302, s32[] %constant.4303) + %constant.4305 = s32[] constant(0) + %select.4306 = s32[] select(pred[] %compare.4301, s32[] %add.4304, s32[] %constant.4305) + %constant.4307 = s32[] constant(0) + %constant.4308 = s32[] constant(0) + %compare.4309 = pred[] compare(s32[] %constant.4307, s32[] %constant.4308), direction=LT + %constant.4310 = s32[] constant(0) + %constant.4311 = s32[] constant(32) + %add.4312 = s32[] add(s32[] %constant.4310, s32[] %constant.4311) + %constant.4313 = s32[] constant(0) + %select.4314 = s32[] select(pred[] %compare.4309, s32[] %add.4312, s32[] %constant.4313) + %constant.4315 = s32[] constant(0) + %constant.4316 = s32[] constant(0) + %compare.4317 = pred[] compare(s32[] %constant.4315, s32[] %constant.4316), direction=LT + %constant.4318 = s32[] constant(0) + %constant.4319 = s32[] constant(32) + %add.4320 = s32[] add(s32[] %constant.4318, s32[] %constant.4319) + %constant.4321 = s32[] constant(0) + %select.4322 = s32[] select(pred[] %compare.4317, s32[] %add.4320, s32[] %constant.4321) + %constant.4323 = s32[] constant(0) + %constant.4324 = s32[] constant(0) + %compare.4325 = pred[] compare(s32[] %constant.4323, s32[] %constant.4324), direction=LT + %constant.4326 = s32[] constant(0) + %constant.4327 = s32[] constant(8) + %add.4328 = s32[] add(s32[] %constant.4326, s32[] %constant.4327) + %constant.4329 = s32[] constant(0) + %select.4330 = s32[] select(pred[] %compare.4325, s32[] %add.4328, s32[] %constant.4329) + %dynamic-update-slice.4331 = f32[2,16,32,32,8]{4,3,2,1,0} dynamic-update-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2721, f32[1,16,32,32,8]{4,3,2,1,0} %broadcast.4293, s32[] %select.4298, s32[] %select.4306, s32[] %select.4314, /*index=5*/s32[] %select.4322, s32[] %select.4330) + ROOT %tuple.4343 = (u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) tuple(u32[2,2]{1,0} %get-tuple-element.2667, f32[2,16]{1,0} %get-tuple-element.2668, f32[2,16]{1,0} %get-tuple-element.2669, f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.2670, f32[2,16]{1,0} %get-tuple-element.2671, /*index=5*/f32[2,16]{1,0} %get-tuple-element.2672, f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.2673, f32[2,8]{1,0} %get-tuple-element.2674, f32[2,8]{1,0} %get-tuple-element.2675, s32[] %add.4333, /*index=10*/f32[16,32,32,8]{3,2,1,0} %add.3009, pred[] %constant.4334, pred[] %constant.4335, pred[] %constant.4336, pred[] %constant.4337, /*index=15*/pred[] %constant.4338, pred[] %constant.4339, pred[] %constant.4340, pred[] %constant.4341, pred[] %constant.4342, /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.3093, f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.3132, f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.3171, f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.3210, f32[2,3,3,8,16]{4,3,2,1,0} %dynamic-update-slice.3249, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.3288, f32[2,1,1,1,16]{4,3,2,1,0} %dynamic-update-slice.3327, f32[2,3,3,8,16]{4,3,2,1,0} %dynamic-update-slice.3366, f32[2,16]{1,0} %dynamic-update-slice.3381, f32[2,1,1,1,16]{4,3,2,1,0} %dynamic-update-slice.3420, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0} %dynamic-update-slice.3459, f32[2,16,32,32,16]{4,3,2,1,0} %dynamic-update-slice.3498, f32[2,16,32,32,16]{4,3,2,1,0} %dynamic-update-slice.3537, f32[2,16,32,32,16]{4,3,2,1,0} %dynamic-update-slice.3576, f32[2,16,32,32,16]{4,3,2,1,0} %dynamic-update-slice.3615, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0} %dynamic-update-slice.3654, f32[2,16,32,32,16]{4,3,2,1,0} %dynamic-update-slice.3693, f32[2,1,1,1,16]{4,3,2,1,0} %dynamic-update-slice.3732, f32[2,1,1,16,16]{4,3,2,1,0} %dynamic-update-slice.3771, f32[2,16]{1,0} %dynamic-update-slice.3786, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0} %dynamic-update-slice.3825, f32[2,16,32,32,16]{4,3,2,1,0} %dynamic-update-slice.3864, f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.3903, f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.3942, f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.3981, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.4020, f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.4059, f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.4098, f32[2,16,1,1,8]{4,3,2,1,0} %dynamic-update-slice.4137, f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.4176, /*index=50*/f32[2,16,1024,8]{3,2,1,0} %dynamic-update-slice.4207, f32[2,16,8]{2,1,0} %dynamic-update-slice.4230, f32[2,16,8]{2,1,0} %dynamic-update-slice.4253, f32[2,1,1,1,8]{4,3,2,1,0} %dynamic-update-slice.4292, f32[2,16,32,32,8]{4,3,2,1,0} %dynamic-update-slice.4331) +} + +%cond_computation__1.4344 (parameter.4345: (u32[2,2], f32[2,16], f32[2,16], f32[2,3,3,8,16], f32[2,16], /*index=5*/f32[2,16], f32[2,1,1,16,16], f32[2,8], f32[2,8], s32[], /*index=10*/f32[16,32,32,8], pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,3,3,8,16], /*index=25*/f32[2,16,32,32,8], f32[2,1,1,1,16], f32[2,3,3,8,16], f32[2,16], f32[2,1,1,1,16], /*index=30*/f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], /*index=35*/f32[2,1,1,16,16], f32[2,16,32,32,16], f32[2,1,1,1,16], f32[2,1,1,16,16], f32[2,16], /*index=40*/f32[2,1,1,1,16], f32[2,16,32,32,16], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], /*index=45*/f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,1,1,8], f32[2,16,32,32,8], /*index=50*/f32[2,16,1024,8], f32[2,16,8], f32[2,16,8], f32[2,1,1,1,8], f32[2,16,32,32,8])) -> pred[] { + %parameter.4345 = (u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) parameter(0) + %get-tuple-element.4346 = u32[2,2]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=0 + %get-tuple-element.4347 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=1 + %get-tuple-element.4348 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=2 + %get-tuple-element.4349 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=3 + %get-tuple-element.4350 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=4 + %get-tuple-element.4351 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=5 + %get-tuple-element.4352 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=6 + %get-tuple-element.4353 = f32[2,8]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=7 + %get-tuple-element.4354 = f32[2,8]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=8 + %get-tuple-element.4356 = f32[16,32,32,8]{3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=10 + %get-tuple-element.4357 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=11 + %get-tuple-element.4358 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=12 + %get-tuple-element.4359 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=13 + %get-tuple-element.4360 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=14 + %get-tuple-element.4361 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=15 + %get-tuple-element.4362 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=16 + %get-tuple-element.4363 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=17 + %get-tuple-element.4364 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=18 + %get-tuple-element.4365 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=19 + %get-tuple-element.4366 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=20 + %get-tuple-element.4367 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=21 + %get-tuple-element.4368 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=22 + %get-tuple-element.4369 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=23 + %get-tuple-element.4370 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=24 + %get-tuple-element.4371 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=25 + %get-tuple-element.4372 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=26 + %get-tuple-element.4373 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=27 + %get-tuple-element.4374 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=28 + %get-tuple-element.4375 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=29 + %get-tuple-element.4376 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=30 + %get-tuple-element.4377 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=31 + %get-tuple-element.4378 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=32 + %get-tuple-element.4379 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=33 + %get-tuple-element.4380 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=34 + %get-tuple-element.4381 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=35 + %get-tuple-element.4382 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=36 + %get-tuple-element.4383 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=37 + %get-tuple-element.4384 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=38 + %get-tuple-element.4385 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=39 + %get-tuple-element.4386 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=40 + %get-tuple-element.4387 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=41 + %get-tuple-element.4388 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=42 + %get-tuple-element.4389 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=43 + %get-tuple-element.4390 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=44 + %get-tuple-element.4391 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=45 + %get-tuple-element.4392 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=46 + %get-tuple-element.4393 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=47 + %get-tuple-element.4394 = f32[2,16,1,1,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=48 + %get-tuple-element.4395 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=49 + %get-tuple-element.4396 = f32[2,16,1024,8]{3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=50 + %get-tuple-element.4397 = f32[2,16,8]{2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=51 + %get-tuple-element.4398 = f32[2,16,8]{2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=52 + %get-tuple-element.4399 = f32[2,1,1,1,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=53 + %get-tuple-element.4400 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=54 + %constant.4401 = pred[] constant(false) + %get-tuple-element.4355 = s32[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %parameter.4345), index=9 + %constant.4402 = s32[] constant(2) + ROOT %compare.4403 = pred[] compare(s32[] %get-tuple-element.4355, s32[] %constant.4402), direction=LT +} + +%primitive_computation_add__1.4558 (parameter.4559: f32[], parameter.4560: f32[]) -> f32[] { + %parameter.4559 = f32[] parameter(0) + %parameter.4560 = f32[] parameter(1) + ROOT %add.4561 = f32[] add(f32[] %parameter.4559, f32[] %parameter.4560) +} + +%primitive_computation_add__1.4629 (parameter.4630: f32[], parameter.4631: f32[]) -> f32[] { + %parameter.4630 = f32[] parameter(0) + %parameter.4631 = f32[] parameter(1) + ROOT %add.4632 = f32[] add(f32[] %parameter.4630, f32[] %parameter.4631) +} + +%primitive_computation_add__1.4642 (parameter.4643: f32[], parameter.4644: f32[]) -> f32[] { + %parameter.4643 = f32[] parameter(0) + %parameter.4644 = f32[] parameter(1) + ROOT %add.4645 = f32[] add(f32[] %parameter.4643, f32[] %parameter.4644) +} + +%primitive_computation_add__1.4659 (parameter.4660: f32[], parameter.4661: f32[]) -> f32[] { + %parameter.4660 = f32[] parameter(0) + %parameter.4661 = f32[] parameter(1) + ROOT %add.4662 = f32[] add(f32[] %parameter.4660, f32[] %parameter.4661) +} + +%primitive_computation_add__1.4687 (parameter.4688: f32[], parameter.4689: f32[]) -> f32[] { + %parameter.4688 = f32[] parameter(0) + %parameter.4689 = f32[] parameter(1) + ROOT %add.4690 = f32[] add(f32[] %parameter.4688, f32[] %parameter.4689) +} + +%scatter_add_reducer.4695 (parameter.4696: f32[], parameter.4697: f32[]) -> f32[] { + %parameter.4696 = f32[] parameter(0) + %parameter.4697 = f32[] parameter(1) + ROOT %add.4698 = f32[] add(f32[] %parameter.4696, f32[] %parameter.4697) +} + +%primitive_computation_add__1.4716 (parameter.4717: f32[], parameter.4718: f32[]) -> f32[] { + %parameter.4717 = f32[] parameter(0) + %parameter.4718 = f32[] parameter(1) + ROOT %add.4719 = f32[] add(f32[] %parameter.4717, f32[] %parameter.4718) +} + +%primitive_computation_add__1.4724 (parameter.4725: f32[], parameter.4726: f32[]) -> f32[] { + %parameter.4725 = f32[] parameter(0) + %parameter.4726 = f32[] parameter(1) + ROOT %add.4727 = f32[] add(f32[] %parameter.4725, f32[] %parameter.4726) +} + +%primitive_computation_add__1.4731 (parameter.4732: f32[], parameter.4733: f32[]) -> f32[] { + %parameter.4732 = f32[] parameter(0) + %parameter.4733 = f32[] parameter(1) + ROOT %add.4734 = f32[] add(f32[] %parameter.4732, f32[] %parameter.4733) +} + +%primitive_computation_add__1.4739 (parameter.4740: f32[], parameter.4741: f32[]) -> f32[] { + %parameter.4740 = f32[] parameter(0) + %parameter.4741 = f32[] parameter(1) + ROOT %add.4742 = f32[] add(f32[] %parameter.4740, f32[] %parameter.4741) +} + +%primitive_computation_add__1.4746 (parameter.4747: f32[], parameter.4748: f32[]) -> f32[] { + %parameter.4747 = f32[] parameter(0) + %parameter.4748 = f32[] parameter(1) + ROOT %add.4749 = f32[] add(f32[] %parameter.4747, f32[] %parameter.4748) +} + +%primitive_computation_add__1.4758 (parameter.4759: f32[], parameter.4760: f32[]) -> f32[] { + %parameter.4759 = f32[] parameter(0) + %parameter.4760 = f32[] parameter(1) + ROOT %add.4761 = f32[] add(f32[] %parameter.4759, f32[] %parameter.4760) +} + +%primitive_computation_add__1.4768 (parameter.4769: f32[], parameter.4770: f32[]) -> f32[] { + %parameter.4769 = f32[] parameter(0) + %parameter.4770 = f32[] parameter(1) + ROOT %add.4771 = f32[] add(f32[] %parameter.4769, f32[] %parameter.4770) +} + +%primitive_computation_add__1.4833 (parameter.4834: f32[], parameter.4835: f32[]) -> f32[] { + %parameter.4834 = f32[] parameter(0) + %parameter.4835 = f32[] parameter(1) + ROOT %add.4836 = f32[] add(f32[] %parameter.4834, f32[] %parameter.4835) +} + +%primitive_computation_add__1.4837 (parameter.4838: f32[], parameter.4839: f32[]) -> f32[] { + %parameter.4838 = f32[] parameter(0) + %parameter.4839 = f32[] parameter(1) + ROOT %add.4840 = f32[] add(f32[] %parameter.4838, f32[] %parameter.4839) +} + +%primitive_computation_add__1.4841 (parameter.4842: f32[], parameter.4843: f32[]) -> f32[] { + %parameter.4842 = f32[] parameter(0) + %parameter.4843 = f32[] parameter(1) + ROOT %add.4844 = f32[] add(f32[] %parameter.4842, f32[] %parameter.4843) +} + +%primitive_computation_add__1.4845 (parameter.4846: f32[], parameter.4847: f32[]) -> f32[] { + %parameter.4846 = f32[] parameter(0) + %parameter.4847 = f32[] parameter(1) + ROOT %add.4848 = f32[] add(f32[] %parameter.4846, f32[] %parameter.4847) +} + +%primitive_computation_add__1.4849 (parameter.4850: f32[], parameter.4851: f32[]) -> f32[] { + %parameter.4850 = f32[] parameter(0) + %parameter.4851 = f32[] parameter(1) + ROOT %add.4852 = f32[] add(f32[] %parameter.4850, f32[] %parameter.4851) +} + +%primitive_computation_add__1.4853 (parameter.4854: f32[], parameter.4855: f32[]) -> f32[] { + %parameter.4854 = f32[] parameter(0) + %parameter.4855 = f32[] parameter(1) + ROOT %add.4856 = f32[] add(f32[] %parameter.4854, f32[] %parameter.4855) +} + +%primitive_computation_add__1.4857 (parameter.4858: f32[], parameter.4859: f32[]) -> f32[] { + %parameter.4858 = f32[] parameter(0) + %parameter.4859 = f32[] parameter(1) + ROOT %add.4860 = f32[] add(f32[] %parameter.4858, f32[] %parameter.4859) +} + +%primitive_computation_add__1.4861 (parameter.4862: f32[], parameter.4863: f32[]) -> f32[] { + %parameter.4862 = f32[] parameter(0) + %parameter.4863 = f32[] parameter(1) + ROOT %add.4864 = f32[] add(f32[] %parameter.4862, f32[] %parameter.4863) +} + +%primitive_computation_add__1.4865 (parameter.4866: f32[], parameter.4867: f32[]) -> f32[] { + %parameter.4866 = f32[] parameter(0) + %parameter.4867 = f32[] parameter(1) + ROOT %add.4868 = f32[] add(f32[] %parameter.4866, f32[] %parameter.4867) +} + +%primitive_computation_add__1.4869 (parameter.4870: f32[], parameter.4871: f32[]) -> f32[] { + %parameter.4870 = f32[] parameter(0) + %parameter.4871 = f32[] parameter(1) + ROOT %add.4872 = f32[] add(f32[] %parameter.4870, f32[] %parameter.4871) +} + +%primitive_computation_add__1.4873 (parameter.4874: f32[], parameter.4875: f32[]) -> f32[] { + %parameter.4874 = f32[] parameter(0) + %parameter.4875 = f32[] parameter(1) + ROOT %add.4876 = f32[] add(f32[] %parameter.4874, f32[] %parameter.4875) +} + +%primitive_computation_add__1.4877 (parameter.4878: f32[], parameter.4879: f32[]) -> f32[] { + %parameter.4878 = f32[] parameter(0) + %parameter.4879 = f32[] parameter(1) + ROOT %add.4880 = f32[] add(f32[] %parameter.4878, f32[] %parameter.4879) +} + +%primitive_computation_add__1.4881 (parameter.4882: f32[], parameter.4883: f32[]) -> f32[] { + %parameter.4882 = f32[] parameter(0) + %parameter.4883 = f32[] parameter(1) + ROOT %add.4884 = f32[] add(f32[] %parameter.4882, f32[] %parameter.4883) +} + +%primitive_computation_add__1.4885 (parameter.4886: f32[], parameter.4887: f32[]) -> f32[] { + %parameter.4886 = f32[] parameter(0) + %parameter.4887 = f32[] parameter(1) + ROOT %add.4888 = f32[] add(f32[] %parameter.4886, f32[] %parameter.4887) +} + +%primitive_computation_add__1.4889 (parameter.4890: f32[], parameter.4891: f32[]) -> f32[] { + %parameter.4890 = f32[] parameter(0) + %parameter.4891 = f32[] parameter(1) + ROOT %add.4892 = f32[] add(f32[] %parameter.4890, f32[] %parameter.4891) +} + +%primitive_computation_add__1.4893 (parameter.4894: f32[], parameter.4895: f32[]) -> f32[] { + %parameter.4894 = f32[] parameter(0) + %parameter.4895 = f32[] parameter(1) + ROOT %add.4896 = f32[] add(f32[] %parameter.4894, f32[] %parameter.4895) +} + +%primitive_computation_add__1.4897 (parameter.4898: f32[], parameter.4899: f32[]) -> f32[] { + %parameter.4898 = f32[] parameter(0) + %parameter.4899 = f32[] parameter(1) + ROOT %add.4900 = f32[] add(f32[] %parameter.4898, f32[] %parameter.4899) +} + +%primitive_computation_add__1.4901 (parameter.4902: f32[], parameter.4903: f32[]) -> f32[] { + %parameter.4902 = f32[] parameter(0) + %parameter.4903 = f32[] parameter(1) + ROOT %add.4904 = f32[] add(f32[] %parameter.4902, f32[] %parameter.4903) +} + +%primitive_computation_add__1.4905 (parameter.4906: f32[], parameter.4907: f32[]) -> f32[] { + %parameter.4906 = f32[] parameter(0) + %parameter.4907 = f32[] parameter(1) + ROOT %add.4908 = f32[] add(f32[] %parameter.4906, f32[] %parameter.4907) +} + +%primitive_computation_add__1.4909 (parameter.4910: f32[], parameter.4911: f32[]) -> f32[] { + %parameter.4910 = f32[] parameter(0) + %parameter.4911 = f32[] parameter(1) + ROOT %add.4912 = f32[] add(f32[] %parameter.4910, f32[] %parameter.4911) +} + +%body_computation__2.4913 (parameter.4914: (f32[2,16], f32[2,16], f32[2,3,3,8,16], f32[2,16], f32[2,16], /*index=5*/f32[2,1,1,16,16], f32[2,8], f32[2,8], f32[2,16,32,32,8], f32[2,16,32,32,8], /*index=10*/f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,3,3,8,16], f32[2,16,32,32,8], f32[2,1,1,1,16], /*index=15*/f32[2,3,3,8,16], f32[2,3,3,8,16], f32[2,16], f32[2,1,1,1,16], f32[2,16,32,32,16], /*index=20*/f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,1,1,16,16], /*index=25*/f32[2,16,32,32,16], f32[2,1,1,1,16], f32[2,1,1,16,16], f32[2,1,1,16,16], f32[2,16], /*index=30*/f32[2,1,1,1,16], f32[2,16,32,32,16], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], /*index=35*/f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,1,1,8], f32[2,16,32,32,8], /*index=40*/f32[2,16,1024,8], f32[2,16,8], f32[2,16,8], f32[2,1,1,1,8], f32[2,16,32,32,8], /*index=45*/s32[], pred[], f32[16,32,32,8], pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16], f32[2,16], f32[2,3,3,8,16], /*index=60*/f32[2,16], f32[2,16], f32[2,1,1,16,16], f32[2,8], f32[2,8])) -> (f32[2,16], f32[2,16], f32[2,3,3,8,16], f32[2,16], f32[2,16], /*index=5*/f32[2,1,1,16,16], f32[2,8], f32[2,8], f32[2,16,32,32,8], f32[2,16,32,32,8], /*index=10*/f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,3,3,8,16], f32[2,16,32,32,8], f32[2,1,1,1,16], /*index=15*/f32[2,3,3,8,16], f32[2,3,3,8,16], f32[2,16], f32[2,1,1,1,16], f32[2,16,32,32,16], /*index=20*/f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,1,1,16,16], /*index=25*/f32[2,16,32,32,16], f32[2,1,1,1,16], f32[2,1,1,16,16], f32[2,1,1,16,16], f32[2,16], /*index=30*/f32[2,1,1,1,16], f32[2,16,32,32,16], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], /*index=35*/f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,1,1,8], f32[2,16,32,32,8], /*index=40*/f32[2,16,1024,8], f32[2,16,8], f32[2,16,8], f32[2,1,1,1,8], f32[2,16,32,32,8], /*index=45*/s32[], pred[], f32[16,32,32,8], pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16], f32[2,16], f32[2,3,3,8,16], /*index=60*/f32[2,16], f32[2,16], f32[2,1,1,16,16], f32[2,8], f32[2,8]) { + %parameter.4914 = (f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) parameter(0) + %get-tuple-element.4961 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=46 + %get-tuple-element.4963 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=48 + %get-tuple-element.4964 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=49 + %get-tuple-element.4965 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=50 + %get-tuple-element.4966 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=51 + %get-tuple-element.4967 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=52 + %get-tuple-element.4968 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=53 + %get-tuple-element.4969 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=54 + %get-tuple-element.4970 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=55 + %get-tuple-element.4971 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=56 + %constant.4980 = pred[] constant(false) + %get-tuple-element.4915 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=0 + %get-tuple-element.4916 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=1 + %get-tuple-element.4917 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=2 + %get-tuple-element.4918 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=3 + %get-tuple-element.4919 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=4 + %get-tuple-element.4920 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=5 + %get-tuple-element.4921 = f32[2,8]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=6 + %get-tuple-element.4922 = f32[2,8]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=7 + %get-tuple-element.4923 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=8 + %get-tuple-element.4924 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=9 + %get-tuple-element.4925 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=10 + %get-tuple-element.4926 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=11 + %get-tuple-element.4927 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=12 + %get-tuple-element.4928 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=13 + %get-tuple-element.4929 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=14 + %get-tuple-element.4930 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=15 + %get-tuple-element.4931 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=16 + %get-tuple-element.4932 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=17 + %get-tuple-element.4933 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=18 + %get-tuple-element.4934 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=19 + %get-tuple-element.4935 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=20 + %get-tuple-element.4936 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=21 + %get-tuple-element.4937 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=22 + %get-tuple-element.4938 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=23 + %get-tuple-element.4939 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=24 + %get-tuple-element.4940 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=25 + %get-tuple-element.4941 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=26 + %get-tuple-element.4942 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=27 + %get-tuple-element.4943 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=28 + %get-tuple-element.4944 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=29 + %get-tuple-element.4945 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=30 + %get-tuple-element.4946 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=31 + %get-tuple-element.4947 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=32 + %get-tuple-element.4948 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=33 + %get-tuple-element.4949 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=34 + %get-tuple-element.4950 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=35 + %get-tuple-element.4951 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=36 + %get-tuple-element.4952 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=37 + %get-tuple-element.4953 = f32[2,16,1,1,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=38 + %get-tuple-element.4954 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=39 + %get-tuple-element.4955 = f32[2,16,1024,8]{3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=40 + %get-tuple-element.4956 = f32[2,16,8]{2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=41 + %get-tuple-element.4957 = f32[2,16,8]{2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=42 + %get-tuple-element.4958 = f32[2,1,1,1,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=43 + %get-tuple-element.4959 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=44 + %get-tuple-element.4960 = s32[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=45 + %constant.6833 = s32[] constant(1) + %add.6834 = s32[] add(s32[] %get-tuple-element.4960, s32[] %constant.6833) + %constant.6835 = pred[] constant(false) + %get-tuple-element.4962 = f32[16,32,32,8]{3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=47 + %constant.4981 = s32[] constant(2) + %subtract.4982 = s32[] subtract(s32[] %constant.4981, s32[] %get-tuple-element.4960) + %constant.4983 = s32[] constant(1) + %subtract.4984 = s32[] subtract(s32[] %subtract.4982, s32[] %constant.4983) + %constant.6430 = s32[] constant(0) + %compare.6431 = pred[] compare(s32[] %subtract.4984, s32[] %constant.6430), direction=LT + %constant.6432 = s32[] constant(2) + %add.6433 = s32[] add(s32[] %subtract.4984, s32[] %constant.6432) + %select.6434 = s32[] select(pred[] %compare.6431, s32[] %add.6433, s32[] %subtract.4984) + %constant.6435 = s32[] constant(0) + %constant.6436 = s32[] constant(0) + %compare.6437 = pred[] compare(s32[] %constant.6435, s32[] %constant.6436), direction=LT + %constant.6438 = s32[] constant(0) + %constant.6439 = s32[] constant(1) + %add.6440 = s32[] add(s32[] %constant.6438, s32[] %constant.6439) + %constant.6441 = s32[] constant(0) + %select.6442 = s32[] select(pred[] %compare.6437, s32[] %add.6440, s32[] %constant.6441) + %constant.6443 = s32[] constant(0) + %constant.6444 = s32[] constant(0) + %compare.6445 = pred[] compare(s32[] %constant.6443, s32[] %constant.6444), direction=LT + %constant.6446 = s32[] constant(0) + %constant.6447 = s32[] constant(1) + %add.6448 = s32[] add(s32[] %constant.6446, s32[] %constant.6447) + %constant.6449 = s32[] constant(0) + %select.6450 = s32[] select(pred[] %compare.6445, s32[] %add.6448, s32[] %constant.6449) + %constant.6451 = s32[] constant(0) + %constant.6452 = s32[] constant(0) + %compare.6453 = pred[] compare(s32[] %constant.6451, s32[] %constant.6452), direction=LT + %constant.6454 = s32[] constant(0) + %constant.6455 = s32[] constant(1) + %add.6456 = s32[] add(s32[] %constant.6454, s32[] %constant.6455) + %constant.6457 = s32[] constant(0) + %select.6458 = s32[] select(pred[] %compare.6453, s32[] %add.6456, s32[] %constant.6457) + %constant.6459 = s32[] constant(0) + %constant.6460 = s32[] constant(0) + %compare.6461 = pred[] compare(s32[] %constant.6459, s32[] %constant.6460), direction=LT + %constant.6462 = s32[] constant(0) + %constant.6463 = s32[] constant(8) + %add.6464 = s32[] add(s32[] %constant.6462, s32[] %constant.6463) + %constant.6465 = s32[] constant(0) + %select.6466 = s32[] select(pred[] %compare.6461, s32[] %add.6464, s32[] %constant.6465) + %dynamic-slice.6467 = f32[1,1,1,1,8]{4,3,2,1,0} dynamic-slice(f32[2,1,1,1,8]{4,3,2,1,0} %get-tuple-element.4958, s32[] %select.6434, s32[] %select.6442, s32[] %select.6450, s32[] %select.6458, /*index=5*/s32[] %select.6466), dynamic_slice_sizes={1,1,1,1,8} + %reshape.6468 = f32[1,1,1,8]{3,2,1,0} reshape(f32[1,1,1,1,8]{4,3,2,1,0} %dynamic-slice.6467) + %reshape.6523 = f32[8]{0} reshape(f32[1,1,1,8]{3,2,1,0} %reshape.6468) + %broadcast.6524 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[8]{0} %reshape.6523), dimensions={3} + %multiply.6525 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %get-tuple-element.4962, f32[16,32,32,8]{3,2,1,0} %broadcast.6524) + %constant.6275 = s32[] constant(0) + %compare.6276 = pred[] compare(s32[] %subtract.4984, s32[] %constant.6275), direction=LT + %constant.6277 = s32[] constant(2) + %add.6278 = s32[] add(s32[] %subtract.4984, s32[] %constant.6277) + %select.6279 = s32[] select(pred[] %compare.6276, s32[] %add.6278, s32[] %subtract.4984) + %constant.6280 = s32[] constant(0) + %constant.6281 = s32[] constant(0) + %compare.6282 = pred[] compare(s32[] %constant.6280, s32[] %constant.6281), direction=LT + %constant.6283 = s32[] constant(0) + %constant.6284 = s32[] constant(16) + %add.6285 = s32[] add(s32[] %constant.6283, s32[] %constant.6284) + %constant.6286 = s32[] constant(0) + %select.6287 = s32[] select(pred[] %compare.6282, s32[] %add.6285, s32[] %constant.6286) + %constant.6288 = s32[] constant(0) + %constant.6289 = s32[] constant(0) + %compare.6290 = pred[] compare(s32[] %constant.6288, s32[] %constant.6289), direction=LT + %constant.6291 = s32[] constant(0) + %constant.6292 = s32[] constant(1) + %add.6293 = s32[] add(s32[] %constant.6291, s32[] %constant.6292) + %constant.6294 = s32[] constant(0) + %select.6295 = s32[] select(pred[] %compare.6290, s32[] %add.6293, s32[] %constant.6294) + %constant.6296 = s32[] constant(0) + %constant.6297 = s32[] constant(0) + %compare.6298 = pred[] compare(s32[] %constant.6296, s32[] %constant.6297), direction=LT + %constant.6299 = s32[] constant(0) + %constant.6300 = s32[] constant(1) + %add.6301 = s32[] add(s32[] %constant.6299, s32[] %constant.6300) + %constant.6302 = s32[] constant(0) + %select.6303 = s32[] select(pred[] %compare.6298, s32[] %add.6301, s32[] %constant.6302) + %constant.6304 = s32[] constant(0) + %constant.6305 = s32[] constant(0) + %compare.6306 = pred[] compare(s32[] %constant.6304, s32[] %constant.6305), direction=LT + %constant.6307 = s32[] constant(0) + %constant.6308 = s32[] constant(8) + %add.6309 = s32[] add(s32[] %constant.6307, s32[] %constant.6308) + %constant.6310 = s32[] constant(0) + %select.6311 = s32[] select(pred[] %compare.6306, s32[] %add.6309, s32[] %constant.6310) + %dynamic-slice.6312 = f32[1,16,1,1,8]{4,3,2,1,0} dynamic-slice(f32[2,16,1,1,8]{4,3,2,1,0} %get-tuple-element.4953, s32[] %select.6279, s32[] %select.6287, s32[] %select.6295, s32[] %select.6303, /*index=5*/s32[] %select.6311), dynamic_slice_sizes={1,16,1,1,8} + %reshape.6313 = f32[16,1,1,8]{3,2,1,0} reshape(f32[1,16,1,1,8]{4,3,2,1,0} %dynamic-slice.6312) + %reshape.6541 = f32[16,8]{1,0} reshape(f32[16,1,1,8]{3,2,1,0} %reshape.6313) + %broadcast.6542 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[16,8]{1,0} %reshape.6541), dimensions={0,3} + %multiply.6543 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %multiply.6525, f32[16,32,32,8]{3,2,1,0} %broadcast.6542) + %constant.6314 = s32[] constant(0) + %compare.6315 = pred[] compare(s32[] %subtract.4984, s32[] %constant.6314), direction=LT + %constant.6316 = s32[] constant(2) + %add.6317 = s32[] add(s32[] %subtract.4984, s32[] %constant.6316) + %select.6318 = s32[] select(pred[] %compare.6315, s32[] %add.6317, s32[] %subtract.4984) + %constant.6319 = s32[] constant(0) + %constant.6320 = s32[] constant(0) + %compare.6321 = pred[] compare(s32[] %constant.6319, s32[] %constant.6320), direction=LT + %constant.6322 = s32[] constant(0) + %constant.6323 = s32[] constant(16) + %add.6324 = s32[] add(s32[] %constant.6322, s32[] %constant.6323) + %constant.6325 = s32[] constant(0) + %select.6326 = s32[] select(pred[] %compare.6321, s32[] %add.6324, s32[] %constant.6325) + %constant.6327 = s32[] constant(0) + %constant.6328 = s32[] constant(0) + %compare.6329 = pred[] compare(s32[] %constant.6327, s32[] %constant.6328), direction=LT + %constant.6330 = s32[] constant(0) + %constant.6331 = s32[] constant(32) + %add.6332 = s32[] add(s32[] %constant.6330, s32[] %constant.6331) + %constant.6333 = s32[] constant(0) + %select.6334 = s32[] select(pred[] %compare.6329, s32[] %add.6332, s32[] %constant.6333) + %constant.6335 = s32[] constant(0) + %constant.6336 = s32[] constant(0) + %compare.6337 = pred[] compare(s32[] %constant.6335, s32[] %constant.6336), direction=LT + %constant.6338 = s32[] constant(0) + %constant.6339 = s32[] constant(32) + %add.6340 = s32[] add(s32[] %constant.6338, s32[] %constant.6339) + %constant.6341 = s32[] constant(0) + %select.6342 = s32[] select(pred[] %compare.6337, s32[] %add.6340, s32[] %constant.6341) + %constant.6343 = s32[] constant(0) + %constant.6344 = s32[] constant(0) + %compare.6345 = pred[] compare(s32[] %constant.6343, s32[] %constant.6344), direction=LT + %constant.6346 = s32[] constant(0) + %constant.6347 = s32[] constant(8) + %add.6348 = s32[] add(s32[] %constant.6346, s32[] %constant.6347) + %constant.6349 = s32[] constant(0) + %select.6350 = s32[] select(pred[] %compare.6345, s32[] %add.6348, s32[] %constant.6349) + %dynamic-slice.6351 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4954, s32[] %select.6318, s32[] %select.6326, s32[] %select.6334, s32[] %select.6342, /*index=5*/s32[] %select.6350), dynamic_slice_sizes={1,16,32,32,8} + %reshape.6352 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.6351) + %multiply.6526 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %reshape.6352, f32[16,32,32,8]{3,2,1,0} %multiply.6525) + %constant.6527 = f32[] constant(0) + %reduce.6528 = f32[16,8]{1,0} reduce(f32[16,32,32,8]{3,2,1,0} %multiply.6526, f32[] %constant.6527), dimensions={1,2}, to_apply=%primitive_computation_add__1.4849 + %reshape.6529 = f32[16,1,1,8]{3,2,1,0} reshape(f32[16,8]{1,0} %reduce.6528) + %constant.6530 = f32[] constant(0) + %reduce.6531 = f32[16,8]{1,0} reduce(f32[16,1,1,8]{3,2,1,0} %reshape.6529, f32[] %constant.6530), dimensions={1,2}, to_apply=%primitive_computation_add__1.4853 + %broadcast.6532 = f32[16,8]{1,0} broadcast(f32[16,8]{1,0} %reduce.6531), dimensions={0,1} + %constant.6407 = s32[] constant(0) + %compare.6408 = pred[] compare(s32[] %subtract.4984, s32[] %constant.6407), direction=LT + %constant.6409 = s32[] constant(2) + %add.6410 = s32[] add(s32[] %subtract.4984, s32[] %constant.6409) + %select.6411 = s32[] select(pred[] %compare.6408, s32[] %add.6410, s32[] %subtract.4984) + %constant.6412 = s32[] constant(0) + %constant.6413 = s32[] constant(0) + %compare.6414 = pred[] compare(s32[] %constant.6412, s32[] %constant.6413), direction=LT + %constant.6415 = s32[] constant(0) + %constant.6416 = s32[] constant(16) + %add.6417 = s32[] add(s32[] %constant.6415, s32[] %constant.6416) + %constant.6418 = s32[] constant(0) + %select.6419 = s32[] select(pred[] %compare.6414, s32[] %add.6417, s32[] %constant.6418) + %constant.6420 = s32[] constant(0) + %constant.6421 = s32[] constant(0) + %compare.6422 = pred[] compare(s32[] %constant.6420, s32[] %constant.6421), direction=LT + %constant.6423 = s32[] constant(0) + %constant.6424 = s32[] constant(8) + %add.6425 = s32[] add(s32[] %constant.6423, s32[] %constant.6424) + %constant.6426 = s32[] constant(0) + %select.6427 = s32[] select(pred[] %compare.6422, s32[] %add.6425, s32[] %constant.6426) + %dynamic-slice.6428 = f32[1,16,8]{2,1,0} dynamic-slice(f32[2,16,8]{2,1,0} %get-tuple-element.4957, s32[] %select.6411, s32[] %select.6419, s32[] %select.6427), dynamic_slice_sizes={1,16,8} + %reshape.6429 = f32[16,8]{1,0} reshape(f32[1,16,8]{2,1,0} %dynamic-slice.6428) + %multiply.6533 = f32[16,8]{1,0} multiply(f32[16,8]{1,0} %broadcast.6532, f32[16,8]{1,0} %reshape.6429) + %constant.6536 = f32[] constant(1024) + %broadcast.6537 = f32[16,8]{1,0} broadcast(f32[] %constant.6536), dimensions={} + %divide.6538 = f32[16,8]{1,0} divide(f32[16,8]{1,0} %multiply.6533, f32[16,8]{1,0} %broadcast.6537) + %broadcast.6539 = f32[16,1024,8]{2,1,0} broadcast(f32[16,8]{1,0} %divide.6538), dimensions={0,2} + %constant.6353 = s32[] constant(0) + %compare.6354 = pred[] compare(s32[] %subtract.4984, s32[] %constant.6353), direction=LT + %constant.6355 = s32[] constant(2) + %add.6356 = s32[] add(s32[] %subtract.4984, s32[] %constant.6355) + %select.6357 = s32[] select(pred[] %compare.6354, s32[] %add.6356, s32[] %subtract.4984) + %constant.6358 = s32[] constant(0) + %constant.6359 = s32[] constant(0) + %compare.6360 = pred[] compare(s32[] %constant.6358, s32[] %constant.6359), direction=LT + %constant.6361 = s32[] constant(0) + %constant.6362 = s32[] constant(16) + %add.6363 = s32[] add(s32[] %constant.6361, s32[] %constant.6362) + %constant.6364 = s32[] constant(0) + %select.6365 = s32[] select(pred[] %compare.6360, s32[] %add.6363, s32[] %constant.6364) + %constant.6366 = s32[] constant(0) + %constant.6367 = s32[] constant(0) + %compare.6368 = pred[] compare(s32[] %constant.6366, s32[] %constant.6367), direction=LT + %constant.6369 = s32[] constant(0) + %constant.6370 = s32[] constant(1024) + %add.6371 = s32[] add(s32[] %constant.6369, s32[] %constant.6370) + %constant.6372 = s32[] constant(0) + %select.6373 = s32[] select(pred[] %compare.6368, s32[] %add.6371, s32[] %constant.6372) + %constant.6374 = s32[] constant(0) + %constant.6375 = s32[] constant(0) + %compare.6376 = pred[] compare(s32[] %constant.6374, s32[] %constant.6375), direction=LT + %constant.6377 = s32[] constant(0) + %constant.6378 = s32[] constant(8) + %add.6379 = s32[] add(s32[] %constant.6377, s32[] %constant.6378) + %constant.6380 = s32[] constant(0) + %select.6381 = s32[] select(pred[] %compare.6376, s32[] %add.6379, s32[] %constant.6380) + %dynamic-slice.6382 = f32[1,16,1024,8]{3,2,1,0} dynamic-slice(f32[2,16,1024,8]{3,2,1,0} %get-tuple-element.4955, s32[] %select.6357, s32[] %select.6365, s32[] %select.6373, s32[] %select.6381), dynamic_slice_sizes={1,16,1024,8} + %reshape.6383 = f32[16,1024,8]{2,1,0} reshape(f32[1,16,1024,8]{3,2,1,0} %dynamic-slice.6382) + %multiply.6540 = f32[16,1024,8]{2,1,0} multiply(f32[16,1024,8]{2,1,0} %broadcast.6539, f32[16,1024,8]{2,1,0} %reshape.6383) + %negate.6534 = f32[16,8]{1,0} negate(f32[16,8]{1,0} %multiply.6533) + %constant.6384 = s32[] constant(0) + %compare.6385 = pred[] compare(s32[] %subtract.4984, s32[] %constant.6384), direction=LT + %constant.6386 = s32[] constant(2) + %add.6387 = s32[] add(s32[] %subtract.4984, s32[] %constant.6386) + %select.6388 = s32[] select(pred[] %compare.6385, s32[] %add.6387, s32[] %subtract.4984) + %constant.6389 = s32[] constant(0) + %constant.6390 = s32[] constant(0) + %compare.6391 = pred[] compare(s32[] %constant.6389, s32[] %constant.6390), direction=LT + %constant.6392 = s32[] constant(0) + %constant.6393 = s32[] constant(16) + %add.6394 = s32[] add(s32[] %constant.6392, s32[] %constant.6393) + %constant.6395 = s32[] constant(0) + %select.6396 = s32[] select(pred[] %compare.6391, s32[] %add.6394, s32[] %constant.6395) + %constant.6397 = s32[] constant(0) + %constant.6398 = s32[] constant(0) + %compare.6399 = pred[] compare(s32[] %constant.6397, s32[] %constant.6398), direction=LT + %constant.6400 = s32[] constant(0) + %constant.6401 = s32[] constant(8) + %add.6402 = s32[] add(s32[] %constant.6400, s32[] %constant.6401) + %constant.6403 = s32[] constant(0) + %select.6404 = s32[] select(pred[] %compare.6399, s32[] %add.6402, s32[] %constant.6403) + %dynamic-slice.6405 = f32[1,16,8]{2,1,0} dynamic-slice(f32[2,16,8]{2,1,0} %get-tuple-element.4956, s32[] %select.6388, s32[] %select.6396, s32[] %select.6404), dynamic_slice_sizes={1,16,8} + %reshape.6406 = f32[16,8]{1,0} reshape(f32[1,16,8]{2,1,0} %dynamic-slice.6405) + %multiply.6535 = f32[16,8]{1,0} multiply(f32[16,8]{1,0} %negate.6534, f32[16,8]{1,0} %reshape.6406) + %negate.6544 = f32[16,32,32,8]{3,2,1,0} negate(f32[16,32,32,8]{3,2,1,0} %multiply.6543) + %constant.6545 = f32[] constant(0) + %reduce.6546 = f32[16,8]{1,0} reduce(f32[16,32,32,8]{3,2,1,0} %negate.6544, f32[] %constant.6545), dimensions={1,2}, to_apply=%primitive_computation_add__1.4857 + %reshape.6547 = f32[16,1,1,8]{3,2,1,0} reshape(f32[16,8]{1,0} %reduce.6546) + %constant.6548 = f32[] constant(0) + %reduce.6549 = f32[16,8]{1,0} reduce(f32[16,1,1,8]{3,2,1,0} %reshape.6547, f32[] %constant.6548), dimensions={1,2}, to_apply=%primitive_computation_add__1.4861 + %broadcast.6550 = f32[16,8]{1,0} broadcast(f32[16,8]{1,0} %reduce.6549), dimensions={0,1} + %add.6551 = f32[16,8]{1,0} add(f32[16,8]{1,0} %multiply.6535, f32[16,8]{1,0} %broadcast.6550) + %constant.6552 = f32[] constant(1024) + %broadcast.6553 = f32[16,8]{1,0} broadcast(f32[] %constant.6552), dimensions={} + %divide.6554 = f32[16,8]{1,0} divide(f32[16,8]{1,0} %add.6551, f32[16,8]{1,0} %broadcast.6553) + %broadcast.6555 = f32[16,1024,8]{2,1,0} broadcast(f32[16,8]{1,0} %divide.6554), dimensions={0,2} + %add.6556 = f32[16,1024,8]{2,1,0} add(f32[16,1024,8]{2,1,0} %multiply.6540, f32[16,1024,8]{2,1,0} %broadcast.6555) + %reshape.6557 = f32[16,32,32,8]{3,2,1,0} reshape(f32[16,1024,8]{2,1,0} %add.6556) + %add.6558 = f32[16,32,32,8]{3,2,1,0} add(f32[16,32,32,8]{3,2,1,0} %multiply.6543, f32[16,32,32,8]{3,2,1,0} %reshape.6557) + %constant.6158 = s32[] constant(0) + %compare.6159 = pred[] compare(s32[] %subtract.4984, s32[] %constant.6158), direction=LT + %constant.6160 = s32[] constant(2) + %add.6161 = s32[] add(s32[] %subtract.4984, s32[] %constant.6160) + %select.6162 = s32[] select(pred[] %compare.6159, s32[] %add.6161, s32[] %subtract.4984) + %constant.6163 = s32[] constant(0) + %constant.6164 = s32[] constant(0) + %compare.6165 = pred[] compare(s32[] %constant.6163, s32[] %constant.6164), direction=LT + %constant.6166 = s32[] constant(0) + %constant.6167 = s32[] constant(16) + %add.6168 = s32[] add(s32[] %constant.6166, s32[] %constant.6167) + %constant.6169 = s32[] constant(0) + %select.6170 = s32[] select(pred[] %compare.6165, s32[] %add.6168, s32[] %constant.6169) + %constant.6171 = s32[] constant(0) + %constant.6172 = s32[] constant(0) + %compare.6173 = pred[] compare(s32[] %constant.6171, s32[] %constant.6172), direction=LT + %constant.6174 = s32[] constant(0) + %constant.6175 = s32[] constant(32) + %add.6176 = s32[] add(s32[] %constant.6174, s32[] %constant.6175) + %constant.6177 = s32[] constant(0) + %select.6178 = s32[] select(pred[] %compare.6173, s32[] %add.6176, s32[] %constant.6177) + %constant.6179 = s32[] constant(0) + %constant.6180 = s32[] constant(0) + %compare.6181 = pred[] compare(s32[] %constant.6179, s32[] %constant.6180), direction=LT + %constant.6182 = s32[] constant(0) + %constant.6183 = s32[] constant(32) + %add.6184 = s32[] add(s32[] %constant.6182, s32[] %constant.6183) + %constant.6185 = s32[] constant(0) + %select.6186 = s32[] select(pred[] %compare.6181, s32[] %add.6184, s32[] %constant.6185) + %constant.6187 = s32[] constant(0) + %constant.6188 = s32[] constant(0) + %compare.6189 = pred[] compare(s32[] %constant.6187, s32[] %constant.6188), direction=LT + %constant.6190 = s32[] constant(0) + %constant.6191 = s32[] constant(8) + %add.6192 = s32[] add(s32[] %constant.6190, s32[] %constant.6191) + %constant.6193 = s32[] constant(0) + %select.6194 = s32[] select(pred[] %compare.6189, s32[] %add.6192, s32[] %constant.6193) + %dynamic-slice.6195 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4950, s32[] %select.6162, s32[] %select.6170, s32[] %select.6178, s32[] %select.6186, /*index=5*/s32[] %select.6194), dynamic_slice_sizes={1,16,32,32,8} + %reshape.6196 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.6195) + %constant.6080 = s32[] constant(0) + %compare.6081 = pred[] compare(s32[] %subtract.4984, s32[] %constant.6080), direction=LT + %constant.6082 = s32[] constant(2) + %add.6083 = s32[] add(s32[] %subtract.4984, s32[] %constant.6082) + %select.6084 = s32[] select(pred[] %compare.6081, s32[] %add.6083, s32[] %subtract.4984) + %constant.6085 = s32[] constant(0) + %constant.6086 = s32[] constant(0) + %compare.6087 = pred[] compare(s32[] %constant.6085, s32[] %constant.6086), direction=LT + %constant.6088 = s32[] constant(0) + %constant.6089 = s32[] constant(16) + %add.6090 = s32[] add(s32[] %constant.6088, s32[] %constant.6089) + %constant.6091 = s32[] constant(0) + %select.6092 = s32[] select(pred[] %compare.6087, s32[] %add.6090, s32[] %constant.6091) + %constant.6093 = s32[] constant(0) + %constant.6094 = s32[] constant(0) + %compare.6095 = pred[] compare(s32[] %constant.6093, s32[] %constant.6094), direction=LT + %constant.6096 = s32[] constant(0) + %constant.6097 = s32[] constant(32) + %add.6098 = s32[] add(s32[] %constant.6096, s32[] %constant.6097) + %constant.6099 = s32[] constant(0) + %select.6100 = s32[] select(pred[] %compare.6095, s32[] %add.6098, s32[] %constant.6099) + %constant.6101 = s32[] constant(0) + %constant.6102 = s32[] constant(0) + %compare.6103 = pred[] compare(s32[] %constant.6101, s32[] %constant.6102), direction=LT + %constant.6104 = s32[] constant(0) + %constant.6105 = s32[] constant(32) + %add.6106 = s32[] add(s32[] %constant.6104, s32[] %constant.6105) + %constant.6107 = s32[] constant(0) + %select.6108 = s32[] select(pred[] %compare.6103, s32[] %add.6106, s32[] %constant.6107) + %constant.6109 = s32[] constant(0) + %constant.6110 = s32[] constant(0) + %compare.6111 = pred[] compare(s32[] %constant.6109, s32[] %constant.6110), direction=LT + %constant.6112 = s32[] constant(0) + %constant.6113 = s32[] constant(8) + %add.6114 = s32[] add(s32[] %constant.6112, s32[] %constant.6113) + %constant.6115 = s32[] constant(0) + %select.6116 = s32[] select(pred[] %compare.6111, s32[] %add.6114, s32[] %constant.6115) + %dynamic-slice.6117 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4948, s32[] %select.6084, s32[] %select.6092, s32[] %select.6100, s32[] %select.6108, /*index=5*/s32[] %select.6116), dynamic_slice_sizes={1,16,32,32,8} + %reshape.6118 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.6117) + %multiply.6559 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %reshape.6118, f32[16,32,32,8]{3,2,1,0} %add.6558) + %constant.6560 = f32[] constant(0.5) + %broadcast.6561 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[] %constant.6560), dimensions={} + %multiply.6562 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %multiply.6559, f32[16,32,32,8]{3,2,1,0} %broadcast.6561) + %multiply.6563 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %reshape.6196, f32[16,32,32,8]{3,2,1,0} %multiply.6562) + %constant.6236 = s32[] constant(0) + %compare.6237 = pred[] compare(s32[] %subtract.4984, s32[] %constant.6236), direction=LT + %constant.6238 = s32[] constant(2) + %add.6239 = s32[] add(s32[] %subtract.4984, s32[] %constant.6238) + %select.6240 = s32[] select(pred[] %compare.6237, s32[] %add.6239, s32[] %subtract.4984) + %constant.6241 = s32[] constant(0) + %constant.6242 = s32[] constant(0) + %compare.6243 = pred[] compare(s32[] %constant.6241, s32[] %constant.6242), direction=LT + %constant.6244 = s32[] constant(0) + %constant.6245 = s32[] constant(16) + %add.6246 = s32[] add(s32[] %constant.6244, s32[] %constant.6245) + %constant.6247 = s32[] constant(0) + %select.6248 = s32[] select(pred[] %compare.6243, s32[] %add.6246, s32[] %constant.6247) + %constant.6249 = s32[] constant(0) + %constant.6250 = s32[] constant(0) + %compare.6251 = pred[] compare(s32[] %constant.6249, s32[] %constant.6250), direction=LT + %constant.6252 = s32[] constant(0) + %constant.6253 = s32[] constant(32) + %add.6254 = s32[] add(s32[] %constant.6252, s32[] %constant.6253) + %constant.6255 = s32[] constant(0) + %select.6256 = s32[] select(pred[] %compare.6251, s32[] %add.6254, s32[] %constant.6255) + %constant.6257 = s32[] constant(0) + %constant.6258 = s32[] constant(0) + %compare.6259 = pred[] compare(s32[] %constant.6257, s32[] %constant.6258), direction=LT + %constant.6260 = s32[] constant(0) + %constant.6261 = s32[] constant(32) + %add.6262 = s32[] add(s32[] %constant.6260, s32[] %constant.6261) + %constant.6263 = s32[] constant(0) + %select.6264 = s32[] select(pred[] %compare.6259, s32[] %add.6262, s32[] %constant.6263) + %constant.6265 = s32[] constant(0) + %constant.6266 = s32[] constant(0) + %compare.6267 = pred[] compare(s32[] %constant.6265, s32[] %constant.6266), direction=LT + %constant.6268 = s32[] constant(0) + %constant.6269 = s32[] constant(8) + %add.6270 = s32[] add(s32[] %constant.6268, s32[] %constant.6269) + %constant.6271 = s32[] constant(0) + %select.6272 = s32[] select(pred[] %compare.6267, s32[] %add.6270, s32[] %constant.6271) + %dynamic-slice.6273 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4952, s32[] %select.6240, s32[] %select.6248, s32[] %select.6256, s32[] %select.6264, /*index=5*/s32[] %select.6272), dynamic_slice_sizes={1,16,32,32,8} + %reshape.6274 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.6273) + %multiply.6564 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %multiply.6563, f32[16,32,32,8]{3,2,1,0} %reshape.6274) + %constant.6197 = s32[] constant(0) + %compare.6198 = pred[] compare(s32[] %subtract.4984, s32[] %constant.6197), direction=LT + %constant.6199 = s32[] constant(2) + %add.6200 = s32[] add(s32[] %subtract.4984, s32[] %constant.6199) + %select.6201 = s32[] select(pred[] %compare.6198, s32[] %add.6200, s32[] %subtract.4984) + %constant.6202 = s32[] constant(0) + %constant.6203 = s32[] constant(0) + %compare.6204 = pred[] compare(s32[] %constant.6202, s32[] %constant.6203), direction=LT + %constant.6205 = s32[] constant(0) + %constant.6206 = s32[] constant(16) + %add.6207 = s32[] add(s32[] %constant.6205, s32[] %constant.6206) + %constant.6208 = s32[] constant(0) + %select.6209 = s32[] select(pred[] %compare.6204, s32[] %add.6207, s32[] %constant.6208) + %constant.6210 = s32[] constant(0) + %constant.6211 = s32[] constant(0) + %compare.6212 = pred[] compare(s32[] %constant.6210, s32[] %constant.6211), direction=LT + %constant.6213 = s32[] constant(0) + %constant.6214 = s32[] constant(32) + %add.6215 = s32[] add(s32[] %constant.6213, s32[] %constant.6214) + %constant.6216 = s32[] constant(0) + %select.6217 = s32[] select(pred[] %compare.6212, s32[] %add.6215, s32[] %constant.6216) + %constant.6218 = s32[] constant(0) + %constant.6219 = s32[] constant(0) + %compare.6220 = pred[] compare(s32[] %constant.6218, s32[] %constant.6219), direction=LT + %constant.6221 = s32[] constant(0) + %constant.6222 = s32[] constant(32) + %add.6223 = s32[] add(s32[] %constant.6221, s32[] %constant.6222) + %constant.6224 = s32[] constant(0) + %select.6225 = s32[] select(pred[] %compare.6220, s32[] %add.6223, s32[] %constant.6224) + %constant.6226 = s32[] constant(0) + %constant.6227 = s32[] constant(0) + %compare.6228 = pred[] compare(s32[] %constant.6226, s32[] %constant.6227), direction=LT + %constant.6229 = s32[] constant(0) + %constant.6230 = s32[] constant(8) + %add.6231 = s32[] add(s32[] %constant.6229, s32[] %constant.6230) + %constant.6232 = s32[] constant(0) + %select.6233 = s32[] select(pred[] %compare.6228, s32[] %add.6231, s32[] %constant.6232) + %dynamic-slice.6234 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4951, s32[] %select.6201, s32[] %select.6209, s32[] %select.6217, s32[] %select.6225, /*index=5*/s32[] %select.6233), dynamic_slice_sizes={1,16,32,32,8} + %reshape.6235 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.6234) + %multiply.6565 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %multiply.6564, f32[16,32,32,8]{3,2,1,0} %reshape.6235) + %constant.6119 = s32[] constant(0) + %compare.6120 = pred[] compare(s32[] %subtract.4984, s32[] %constant.6119), direction=LT + %constant.6121 = s32[] constant(2) + %add.6122 = s32[] add(s32[] %subtract.4984, s32[] %constant.6121) + %select.6123 = s32[] select(pred[] %compare.6120, s32[] %add.6122, s32[] %subtract.4984) + %constant.6124 = s32[] constant(0) + %constant.6125 = s32[] constant(0) + %compare.6126 = pred[] compare(s32[] %constant.6124, s32[] %constant.6125), direction=LT + %constant.6127 = s32[] constant(0) + %constant.6128 = s32[] constant(16) + %add.6129 = s32[] add(s32[] %constant.6127, s32[] %constant.6128) + %constant.6130 = s32[] constant(0) + %select.6131 = s32[] select(pred[] %compare.6126, s32[] %add.6129, s32[] %constant.6130) + %constant.6132 = s32[] constant(0) + %constant.6133 = s32[] constant(0) + %compare.6134 = pred[] compare(s32[] %constant.6132, s32[] %constant.6133), direction=LT + %constant.6135 = s32[] constant(0) + %constant.6136 = s32[] constant(32) + %add.6137 = s32[] add(s32[] %constant.6135, s32[] %constant.6136) + %constant.6138 = s32[] constant(0) + %select.6139 = s32[] select(pred[] %compare.6134, s32[] %add.6137, s32[] %constant.6138) + %constant.6140 = s32[] constant(0) + %constant.6141 = s32[] constant(0) + %compare.6142 = pred[] compare(s32[] %constant.6140, s32[] %constant.6141), direction=LT + %constant.6143 = s32[] constant(0) + %constant.6144 = s32[] constant(32) + %add.6145 = s32[] add(s32[] %constant.6143, s32[] %constant.6144) + %constant.6146 = s32[] constant(0) + %select.6147 = s32[] select(pred[] %compare.6142, s32[] %add.6145, s32[] %constant.6146) + %constant.6148 = s32[] constant(0) + %constant.6149 = s32[] constant(0) + %compare.6150 = pred[] compare(s32[] %constant.6148, s32[] %constant.6149), direction=LT + %constant.6151 = s32[] constant(0) + %constant.6152 = s32[] constant(8) + %add.6153 = s32[] add(s32[] %constant.6151, s32[] %constant.6152) + %constant.6154 = s32[] constant(0) + %select.6155 = s32[] select(pred[] %compare.6150, s32[] %add.6153, s32[] %constant.6154) + %dynamic-slice.6156 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4949, s32[] %select.6123, s32[] %select.6131, s32[] %select.6139, s32[] %select.6147, /*index=5*/s32[] %select.6155), dynamic_slice_sizes={1,16,32,32,8} + %reshape.6157 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.6156) + %multiply.6566 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %multiply.6562, f32[16,32,32,8]{3,2,1,0} %reshape.6157) + %add.6567 = f32[16,32,32,8]{3,2,1,0} add(f32[16,32,32,8]{3,2,1,0} %multiply.6565, f32[16,32,32,8]{3,2,1,0} %multiply.6566) + %constant.6568 = f32[] constant(0) + %pad.6569 = f32[16,32,32,16]{3,2,1,0} pad(f32[16,32,32,8]{3,2,1,0} %add.6567, f32[] %constant.6568), padding=0_0x0_0x0_0x8_0 + %constant.6041 = s32[] constant(0) + %compare.6042 = pred[] compare(s32[] %subtract.4984, s32[] %constant.6041), direction=LT + %constant.6043 = s32[] constant(2) + %add.6044 = s32[] add(s32[] %subtract.4984, s32[] %constant.6043) + %select.6045 = s32[] select(pred[] %compare.6042, s32[] %add.6044, s32[] %subtract.4984) + %constant.6046 = s32[] constant(0) + %constant.6047 = s32[] constant(0) + %compare.6048 = pred[] compare(s32[] %constant.6046, s32[] %constant.6047), direction=LT + %constant.6049 = s32[] constant(0) + %constant.6050 = s32[] constant(16) + %add.6051 = s32[] add(s32[] %constant.6049, s32[] %constant.6050) + %constant.6052 = s32[] constant(0) + %select.6053 = s32[] select(pred[] %compare.6048, s32[] %add.6051, s32[] %constant.6052) + %constant.6054 = s32[] constant(0) + %constant.6055 = s32[] constant(0) + %compare.6056 = pred[] compare(s32[] %constant.6054, s32[] %constant.6055), direction=LT + %constant.6057 = s32[] constant(0) + %constant.6058 = s32[] constant(32) + %add.6059 = s32[] add(s32[] %constant.6057, s32[] %constant.6058) + %constant.6060 = s32[] constant(0) + %select.6061 = s32[] select(pred[] %compare.6056, s32[] %add.6059, s32[] %constant.6060) + %constant.6062 = s32[] constant(0) + %constant.6063 = s32[] constant(0) + %compare.6064 = pred[] compare(s32[] %constant.6062, s32[] %constant.6063), direction=LT + %constant.6065 = s32[] constant(0) + %constant.6066 = s32[] constant(32) + %add.6067 = s32[] add(s32[] %constant.6065, s32[] %constant.6066) + %constant.6068 = s32[] constant(0) + %select.6069 = s32[] select(pred[] %compare.6064, s32[] %add.6067, s32[] %constant.6068) + %constant.6070 = s32[] constant(0) + %constant.6071 = s32[] constant(0) + %compare.6072 = pred[] compare(s32[] %constant.6070, s32[] %constant.6071), direction=LT + %constant.6073 = s32[] constant(0) + %constant.6074 = s32[] constant(8) + %add.6075 = s32[] add(s32[] %constant.6073, s32[] %constant.6074) + %constant.6076 = s32[] constant(0) + %select.6077 = s32[] select(pred[] %compare.6072, s32[] %add.6075, s32[] %constant.6076) + %dynamic-slice.6078 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4947, s32[] %select.6045, s32[] %select.6053, s32[] %select.6061, s32[] %select.6069, /*index=5*/s32[] %select.6077), dynamic_slice_sizes={1,16,32,32,8} + %reshape.6079 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.6078) + %multiply.6570 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %add.6558, f32[16,32,32,8]{3,2,1,0} %reshape.6079) + %constant.6571 = f32[] constant(0) + %pad.6572 = f32[16,32,32,16]{3,2,1,0} pad(f32[16,32,32,8]{3,2,1,0} %multiply.6570, f32[] %constant.6571), padding=0_0x0_0x0_0x0_8 + %add.6573 = f32[16,32,32,16]{3,2,1,0} add(f32[16,32,32,16]{3,2,1,0} %pad.6569, f32[16,32,32,16]{3,2,1,0} %pad.6572) + %constant.5963 = s32[] constant(0) + %compare.5964 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5963), direction=LT + %constant.5965 = s32[] constant(2) + %add.5966 = s32[] add(s32[] %subtract.4984, s32[] %constant.5965) + %select.5967 = s32[] select(pred[] %compare.5964, s32[] %add.5966, s32[] %subtract.4984) + %constant.5968 = s32[] constant(0) + %constant.5969 = s32[] constant(0) + %compare.5970 = pred[] compare(s32[] %constant.5968, s32[] %constant.5969), direction=LT + %constant.5971 = s32[] constant(0) + %constant.5972 = s32[] constant(1) + %add.5973 = s32[] add(s32[] %constant.5971, s32[] %constant.5972) + %constant.5974 = s32[] constant(0) + %select.5975 = s32[] select(pred[] %compare.5970, s32[] %add.5973, s32[] %constant.5974) + %constant.5976 = s32[] constant(0) + %constant.5977 = s32[] constant(0) + %compare.5978 = pred[] compare(s32[] %constant.5976, s32[] %constant.5977), direction=LT + %constant.5979 = s32[] constant(0) + %constant.5980 = s32[] constant(1) + %add.5981 = s32[] add(s32[] %constant.5979, s32[] %constant.5980) + %constant.5982 = s32[] constant(0) + %select.5983 = s32[] select(pred[] %compare.5978, s32[] %add.5981, s32[] %constant.5982) + %constant.5984 = s32[] constant(0) + %constant.5985 = s32[] constant(0) + %compare.5986 = pred[] compare(s32[] %constant.5984, s32[] %constant.5985), direction=LT + %constant.5987 = s32[] constant(0) + %constant.5988 = s32[] constant(1) + %add.5989 = s32[] add(s32[] %constant.5987, s32[] %constant.5988) + %constant.5990 = s32[] constant(0) + %select.5991 = s32[] select(pred[] %compare.5986, s32[] %add.5989, s32[] %constant.5990) + %constant.5992 = s32[] constant(0) + %constant.5993 = s32[] constant(0) + %compare.5994 = pred[] compare(s32[] %constant.5992, s32[] %constant.5993), direction=LT + %constant.5995 = s32[] constant(0) + %constant.5996 = s32[] constant(16) + %add.5997 = s32[] add(s32[] %constant.5995, s32[] %constant.5996) + %constant.5998 = s32[] constant(0) + %select.5999 = s32[] select(pred[] %compare.5994, s32[] %add.5997, s32[] %constant.5998) + %dynamic-slice.6000 = f32[1,1,1,1,16]{4,3,2,1,0} dynamic-slice(f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.4945, s32[] %select.5967, s32[] %select.5975, s32[] %select.5983, s32[] %select.5991, /*index=5*/s32[] %select.5999), dynamic_slice_sizes={1,1,1,1,16} + %reshape.6001 = f32[1,1,1,16]{3,2,1,0} reshape(f32[1,1,1,1,16]{4,3,2,1,0} %dynamic-slice.6000) + %reshape.6589 = f32[16]{0} reshape(f32[1,1,1,16]{3,2,1,0} %reshape.6001) + %broadcast.6590 = f32[16,32,32,16]{3,2,1,0} broadcast(f32[16]{0} %reshape.6589), dimensions={3} + %multiply.6591 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %add.6573, f32[16,32,32,16]{3,2,1,0} %broadcast.6590) + %constant.5753 = s32[] constant(0) + %compare.5754 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5753), direction=LT + %constant.5755 = s32[] constant(2) + %add.5756 = s32[] add(s32[] %subtract.4984, s32[] %constant.5755) + %select.5757 = s32[] select(pred[] %compare.5754, s32[] %add.5756, s32[] %subtract.4984) + %constant.5758 = s32[] constant(0) + %constant.5759 = s32[] constant(0) + %compare.5760 = pred[] compare(s32[] %constant.5758, s32[] %constant.5759), direction=LT + %constant.5761 = s32[] constant(0) + %constant.5762 = s32[] constant(1) + %add.5763 = s32[] add(s32[] %constant.5761, s32[] %constant.5762) + %constant.5764 = s32[] constant(0) + %select.5765 = s32[] select(pred[] %compare.5760, s32[] %add.5763, s32[] %constant.5764) + %constant.5766 = s32[] constant(0) + %constant.5767 = s32[] constant(0) + %compare.5768 = pred[] compare(s32[] %constant.5766, s32[] %constant.5767), direction=LT + %constant.5769 = s32[] constant(0) + %constant.5770 = s32[] constant(1) + %add.5771 = s32[] add(s32[] %constant.5769, s32[] %constant.5770) + %constant.5772 = s32[] constant(0) + %select.5773 = s32[] select(pred[] %compare.5768, s32[] %add.5771, s32[] %constant.5772) + %constant.5774 = s32[] constant(0) + %constant.5775 = s32[] constant(0) + %compare.5776 = pred[] compare(s32[] %constant.5774, s32[] %constant.5775), direction=LT + %constant.5777 = s32[] constant(0) + %constant.5778 = s32[] constant(16) + %add.5779 = s32[] add(s32[] %constant.5777, s32[] %constant.5778) + %constant.5780 = s32[] constant(0) + %select.5781 = s32[] select(pred[] %compare.5776, s32[] %add.5779, s32[] %constant.5780) + %constant.5782 = s32[] constant(0) + %constant.5783 = s32[] constant(0) + %compare.5784 = pred[] compare(s32[] %constant.5782, s32[] %constant.5783), direction=LT + %constant.5785 = s32[] constant(0) + %constant.5786 = s32[] constant(16) + %add.5787 = s32[] add(s32[] %constant.5785, s32[] %constant.5786) + %constant.5788 = s32[] constant(0) + %select.5789 = s32[] select(pred[] %compare.5784, s32[] %add.5787, s32[] %constant.5788) + %dynamic-slice.5790 = f32[1,1,1,16,16]{4,3,2,1,0} dynamic-slice(f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.4939, s32[] %select.5757, s32[] %select.5765, s32[] %select.5773, s32[] %select.5781, /*index=5*/s32[] %select.5789), dynamic_slice_sizes={1,1,1,16,16} + %reshape.5791 = f32[1,1,16,16]{3,2,1,0} reshape(f32[1,1,1,16,16]{4,3,2,1,0} %dynamic-slice.5790) + %reverse.6608 = f32[1,1,16,16]{3,2,1,0} reverse(f32[1,1,16,16]{3,2,1,0} %reshape.5791), dimensions={0,1} + %convolution.6609 = f32[16,32,32,16]{3,2,1,0} convolution(f32[16,32,32,16]{3,2,1,0} %multiply.6591, f32[1,1,16,16]{3,2,1,0} %reverse.6608), window={size=1x1}, dim_labels=b01f_01oi->b01f + %constant.6610 = f32[] constant(0.5) + %broadcast.6611 = f32[16,32,32,16]{3,2,1,0} broadcast(f32[] %constant.6610), dimensions={} + %multiply.6612 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %convolution.6609, f32[16,32,32,16]{3,2,1,0} %broadcast.6611) + %constant.5675 = s32[] constant(0) + %compare.5676 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5675), direction=LT + %constant.5677 = s32[] constant(2) + %add.5678 = s32[] add(s32[] %subtract.4984, s32[] %constant.5677) + %select.5679 = s32[] select(pred[] %compare.5676, s32[] %add.5678, s32[] %subtract.4984) + %constant.5680 = s32[] constant(0) + %constant.5681 = s32[] constant(0) + %compare.5682 = pred[] compare(s32[] %constant.5680, s32[] %constant.5681), direction=LT + %constant.5683 = s32[] constant(0) + %constant.5684 = s32[] constant(16) + %add.5685 = s32[] add(s32[] %constant.5683, s32[] %constant.5684) + %constant.5686 = s32[] constant(0) + %select.5687 = s32[] select(pred[] %compare.5682, s32[] %add.5685, s32[] %constant.5686) + %constant.5688 = s32[] constant(0) + %constant.5689 = s32[] constant(0) + %compare.5690 = pred[] compare(s32[] %constant.5688, s32[] %constant.5689), direction=LT + %constant.5691 = s32[] constant(0) + %constant.5692 = s32[] constant(32) + %add.5693 = s32[] add(s32[] %constant.5691, s32[] %constant.5692) + %constant.5694 = s32[] constant(0) + %select.5695 = s32[] select(pred[] %compare.5690, s32[] %add.5693, s32[] %constant.5694) + %constant.5696 = s32[] constant(0) + %constant.5697 = s32[] constant(0) + %compare.5698 = pred[] compare(s32[] %constant.5696, s32[] %constant.5697), direction=LT + %constant.5699 = s32[] constant(0) + %constant.5700 = s32[] constant(32) + %add.5701 = s32[] add(s32[] %constant.5699, s32[] %constant.5700) + %constant.5702 = s32[] constant(0) + %select.5703 = s32[] select(pred[] %compare.5698, s32[] %add.5701, s32[] %constant.5702) + %constant.5704 = s32[] constant(0) + %constant.5705 = s32[] constant(0) + %compare.5706 = pred[] compare(s32[] %constant.5704, s32[] %constant.5705), direction=LT + %constant.5707 = s32[] constant(0) + %constant.5708 = s32[] constant(16) + %add.5709 = s32[] add(s32[] %constant.5707, s32[] %constant.5708) + %constant.5710 = s32[] constant(0) + %select.5711 = s32[] select(pred[] %compare.5706, s32[] %add.5709, s32[] %constant.5710) + %dynamic-slice.5712 = f32[1,16,32,32,16]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4937, s32[] %select.5679, s32[] %select.5687, s32[] %select.5695, s32[] %select.5703, /*index=5*/s32[] %select.5711), dynamic_slice_sizes={1,16,32,32,16} + %reshape.5713 = f32[16,32,32,16]{3,2,1,0} reshape(f32[1,16,32,32,16]{4,3,2,1,0} %dynamic-slice.5712) + %multiply.6613 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %reshape.5713, f32[16,32,32,16]{3,2,1,0} %multiply.6612) + %constant.5714 = s32[] constant(0) + %compare.5715 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5714), direction=LT + %constant.5716 = s32[] constant(2) + %add.5717 = s32[] add(s32[] %subtract.4984, s32[] %constant.5716) + %select.5718 = s32[] select(pred[] %compare.5715, s32[] %add.5717, s32[] %subtract.4984) + %constant.5719 = s32[] constant(0) + %constant.5720 = s32[] constant(0) + %compare.5721 = pred[] compare(s32[] %constant.5719, s32[] %constant.5720), direction=LT + %constant.5722 = s32[] constant(0) + %constant.5723 = s32[] constant(16) + %add.5724 = s32[] add(s32[] %constant.5722, s32[] %constant.5723) + %constant.5725 = s32[] constant(0) + %select.5726 = s32[] select(pred[] %compare.5721, s32[] %add.5724, s32[] %constant.5725) + %constant.5727 = s32[] constant(0) + %constant.5728 = s32[] constant(0) + %compare.5729 = pred[] compare(s32[] %constant.5727, s32[] %constant.5728), direction=LT + %constant.5730 = s32[] constant(0) + %constant.5731 = s32[] constant(32) + %add.5732 = s32[] add(s32[] %constant.5730, s32[] %constant.5731) + %constant.5733 = s32[] constant(0) + %select.5734 = s32[] select(pred[] %compare.5729, s32[] %add.5732, s32[] %constant.5733) + %constant.5735 = s32[] constant(0) + %constant.5736 = s32[] constant(0) + %compare.5737 = pred[] compare(s32[] %constant.5735, s32[] %constant.5736), direction=LT + %constant.5738 = s32[] constant(0) + %constant.5739 = s32[] constant(32) + %add.5740 = s32[] add(s32[] %constant.5738, s32[] %constant.5739) + %constant.5741 = s32[] constant(0) + %select.5742 = s32[] select(pred[] %compare.5737, s32[] %add.5740, s32[] %constant.5741) + %constant.5743 = s32[] constant(0) + %constant.5744 = s32[] constant(0) + %compare.5745 = pred[] compare(s32[] %constant.5743, s32[] %constant.5744), direction=LT + %constant.5746 = s32[] constant(0) + %constant.5747 = s32[] constant(16) + %add.5748 = s32[] add(s32[] %constant.5746, s32[] %constant.5747) + %constant.5749 = s32[] constant(0) + %select.5750 = s32[] select(pred[] %compare.5745, s32[] %add.5748, s32[] %constant.5749) + %dynamic-slice.5751 = f32[1,16,32,32,16]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4938, s32[] %select.5718, s32[] %select.5726, s32[] %select.5734, s32[] %select.5742, /*index=5*/s32[] %select.5750), dynamic_slice_sizes={1,16,32,32,16} + %reshape.5752 = f32[16,32,32,16]{3,2,1,0} reshape(f32[1,16,32,32,16]{4,3,2,1,0} %dynamic-slice.5751) + %multiply.6614 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %multiply.6613, f32[16,32,32,16]{3,2,1,0} %reshape.5752) + %constant.5636 = s32[] constant(0) + %compare.5637 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5636), direction=LT + %constant.5638 = s32[] constant(2) + %add.5639 = s32[] add(s32[] %subtract.4984, s32[] %constant.5638) + %select.5640 = s32[] select(pred[] %compare.5637, s32[] %add.5639, s32[] %subtract.4984) + %constant.5641 = s32[] constant(0) + %constant.5642 = s32[] constant(0) + %compare.5643 = pred[] compare(s32[] %constant.5641, s32[] %constant.5642), direction=LT + %constant.5644 = s32[] constant(0) + %constant.5645 = s32[] constant(16) + %add.5646 = s32[] add(s32[] %constant.5644, s32[] %constant.5645) + %constant.5647 = s32[] constant(0) + %select.5648 = s32[] select(pred[] %compare.5643, s32[] %add.5646, s32[] %constant.5647) + %constant.5649 = s32[] constant(0) + %constant.5650 = s32[] constant(0) + %compare.5651 = pred[] compare(s32[] %constant.5649, s32[] %constant.5650), direction=LT + %constant.5652 = s32[] constant(0) + %constant.5653 = s32[] constant(32) + %add.5654 = s32[] add(s32[] %constant.5652, s32[] %constant.5653) + %constant.5655 = s32[] constant(0) + %select.5656 = s32[] select(pred[] %compare.5651, s32[] %add.5654, s32[] %constant.5655) + %constant.5657 = s32[] constant(0) + %constant.5658 = s32[] constant(0) + %compare.5659 = pred[] compare(s32[] %constant.5657, s32[] %constant.5658), direction=LT + %constant.5660 = s32[] constant(0) + %constant.5661 = s32[] constant(32) + %add.5662 = s32[] add(s32[] %constant.5660, s32[] %constant.5661) + %constant.5663 = s32[] constant(0) + %select.5664 = s32[] select(pred[] %compare.5659, s32[] %add.5662, s32[] %constant.5663) + %constant.5665 = s32[] constant(0) + %constant.5666 = s32[] constant(0) + %compare.5667 = pred[] compare(s32[] %constant.5665, s32[] %constant.5666), direction=LT + %constant.5668 = s32[] constant(0) + %constant.5669 = s32[] constant(16) + %add.5670 = s32[] add(s32[] %constant.5668, s32[] %constant.5669) + %constant.5671 = s32[] constant(0) + %select.5672 = s32[] select(pred[] %compare.5667, s32[] %add.5670, s32[] %constant.5671) + %dynamic-slice.5673 = f32[1,16,32,32,16]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4936, s32[] %select.5640, s32[] %select.5648, s32[] %select.5656, s32[] %select.5664, /*index=5*/s32[] %select.5672), dynamic_slice_sizes={1,16,32,32,16} + %reshape.5674 = f32[16,32,32,16]{3,2,1,0} reshape(f32[1,16,32,32,16]{4,3,2,1,0} %dynamic-slice.5673) + %multiply.6615 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %multiply.6612, f32[16,32,32,16]{3,2,1,0} %reshape.5674) + %add.6616 = f32[16,32,32,16]{3,2,1,0} add(f32[16,32,32,16]{3,2,1,0} %multiply.6614, f32[16,32,32,16]{3,2,1,0} %multiply.6615) + %constant.5597 = s32[] constant(0) + %compare.5598 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5597), direction=LT + %constant.5599 = s32[] constant(2) + %add.5600 = s32[] add(s32[] %subtract.4984, s32[] %constant.5599) + %select.5601 = s32[] select(pred[] %compare.5598, s32[] %add.5600, s32[] %subtract.4984) + %constant.5602 = s32[] constant(0) + %constant.5603 = s32[] constant(0) + %compare.5604 = pred[] compare(s32[] %constant.5602, s32[] %constant.5603), direction=LT + %constant.5605 = s32[] constant(0) + %constant.5606 = s32[] constant(16) + %add.5607 = s32[] add(s32[] %constant.5605, s32[] %constant.5606) + %constant.5608 = s32[] constant(0) + %select.5609 = s32[] select(pred[] %compare.5604, s32[] %add.5607, s32[] %constant.5608) + %constant.5610 = s32[] constant(0) + %constant.5611 = s32[] constant(0) + %compare.5612 = pred[] compare(s32[] %constant.5610, s32[] %constant.5611), direction=LT + %constant.5613 = s32[] constant(0) + %constant.5614 = s32[] constant(32) + %add.5615 = s32[] add(s32[] %constant.5613, s32[] %constant.5614) + %constant.5616 = s32[] constant(0) + %select.5617 = s32[] select(pred[] %compare.5612, s32[] %add.5615, s32[] %constant.5616) + %constant.5618 = s32[] constant(0) + %constant.5619 = s32[] constant(0) + %compare.5620 = pred[] compare(s32[] %constant.5618, s32[] %constant.5619), direction=LT + %constant.5621 = s32[] constant(0) + %constant.5622 = s32[] constant(32) + %add.5623 = s32[] add(s32[] %constant.5621, s32[] %constant.5622) + %constant.5624 = s32[] constant(0) + %select.5625 = s32[] select(pred[] %compare.5620, s32[] %add.5623, s32[] %constant.5624) + %constant.5626 = s32[] constant(0) + %constant.5627 = s32[] constant(0) + %compare.5628 = pred[] compare(s32[] %constant.5626, s32[] %constant.5627), direction=LT + %constant.5629 = s32[] constant(0) + %constant.5630 = s32[] constant(16) + %add.5631 = s32[] add(s32[] %constant.5629, s32[] %constant.5630) + %constant.5632 = s32[] constant(0) + %select.5633 = s32[] select(pred[] %compare.5628, s32[] %add.5631, s32[] %constant.5632) + %dynamic-slice.5634 = f32[1,16,32,32,16]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4935, s32[] %select.5601, s32[] %select.5609, s32[] %select.5617, s32[] %select.5625, /*index=5*/s32[] %select.5633), dynamic_slice_sizes={1,16,32,32,16} + %reshape.5635 = f32[16,32,32,16]{3,2,1,0} reshape(f32[1,16,32,32,16]{4,3,2,1,0} %dynamic-slice.5634) + %multiply.6617 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %add.6616, f32[16,32,32,16]{3,2,1,0} %reshape.5635) + %add.6618 = f32[16,32,32,16]{3,2,1,0} add(f32[16,32,32,16]{3,2,1,0} %multiply.6612, f32[16,32,32,16]{3,2,1,0} %multiply.6617) + %constant.5519 = s32[] constant(0) + %compare.5520 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5519), direction=LT + %constant.5521 = s32[] constant(2) + %add.5522 = s32[] add(s32[] %subtract.4984, s32[] %constant.5521) + %select.5523 = s32[] select(pred[] %compare.5520, s32[] %add.5522, s32[] %subtract.4984) + %constant.5524 = s32[] constant(0) + %constant.5525 = s32[] constant(0) + %compare.5526 = pred[] compare(s32[] %constant.5524, s32[] %constant.5525), direction=LT + %constant.5527 = s32[] constant(0) + %constant.5528 = s32[] constant(1) + %add.5529 = s32[] add(s32[] %constant.5527, s32[] %constant.5528) + %constant.5530 = s32[] constant(0) + %select.5531 = s32[] select(pred[] %compare.5526, s32[] %add.5529, s32[] %constant.5530) + %constant.5532 = s32[] constant(0) + %constant.5533 = s32[] constant(0) + %compare.5534 = pred[] compare(s32[] %constant.5532, s32[] %constant.5533), direction=LT + %constant.5535 = s32[] constant(0) + %constant.5536 = s32[] constant(1) + %add.5537 = s32[] add(s32[] %constant.5535, s32[] %constant.5536) + %constant.5538 = s32[] constant(0) + %select.5539 = s32[] select(pred[] %compare.5534, s32[] %add.5537, s32[] %constant.5538) + %constant.5540 = s32[] constant(0) + %constant.5541 = s32[] constant(0) + %compare.5542 = pred[] compare(s32[] %constant.5540, s32[] %constant.5541), direction=LT + %constant.5543 = s32[] constant(0) + %constant.5544 = s32[] constant(1) + %add.5545 = s32[] add(s32[] %constant.5543, s32[] %constant.5544) + %constant.5546 = s32[] constant(0) + %select.5547 = s32[] select(pred[] %compare.5542, s32[] %add.5545, s32[] %constant.5546) + %constant.5548 = s32[] constant(0) + %constant.5549 = s32[] constant(0) + %compare.5550 = pred[] compare(s32[] %constant.5548, s32[] %constant.5549), direction=LT + %constant.5551 = s32[] constant(0) + %constant.5552 = s32[] constant(16) + %add.5553 = s32[] add(s32[] %constant.5551, s32[] %constant.5552) + %constant.5554 = s32[] constant(0) + %select.5555 = s32[] select(pred[] %compare.5550, s32[] %add.5553, s32[] %constant.5554) + %dynamic-slice.5556 = f32[1,1,1,1,16]{4,3,2,1,0} dynamic-slice(f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.4933, s32[] %select.5523, s32[] %select.5531, s32[] %select.5539, s32[] %select.5547, /*index=5*/s32[] %select.5555), dynamic_slice_sizes={1,1,1,1,16} + %reshape.5557 = f32[1,1,1,16]{3,2,1,0} reshape(f32[1,1,1,1,16]{4,3,2,1,0} %dynamic-slice.5556) + %reshape.6634 = f32[16]{0} reshape(f32[1,1,1,16]{3,2,1,0} %reshape.5557) + %broadcast.6635 = f32[16,32,32,16]{3,2,1,0} broadcast(f32[16]{0} %reshape.6634), dimensions={3} + %multiply.6636 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %add.6618, f32[16,32,32,16]{3,2,1,0} %broadcast.6635) + %constant.5309 = s32[] constant(0) + %compare.5310 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5309), direction=LT + %constant.5311 = s32[] constant(2) + %add.5312 = s32[] add(s32[] %subtract.4984, s32[] %constant.5311) + %select.5313 = s32[] select(pred[] %compare.5310, s32[] %add.5312, s32[] %subtract.4984) + %constant.5314 = s32[] constant(0) + %constant.5315 = s32[] constant(0) + %compare.5316 = pred[] compare(s32[] %constant.5314, s32[] %constant.5315), direction=LT + %constant.5317 = s32[] constant(0) + %constant.5318 = s32[] constant(3) + %add.5319 = s32[] add(s32[] %constant.5317, s32[] %constant.5318) + %constant.5320 = s32[] constant(0) + %select.5321 = s32[] select(pred[] %compare.5316, s32[] %add.5319, s32[] %constant.5320) + %constant.5322 = s32[] constant(0) + %constant.5323 = s32[] constant(0) + %compare.5324 = pred[] compare(s32[] %constant.5322, s32[] %constant.5323), direction=LT + %constant.5325 = s32[] constant(0) + %constant.5326 = s32[] constant(3) + %add.5327 = s32[] add(s32[] %constant.5325, s32[] %constant.5326) + %constant.5328 = s32[] constant(0) + %select.5329 = s32[] select(pred[] %compare.5324, s32[] %add.5327, s32[] %constant.5328) + %constant.5330 = s32[] constant(0) + %constant.5331 = s32[] constant(0) + %compare.5332 = pred[] compare(s32[] %constant.5330, s32[] %constant.5331), direction=LT + %constant.5333 = s32[] constant(0) + %constant.5334 = s32[] constant(8) + %add.5335 = s32[] add(s32[] %constant.5333, s32[] %constant.5334) + %constant.5336 = s32[] constant(0) + %select.5337 = s32[] select(pred[] %compare.5332, s32[] %add.5335, s32[] %constant.5336) + %constant.5338 = s32[] constant(0) + %constant.5339 = s32[] constant(0) + %compare.5340 = pred[] compare(s32[] %constant.5338, s32[] %constant.5339), direction=LT + %constant.5341 = s32[] constant(0) + %constant.5342 = s32[] constant(16) + %add.5343 = s32[] add(s32[] %constant.5341, s32[] %constant.5342) + %constant.5344 = s32[] constant(0) + %select.5345 = s32[] select(pred[] %compare.5340, s32[] %add.5343, s32[] %constant.5344) + %dynamic-slice.5346 = f32[1,3,3,8,16]{4,3,2,1,0} dynamic-slice(f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.4927, s32[] %select.5313, s32[] %select.5321, s32[] %select.5329, s32[] %select.5337, /*index=5*/s32[] %select.5345), dynamic_slice_sizes={1,3,3,8,16} + %reshape.5347 = f32[3,3,8,16]{3,2,1,0} reshape(f32[1,3,3,8,16]{4,3,2,1,0} %dynamic-slice.5346) + %reverse.6653 = f32[3,3,8,16]{3,2,1,0} reverse(f32[3,3,8,16]{3,2,1,0} %reshape.5347), dimensions={0,1} + %convolution.6654 = f32[16,32,32,8]{3,2,1,0} convolution(f32[16,32,32,16]{3,2,1,0} %multiply.6636, f32[3,3,8,16]{3,2,1,0} %reverse.6653), window={size=3x3 pad=1_1x1_1}, dim_labels=b01f_01oi->b01f + %constant.6655 = f32[] constant(0.5) + %broadcast.6656 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[] %constant.6655), dimensions={} + %multiply.6657 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %convolution.6654, f32[16,32,32,8]{3,2,1,0} %broadcast.6656) + %add.6658 = f32[16,32,32,8]{3,2,1,0} add(f32[16,32,32,8]{3,2,1,0} %add.6558, f32[16,32,32,8]{3,2,1,0} %multiply.6657) + %constant.5231 = s32[] constant(0) + %compare.5232 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5231), direction=LT + %constant.5233 = s32[] constant(2) + %add.5234 = s32[] add(s32[] %subtract.4984, s32[] %constant.5233) + %select.5235 = s32[] select(pred[] %compare.5232, s32[] %add.5234, s32[] %subtract.4984) + %constant.5236 = s32[] constant(0) + %constant.5237 = s32[] constant(0) + %compare.5238 = pred[] compare(s32[] %constant.5236, s32[] %constant.5237), direction=LT + %constant.5239 = s32[] constant(0) + %constant.5240 = s32[] constant(16) + %add.5241 = s32[] add(s32[] %constant.5239, s32[] %constant.5240) + %constant.5242 = s32[] constant(0) + %select.5243 = s32[] select(pred[] %compare.5238, s32[] %add.5241, s32[] %constant.5242) + %constant.5244 = s32[] constant(0) + %constant.5245 = s32[] constant(0) + %compare.5246 = pred[] compare(s32[] %constant.5244, s32[] %constant.5245), direction=LT + %constant.5247 = s32[] constant(0) + %constant.5248 = s32[] constant(32) + %add.5249 = s32[] add(s32[] %constant.5247, s32[] %constant.5248) + %constant.5250 = s32[] constant(0) + %select.5251 = s32[] select(pred[] %compare.5246, s32[] %add.5249, s32[] %constant.5250) + %constant.5252 = s32[] constant(0) + %constant.5253 = s32[] constant(0) + %compare.5254 = pred[] compare(s32[] %constant.5252, s32[] %constant.5253), direction=LT + %constant.5255 = s32[] constant(0) + %constant.5256 = s32[] constant(32) + %add.5257 = s32[] add(s32[] %constant.5255, s32[] %constant.5256) + %constant.5258 = s32[] constant(0) + %select.5259 = s32[] select(pred[] %compare.5254, s32[] %add.5257, s32[] %constant.5258) + %constant.5260 = s32[] constant(0) + %constant.5261 = s32[] constant(0) + %compare.5262 = pred[] compare(s32[] %constant.5260, s32[] %constant.5261), direction=LT + %constant.5263 = s32[] constant(0) + %constant.5264 = s32[] constant(8) + %add.5265 = s32[] add(s32[] %constant.5263, s32[] %constant.5264) + %constant.5266 = s32[] constant(0) + %select.5267 = s32[] select(pred[] %compare.5262, s32[] %add.5265, s32[] %constant.5266) + %dynamic-slice.5268 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4925, s32[] %select.5235, s32[] %select.5243, s32[] %select.5251, s32[] %select.5259, /*index=5*/s32[] %select.5267), dynamic_slice_sizes={1,16,32,32,8} + %reshape.5269 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.5268) + %multiply.6659 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %reshape.5269, f32[16,32,32,8]{3,2,1,0} %multiply.6657) + %constant.5270 = s32[] constant(0) + %compare.5271 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5270), direction=LT + %constant.5272 = s32[] constant(2) + %add.5273 = s32[] add(s32[] %subtract.4984, s32[] %constant.5272) + %select.5274 = s32[] select(pred[] %compare.5271, s32[] %add.5273, s32[] %subtract.4984) + %constant.5275 = s32[] constant(0) + %constant.5276 = s32[] constant(0) + %compare.5277 = pred[] compare(s32[] %constant.5275, s32[] %constant.5276), direction=LT + %constant.5278 = s32[] constant(0) + %constant.5279 = s32[] constant(16) + %add.5280 = s32[] add(s32[] %constant.5278, s32[] %constant.5279) + %constant.5281 = s32[] constant(0) + %select.5282 = s32[] select(pred[] %compare.5277, s32[] %add.5280, s32[] %constant.5281) + %constant.5283 = s32[] constant(0) + %constant.5284 = s32[] constant(0) + %compare.5285 = pred[] compare(s32[] %constant.5283, s32[] %constant.5284), direction=LT + %constant.5286 = s32[] constant(0) + %constant.5287 = s32[] constant(32) + %add.5288 = s32[] add(s32[] %constant.5286, s32[] %constant.5287) + %constant.5289 = s32[] constant(0) + %select.5290 = s32[] select(pred[] %compare.5285, s32[] %add.5288, s32[] %constant.5289) + %constant.5291 = s32[] constant(0) + %constant.5292 = s32[] constant(0) + %compare.5293 = pred[] compare(s32[] %constant.5291, s32[] %constant.5292), direction=LT + %constant.5294 = s32[] constant(0) + %constant.5295 = s32[] constant(32) + %add.5296 = s32[] add(s32[] %constant.5294, s32[] %constant.5295) + %constant.5297 = s32[] constant(0) + %select.5298 = s32[] select(pred[] %compare.5293, s32[] %add.5296, s32[] %constant.5297) + %constant.5299 = s32[] constant(0) + %constant.5300 = s32[] constant(0) + %compare.5301 = pred[] compare(s32[] %constant.5299, s32[] %constant.5300), direction=LT + %constant.5302 = s32[] constant(0) + %constant.5303 = s32[] constant(8) + %add.5304 = s32[] add(s32[] %constant.5302, s32[] %constant.5303) + %constant.5305 = s32[] constant(0) + %select.5306 = s32[] select(pred[] %compare.5301, s32[] %add.5304, s32[] %constant.5305) + %dynamic-slice.5307 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4926, s32[] %select.5274, s32[] %select.5282, s32[] %select.5290, s32[] %select.5298, /*index=5*/s32[] %select.5306), dynamic_slice_sizes={1,16,32,32,8} + %reshape.5308 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.5307) + %multiply.6660 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %multiply.6659, f32[16,32,32,8]{3,2,1,0} %reshape.5308) + %constant.5192 = s32[] constant(0) + %compare.5193 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5192), direction=LT + %constant.5194 = s32[] constant(2) + %add.5195 = s32[] add(s32[] %subtract.4984, s32[] %constant.5194) + %select.5196 = s32[] select(pred[] %compare.5193, s32[] %add.5195, s32[] %subtract.4984) + %constant.5197 = s32[] constant(0) + %constant.5198 = s32[] constant(0) + %compare.5199 = pred[] compare(s32[] %constant.5197, s32[] %constant.5198), direction=LT + %constant.5200 = s32[] constant(0) + %constant.5201 = s32[] constant(16) + %add.5202 = s32[] add(s32[] %constant.5200, s32[] %constant.5201) + %constant.5203 = s32[] constant(0) + %select.5204 = s32[] select(pred[] %compare.5199, s32[] %add.5202, s32[] %constant.5203) + %constant.5205 = s32[] constant(0) + %constant.5206 = s32[] constant(0) + %compare.5207 = pred[] compare(s32[] %constant.5205, s32[] %constant.5206), direction=LT + %constant.5208 = s32[] constant(0) + %constant.5209 = s32[] constant(32) + %add.5210 = s32[] add(s32[] %constant.5208, s32[] %constant.5209) + %constant.5211 = s32[] constant(0) + %select.5212 = s32[] select(pred[] %compare.5207, s32[] %add.5210, s32[] %constant.5211) + %constant.5213 = s32[] constant(0) + %constant.5214 = s32[] constant(0) + %compare.5215 = pred[] compare(s32[] %constant.5213, s32[] %constant.5214), direction=LT + %constant.5216 = s32[] constant(0) + %constant.5217 = s32[] constant(32) + %add.5218 = s32[] add(s32[] %constant.5216, s32[] %constant.5217) + %constant.5219 = s32[] constant(0) + %select.5220 = s32[] select(pred[] %compare.5215, s32[] %add.5218, s32[] %constant.5219) + %constant.5221 = s32[] constant(0) + %constant.5222 = s32[] constant(0) + %compare.5223 = pred[] compare(s32[] %constant.5221, s32[] %constant.5222), direction=LT + %constant.5224 = s32[] constant(0) + %constant.5225 = s32[] constant(8) + %add.5226 = s32[] add(s32[] %constant.5224, s32[] %constant.5225) + %constant.5227 = s32[] constant(0) + %select.5228 = s32[] select(pred[] %compare.5223, s32[] %add.5226, s32[] %constant.5227) + %dynamic-slice.5229 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4924, s32[] %select.5196, s32[] %select.5204, s32[] %select.5212, s32[] %select.5220, /*index=5*/s32[] %select.5228), dynamic_slice_sizes={1,16,32,32,8} + %reshape.5230 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.5229) + %multiply.6661 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %multiply.6657, f32[16,32,32,8]{3,2,1,0} %reshape.5230) + %add.6662 = f32[16,32,32,8]{3,2,1,0} add(f32[16,32,32,8]{3,2,1,0} %multiply.6660, f32[16,32,32,8]{3,2,1,0} %multiply.6661) + %constant.5153 = s32[] constant(0) + %compare.5154 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5153), direction=LT + %constant.5155 = s32[] constant(2) + %add.5156 = s32[] add(s32[] %subtract.4984, s32[] %constant.5155) + %select.5157 = s32[] select(pred[] %compare.5154, s32[] %add.5156, s32[] %subtract.4984) + %constant.5158 = s32[] constant(0) + %constant.5159 = s32[] constant(0) + %compare.5160 = pred[] compare(s32[] %constant.5158, s32[] %constant.5159), direction=LT + %constant.5161 = s32[] constant(0) + %constant.5162 = s32[] constant(16) + %add.5163 = s32[] add(s32[] %constant.5161, s32[] %constant.5162) + %constant.5164 = s32[] constant(0) + %select.5165 = s32[] select(pred[] %compare.5160, s32[] %add.5163, s32[] %constant.5164) + %constant.5166 = s32[] constant(0) + %constant.5167 = s32[] constant(0) + %compare.5168 = pred[] compare(s32[] %constant.5166, s32[] %constant.5167), direction=LT + %constant.5169 = s32[] constant(0) + %constant.5170 = s32[] constant(32) + %add.5171 = s32[] add(s32[] %constant.5169, s32[] %constant.5170) + %constant.5172 = s32[] constant(0) + %select.5173 = s32[] select(pred[] %compare.5168, s32[] %add.5171, s32[] %constant.5172) + %constant.5174 = s32[] constant(0) + %constant.5175 = s32[] constant(0) + %compare.5176 = pred[] compare(s32[] %constant.5174, s32[] %constant.5175), direction=LT + %constant.5177 = s32[] constant(0) + %constant.5178 = s32[] constant(32) + %add.5179 = s32[] add(s32[] %constant.5177, s32[] %constant.5178) + %constant.5180 = s32[] constant(0) + %select.5181 = s32[] select(pred[] %compare.5176, s32[] %add.5179, s32[] %constant.5180) + %constant.5182 = s32[] constant(0) + %constant.5183 = s32[] constant(0) + %compare.5184 = pred[] compare(s32[] %constant.5182, s32[] %constant.5183), direction=LT + %constant.5185 = s32[] constant(0) + %constant.5186 = s32[] constant(8) + %add.5187 = s32[] add(s32[] %constant.5185, s32[] %constant.5186) + %constant.5188 = s32[] constant(0) + %select.5189 = s32[] select(pred[] %compare.5184, s32[] %add.5187, s32[] %constant.5188) + %dynamic-slice.5190 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4923, s32[] %select.5157, s32[] %select.5165, s32[] %select.5173, s32[] %select.5181, /*index=5*/s32[] %select.5189), dynamic_slice_sizes={1,16,32,32,8} + %reshape.5191 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.5190) + %multiply.6663 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %add.6662, f32[16,32,32,8]{3,2,1,0} %reshape.5191) + %add.6664 = f32[16,32,32,8]{3,2,1,0} add(f32[16,32,32,8]{3,2,1,0} %add.6658, f32[16,32,32,8]{3,2,1,0} %multiply.6663) + %constant.6836 = pred[] constant(false) + %constant.6837 = pred[] constant(false) + %constant.6838 = pred[] constant(false) + %constant.6839 = pred[] constant(false) + %constant.6840 = pred[] constant(false) + %constant.6841 = pred[] constant(false) + %constant.6842 = pred[] constant(false) + %constant.6843 = pred[] constant(false) + %constant.6844 = pred[] constant(false) + %get-tuple-element.4972 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=57 + %constant.4985 = s32[] constant(0) + %compare.4986 = pred[] compare(s32[] %subtract.4984, s32[] %constant.4985), direction=LT + %constant.4987 = s32[] constant(2) + %add.4988 = s32[] add(s32[] %subtract.4984, s32[] %constant.4987) + %select.4989 = s32[] select(pred[] %compare.4986, s32[] %add.4988, s32[] %subtract.4984) + %constant.4990 = s32[] constant(0) + %constant.4991 = s32[] constant(0) + %compare.4992 = pred[] compare(s32[] %constant.4990, s32[] %constant.4991), direction=LT + %constant.4993 = s32[] constant(0) + %constant.4994 = s32[] constant(16) + %add.4995 = s32[] add(s32[] %constant.4993, s32[] %constant.4994) + %constant.4996 = s32[] constant(0) + %select.4997 = s32[] select(pred[] %compare.4992, s32[] %add.4995, s32[] %constant.4996) + %dynamic-slice.4998 = f32[1,16]{1,0} dynamic-slice(f32[2,16]{1,0} %get-tuple-element.4915, s32[] %select.4989, s32[] %select.4997), dynamic_slice_sizes={1,16} + %reshape.4999 = f32[16]{0} reshape(f32[1,16]{1,0} %dynamic-slice.4998) + %constant.6619 = f32[] constant(0) + %reduce.6620 = f32[16]{0} reduce(f32[16,32,32,16]{3,2,1,0} %add.6618, f32[] %constant.6619), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.4889 + %reshape.6621 = f32[1,1,1,16]{3,2,1,0} reshape(f32[16]{0} %reduce.6620) + %constant.6622 = f32[] constant(0) + %reduce.6623 = f32[16]{0} reduce(f32[1,1,1,16]{3,2,1,0} %reshape.6621, f32[] %constant.6622), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.4893 + %broadcast.6624 = f32[16]{0} broadcast(f32[16]{0} %reduce.6623), dimensions={0} + %add.6625 = f32[16]{0} add(f32[16]{0} %reshape.4999, f32[16]{0} %broadcast.6624) + %broadcast.6665 = f32[1,16]{1,0} broadcast(f32[16]{0} %add.6625), dimensions={1} + %constant.6666 = s32[] constant(0) + %compare.6667 = pred[] compare(s32[] %subtract.4984, s32[] %constant.6666), direction=LT + %constant.6668 = s32[] constant(2) + %add.6669 = s32[] add(s32[] %subtract.4984, s32[] %constant.6668) + %select.6670 = s32[] select(pred[] %compare.6667, s32[] %add.6669, s32[] %subtract.4984) + %constant.6671 = s32[] constant(0) + %constant.6672 = s32[] constant(0) + %compare.6673 = pred[] compare(s32[] %constant.6671, s32[] %constant.6672), direction=LT + %constant.6674 = s32[] constant(0) + %constant.6675 = s32[] constant(16) + %add.6676 = s32[] add(s32[] %constant.6674, s32[] %constant.6675) + %constant.6677 = s32[] constant(0) + %select.6678 = s32[] select(pred[] %compare.6673, s32[] %add.6676, s32[] %constant.6677) + %dynamic-update-slice.6679 = f32[2,16]{1,0} dynamic-update-slice(f32[2,16]{1,0} %get-tuple-element.4972, f32[1,16]{1,0} %broadcast.6665, s32[] %select.6670, s32[] %select.6678) + %get-tuple-element.4973 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=58 + %constant.5000 = s32[] constant(0) + %compare.5001 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5000), direction=LT + %constant.5002 = s32[] constant(2) + %add.5003 = s32[] add(s32[] %subtract.4984, s32[] %constant.5002) + %select.5004 = s32[] select(pred[] %compare.5001, s32[] %add.5003, s32[] %subtract.4984) + %constant.5005 = s32[] constant(0) + %constant.5006 = s32[] constant(0) + %compare.5007 = pred[] compare(s32[] %constant.5005, s32[] %constant.5006), direction=LT + %constant.5008 = s32[] constant(0) + %constant.5009 = s32[] constant(16) + %add.5010 = s32[] add(s32[] %constant.5008, s32[] %constant.5009) + %constant.5011 = s32[] constant(0) + %select.5012 = s32[] select(pred[] %compare.5007, s32[] %add.5010, s32[] %constant.5011) + %dynamic-slice.5013 = f32[1,16]{1,0} dynamic-slice(f32[2,16]{1,0} %get-tuple-element.4916, s32[] %select.5004, s32[] %select.5012), dynamic_slice_sizes={1,16} + %reshape.5014 = f32[16]{0} reshape(f32[1,16]{1,0} %dynamic-slice.5013) + %constant.5558 = s32[] constant(0) + %compare.5559 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5558), direction=LT + %constant.5560 = s32[] constant(2) + %add.5561 = s32[] add(s32[] %subtract.4984, s32[] %constant.5560) + %select.5562 = s32[] select(pred[] %compare.5559, s32[] %add.5561, s32[] %subtract.4984) + %constant.5563 = s32[] constant(0) + %constant.5564 = s32[] constant(0) + %compare.5565 = pred[] compare(s32[] %constant.5563, s32[] %constant.5564), direction=LT + %constant.5566 = s32[] constant(0) + %constant.5567 = s32[] constant(16) + %add.5568 = s32[] add(s32[] %constant.5566, s32[] %constant.5567) + %constant.5569 = s32[] constant(0) + %select.5570 = s32[] select(pred[] %compare.5565, s32[] %add.5568, s32[] %constant.5569) + %constant.5571 = s32[] constant(0) + %constant.5572 = s32[] constant(0) + %compare.5573 = pred[] compare(s32[] %constant.5571, s32[] %constant.5572), direction=LT + %constant.5574 = s32[] constant(0) + %constant.5575 = s32[] constant(32) + %add.5576 = s32[] add(s32[] %constant.5574, s32[] %constant.5575) + %constant.5577 = s32[] constant(0) + %select.5578 = s32[] select(pred[] %compare.5573, s32[] %add.5576, s32[] %constant.5577) + %constant.5579 = s32[] constant(0) + %constant.5580 = s32[] constant(0) + %compare.5581 = pred[] compare(s32[] %constant.5579, s32[] %constant.5580), direction=LT + %constant.5582 = s32[] constant(0) + %constant.5583 = s32[] constant(32) + %add.5584 = s32[] add(s32[] %constant.5582, s32[] %constant.5583) + %constant.5585 = s32[] constant(0) + %select.5586 = s32[] select(pred[] %compare.5581, s32[] %add.5584, s32[] %constant.5585) + %constant.5587 = s32[] constant(0) + %constant.5588 = s32[] constant(0) + %compare.5589 = pred[] compare(s32[] %constant.5587, s32[] %constant.5588), direction=LT + %constant.5590 = s32[] constant(0) + %constant.5591 = s32[] constant(16) + %add.5592 = s32[] add(s32[] %constant.5590, s32[] %constant.5591) + %constant.5593 = s32[] constant(0) + %select.5594 = s32[] select(pred[] %compare.5589, s32[] %add.5592, s32[] %constant.5593) + %dynamic-slice.5595 = f32[1,16,32,32,16]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4934, s32[] %select.5562, s32[] %select.5570, s32[] %select.5578, s32[] %select.5586, /*index=5*/s32[] %select.5594), dynamic_slice_sizes={1,16,32,32,16} + %reshape.5596 = f32[16,32,32,16]{3,2,1,0} reshape(f32[1,16,32,32,16]{4,3,2,1,0} %dynamic-slice.5595) + %multiply.6626 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %reshape.5596, f32[16,32,32,16]{3,2,1,0} %add.6618) + %constant.6627 = f32[] constant(0) + %reduce.6628 = f32[16]{0} reduce(f32[16,32,32,16]{3,2,1,0} %multiply.6626, f32[] %constant.6627), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.4897 + %reshape.6629 = f32[1,1,1,16]{3,2,1,0} reshape(f32[16]{0} %reduce.6628) + %constant.6630 = f32[] constant(0) + %reduce.6631 = f32[16]{0} reduce(f32[1,1,1,16]{3,2,1,0} %reshape.6629, f32[] %constant.6630), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.4901 + %broadcast.6632 = f32[16]{0} broadcast(f32[16]{0} %reduce.6631), dimensions={0} + %add.6633 = f32[16]{0} add(f32[16]{0} %reshape.5014, f32[16]{0} %broadcast.6632) + %broadcast.6680 = f32[1,16]{1,0} broadcast(f32[16]{0} %add.6633), dimensions={1} + %constant.6681 = s32[] constant(0) + %compare.6682 = pred[] compare(s32[] %subtract.4984, s32[] %constant.6681), direction=LT + %constant.6683 = s32[] constant(2) + %add.6684 = s32[] add(s32[] %subtract.4984, s32[] %constant.6683) + %select.6685 = s32[] select(pred[] %compare.6682, s32[] %add.6684, s32[] %subtract.4984) + %constant.6686 = s32[] constant(0) + %constant.6687 = s32[] constant(0) + %compare.6688 = pred[] compare(s32[] %constant.6686, s32[] %constant.6687), direction=LT + %constant.6689 = s32[] constant(0) + %constant.6690 = s32[] constant(16) + %add.6691 = s32[] add(s32[] %constant.6689, s32[] %constant.6690) + %constant.6692 = s32[] constant(0) + %select.6693 = s32[] select(pred[] %compare.6688, s32[] %add.6691, s32[] %constant.6692) + %dynamic-update-slice.6694 = f32[2,16]{1,0} dynamic-update-slice(f32[2,16]{1,0} %get-tuple-element.4973, f32[1,16]{1,0} %broadcast.6680, s32[] %select.6685, s32[] %select.6693) + %get-tuple-element.4974 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=59 + %constant.5015 = s32[] constant(0) + %compare.5016 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5015), direction=LT + %constant.5017 = s32[] constant(2) + %add.5018 = s32[] add(s32[] %subtract.4984, s32[] %constant.5017) + %select.5019 = s32[] select(pred[] %compare.5016, s32[] %add.5018, s32[] %subtract.4984) + %constant.5020 = s32[] constant(0) + %constant.5021 = s32[] constant(0) + %compare.5022 = pred[] compare(s32[] %constant.5020, s32[] %constant.5021), direction=LT + %constant.5023 = s32[] constant(0) + %constant.5024 = s32[] constant(3) + %add.5025 = s32[] add(s32[] %constant.5023, s32[] %constant.5024) + %constant.5026 = s32[] constant(0) + %select.5027 = s32[] select(pred[] %compare.5022, s32[] %add.5025, s32[] %constant.5026) + %constant.5028 = s32[] constant(0) + %constant.5029 = s32[] constant(0) + %compare.5030 = pred[] compare(s32[] %constant.5028, s32[] %constant.5029), direction=LT + %constant.5031 = s32[] constant(0) + %constant.5032 = s32[] constant(3) + %add.5033 = s32[] add(s32[] %constant.5031, s32[] %constant.5032) + %constant.5034 = s32[] constant(0) + %select.5035 = s32[] select(pred[] %compare.5030, s32[] %add.5033, s32[] %constant.5034) + %constant.5036 = s32[] constant(0) + %constant.5037 = s32[] constant(0) + %compare.5038 = pred[] compare(s32[] %constant.5036, s32[] %constant.5037), direction=LT + %constant.5039 = s32[] constant(0) + %constant.5040 = s32[] constant(8) + %add.5041 = s32[] add(s32[] %constant.5039, s32[] %constant.5040) + %constant.5042 = s32[] constant(0) + %select.5043 = s32[] select(pred[] %compare.5038, s32[] %add.5041, s32[] %constant.5042) + %constant.5044 = s32[] constant(0) + %constant.5045 = s32[] constant(0) + %compare.5046 = pred[] compare(s32[] %constant.5044, s32[] %constant.5045), direction=LT + %constant.5047 = s32[] constant(0) + %constant.5048 = s32[] constant(16) + %add.5049 = s32[] add(s32[] %constant.5047, s32[] %constant.5048) + %constant.5050 = s32[] constant(0) + %select.5051 = s32[] select(pred[] %compare.5046, s32[] %add.5049, s32[] %constant.5050) + %dynamic-slice.5052 = f32[1,3,3,8,16]{4,3,2,1,0} dynamic-slice(f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.4917, s32[] %select.5019, s32[] %select.5027, s32[] %select.5035, s32[] %select.5043, /*index=5*/s32[] %select.5051), dynamic_slice_sizes={1,3,3,8,16} + %reshape.5053 = f32[3,3,8,16]{3,2,1,0} reshape(f32[1,3,3,8,16]{4,3,2,1,0} %dynamic-slice.5052) + %constant.5426 = s32[] constant(0) + %compare.5427 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5426), direction=LT + %constant.5428 = s32[] constant(2) + %add.5429 = s32[] add(s32[] %subtract.4984, s32[] %constant.5428) + %select.5430 = s32[] select(pred[] %compare.5427, s32[] %add.5429, s32[] %subtract.4984) + %constant.5431 = s32[] constant(0) + %constant.5432 = s32[] constant(0) + %compare.5433 = pred[] compare(s32[] %constant.5431, s32[] %constant.5432), direction=LT + %constant.5434 = s32[] constant(0) + %constant.5435 = s32[] constant(3) + %add.5436 = s32[] add(s32[] %constant.5434, s32[] %constant.5435) + %constant.5437 = s32[] constant(0) + %select.5438 = s32[] select(pred[] %compare.5433, s32[] %add.5436, s32[] %constant.5437) + %constant.5439 = s32[] constant(0) + %constant.5440 = s32[] constant(0) + %compare.5441 = pred[] compare(s32[] %constant.5439, s32[] %constant.5440), direction=LT + %constant.5442 = s32[] constant(0) + %constant.5443 = s32[] constant(3) + %add.5444 = s32[] add(s32[] %constant.5442, s32[] %constant.5443) + %constant.5445 = s32[] constant(0) + %select.5446 = s32[] select(pred[] %compare.5441, s32[] %add.5444, s32[] %constant.5445) + %constant.5447 = s32[] constant(0) + %constant.5448 = s32[] constant(0) + %compare.5449 = pred[] compare(s32[] %constant.5447, s32[] %constant.5448), direction=LT + %constant.5450 = s32[] constant(0) + %constant.5451 = s32[] constant(8) + %add.5452 = s32[] add(s32[] %constant.5450, s32[] %constant.5451) + %constant.5453 = s32[] constant(0) + %select.5454 = s32[] select(pred[] %compare.5449, s32[] %add.5452, s32[] %constant.5453) + %constant.5455 = s32[] constant(0) + %constant.5456 = s32[] constant(0) + %compare.5457 = pred[] compare(s32[] %constant.5455, s32[] %constant.5456), direction=LT + %constant.5458 = s32[] constant(0) + %constant.5459 = s32[] constant(16) + %add.5460 = s32[] add(s32[] %constant.5458, s32[] %constant.5459) + %constant.5461 = s32[] constant(0) + %select.5462 = s32[] select(pred[] %compare.5457, s32[] %add.5460, s32[] %constant.5461) + %dynamic-slice.5463 = f32[1,3,3,8,16]{4,3,2,1,0} dynamic-slice(f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.4930, s32[] %select.5430, s32[] %select.5438, s32[] %select.5446, s32[] %select.5454, /*index=5*/s32[] %select.5462), dynamic_slice_sizes={1,3,3,8,16} + %reshape.5464 = f32[3,3,8,16]{3,2,1,0} reshape(f32[1,3,3,8,16]{4,3,2,1,0} %dynamic-slice.5463) + %constant.5348 = s32[] constant(0) + %compare.5349 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5348), direction=LT + %constant.5350 = s32[] constant(2) + %add.5351 = s32[] add(s32[] %subtract.4984, s32[] %constant.5350) + %select.5352 = s32[] select(pred[] %compare.5349, s32[] %add.5351, s32[] %subtract.4984) + %constant.5353 = s32[] constant(0) + %constant.5354 = s32[] constant(0) + %compare.5355 = pred[] compare(s32[] %constant.5353, s32[] %constant.5354), direction=LT + %constant.5356 = s32[] constant(0) + %constant.5357 = s32[] constant(16) + %add.5358 = s32[] add(s32[] %constant.5356, s32[] %constant.5357) + %constant.5359 = s32[] constant(0) + %select.5360 = s32[] select(pred[] %compare.5355, s32[] %add.5358, s32[] %constant.5359) + %constant.5361 = s32[] constant(0) + %constant.5362 = s32[] constant(0) + %compare.5363 = pred[] compare(s32[] %constant.5361, s32[] %constant.5362), direction=LT + %constant.5364 = s32[] constant(0) + %constant.5365 = s32[] constant(32) + %add.5366 = s32[] add(s32[] %constant.5364, s32[] %constant.5365) + %constant.5367 = s32[] constant(0) + %select.5368 = s32[] select(pred[] %compare.5363, s32[] %add.5366, s32[] %constant.5367) + %constant.5369 = s32[] constant(0) + %constant.5370 = s32[] constant(0) + %compare.5371 = pred[] compare(s32[] %constant.5369, s32[] %constant.5370), direction=LT + %constant.5372 = s32[] constant(0) + %constant.5373 = s32[] constant(32) + %add.5374 = s32[] add(s32[] %constant.5372, s32[] %constant.5373) + %constant.5375 = s32[] constant(0) + %select.5376 = s32[] select(pred[] %compare.5371, s32[] %add.5374, s32[] %constant.5375) + %constant.5377 = s32[] constant(0) + %constant.5378 = s32[] constant(0) + %compare.5379 = pred[] compare(s32[] %constant.5377, s32[] %constant.5378), direction=LT + %constant.5380 = s32[] constant(0) + %constant.5381 = s32[] constant(8) + %add.5382 = s32[] add(s32[] %constant.5380, s32[] %constant.5381) + %constant.5383 = s32[] constant(0) + %select.5384 = s32[] select(pred[] %compare.5379, s32[] %add.5382, s32[] %constant.5383) + %dynamic-slice.5385 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4928, s32[] %select.5352, s32[] %select.5360, s32[] %select.5368, s32[] %select.5376, /*index=5*/s32[] %select.5384), dynamic_slice_sizes={1,16,32,32,8} + %reshape.5386 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.5385) + %convolution.6637 = f32[3,3,8,16]{3,2,1,0} convolution(f32[16,32,32,8]{3,2,1,0} %reshape.5386, f32[16,32,32,16]{3,2,1,0} %multiply.6636), window={size=32x32 pad=1_1x1_1}, dim_labels=f01b_i01o->01bf + %multiply.6638 = f32[3,3,8,16]{3,2,1,0} multiply(f32[3,3,8,16]{3,2,1,0} %reshape.5464, f32[3,3,8,16]{3,2,1,0} %convolution.6637) + %constant.6639 = f32[] constant(0) + %reduce.6640 = f32[16]{0} reduce(f32[3,3,8,16]{3,2,1,0} %multiply.6638, f32[] %constant.6639), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.4905 + %reshape.6641 = f32[1,1,1,16]{3,2,1,0} reshape(f32[16]{0} %reduce.6640) + %constant.6642 = f32[] constant(0) + %reduce.6643 = f32[16]{0} reduce(f32[1,1,1,16]{3,2,1,0} %reshape.6641, f32[] %constant.6642), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.4909 + %broadcast.6644 = f32[16]{0} broadcast(f32[16]{0} %reduce.6643), dimensions={0} + %constant.5504 = s32[] constant(0) + %compare.5505 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5504), direction=LT + %constant.5506 = s32[] constant(2) + %add.5507 = s32[] add(s32[] %subtract.4984, s32[] %constant.5506) + %select.5508 = s32[] select(pred[] %compare.5505, s32[] %add.5507, s32[] %subtract.4984) + %constant.5509 = s32[] constant(0) + %constant.5510 = s32[] constant(0) + %compare.5511 = pred[] compare(s32[] %constant.5509, s32[] %constant.5510), direction=LT + %constant.5512 = s32[] constant(0) + %constant.5513 = s32[] constant(16) + %add.5514 = s32[] add(s32[] %constant.5512, s32[] %constant.5513) + %constant.5515 = s32[] constant(0) + %select.5516 = s32[] select(pred[] %compare.5511, s32[] %add.5514, s32[] %constant.5515) + %dynamic-slice.5517 = f32[1,16]{1,0} dynamic-slice(f32[2,16]{1,0} %get-tuple-element.4932, s32[] %select.5508, s32[] %select.5516), dynamic_slice_sizes={1,16} + %reshape.5518 = f32[16]{0} reshape(f32[1,16]{1,0} %dynamic-slice.5517) + %multiply.6645 = f32[16]{0} multiply(f32[16]{0} %broadcast.6644, f32[16]{0} %reshape.5518) + %broadcast.6646 = f32[3,3,8,16]{3,2,1,0} broadcast(f32[16]{0} %multiply.6645), dimensions={3} + %constant.5465 = s32[] constant(0) + %compare.5466 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5465), direction=LT + %constant.5467 = s32[] constant(2) + %add.5468 = s32[] add(s32[] %subtract.4984, s32[] %constant.5467) + %select.5469 = s32[] select(pred[] %compare.5466, s32[] %add.5468, s32[] %subtract.4984) + %constant.5470 = s32[] constant(0) + %constant.5471 = s32[] constant(0) + %compare.5472 = pred[] compare(s32[] %constant.5470, s32[] %constant.5471), direction=LT + %constant.5473 = s32[] constant(0) + %constant.5474 = s32[] constant(3) + %add.5475 = s32[] add(s32[] %constant.5473, s32[] %constant.5474) + %constant.5476 = s32[] constant(0) + %select.5477 = s32[] select(pred[] %compare.5472, s32[] %add.5475, s32[] %constant.5476) + %constant.5478 = s32[] constant(0) + %constant.5479 = s32[] constant(0) + %compare.5480 = pred[] compare(s32[] %constant.5478, s32[] %constant.5479), direction=LT + %constant.5481 = s32[] constant(0) + %constant.5482 = s32[] constant(3) + %add.5483 = s32[] add(s32[] %constant.5481, s32[] %constant.5482) + %constant.5484 = s32[] constant(0) + %select.5485 = s32[] select(pred[] %compare.5480, s32[] %add.5483, s32[] %constant.5484) + %constant.5486 = s32[] constant(0) + %constant.5487 = s32[] constant(0) + %compare.5488 = pred[] compare(s32[] %constant.5486, s32[] %constant.5487), direction=LT + %constant.5489 = s32[] constant(0) + %constant.5490 = s32[] constant(8) + %add.5491 = s32[] add(s32[] %constant.5489, s32[] %constant.5490) + %constant.5492 = s32[] constant(0) + %select.5493 = s32[] select(pred[] %compare.5488, s32[] %add.5491, s32[] %constant.5492) + %constant.5494 = s32[] constant(0) + %constant.5495 = s32[] constant(0) + %compare.5496 = pred[] compare(s32[] %constant.5494, s32[] %constant.5495), direction=LT + %constant.5497 = s32[] constant(0) + %constant.5498 = s32[] constant(16) + %add.5499 = s32[] add(s32[] %constant.5497, s32[] %constant.5498) + %constant.5500 = s32[] constant(0) + %select.5501 = s32[] select(pred[] %compare.5496, s32[] %add.5499, s32[] %constant.5500) + %dynamic-slice.5502 = f32[1,3,3,8,16]{4,3,2,1,0} dynamic-slice(f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.4931, s32[] %select.5469, s32[] %select.5477, s32[] %select.5485, s32[] %select.5493, /*index=5*/s32[] %select.5501), dynamic_slice_sizes={1,3,3,8,16} + %reshape.5503 = f32[3,3,8,16]{3,2,1,0} reshape(f32[1,3,3,8,16]{4,3,2,1,0} %dynamic-slice.5502) + %multiply.6647 = f32[3,3,8,16]{3,2,1,0} multiply(f32[3,3,8,16]{3,2,1,0} %broadcast.6646, f32[3,3,8,16]{3,2,1,0} %reshape.5503) + %add.6648 = f32[3,3,8,16]{3,2,1,0} add(f32[3,3,8,16]{3,2,1,0} %reshape.5053, f32[3,3,8,16]{3,2,1,0} %multiply.6647) + %constant.5387 = s32[] constant(0) + %compare.5388 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5387), direction=LT + %constant.5389 = s32[] constant(2) + %add.5390 = s32[] add(s32[] %subtract.4984, s32[] %constant.5389) + %select.5391 = s32[] select(pred[] %compare.5388, s32[] %add.5390, s32[] %subtract.4984) + %constant.5392 = s32[] constant(0) + %constant.5393 = s32[] constant(0) + %compare.5394 = pred[] compare(s32[] %constant.5392, s32[] %constant.5393), direction=LT + %constant.5395 = s32[] constant(0) + %constant.5396 = s32[] constant(1) + %add.5397 = s32[] add(s32[] %constant.5395, s32[] %constant.5396) + %constant.5398 = s32[] constant(0) + %select.5399 = s32[] select(pred[] %compare.5394, s32[] %add.5397, s32[] %constant.5398) + %constant.5400 = s32[] constant(0) + %constant.5401 = s32[] constant(0) + %compare.5402 = pred[] compare(s32[] %constant.5400, s32[] %constant.5401), direction=LT + %constant.5403 = s32[] constant(0) + %constant.5404 = s32[] constant(1) + %add.5405 = s32[] add(s32[] %constant.5403, s32[] %constant.5404) + %constant.5406 = s32[] constant(0) + %select.5407 = s32[] select(pred[] %compare.5402, s32[] %add.5405, s32[] %constant.5406) + %constant.5408 = s32[] constant(0) + %constant.5409 = s32[] constant(0) + %compare.5410 = pred[] compare(s32[] %constant.5408, s32[] %constant.5409), direction=LT + %constant.5411 = s32[] constant(0) + %constant.5412 = s32[] constant(1) + %add.5413 = s32[] add(s32[] %constant.5411, s32[] %constant.5412) + %constant.5414 = s32[] constant(0) + %select.5415 = s32[] select(pred[] %compare.5410, s32[] %add.5413, s32[] %constant.5414) + %constant.5416 = s32[] constant(0) + %constant.5417 = s32[] constant(0) + %compare.5418 = pred[] compare(s32[] %constant.5416, s32[] %constant.5417), direction=LT + %constant.5419 = s32[] constant(0) + %constant.5420 = s32[] constant(16) + %add.5421 = s32[] add(s32[] %constant.5419, s32[] %constant.5420) + %constant.5422 = s32[] constant(0) + %select.5423 = s32[] select(pred[] %compare.5418, s32[] %add.5421, s32[] %constant.5422) + %dynamic-slice.5424 = f32[1,1,1,1,16]{4,3,2,1,0} dynamic-slice(f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.4929, s32[] %select.5391, s32[] %select.5399, s32[] %select.5407, s32[] %select.5415, /*index=5*/s32[] %select.5423), dynamic_slice_sizes={1,1,1,1,16} + %reshape.5425 = f32[1,1,1,16]{3,2,1,0} reshape(f32[1,1,1,1,16]{4,3,2,1,0} %dynamic-slice.5424) + %reshape.6649 = f32[16]{0} reshape(f32[1,1,1,16]{3,2,1,0} %reshape.5425) + %broadcast.6650 = f32[3,3,8,16]{3,2,1,0} broadcast(f32[16]{0} %reshape.6649), dimensions={3} + %multiply.6651 = f32[3,3,8,16]{3,2,1,0} multiply(f32[3,3,8,16]{3,2,1,0} %convolution.6637, f32[3,3,8,16]{3,2,1,0} %broadcast.6650) + %add.6652 = f32[3,3,8,16]{3,2,1,0} add(f32[3,3,8,16]{3,2,1,0} %add.6648, f32[3,3,8,16]{3,2,1,0} %multiply.6651) + %broadcast.6695 = f32[1,3,3,8,16]{4,3,2,1,0} broadcast(f32[3,3,8,16]{3,2,1,0} %add.6652), dimensions={1,2,3,4} + %constant.6696 = s32[] constant(0) + %compare.6697 = pred[] compare(s32[] %subtract.4984, s32[] %constant.6696), direction=LT + %constant.6698 = s32[] constant(2) + %add.6699 = s32[] add(s32[] %subtract.4984, s32[] %constant.6698) + %select.6700 = s32[] select(pred[] %compare.6697, s32[] %add.6699, s32[] %subtract.4984) + %constant.6701 = s32[] constant(0) + %constant.6702 = s32[] constant(0) + %compare.6703 = pred[] compare(s32[] %constant.6701, s32[] %constant.6702), direction=LT + %constant.6704 = s32[] constant(0) + %constant.6705 = s32[] constant(3) + %add.6706 = s32[] add(s32[] %constant.6704, s32[] %constant.6705) + %constant.6707 = s32[] constant(0) + %select.6708 = s32[] select(pred[] %compare.6703, s32[] %add.6706, s32[] %constant.6707) + %constant.6709 = s32[] constant(0) + %constant.6710 = s32[] constant(0) + %compare.6711 = pred[] compare(s32[] %constant.6709, s32[] %constant.6710), direction=LT + %constant.6712 = s32[] constant(0) + %constant.6713 = s32[] constant(3) + %add.6714 = s32[] add(s32[] %constant.6712, s32[] %constant.6713) + %constant.6715 = s32[] constant(0) + %select.6716 = s32[] select(pred[] %compare.6711, s32[] %add.6714, s32[] %constant.6715) + %constant.6717 = s32[] constant(0) + %constant.6718 = s32[] constant(0) + %compare.6719 = pred[] compare(s32[] %constant.6717, s32[] %constant.6718), direction=LT + %constant.6720 = s32[] constant(0) + %constant.6721 = s32[] constant(8) + %add.6722 = s32[] add(s32[] %constant.6720, s32[] %constant.6721) + %constant.6723 = s32[] constant(0) + %select.6724 = s32[] select(pred[] %compare.6719, s32[] %add.6722, s32[] %constant.6723) + %constant.6725 = s32[] constant(0) + %constant.6726 = s32[] constant(0) + %compare.6727 = pred[] compare(s32[] %constant.6725, s32[] %constant.6726), direction=LT + %constant.6728 = s32[] constant(0) + %constant.6729 = s32[] constant(16) + %add.6730 = s32[] add(s32[] %constant.6728, s32[] %constant.6729) + %constant.6731 = s32[] constant(0) + %select.6732 = s32[] select(pred[] %compare.6727, s32[] %add.6730, s32[] %constant.6731) + %dynamic-update-slice.6733 = f32[2,3,3,8,16]{4,3,2,1,0} dynamic-update-slice(f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.4974, f32[1,3,3,8,16]{4,3,2,1,0} %broadcast.6695, s32[] %select.6700, s32[] %select.6708, s32[] %select.6716, /*index=5*/s32[] %select.6724, s32[] %select.6732) + %get-tuple-element.4975 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=60 + %constant.5054 = s32[] constant(0) + %compare.5055 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5054), direction=LT + %constant.5056 = s32[] constant(2) + %add.5057 = s32[] add(s32[] %subtract.4984, s32[] %constant.5056) + %select.5058 = s32[] select(pred[] %compare.5055, s32[] %add.5057, s32[] %subtract.4984) + %constant.5059 = s32[] constant(0) + %constant.5060 = s32[] constant(0) + %compare.5061 = pred[] compare(s32[] %constant.5059, s32[] %constant.5060), direction=LT + %constant.5062 = s32[] constant(0) + %constant.5063 = s32[] constant(16) + %add.5064 = s32[] add(s32[] %constant.5062, s32[] %constant.5063) + %constant.5065 = s32[] constant(0) + %select.5066 = s32[] select(pred[] %compare.5061, s32[] %add.5064, s32[] %constant.5065) + %dynamic-slice.5067 = f32[1,16]{1,0} dynamic-slice(f32[2,16]{1,0} %get-tuple-element.4918, s32[] %select.5058, s32[] %select.5066), dynamic_slice_sizes={1,16} + %reshape.5068 = f32[16]{0} reshape(f32[1,16]{1,0} %dynamic-slice.5067) + %constant.6574 = f32[] constant(0) + %reduce.6575 = f32[16]{0} reduce(f32[16,32,32,16]{3,2,1,0} %add.6573, f32[] %constant.6574), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.4865 + %reshape.6576 = f32[1,1,1,16]{3,2,1,0} reshape(f32[16]{0} %reduce.6575) + %constant.6577 = f32[] constant(0) + %reduce.6578 = f32[16]{0} reduce(f32[1,1,1,16]{3,2,1,0} %reshape.6576, f32[] %constant.6577), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.4869 + %broadcast.6579 = f32[16]{0} broadcast(f32[16]{0} %reduce.6578), dimensions={0} + %add.6580 = f32[16]{0} add(f32[16]{0} %reshape.5068, f32[16]{0} %broadcast.6579) + %broadcast.6734 = f32[1,16]{1,0} broadcast(f32[16]{0} %add.6580), dimensions={1} + %constant.6735 = s32[] constant(0) + %compare.6736 = pred[] compare(s32[] %subtract.4984, s32[] %constant.6735), direction=LT + %constant.6737 = s32[] constant(2) + %add.6738 = s32[] add(s32[] %subtract.4984, s32[] %constant.6737) + %select.6739 = s32[] select(pred[] %compare.6736, s32[] %add.6738, s32[] %subtract.4984) + %constant.6740 = s32[] constant(0) + %constant.6741 = s32[] constant(0) + %compare.6742 = pred[] compare(s32[] %constant.6740, s32[] %constant.6741), direction=LT + %constant.6743 = s32[] constant(0) + %constant.6744 = s32[] constant(16) + %add.6745 = s32[] add(s32[] %constant.6743, s32[] %constant.6744) + %constant.6746 = s32[] constant(0) + %select.6747 = s32[] select(pred[] %compare.6742, s32[] %add.6745, s32[] %constant.6746) + %dynamic-update-slice.6748 = f32[2,16]{1,0} dynamic-update-slice(f32[2,16]{1,0} %get-tuple-element.4975, f32[1,16]{1,0} %broadcast.6734, s32[] %select.6739, s32[] %select.6747) + %get-tuple-element.4976 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=61 + %constant.5069 = s32[] constant(0) + %compare.5070 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5069), direction=LT + %constant.5071 = s32[] constant(2) + %add.5072 = s32[] add(s32[] %subtract.4984, s32[] %constant.5071) + %select.5073 = s32[] select(pred[] %compare.5070, s32[] %add.5072, s32[] %subtract.4984) + %constant.5074 = s32[] constant(0) + %constant.5075 = s32[] constant(0) + %compare.5076 = pred[] compare(s32[] %constant.5074, s32[] %constant.5075), direction=LT + %constant.5077 = s32[] constant(0) + %constant.5078 = s32[] constant(16) + %add.5079 = s32[] add(s32[] %constant.5077, s32[] %constant.5078) + %constant.5080 = s32[] constant(0) + %select.5081 = s32[] select(pred[] %compare.5076, s32[] %add.5079, s32[] %constant.5080) + %dynamic-slice.5082 = f32[1,16]{1,0} dynamic-slice(f32[2,16]{1,0} %get-tuple-element.4919, s32[] %select.5073, s32[] %select.5081), dynamic_slice_sizes={1,16} + %reshape.5083 = f32[16]{0} reshape(f32[1,16]{1,0} %dynamic-slice.5082) + %constant.6002 = s32[] constant(0) + %compare.6003 = pred[] compare(s32[] %subtract.4984, s32[] %constant.6002), direction=LT + %constant.6004 = s32[] constant(2) + %add.6005 = s32[] add(s32[] %subtract.4984, s32[] %constant.6004) + %select.6006 = s32[] select(pred[] %compare.6003, s32[] %add.6005, s32[] %subtract.4984) + %constant.6007 = s32[] constant(0) + %constant.6008 = s32[] constant(0) + %compare.6009 = pred[] compare(s32[] %constant.6007, s32[] %constant.6008), direction=LT + %constant.6010 = s32[] constant(0) + %constant.6011 = s32[] constant(16) + %add.6012 = s32[] add(s32[] %constant.6010, s32[] %constant.6011) + %constant.6013 = s32[] constant(0) + %select.6014 = s32[] select(pred[] %compare.6009, s32[] %add.6012, s32[] %constant.6013) + %constant.6015 = s32[] constant(0) + %constant.6016 = s32[] constant(0) + %compare.6017 = pred[] compare(s32[] %constant.6015, s32[] %constant.6016), direction=LT + %constant.6018 = s32[] constant(0) + %constant.6019 = s32[] constant(32) + %add.6020 = s32[] add(s32[] %constant.6018, s32[] %constant.6019) + %constant.6021 = s32[] constant(0) + %select.6022 = s32[] select(pred[] %compare.6017, s32[] %add.6020, s32[] %constant.6021) + %constant.6023 = s32[] constant(0) + %constant.6024 = s32[] constant(0) + %compare.6025 = pred[] compare(s32[] %constant.6023, s32[] %constant.6024), direction=LT + %constant.6026 = s32[] constant(0) + %constant.6027 = s32[] constant(32) + %add.6028 = s32[] add(s32[] %constant.6026, s32[] %constant.6027) + %constant.6029 = s32[] constant(0) + %select.6030 = s32[] select(pred[] %compare.6025, s32[] %add.6028, s32[] %constant.6029) + %constant.6031 = s32[] constant(0) + %constant.6032 = s32[] constant(0) + %compare.6033 = pred[] compare(s32[] %constant.6031, s32[] %constant.6032), direction=LT + %constant.6034 = s32[] constant(0) + %constant.6035 = s32[] constant(16) + %add.6036 = s32[] add(s32[] %constant.6034, s32[] %constant.6035) + %constant.6037 = s32[] constant(0) + %select.6038 = s32[] select(pred[] %compare.6033, s32[] %add.6036, s32[] %constant.6037) + %dynamic-slice.6039 = f32[1,16,32,32,16]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4946, s32[] %select.6006, s32[] %select.6014, s32[] %select.6022, s32[] %select.6030, /*index=5*/s32[] %select.6038), dynamic_slice_sizes={1,16,32,32,16} + %reshape.6040 = f32[16,32,32,16]{3,2,1,0} reshape(f32[1,16,32,32,16]{4,3,2,1,0} %dynamic-slice.6039) + %multiply.6581 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %reshape.6040, f32[16,32,32,16]{3,2,1,0} %add.6573) + %constant.6582 = f32[] constant(0) + %reduce.6583 = f32[16]{0} reduce(f32[16,32,32,16]{3,2,1,0} %multiply.6581, f32[] %constant.6582), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.4873 + %reshape.6584 = f32[1,1,1,16]{3,2,1,0} reshape(f32[16]{0} %reduce.6583) + %constant.6585 = f32[] constant(0) + %reduce.6586 = f32[16]{0} reduce(f32[1,1,1,16]{3,2,1,0} %reshape.6584, f32[] %constant.6585), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.4877 + %broadcast.6587 = f32[16]{0} broadcast(f32[16]{0} %reduce.6586), dimensions={0} + %add.6588 = f32[16]{0} add(f32[16]{0} %reshape.5083, f32[16]{0} %broadcast.6587) + %broadcast.6749 = f32[1,16]{1,0} broadcast(f32[16]{0} %add.6588), dimensions={1} + %constant.6750 = s32[] constant(0) + %compare.6751 = pred[] compare(s32[] %subtract.4984, s32[] %constant.6750), direction=LT + %constant.6752 = s32[] constant(2) + %add.6753 = s32[] add(s32[] %subtract.4984, s32[] %constant.6752) + %select.6754 = s32[] select(pred[] %compare.6751, s32[] %add.6753, s32[] %subtract.4984) + %constant.6755 = s32[] constant(0) + %constant.6756 = s32[] constant(0) + %compare.6757 = pred[] compare(s32[] %constant.6755, s32[] %constant.6756), direction=LT + %constant.6758 = s32[] constant(0) + %constant.6759 = s32[] constant(16) + %add.6760 = s32[] add(s32[] %constant.6758, s32[] %constant.6759) + %constant.6761 = s32[] constant(0) + %select.6762 = s32[] select(pred[] %compare.6757, s32[] %add.6760, s32[] %constant.6761) + %dynamic-update-slice.6763 = f32[2,16]{1,0} dynamic-update-slice(f32[2,16]{1,0} %get-tuple-element.4976, f32[1,16]{1,0} %broadcast.6749, s32[] %select.6754, s32[] %select.6762) + %get-tuple-element.4977 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=62 + %constant.5084 = s32[] constant(0) + %compare.5085 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5084), direction=LT + %constant.5086 = s32[] constant(2) + %add.5087 = s32[] add(s32[] %subtract.4984, s32[] %constant.5086) + %select.5088 = s32[] select(pred[] %compare.5085, s32[] %add.5087, s32[] %subtract.4984) + %constant.5089 = s32[] constant(0) + %constant.5090 = s32[] constant(0) + %compare.5091 = pred[] compare(s32[] %constant.5089, s32[] %constant.5090), direction=LT + %constant.5092 = s32[] constant(0) + %constant.5093 = s32[] constant(1) + %add.5094 = s32[] add(s32[] %constant.5092, s32[] %constant.5093) + %constant.5095 = s32[] constant(0) + %select.5096 = s32[] select(pred[] %compare.5091, s32[] %add.5094, s32[] %constant.5095) + %constant.5097 = s32[] constant(0) + %constant.5098 = s32[] constant(0) + %compare.5099 = pred[] compare(s32[] %constant.5097, s32[] %constant.5098), direction=LT + %constant.5100 = s32[] constant(0) + %constant.5101 = s32[] constant(1) + %add.5102 = s32[] add(s32[] %constant.5100, s32[] %constant.5101) + %constant.5103 = s32[] constant(0) + %select.5104 = s32[] select(pred[] %compare.5099, s32[] %add.5102, s32[] %constant.5103) + %constant.5105 = s32[] constant(0) + %constant.5106 = s32[] constant(0) + %compare.5107 = pred[] compare(s32[] %constant.5105, s32[] %constant.5106), direction=LT + %constant.5108 = s32[] constant(0) + %constant.5109 = s32[] constant(16) + %add.5110 = s32[] add(s32[] %constant.5108, s32[] %constant.5109) + %constant.5111 = s32[] constant(0) + %select.5112 = s32[] select(pred[] %compare.5107, s32[] %add.5110, s32[] %constant.5111) + %constant.5113 = s32[] constant(0) + %constant.5114 = s32[] constant(0) + %compare.5115 = pred[] compare(s32[] %constant.5113, s32[] %constant.5114), direction=LT + %constant.5116 = s32[] constant(0) + %constant.5117 = s32[] constant(16) + %add.5118 = s32[] add(s32[] %constant.5116, s32[] %constant.5117) + %constant.5119 = s32[] constant(0) + %select.5120 = s32[] select(pred[] %compare.5115, s32[] %add.5118, s32[] %constant.5119) + %dynamic-slice.5121 = f32[1,1,1,16,16]{4,3,2,1,0} dynamic-slice(f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.4920, s32[] %select.5088, s32[] %select.5096, s32[] %select.5104, s32[] %select.5112, /*index=5*/s32[] %select.5120), dynamic_slice_sizes={1,1,1,16,16} + %reshape.5122 = f32[1,1,16,16]{3,2,1,0} reshape(f32[1,1,1,16,16]{4,3,2,1,0} %dynamic-slice.5121) + %constant.5870 = s32[] constant(0) + %compare.5871 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5870), direction=LT + %constant.5872 = s32[] constant(2) + %add.5873 = s32[] add(s32[] %subtract.4984, s32[] %constant.5872) + %select.5874 = s32[] select(pred[] %compare.5871, s32[] %add.5873, s32[] %subtract.4984) + %constant.5875 = s32[] constant(0) + %constant.5876 = s32[] constant(0) + %compare.5877 = pred[] compare(s32[] %constant.5875, s32[] %constant.5876), direction=LT + %constant.5878 = s32[] constant(0) + %constant.5879 = s32[] constant(1) + %add.5880 = s32[] add(s32[] %constant.5878, s32[] %constant.5879) + %constant.5881 = s32[] constant(0) + %select.5882 = s32[] select(pred[] %compare.5877, s32[] %add.5880, s32[] %constant.5881) + %constant.5883 = s32[] constant(0) + %constant.5884 = s32[] constant(0) + %compare.5885 = pred[] compare(s32[] %constant.5883, s32[] %constant.5884), direction=LT + %constant.5886 = s32[] constant(0) + %constant.5887 = s32[] constant(1) + %add.5888 = s32[] add(s32[] %constant.5886, s32[] %constant.5887) + %constant.5889 = s32[] constant(0) + %select.5890 = s32[] select(pred[] %compare.5885, s32[] %add.5888, s32[] %constant.5889) + %constant.5891 = s32[] constant(0) + %constant.5892 = s32[] constant(0) + %compare.5893 = pred[] compare(s32[] %constant.5891, s32[] %constant.5892), direction=LT + %constant.5894 = s32[] constant(0) + %constant.5895 = s32[] constant(16) + %add.5896 = s32[] add(s32[] %constant.5894, s32[] %constant.5895) + %constant.5897 = s32[] constant(0) + %select.5898 = s32[] select(pred[] %compare.5893, s32[] %add.5896, s32[] %constant.5897) + %constant.5899 = s32[] constant(0) + %constant.5900 = s32[] constant(0) + %compare.5901 = pred[] compare(s32[] %constant.5899, s32[] %constant.5900), direction=LT + %constant.5902 = s32[] constant(0) + %constant.5903 = s32[] constant(16) + %add.5904 = s32[] add(s32[] %constant.5902, s32[] %constant.5903) + %constant.5905 = s32[] constant(0) + %select.5906 = s32[] select(pred[] %compare.5901, s32[] %add.5904, s32[] %constant.5905) + %dynamic-slice.5907 = f32[1,1,1,16,16]{4,3,2,1,0} dynamic-slice(f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.4942, s32[] %select.5874, s32[] %select.5882, s32[] %select.5890, s32[] %select.5898, /*index=5*/s32[] %select.5906), dynamic_slice_sizes={1,1,1,16,16} + %reshape.5908 = f32[1,1,16,16]{3,2,1,0} reshape(f32[1,1,1,16,16]{4,3,2,1,0} %dynamic-slice.5907) + %constant.5792 = s32[] constant(0) + %compare.5793 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5792), direction=LT + %constant.5794 = s32[] constant(2) + %add.5795 = s32[] add(s32[] %subtract.4984, s32[] %constant.5794) + %select.5796 = s32[] select(pred[] %compare.5793, s32[] %add.5795, s32[] %subtract.4984) + %constant.5797 = s32[] constant(0) + %constant.5798 = s32[] constant(0) + %compare.5799 = pred[] compare(s32[] %constant.5797, s32[] %constant.5798), direction=LT + %constant.5800 = s32[] constant(0) + %constant.5801 = s32[] constant(16) + %add.5802 = s32[] add(s32[] %constant.5800, s32[] %constant.5801) + %constant.5803 = s32[] constant(0) + %select.5804 = s32[] select(pred[] %compare.5799, s32[] %add.5802, s32[] %constant.5803) + %constant.5805 = s32[] constant(0) + %constant.5806 = s32[] constant(0) + %compare.5807 = pred[] compare(s32[] %constant.5805, s32[] %constant.5806), direction=LT + %constant.5808 = s32[] constant(0) + %constant.5809 = s32[] constant(32) + %add.5810 = s32[] add(s32[] %constant.5808, s32[] %constant.5809) + %constant.5811 = s32[] constant(0) + %select.5812 = s32[] select(pred[] %compare.5807, s32[] %add.5810, s32[] %constant.5811) + %constant.5813 = s32[] constant(0) + %constant.5814 = s32[] constant(0) + %compare.5815 = pred[] compare(s32[] %constant.5813, s32[] %constant.5814), direction=LT + %constant.5816 = s32[] constant(0) + %constant.5817 = s32[] constant(32) + %add.5818 = s32[] add(s32[] %constant.5816, s32[] %constant.5817) + %constant.5819 = s32[] constant(0) + %select.5820 = s32[] select(pred[] %compare.5815, s32[] %add.5818, s32[] %constant.5819) + %constant.5821 = s32[] constant(0) + %constant.5822 = s32[] constant(0) + %compare.5823 = pred[] compare(s32[] %constant.5821, s32[] %constant.5822), direction=LT + %constant.5824 = s32[] constant(0) + %constant.5825 = s32[] constant(16) + %add.5826 = s32[] add(s32[] %constant.5824, s32[] %constant.5825) + %constant.5827 = s32[] constant(0) + %select.5828 = s32[] select(pred[] %compare.5823, s32[] %add.5826, s32[] %constant.5827) + %dynamic-slice.5829 = f32[1,16,32,32,16]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4940, s32[] %select.5796, s32[] %select.5804, s32[] %select.5812, s32[] %select.5820, /*index=5*/s32[] %select.5828), dynamic_slice_sizes={1,16,32,32,16} + %reshape.5830 = f32[16,32,32,16]{3,2,1,0} reshape(f32[1,16,32,32,16]{4,3,2,1,0} %dynamic-slice.5829) + %convolution.6592 = f32[1,1,16,16]{3,2,1,0} convolution(f32[16,32,32,16]{3,2,1,0} %reshape.5830, f32[16,32,32,16]{3,2,1,0} %multiply.6591), window={size=32x32}, dim_labels=f01b_i01o->01bf + %multiply.6593 = f32[1,1,16,16]{3,2,1,0} multiply(f32[1,1,16,16]{3,2,1,0} %reshape.5908, f32[1,1,16,16]{3,2,1,0} %convolution.6592) + %constant.6594 = f32[] constant(0) + %reduce.6595 = f32[1,1,16]{2,1,0} reduce(f32[1,1,16,16]{3,2,1,0} %multiply.6593, f32[] %constant.6594), dimensions={2}, to_apply=%primitive_computation_add__1.4881 + %reshape.6596 = f32[1,1,1,16]{3,2,1,0} reshape(f32[1,1,16]{2,1,0} %reduce.6595) + %constant.6597 = f32[] constant(0) + %reduce.6598 = f32[16]{0} reduce(f32[1,1,1,16]{3,2,1,0} %reshape.6596, f32[] %constant.6597), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.4885 + %broadcast.6599 = f32[16]{0} broadcast(f32[16]{0} %reduce.6598), dimensions={0} + %constant.5948 = s32[] constant(0) + %compare.5949 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5948), direction=LT + %constant.5950 = s32[] constant(2) + %add.5951 = s32[] add(s32[] %subtract.4984, s32[] %constant.5950) + %select.5952 = s32[] select(pred[] %compare.5949, s32[] %add.5951, s32[] %subtract.4984) + %constant.5953 = s32[] constant(0) + %constant.5954 = s32[] constant(0) + %compare.5955 = pred[] compare(s32[] %constant.5953, s32[] %constant.5954), direction=LT + %constant.5956 = s32[] constant(0) + %constant.5957 = s32[] constant(16) + %add.5958 = s32[] add(s32[] %constant.5956, s32[] %constant.5957) + %constant.5959 = s32[] constant(0) + %select.5960 = s32[] select(pred[] %compare.5955, s32[] %add.5958, s32[] %constant.5959) + %dynamic-slice.5961 = f32[1,16]{1,0} dynamic-slice(f32[2,16]{1,0} %get-tuple-element.4944, s32[] %select.5952, s32[] %select.5960), dynamic_slice_sizes={1,16} + %reshape.5962 = f32[16]{0} reshape(f32[1,16]{1,0} %dynamic-slice.5961) + %multiply.6600 = f32[16]{0} multiply(f32[16]{0} %broadcast.6599, f32[16]{0} %reshape.5962) + %broadcast.6601 = f32[1,1,16,16]{3,2,1,0} broadcast(f32[16]{0} %multiply.6600), dimensions={3} + %constant.5909 = s32[] constant(0) + %compare.5910 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5909), direction=LT + %constant.5911 = s32[] constant(2) + %add.5912 = s32[] add(s32[] %subtract.4984, s32[] %constant.5911) + %select.5913 = s32[] select(pred[] %compare.5910, s32[] %add.5912, s32[] %subtract.4984) + %constant.5914 = s32[] constant(0) + %constant.5915 = s32[] constant(0) + %compare.5916 = pred[] compare(s32[] %constant.5914, s32[] %constant.5915), direction=LT + %constant.5917 = s32[] constant(0) + %constant.5918 = s32[] constant(1) + %add.5919 = s32[] add(s32[] %constant.5917, s32[] %constant.5918) + %constant.5920 = s32[] constant(0) + %select.5921 = s32[] select(pred[] %compare.5916, s32[] %add.5919, s32[] %constant.5920) + %constant.5922 = s32[] constant(0) + %constant.5923 = s32[] constant(0) + %compare.5924 = pred[] compare(s32[] %constant.5922, s32[] %constant.5923), direction=LT + %constant.5925 = s32[] constant(0) + %constant.5926 = s32[] constant(1) + %add.5927 = s32[] add(s32[] %constant.5925, s32[] %constant.5926) + %constant.5928 = s32[] constant(0) + %select.5929 = s32[] select(pred[] %compare.5924, s32[] %add.5927, s32[] %constant.5928) + %constant.5930 = s32[] constant(0) + %constant.5931 = s32[] constant(0) + %compare.5932 = pred[] compare(s32[] %constant.5930, s32[] %constant.5931), direction=LT + %constant.5933 = s32[] constant(0) + %constant.5934 = s32[] constant(16) + %add.5935 = s32[] add(s32[] %constant.5933, s32[] %constant.5934) + %constant.5936 = s32[] constant(0) + %select.5937 = s32[] select(pred[] %compare.5932, s32[] %add.5935, s32[] %constant.5936) + %constant.5938 = s32[] constant(0) + %constant.5939 = s32[] constant(0) + %compare.5940 = pred[] compare(s32[] %constant.5938, s32[] %constant.5939), direction=LT + %constant.5941 = s32[] constant(0) + %constant.5942 = s32[] constant(16) + %add.5943 = s32[] add(s32[] %constant.5941, s32[] %constant.5942) + %constant.5944 = s32[] constant(0) + %select.5945 = s32[] select(pred[] %compare.5940, s32[] %add.5943, s32[] %constant.5944) + %dynamic-slice.5946 = f32[1,1,1,16,16]{4,3,2,1,0} dynamic-slice(f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.4943, s32[] %select.5913, s32[] %select.5921, s32[] %select.5929, s32[] %select.5937, /*index=5*/s32[] %select.5945), dynamic_slice_sizes={1,1,1,16,16} + %reshape.5947 = f32[1,1,16,16]{3,2,1,0} reshape(f32[1,1,1,16,16]{4,3,2,1,0} %dynamic-slice.5946) + %multiply.6602 = f32[1,1,16,16]{3,2,1,0} multiply(f32[1,1,16,16]{3,2,1,0} %broadcast.6601, f32[1,1,16,16]{3,2,1,0} %reshape.5947) + %add.6603 = f32[1,1,16,16]{3,2,1,0} add(f32[1,1,16,16]{3,2,1,0} %reshape.5122, f32[1,1,16,16]{3,2,1,0} %multiply.6602) + %constant.5831 = s32[] constant(0) + %compare.5832 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5831), direction=LT + %constant.5833 = s32[] constant(2) + %add.5834 = s32[] add(s32[] %subtract.4984, s32[] %constant.5833) + %select.5835 = s32[] select(pred[] %compare.5832, s32[] %add.5834, s32[] %subtract.4984) + %constant.5836 = s32[] constant(0) + %constant.5837 = s32[] constant(0) + %compare.5838 = pred[] compare(s32[] %constant.5836, s32[] %constant.5837), direction=LT + %constant.5839 = s32[] constant(0) + %constant.5840 = s32[] constant(1) + %add.5841 = s32[] add(s32[] %constant.5839, s32[] %constant.5840) + %constant.5842 = s32[] constant(0) + %select.5843 = s32[] select(pred[] %compare.5838, s32[] %add.5841, s32[] %constant.5842) + %constant.5844 = s32[] constant(0) + %constant.5845 = s32[] constant(0) + %compare.5846 = pred[] compare(s32[] %constant.5844, s32[] %constant.5845), direction=LT + %constant.5847 = s32[] constant(0) + %constant.5848 = s32[] constant(1) + %add.5849 = s32[] add(s32[] %constant.5847, s32[] %constant.5848) + %constant.5850 = s32[] constant(0) + %select.5851 = s32[] select(pred[] %compare.5846, s32[] %add.5849, s32[] %constant.5850) + %constant.5852 = s32[] constant(0) + %constant.5853 = s32[] constant(0) + %compare.5854 = pred[] compare(s32[] %constant.5852, s32[] %constant.5853), direction=LT + %constant.5855 = s32[] constant(0) + %constant.5856 = s32[] constant(1) + %add.5857 = s32[] add(s32[] %constant.5855, s32[] %constant.5856) + %constant.5858 = s32[] constant(0) + %select.5859 = s32[] select(pred[] %compare.5854, s32[] %add.5857, s32[] %constant.5858) + %constant.5860 = s32[] constant(0) + %constant.5861 = s32[] constant(0) + %compare.5862 = pred[] compare(s32[] %constant.5860, s32[] %constant.5861), direction=LT + %constant.5863 = s32[] constant(0) + %constant.5864 = s32[] constant(16) + %add.5865 = s32[] add(s32[] %constant.5863, s32[] %constant.5864) + %constant.5866 = s32[] constant(0) + %select.5867 = s32[] select(pred[] %compare.5862, s32[] %add.5865, s32[] %constant.5866) + %dynamic-slice.5868 = f32[1,1,1,1,16]{4,3,2,1,0} dynamic-slice(f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.4941, s32[] %select.5835, s32[] %select.5843, s32[] %select.5851, s32[] %select.5859, /*index=5*/s32[] %select.5867), dynamic_slice_sizes={1,1,1,1,16} + %reshape.5869 = f32[1,1,1,16]{3,2,1,0} reshape(f32[1,1,1,1,16]{4,3,2,1,0} %dynamic-slice.5868) + %reshape.6604 = f32[1,1,16]{2,1,0} reshape(f32[1,1,1,16]{3,2,1,0} %reshape.5869) + %broadcast.6605 = f32[1,1,16,16]{3,2,1,0} broadcast(f32[1,1,16]{2,1,0} %reshape.6604), dimensions={0,1,3} + %multiply.6606 = f32[1,1,16,16]{3,2,1,0} multiply(f32[1,1,16,16]{3,2,1,0} %convolution.6592, f32[1,1,16,16]{3,2,1,0} %broadcast.6605) + %add.6607 = f32[1,1,16,16]{3,2,1,0} add(f32[1,1,16,16]{3,2,1,0} %add.6603, f32[1,1,16,16]{3,2,1,0} %multiply.6606) + %broadcast.6764 = f32[1,1,1,16,16]{4,3,2,1,0} broadcast(f32[1,1,16,16]{3,2,1,0} %add.6607), dimensions={1,2,3,4} + %constant.6765 = s32[] constant(0) + %compare.6766 = pred[] compare(s32[] %subtract.4984, s32[] %constant.6765), direction=LT + %constant.6767 = s32[] constant(2) + %add.6768 = s32[] add(s32[] %subtract.4984, s32[] %constant.6767) + %select.6769 = s32[] select(pred[] %compare.6766, s32[] %add.6768, s32[] %subtract.4984) + %constant.6770 = s32[] constant(0) + %constant.6771 = s32[] constant(0) + %compare.6772 = pred[] compare(s32[] %constant.6770, s32[] %constant.6771), direction=LT + %constant.6773 = s32[] constant(0) + %constant.6774 = s32[] constant(1) + %add.6775 = s32[] add(s32[] %constant.6773, s32[] %constant.6774) + %constant.6776 = s32[] constant(0) + %select.6777 = s32[] select(pred[] %compare.6772, s32[] %add.6775, s32[] %constant.6776) + %constant.6778 = s32[] constant(0) + %constant.6779 = s32[] constant(0) + %compare.6780 = pred[] compare(s32[] %constant.6778, s32[] %constant.6779), direction=LT + %constant.6781 = s32[] constant(0) + %constant.6782 = s32[] constant(1) + %add.6783 = s32[] add(s32[] %constant.6781, s32[] %constant.6782) + %constant.6784 = s32[] constant(0) + %select.6785 = s32[] select(pred[] %compare.6780, s32[] %add.6783, s32[] %constant.6784) + %constant.6786 = s32[] constant(0) + %constant.6787 = s32[] constant(0) + %compare.6788 = pred[] compare(s32[] %constant.6786, s32[] %constant.6787), direction=LT + %constant.6789 = s32[] constant(0) + %constant.6790 = s32[] constant(16) + %add.6791 = s32[] add(s32[] %constant.6789, s32[] %constant.6790) + %constant.6792 = s32[] constant(0) + %select.6793 = s32[] select(pred[] %compare.6788, s32[] %add.6791, s32[] %constant.6792) + %constant.6794 = s32[] constant(0) + %constant.6795 = s32[] constant(0) + %compare.6796 = pred[] compare(s32[] %constant.6794, s32[] %constant.6795), direction=LT + %constant.6797 = s32[] constant(0) + %constant.6798 = s32[] constant(16) + %add.6799 = s32[] add(s32[] %constant.6797, s32[] %constant.6798) + %constant.6800 = s32[] constant(0) + %select.6801 = s32[] select(pred[] %compare.6796, s32[] %add.6799, s32[] %constant.6800) + %dynamic-update-slice.6802 = f32[2,1,1,16,16]{4,3,2,1,0} dynamic-update-slice(f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.4977, f32[1,1,1,16,16]{4,3,2,1,0} %broadcast.6764, s32[] %select.6769, s32[] %select.6777, s32[] %select.6785, /*index=5*/s32[] %select.6793, s32[] %select.6801) + %get-tuple-element.4978 = f32[2,8]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=63 + %constant.5123 = s32[] constant(0) + %compare.5124 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5123), direction=LT + %constant.5125 = s32[] constant(2) + %add.5126 = s32[] add(s32[] %subtract.4984, s32[] %constant.5125) + %select.5127 = s32[] select(pred[] %compare.5124, s32[] %add.5126, s32[] %subtract.4984) + %constant.5128 = s32[] constant(0) + %constant.5129 = s32[] constant(0) + %compare.5130 = pred[] compare(s32[] %constant.5128, s32[] %constant.5129), direction=LT + %constant.5131 = s32[] constant(0) + %constant.5132 = s32[] constant(8) + %add.5133 = s32[] add(s32[] %constant.5131, s32[] %constant.5132) + %constant.5134 = s32[] constant(0) + %select.5135 = s32[] select(pred[] %compare.5130, s32[] %add.5133, s32[] %constant.5134) + %dynamic-slice.5136 = f32[1,8]{1,0} dynamic-slice(f32[2,8]{1,0} %get-tuple-element.4921, s32[] %select.5127, s32[] %select.5135), dynamic_slice_sizes={1,8} + %reshape.5137 = f32[8]{0} reshape(f32[1,8]{1,0} %dynamic-slice.5136) + %constant.6508 = f32[] constant(0) + %reduce.6509 = f32[8]{0} reduce(f32[16,32,32,8]{3,2,1,0} %get-tuple-element.4962, f32[] %constant.6508), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.4833 + %reshape.6510 = f32[1,1,1,8]{3,2,1,0} reshape(f32[8]{0} %reduce.6509) + %constant.6511 = f32[] constant(0) + %reduce.6512 = f32[8]{0} reduce(f32[1,1,1,8]{3,2,1,0} %reshape.6510, f32[] %constant.6511), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.4837 + %broadcast.6513 = f32[8]{0} broadcast(f32[8]{0} %reduce.6512), dimensions={0} + %add.6514 = f32[8]{0} add(f32[8]{0} %reshape.5137, f32[8]{0} %broadcast.6513) + %broadcast.6803 = f32[1,8]{1,0} broadcast(f32[8]{0} %add.6514), dimensions={1} + %constant.6804 = s32[] constant(0) + %compare.6805 = pred[] compare(s32[] %subtract.4984, s32[] %constant.6804), direction=LT + %constant.6806 = s32[] constant(2) + %add.6807 = s32[] add(s32[] %subtract.4984, s32[] %constant.6806) + %select.6808 = s32[] select(pred[] %compare.6805, s32[] %add.6807, s32[] %subtract.4984) + %constant.6809 = s32[] constant(0) + %constant.6810 = s32[] constant(0) + %compare.6811 = pred[] compare(s32[] %constant.6809, s32[] %constant.6810), direction=LT + %constant.6812 = s32[] constant(0) + %constant.6813 = s32[] constant(8) + %add.6814 = s32[] add(s32[] %constant.6812, s32[] %constant.6813) + %constant.6815 = s32[] constant(0) + %select.6816 = s32[] select(pred[] %compare.6811, s32[] %add.6814, s32[] %constant.6815) + %dynamic-update-slice.6817 = f32[2,8]{1,0} dynamic-update-slice(f32[2,8]{1,0} %get-tuple-element.4978, f32[1,8]{1,0} %broadcast.6803, s32[] %select.6808, s32[] %select.6816) + %get-tuple-element.4979 = f32[2,8]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.4914), index=64 + %constant.5138 = s32[] constant(0) + %compare.5139 = pred[] compare(s32[] %subtract.4984, s32[] %constant.5138), direction=LT + %constant.5140 = s32[] constant(2) + %add.5141 = s32[] add(s32[] %subtract.4984, s32[] %constant.5140) + %select.5142 = s32[] select(pred[] %compare.5139, s32[] %add.5141, s32[] %subtract.4984) + %constant.5143 = s32[] constant(0) + %constant.5144 = s32[] constant(0) + %compare.5145 = pred[] compare(s32[] %constant.5143, s32[] %constant.5144), direction=LT + %constant.5146 = s32[] constant(0) + %constant.5147 = s32[] constant(8) + %add.5148 = s32[] add(s32[] %constant.5146, s32[] %constant.5147) + %constant.5149 = s32[] constant(0) + %select.5150 = s32[] select(pred[] %compare.5145, s32[] %add.5148, s32[] %constant.5149) + %dynamic-slice.5151 = f32[1,8]{1,0} dynamic-slice(f32[2,8]{1,0} %get-tuple-element.4922, s32[] %select.5142, s32[] %select.5150), dynamic_slice_sizes={1,8} + %reshape.5152 = f32[8]{0} reshape(f32[1,8]{1,0} %dynamic-slice.5151) + %constant.6469 = s32[] constant(0) + %compare.6470 = pred[] compare(s32[] %subtract.4984, s32[] %constant.6469), direction=LT + %constant.6471 = s32[] constant(2) + %add.6472 = s32[] add(s32[] %subtract.4984, s32[] %constant.6471) + %select.6473 = s32[] select(pred[] %compare.6470, s32[] %add.6472, s32[] %subtract.4984) + %constant.6474 = s32[] constant(0) + %constant.6475 = s32[] constant(0) + %compare.6476 = pred[] compare(s32[] %constant.6474, s32[] %constant.6475), direction=LT + %constant.6477 = s32[] constant(0) + %constant.6478 = s32[] constant(16) + %add.6479 = s32[] add(s32[] %constant.6477, s32[] %constant.6478) + %constant.6480 = s32[] constant(0) + %select.6481 = s32[] select(pred[] %compare.6476, s32[] %add.6479, s32[] %constant.6480) + %constant.6482 = s32[] constant(0) + %constant.6483 = s32[] constant(0) + %compare.6484 = pred[] compare(s32[] %constant.6482, s32[] %constant.6483), direction=LT + %constant.6485 = s32[] constant(0) + %constant.6486 = s32[] constant(32) + %add.6487 = s32[] add(s32[] %constant.6485, s32[] %constant.6486) + %constant.6488 = s32[] constant(0) + %select.6489 = s32[] select(pred[] %compare.6484, s32[] %add.6487, s32[] %constant.6488) + %constant.6490 = s32[] constant(0) + %constant.6491 = s32[] constant(0) + %compare.6492 = pred[] compare(s32[] %constant.6490, s32[] %constant.6491), direction=LT + %constant.6493 = s32[] constant(0) + %constant.6494 = s32[] constant(32) + %add.6495 = s32[] add(s32[] %constant.6493, s32[] %constant.6494) + %constant.6496 = s32[] constant(0) + %select.6497 = s32[] select(pred[] %compare.6492, s32[] %add.6495, s32[] %constant.6496) + %constant.6498 = s32[] constant(0) + %constant.6499 = s32[] constant(0) + %compare.6500 = pred[] compare(s32[] %constant.6498, s32[] %constant.6499), direction=LT + %constant.6501 = s32[] constant(0) + %constant.6502 = s32[] constant(8) + %add.6503 = s32[] add(s32[] %constant.6501, s32[] %constant.6502) + %constant.6504 = s32[] constant(0) + %select.6505 = s32[] select(pred[] %compare.6500, s32[] %add.6503, s32[] %constant.6504) + %dynamic-slice.6506 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4959, s32[] %select.6473, s32[] %select.6481, s32[] %select.6489, s32[] %select.6497, /*index=5*/s32[] %select.6505), dynamic_slice_sizes={1,16,32,32,8} + %reshape.6507 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.6506) + %multiply.6515 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %reshape.6507, f32[16,32,32,8]{3,2,1,0} %get-tuple-element.4962) + %constant.6516 = f32[] constant(0) + %reduce.6517 = f32[8]{0} reduce(f32[16,32,32,8]{3,2,1,0} %multiply.6515, f32[] %constant.6516), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.4841 + %reshape.6518 = f32[1,1,1,8]{3,2,1,0} reshape(f32[8]{0} %reduce.6517) + %constant.6519 = f32[] constant(0) + %reduce.6520 = f32[8]{0} reduce(f32[1,1,1,8]{3,2,1,0} %reshape.6518, f32[] %constant.6519), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.4845 + %broadcast.6521 = f32[8]{0} broadcast(f32[8]{0} %reduce.6520), dimensions={0} + %add.6522 = f32[8]{0} add(f32[8]{0} %reshape.5152, f32[8]{0} %broadcast.6521) + %broadcast.6818 = f32[1,8]{1,0} broadcast(f32[8]{0} %add.6522), dimensions={1} + %constant.6819 = s32[] constant(0) + %compare.6820 = pred[] compare(s32[] %subtract.4984, s32[] %constant.6819), direction=LT + %constant.6821 = s32[] constant(2) + %add.6822 = s32[] add(s32[] %subtract.4984, s32[] %constant.6821) + %select.6823 = s32[] select(pred[] %compare.6820, s32[] %add.6822, s32[] %subtract.4984) + %constant.6824 = s32[] constant(0) + %constant.6825 = s32[] constant(0) + %compare.6826 = pred[] compare(s32[] %constant.6824, s32[] %constant.6825), direction=LT + %constant.6827 = s32[] constant(0) + %constant.6828 = s32[] constant(8) + %add.6829 = s32[] add(s32[] %constant.6827, s32[] %constant.6828) + %constant.6830 = s32[] constant(0) + %select.6831 = s32[] select(pred[] %compare.6826, s32[] %add.6829, s32[] %constant.6830) + %dynamic-update-slice.6832 = f32[2,8]{1,0} dynamic-update-slice(f32[2,8]{1,0} %get-tuple-element.4979, f32[1,8]{1,0} %broadcast.6818, s32[] %select.6823, s32[] %select.6831) + ROOT %tuple.6845 = (f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) tuple(f32[2,16]{1,0} %get-tuple-element.4915, f32[2,16]{1,0} %get-tuple-element.4916, f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.4917, f32[2,16]{1,0} %get-tuple-element.4918, f32[2,16]{1,0} %get-tuple-element.4919, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.4920, f32[2,8]{1,0} %get-tuple-element.4921, f32[2,8]{1,0} %get-tuple-element.4922, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4923, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4924, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4925, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4926, f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.4927, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4928, f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.4929, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.4930, f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.4931, f32[2,16]{1,0} %get-tuple-element.4932, f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.4933, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4934, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4935, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4936, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4937, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4938, f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.4939, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4940, f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.4941, f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.4942, f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.4943, f32[2,16]{1,0} %get-tuple-element.4944, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.4945, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4946, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4947, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4948, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4949, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4950, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4951, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4952, f32[2,16,1,1,8]{4,3,2,1,0} %get-tuple-element.4953, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4954, /*index=40*/f32[2,16,1024,8]{3,2,1,0} %get-tuple-element.4955, f32[2,16,8]{2,1,0} %get-tuple-element.4956, f32[2,16,8]{2,1,0} %get-tuple-element.4957, f32[2,1,1,1,8]{4,3,2,1,0} %get-tuple-element.4958, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4959, /*index=45*/s32[] %add.6834, pred[] %constant.6835, f32[16,32,32,8]{3,2,1,0} %add.6664, pred[] %constant.6836, pred[] %constant.6837, /*index=50*/pred[] %constant.6838, pred[] %constant.6839, pred[] %constant.6840, pred[] %constant.6841, pred[] %constant.6842, /*index=55*/pred[] %constant.6843, pred[] %constant.6844, f32[2,16]{1,0} %dynamic-update-slice.6679, f32[2,16]{1,0} %dynamic-update-slice.6694, f32[2,3,3,8,16]{4,3,2,1,0} %dynamic-update-slice.6733, /*index=60*/f32[2,16]{1,0} %dynamic-update-slice.6748, f32[2,16]{1,0} %dynamic-update-slice.6763, f32[2,1,1,16,16]{4,3,2,1,0} %dynamic-update-slice.6802, f32[2,8]{1,0} %dynamic-update-slice.6817, f32[2,8]{1,0} %dynamic-update-slice.6832) +} + +%cond_computation__2.6846 (parameter.6847: (f32[2,16], f32[2,16], f32[2,3,3,8,16], f32[2,16], f32[2,16], /*index=5*/f32[2,1,1,16,16], f32[2,8], f32[2,8], f32[2,16,32,32,8], f32[2,16,32,32,8], /*index=10*/f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,3,3,8,16], f32[2,16,32,32,8], f32[2,1,1,1,16], /*index=15*/f32[2,3,3,8,16], f32[2,3,3,8,16], f32[2,16], f32[2,1,1,1,16], f32[2,16,32,32,16], /*index=20*/f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,1,1,16,16], /*index=25*/f32[2,16,32,32,16], f32[2,1,1,1,16], f32[2,1,1,16,16], f32[2,1,1,16,16], f32[2,16], /*index=30*/f32[2,1,1,1,16], f32[2,16,32,32,16], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], /*index=35*/f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,1,1,8], f32[2,16,32,32,8], /*index=40*/f32[2,16,1024,8], f32[2,16,8], f32[2,16,8], f32[2,1,1,1,8], f32[2,16,32,32,8], /*index=45*/s32[], pred[], f32[16,32,32,8], pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16], f32[2,16], f32[2,3,3,8,16], /*index=60*/f32[2,16], f32[2,16], f32[2,1,1,16,16], f32[2,8], f32[2,8])) -> pred[] { + %parameter.6847 = (f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) parameter(0) + %get-tuple-element.6848 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=0 + %get-tuple-element.6849 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=1 + %get-tuple-element.6850 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=2 + %get-tuple-element.6851 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=3 + %get-tuple-element.6852 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=4 + %get-tuple-element.6853 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=5 + %get-tuple-element.6854 = f32[2,8]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=6 + %get-tuple-element.6855 = f32[2,8]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=7 + %get-tuple-element.6856 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=8 + %get-tuple-element.6857 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=9 + %get-tuple-element.6858 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=10 + %get-tuple-element.6859 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=11 + %get-tuple-element.6860 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=12 + %get-tuple-element.6861 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=13 + %get-tuple-element.6862 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=14 + %get-tuple-element.6863 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=15 + %get-tuple-element.6864 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=16 + %get-tuple-element.6865 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=17 + %get-tuple-element.6866 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=18 + %get-tuple-element.6867 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=19 + %get-tuple-element.6868 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=20 + %get-tuple-element.6869 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=21 + %get-tuple-element.6870 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=22 + %get-tuple-element.6871 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=23 + %get-tuple-element.6872 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=24 + %get-tuple-element.6873 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=25 + %get-tuple-element.6874 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=26 + %get-tuple-element.6875 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=27 + %get-tuple-element.6876 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=28 + %get-tuple-element.6877 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=29 + %get-tuple-element.6878 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=30 + %get-tuple-element.6879 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=31 + %get-tuple-element.6880 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=32 + %get-tuple-element.6881 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=33 + %get-tuple-element.6882 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=34 + %get-tuple-element.6883 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=35 + %get-tuple-element.6884 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=36 + %get-tuple-element.6885 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=37 + %get-tuple-element.6886 = f32[2,16,1,1,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=38 + %get-tuple-element.6887 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=39 + %get-tuple-element.6888 = f32[2,16,1024,8]{3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=40 + %get-tuple-element.6889 = f32[2,16,8]{2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=41 + %get-tuple-element.6890 = f32[2,16,8]{2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=42 + %get-tuple-element.6891 = f32[2,1,1,1,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=43 + %get-tuple-element.6892 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=44 + %get-tuple-element.6894 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=46 + %get-tuple-element.6895 = f32[16,32,32,8]{3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=47 + %get-tuple-element.6896 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=48 + %get-tuple-element.6897 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=49 + %get-tuple-element.6898 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=50 + %get-tuple-element.6899 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=51 + %get-tuple-element.6900 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=52 + %get-tuple-element.6901 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=53 + %get-tuple-element.6902 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=54 + %get-tuple-element.6903 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=55 + %get-tuple-element.6904 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=56 + %get-tuple-element.6905 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=57 + %get-tuple-element.6906 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=58 + %get-tuple-element.6907 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=59 + %get-tuple-element.6908 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=60 + %get-tuple-element.6909 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=61 + %get-tuple-element.6910 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=62 + %get-tuple-element.6911 = f32[2,8]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=63 + %get-tuple-element.6912 = f32[2,8]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=64 + %constant.6913 = pred[] constant(false) + %get-tuple-element.6893 = s32[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.6847), index=45 + %constant.6914 = s32[] constant(2) + ROOT %compare.6915 = pred[] compare(s32[] %get-tuple-element.6893, s32[] %constant.6914), direction=LT +} + +%primitive_computation_add__1.7024 (parameter.7025: f32[], parameter.7026: f32[]) -> f32[] { + %parameter.7025 = f32[] parameter(0) + %parameter.7026 = f32[] parameter(1) + ROOT %add.7027 = f32[] add(f32[] %parameter.7025, f32[] %parameter.7026) +} + +%primitive_computation_add__1.7031 (parameter.7032: f32[], parameter.7033: f32[]) -> f32[] { + %parameter.7032 = f32[] parameter(0) + %parameter.7033 = f32[] parameter(1) + ROOT %add.7034 = f32[] add(f32[] %parameter.7032, f32[] %parameter.7033) +} + +%primitive_computation_add__1.7039 (parameter.7040: f32[], parameter.7041: f32[]) -> f32[] { + %parameter.7040 = f32[] parameter(0) + %parameter.7041 = f32[] parameter(1) + ROOT %add.7042 = f32[] add(f32[] %parameter.7040, f32[] %parameter.7041) +} + +%primitive_computation_add__1.7046 (parameter.7047: f32[], parameter.7048: f32[]) -> f32[] { + %parameter.7047 = f32[] parameter(0) + %parameter.7048 = f32[] parameter(1) + ROOT %add.7049 = f32[] add(f32[] %parameter.7047, f32[] %parameter.7048) +} + +%primitive_computation_add__1.7058 (parameter.7059: f32[], parameter.7060: f32[]) -> f32[] { + %parameter.7059 = f32[] parameter(0) + %parameter.7060 = f32[] parameter(1) + ROOT %add.7061 = f32[] add(f32[] %parameter.7059, f32[] %parameter.7060) +} + +%primitive_computation_add__1.7068 (parameter.7069: f32[], parameter.7070: f32[]) -> f32[] { + %parameter.7069 = f32[] parameter(0) + %parameter.7070 = f32[] parameter(1) + ROOT %add.7071 = f32[] add(f32[] %parameter.7069, f32[] %parameter.7070) +} + +%primitive_computation_add__1.7082 (parameter.7083: f32[], parameter.7084: f32[]) -> f32[] { + %parameter.7083 = f32[] parameter(0) + %parameter.7084 = f32[] parameter(1) + ROOT %add.7085 = f32[] add(f32[] %parameter.7083, f32[] %parameter.7084) +} + +%scatter_add_reducer__1.7090 (parameter.7091: f32[], parameter.7092: f32[]) -> f32[] { + %parameter.7091 = f32[] parameter(0) + %parameter.7092 = f32[] parameter(1) + ROOT %add.7093 = f32[] add(f32[] %parameter.7091, f32[] %parameter.7092) +} + +%primitive_computation_add__1.7098 (parameter.7099: f32[], parameter.7100: f32[]) -> f32[] { + %parameter.7099 = f32[] parameter(0) + %parameter.7100 = f32[] parameter(1) + ROOT %add.7101 = f32[] add(f32[] %parameter.7099, f32[] %parameter.7100) +} + +%primitive_computation_add__1.7116 (parameter.7117: f32[], parameter.7118: f32[]) -> f32[] { + %parameter.7117 = f32[] parameter(0) + %parameter.7118 = f32[] parameter(1) + ROOT %add.7119 = f32[] add(f32[] %parameter.7117, f32[] %parameter.7118) +} + +%jit_transpose__where_.7126 (parameter.7127: pred[3,3], parameter.7128: f32[3,3], parameter.7129: f32[3,3]) -> (f32[3,3]) { + %parameter.7128 = f32[3,3]{1,0} parameter(1) + %constant.7130 = pred[] constant(false) + %parameter.7127 = pred[3,3]{1,0} parameter(0) + %parameter.7129 = f32[3,3]{1,0} parameter(2) + %constant.7131 = f32[] constant(0) + %broadcast.7132 = f32[3,3]{1,0} broadcast(f32[] %constant.7131), dimensions={} + %select.7133 = f32[3,3]{1,0} select(pred[3,3]{1,0} %parameter.7127, f32[3,3]{1,0} %parameter.7129, f32[3,3]{1,0} %broadcast.7132) + ROOT %tuple.7134 = (f32[3,3]{1,0}) tuple(f32[3,3]{1,0} %select.7133) +} + +%sort_lt_comparator.7138 (parameter.7139: s32[], parameter.7140: s32[], parameter.7141: s32[], parameter.7142: s32[]) -> pred[] { + %parameter.7141 = s32[] parameter(2) + %parameter.7142 = s32[] parameter(3) + %constant.7143 = pred[] constant(false) + %parameter.7139 = s32[] parameter(0) + %parameter.7140 = s32[] parameter(1) + ROOT %compare.7144 = pred[] compare(s32[] %parameter.7139, s32[] %parameter.7140), direction=LT +} + +%jit_vmap__lu_solve_.7145 (parameter.7146: f32[3,3], parameter.7147: s32[3], parameter.7148: f32[3,3]) -> (f32[3,3]) { + %constant.7149 = pred[] constant(false) + %parameter.7147 = s32[3]{0} parameter(1) + %iota.7158 = s32[3] iota(), iota_dimension=0 + %sort.7159 = (s32[3]{0}, s32[3]) sort(s32[3]{0} %parameter.7147, s32[3] %iota.7158), dimensions={0}, is_stable=true, to_apply=%sort_lt_comparator.7138 + %get-tuple-element.7160 = s32[3]{0} get-tuple-element((s32[3]{0}, s32[3]) %sort.7159), index=0 + %parameter.7146 = f32[3,3]{1,0} parameter(0) + %parameter.7148 = f32[3,3]{1,0} parameter(2) + %broadcast.7150 = f32[3,3,1]{2,1,0} broadcast(f32[3,3]{1,0} %parameter.7148), dimensions={0,1} + %transpose.7151 = f32[3,1,3]{1,0,2} transpose(f32[3,3,1]{2,1,0} %broadcast.7150), dimensions={1,2,0} + %reshape.7152 = f32[3,3]{1,0} reshape(f32[3,1,3]{1,0,2} %transpose.7151) + %triangular-solve.7153 = f32[3,3]{1,0} triangular-solve(f32[3,3]{1,0} %parameter.7146, f32[3,3]{1,0} %reshape.7152), left_side=true, transpose_a=TRANSPOSE + %reshape.7154 = f32[3,1,3]{2,1,0} reshape(f32[3,3]{1,0} %triangular-solve.7153) + %reshape.7155 = f32[3,3]{1,0} reshape(f32[3,1,3]{2,1,0} %reshape.7154) + %triangular-solve.7156 = f32[3,3]{1,0} triangular-solve(f32[3,3]{1,0} %parameter.7146, f32[3,3]{1,0} %reshape.7155), left_side=true, lower=true, unit_diagonal=true, transpose_a=TRANSPOSE + %reshape.7157 = f32[3,1,3]{2,1,0} reshape(f32[3,3]{1,0} %triangular-solve.7156) + %transpose.7170 = f32[3,3,1]{0,2,1} transpose(f32[3,1,3]{2,1,0} %reshape.7157), dimensions={2,0,1} + %get-tuple-element.7161 = s32[3] get-tuple-element((s32[3]{0}, s32[3]) %sort.7159), index=1 + %constant.7162 = s32[] constant(0) + %broadcast.7163 = s32[3]{0} broadcast(s32[] %constant.7162), dimensions={} + %compare.7164 = pred[3]{0} compare(s32[3] %get-tuple-element.7161, s32[3]{0} %broadcast.7163), direction=LT + %constant.7165 = s32[] constant(3) + %broadcast.7166 = s32[3]{0} broadcast(s32[] %constant.7165), dimensions={} + %add.7167 = s32[3]{0} add(s32[3] %get-tuple-element.7161, s32[3]{0} %broadcast.7166) + %select.7168 = s32[3]{0} select(pred[3]{0} %compare.7164, s32[3]{0} %add.7167, s32[3] %get-tuple-element.7161) + %broadcast.7169 = s32[3,1]{1,0} broadcast(s32[3]{0} %select.7168), dimensions={0} + %gather.7171 = f32[3,3,1]{2,1,0} gather(f32[3,3,1]{0,2,1} %transpose.7170, s32[3,1]{1,0} %broadcast.7169), offset_dims={0,2}, collapsed_slice_dims={1}, start_index_map={1}, index_vector_dim=1, slice_sizes={3,1,1} + %broadcast.7172 = f32[3,3,1]{2,1,0} broadcast(f32[3,3,1]{2,1,0} %gather.7171), dimensions={0,1,2} + %constant.7173 = s32[] constant(0) + %constant.7174 = s32[] constant(0) + %compare.7175 = pred[] compare(s32[] %constant.7173, s32[] %constant.7174), direction=LT + %constant.7176 = s32[] constant(0) + %constant.7177 = s32[] constant(1) + %add.7178 = s32[] add(s32[] %constant.7176, s32[] %constant.7177) + %constant.7179 = s32[] constant(0) + %select.7180 = s32[] select(pred[] %compare.7175, s32[] %add.7178, s32[] %constant.7179) + %broadcast.7181 = s32[1]{0} broadcast(s32[] %select.7180), dimensions={} + %gather.7182 = f32[3,3]{1,0} gather(f32[3,3,1]{2,1,0} %broadcast.7172, s32[1]{0} %broadcast.7181), offset_dims={0,1}, collapsed_slice_dims={2}, start_index_map={2}, index_vector_dim=0, slice_sizes={3,3,1}, indices_are_sorted=true + %broadcast.7183 = f32[3,3]{1,0} broadcast(f32[3,3]{1,0} %gather.7182), dimensions={0,1} + ROOT %tuple.7184 = (f32[3,3]{1,0}) tuple(f32[3,3]{1,0} %broadcast.7183) +} + +%jit_transpose_solve_.7185 (parameter.7186: f32[3,3], parameter.7187: f32[3,3], parameter.7188: s32[3], parameter.7189: f32[3,3]) -> (f32[3,3]) { + %parameter.7186 = f32[3,3]{1,0} parameter(0) + %constant.7190 = pred[] constant(false) + %constant.7192 = pred[] constant(false) + %parameter.7187 = f32[3,3]{1,0} parameter(1) + %parameter.7188 = s32[3]{0} parameter(2) + %parameter.7189 = f32[3,3]{0,1} parameter(3) + %transpose.7191 = f32[3,3]{1,0} transpose(f32[3,3]{0,1} %parameter.7189), dimensions={1,0} + %call.7193 = (f32[3,3]{1,0}) call(f32[3,3]{1,0} %parameter.7187, s32[3]{0} %parameter.7188, f32[3,3]{1,0} %transpose.7191), to_apply=%jit_vmap__lu_solve_.7145 + %get-tuple-element.7194 = f32[3,3]{1,0} get-tuple-element((f32[3,3]{1,0}) %call.7193), index=0 + %tuple.7195 = (f32[3,3]{1,0}) tuple(f32[3,3]{1,0} %get-tuple-element.7194) + %get-tuple-element.7196 = f32[3,3]{1,0} get-tuple-element((f32[3,3]{1,0}) %tuple.7195), index=0 + %transpose.7197 = f32[3,3]{0,1} transpose(f32[3,3]{1,0} %get-tuple-element.7196), dimensions={1,0} + ROOT %tuple.7198 = (f32[3,3]{0,1}) tuple(f32[3,3]{0,1} %transpose.7197) +} + +%primitive_computation_add__1.7218 (parameter.7219: f32[], parameter.7220: f32[]) -> f32[] { + %parameter.7219 = f32[] parameter(0) + %parameter.7220 = f32[] parameter(1) + ROOT %add.7221 = f32[] add(f32[] %parameter.7219, f32[] %parameter.7220) +} + +%primitive_computation_add__1.7226 (parameter.7227: f32[], parameter.7228: f32[]) -> f32[] { + %parameter.7227 = f32[] parameter(0) + %parameter.7228 = f32[] parameter(1) + ROOT %add.7229 = f32[] add(f32[] %parameter.7227, f32[] %parameter.7228) +} + +%primitive_computation_add__1.7233 (parameter.7234: f32[], parameter.7235: f32[]) -> f32[] { + %parameter.7234 = f32[] parameter(0) + %parameter.7235 = f32[] parameter(1) + ROOT %add.7236 = f32[] add(f32[] %parameter.7234, f32[] %parameter.7235) +} + +%primitive_computation_add__1.7241 (parameter.7242: f32[], parameter.7243: f32[]) -> f32[] { + %parameter.7242 = f32[] parameter(0) + %parameter.7243 = f32[] parameter(1) + ROOT %add.7244 = f32[] add(f32[] %parameter.7242, f32[] %parameter.7243) +} + +%primitive_computation_add__1.7248 (parameter.7249: f32[], parameter.7250: f32[]) -> f32[] { + %parameter.7249 = f32[] parameter(0) + %parameter.7250 = f32[] parameter(1) + ROOT %add.7251 = f32[] add(f32[] %parameter.7249, f32[] %parameter.7250) +} + +%primitive_computation_add__1.7260 (parameter.7261: f32[], parameter.7262: f32[]) -> f32[] { + %parameter.7261 = f32[] parameter(0) + %parameter.7262 = f32[] parameter(1) + ROOT %add.7263 = f32[] add(f32[] %parameter.7261, f32[] %parameter.7262) +} + +%primitive_computation_add__1.7270 (parameter.7271: f32[], parameter.7272: f32[]) -> f32[] { + %parameter.7271 = f32[] parameter(0) + %parameter.7272 = f32[] parameter(1) + ROOT %add.7273 = f32[] add(f32[] %parameter.7271, f32[] %parameter.7272) +} + +%primitive_computation_add__1.7335 (parameter.7336: f32[], parameter.7337: f32[]) -> f32[] { + %parameter.7336 = f32[] parameter(0) + %parameter.7337 = f32[] parameter(1) + ROOT %add.7338 = f32[] add(f32[] %parameter.7336, f32[] %parameter.7337) +} + +%primitive_computation_add__1.7339 (parameter.7340: f32[], parameter.7341: f32[]) -> f32[] { + %parameter.7340 = f32[] parameter(0) + %parameter.7341 = f32[] parameter(1) + ROOT %add.7342 = f32[] add(f32[] %parameter.7340, f32[] %parameter.7341) +} + +%primitive_computation_add__1.7343 (parameter.7344: f32[], parameter.7345: f32[]) -> f32[] { + %parameter.7344 = f32[] parameter(0) + %parameter.7345 = f32[] parameter(1) + ROOT %add.7346 = f32[] add(f32[] %parameter.7344, f32[] %parameter.7345) +} + +%primitive_computation_add__1.7347 (parameter.7348: f32[], parameter.7349: f32[]) -> f32[] { + %parameter.7348 = f32[] parameter(0) + %parameter.7349 = f32[] parameter(1) + ROOT %add.7350 = f32[] add(f32[] %parameter.7348, f32[] %parameter.7349) +} + +%primitive_computation_add__1.7351 (parameter.7352: f32[], parameter.7353: f32[]) -> f32[] { + %parameter.7352 = f32[] parameter(0) + %parameter.7353 = f32[] parameter(1) + ROOT %add.7354 = f32[] add(f32[] %parameter.7352, f32[] %parameter.7353) +} + +%primitive_computation_add__1.7355 (parameter.7356: f32[], parameter.7357: f32[]) -> f32[] { + %parameter.7356 = f32[] parameter(0) + %parameter.7357 = f32[] parameter(1) + ROOT %add.7358 = f32[] add(f32[] %parameter.7356, f32[] %parameter.7357) +} + +%primitive_computation_add__1.7359 (parameter.7360: f32[], parameter.7361: f32[]) -> f32[] { + %parameter.7360 = f32[] parameter(0) + %parameter.7361 = f32[] parameter(1) + ROOT %add.7362 = f32[] add(f32[] %parameter.7360, f32[] %parameter.7361) +} + +%primitive_computation_add__1.7363 (parameter.7364: f32[], parameter.7365: f32[]) -> f32[] { + %parameter.7364 = f32[] parameter(0) + %parameter.7365 = f32[] parameter(1) + ROOT %add.7366 = f32[] add(f32[] %parameter.7364, f32[] %parameter.7365) +} + +%primitive_computation_add__1.7367 (parameter.7368: f32[], parameter.7369: f32[]) -> f32[] { + %parameter.7368 = f32[] parameter(0) + %parameter.7369 = f32[] parameter(1) + ROOT %add.7370 = f32[] add(f32[] %parameter.7368, f32[] %parameter.7369) +} + +%primitive_computation_add__1.7371 (parameter.7372: f32[], parameter.7373: f32[]) -> f32[] { + %parameter.7372 = f32[] parameter(0) + %parameter.7373 = f32[] parameter(1) + ROOT %add.7374 = f32[] add(f32[] %parameter.7372, f32[] %parameter.7373) +} + +%primitive_computation_add__1.7375 (parameter.7376: f32[], parameter.7377: f32[]) -> f32[] { + %parameter.7376 = f32[] parameter(0) + %parameter.7377 = f32[] parameter(1) + ROOT %add.7378 = f32[] add(f32[] %parameter.7376, f32[] %parameter.7377) +} + +%primitive_computation_add__1.7379 (parameter.7380: f32[], parameter.7381: f32[]) -> f32[] { + %parameter.7380 = f32[] parameter(0) + %parameter.7381 = f32[] parameter(1) + ROOT %add.7382 = f32[] add(f32[] %parameter.7380, f32[] %parameter.7381) +} + +%primitive_computation_add__1.7383 (parameter.7384: f32[], parameter.7385: f32[]) -> f32[] { + %parameter.7384 = f32[] parameter(0) + %parameter.7385 = f32[] parameter(1) + ROOT %add.7386 = f32[] add(f32[] %parameter.7384, f32[] %parameter.7385) +} + +%primitive_computation_add__1.7387 (parameter.7388: f32[], parameter.7389: f32[]) -> f32[] { + %parameter.7388 = f32[] parameter(0) + %parameter.7389 = f32[] parameter(1) + ROOT %add.7390 = f32[] add(f32[] %parameter.7388, f32[] %parameter.7389) +} + +%primitive_computation_add__1.7391 (parameter.7392: f32[], parameter.7393: f32[]) -> f32[] { + %parameter.7392 = f32[] parameter(0) + %parameter.7393 = f32[] parameter(1) + ROOT %add.7394 = f32[] add(f32[] %parameter.7392, f32[] %parameter.7393) +} + +%primitive_computation_add__1.7395 (parameter.7396: f32[], parameter.7397: f32[]) -> f32[] { + %parameter.7396 = f32[] parameter(0) + %parameter.7397 = f32[] parameter(1) + ROOT %add.7398 = f32[] add(f32[] %parameter.7396, f32[] %parameter.7397) +} + +%primitive_computation_add__1.7399 (parameter.7400: f32[], parameter.7401: f32[]) -> f32[] { + %parameter.7400 = f32[] parameter(0) + %parameter.7401 = f32[] parameter(1) + ROOT %add.7402 = f32[] add(f32[] %parameter.7400, f32[] %parameter.7401) +} + +%primitive_computation_add__1.7403 (parameter.7404: f32[], parameter.7405: f32[]) -> f32[] { + %parameter.7404 = f32[] parameter(0) + %parameter.7405 = f32[] parameter(1) + ROOT %add.7406 = f32[] add(f32[] %parameter.7404, f32[] %parameter.7405) +} + +%primitive_computation_add__1.7407 (parameter.7408: f32[], parameter.7409: f32[]) -> f32[] { + %parameter.7408 = f32[] parameter(0) + %parameter.7409 = f32[] parameter(1) + ROOT %add.7410 = f32[] add(f32[] %parameter.7408, f32[] %parameter.7409) +} + +%primitive_computation_add__1.7411 (parameter.7412: f32[], parameter.7413: f32[]) -> f32[] { + %parameter.7412 = f32[] parameter(0) + %parameter.7413 = f32[] parameter(1) + ROOT %add.7414 = f32[] add(f32[] %parameter.7412, f32[] %parameter.7413) +} + +%body_computation__3.7415 (parameter.7416: (f32[2,16], f32[2,16], f32[2,3,3,8,16], f32[2,16], f32[2,16], /*index=5*/f32[2,1,1,16,16], f32[2,8], f32[2,8], f32[2,16,32,32,8], f32[2,16,32,32,8], /*index=10*/f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,3,3,8,16], f32[2,16,32,32,8], f32[2,1,1,1,16], /*index=15*/f32[2,3,3,8,16], f32[2,3,3,8,16], f32[2,16], f32[2,1,1,1,16], f32[2,16,32,32,16], /*index=20*/f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,1,1,16,16], /*index=25*/f32[2,16,32,32,16], f32[2,1,1,1,16], f32[2,1,1,16,16], f32[2,1,1,16,16], f32[2,16], /*index=30*/f32[2,1,1,1,16], f32[2,16,32,32,16], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], /*index=35*/f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,1,1,8], f32[2,16,32,32,8], /*index=40*/f32[2,16,1024,8], f32[2,16,8], f32[2,16,8], f32[2,1,1,1,8], f32[2,16,32,32,8], /*index=45*/s32[], pred[], f32[16,32,32,8], pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16], f32[2,16], f32[2,3,3,8,16], /*index=60*/f32[2,16], f32[2,16], f32[2,1,1,16,16], f32[2,8], f32[2,8])) -> (f32[2,16], f32[2,16], f32[2,3,3,8,16], f32[2,16], f32[2,16], /*index=5*/f32[2,1,1,16,16], f32[2,8], f32[2,8], f32[2,16,32,32,8], f32[2,16,32,32,8], /*index=10*/f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,3,3,8,16], f32[2,16,32,32,8], f32[2,1,1,1,16], /*index=15*/f32[2,3,3,8,16], f32[2,3,3,8,16], f32[2,16], f32[2,1,1,1,16], f32[2,16,32,32,16], /*index=20*/f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,1,1,16,16], /*index=25*/f32[2,16,32,32,16], f32[2,1,1,1,16], f32[2,1,1,16,16], f32[2,1,1,16,16], f32[2,16], /*index=30*/f32[2,1,1,1,16], f32[2,16,32,32,16], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], /*index=35*/f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,1,1,8], f32[2,16,32,32,8], /*index=40*/f32[2,16,1024,8], f32[2,16,8], f32[2,16,8], f32[2,1,1,1,8], f32[2,16,32,32,8], /*index=45*/s32[], pred[], f32[16,32,32,8], pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16], f32[2,16], f32[2,3,3,8,16], /*index=60*/f32[2,16], f32[2,16], f32[2,1,1,16,16], f32[2,8], f32[2,8]) { + %parameter.7416 = (f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) parameter(0) + %get-tuple-element.7463 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=46 + %get-tuple-element.7465 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=48 + %get-tuple-element.7466 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=49 + %get-tuple-element.7467 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=50 + %get-tuple-element.7468 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=51 + %get-tuple-element.7469 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=52 + %get-tuple-element.7470 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=53 + %get-tuple-element.7471 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=54 + %get-tuple-element.7472 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=55 + %get-tuple-element.7473 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=56 + %constant.7482 = pred[] constant(false) + %get-tuple-element.7417 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=0 + %get-tuple-element.7418 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=1 + %get-tuple-element.7419 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=2 + %get-tuple-element.7420 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=3 + %get-tuple-element.7421 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=4 + %get-tuple-element.7422 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=5 + %get-tuple-element.7423 = f32[2,8]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=6 + %get-tuple-element.7424 = f32[2,8]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=7 + %get-tuple-element.7425 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=8 + %get-tuple-element.7426 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=9 + %get-tuple-element.7427 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=10 + %get-tuple-element.7428 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=11 + %get-tuple-element.7429 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=12 + %get-tuple-element.7430 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=13 + %get-tuple-element.7431 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=14 + %get-tuple-element.7432 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=15 + %get-tuple-element.7433 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=16 + %get-tuple-element.7434 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=17 + %get-tuple-element.7435 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=18 + %get-tuple-element.7436 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=19 + %get-tuple-element.7437 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=20 + %get-tuple-element.7438 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=21 + %get-tuple-element.7439 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=22 + %get-tuple-element.7440 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=23 + %get-tuple-element.7441 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=24 + %get-tuple-element.7442 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=25 + %get-tuple-element.7443 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=26 + %get-tuple-element.7444 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=27 + %get-tuple-element.7445 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=28 + %get-tuple-element.7446 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=29 + %get-tuple-element.7447 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=30 + %get-tuple-element.7448 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=31 + %get-tuple-element.7449 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=32 + %get-tuple-element.7450 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=33 + %get-tuple-element.7451 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=34 + %get-tuple-element.7452 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=35 + %get-tuple-element.7453 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=36 + %get-tuple-element.7454 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=37 + %get-tuple-element.7455 = f32[2,16,1,1,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=38 + %get-tuple-element.7456 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=39 + %get-tuple-element.7457 = f32[2,16,1024,8]{3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=40 + %get-tuple-element.7458 = f32[2,16,8]{2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=41 + %get-tuple-element.7459 = f32[2,16,8]{2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=42 + %get-tuple-element.7460 = f32[2,1,1,1,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=43 + %get-tuple-element.7461 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=44 + %get-tuple-element.7462 = s32[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=45 + %constant.9335 = s32[] constant(1) + %add.9336 = s32[] add(s32[] %get-tuple-element.7462, s32[] %constant.9335) + %constant.9337 = pred[] constant(false) + %get-tuple-element.7464 = f32[16,32,32,8]{3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=47 + %constant.7483 = s32[] constant(2) + %subtract.7484 = s32[] subtract(s32[] %constant.7483, s32[] %get-tuple-element.7462) + %constant.7485 = s32[] constant(1) + %subtract.7486 = s32[] subtract(s32[] %subtract.7484, s32[] %constant.7485) + %constant.8932 = s32[] constant(0) + %compare.8933 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8932), direction=LT + %constant.8934 = s32[] constant(2) + %add.8935 = s32[] add(s32[] %subtract.7486, s32[] %constant.8934) + %select.8936 = s32[] select(pred[] %compare.8933, s32[] %add.8935, s32[] %subtract.7486) + %constant.8937 = s32[] constant(0) + %constant.8938 = s32[] constant(0) + %compare.8939 = pred[] compare(s32[] %constant.8937, s32[] %constant.8938), direction=LT + %constant.8940 = s32[] constant(0) + %constant.8941 = s32[] constant(1) + %add.8942 = s32[] add(s32[] %constant.8940, s32[] %constant.8941) + %constant.8943 = s32[] constant(0) + %select.8944 = s32[] select(pred[] %compare.8939, s32[] %add.8942, s32[] %constant.8943) + %constant.8945 = s32[] constant(0) + %constant.8946 = s32[] constant(0) + %compare.8947 = pred[] compare(s32[] %constant.8945, s32[] %constant.8946), direction=LT + %constant.8948 = s32[] constant(0) + %constant.8949 = s32[] constant(1) + %add.8950 = s32[] add(s32[] %constant.8948, s32[] %constant.8949) + %constant.8951 = s32[] constant(0) + %select.8952 = s32[] select(pred[] %compare.8947, s32[] %add.8950, s32[] %constant.8951) + %constant.8953 = s32[] constant(0) + %constant.8954 = s32[] constant(0) + %compare.8955 = pred[] compare(s32[] %constant.8953, s32[] %constant.8954), direction=LT + %constant.8956 = s32[] constant(0) + %constant.8957 = s32[] constant(1) + %add.8958 = s32[] add(s32[] %constant.8956, s32[] %constant.8957) + %constant.8959 = s32[] constant(0) + %select.8960 = s32[] select(pred[] %compare.8955, s32[] %add.8958, s32[] %constant.8959) + %constant.8961 = s32[] constant(0) + %constant.8962 = s32[] constant(0) + %compare.8963 = pred[] compare(s32[] %constant.8961, s32[] %constant.8962), direction=LT + %constant.8964 = s32[] constant(0) + %constant.8965 = s32[] constant(8) + %add.8966 = s32[] add(s32[] %constant.8964, s32[] %constant.8965) + %constant.8967 = s32[] constant(0) + %select.8968 = s32[] select(pred[] %compare.8963, s32[] %add.8966, s32[] %constant.8967) + %dynamic-slice.8969 = f32[1,1,1,1,8]{4,3,2,1,0} dynamic-slice(f32[2,1,1,1,8]{4,3,2,1,0} %get-tuple-element.7460, s32[] %select.8936, s32[] %select.8944, s32[] %select.8952, s32[] %select.8960, /*index=5*/s32[] %select.8968), dynamic_slice_sizes={1,1,1,1,8} + %reshape.8970 = f32[1,1,1,8]{3,2,1,0} reshape(f32[1,1,1,1,8]{4,3,2,1,0} %dynamic-slice.8969) + %reshape.9025 = f32[8]{0} reshape(f32[1,1,1,8]{3,2,1,0} %reshape.8970) + %broadcast.9026 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[8]{0} %reshape.9025), dimensions={3} + %multiply.9027 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %get-tuple-element.7464, f32[16,32,32,8]{3,2,1,0} %broadcast.9026) + %constant.8777 = s32[] constant(0) + %compare.8778 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8777), direction=LT + %constant.8779 = s32[] constant(2) + %add.8780 = s32[] add(s32[] %subtract.7486, s32[] %constant.8779) + %select.8781 = s32[] select(pred[] %compare.8778, s32[] %add.8780, s32[] %subtract.7486) + %constant.8782 = s32[] constant(0) + %constant.8783 = s32[] constant(0) + %compare.8784 = pred[] compare(s32[] %constant.8782, s32[] %constant.8783), direction=LT + %constant.8785 = s32[] constant(0) + %constant.8786 = s32[] constant(16) + %add.8787 = s32[] add(s32[] %constant.8785, s32[] %constant.8786) + %constant.8788 = s32[] constant(0) + %select.8789 = s32[] select(pred[] %compare.8784, s32[] %add.8787, s32[] %constant.8788) + %constant.8790 = s32[] constant(0) + %constant.8791 = s32[] constant(0) + %compare.8792 = pred[] compare(s32[] %constant.8790, s32[] %constant.8791), direction=LT + %constant.8793 = s32[] constant(0) + %constant.8794 = s32[] constant(1) + %add.8795 = s32[] add(s32[] %constant.8793, s32[] %constant.8794) + %constant.8796 = s32[] constant(0) + %select.8797 = s32[] select(pred[] %compare.8792, s32[] %add.8795, s32[] %constant.8796) + %constant.8798 = s32[] constant(0) + %constant.8799 = s32[] constant(0) + %compare.8800 = pred[] compare(s32[] %constant.8798, s32[] %constant.8799), direction=LT + %constant.8801 = s32[] constant(0) + %constant.8802 = s32[] constant(1) + %add.8803 = s32[] add(s32[] %constant.8801, s32[] %constant.8802) + %constant.8804 = s32[] constant(0) + %select.8805 = s32[] select(pred[] %compare.8800, s32[] %add.8803, s32[] %constant.8804) + %constant.8806 = s32[] constant(0) + %constant.8807 = s32[] constant(0) + %compare.8808 = pred[] compare(s32[] %constant.8806, s32[] %constant.8807), direction=LT + %constant.8809 = s32[] constant(0) + %constant.8810 = s32[] constant(8) + %add.8811 = s32[] add(s32[] %constant.8809, s32[] %constant.8810) + %constant.8812 = s32[] constant(0) + %select.8813 = s32[] select(pred[] %compare.8808, s32[] %add.8811, s32[] %constant.8812) + %dynamic-slice.8814 = f32[1,16,1,1,8]{4,3,2,1,0} dynamic-slice(f32[2,16,1,1,8]{4,3,2,1,0} %get-tuple-element.7455, s32[] %select.8781, s32[] %select.8789, s32[] %select.8797, s32[] %select.8805, /*index=5*/s32[] %select.8813), dynamic_slice_sizes={1,16,1,1,8} + %reshape.8815 = f32[16,1,1,8]{3,2,1,0} reshape(f32[1,16,1,1,8]{4,3,2,1,0} %dynamic-slice.8814) + %reshape.9043 = f32[16,8]{1,0} reshape(f32[16,1,1,8]{3,2,1,0} %reshape.8815) + %broadcast.9044 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[16,8]{1,0} %reshape.9043), dimensions={0,3} + %multiply.9045 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %multiply.9027, f32[16,32,32,8]{3,2,1,0} %broadcast.9044) + %constant.8816 = s32[] constant(0) + %compare.8817 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8816), direction=LT + %constant.8818 = s32[] constant(2) + %add.8819 = s32[] add(s32[] %subtract.7486, s32[] %constant.8818) + %select.8820 = s32[] select(pred[] %compare.8817, s32[] %add.8819, s32[] %subtract.7486) + %constant.8821 = s32[] constant(0) + %constant.8822 = s32[] constant(0) + %compare.8823 = pred[] compare(s32[] %constant.8821, s32[] %constant.8822), direction=LT + %constant.8824 = s32[] constant(0) + %constant.8825 = s32[] constant(16) + %add.8826 = s32[] add(s32[] %constant.8824, s32[] %constant.8825) + %constant.8827 = s32[] constant(0) + %select.8828 = s32[] select(pred[] %compare.8823, s32[] %add.8826, s32[] %constant.8827) + %constant.8829 = s32[] constant(0) + %constant.8830 = s32[] constant(0) + %compare.8831 = pred[] compare(s32[] %constant.8829, s32[] %constant.8830), direction=LT + %constant.8832 = s32[] constant(0) + %constant.8833 = s32[] constant(32) + %add.8834 = s32[] add(s32[] %constant.8832, s32[] %constant.8833) + %constant.8835 = s32[] constant(0) + %select.8836 = s32[] select(pred[] %compare.8831, s32[] %add.8834, s32[] %constant.8835) + %constant.8837 = s32[] constant(0) + %constant.8838 = s32[] constant(0) + %compare.8839 = pred[] compare(s32[] %constant.8837, s32[] %constant.8838), direction=LT + %constant.8840 = s32[] constant(0) + %constant.8841 = s32[] constant(32) + %add.8842 = s32[] add(s32[] %constant.8840, s32[] %constant.8841) + %constant.8843 = s32[] constant(0) + %select.8844 = s32[] select(pred[] %compare.8839, s32[] %add.8842, s32[] %constant.8843) + %constant.8845 = s32[] constant(0) + %constant.8846 = s32[] constant(0) + %compare.8847 = pred[] compare(s32[] %constant.8845, s32[] %constant.8846), direction=LT + %constant.8848 = s32[] constant(0) + %constant.8849 = s32[] constant(8) + %add.8850 = s32[] add(s32[] %constant.8848, s32[] %constant.8849) + %constant.8851 = s32[] constant(0) + %select.8852 = s32[] select(pred[] %compare.8847, s32[] %add.8850, s32[] %constant.8851) + %dynamic-slice.8853 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7456, s32[] %select.8820, s32[] %select.8828, s32[] %select.8836, s32[] %select.8844, /*index=5*/s32[] %select.8852), dynamic_slice_sizes={1,16,32,32,8} + %reshape.8854 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.8853) + %multiply.9028 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %reshape.8854, f32[16,32,32,8]{3,2,1,0} %multiply.9027) + %constant.9029 = f32[] constant(0) + %reduce.9030 = f32[16,8]{1,0} reduce(f32[16,32,32,8]{3,2,1,0} %multiply.9028, f32[] %constant.9029), dimensions={1,2}, to_apply=%primitive_computation_add__1.7351 + %reshape.9031 = f32[16,1,1,8]{3,2,1,0} reshape(f32[16,8]{1,0} %reduce.9030) + %constant.9032 = f32[] constant(0) + %reduce.9033 = f32[16,8]{1,0} reduce(f32[16,1,1,8]{3,2,1,0} %reshape.9031, f32[] %constant.9032), dimensions={1,2}, to_apply=%primitive_computation_add__1.7355 + %broadcast.9034 = f32[16,8]{1,0} broadcast(f32[16,8]{1,0} %reduce.9033), dimensions={0,1} + %constant.8909 = s32[] constant(0) + %compare.8910 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8909), direction=LT + %constant.8911 = s32[] constant(2) + %add.8912 = s32[] add(s32[] %subtract.7486, s32[] %constant.8911) + %select.8913 = s32[] select(pred[] %compare.8910, s32[] %add.8912, s32[] %subtract.7486) + %constant.8914 = s32[] constant(0) + %constant.8915 = s32[] constant(0) + %compare.8916 = pred[] compare(s32[] %constant.8914, s32[] %constant.8915), direction=LT + %constant.8917 = s32[] constant(0) + %constant.8918 = s32[] constant(16) + %add.8919 = s32[] add(s32[] %constant.8917, s32[] %constant.8918) + %constant.8920 = s32[] constant(0) + %select.8921 = s32[] select(pred[] %compare.8916, s32[] %add.8919, s32[] %constant.8920) + %constant.8922 = s32[] constant(0) + %constant.8923 = s32[] constant(0) + %compare.8924 = pred[] compare(s32[] %constant.8922, s32[] %constant.8923), direction=LT + %constant.8925 = s32[] constant(0) + %constant.8926 = s32[] constant(8) + %add.8927 = s32[] add(s32[] %constant.8925, s32[] %constant.8926) + %constant.8928 = s32[] constant(0) + %select.8929 = s32[] select(pred[] %compare.8924, s32[] %add.8927, s32[] %constant.8928) + %dynamic-slice.8930 = f32[1,16,8]{2,1,0} dynamic-slice(f32[2,16,8]{2,1,0} %get-tuple-element.7459, s32[] %select.8913, s32[] %select.8921, s32[] %select.8929), dynamic_slice_sizes={1,16,8} + %reshape.8931 = f32[16,8]{1,0} reshape(f32[1,16,8]{2,1,0} %dynamic-slice.8930) + %multiply.9035 = f32[16,8]{1,0} multiply(f32[16,8]{1,0} %broadcast.9034, f32[16,8]{1,0} %reshape.8931) + %constant.9038 = f32[] constant(1024) + %broadcast.9039 = f32[16,8]{1,0} broadcast(f32[] %constant.9038), dimensions={} + %divide.9040 = f32[16,8]{1,0} divide(f32[16,8]{1,0} %multiply.9035, f32[16,8]{1,0} %broadcast.9039) + %broadcast.9041 = f32[16,1024,8]{2,1,0} broadcast(f32[16,8]{1,0} %divide.9040), dimensions={0,2} + %constant.8855 = s32[] constant(0) + %compare.8856 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8855), direction=LT + %constant.8857 = s32[] constant(2) + %add.8858 = s32[] add(s32[] %subtract.7486, s32[] %constant.8857) + %select.8859 = s32[] select(pred[] %compare.8856, s32[] %add.8858, s32[] %subtract.7486) + %constant.8860 = s32[] constant(0) + %constant.8861 = s32[] constant(0) + %compare.8862 = pred[] compare(s32[] %constant.8860, s32[] %constant.8861), direction=LT + %constant.8863 = s32[] constant(0) + %constant.8864 = s32[] constant(16) + %add.8865 = s32[] add(s32[] %constant.8863, s32[] %constant.8864) + %constant.8866 = s32[] constant(0) + %select.8867 = s32[] select(pred[] %compare.8862, s32[] %add.8865, s32[] %constant.8866) + %constant.8868 = s32[] constant(0) + %constant.8869 = s32[] constant(0) + %compare.8870 = pred[] compare(s32[] %constant.8868, s32[] %constant.8869), direction=LT + %constant.8871 = s32[] constant(0) + %constant.8872 = s32[] constant(1024) + %add.8873 = s32[] add(s32[] %constant.8871, s32[] %constant.8872) + %constant.8874 = s32[] constant(0) + %select.8875 = s32[] select(pred[] %compare.8870, s32[] %add.8873, s32[] %constant.8874) + %constant.8876 = s32[] constant(0) + %constant.8877 = s32[] constant(0) + %compare.8878 = pred[] compare(s32[] %constant.8876, s32[] %constant.8877), direction=LT + %constant.8879 = s32[] constant(0) + %constant.8880 = s32[] constant(8) + %add.8881 = s32[] add(s32[] %constant.8879, s32[] %constant.8880) + %constant.8882 = s32[] constant(0) + %select.8883 = s32[] select(pred[] %compare.8878, s32[] %add.8881, s32[] %constant.8882) + %dynamic-slice.8884 = f32[1,16,1024,8]{3,2,1,0} dynamic-slice(f32[2,16,1024,8]{3,2,1,0} %get-tuple-element.7457, s32[] %select.8859, s32[] %select.8867, s32[] %select.8875, s32[] %select.8883), dynamic_slice_sizes={1,16,1024,8} + %reshape.8885 = f32[16,1024,8]{2,1,0} reshape(f32[1,16,1024,8]{3,2,1,0} %dynamic-slice.8884) + %multiply.9042 = f32[16,1024,8]{2,1,0} multiply(f32[16,1024,8]{2,1,0} %broadcast.9041, f32[16,1024,8]{2,1,0} %reshape.8885) + %negate.9036 = f32[16,8]{1,0} negate(f32[16,8]{1,0} %multiply.9035) + %constant.8886 = s32[] constant(0) + %compare.8887 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8886), direction=LT + %constant.8888 = s32[] constant(2) + %add.8889 = s32[] add(s32[] %subtract.7486, s32[] %constant.8888) + %select.8890 = s32[] select(pred[] %compare.8887, s32[] %add.8889, s32[] %subtract.7486) + %constant.8891 = s32[] constant(0) + %constant.8892 = s32[] constant(0) + %compare.8893 = pred[] compare(s32[] %constant.8891, s32[] %constant.8892), direction=LT + %constant.8894 = s32[] constant(0) + %constant.8895 = s32[] constant(16) + %add.8896 = s32[] add(s32[] %constant.8894, s32[] %constant.8895) + %constant.8897 = s32[] constant(0) + %select.8898 = s32[] select(pred[] %compare.8893, s32[] %add.8896, s32[] %constant.8897) + %constant.8899 = s32[] constant(0) + %constant.8900 = s32[] constant(0) + %compare.8901 = pred[] compare(s32[] %constant.8899, s32[] %constant.8900), direction=LT + %constant.8902 = s32[] constant(0) + %constant.8903 = s32[] constant(8) + %add.8904 = s32[] add(s32[] %constant.8902, s32[] %constant.8903) + %constant.8905 = s32[] constant(0) + %select.8906 = s32[] select(pred[] %compare.8901, s32[] %add.8904, s32[] %constant.8905) + %dynamic-slice.8907 = f32[1,16,8]{2,1,0} dynamic-slice(f32[2,16,8]{2,1,0} %get-tuple-element.7458, s32[] %select.8890, s32[] %select.8898, s32[] %select.8906), dynamic_slice_sizes={1,16,8} + %reshape.8908 = f32[16,8]{1,0} reshape(f32[1,16,8]{2,1,0} %dynamic-slice.8907) + %multiply.9037 = f32[16,8]{1,0} multiply(f32[16,8]{1,0} %negate.9036, f32[16,8]{1,0} %reshape.8908) + %negate.9046 = f32[16,32,32,8]{3,2,1,0} negate(f32[16,32,32,8]{3,2,1,0} %multiply.9045) + %constant.9047 = f32[] constant(0) + %reduce.9048 = f32[16,8]{1,0} reduce(f32[16,32,32,8]{3,2,1,0} %negate.9046, f32[] %constant.9047), dimensions={1,2}, to_apply=%primitive_computation_add__1.7359 + %reshape.9049 = f32[16,1,1,8]{3,2,1,0} reshape(f32[16,8]{1,0} %reduce.9048) + %constant.9050 = f32[] constant(0) + %reduce.9051 = f32[16,8]{1,0} reduce(f32[16,1,1,8]{3,2,1,0} %reshape.9049, f32[] %constant.9050), dimensions={1,2}, to_apply=%primitive_computation_add__1.7363 + %broadcast.9052 = f32[16,8]{1,0} broadcast(f32[16,8]{1,0} %reduce.9051), dimensions={0,1} + %add.9053 = f32[16,8]{1,0} add(f32[16,8]{1,0} %multiply.9037, f32[16,8]{1,0} %broadcast.9052) + %constant.9054 = f32[] constant(1024) + %broadcast.9055 = f32[16,8]{1,0} broadcast(f32[] %constant.9054), dimensions={} + %divide.9056 = f32[16,8]{1,0} divide(f32[16,8]{1,0} %add.9053, f32[16,8]{1,0} %broadcast.9055) + %broadcast.9057 = f32[16,1024,8]{2,1,0} broadcast(f32[16,8]{1,0} %divide.9056), dimensions={0,2} + %add.9058 = f32[16,1024,8]{2,1,0} add(f32[16,1024,8]{2,1,0} %multiply.9042, f32[16,1024,8]{2,1,0} %broadcast.9057) + %reshape.9059 = f32[16,32,32,8]{3,2,1,0} reshape(f32[16,1024,8]{2,1,0} %add.9058) + %add.9060 = f32[16,32,32,8]{3,2,1,0} add(f32[16,32,32,8]{3,2,1,0} %multiply.9045, f32[16,32,32,8]{3,2,1,0} %reshape.9059) + %constant.8660 = s32[] constant(0) + %compare.8661 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8660), direction=LT + %constant.8662 = s32[] constant(2) + %add.8663 = s32[] add(s32[] %subtract.7486, s32[] %constant.8662) + %select.8664 = s32[] select(pred[] %compare.8661, s32[] %add.8663, s32[] %subtract.7486) + %constant.8665 = s32[] constant(0) + %constant.8666 = s32[] constant(0) + %compare.8667 = pred[] compare(s32[] %constant.8665, s32[] %constant.8666), direction=LT + %constant.8668 = s32[] constant(0) + %constant.8669 = s32[] constant(16) + %add.8670 = s32[] add(s32[] %constant.8668, s32[] %constant.8669) + %constant.8671 = s32[] constant(0) + %select.8672 = s32[] select(pred[] %compare.8667, s32[] %add.8670, s32[] %constant.8671) + %constant.8673 = s32[] constant(0) + %constant.8674 = s32[] constant(0) + %compare.8675 = pred[] compare(s32[] %constant.8673, s32[] %constant.8674), direction=LT + %constant.8676 = s32[] constant(0) + %constant.8677 = s32[] constant(32) + %add.8678 = s32[] add(s32[] %constant.8676, s32[] %constant.8677) + %constant.8679 = s32[] constant(0) + %select.8680 = s32[] select(pred[] %compare.8675, s32[] %add.8678, s32[] %constant.8679) + %constant.8681 = s32[] constant(0) + %constant.8682 = s32[] constant(0) + %compare.8683 = pred[] compare(s32[] %constant.8681, s32[] %constant.8682), direction=LT + %constant.8684 = s32[] constant(0) + %constant.8685 = s32[] constant(32) + %add.8686 = s32[] add(s32[] %constant.8684, s32[] %constant.8685) + %constant.8687 = s32[] constant(0) + %select.8688 = s32[] select(pred[] %compare.8683, s32[] %add.8686, s32[] %constant.8687) + %constant.8689 = s32[] constant(0) + %constant.8690 = s32[] constant(0) + %compare.8691 = pred[] compare(s32[] %constant.8689, s32[] %constant.8690), direction=LT + %constant.8692 = s32[] constant(0) + %constant.8693 = s32[] constant(8) + %add.8694 = s32[] add(s32[] %constant.8692, s32[] %constant.8693) + %constant.8695 = s32[] constant(0) + %select.8696 = s32[] select(pred[] %compare.8691, s32[] %add.8694, s32[] %constant.8695) + %dynamic-slice.8697 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7452, s32[] %select.8664, s32[] %select.8672, s32[] %select.8680, s32[] %select.8688, /*index=5*/s32[] %select.8696), dynamic_slice_sizes={1,16,32,32,8} + %reshape.8698 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.8697) + %constant.8582 = s32[] constant(0) + %compare.8583 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8582), direction=LT + %constant.8584 = s32[] constant(2) + %add.8585 = s32[] add(s32[] %subtract.7486, s32[] %constant.8584) + %select.8586 = s32[] select(pred[] %compare.8583, s32[] %add.8585, s32[] %subtract.7486) + %constant.8587 = s32[] constant(0) + %constant.8588 = s32[] constant(0) + %compare.8589 = pred[] compare(s32[] %constant.8587, s32[] %constant.8588), direction=LT + %constant.8590 = s32[] constant(0) + %constant.8591 = s32[] constant(16) + %add.8592 = s32[] add(s32[] %constant.8590, s32[] %constant.8591) + %constant.8593 = s32[] constant(0) + %select.8594 = s32[] select(pred[] %compare.8589, s32[] %add.8592, s32[] %constant.8593) + %constant.8595 = s32[] constant(0) + %constant.8596 = s32[] constant(0) + %compare.8597 = pred[] compare(s32[] %constant.8595, s32[] %constant.8596), direction=LT + %constant.8598 = s32[] constant(0) + %constant.8599 = s32[] constant(32) + %add.8600 = s32[] add(s32[] %constant.8598, s32[] %constant.8599) + %constant.8601 = s32[] constant(0) + %select.8602 = s32[] select(pred[] %compare.8597, s32[] %add.8600, s32[] %constant.8601) + %constant.8603 = s32[] constant(0) + %constant.8604 = s32[] constant(0) + %compare.8605 = pred[] compare(s32[] %constant.8603, s32[] %constant.8604), direction=LT + %constant.8606 = s32[] constant(0) + %constant.8607 = s32[] constant(32) + %add.8608 = s32[] add(s32[] %constant.8606, s32[] %constant.8607) + %constant.8609 = s32[] constant(0) + %select.8610 = s32[] select(pred[] %compare.8605, s32[] %add.8608, s32[] %constant.8609) + %constant.8611 = s32[] constant(0) + %constant.8612 = s32[] constant(0) + %compare.8613 = pred[] compare(s32[] %constant.8611, s32[] %constant.8612), direction=LT + %constant.8614 = s32[] constant(0) + %constant.8615 = s32[] constant(8) + %add.8616 = s32[] add(s32[] %constant.8614, s32[] %constant.8615) + %constant.8617 = s32[] constant(0) + %select.8618 = s32[] select(pred[] %compare.8613, s32[] %add.8616, s32[] %constant.8617) + %dynamic-slice.8619 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7450, s32[] %select.8586, s32[] %select.8594, s32[] %select.8602, s32[] %select.8610, /*index=5*/s32[] %select.8618), dynamic_slice_sizes={1,16,32,32,8} + %reshape.8620 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.8619) + %multiply.9061 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %reshape.8620, f32[16,32,32,8]{3,2,1,0} %add.9060) + %constant.9062 = f32[] constant(0.5) + %broadcast.9063 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[] %constant.9062), dimensions={} + %multiply.9064 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %multiply.9061, f32[16,32,32,8]{3,2,1,0} %broadcast.9063) + %multiply.9065 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %reshape.8698, f32[16,32,32,8]{3,2,1,0} %multiply.9064) + %constant.8738 = s32[] constant(0) + %compare.8739 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8738), direction=LT + %constant.8740 = s32[] constant(2) + %add.8741 = s32[] add(s32[] %subtract.7486, s32[] %constant.8740) + %select.8742 = s32[] select(pred[] %compare.8739, s32[] %add.8741, s32[] %subtract.7486) + %constant.8743 = s32[] constant(0) + %constant.8744 = s32[] constant(0) + %compare.8745 = pred[] compare(s32[] %constant.8743, s32[] %constant.8744), direction=LT + %constant.8746 = s32[] constant(0) + %constant.8747 = s32[] constant(16) + %add.8748 = s32[] add(s32[] %constant.8746, s32[] %constant.8747) + %constant.8749 = s32[] constant(0) + %select.8750 = s32[] select(pred[] %compare.8745, s32[] %add.8748, s32[] %constant.8749) + %constant.8751 = s32[] constant(0) + %constant.8752 = s32[] constant(0) + %compare.8753 = pred[] compare(s32[] %constant.8751, s32[] %constant.8752), direction=LT + %constant.8754 = s32[] constant(0) + %constant.8755 = s32[] constant(32) + %add.8756 = s32[] add(s32[] %constant.8754, s32[] %constant.8755) + %constant.8757 = s32[] constant(0) + %select.8758 = s32[] select(pred[] %compare.8753, s32[] %add.8756, s32[] %constant.8757) + %constant.8759 = s32[] constant(0) + %constant.8760 = s32[] constant(0) + %compare.8761 = pred[] compare(s32[] %constant.8759, s32[] %constant.8760), direction=LT + %constant.8762 = s32[] constant(0) + %constant.8763 = s32[] constant(32) + %add.8764 = s32[] add(s32[] %constant.8762, s32[] %constant.8763) + %constant.8765 = s32[] constant(0) + %select.8766 = s32[] select(pred[] %compare.8761, s32[] %add.8764, s32[] %constant.8765) + %constant.8767 = s32[] constant(0) + %constant.8768 = s32[] constant(0) + %compare.8769 = pred[] compare(s32[] %constant.8767, s32[] %constant.8768), direction=LT + %constant.8770 = s32[] constant(0) + %constant.8771 = s32[] constant(8) + %add.8772 = s32[] add(s32[] %constant.8770, s32[] %constant.8771) + %constant.8773 = s32[] constant(0) + %select.8774 = s32[] select(pred[] %compare.8769, s32[] %add.8772, s32[] %constant.8773) + %dynamic-slice.8775 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7454, s32[] %select.8742, s32[] %select.8750, s32[] %select.8758, s32[] %select.8766, /*index=5*/s32[] %select.8774), dynamic_slice_sizes={1,16,32,32,8} + %reshape.8776 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.8775) + %multiply.9066 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %multiply.9065, f32[16,32,32,8]{3,2,1,0} %reshape.8776) + %constant.8699 = s32[] constant(0) + %compare.8700 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8699), direction=LT + %constant.8701 = s32[] constant(2) + %add.8702 = s32[] add(s32[] %subtract.7486, s32[] %constant.8701) + %select.8703 = s32[] select(pred[] %compare.8700, s32[] %add.8702, s32[] %subtract.7486) + %constant.8704 = s32[] constant(0) + %constant.8705 = s32[] constant(0) + %compare.8706 = pred[] compare(s32[] %constant.8704, s32[] %constant.8705), direction=LT + %constant.8707 = s32[] constant(0) + %constant.8708 = s32[] constant(16) + %add.8709 = s32[] add(s32[] %constant.8707, s32[] %constant.8708) + %constant.8710 = s32[] constant(0) + %select.8711 = s32[] select(pred[] %compare.8706, s32[] %add.8709, s32[] %constant.8710) + %constant.8712 = s32[] constant(0) + %constant.8713 = s32[] constant(0) + %compare.8714 = pred[] compare(s32[] %constant.8712, s32[] %constant.8713), direction=LT + %constant.8715 = s32[] constant(0) + %constant.8716 = s32[] constant(32) + %add.8717 = s32[] add(s32[] %constant.8715, s32[] %constant.8716) + %constant.8718 = s32[] constant(0) + %select.8719 = s32[] select(pred[] %compare.8714, s32[] %add.8717, s32[] %constant.8718) + %constant.8720 = s32[] constant(0) + %constant.8721 = s32[] constant(0) + %compare.8722 = pred[] compare(s32[] %constant.8720, s32[] %constant.8721), direction=LT + %constant.8723 = s32[] constant(0) + %constant.8724 = s32[] constant(32) + %add.8725 = s32[] add(s32[] %constant.8723, s32[] %constant.8724) + %constant.8726 = s32[] constant(0) + %select.8727 = s32[] select(pred[] %compare.8722, s32[] %add.8725, s32[] %constant.8726) + %constant.8728 = s32[] constant(0) + %constant.8729 = s32[] constant(0) + %compare.8730 = pred[] compare(s32[] %constant.8728, s32[] %constant.8729), direction=LT + %constant.8731 = s32[] constant(0) + %constant.8732 = s32[] constant(8) + %add.8733 = s32[] add(s32[] %constant.8731, s32[] %constant.8732) + %constant.8734 = s32[] constant(0) + %select.8735 = s32[] select(pred[] %compare.8730, s32[] %add.8733, s32[] %constant.8734) + %dynamic-slice.8736 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7453, s32[] %select.8703, s32[] %select.8711, s32[] %select.8719, s32[] %select.8727, /*index=5*/s32[] %select.8735), dynamic_slice_sizes={1,16,32,32,8} + %reshape.8737 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.8736) + %multiply.9067 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %multiply.9066, f32[16,32,32,8]{3,2,1,0} %reshape.8737) + %constant.8621 = s32[] constant(0) + %compare.8622 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8621), direction=LT + %constant.8623 = s32[] constant(2) + %add.8624 = s32[] add(s32[] %subtract.7486, s32[] %constant.8623) + %select.8625 = s32[] select(pred[] %compare.8622, s32[] %add.8624, s32[] %subtract.7486) + %constant.8626 = s32[] constant(0) + %constant.8627 = s32[] constant(0) + %compare.8628 = pred[] compare(s32[] %constant.8626, s32[] %constant.8627), direction=LT + %constant.8629 = s32[] constant(0) + %constant.8630 = s32[] constant(16) + %add.8631 = s32[] add(s32[] %constant.8629, s32[] %constant.8630) + %constant.8632 = s32[] constant(0) + %select.8633 = s32[] select(pred[] %compare.8628, s32[] %add.8631, s32[] %constant.8632) + %constant.8634 = s32[] constant(0) + %constant.8635 = s32[] constant(0) + %compare.8636 = pred[] compare(s32[] %constant.8634, s32[] %constant.8635), direction=LT + %constant.8637 = s32[] constant(0) + %constant.8638 = s32[] constant(32) + %add.8639 = s32[] add(s32[] %constant.8637, s32[] %constant.8638) + %constant.8640 = s32[] constant(0) + %select.8641 = s32[] select(pred[] %compare.8636, s32[] %add.8639, s32[] %constant.8640) + %constant.8642 = s32[] constant(0) + %constant.8643 = s32[] constant(0) + %compare.8644 = pred[] compare(s32[] %constant.8642, s32[] %constant.8643), direction=LT + %constant.8645 = s32[] constant(0) + %constant.8646 = s32[] constant(32) + %add.8647 = s32[] add(s32[] %constant.8645, s32[] %constant.8646) + %constant.8648 = s32[] constant(0) + %select.8649 = s32[] select(pred[] %compare.8644, s32[] %add.8647, s32[] %constant.8648) + %constant.8650 = s32[] constant(0) + %constant.8651 = s32[] constant(0) + %compare.8652 = pred[] compare(s32[] %constant.8650, s32[] %constant.8651), direction=LT + %constant.8653 = s32[] constant(0) + %constant.8654 = s32[] constant(8) + %add.8655 = s32[] add(s32[] %constant.8653, s32[] %constant.8654) + %constant.8656 = s32[] constant(0) + %select.8657 = s32[] select(pred[] %compare.8652, s32[] %add.8655, s32[] %constant.8656) + %dynamic-slice.8658 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7451, s32[] %select.8625, s32[] %select.8633, s32[] %select.8641, s32[] %select.8649, /*index=5*/s32[] %select.8657), dynamic_slice_sizes={1,16,32,32,8} + %reshape.8659 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.8658) + %multiply.9068 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %multiply.9064, f32[16,32,32,8]{3,2,1,0} %reshape.8659) + %add.9069 = f32[16,32,32,8]{3,2,1,0} add(f32[16,32,32,8]{3,2,1,0} %multiply.9067, f32[16,32,32,8]{3,2,1,0} %multiply.9068) + %constant.9070 = f32[] constant(0) + %pad.9071 = f32[16,32,32,16]{3,2,1,0} pad(f32[16,32,32,8]{3,2,1,0} %add.9069, f32[] %constant.9070), padding=0_0x0_0x0_0x8_0 + %constant.8543 = s32[] constant(0) + %compare.8544 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8543), direction=LT + %constant.8545 = s32[] constant(2) + %add.8546 = s32[] add(s32[] %subtract.7486, s32[] %constant.8545) + %select.8547 = s32[] select(pred[] %compare.8544, s32[] %add.8546, s32[] %subtract.7486) + %constant.8548 = s32[] constant(0) + %constant.8549 = s32[] constant(0) + %compare.8550 = pred[] compare(s32[] %constant.8548, s32[] %constant.8549), direction=LT + %constant.8551 = s32[] constant(0) + %constant.8552 = s32[] constant(16) + %add.8553 = s32[] add(s32[] %constant.8551, s32[] %constant.8552) + %constant.8554 = s32[] constant(0) + %select.8555 = s32[] select(pred[] %compare.8550, s32[] %add.8553, s32[] %constant.8554) + %constant.8556 = s32[] constant(0) + %constant.8557 = s32[] constant(0) + %compare.8558 = pred[] compare(s32[] %constant.8556, s32[] %constant.8557), direction=LT + %constant.8559 = s32[] constant(0) + %constant.8560 = s32[] constant(32) + %add.8561 = s32[] add(s32[] %constant.8559, s32[] %constant.8560) + %constant.8562 = s32[] constant(0) + %select.8563 = s32[] select(pred[] %compare.8558, s32[] %add.8561, s32[] %constant.8562) + %constant.8564 = s32[] constant(0) + %constant.8565 = s32[] constant(0) + %compare.8566 = pred[] compare(s32[] %constant.8564, s32[] %constant.8565), direction=LT + %constant.8567 = s32[] constant(0) + %constant.8568 = s32[] constant(32) + %add.8569 = s32[] add(s32[] %constant.8567, s32[] %constant.8568) + %constant.8570 = s32[] constant(0) + %select.8571 = s32[] select(pred[] %compare.8566, s32[] %add.8569, s32[] %constant.8570) + %constant.8572 = s32[] constant(0) + %constant.8573 = s32[] constant(0) + %compare.8574 = pred[] compare(s32[] %constant.8572, s32[] %constant.8573), direction=LT + %constant.8575 = s32[] constant(0) + %constant.8576 = s32[] constant(8) + %add.8577 = s32[] add(s32[] %constant.8575, s32[] %constant.8576) + %constant.8578 = s32[] constant(0) + %select.8579 = s32[] select(pred[] %compare.8574, s32[] %add.8577, s32[] %constant.8578) + %dynamic-slice.8580 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7449, s32[] %select.8547, s32[] %select.8555, s32[] %select.8563, s32[] %select.8571, /*index=5*/s32[] %select.8579), dynamic_slice_sizes={1,16,32,32,8} + %reshape.8581 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.8580) + %multiply.9072 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %add.9060, f32[16,32,32,8]{3,2,1,0} %reshape.8581) + %constant.9073 = f32[] constant(0) + %pad.9074 = f32[16,32,32,16]{3,2,1,0} pad(f32[16,32,32,8]{3,2,1,0} %multiply.9072, f32[] %constant.9073), padding=0_0x0_0x0_0x0_8 + %add.9075 = f32[16,32,32,16]{3,2,1,0} add(f32[16,32,32,16]{3,2,1,0} %pad.9071, f32[16,32,32,16]{3,2,1,0} %pad.9074) + %constant.8465 = s32[] constant(0) + %compare.8466 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8465), direction=LT + %constant.8467 = s32[] constant(2) + %add.8468 = s32[] add(s32[] %subtract.7486, s32[] %constant.8467) + %select.8469 = s32[] select(pred[] %compare.8466, s32[] %add.8468, s32[] %subtract.7486) + %constant.8470 = s32[] constant(0) + %constant.8471 = s32[] constant(0) + %compare.8472 = pred[] compare(s32[] %constant.8470, s32[] %constant.8471), direction=LT + %constant.8473 = s32[] constant(0) + %constant.8474 = s32[] constant(1) + %add.8475 = s32[] add(s32[] %constant.8473, s32[] %constant.8474) + %constant.8476 = s32[] constant(0) + %select.8477 = s32[] select(pred[] %compare.8472, s32[] %add.8475, s32[] %constant.8476) + %constant.8478 = s32[] constant(0) + %constant.8479 = s32[] constant(0) + %compare.8480 = pred[] compare(s32[] %constant.8478, s32[] %constant.8479), direction=LT + %constant.8481 = s32[] constant(0) + %constant.8482 = s32[] constant(1) + %add.8483 = s32[] add(s32[] %constant.8481, s32[] %constant.8482) + %constant.8484 = s32[] constant(0) + %select.8485 = s32[] select(pred[] %compare.8480, s32[] %add.8483, s32[] %constant.8484) + %constant.8486 = s32[] constant(0) + %constant.8487 = s32[] constant(0) + %compare.8488 = pred[] compare(s32[] %constant.8486, s32[] %constant.8487), direction=LT + %constant.8489 = s32[] constant(0) + %constant.8490 = s32[] constant(1) + %add.8491 = s32[] add(s32[] %constant.8489, s32[] %constant.8490) + %constant.8492 = s32[] constant(0) + %select.8493 = s32[] select(pred[] %compare.8488, s32[] %add.8491, s32[] %constant.8492) + %constant.8494 = s32[] constant(0) + %constant.8495 = s32[] constant(0) + %compare.8496 = pred[] compare(s32[] %constant.8494, s32[] %constant.8495), direction=LT + %constant.8497 = s32[] constant(0) + %constant.8498 = s32[] constant(16) + %add.8499 = s32[] add(s32[] %constant.8497, s32[] %constant.8498) + %constant.8500 = s32[] constant(0) + %select.8501 = s32[] select(pred[] %compare.8496, s32[] %add.8499, s32[] %constant.8500) + %dynamic-slice.8502 = f32[1,1,1,1,16]{4,3,2,1,0} dynamic-slice(f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.7447, s32[] %select.8469, s32[] %select.8477, s32[] %select.8485, s32[] %select.8493, /*index=5*/s32[] %select.8501), dynamic_slice_sizes={1,1,1,1,16} + %reshape.8503 = f32[1,1,1,16]{3,2,1,0} reshape(f32[1,1,1,1,16]{4,3,2,1,0} %dynamic-slice.8502) + %reshape.9091 = f32[16]{0} reshape(f32[1,1,1,16]{3,2,1,0} %reshape.8503) + %broadcast.9092 = f32[16,32,32,16]{3,2,1,0} broadcast(f32[16]{0} %reshape.9091), dimensions={3} + %multiply.9093 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %add.9075, f32[16,32,32,16]{3,2,1,0} %broadcast.9092) + %constant.8255 = s32[] constant(0) + %compare.8256 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8255), direction=LT + %constant.8257 = s32[] constant(2) + %add.8258 = s32[] add(s32[] %subtract.7486, s32[] %constant.8257) + %select.8259 = s32[] select(pred[] %compare.8256, s32[] %add.8258, s32[] %subtract.7486) + %constant.8260 = s32[] constant(0) + %constant.8261 = s32[] constant(0) + %compare.8262 = pred[] compare(s32[] %constant.8260, s32[] %constant.8261), direction=LT + %constant.8263 = s32[] constant(0) + %constant.8264 = s32[] constant(1) + %add.8265 = s32[] add(s32[] %constant.8263, s32[] %constant.8264) + %constant.8266 = s32[] constant(0) + %select.8267 = s32[] select(pred[] %compare.8262, s32[] %add.8265, s32[] %constant.8266) + %constant.8268 = s32[] constant(0) + %constant.8269 = s32[] constant(0) + %compare.8270 = pred[] compare(s32[] %constant.8268, s32[] %constant.8269), direction=LT + %constant.8271 = s32[] constant(0) + %constant.8272 = s32[] constant(1) + %add.8273 = s32[] add(s32[] %constant.8271, s32[] %constant.8272) + %constant.8274 = s32[] constant(0) + %select.8275 = s32[] select(pred[] %compare.8270, s32[] %add.8273, s32[] %constant.8274) + %constant.8276 = s32[] constant(0) + %constant.8277 = s32[] constant(0) + %compare.8278 = pred[] compare(s32[] %constant.8276, s32[] %constant.8277), direction=LT + %constant.8279 = s32[] constant(0) + %constant.8280 = s32[] constant(16) + %add.8281 = s32[] add(s32[] %constant.8279, s32[] %constant.8280) + %constant.8282 = s32[] constant(0) + %select.8283 = s32[] select(pred[] %compare.8278, s32[] %add.8281, s32[] %constant.8282) + %constant.8284 = s32[] constant(0) + %constant.8285 = s32[] constant(0) + %compare.8286 = pred[] compare(s32[] %constant.8284, s32[] %constant.8285), direction=LT + %constant.8287 = s32[] constant(0) + %constant.8288 = s32[] constant(16) + %add.8289 = s32[] add(s32[] %constant.8287, s32[] %constant.8288) + %constant.8290 = s32[] constant(0) + %select.8291 = s32[] select(pred[] %compare.8286, s32[] %add.8289, s32[] %constant.8290) + %dynamic-slice.8292 = f32[1,1,1,16,16]{4,3,2,1,0} dynamic-slice(f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.7441, s32[] %select.8259, s32[] %select.8267, s32[] %select.8275, s32[] %select.8283, /*index=5*/s32[] %select.8291), dynamic_slice_sizes={1,1,1,16,16} + %reshape.8293 = f32[1,1,16,16]{3,2,1,0} reshape(f32[1,1,1,16,16]{4,3,2,1,0} %dynamic-slice.8292) + %reverse.9110 = f32[1,1,16,16]{3,2,1,0} reverse(f32[1,1,16,16]{3,2,1,0} %reshape.8293), dimensions={0,1} + %convolution.9111 = f32[16,32,32,16]{3,2,1,0} convolution(f32[16,32,32,16]{3,2,1,0} %multiply.9093, f32[1,1,16,16]{3,2,1,0} %reverse.9110), window={size=1x1}, dim_labels=b01f_01oi->b01f + %constant.9112 = f32[] constant(0.5) + %broadcast.9113 = f32[16,32,32,16]{3,2,1,0} broadcast(f32[] %constant.9112), dimensions={} + %multiply.9114 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %convolution.9111, f32[16,32,32,16]{3,2,1,0} %broadcast.9113) + %constant.8177 = s32[] constant(0) + %compare.8178 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8177), direction=LT + %constant.8179 = s32[] constant(2) + %add.8180 = s32[] add(s32[] %subtract.7486, s32[] %constant.8179) + %select.8181 = s32[] select(pred[] %compare.8178, s32[] %add.8180, s32[] %subtract.7486) + %constant.8182 = s32[] constant(0) + %constant.8183 = s32[] constant(0) + %compare.8184 = pred[] compare(s32[] %constant.8182, s32[] %constant.8183), direction=LT + %constant.8185 = s32[] constant(0) + %constant.8186 = s32[] constant(16) + %add.8187 = s32[] add(s32[] %constant.8185, s32[] %constant.8186) + %constant.8188 = s32[] constant(0) + %select.8189 = s32[] select(pred[] %compare.8184, s32[] %add.8187, s32[] %constant.8188) + %constant.8190 = s32[] constant(0) + %constant.8191 = s32[] constant(0) + %compare.8192 = pred[] compare(s32[] %constant.8190, s32[] %constant.8191), direction=LT + %constant.8193 = s32[] constant(0) + %constant.8194 = s32[] constant(32) + %add.8195 = s32[] add(s32[] %constant.8193, s32[] %constant.8194) + %constant.8196 = s32[] constant(0) + %select.8197 = s32[] select(pred[] %compare.8192, s32[] %add.8195, s32[] %constant.8196) + %constant.8198 = s32[] constant(0) + %constant.8199 = s32[] constant(0) + %compare.8200 = pred[] compare(s32[] %constant.8198, s32[] %constant.8199), direction=LT + %constant.8201 = s32[] constant(0) + %constant.8202 = s32[] constant(32) + %add.8203 = s32[] add(s32[] %constant.8201, s32[] %constant.8202) + %constant.8204 = s32[] constant(0) + %select.8205 = s32[] select(pred[] %compare.8200, s32[] %add.8203, s32[] %constant.8204) + %constant.8206 = s32[] constant(0) + %constant.8207 = s32[] constant(0) + %compare.8208 = pred[] compare(s32[] %constant.8206, s32[] %constant.8207), direction=LT + %constant.8209 = s32[] constant(0) + %constant.8210 = s32[] constant(16) + %add.8211 = s32[] add(s32[] %constant.8209, s32[] %constant.8210) + %constant.8212 = s32[] constant(0) + %select.8213 = s32[] select(pred[] %compare.8208, s32[] %add.8211, s32[] %constant.8212) + %dynamic-slice.8214 = f32[1,16,32,32,16]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.7439, s32[] %select.8181, s32[] %select.8189, s32[] %select.8197, s32[] %select.8205, /*index=5*/s32[] %select.8213), dynamic_slice_sizes={1,16,32,32,16} + %reshape.8215 = f32[16,32,32,16]{3,2,1,0} reshape(f32[1,16,32,32,16]{4,3,2,1,0} %dynamic-slice.8214) + %multiply.9115 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %reshape.8215, f32[16,32,32,16]{3,2,1,0} %multiply.9114) + %constant.8216 = s32[] constant(0) + %compare.8217 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8216), direction=LT + %constant.8218 = s32[] constant(2) + %add.8219 = s32[] add(s32[] %subtract.7486, s32[] %constant.8218) + %select.8220 = s32[] select(pred[] %compare.8217, s32[] %add.8219, s32[] %subtract.7486) + %constant.8221 = s32[] constant(0) + %constant.8222 = s32[] constant(0) + %compare.8223 = pred[] compare(s32[] %constant.8221, s32[] %constant.8222), direction=LT + %constant.8224 = s32[] constant(0) + %constant.8225 = s32[] constant(16) + %add.8226 = s32[] add(s32[] %constant.8224, s32[] %constant.8225) + %constant.8227 = s32[] constant(0) + %select.8228 = s32[] select(pred[] %compare.8223, s32[] %add.8226, s32[] %constant.8227) + %constant.8229 = s32[] constant(0) + %constant.8230 = s32[] constant(0) + %compare.8231 = pred[] compare(s32[] %constant.8229, s32[] %constant.8230), direction=LT + %constant.8232 = s32[] constant(0) + %constant.8233 = s32[] constant(32) + %add.8234 = s32[] add(s32[] %constant.8232, s32[] %constant.8233) + %constant.8235 = s32[] constant(0) + %select.8236 = s32[] select(pred[] %compare.8231, s32[] %add.8234, s32[] %constant.8235) + %constant.8237 = s32[] constant(0) + %constant.8238 = s32[] constant(0) + %compare.8239 = pred[] compare(s32[] %constant.8237, s32[] %constant.8238), direction=LT + %constant.8240 = s32[] constant(0) + %constant.8241 = s32[] constant(32) + %add.8242 = s32[] add(s32[] %constant.8240, s32[] %constant.8241) + %constant.8243 = s32[] constant(0) + %select.8244 = s32[] select(pred[] %compare.8239, s32[] %add.8242, s32[] %constant.8243) + %constant.8245 = s32[] constant(0) + %constant.8246 = s32[] constant(0) + %compare.8247 = pred[] compare(s32[] %constant.8245, s32[] %constant.8246), direction=LT + %constant.8248 = s32[] constant(0) + %constant.8249 = s32[] constant(16) + %add.8250 = s32[] add(s32[] %constant.8248, s32[] %constant.8249) + %constant.8251 = s32[] constant(0) + %select.8252 = s32[] select(pred[] %compare.8247, s32[] %add.8250, s32[] %constant.8251) + %dynamic-slice.8253 = f32[1,16,32,32,16]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.7440, s32[] %select.8220, s32[] %select.8228, s32[] %select.8236, s32[] %select.8244, /*index=5*/s32[] %select.8252), dynamic_slice_sizes={1,16,32,32,16} + %reshape.8254 = f32[16,32,32,16]{3,2,1,0} reshape(f32[1,16,32,32,16]{4,3,2,1,0} %dynamic-slice.8253) + %multiply.9116 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %multiply.9115, f32[16,32,32,16]{3,2,1,0} %reshape.8254) + %constant.8138 = s32[] constant(0) + %compare.8139 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8138), direction=LT + %constant.8140 = s32[] constant(2) + %add.8141 = s32[] add(s32[] %subtract.7486, s32[] %constant.8140) + %select.8142 = s32[] select(pred[] %compare.8139, s32[] %add.8141, s32[] %subtract.7486) + %constant.8143 = s32[] constant(0) + %constant.8144 = s32[] constant(0) + %compare.8145 = pred[] compare(s32[] %constant.8143, s32[] %constant.8144), direction=LT + %constant.8146 = s32[] constant(0) + %constant.8147 = s32[] constant(16) + %add.8148 = s32[] add(s32[] %constant.8146, s32[] %constant.8147) + %constant.8149 = s32[] constant(0) + %select.8150 = s32[] select(pred[] %compare.8145, s32[] %add.8148, s32[] %constant.8149) + %constant.8151 = s32[] constant(0) + %constant.8152 = s32[] constant(0) + %compare.8153 = pred[] compare(s32[] %constant.8151, s32[] %constant.8152), direction=LT + %constant.8154 = s32[] constant(0) + %constant.8155 = s32[] constant(32) + %add.8156 = s32[] add(s32[] %constant.8154, s32[] %constant.8155) + %constant.8157 = s32[] constant(0) + %select.8158 = s32[] select(pred[] %compare.8153, s32[] %add.8156, s32[] %constant.8157) + %constant.8159 = s32[] constant(0) + %constant.8160 = s32[] constant(0) + %compare.8161 = pred[] compare(s32[] %constant.8159, s32[] %constant.8160), direction=LT + %constant.8162 = s32[] constant(0) + %constant.8163 = s32[] constant(32) + %add.8164 = s32[] add(s32[] %constant.8162, s32[] %constant.8163) + %constant.8165 = s32[] constant(0) + %select.8166 = s32[] select(pred[] %compare.8161, s32[] %add.8164, s32[] %constant.8165) + %constant.8167 = s32[] constant(0) + %constant.8168 = s32[] constant(0) + %compare.8169 = pred[] compare(s32[] %constant.8167, s32[] %constant.8168), direction=LT + %constant.8170 = s32[] constant(0) + %constant.8171 = s32[] constant(16) + %add.8172 = s32[] add(s32[] %constant.8170, s32[] %constant.8171) + %constant.8173 = s32[] constant(0) + %select.8174 = s32[] select(pred[] %compare.8169, s32[] %add.8172, s32[] %constant.8173) + %dynamic-slice.8175 = f32[1,16,32,32,16]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.7438, s32[] %select.8142, s32[] %select.8150, s32[] %select.8158, s32[] %select.8166, /*index=5*/s32[] %select.8174), dynamic_slice_sizes={1,16,32,32,16} + %reshape.8176 = f32[16,32,32,16]{3,2,1,0} reshape(f32[1,16,32,32,16]{4,3,2,1,0} %dynamic-slice.8175) + %multiply.9117 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %multiply.9114, f32[16,32,32,16]{3,2,1,0} %reshape.8176) + %add.9118 = f32[16,32,32,16]{3,2,1,0} add(f32[16,32,32,16]{3,2,1,0} %multiply.9116, f32[16,32,32,16]{3,2,1,0} %multiply.9117) + %constant.8099 = s32[] constant(0) + %compare.8100 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8099), direction=LT + %constant.8101 = s32[] constant(2) + %add.8102 = s32[] add(s32[] %subtract.7486, s32[] %constant.8101) + %select.8103 = s32[] select(pred[] %compare.8100, s32[] %add.8102, s32[] %subtract.7486) + %constant.8104 = s32[] constant(0) + %constant.8105 = s32[] constant(0) + %compare.8106 = pred[] compare(s32[] %constant.8104, s32[] %constant.8105), direction=LT + %constant.8107 = s32[] constant(0) + %constant.8108 = s32[] constant(16) + %add.8109 = s32[] add(s32[] %constant.8107, s32[] %constant.8108) + %constant.8110 = s32[] constant(0) + %select.8111 = s32[] select(pred[] %compare.8106, s32[] %add.8109, s32[] %constant.8110) + %constant.8112 = s32[] constant(0) + %constant.8113 = s32[] constant(0) + %compare.8114 = pred[] compare(s32[] %constant.8112, s32[] %constant.8113), direction=LT + %constant.8115 = s32[] constant(0) + %constant.8116 = s32[] constant(32) + %add.8117 = s32[] add(s32[] %constant.8115, s32[] %constant.8116) + %constant.8118 = s32[] constant(0) + %select.8119 = s32[] select(pred[] %compare.8114, s32[] %add.8117, s32[] %constant.8118) + %constant.8120 = s32[] constant(0) + %constant.8121 = s32[] constant(0) + %compare.8122 = pred[] compare(s32[] %constant.8120, s32[] %constant.8121), direction=LT + %constant.8123 = s32[] constant(0) + %constant.8124 = s32[] constant(32) + %add.8125 = s32[] add(s32[] %constant.8123, s32[] %constant.8124) + %constant.8126 = s32[] constant(0) + %select.8127 = s32[] select(pred[] %compare.8122, s32[] %add.8125, s32[] %constant.8126) + %constant.8128 = s32[] constant(0) + %constant.8129 = s32[] constant(0) + %compare.8130 = pred[] compare(s32[] %constant.8128, s32[] %constant.8129), direction=LT + %constant.8131 = s32[] constant(0) + %constant.8132 = s32[] constant(16) + %add.8133 = s32[] add(s32[] %constant.8131, s32[] %constant.8132) + %constant.8134 = s32[] constant(0) + %select.8135 = s32[] select(pred[] %compare.8130, s32[] %add.8133, s32[] %constant.8134) + %dynamic-slice.8136 = f32[1,16,32,32,16]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.7437, s32[] %select.8103, s32[] %select.8111, s32[] %select.8119, s32[] %select.8127, /*index=5*/s32[] %select.8135), dynamic_slice_sizes={1,16,32,32,16} + %reshape.8137 = f32[16,32,32,16]{3,2,1,0} reshape(f32[1,16,32,32,16]{4,3,2,1,0} %dynamic-slice.8136) + %multiply.9119 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %add.9118, f32[16,32,32,16]{3,2,1,0} %reshape.8137) + %add.9120 = f32[16,32,32,16]{3,2,1,0} add(f32[16,32,32,16]{3,2,1,0} %multiply.9114, f32[16,32,32,16]{3,2,1,0} %multiply.9119) + %constant.8021 = s32[] constant(0) + %compare.8022 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8021), direction=LT + %constant.8023 = s32[] constant(2) + %add.8024 = s32[] add(s32[] %subtract.7486, s32[] %constant.8023) + %select.8025 = s32[] select(pred[] %compare.8022, s32[] %add.8024, s32[] %subtract.7486) + %constant.8026 = s32[] constant(0) + %constant.8027 = s32[] constant(0) + %compare.8028 = pred[] compare(s32[] %constant.8026, s32[] %constant.8027), direction=LT + %constant.8029 = s32[] constant(0) + %constant.8030 = s32[] constant(1) + %add.8031 = s32[] add(s32[] %constant.8029, s32[] %constant.8030) + %constant.8032 = s32[] constant(0) + %select.8033 = s32[] select(pred[] %compare.8028, s32[] %add.8031, s32[] %constant.8032) + %constant.8034 = s32[] constant(0) + %constant.8035 = s32[] constant(0) + %compare.8036 = pred[] compare(s32[] %constant.8034, s32[] %constant.8035), direction=LT + %constant.8037 = s32[] constant(0) + %constant.8038 = s32[] constant(1) + %add.8039 = s32[] add(s32[] %constant.8037, s32[] %constant.8038) + %constant.8040 = s32[] constant(0) + %select.8041 = s32[] select(pred[] %compare.8036, s32[] %add.8039, s32[] %constant.8040) + %constant.8042 = s32[] constant(0) + %constant.8043 = s32[] constant(0) + %compare.8044 = pred[] compare(s32[] %constant.8042, s32[] %constant.8043), direction=LT + %constant.8045 = s32[] constant(0) + %constant.8046 = s32[] constant(1) + %add.8047 = s32[] add(s32[] %constant.8045, s32[] %constant.8046) + %constant.8048 = s32[] constant(0) + %select.8049 = s32[] select(pred[] %compare.8044, s32[] %add.8047, s32[] %constant.8048) + %constant.8050 = s32[] constant(0) + %constant.8051 = s32[] constant(0) + %compare.8052 = pred[] compare(s32[] %constant.8050, s32[] %constant.8051), direction=LT + %constant.8053 = s32[] constant(0) + %constant.8054 = s32[] constant(16) + %add.8055 = s32[] add(s32[] %constant.8053, s32[] %constant.8054) + %constant.8056 = s32[] constant(0) + %select.8057 = s32[] select(pred[] %compare.8052, s32[] %add.8055, s32[] %constant.8056) + %dynamic-slice.8058 = f32[1,1,1,1,16]{4,3,2,1,0} dynamic-slice(f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.7435, s32[] %select.8025, s32[] %select.8033, s32[] %select.8041, s32[] %select.8049, /*index=5*/s32[] %select.8057), dynamic_slice_sizes={1,1,1,1,16} + %reshape.8059 = f32[1,1,1,16]{3,2,1,0} reshape(f32[1,1,1,1,16]{4,3,2,1,0} %dynamic-slice.8058) + %reshape.9136 = f32[16]{0} reshape(f32[1,1,1,16]{3,2,1,0} %reshape.8059) + %broadcast.9137 = f32[16,32,32,16]{3,2,1,0} broadcast(f32[16]{0} %reshape.9136), dimensions={3} + %multiply.9138 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %add.9120, f32[16,32,32,16]{3,2,1,0} %broadcast.9137) + %constant.7811 = s32[] constant(0) + %compare.7812 = pred[] compare(s32[] %subtract.7486, s32[] %constant.7811), direction=LT + %constant.7813 = s32[] constant(2) + %add.7814 = s32[] add(s32[] %subtract.7486, s32[] %constant.7813) + %select.7815 = s32[] select(pred[] %compare.7812, s32[] %add.7814, s32[] %subtract.7486) + %constant.7816 = s32[] constant(0) + %constant.7817 = s32[] constant(0) + %compare.7818 = pred[] compare(s32[] %constant.7816, s32[] %constant.7817), direction=LT + %constant.7819 = s32[] constant(0) + %constant.7820 = s32[] constant(3) + %add.7821 = s32[] add(s32[] %constant.7819, s32[] %constant.7820) + %constant.7822 = s32[] constant(0) + %select.7823 = s32[] select(pred[] %compare.7818, s32[] %add.7821, s32[] %constant.7822) + %constant.7824 = s32[] constant(0) + %constant.7825 = s32[] constant(0) + %compare.7826 = pred[] compare(s32[] %constant.7824, s32[] %constant.7825), direction=LT + %constant.7827 = s32[] constant(0) + %constant.7828 = s32[] constant(3) + %add.7829 = s32[] add(s32[] %constant.7827, s32[] %constant.7828) + %constant.7830 = s32[] constant(0) + %select.7831 = s32[] select(pred[] %compare.7826, s32[] %add.7829, s32[] %constant.7830) + %constant.7832 = s32[] constant(0) + %constant.7833 = s32[] constant(0) + %compare.7834 = pred[] compare(s32[] %constant.7832, s32[] %constant.7833), direction=LT + %constant.7835 = s32[] constant(0) + %constant.7836 = s32[] constant(8) + %add.7837 = s32[] add(s32[] %constant.7835, s32[] %constant.7836) + %constant.7838 = s32[] constant(0) + %select.7839 = s32[] select(pred[] %compare.7834, s32[] %add.7837, s32[] %constant.7838) + %constant.7840 = s32[] constant(0) + %constant.7841 = s32[] constant(0) + %compare.7842 = pred[] compare(s32[] %constant.7840, s32[] %constant.7841), direction=LT + %constant.7843 = s32[] constant(0) + %constant.7844 = s32[] constant(16) + %add.7845 = s32[] add(s32[] %constant.7843, s32[] %constant.7844) + %constant.7846 = s32[] constant(0) + %select.7847 = s32[] select(pred[] %compare.7842, s32[] %add.7845, s32[] %constant.7846) + %dynamic-slice.7848 = f32[1,3,3,8,16]{4,3,2,1,0} dynamic-slice(f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.7429, s32[] %select.7815, s32[] %select.7823, s32[] %select.7831, s32[] %select.7839, /*index=5*/s32[] %select.7847), dynamic_slice_sizes={1,3,3,8,16} + %reshape.7849 = f32[3,3,8,16]{3,2,1,0} reshape(f32[1,3,3,8,16]{4,3,2,1,0} %dynamic-slice.7848) + %reverse.9155 = f32[3,3,8,16]{3,2,1,0} reverse(f32[3,3,8,16]{3,2,1,0} %reshape.7849), dimensions={0,1} + %convolution.9156 = f32[16,32,32,8]{3,2,1,0} convolution(f32[16,32,32,16]{3,2,1,0} %multiply.9138, f32[3,3,8,16]{3,2,1,0} %reverse.9155), window={size=3x3 pad=1_1x1_1}, dim_labels=b01f_01oi->b01f + %constant.9157 = f32[] constant(0.5) + %broadcast.9158 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[] %constant.9157), dimensions={} + %multiply.9159 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %convolution.9156, f32[16,32,32,8]{3,2,1,0} %broadcast.9158) + %add.9160 = f32[16,32,32,8]{3,2,1,0} add(f32[16,32,32,8]{3,2,1,0} %add.9060, f32[16,32,32,8]{3,2,1,0} %multiply.9159) + %constant.7733 = s32[] constant(0) + %compare.7734 = pred[] compare(s32[] %subtract.7486, s32[] %constant.7733), direction=LT + %constant.7735 = s32[] constant(2) + %add.7736 = s32[] add(s32[] %subtract.7486, s32[] %constant.7735) + %select.7737 = s32[] select(pred[] %compare.7734, s32[] %add.7736, s32[] %subtract.7486) + %constant.7738 = s32[] constant(0) + %constant.7739 = s32[] constant(0) + %compare.7740 = pred[] compare(s32[] %constant.7738, s32[] %constant.7739), direction=LT + %constant.7741 = s32[] constant(0) + %constant.7742 = s32[] constant(16) + %add.7743 = s32[] add(s32[] %constant.7741, s32[] %constant.7742) + %constant.7744 = s32[] constant(0) + %select.7745 = s32[] select(pred[] %compare.7740, s32[] %add.7743, s32[] %constant.7744) + %constant.7746 = s32[] constant(0) + %constant.7747 = s32[] constant(0) + %compare.7748 = pred[] compare(s32[] %constant.7746, s32[] %constant.7747), direction=LT + %constant.7749 = s32[] constant(0) + %constant.7750 = s32[] constant(32) + %add.7751 = s32[] add(s32[] %constant.7749, s32[] %constant.7750) + %constant.7752 = s32[] constant(0) + %select.7753 = s32[] select(pred[] %compare.7748, s32[] %add.7751, s32[] %constant.7752) + %constant.7754 = s32[] constant(0) + %constant.7755 = s32[] constant(0) + %compare.7756 = pred[] compare(s32[] %constant.7754, s32[] %constant.7755), direction=LT + %constant.7757 = s32[] constant(0) + %constant.7758 = s32[] constant(32) + %add.7759 = s32[] add(s32[] %constant.7757, s32[] %constant.7758) + %constant.7760 = s32[] constant(0) + %select.7761 = s32[] select(pred[] %compare.7756, s32[] %add.7759, s32[] %constant.7760) + %constant.7762 = s32[] constant(0) + %constant.7763 = s32[] constant(0) + %compare.7764 = pred[] compare(s32[] %constant.7762, s32[] %constant.7763), direction=LT + %constant.7765 = s32[] constant(0) + %constant.7766 = s32[] constant(8) + %add.7767 = s32[] add(s32[] %constant.7765, s32[] %constant.7766) + %constant.7768 = s32[] constant(0) + %select.7769 = s32[] select(pred[] %compare.7764, s32[] %add.7767, s32[] %constant.7768) + %dynamic-slice.7770 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7427, s32[] %select.7737, s32[] %select.7745, s32[] %select.7753, s32[] %select.7761, /*index=5*/s32[] %select.7769), dynamic_slice_sizes={1,16,32,32,8} + %reshape.7771 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.7770) + %multiply.9161 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %reshape.7771, f32[16,32,32,8]{3,2,1,0} %multiply.9159) + %constant.7772 = s32[] constant(0) + %compare.7773 = pred[] compare(s32[] %subtract.7486, s32[] %constant.7772), direction=LT + %constant.7774 = s32[] constant(2) + %add.7775 = s32[] add(s32[] %subtract.7486, s32[] %constant.7774) + %select.7776 = s32[] select(pred[] %compare.7773, s32[] %add.7775, s32[] %subtract.7486) + %constant.7777 = s32[] constant(0) + %constant.7778 = s32[] constant(0) + %compare.7779 = pred[] compare(s32[] %constant.7777, s32[] %constant.7778), direction=LT + %constant.7780 = s32[] constant(0) + %constant.7781 = s32[] constant(16) + %add.7782 = s32[] add(s32[] %constant.7780, s32[] %constant.7781) + %constant.7783 = s32[] constant(0) + %select.7784 = s32[] select(pred[] %compare.7779, s32[] %add.7782, s32[] %constant.7783) + %constant.7785 = s32[] constant(0) + %constant.7786 = s32[] constant(0) + %compare.7787 = pred[] compare(s32[] %constant.7785, s32[] %constant.7786), direction=LT + %constant.7788 = s32[] constant(0) + %constant.7789 = s32[] constant(32) + %add.7790 = s32[] add(s32[] %constant.7788, s32[] %constant.7789) + %constant.7791 = s32[] constant(0) + %select.7792 = s32[] select(pred[] %compare.7787, s32[] %add.7790, s32[] %constant.7791) + %constant.7793 = s32[] constant(0) + %constant.7794 = s32[] constant(0) + %compare.7795 = pred[] compare(s32[] %constant.7793, s32[] %constant.7794), direction=LT + %constant.7796 = s32[] constant(0) + %constant.7797 = s32[] constant(32) + %add.7798 = s32[] add(s32[] %constant.7796, s32[] %constant.7797) + %constant.7799 = s32[] constant(0) + %select.7800 = s32[] select(pred[] %compare.7795, s32[] %add.7798, s32[] %constant.7799) + %constant.7801 = s32[] constant(0) + %constant.7802 = s32[] constant(0) + %compare.7803 = pred[] compare(s32[] %constant.7801, s32[] %constant.7802), direction=LT + %constant.7804 = s32[] constant(0) + %constant.7805 = s32[] constant(8) + %add.7806 = s32[] add(s32[] %constant.7804, s32[] %constant.7805) + %constant.7807 = s32[] constant(0) + %select.7808 = s32[] select(pred[] %compare.7803, s32[] %add.7806, s32[] %constant.7807) + %dynamic-slice.7809 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7428, s32[] %select.7776, s32[] %select.7784, s32[] %select.7792, s32[] %select.7800, /*index=5*/s32[] %select.7808), dynamic_slice_sizes={1,16,32,32,8} + %reshape.7810 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.7809) + %multiply.9162 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %multiply.9161, f32[16,32,32,8]{3,2,1,0} %reshape.7810) + %constant.7694 = s32[] constant(0) + %compare.7695 = pred[] compare(s32[] %subtract.7486, s32[] %constant.7694), direction=LT + %constant.7696 = s32[] constant(2) + %add.7697 = s32[] add(s32[] %subtract.7486, s32[] %constant.7696) + %select.7698 = s32[] select(pred[] %compare.7695, s32[] %add.7697, s32[] %subtract.7486) + %constant.7699 = s32[] constant(0) + %constant.7700 = s32[] constant(0) + %compare.7701 = pred[] compare(s32[] %constant.7699, s32[] %constant.7700), direction=LT + %constant.7702 = s32[] constant(0) + %constant.7703 = s32[] constant(16) + %add.7704 = s32[] add(s32[] %constant.7702, s32[] %constant.7703) + %constant.7705 = s32[] constant(0) + %select.7706 = s32[] select(pred[] %compare.7701, s32[] %add.7704, s32[] %constant.7705) + %constant.7707 = s32[] constant(0) + %constant.7708 = s32[] constant(0) + %compare.7709 = pred[] compare(s32[] %constant.7707, s32[] %constant.7708), direction=LT + %constant.7710 = s32[] constant(0) + %constant.7711 = s32[] constant(32) + %add.7712 = s32[] add(s32[] %constant.7710, s32[] %constant.7711) + %constant.7713 = s32[] constant(0) + %select.7714 = s32[] select(pred[] %compare.7709, s32[] %add.7712, s32[] %constant.7713) + %constant.7715 = s32[] constant(0) + %constant.7716 = s32[] constant(0) + %compare.7717 = pred[] compare(s32[] %constant.7715, s32[] %constant.7716), direction=LT + %constant.7718 = s32[] constant(0) + %constant.7719 = s32[] constant(32) + %add.7720 = s32[] add(s32[] %constant.7718, s32[] %constant.7719) + %constant.7721 = s32[] constant(0) + %select.7722 = s32[] select(pred[] %compare.7717, s32[] %add.7720, s32[] %constant.7721) + %constant.7723 = s32[] constant(0) + %constant.7724 = s32[] constant(0) + %compare.7725 = pred[] compare(s32[] %constant.7723, s32[] %constant.7724), direction=LT + %constant.7726 = s32[] constant(0) + %constant.7727 = s32[] constant(8) + %add.7728 = s32[] add(s32[] %constant.7726, s32[] %constant.7727) + %constant.7729 = s32[] constant(0) + %select.7730 = s32[] select(pred[] %compare.7725, s32[] %add.7728, s32[] %constant.7729) + %dynamic-slice.7731 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7426, s32[] %select.7698, s32[] %select.7706, s32[] %select.7714, s32[] %select.7722, /*index=5*/s32[] %select.7730), dynamic_slice_sizes={1,16,32,32,8} + %reshape.7732 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.7731) + %multiply.9163 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %multiply.9159, f32[16,32,32,8]{3,2,1,0} %reshape.7732) + %add.9164 = f32[16,32,32,8]{3,2,1,0} add(f32[16,32,32,8]{3,2,1,0} %multiply.9162, f32[16,32,32,8]{3,2,1,0} %multiply.9163) + %constant.7655 = s32[] constant(0) + %compare.7656 = pred[] compare(s32[] %subtract.7486, s32[] %constant.7655), direction=LT + %constant.7657 = s32[] constant(2) + %add.7658 = s32[] add(s32[] %subtract.7486, s32[] %constant.7657) + %select.7659 = s32[] select(pred[] %compare.7656, s32[] %add.7658, s32[] %subtract.7486) + %constant.7660 = s32[] constant(0) + %constant.7661 = s32[] constant(0) + %compare.7662 = pred[] compare(s32[] %constant.7660, s32[] %constant.7661), direction=LT + %constant.7663 = s32[] constant(0) + %constant.7664 = s32[] constant(16) + %add.7665 = s32[] add(s32[] %constant.7663, s32[] %constant.7664) + %constant.7666 = s32[] constant(0) + %select.7667 = s32[] select(pred[] %compare.7662, s32[] %add.7665, s32[] %constant.7666) + %constant.7668 = s32[] constant(0) + %constant.7669 = s32[] constant(0) + %compare.7670 = pred[] compare(s32[] %constant.7668, s32[] %constant.7669), direction=LT + %constant.7671 = s32[] constant(0) + %constant.7672 = s32[] constant(32) + %add.7673 = s32[] add(s32[] %constant.7671, s32[] %constant.7672) + %constant.7674 = s32[] constant(0) + %select.7675 = s32[] select(pred[] %compare.7670, s32[] %add.7673, s32[] %constant.7674) + %constant.7676 = s32[] constant(0) + %constant.7677 = s32[] constant(0) + %compare.7678 = pred[] compare(s32[] %constant.7676, s32[] %constant.7677), direction=LT + %constant.7679 = s32[] constant(0) + %constant.7680 = s32[] constant(32) + %add.7681 = s32[] add(s32[] %constant.7679, s32[] %constant.7680) + %constant.7682 = s32[] constant(0) + %select.7683 = s32[] select(pred[] %compare.7678, s32[] %add.7681, s32[] %constant.7682) + %constant.7684 = s32[] constant(0) + %constant.7685 = s32[] constant(0) + %compare.7686 = pred[] compare(s32[] %constant.7684, s32[] %constant.7685), direction=LT + %constant.7687 = s32[] constant(0) + %constant.7688 = s32[] constant(8) + %add.7689 = s32[] add(s32[] %constant.7687, s32[] %constant.7688) + %constant.7690 = s32[] constant(0) + %select.7691 = s32[] select(pred[] %compare.7686, s32[] %add.7689, s32[] %constant.7690) + %dynamic-slice.7692 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7425, s32[] %select.7659, s32[] %select.7667, s32[] %select.7675, s32[] %select.7683, /*index=5*/s32[] %select.7691), dynamic_slice_sizes={1,16,32,32,8} + %reshape.7693 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.7692) + %multiply.9165 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %add.9164, f32[16,32,32,8]{3,2,1,0} %reshape.7693) + %add.9166 = f32[16,32,32,8]{3,2,1,0} add(f32[16,32,32,8]{3,2,1,0} %add.9160, f32[16,32,32,8]{3,2,1,0} %multiply.9165) + %constant.9338 = pred[] constant(false) + %constant.9339 = pred[] constant(false) + %constant.9340 = pred[] constant(false) + %constant.9341 = pred[] constant(false) + %constant.9342 = pred[] constant(false) + %constant.9343 = pred[] constant(false) + %constant.9344 = pred[] constant(false) + %constant.9345 = pred[] constant(false) + %constant.9346 = pred[] constant(false) + %get-tuple-element.7474 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=57 + %constant.7487 = s32[] constant(0) + %compare.7488 = pred[] compare(s32[] %subtract.7486, s32[] %constant.7487), direction=LT + %constant.7489 = s32[] constant(2) + %add.7490 = s32[] add(s32[] %subtract.7486, s32[] %constant.7489) + %select.7491 = s32[] select(pred[] %compare.7488, s32[] %add.7490, s32[] %subtract.7486) + %constant.7492 = s32[] constant(0) + %constant.7493 = s32[] constant(0) + %compare.7494 = pred[] compare(s32[] %constant.7492, s32[] %constant.7493), direction=LT + %constant.7495 = s32[] constant(0) + %constant.7496 = s32[] constant(16) + %add.7497 = s32[] add(s32[] %constant.7495, s32[] %constant.7496) + %constant.7498 = s32[] constant(0) + %select.7499 = s32[] select(pred[] %compare.7494, s32[] %add.7497, s32[] %constant.7498) + %dynamic-slice.7500 = f32[1,16]{1,0} dynamic-slice(f32[2,16]{1,0} %get-tuple-element.7417, s32[] %select.7491, s32[] %select.7499), dynamic_slice_sizes={1,16} + %reshape.7501 = f32[16]{0} reshape(f32[1,16]{1,0} %dynamic-slice.7500) + %constant.9121 = f32[] constant(0) + %reduce.9122 = f32[16]{0} reduce(f32[16,32,32,16]{3,2,1,0} %add.9120, f32[] %constant.9121), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7391 + %reshape.9123 = f32[1,1,1,16]{3,2,1,0} reshape(f32[16]{0} %reduce.9122) + %constant.9124 = f32[] constant(0) + %reduce.9125 = f32[16]{0} reduce(f32[1,1,1,16]{3,2,1,0} %reshape.9123, f32[] %constant.9124), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7395 + %broadcast.9126 = f32[16]{0} broadcast(f32[16]{0} %reduce.9125), dimensions={0} + %add.9127 = f32[16]{0} add(f32[16]{0} %reshape.7501, f32[16]{0} %broadcast.9126) + %broadcast.9167 = f32[1,16]{1,0} broadcast(f32[16]{0} %add.9127), dimensions={1} + %constant.9168 = s32[] constant(0) + %compare.9169 = pred[] compare(s32[] %subtract.7486, s32[] %constant.9168), direction=LT + %constant.9170 = s32[] constant(2) + %add.9171 = s32[] add(s32[] %subtract.7486, s32[] %constant.9170) + %select.9172 = s32[] select(pred[] %compare.9169, s32[] %add.9171, s32[] %subtract.7486) + %constant.9173 = s32[] constant(0) + %constant.9174 = s32[] constant(0) + %compare.9175 = pred[] compare(s32[] %constant.9173, s32[] %constant.9174), direction=LT + %constant.9176 = s32[] constant(0) + %constant.9177 = s32[] constant(16) + %add.9178 = s32[] add(s32[] %constant.9176, s32[] %constant.9177) + %constant.9179 = s32[] constant(0) + %select.9180 = s32[] select(pred[] %compare.9175, s32[] %add.9178, s32[] %constant.9179) + %dynamic-update-slice.9181 = f32[2,16]{1,0} dynamic-update-slice(f32[2,16]{1,0} %get-tuple-element.7474, f32[1,16]{1,0} %broadcast.9167, s32[] %select.9172, s32[] %select.9180) + %get-tuple-element.7475 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=58 + %constant.7502 = s32[] constant(0) + %compare.7503 = pred[] compare(s32[] %subtract.7486, s32[] %constant.7502), direction=LT + %constant.7504 = s32[] constant(2) + %add.7505 = s32[] add(s32[] %subtract.7486, s32[] %constant.7504) + %select.7506 = s32[] select(pred[] %compare.7503, s32[] %add.7505, s32[] %subtract.7486) + %constant.7507 = s32[] constant(0) + %constant.7508 = s32[] constant(0) + %compare.7509 = pred[] compare(s32[] %constant.7507, s32[] %constant.7508), direction=LT + %constant.7510 = s32[] constant(0) + %constant.7511 = s32[] constant(16) + %add.7512 = s32[] add(s32[] %constant.7510, s32[] %constant.7511) + %constant.7513 = s32[] constant(0) + %select.7514 = s32[] select(pred[] %compare.7509, s32[] %add.7512, s32[] %constant.7513) + %dynamic-slice.7515 = f32[1,16]{1,0} dynamic-slice(f32[2,16]{1,0} %get-tuple-element.7418, s32[] %select.7506, s32[] %select.7514), dynamic_slice_sizes={1,16} + %reshape.7516 = f32[16]{0} reshape(f32[1,16]{1,0} %dynamic-slice.7515) + %constant.8060 = s32[] constant(0) + %compare.8061 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8060), direction=LT + %constant.8062 = s32[] constant(2) + %add.8063 = s32[] add(s32[] %subtract.7486, s32[] %constant.8062) + %select.8064 = s32[] select(pred[] %compare.8061, s32[] %add.8063, s32[] %subtract.7486) + %constant.8065 = s32[] constant(0) + %constant.8066 = s32[] constant(0) + %compare.8067 = pred[] compare(s32[] %constant.8065, s32[] %constant.8066), direction=LT + %constant.8068 = s32[] constant(0) + %constant.8069 = s32[] constant(16) + %add.8070 = s32[] add(s32[] %constant.8068, s32[] %constant.8069) + %constant.8071 = s32[] constant(0) + %select.8072 = s32[] select(pred[] %compare.8067, s32[] %add.8070, s32[] %constant.8071) + %constant.8073 = s32[] constant(0) + %constant.8074 = s32[] constant(0) + %compare.8075 = pred[] compare(s32[] %constant.8073, s32[] %constant.8074), direction=LT + %constant.8076 = s32[] constant(0) + %constant.8077 = s32[] constant(32) + %add.8078 = s32[] add(s32[] %constant.8076, s32[] %constant.8077) + %constant.8079 = s32[] constant(0) + %select.8080 = s32[] select(pred[] %compare.8075, s32[] %add.8078, s32[] %constant.8079) + %constant.8081 = s32[] constant(0) + %constant.8082 = s32[] constant(0) + %compare.8083 = pred[] compare(s32[] %constant.8081, s32[] %constant.8082), direction=LT + %constant.8084 = s32[] constant(0) + %constant.8085 = s32[] constant(32) + %add.8086 = s32[] add(s32[] %constant.8084, s32[] %constant.8085) + %constant.8087 = s32[] constant(0) + %select.8088 = s32[] select(pred[] %compare.8083, s32[] %add.8086, s32[] %constant.8087) + %constant.8089 = s32[] constant(0) + %constant.8090 = s32[] constant(0) + %compare.8091 = pred[] compare(s32[] %constant.8089, s32[] %constant.8090), direction=LT + %constant.8092 = s32[] constant(0) + %constant.8093 = s32[] constant(16) + %add.8094 = s32[] add(s32[] %constant.8092, s32[] %constant.8093) + %constant.8095 = s32[] constant(0) + %select.8096 = s32[] select(pred[] %compare.8091, s32[] %add.8094, s32[] %constant.8095) + %dynamic-slice.8097 = f32[1,16,32,32,16]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.7436, s32[] %select.8064, s32[] %select.8072, s32[] %select.8080, s32[] %select.8088, /*index=5*/s32[] %select.8096), dynamic_slice_sizes={1,16,32,32,16} + %reshape.8098 = f32[16,32,32,16]{3,2,1,0} reshape(f32[1,16,32,32,16]{4,3,2,1,0} %dynamic-slice.8097) + %multiply.9128 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %reshape.8098, f32[16,32,32,16]{3,2,1,0} %add.9120) + %constant.9129 = f32[] constant(0) + %reduce.9130 = f32[16]{0} reduce(f32[16,32,32,16]{3,2,1,0} %multiply.9128, f32[] %constant.9129), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7399 + %reshape.9131 = f32[1,1,1,16]{3,2,1,0} reshape(f32[16]{0} %reduce.9130) + %constant.9132 = f32[] constant(0) + %reduce.9133 = f32[16]{0} reduce(f32[1,1,1,16]{3,2,1,0} %reshape.9131, f32[] %constant.9132), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7403 + %broadcast.9134 = f32[16]{0} broadcast(f32[16]{0} %reduce.9133), dimensions={0} + %add.9135 = f32[16]{0} add(f32[16]{0} %reshape.7516, f32[16]{0} %broadcast.9134) + %broadcast.9182 = f32[1,16]{1,0} broadcast(f32[16]{0} %add.9135), dimensions={1} + %constant.9183 = s32[] constant(0) + %compare.9184 = pred[] compare(s32[] %subtract.7486, s32[] %constant.9183), direction=LT + %constant.9185 = s32[] constant(2) + %add.9186 = s32[] add(s32[] %subtract.7486, s32[] %constant.9185) + %select.9187 = s32[] select(pred[] %compare.9184, s32[] %add.9186, s32[] %subtract.7486) + %constant.9188 = s32[] constant(0) + %constant.9189 = s32[] constant(0) + %compare.9190 = pred[] compare(s32[] %constant.9188, s32[] %constant.9189), direction=LT + %constant.9191 = s32[] constant(0) + %constant.9192 = s32[] constant(16) + %add.9193 = s32[] add(s32[] %constant.9191, s32[] %constant.9192) + %constant.9194 = s32[] constant(0) + %select.9195 = s32[] select(pred[] %compare.9190, s32[] %add.9193, s32[] %constant.9194) + %dynamic-update-slice.9196 = f32[2,16]{1,0} dynamic-update-slice(f32[2,16]{1,0} %get-tuple-element.7475, f32[1,16]{1,0} %broadcast.9182, s32[] %select.9187, s32[] %select.9195) + %get-tuple-element.7476 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=59 + %constant.7517 = s32[] constant(0) + %compare.7518 = pred[] compare(s32[] %subtract.7486, s32[] %constant.7517), direction=LT + %constant.7519 = s32[] constant(2) + %add.7520 = s32[] add(s32[] %subtract.7486, s32[] %constant.7519) + %select.7521 = s32[] select(pred[] %compare.7518, s32[] %add.7520, s32[] %subtract.7486) + %constant.7522 = s32[] constant(0) + %constant.7523 = s32[] constant(0) + %compare.7524 = pred[] compare(s32[] %constant.7522, s32[] %constant.7523), direction=LT + %constant.7525 = s32[] constant(0) + %constant.7526 = s32[] constant(3) + %add.7527 = s32[] add(s32[] %constant.7525, s32[] %constant.7526) + %constant.7528 = s32[] constant(0) + %select.7529 = s32[] select(pred[] %compare.7524, s32[] %add.7527, s32[] %constant.7528) + %constant.7530 = s32[] constant(0) + %constant.7531 = s32[] constant(0) + %compare.7532 = pred[] compare(s32[] %constant.7530, s32[] %constant.7531), direction=LT + %constant.7533 = s32[] constant(0) + %constant.7534 = s32[] constant(3) + %add.7535 = s32[] add(s32[] %constant.7533, s32[] %constant.7534) + %constant.7536 = s32[] constant(0) + %select.7537 = s32[] select(pred[] %compare.7532, s32[] %add.7535, s32[] %constant.7536) + %constant.7538 = s32[] constant(0) + %constant.7539 = s32[] constant(0) + %compare.7540 = pred[] compare(s32[] %constant.7538, s32[] %constant.7539), direction=LT + %constant.7541 = s32[] constant(0) + %constant.7542 = s32[] constant(8) + %add.7543 = s32[] add(s32[] %constant.7541, s32[] %constant.7542) + %constant.7544 = s32[] constant(0) + %select.7545 = s32[] select(pred[] %compare.7540, s32[] %add.7543, s32[] %constant.7544) + %constant.7546 = s32[] constant(0) + %constant.7547 = s32[] constant(0) + %compare.7548 = pred[] compare(s32[] %constant.7546, s32[] %constant.7547), direction=LT + %constant.7549 = s32[] constant(0) + %constant.7550 = s32[] constant(16) + %add.7551 = s32[] add(s32[] %constant.7549, s32[] %constant.7550) + %constant.7552 = s32[] constant(0) + %select.7553 = s32[] select(pred[] %compare.7548, s32[] %add.7551, s32[] %constant.7552) + %dynamic-slice.7554 = f32[1,3,3,8,16]{4,3,2,1,0} dynamic-slice(f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.7419, s32[] %select.7521, s32[] %select.7529, s32[] %select.7537, s32[] %select.7545, /*index=5*/s32[] %select.7553), dynamic_slice_sizes={1,3,3,8,16} + %reshape.7555 = f32[3,3,8,16]{3,2,1,0} reshape(f32[1,3,3,8,16]{4,3,2,1,0} %dynamic-slice.7554) + %constant.7928 = s32[] constant(0) + %compare.7929 = pred[] compare(s32[] %subtract.7486, s32[] %constant.7928), direction=LT + %constant.7930 = s32[] constant(2) + %add.7931 = s32[] add(s32[] %subtract.7486, s32[] %constant.7930) + %select.7932 = s32[] select(pred[] %compare.7929, s32[] %add.7931, s32[] %subtract.7486) + %constant.7933 = s32[] constant(0) + %constant.7934 = s32[] constant(0) + %compare.7935 = pred[] compare(s32[] %constant.7933, s32[] %constant.7934), direction=LT + %constant.7936 = s32[] constant(0) + %constant.7937 = s32[] constant(3) + %add.7938 = s32[] add(s32[] %constant.7936, s32[] %constant.7937) + %constant.7939 = s32[] constant(0) + %select.7940 = s32[] select(pred[] %compare.7935, s32[] %add.7938, s32[] %constant.7939) + %constant.7941 = s32[] constant(0) + %constant.7942 = s32[] constant(0) + %compare.7943 = pred[] compare(s32[] %constant.7941, s32[] %constant.7942), direction=LT + %constant.7944 = s32[] constant(0) + %constant.7945 = s32[] constant(3) + %add.7946 = s32[] add(s32[] %constant.7944, s32[] %constant.7945) + %constant.7947 = s32[] constant(0) + %select.7948 = s32[] select(pred[] %compare.7943, s32[] %add.7946, s32[] %constant.7947) + %constant.7949 = s32[] constant(0) + %constant.7950 = s32[] constant(0) + %compare.7951 = pred[] compare(s32[] %constant.7949, s32[] %constant.7950), direction=LT + %constant.7952 = s32[] constant(0) + %constant.7953 = s32[] constant(8) + %add.7954 = s32[] add(s32[] %constant.7952, s32[] %constant.7953) + %constant.7955 = s32[] constant(0) + %select.7956 = s32[] select(pred[] %compare.7951, s32[] %add.7954, s32[] %constant.7955) + %constant.7957 = s32[] constant(0) + %constant.7958 = s32[] constant(0) + %compare.7959 = pred[] compare(s32[] %constant.7957, s32[] %constant.7958), direction=LT + %constant.7960 = s32[] constant(0) + %constant.7961 = s32[] constant(16) + %add.7962 = s32[] add(s32[] %constant.7960, s32[] %constant.7961) + %constant.7963 = s32[] constant(0) + %select.7964 = s32[] select(pred[] %compare.7959, s32[] %add.7962, s32[] %constant.7963) + %dynamic-slice.7965 = f32[1,3,3,8,16]{4,3,2,1,0} dynamic-slice(f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.7432, s32[] %select.7932, s32[] %select.7940, s32[] %select.7948, s32[] %select.7956, /*index=5*/s32[] %select.7964), dynamic_slice_sizes={1,3,3,8,16} + %reshape.7966 = f32[3,3,8,16]{3,2,1,0} reshape(f32[1,3,3,8,16]{4,3,2,1,0} %dynamic-slice.7965) + %constant.7850 = s32[] constant(0) + %compare.7851 = pred[] compare(s32[] %subtract.7486, s32[] %constant.7850), direction=LT + %constant.7852 = s32[] constant(2) + %add.7853 = s32[] add(s32[] %subtract.7486, s32[] %constant.7852) + %select.7854 = s32[] select(pred[] %compare.7851, s32[] %add.7853, s32[] %subtract.7486) + %constant.7855 = s32[] constant(0) + %constant.7856 = s32[] constant(0) + %compare.7857 = pred[] compare(s32[] %constant.7855, s32[] %constant.7856), direction=LT + %constant.7858 = s32[] constant(0) + %constant.7859 = s32[] constant(16) + %add.7860 = s32[] add(s32[] %constant.7858, s32[] %constant.7859) + %constant.7861 = s32[] constant(0) + %select.7862 = s32[] select(pred[] %compare.7857, s32[] %add.7860, s32[] %constant.7861) + %constant.7863 = s32[] constant(0) + %constant.7864 = s32[] constant(0) + %compare.7865 = pred[] compare(s32[] %constant.7863, s32[] %constant.7864), direction=LT + %constant.7866 = s32[] constant(0) + %constant.7867 = s32[] constant(32) + %add.7868 = s32[] add(s32[] %constant.7866, s32[] %constant.7867) + %constant.7869 = s32[] constant(0) + %select.7870 = s32[] select(pred[] %compare.7865, s32[] %add.7868, s32[] %constant.7869) + %constant.7871 = s32[] constant(0) + %constant.7872 = s32[] constant(0) + %compare.7873 = pred[] compare(s32[] %constant.7871, s32[] %constant.7872), direction=LT + %constant.7874 = s32[] constant(0) + %constant.7875 = s32[] constant(32) + %add.7876 = s32[] add(s32[] %constant.7874, s32[] %constant.7875) + %constant.7877 = s32[] constant(0) + %select.7878 = s32[] select(pred[] %compare.7873, s32[] %add.7876, s32[] %constant.7877) + %constant.7879 = s32[] constant(0) + %constant.7880 = s32[] constant(0) + %compare.7881 = pred[] compare(s32[] %constant.7879, s32[] %constant.7880), direction=LT + %constant.7882 = s32[] constant(0) + %constant.7883 = s32[] constant(8) + %add.7884 = s32[] add(s32[] %constant.7882, s32[] %constant.7883) + %constant.7885 = s32[] constant(0) + %select.7886 = s32[] select(pred[] %compare.7881, s32[] %add.7884, s32[] %constant.7885) + %dynamic-slice.7887 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7430, s32[] %select.7854, s32[] %select.7862, s32[] %select.7870, s32[] %select.7878, /*index=5*/s32[] %select.7886), dynamic_slice_sizes={1,16,32,32,8} + %reshape.7888 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.7887) + %convolution.9139 = f32[3,3,8,16]{3,2,1,0} convolution(f32[16,32,32,8]{3,2,1,0} %reshape.7888, f32[16,32,32,16]{3,2,1,0} %multiply.9138), window={size=32x32 pad=1_1x1_1}, dim_labels=f01b_i01o->01bf + %multiply.9140 = f32[3,3,8,16]{3,2,1,0} multiply(f32[3,3,8,16]{3,2,1,0} %reshape.7966, f32[3,3,8,16]{3,2,1,0} %convolution.9139) + %constant.9141 = f32[] constant(0) + %reduce.9142 = f32[16]{0} reduce(f32[3,3,8,16]{3,2,1,0} %multiply.9140, f32[] %constant.9141), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7407 + %reshape.9143 = f32[1,1,1,16]{3,2,1,0} reshape(f32[16]{0} %reduce.9142) + %constant.9144 = f32[] constant(0) + %reduce.9145 = f32[16]{0} reduce(f32[1,1,1,16]{3,2,1,0} %reshape.9143, f32[] %constant.9144), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7411 + %broadcast.9146 = f32[16]{0} broadcast(f32[16]{0} %reduce.9145), dimensions={0} + %constant.8006 = s32[] constant(0) + %compare.8007 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8006), direction=LT + %constant.8008 = s32[] constant(2) + %add.8009 = s32[] add(s32[] %subtract.7486, s32[] %constant.8008) + %select.8010 = s32[] select(pred[] %compare.8007, s32[] %add.8009, s32[] %subtract.7486) + %constant.8011 = s32[] constant(0) + %constant.8012 = s32[] constant(0) + %compare.8013 = pred[] compare(s32[] %constant.8011, s32[] %constant.8012), direction=LT + %constant.8014 = s32[] constant(0) + %constant.8015 = s32[] constant(16) + %add.8016 = s32[] add(s32[] %constant.8014, s32[] %constant.8015) + %constant.8017 = s32[] constant(0) + %select.8018 = s32[] select(pred[] %compare.8013, s32[] %add.8016, s32[] %constant.8017) + %dynamic-slice.8019 = f32[1,16]{1,0} dynamic-slice(f32[2,16]{1,0} %get-tuple-element.7434, s32[] %select.8010, s32[] %select.8018), dynamic_slice_sizes={1,16} + %reshape.8020 = f32[16]{0} reshape(f32[1,16]{1,0} %dynamic-slice.8019) + %multiply.9147 = f32[16]{0} multiply(f32[16]{0} %broadcast.9146, f32[16]{0} %reshape.8020) + %broadcast.9148 = f32[3,3,8,16]{3,2,1,0} broadcast(f32[16]{0} %multiply.9147), dimensions={3} + %constant.7967 = s32[] constant(0) + %compare.7968 = pred[] compare(s32[] %subtract.7486, s32[] %constant.7967), direction=LT + %constant.7969 = s32[] constant(2) + %add.7970 = s32[] add(s32[] %subtract.7486, s32[] %constant.7969) + %select.7971 = s32[] select(pred[] %compare.7968, s32[] %add.7970, s32[] %subtract.7486) + %constant.7972 = s32[] constant(0) + %constant.7973 = s32[] constant(0) + %compare.7974 = pred[] compare(s32[] %constant.7972, s32[] %constant.7973), direction=LT + %constant.7975 = s32[] constant(0) + %constant.7976 = s32[] constant(3) + %add.7977 = s32[] add(s32[] %constant.7975, s32[] %constant.7976) + %constant.7978 = s32[] constant(0) + %select.7979 = s32[] select(pred[] %compare.7974, s32[] %add.7977, s32[] %constant.7978) + %constant.7980 = s32[] constant(0) + %constant.7981 = s32[] constant(0) + %compare.7982 = pred[] compare(s32[] %constant.7980, s32[] %constant.7981), direction=LT + %constant.7983 = s32[] constant(0) + %constant.7984 = s32[] constant(3) + %add.7985 = s32[] add(s32[] %constant.7983, s32[] %constant.7984) + %constant.7986 = s32[] constant(0) + %select.7987 = s32[] select(pred[] %compare.7982, s32[] %add.7985, s32[] %constant.7986) + %constant.7988 = s32[] constant(0) + %constant.7989 = s32[] constant(0) + %compare.7990 = pred[] compare(s32[] %constant.7988, s32[] %constant.7989), direction=LT + %constant.7991 = s32[] constant(0) + %constant.7992 = s32[] constant(8) + %add.7993 = s32[] add(s32[] %constant.7991, s32[] %constant.7992) + %constant.7994 = s32[] constant(0) + %select.7995 = s32[] select(pred[] %compare.7990, s32[] %add.7993, s32[] %constant.7994) + %constant.7996 = s32[] constant(0) + %constant.7997 = s32[] constant(0) + %compare.7998 = pred[] compare(s32[] %constant.7996, s32[] %constant.7997), direction=LT + %constant.7999 = s32[] constant(0) + %constant.8000 = s32[] constant(16) + %add.8001 = s32[] add(s32[] %constant.7999, s32[] %constant.8000) + %constant.8002 = s32[] constant(0) + %select.8003 = s32[] select(pred[] %compare.7998, s32[] %add.8001, s32[] %constant.8002) + %dynamic-slice.8004 = f32[1,3,3,8,16]{4,3,2,1,0} dynamic-slice(f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.7433, s32[] %select.7971, s32[] %select.7979, s32[] %select.7987, s32[] %select.7995, /*index=5*/s32[] %select.8003), dynamic_slice_sizes={1,3,3,8,16} + %reshape.8005 = f32[3,3,8,16]{3,2,1,0} reshape(f32[1,3,3,8,16]{4,3,2,1,0} %dynamic-slice.8004) + %multiply.9149 = f32[3,3,8,16]{3,2,1,0} multiply(f32[3,3,8,16]{3,2,1,0} %broadcast.9148, f32[3,3,8,16]{3,2,1,0} %reshape.8005) + %add.9150 = f32[3,3,8,16]{3,2,1,0} add(f32[3,3,8,16]{3,2,1,0} %reshape.7555, f32[3,3,8,16]{3,2,1,0} %multiply.9149) + %constant.7889 = s32[] constant(0) + %compare.7890 = pred[] compare(s32[] %subtract.7486, s32[] %constant.7889), direction=LT + %constant.7891 = s32[] constant(2) + %add.7892 = s32[] add(s32[] %subtract.7486, s32[] %constant.7891) + %select.7893 = s32[] select(pred[] %compare.7890, s32[] %add.7892, s32[] %subtract.7486) + %constant.7894 = s32[] constant(0) + %constant.7895 = s32[] constant(0) + %compare.7896 = pred[] compare(s32[] %constant.7894, s32[] %constant.7895), direction=LT + %constant.7897 = s32[] constant(0) + %constant.7898 = s32[] constant(1) + %add.7899 = s32[] add(s32[] %constant.7897, s32[] %constant.7898) + %constant.7900 = s32[] constant(0) + %select.7901 = s32[] select(pred[] %compare.7896, s32[] %add.7899, s32[] %constant.7900) + %constant.7902 = s32[] constant(0) + %constant.7903 = s32[] constant(0) + %compare.7904 = pred[] compare(s32[] %constant.7902, s32[] %constant.7903), direction=LT + %constant.7905 = s32[] constant(0) + %constant.7906 = s32[] constant(1) + %add.7907 = s32[] add(s32[] %constant.7905, s32[] %constant.7906) + %constant.7908 = s32[] constant(0) + %select.7909 = s32[] select(pred[] %compare.7904, s32[] %add.7907, s32[] %constant.7908) + %constant.7910 = s32[] constant(0) + %constant.7911 = s32[] constant(0) + %compare.7912 = pred[] compare(s32[] %constant.7910, s32[] %constant.7911), direction=LT + %constant.7913 = s32[] constant(0) + %constant.7914 = s32[] constant(1) + %add.7915 = s32[] add(s32[] %constant.7913, s32[] %constant.7914) + %constant.7916 = s32[] constant(0) + %select.7917 = s32[] select(pred[] %compare.7912, s32[] %add.7915, s32[] %constant.7916) + %constant.7918 = s32[] constant(0) + %constant.7919 = s32[] constant(0) + %compare.7920 = pred[] compare(s32[] %constant.7918, s32[] %constant.7919), direction=LT + %constant.7921 = s32[] constant(0) + %constant.7922 = s32[] constant(16) + %add.7923 = s32[] add(s32[] %constant.7921, s32[] %constant.7922) + %constant.7924 = s32[] constant(0) + %select.7925 = s32[] select(pred[] %compare.7920, s32[] %add.7923, s32[] %constant.7924) + %dynamic-slice.7926 = f32[1,1,1,1,16]{4,3,2,1,0} dynamic-slice(f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.7431, s32[] %select.7893, s32[] %select.7901, s32[] %select.7909, s32[] %select.7917, /*index=5*/s32[] %select.7925), dynamic_slice_sizes={1,1,1,1,16} + %reshape.7927 = f32[1,1,1,16]{3,2,1,0} reshape(f32[1,1,1,1,16]{4,3,2,1,0} %dynamic-slice.7926) + %reshape.9151 = f32[16]{0} reshape(f32[1,1,1,16]{3,2,1,0} %reshape.7927) + %broadcast.9152 = f32[3,3,8,16]{3,2,1,0} broadcast(f32[16]{0} %reshape.9151), dimensions={3} + %multiply.9153 = f32[3,3,8,16]{3,2,1,0} multiply(f32[3,3,8,16]{3,2,1,0} %convolution.9139, f32[3,3,8,16]{3,2,1,0} %broadcast.9152) + %add.9154 = f32[3,3,8,16]{3,2,1,0} add(f32[3,3,8,16]{3,2,1,0} %add.9150, f32[3,3,8,16]{3,2,1,0} %multiply.9153) + %broadcast.9197 = f32[1,3,3,8,16]{4,3,2,1,0} broadcast(f32[3,3,8,16]{3,2,1,0} %add.9154), dimensions={1,2,3,4} + %constant.9198 = s32[] constant(0) + %compare.9199 = pred[] compare(s32[] %subtract.7486, s32[] %constant.9198), direction=LT + %constant.9200 = s32[] constant(2) + %add.9201 = s32[] add(s32[] %subtract.7486, s32[] %constant.9200) + %select.9202 = s32[] select(pred[] %compare.9199, s32[] %add.9201, s32[] %subtract.7486) + %constant.9203 = s32[] constant(0) + %constant.9204 = s32[] constant(0) + %compare.9205 = pred[] compare(s32[] %constant.9203, s32[] %constant.9204), direction=LT + %constant.9206 = s32[] constant(0) + %constant.9207 = s32[] constant(3) + %add.9208 = s32[] add(s32[] %constant.9206, s32[] %constant.9207) + %constant.9209 = s32[] constant(0) + %select.9210 = s32[] select(pred[] %compare.9205, s32[] %add.9208, s32[] %constant.9209) + %constant.9211 = s32[] constant(0) + %constant.9212 = s32[] constant(0) + %compare.9213 = pred[] compare(s32[] %constant.9211, s32[] %constant.9212), direction=LT + %constant.9214 = s32[] constant(0) + %constant.9215 = s32[] constant(3) + %add.9216 = s32[] add(s32[] %constant.9214, s32[] %constant.9215) + %constant.9217 = s32[] constant(0) + %select.9218 = s32[] select(pred[] %compare.9213, s32[] %add.9216, s32[] %constant.9217) + %constant.9219 = s32[] constant(0) + %constant.9220 = s32[] constant(0) + %compare.9221 = pred[] compare(s32[] %constant.9219, s32[] %constant.9220), direction=LT + %constant.9222 = s32[] constant(0) + %constant.9223 = s32[] constant(8) + %add.9224 = s32[] add(s32[] %constant.9222, s32[] %constant.9223) + %constant.9225 = s32[] constant(0) + %select.9226 = s32[] select(pred[] %compare.9221, s32[] %add.9224, s32[] %constant.9225) + %constant.9227 = s32[] constant(0) + %constant.9228 = s32[] constant(0) + %compare.9229 = pred[] compare(s32[] %constant.9227, s32[] %constant.9228), direction=LT + %constant.9230 = s32[] constant(0) + %constant.9231 = s32[] constant(16) + %add.9232 = s32[] add(s32[] %constant.9230, s32[] %constant.9231) + %constant.9233 = s32[] constant(0) + %select.9234 = s32[] select(pred[] %compare.9229, s32[] %add.9232, s32[] %constant.9233) + %dynamic-update-slice.9235 = f32[2,3,3,8,16]{4,3,2,1,0} dynamic-update-slice(f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.7476, f32[1,3,3,8,16]{4,3,2,1,0} %broadcast.9197, s32[] %select.9202, s32[] %select.9210, s32[] %select.9218, /*index=5*/s32[] %select.9226, s32[] %select.9234) + %get-tuple-element.7477 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=60 + %constant.7556 = s32[] constant(0) + %compare.7557 = pred[] compare(s32[] %subtract.7486, s32[] %constant.7556), direction=LT + %constant.7558 = s32[] constant(2) + %add.7559 = s32[] add(s32[] %subtract.7486, s32[] %constant.7558) + %select.7560 = s32[] select(pred[] %compare.7557, s32[] %add.7559, s32[] %subtract.7486) + %constant.7561 = s32[] constant(0) + %constant.7562 = s32[] constant(0) + %compare.7563 = pred[] compare(s32[] %constant.7561, s32[] %constant.7562), direction=LT + %constant.7564 = s32[] constant(0) + %constant.7565 = s32[] constant(16) + %add.7566 = s32[] add(s32[] %constant.7564, s32[] %constant.7565) + %constant.7567 = s32[] constant(0) + %select.7568 = s32[] select(pred[] %compare.7563, s32[] %add.7566, s32[] %constant.7567) + %dynamic-slice.7569 = f32[1,16]{1,0} dynamic-slice(f32[2,16]{1,0} %get-tuple-element.7420, s32[] %select.7560, s32[] %select.7568), dynamic_slice_sizes={1,16} + %reshape.7570 = f32[16]{0} reshape(f32[1,16]{1,0} %dynamic-slice.7569) + %constant.9076 = f32[] constant(0) + %reduce.9077 = f32[16]{0} reduce(f32[16,32,32,16]{3,2,1,0} %add.9075, f32[] %constant.9076), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7367 + %reshape.9078 = f32[1,1,1,16]{3,2,1,0} reshape(f32[16]{0} %reduce.9077) + %constant.9079 = f32[] constant(0) + %reduce.9080 = f32[16]{0} reduce(f32[1,1,1,16]{3,2,1,0} %reshape.9078, f32[] %constant.9079), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7371 + %broadcast.9081 = f32[16]{0} broadcast(f32[16]{0} %reduce.9080), dimensions={0} + %add.9082 = f32[16]{0} add(f32[16]{0} %reshape.7570, f32[16]{0} %broadcast.9081) + %broadcast.9236 = f32[1,16]{1,0} broadcast(f32[16]{0} %add.9082), dimensions={1} + %constant.9237 = s32[] constant(0) + %compare.9238 = pred[] compare(s32[] %subtract.7486, s32[] %constant.9237), direction=LT + %constant.9239 = s32[] constant(2) + %add.9240 = s32[] add(s32[] %subtract.7486, s32[] %constant.9239) + %select.9241 = s32[] select(pred[] %compare.9238, s32[] %add.9240, s32[] %subtract.7486) + %constant.9242 = s32[] constant(0) + %constant.9243 = s32[] constant(0) + %compare.9244 = pred[] compare(s32[] %constant.9242, s32[] %constant.9243), direction=LT + %constant.9245 = s32[] constant(0) + %constant.9246 = s32[] constant(16) + %add.9247 = s32[] add(s32[] %constant.9245, s32[] %constant.9246) + %constant.9248 = s32[] constant(0) + %select.9249 = s32[] select(pred[] %compare.9244, s32[] %add.9247, s32[] %constant.9248) + %dynamic-update-slice.9250 = f32[2,16]{1,0} dynamic-update-slice(f32[2,16]{1,0} %get-tuple-element.7477, f32[1,16]{1,0} %broadcast.9236, s32[] %select.9241, s32[] %select.9249) + %get-tuple-element.7478 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=61 + %constant.7571 = s32[] constant(0) + %compare.7572 = pred[] compare(s32[] %subtract.7486, s32[] %constant.7571), direction=LT + %constant.7573 = s32[] constant(2) + %add.7574 = s32[] add(s32[] %subtract.7486, s32[] %constant.7573) + %select.7575 = s32[] select(pred[] %compare.7572, s32[] %add.7574, s32[] %subtract.7486) + %constant.7576 = s32[] constant(0) + %constant.7577 = s32[] constant(0) + %compare.7578 = pred[] compare(s32[] %constant.7576, s32[] %constant.7577), direction=LT + %constant.7579 = s32[] constant(0) + %constant.7580 = s32[] constant(16) + %add.7581 = s32[] add(s32[] %constant.7579, s32[] %constant.7580) + %constant.7582 = s32[] constant(0) + %select.7583 = s32[] select(pred[] %compare.7578, s32[] %add.7581, s32[] %constant.7582) + %dynamic-slice.7584 = f32[1,16]{1,0} dynamic-slice(f32[2,16]{1,0} %get-tuple-element.7421, s32[] %select.7575, s32[] %select.7583), dynamic_slice_sizes={1,16} + %reshape.7585 = f32[16]{0} reshape(f32[1,16]{1,0} %dynamic-slice.7584) + %constant.8504 = s32[] constant(0) + %compare.8505 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8504), direction=LT + %constant.8506 = s32[] constant(2) + %add.8507 = s32[] add(s32[] %subtract.7486, s32[] %constant.8506) + %select.8508 = s32[] select(pred[] %compare.8505, s32[] %add.8507, s32[] %subtract.7486) + %constant.8509 = s32[] constant(0) + %constant.8510 = s32[] constant(0) + %compare.8511 = pred[] compare(s32[] %constant.8509, s32[] %constant.8510), direction=LT + %constant.8512 = s32[] constant(0) + %constant.8513 = s32[] constant(16) + %add.8514 = s32[] add(s32[] %constant.8512, s32[] %constant.8513) + %constant.8515 = s32[] constant(0) + %select.8516 = s32[] select(pred[] %compare.8511, s32[] %add.8514, s32[] %constant.8515) + %constant.8517 = s32[] constant(0) + %constant.8518 = s32[] constant(0) + %compare.8519 = pred[] compare(s32[] %constant.8517, s32[] %constant.8518), direction=LT + %constant.8520 = s32[] constant(0) + %constant.8521 = s32[] constant(32) + %add.8522 = s32[] add(s32[] %constant.8520, s32[] %constant.8521) + %constant.8523 = s32[] constant(0) + %select.8524 = s32[] select(pred[] %compare.8519, s32[] %add.8522, s32[] %constant.8523) + %constant.8525 = s32[] constant(0) + %constant.8526 = s32[] constant(0) + %compare.8527 = pred[] compare(s32[] %constant.8525, s32[] %constant.8526), direction=LT + %constant.8528 = s32[] constant(0) + %constant.8529 = s32[] constant(32) + %add.8530 = s32[] add(s32[] %constant.8528, s32[] %constant.8529) + %constant.8531 = s32[] constant(0) + %select.8532 = s32[] select(pred[] %compare.8527, s32[] %add.8530, s32[] %constant.8531) + %constant.8533 = s32[] constant(0) + %constant.8534 = s32[] constant(0) + %compare.8535 = pred[] compare(s32[] %constant.8533, s32[] %constant.8534), direction=LT + %constant.8536 = s32[] constant(0) + %constant.8537 = s32[] constant(16) + %add.8538 = s32[] add(s32[] %constant.8536, s32[] %constant.8537) + %constant.8539 = s32[] constant(0) + %select.8540 = s32[] select(pred[] %compare.8535, s32[] %add.8538, s32[] %constant.8539) + %dynamic-slice.8541 = f32[1,16,32,32,16]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.7448, s32[] %select.8508, s32[] %select.8516, s32[] %select.8524, s32[] %select.8532, /*index=5*/s32[] %select.8540), dynamic_slice_sizes={1,16,32,32,16} + %reshape.8542 = f32[16,32,32,16]{3,2,1,0} reshape(f32[1,16,32,32,16]{4,3,2,1,0} %dynamic-slice.8541) + %multiply.9083 = f32[16,32,32,16]{3,2,1,0} multiply(f32[16,32,32,16]{3,2,1,0} %reshape.8542, f32[16,32,32,16]{3,2,1,0} %add.9075) + %constant.9084 = f32[] constant(0) + %reduce.9085 = f32[16]{0} reduce(f32[16,32,32,16]{3,2,1,0} %multiply.9083, f32[] %constant.9084), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7375 + %reshape.9086 = f32[1,1,1,16]{3,2,1,0} reshape(f32[16]{0} %reduce.9085) + %constant.9087 = f32[] constant(0) + %reduce.9088 = f32[16]{0} reduce(f32[1,1,1,16]{3,2,1,0} %reshape.9086, f32[] %constant.9087), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7379 + %broadcast.9089 = f32[16]{0} broadcast(f32[16]{0} %reduce.9088), dimensions={0} + %add.9090 = f32[16]{0} add(f32[16]{0} %reshape.7585, f32[16]{0} %broadcast.9089) + %broadcast.9251 = f32[1,16]{1,0} broadcast(f32[16]{0} %add.9090), dimensions={1} + %constant.9252 = s32[] constant(0) + %compare.9253 = pred[] compare(s32[] %subtract.7486, s32[] %constant.9252), direction=LT + %constant.9254 = s32[] constant(2) + %add.9255 = s32[] add(s32[] %subtract.7486, s32[] %constant.9254) + %select.9256 = s32[] select(pred[] %compare.9253, s32[] %add.9255, s32[] %subtract.7486) + %constant.9257 = s32[] constant(0) + %constant.9258 = s32[] constant(0) + %compare.9259 = pred[] compare(s32[] %constant.9257, s32[] %constant.9258), direction=LT + %constant.9260 = s32[] constant(0) + %constant.9261 = s32[] constant(16) + %add.9262 = s32[] add(s32[] %constant.9260, s32[] %constant.9261) + %constant.9263 = s32[] constant(0) + %select.9264 = s32[] select(pred[] %compare.9259, s32[] %add.9262, s32[] %constant.9263) + %dynamic-update-slice.9265 = f32[2,16]{1,0} dynamic-update-slice(f32[2,16]{1,0} %get-tuple-element.7478, f32[1,16]{1,0} %broadcast.9251, s32[] %select.9256, s32[] %select.9264) + %get-tuple-element.7479 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=62 + %constant.7586 = s32[] constant(0) + %compare.7587 = pred[] compare(s32[] %subtract.7486, s32[] %constant.7586), direction=LT + %constant.7588 = s32[] constant(2) + %add.7589 = s32[] add(s32[] %subtract.7486, s32[] %constant.7588) + %select.7590 = s32[] select(pred[] %compare.7587, s32[] %add.7589, s32[] %subtract.7486) + %constant.7591 = s32[] constant(0) + %constant.7592 = s32[] constant(0) + %compare.7593 = pred[] compare(s32[] %constant.7591, s32[] %constant.7592), direction=LT + %constant.7594 = s32[] constant(0) + %constant.7595 = s32[] constant(1) + %add.7596 = s32[] add(s32[] %constant.7594, s32[] %constant.7595) + %constant.7597 = s32[] constant(0) + %select.7598 = s32[] select(pred[] %compare.7593, s32[] %add.7596, s32[] %constant.7597) + %constant.7599 = s32[] constant(0) + %constant.7600 = s32[] constant(0) + %compare.7601 = pred[] compare(s32[] %constant.7599, s32[] %constant.7600), direction=LT + %constant.7602 = s32[] constant(0) + %constant.7603 = s32[] constant(1) + %add.7604 = s32[] add(s32[] %constant.7602, s32[] %constant.7603) + %constant.7605 = s32[] constant(0) + %select.7606 = s32[] select(pred[] %compare.7601, s32[] %add.7604, s32[] %constant.7605) + %constant.7607 = s32[] constant(0) + %constant.7608 = s32[] constant(0) + %compare.7609 = pred[] compare(s32[] %constant.7607, s32[] %constant.7608), direction=LT + %constant.7610 = s32[] constant(0) + %constant.7611 = s32[] constant(16) + %add.7612 = s32[] add(s32[] %constant.7610, s32[] %constant.7611) + %constant.7613 = s32[] constant(0) + %select.7614 = s32[] select(pred[] %compare.7609, s32[] %add.7612, s32[] %constant.7613) + %constant.7615 = s32[] constant(0) + %constant.7616 = s32[] constant(0) + %compare.7617 = pred[] compare(s32[] %constant.7615, s32[] %constant.7616), direction=LT + %constant.7618 = s32[] constant(0) + %constant.7619 = s32[] constant(16) + %add.7620 = s32[] add(s32[] %constant.7618, s32[] %constant.7619) + %constant.7621 = s32[] constant(0) + %select.7622 = s32[] select(pred[] %compare.7617, s32[] %add.7620, s32[] %constant.7621) + %dynamic-slice.7623 = f32[1,1,1,16,16]{4,3,2,1,0} dynamic-slice(f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.7422, s32[] %select.7590, s32[] %select.7598, s32[] %select.7606, s32[] %select.7614, /*index=5*/s32[] %select.7622), dynamic_slice_sizes={1,1,1,16,16} + %reshape.7624 = f32[1,1,16,16]{3,2,1,0} reshape(f32[1,1,1,16,16]{4,3,2,1,0} %dynamic-slice.7623) + %constant.8372 = s32[] constant(0) + %compare.8373 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8372), direction=LT + %constant.8374 = s32[] constant(2) + %add.8375 = s32[] add(s32[] %subtract.7486, s32[] %constant.8374) + %select.8376 = s32[] select(pred[] %compare.8373, s32[] %add.8375, s32[] %subtract.7486) + %constant.8377 = s32[] constant(0) + %constant.8378 = s32[] constant(0) + %compare.8379 = pred[] compare(s32[] %constant.8377, s32[] %constant.8378), direction=LT + %constant.8380 = s32[] constant(0) + %constant.8381 = s32[] constant(1) + %add.8382 = s32[] add(s32[] %constant.8380, s32[] %constant.8381) + %constant.8383 = s32[] constant(0) + %select.8384 = s32[] select(pred[] %compare.8379, s32[] %add.8382, s32[] %constant.8383) + %constant.8385 = s32[] constant(0) + %constant.8386 = s32[] constant(0) + %compare.8387 = pred[] compare(s32[] %constant.8385, s32[] %constant.8386), direction=LT + %constant.8388 = s32[] constant(0) + %constant.8389 = s32[] constant(1) + %add.8390 = s32[] add(s32[] %constant.8388, s32[] %constant.8389) + %constant.8391 = s32[] constant(0) + %select.8392 = s32[] select(pred[] %compare.8387, s32[] %add.8390, s32[] %constant.8391) + %constant.8393 = s32[] constant(0) + %constant.8394 = s32[] constant(0) + %compare.8395 = pred[] compare(s32[] %constant.8393, s32[] %constant.8394), direction=LT + %constant.8396 = s32[] constant(0) + %constant.8397 = s32[] constant(16) + %add.8398 = s32[] add(s32[] %constant.8396, s32[] %constant.8397) + %constant.8399 = s32[] constant(0) + %select.8400 = s32[] select(pred[] %compare.8395, s32[] %add.8398, s32[] %constant.8399) + %constant.8401 = s32[] constant(0) + %constant.8402 = s32[] constant(0) + %compare.8403 = pred[] compare(s32[] %constant.8401, s32[] %constant.8402), direction=LT + %constant.8404 = s32[] constant(0) + %constant.8405 = s32[] constant(16) + %add.8406 = s32[] add(s32[] %constant.8404, s32[] %constant.8405) + %constant.8407 = s32[] constant(0) + %select.8408 = s32[] select(pred[] %compare.8403, s32[] %add.8406, s32[] %constant.8407) + %dynamic-slice.8409 = f32[1,1,1,16,16]{4,3,2,1,0} dynamic-slice(f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.7444, s32[] %select.8376, s32[] %select.8384, s32[] %select.8392, s32[] %select.8400, /*index=5*/s32[] %select.8408), dynamic_slice_sizes={1,1,1,16,16} + %reshape.8410 = f32[1,1,16,16]{3,2,1,0} reshape(f32[1,1,1,16,16]{4,3,2,1,0} %dynamic-slice.8409) + %constant.8294 = s32[] constant(0) + %compare.8295 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8294), direction=LT + %constant.8296 = s32[] constant(2) + %add.8297 = s32[] add(s32[] %subtract.7486, s32[] %constant.8296) + %select.8298 = s32[] select(pred[] %compare.8295, s32[] %add.8297, s32[] %subtract.7486) + %constant.8299 = s32[] constant(0) + %constant.8300 = s32[] constant(0) + %compare.8301 = pred[] compare(s32[] %constant.8299, s32[] %constant.8300), direction=LT + %constant.8302 = s32[] constant(0) + %constant.8303 = s32[] constant(16) + %add.8304 = s32[] add(s32[] %constant.8302, s32[] %constant.8303) + %constant.8305 = s32[] constant(0) + %select.8306 = s32[] select(pred[] %compare.8301, s32[] %add.8304, s32[] %constant.8305) + %constant.8307 = s32[] constant(0) + %constant.8308 = s32[] constant(0) + %compare.8309 = pred[] compare(s32[] %constant.8307, s32[] %constant.8308), direction=LT + %constant.8310 = s32[] constant(0) + %constant.8311 = s32[] constant(32) + %add.8312 = s32[] add(s32[] %constant.8310, s32[] %constant.8311) + %constant.8313 = s32[] constant(0) + %select.8314 = s32[] select(pred[] %compare.8309, s32[] %add.8312, s32[] %constant.8313) + %constant.8315 = s32[] constant(0) + %constant.8316 = s32[] constant(0) + %compare.8317 = pred[] compare(s32[] %constant.8315, s32[] %constant.8316), direction=LT + %constant.8318 = s32[] constant(0) + %constant.8319 = s32[] constant(32) + %add.8320 = s32[] add(s32[] %constant.8318, s32[] %constant.8319) + %constant.8321 = s32[] constant(0) + %select.8322 = s32[] select(pred[] %compare.8317, s32[] %add.8320, s32[] %constant.8321) + %constant.8323 = s32[] constant(0) + %constant.8324 = s32[] constant(0) + %compare.8325 = pred[] compare(s32[] %constant.8323, s32[] %constant.8324), direction=LT + %constant.8326 = s32[] constant(0) + %constant.8327 = s32[] constant(16) + %add.8328 = s32[] add(s32[] %constant.8326, s32[] %constant.8327) + %constant.8329 = s32[] constant(0) + %select.8330 = s32[] select(pred[] %compare.8325, s32[] %add.8328, s32[] %constant.8329) + %dynamic-slice.8331 = f32[1,16,32,32,16]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.7442, s32[] %select.8298, s32[] %select.8306, s32[] %select.8314, s32[] %select.8322, /*index=5*/s32[] %select.8330), dynamic_slice_sizes={1,16,32,32,16} + %reshape.8332 = f32[16,32,32,16]{3,2,1,0} reshape(f32[1,16,32,32,16]{4,3,2,1,0} %dynamic-slice.8331) + %convolution.9094 = f32[1,1,16,16]{3,2,1,0} convolution(f32[16,32,32,16]{3,2,1,0} %reshape.8332, f32[16,32,32,16]{3,2,1,0} %multiply.9093), window={size=32x32}, dim_labels=f01b_i01o->01bf + %multiply.9095 = f32[1,1,16,16]{3,2,1,0} multiply(f32[1,1,16,16]{3,2,1,0} %reshape.8410, f32[1,1,16,16]{3,2,1,0} %convolution.9094) + %constant.9096 = f32[] constant(0) + %reduce.9097 = f32[1,1,16]{2,1,0} reduce(f32[1,1,16,16]{3,2,1,0} %multiply.9095, f32[] %constant.9096), dimensions={2}, to_apply=%primitive_computation_add__1.7383 + %reshape.9098 = f32[1,1,1,16]{3,2,1,0} reshape(f32[1,1,16]{2,1,0} %reduce.9097) + %constant.9099 = f32[] constant(0) + %reduce.9100 = f32[16]{0} reduce(f32[1,1,1,16]{3,2,1,0} %reshape.9098, f32[] %constant.9099), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7387 + %broadcast.9101 = f32[16]{0} broadcast(f32[16]{0} %reduce.9100), dimensions={0} + %constant.8450 = s32[] constant(0) + %compare.8451 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8450), direction=LT + %constant.8452 = s32[] constant(2) + %add.8453 = s32[] add(s32[] %subtract.7486, s32[] %constant.8452) + %select.8454 = s32[] select(pred[] %compare.8451, s32[] %add.8453, s32[] %subtract.7486) + %constant.8455 = s32[] constant(0) + %constant.8456 = s32[] constant(0) + %compare.8457 = pred[] compare(s32[] %constant.8455, s32[] %constant.8456), direction=LT + %constant.8458 = s32[] constant(0) + %constant.8459 = s32[] constant(16) + %add.8460 = s32[] add(s32[] %constant.8458, s32[] %constant.8459) + %constant.8461 = s32[] constant(0) + %select.8462 = s32[] select(pred[] %compare.8457, s32[] %add.8460, s32[] %constant.8461) + %dynamic-slice.8463 = f32[1,16]{1,0} dynamic-slice(f32[2,16]{1,0} %get-tuple-element.7446, s32[] %select.8454, s32[] %select.8462), dynamic_slice_sizes={1,16} + %reshape.8464 = f32[16]{0} reshape(f32[1,16]{1,0} %dynamic-slice.8463) + %multiply.9102 = f32[16]{0} multiply(f32[16]{0} %broadcast.9101, f32[16]{0} %reshape.8464) + %broadcast.9103 = f32[1,1,16,16]{3,2,1,0} broadcast(f32[16]{0} %multiply.9102), dimensions={3} + %constant.8411 = s32[] constant(0) + %compare.8412 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8411), direction=LT + %constant.8413 = s32[] constant(2) + %add.8414 = s32[] add(s32[] %subtract.7486, s32[] %constant.8413) + %select.8415 = s32[] select(pred[] %compare.8412, s32[] %add.8414, s32[] %subtract.7486) + %constant.8416 = s32[] constant(0) + %constant.8417 = s32[] constant(0) + %compare.8418 = pred[] compare(s32[] %constant.8416, s32[] %constant.8417), direction=LT + %constant.8419 = s32[] constant(0) + %constant.8420 = s32[] constant(1) + %add.8421 = s32[] add(s32[] %constant.8419, s32[] %constant.8420) + %constant.8422 = s32[] constant(0) + %select.8423 = s32[] select(pred[] %compare.8418, s32[] %add.8421, s32[] %constant.8422) + %constant.8424 = s32[] constant(0) + %constant.8425 = s32[] constant(0) + %compare.8426 = pred[] compare(s32[] %constant.8424, s32[] %constant.8425), direction=LT + %constant.8427 = s32[] constant(0) + %constant.8428 = s32[] constant(1) + %add.8429 = s32[] add(s32[] %constant.8427, s32[] %constant.8428) + %constant.8430 = s32[] constant(0) + %select.8431 = s32[] select(pred[] %compare.8426, s32[] %add.8429, s32[] %constant.8430) + %constant.8432 = s32[] constant(0) + %constant.8433 = s32[] constant(0) + %compare.8434 = pred[] compare(s32[] %constant.8432, s32[] %constant.8433), direction=LT + %constant.8435 = s32[] constant(0) + %constant.8436 = s32[] constant(16) + %add.8437 = s32[] add(s32[] %constant.8435, s32[] %constant.8436) + %constant.8438 = s32[] constant(0) + %select.8439 = s32[] select(pred[] %compare.8434, s32[] %add.8437, s32[] %constant.8438) + %constant.8440 = s32[] constant(0) + %constant.8441 = s32[] constant(0) + %compare.8442 = pred[] compare(s32[] %constant.8440, s32[] %constant.8441), direction=LT + %constant.8443 = s32[] constant(0) + %constant.8444 = s32[] constant(16) + %add.8445 = s32[] add(s32[] %constant.8443, s32[] %constant.8444) + %constant.8446 = s32[] constant(0) + %select.8447 = s32[] select(pred[] %compare.8442, s32[] %add.8445, s32[] %constant.8446) + %dynamic-slice.8448 = f32[1,1,1,16,16]{4,3,2,1,0} dynamic-slice(f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.7445, s32[] %select.8415, s32[] %select.8423, s32[] %select.8431, s32[] %select.8439, /*index=5*/s32[] %select.8447), dynamic_slice_sizes={1,1,1,16,16} + %reshape.8449 = f32[1,1,16,16]{3,2,1,0} reshape(f32[1,1,1,16,16]{4,3,2,1,0} %dynamic-slice.8448) + %multiply.9104 = f32[1,1,16,16]{3,2,1,0} multiply(f32[1,1,16,16]{3,2,1,0} %broadcast.9103, f32[1,1,16,16]{3,2,1,0} %reshape.8449) + %add.9105 = f32[1,1,16,16]{3,2,1,0} add(f32[1,1,16,16]{3,2,1,0} %reshape.7624, f32[1,1,16,16]{3,2,1,0} %multiply.9104) + %constant.8333 = s32[] constant(0) + %compare.8334 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8333), direction=LT + %constant.8335 = s32[] constant(2) + %add.8336 = s32[] add(s32[] %subtract.7486, s32[] %constant.8335) + %select.8337 = s32[] select(pred[] %compare.8334, s32[] %add.8336, s32[] %subtract.7486) + %constant.8338 = s32[] constant(0) + %constant.8339 = s32[] constant(0) + %compare.8340 = pred[] compare(s32[] %constant.8338, s32[] %constant.8339), direction=LT + %constant.8341 = s32[] constant(0) + %constant.8342 = s32[] constant(1) + %add.8343 = s32[] add(s32[] %constant.8341, s32[] %constant.8342) + %constant.8344 = s32[] constant(0) + %select.8345 = s32[] select(pred[] %compare.8340, s32[] %add.8343, s32[] %constant.8344) + %constant.8346 = s32[] constant(0) + %constant.8347 = s32[] constant(0) + %compare.8348 = pred[] compare(s32[] %constant.8346, s32[] %constant.8347), direction=LT + %constant.8349 = s32[] constant(0) + %constant.8350 = s32[] constant(1) + %add.8351 = s32[] add(s32[] %constant.8349, s32[] %constant.8350) + %constant.8352 = s32[] constant(0) + %select.8353 = s32[] select(pred[] %compare.8348, s32[] %add.8351, s32[] %constant.8352) + %constant.8354 = s32[] constant(0) + %constant.8355 = s32[] constant(0) + %compare.8356 = pred[] compare(s32[] %constant.8354, s32[] %constant.8355), direction=LT + %constant.8357 = s32[] constant(0) + %constant.8358 = s32[] constant(1) + %add.8359 = s32[] add(s32[] %constant.8357, s32[] %constant.8358) + %constant.8360 = s32[] constant(0) + %select.8361 = s32[] select(pred[] %compare.8356, s32[] %add.8359, s32[] %constant.8360) + %constant.8362 = s32[] constant(0) + %constant.8363 = s32[] constant(0) + %compare.8364 = pred[] compare(s32[] %constant.8362, s32[] %constant.8363), direction=LT + %constant.8365 = s32[] constant(0) + %constant.8366 = s32[] constant(16) + %add.8367 = s32[] add(s32[] %constant.8365, s32[] %constant.8366) + %constant.8368 = s32[] constant(0) + %select.8369 = s32[] select(pred[] %compare.8364, s32[] %add.8367, s32[] %constant.8368) + %dynamic-slice.8370 = f32[1,1,1,1,16]{4,3,2,1,0} dynamic-slice(f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.7443, s32[] %select.8337, s32[] %select.8345, s32[] %select.8353, s32[] %select.8361, /*index=5*/s32[] %select.8369), dynamic_slice_sizes={1,1,1,1,16} + %reshape.8371 = f32[1,1,1,16]{3,2,1,0} reshape(f32[1,1,1,1,16]{4,3,2,1,0} %dynamic-slice.8370) + %reshape.9106 = f32[1,1,16]{2,1,0} reshape(f32[1,1,1,16]{3,2,1,0} %reshape.8371) + %broadcast.9107 = f32[1,1,16,16]{3,2,1,0} broadcast(f32[1,1,16]{2,1,0} %reshape.9106), dimensions={0,1,3} + %multiply.9108 = f32[1,1,16,16]{3,2,1,0} multiply(f32[1,1,16,16]{3,2,1,0} %convolution.9094, f32[1,1,16,16]{3,2,1,0} %broadcast.9107) + %add.9109 = f32[1,1,16,16]{3,2,1,0} add(f32[1,1,16,16]{3,2,1,0} %add.9105, f32[1,1,16,16]{3,2,1,0} %multiply.9108) + %broadcast.9266 = f32[1,1,1,16,16]{4,3,2,1,0} broadcast(f32[1,1,16,16]{3,2,1,0} %add.9109), dimensions={1,2,3,4} + %constant.9267 = s32[] constant(0) + %compare.9268 = pred[] compare(s32[] %subtract.7486, s32[] %constant.9267), direction=LT + %constant.9269 = s32[] constant(2) + %add.9270 = s32[] add(s32[] %subtract.7486, s32[] %constant.9269) + %select.9271 = s32[] select(pred[] %compare.9268, s32[] %add.9270, s32[] %subtract.7486) + %constant.9272 = s32[] constant(0) + %constant.9273 = s32[] constant(0) + %compare.9274 = pred[] compare(s32[] %constant.9272, s32[] %constant.9273), direction=LT + %constant.9275 = s32[] constant(0) + %constant.9276 = s32[] constant(1) + %add.9277 = s32[] add(s32[] %constant.9275, s32[] %constant.9276) + %constant.9278 = s32[] constant(0) + %select.9279 = s32[] select(pred[] %compare.9274, s32[] %add.9277, s32[] %constant.9278) + %constant.9280 = s32[] constant(0) + %constant.9281 = s32[] constant(0) + %compare.9282 = pred[] compare(s32[] %constant.9280, s32[] %constant.9281), direction=LT + %constant.9283 = s32[] constant(0) + %constant.9284 = s32[] constant(1) + %add.9285 = s32[] add(s32[] %constant.9283, s32[] %constant.9284) + %constant.9286 = s32[] constant(0) + %select.9287 = s32[] select(pred[] %compare.9282, s32[] %add.9285, s32[] %constant.9286) + %constant.9288 = s32[] constant(0) + %constant.9289 = s32[] constant(0) + %compare.9290 = pred[] compare(s32[] %constant.9288, s32[] %constant.9289), direction=LT + %constant.9291 = s32[] constant(0) + %constant.9292 = s32[] constant(16) + %add.9293 = s32[] add(s32[] %constant.9291, s32[] %constant.9292) + %constant.9294 = s32[] constant(0) + %select.9295 = s32[] select(pred[] %compare.9290, s32[] %add.9293, s32[] %constant.9294) + %constant.9296 = s32[] constant(0) + %constant.9297 = s32[] constant(0) + %compare.9298 = pred[] compare(s32[] %constant.9296, s32[] %constant.9297), direction=LT + %constant.9299 = s32[] constant(0) + %constant.9300 = s32[] constant(16) + %add.9301 = s32[] add(s32[] %constant.9299, s32[] %constant.9300) + %constant.9302 = s32[] constant(0) + %select.9303 = s32[] select(pred[] %compare.9298, s32[] %add.9301, s32[] %constant.9302) + %dynamic-update-slice.9304 = f32[2,1,1,16,16]{4,3,2,1,0} dynamic-update-slice(f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.7479, f32[1,1,1,16,16]{4,3,2,1,0} %broadcast.9266, s32[] %select.9271, s32[] %select.9279, s32[] %select.9287, /*index=5*/s32[] %select.9295, s32[] %select.9303) + %get-tuple-element.7480 = f32[2,8]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=63 + %constant.7625 = s32[] constant(0) + %compare.7626 = pred[] compare(s32[] %subtract.7486, s32[] %constant.7625), direction=LT + %constant.7627 = s32[] constant(2) + %add.7628 = s32[] add(s32[] %subtract.7486, s32[] %constant.7627) + %select.7629 = s32[] select(pred[] %compare.7626, s32[] %add.7628, s32[] %subtract.7486) + %constant.7630 = s32[] constant(0) + %constant.7631 = s32[] constant(0) + %compare.7632 = pred[] compare(s32[] %constant.7630, s32[] %constant.7631), direction=LT + %constant.7633 = s32[] constant(0) + %constant.7634 = s32[] constant(8) + %add.7635 = s32[] add(s32[] %constant.7633, s32[] %constant.7634) + %constant.7636 = s32[] constant(0) + %select.7637 = s32[] select(pred[] %compare.7632, s32[] %add.7635, s32[] %constant.7636) + %dynamic-slice.7638 = f32[1,8]{1,0} dynamic-slice(f32[2,8]{1,0} %get-tuple-element.7423, s32[] %select.7629, s32[] %select.7637), dynamic_slice_sizes={1,8} + %reshape.7639 = f32[8]{0} reshape(f32[1,8]{1,0} %dynamic-slice.7638) + %constant.9010 = f32[] constant(0) + %reduce.9011 = f32[8]{0} reduce(f32[16,32,32,8]{3,2,1,0} %get-tuple-element.7464, f32[] %constant.9010), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7335 + %reshape.9012 = f32[1,1,1,8]{3,2,1,0} reshape(f32[8]{0} %reduce.9011) + %constant.9013 = f32[] constant(0) + %reduce.9014 = f32[8]{0} reduce(f32[1,1,1,8]{3,2,1,0} %reshape.9012, f32[] %constant.9013), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7339 + %broadcast.9015 = f32[8]{0} broadcast(f32[8]{0} %reduce.9014), dimensions={0} + %add.9016 = f32[8]{0} add(f32[8]{0} %reshape.7639, f32[8]{0} %broadcast.9015) + %broadcast.9305 = f32[1,8]{1,0} broadcast(f32[8]{0} %add.9016), dimensions={1} + %constant.9306 = s32[] constant(0) + %compare.9307 = pred[] compare(s32[] %subtract.7486, s32[] %constant.9306), direction=LT + %constant.9308 = s32[] constant(2) + %add.9309 = s32[] add(s32[] %subtract.7486, s32[] %constant.9308) + %select.9310 = s32[] select(pred[] %compare.9307, s32[] %add.9309, s32[] %subtract.7486) + %constant.9311 = s32[] constant(0) + %constant.9312 = s32[] constant(0) + %compare.9313 = pred[] compare(s32[] %constant.9311, s32[] %constant.9312), direction=LT + %constant.9314 = s32[] constant(0) + %constant.9315 = s32[] constant(8) + %add.9316 = s32[] add(s32[] %constant.9314, s32[] %constant.9315) + %constant.9317 = s32[] constant(0) + %select.9318 = s32[] select(pred[] %compare.9313, s32[] %add.9316, s32[] %constant.9317) + %dynamic-update-slice.9319 = f32[2,8]{1,0} dynamic-update-slice(f32[2,8]{1,0} %get-tuple-element.7480, f32[1,8]{1,0} %broadcast.9305, s32[] %select.9310, s32[] %select.9318) + %get-tuple-element.7481 = f32[2,8]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.7416), index=64 + %constant.7640 = s32[] constant(0) + %compare.7641 = pred[] compare(s32[] %subtract.7486, s32[] %constant.7640), direction=LT + %constant.7642 = s32[] constant(2) + %add.7643 = s32[] add(s32[] %subtract.7486, s32[] %constant.7642) + %select.7644 = s32[] select(pred[] %compare.7641, s32[] %add.7643, s32[] %subtract.7486) + %constant.7645 = s32[] constant(0) + %constant.7646 = s32[] constant(0) + %compare.7647 = pred[] compare(s32[] %constant.7645, s32[] %constant.7646), direction=LT + %constant.7648 = s32[] constant(0) + %constant.7649 = s32[] constant(8) + %add.7650 = s32[] add(s32[] %constant.7648, s32[] %constant.7649) + %constant.7651 = s32[] constant(0) + %select.7652 = s32[] select(pred[] %compare.7647, s32[] %add.7650, s32[] %constant.7651) + %dynamic-slice.7653 = f32[1,8]{1,0} dynamic-slice(f32[2,8]{1,0} %get-tuple-element.7424, s32[] %select.7644, s32[] %select.7652), dynamic_slice_sizes={1,8} + %reshape.7654 = f32[8]{0} reshape(f32[1,8]{1,0} %dynamic-slice.7653) + %constant.8971 = s32[] constant(0) + %compare.8972 = pred[] compare(s32[] %subtract.7486, s32[] %constant.8971), direction=LT + %constant.8973 = s32[] constant(2) + %add.8974 = s32[] add(s32[] %subtract.7486, s32[] %constant.8973) + %select.8975 = s32[] select(pred[] %compare.8972, s32[] %add.8974, s32[] %subtract.7486) + %constant.8976 = s32[] constant(0) + %constant.8977 = s32[] constant(0) + %compare.8978 = pred[] compare(s32[] %constant.8976, s32[] %constant.8977), direction=LT + %constant.8979 = s32[] constant(0) + %constant.8980 = s32[] constant(16) + %add.8981 = s32[] add(s32[] %constant.8979, s32[] %constant.8980) + %constant.8982 = s32[] constant(0) + %select.8983 = s32[] select(pred[] %compare.8978, s32[] %add.8981, s32[] %constant.8982) + %constant.8984 = s32[] constant(0) + %constant.8985 = s32[] constant(0) + %compare.8986 = pred[] compare(s32[] %constant.8984, s32[] %constant.8985), direction=LT + %constant.8987 = s32[] constant(0) + %constant.8988 = s32[] constant(32) + %add.8989 = s32[] add(s32[] %constant.8987, s32[] %constant.8988) + %constant.8990 = s32[] constant(0) + %select.8991 = s32[] select(pred[] %compare.8986, s32[] %add.8989, s32[] %constant.8990) + %constant.8992 = s32[] constant(0) + %constant.8993 = s32[] constant(0) + %compare.8994 = pred[] compare(s32[] %constant.8992, s32[] %constant.8993), direction=LT + %constant.8995 = s32[] constant(0) + %constant.8996 = s32[] constant(32) + %add.8997 = s32[] add(s32[] %constant.8995, s32[] %constant.8996) + %constant.8998 = s32[] constant(0) + %select.8999 = s32[] select(pred[] %compare.8994, s32[] %add.8997, s32[] %constant.8998) + %constant.9000 = s32[] constant(0) + %constant.9001 = s32[] constant(0) + %compare.9002 = pred[] compare(s32[] %constant.9000, s32[] %constant.9001), direction=LT + %constant.9003 = s32[] constant(0) + %constant.9004 = s32[] constant(8) + %add.9005 = s32[] add(s32[] %constant.9003, s32[] %constant.9004) + %constant.9006 = s32[] constant(0) + %select.9007 = s32[] select(pred[] %compare.9002, s32[] %add.9005, s32[] %constant.9006) + %dynamic-slice.9008 = f32[1,16,32,32,8]{4,3,2,1,0} dynamic-slice(f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7461, s32[] %select.8975, s32[] %select.8983, s32[] %select.8991, s32[] %select.8999, /*index=5*/s32[] %select.9007), dynamic_slice_sizes={1,16,32,32,8} + %reshape.9009 = f32[16,32,32,8]{3,2,1,0} reshape(f32[1,16,32,32,8]{4,3,2,1,0} %dynamic-slice.9008) + %multiply.9017 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %reshape.9009, f32[16,32,32,8]{3,2,1,0} %get-tuple-element.7464) + %constant.9018 = f32[] constant(0) + %reduce.9019 = f32[8]{0} reduce(f32[16,32,32,8]{3,2,1,0} %multiply.9017, f32[] %constant.9018), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7343 + %reshape.9020 = f32[1,1,1,8]{3,2,1,0} reshape(f32[8]{0} %reduce.9019) + %constant.9021 = f32[] constant(0) + %reduce.9022 = f32[8]{0} reduce(f32[1,1,1,8]{3,2,1,0} %reshape.9020, f32[] %constant.9021), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7347 + %broadcast.9023 = f32[8]{0} broadcast(f32[8]{0} %reduce.9022), dimensions={0} + %add.9024 = f32[8]{0} add(f32[8]{0} %reshape.7654, f32[8]{0} %broadcast.9023) + %broadcast.9320 = f32[1,8]{1,0} broadcast(f32[8]{0} %add.9024), dimensions={1} + %constant.9321 = s32[] constant(0) + %compare.9322 = pred[] compare(s32[] %subtract.7486, s32[] %constant.9321), direction=LT + %constant.9323 = s32[] constant(2) + %add.9324 = s32[] add(s32[] %subtract.7486, s32[] %constant.9323) + %select.9325 = s32[] select(pred[] %compare.9322, s32[] %add.9324, s32[] %subtract.7486) + %constant.9326 = s32[] constant(0) + %constant.9327 = s32[] constant(0) + %compare.9328 = pred[] compare(s32[] %constant.9326, s32[] %constant.9327), direction=LT + %constant.9329 = s32[] constant(0) + %constant.9330 = s32[] constant(8) + %add.9331 = s32[] add(s32[] %constant.9329, s32[] %constant.9330) + %constant.9332 = s32[] constant(0) + %select.9333 = s32[] select(pred[] %compare.9328, s32[] %add.9331, s32[] %constant.9332) + %dynamic-update-slice.9334 = f32[2,8]{1,0} dynamic-update-slice(f32[2,8]{1,0} %get-tuple-element.7481, f32[1,8]{1,0} %broadcast.9320, s32[] %select.9325, s32[] %select.9333) + ROOT %tuple.9347 = (f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) tuple(f32[2,16]{1,0} %get-tuple-element.7417, f32[2,16]{1,0} %get-tuple-element.7418, f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.7419, f32[2,16]{1,0} %get-tuple-element.7420, f32[2,16]{1,0} %get-tuple-element.7421, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.7422, f32[2,8]{1,0} %get-tuple-element.7423, f32[2,8]{1,0} %get-tuple-element.7424, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7425, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7426, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7427, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7428, f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.7429, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7430, f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.7431, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.7432, f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.7433, f32[2,16]{1,0} %get-tuple-element.7434, f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.7435, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.7436, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.7437, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.7438, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.7439, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.7440, f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.7441, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.7442, f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.7443, f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.7444, f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.7445, f32[2,16]{1,0} %get-tuple-element.7446, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.7447, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.7448, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7449, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7450, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7451, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7452, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7453, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7454, f32[2,16,1,1,8]{4,3,2,1,0} %get-tuple-element.7455, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7456, /*index=40*/f32[2,16,1024,8]{3,2,1,0} %get-tuple-element.7457, f32[2,16,8]{2,1,0} %get-tuple-element.7458, f32[2,16,8]{2,1,0} %get-tuple-element.7459, f32[2,1,1,1,8]{4,3,2,1,0} %get-tuple-element.7460, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.7461, /*index=45*/s32[] %add.9336, pred[] %constant.9337, f32[16,32,32,8]{3,2,1,0} %add.9166, pred[] %constant.9338, pred[] %constant.9339, /*index=50*/pred[] %constant.9340, pred[] %constant.9341, pred[] %constant.9342, pred[] %constant.9343, pred[] %constant.9344, /*index=55*/pred[] %constant.9345, pred[] %constant.9346, f32[2,16]{1,0} %dynamic-update-slice.9181, f32[2,16]{1,0} %dynamic-update-slice.9196, f32[2,3,3,8,16]{4,3,2,1,0} %dynamic-update-slice.9235, /*index=60*/f32[2,16]{1,0} %dynamic-update-slice.9250, f32[2,16]{1,0} %dynamic-update-slice.9265, f32[2,1,1,16,16]{4,3,2,1,0} %dynamic-update-slice.9304, f32[2,8]{1,0} %dynamic-update-slice.9319, f32[2,8]{1,0} %dynamic-update-slice.9334) +} + +%cond_computation__3.9348 (parameter.9349: (f32[2,16], f32[2,16], f32[2,3,3,8,16], f32[2,16], f32[2,16], /*index=5*/f32[2,1,1,16,16], f32[2,8], f32[2,8], f32[2,16,32,32,8], f32[2,16,32,32,8], /*index=10*/f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,3,3,8,16], f32[2,16,32,32,8], f32[2,1,1,1,16], /*index=15*/f32[2,3,3,8,16], f32[2,3,3,8,16], f32[2,16], f32[2,1,1,1,16], f32[2,16,32,32,16], /*index=20*/f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,16,32,32,16], f32[2,1,1,16,16], /*index=25*/f32[2,16,32,32,16], f32[2,1,1,1,16], f32[2,1,1,16,16], f32[2,1,1,16,16], f32[2,16], /*index=30*/f32[2,1,1,1,16], f32[2,16,32,32,16], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], /*index=35*/f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,32,32,8], f32[2,16,1,1,8], f32[2,16,32,32,8], /*index=40*/f32[2,16,1024,8], f32[2,16,8], f32[2,16,8], f32[2,1,1,1,8], f32[2,16,32,32,8], /*index=45*/s32[], pred[], f32[16,32,32,8], pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16], f32[2,16], f32[2,3,3,8,16], /*index=60*/f32[2,16], f32[2,16], f32[2,1,1,16,16], f32[2,8], f32[2,8])) -> pred[] { + %parameter.9349 = (f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) parameter(0) + %get-tuple-element.9350 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=0 + %get-tuple-element.9351 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=1 + %get-tuple-element.9352 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=2 + %get-tuple-element.9353 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=3 + %get-tuple-element.9354 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=4 + %get-tuple-element.9355 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=5 + %get-tuple-element.9356 = f32[2,8]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=6 + %get-tuple-element.9357 = f32[2,8]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=7 + %get-tuple-element.9358 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=8 + %get-tuple-element.9359 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=9 + %get-tuple-element.9360 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=10 + %get-tuple-element.9361 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=11 + %get-tuple-element.9362 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=12 + %get-tuple-element.9363 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=13 + %get-tuple-element.9364 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=14 + %get-tuple-element.9365 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=15 + %get-tuple-element.9366 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=16 + %get-tuple-element.9367 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=17 + %get-tuple-element.9368 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=18 + %get-tuple-element.9369 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=19 + %get-tuple-element.9370 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=20 + %get-tuple-element.9371 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=21 + %get-tuple-element.9372 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=22 + %get-tuple-element.9373 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=23 + %get-tuple-element.9374 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=24 + %get-tuple-element.9375 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=25 + %get-tuple-element.9376 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=26 + %get-tuple-element.9377 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=27 + %get-tuple-element.9378 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=28 + %get-tuple-element.9379 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=29 + %get-tuple-element.9380 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=30 + %get-tuple-element.9381 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=31 + %get-tuple-element.9382 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=32 + %get-tuple-element.9383 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=33 + %get-tuple-element.9384 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=34 + %get-tuple-element.9385 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=35 + %get-tuple-element.9386 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=36 + %get-tuple-element.9387 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=37 + %get-tuple-element.9388 = f32[2,16,1,1,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=38 + %get-tuple-element.9389 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=39 + %get-tuple-element.9390 = f32[2,16,1024,8]{3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=40 + %get-tuple-element.9391 = f32[2,16,8]{2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=41 + %get-tuple-element.9392 = f32[2,16,8]{2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=42 + %get-tuple-element.9393 = f32[2,1,1,1,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=43 + %get-tuple-element.9394 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=44 + %get-tuple-element.9396 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=46 + %get-tuple-element.9397 = f32[16,32,32,8]{3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=47 + %get-tuple-element.9398 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=48 + %get-tuple-element.9399 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=49 + %get-tuple-element.9400 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=50 + %get-tuple-element.9401 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=51 + %get-tuple-element.9402 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=52 + %get-tuple-element.9403 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=53 + %get-tuple-element.9404 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=54 + %get-tuple-element.9405 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=55 + %get-tuple-element.9406 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=56 + %get-tuple-element.9407 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=57 + %get-tuple-element.9408 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=58 + %get-tuple-element.9409 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=59 + %get-tuple-element.9410 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=60 + %get-tuple-element.9411 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=61 + %get-tuple-element.9412 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=62 + %get-tuple-element.9413 = f32[2,8]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=63 + %get-tuple-element.9414 = f32[2,8]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=64 + %constant.9415 = pred[] constant(false) + %get-tuple-element.9395 = s32[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %parameter.9349), index=45 + %constant.9416 = s32[] constant(2) + ROOT %compare.9417 = pred[] compare(s32[] %get-tuple-element.9395, s32[] %constant.9416), direction=LT +} + +%primitive_computation_add__1.9526 (parameter.9527: f32[], parameter.9528: f32[]) -> f32[] { + %parameter.9527 = f32[] parameter(0) + %parameter.9528 = f32[] parameter(1) + ROOT %add.9529 = f32[] add(f32[] %parameter.9527, f32[] %parameter.9528) +} + +%primitive_computation_add__1.9533 (parameter.9534: f32[], parameter.9535: f32[]) -> f32[] { + %parameter.9534 = f32[] parameter(0) + %parameter.9535 = f32[] parameter(1) + ROOT %add.9536 = f32[] add(f32[] %parameter.9534, f32[] %parameter.9535) +} + +%primitive_computation_add__1.9541 (parameter.9542: f32[], parameter.9543: f32[]) -> f32[] { + %parameter.9542 = f32[] parameter(0) + %parameter.9543 = f32[] parameter(1) + ROOT %add.9544 = f32[] add(f32[] %parameter.9542, f32[] %parameter.9543) +} + +%primitive_computation_add__1.9548 (parameter.9549: f32[], parameter.9550: f32[]) -> f32[] { + %parameter.9549 = f32[] parameter(0) + %parameter.9550 = f32[] parameter(1) + ROOT %add.9551 = f32[] add(f32[] %parameter.9549, f32[] %parameter.9550) +} + +%primitive_computation_add__1.9560 (parameter.9561: f32[], parameter.9562: f32[]) -> f32[] { + %parameter.9561 = f32[] parameter(0) + %parameter.9562 = f32[] parameter(1) + ROOT %add.9563 = f32[] add(f32[] %parameter.9561, f32[] %parameter.9562) +} + +%primitive_computation_add__1.9570 (parameter.9571: f32[], parameter.9572: f32[]) -> f32[] { + %parameter.9571 = f32[] parameter(0) + %parameter.9572 = f32[] parameter(1) + ROOT %add.9573 = f32[] add(f32[] %parameter.9571, f32[] %parameter.9572) +} + +ENTRY %jit_loss.9581 (parameter.1: f32[2,16], parameter.2: f32[2,16], parameter.3: f32[2,3,3,8,16], parameter.4: f32[2,16], parameter.5: f32[2,16], parameter.6: f32[2,1,1,16,16], parameter.7: f32[2,8], parameter.8: f32[2,8], parameter.9: f32[8], parameter.10: f32[8], parameter.11: f32[1,1,2,8], parameter.12: f32[2], parameter.13: f32[2], parameter.14: f32[1,1,8,2], parameter.15: f32[], parameter.16: f32[3,3], parameter.17: f32[2,16], parameter.18: f32[2,16], parameter.19: f32[2,3,3,8,16], parameter.20: f32[2,16], parameter.21: f32[2,16], parameter.22: f32[2,1,1,16,16], parameter.23: f32[2,8], parameter.24: f32[2,8], parameter.25: f32[8], parameter.26: f32[8], parameter.27: f32[1,1,2,8], parameter.28: f32[2], parameter.29: f32[2], parameter.30: f32[1,1,8,2], parameter.31: f32[], parameter.32: f32[16,32,32,3], parameter.33: u32[2]) -> (f32[], f32[2,16], f32[2,16], f32[2,3,3,8,16], f32[2,16], /*index=5*/f32[2,16], f32[2,1,1,16,16], f32[2,8], f32[2,8], f32[8], /*index=10*/f32[8], f32[1,1,2,8], f32[2], f32[2], f32[1,1,8,2], /*index=15*/f32[], f32[3,3], f32[2,16], f32[2,16], f32[2,3,3,8,16], /*index=20*/f32[2,16], f32[2,16], f32[2,1,1,16,16], f32[2,8], f32[2,8], /*index=25*/f32[8], f32[8], f32[1,1,2,8], f32[2], f32[2], /*index=30*/f32[1,1,8,2], f32[]) { + %constant.34 = pred[] constant(false) + %parameter.33 = u32[2]{0} parameter(32) + %slice.36 = u32[1]{0} slice(u32[2]{0} %parameter.33), slice={[0:1]} + %reshape.37 = u32[] reshape(u32[1]{0} %slice.36) + %broadcast.42 = u32[4]{0} broadcast(u32[] %reshape.37), dimensions={} + %slice.38 = u32[1]{0} slice(u32[2]{0} %parameter.33), slice={[1:2]} + %reshape.39 = u32[] reshape(u32[1]{0} %slice.38) + %broadcast.43 = u32[4]{0} broadcast(u32[] %reshape.39), dimensions={} + %iota.35 = u32[8] iota(), iota_dimension=0 + %slice.40 = u32[4]{0} slice(u32[8] %iota.35), slice={[0:4]} + %broadcast.44 = u32[4]{0} broadcast(u32[4]{0} %slice.40), dimensions={0} + %slice.41 = u32[4]{0} slice(u32[8] %iota.35), slice={[4:8]} + %broadcast.45 = u32[4]{0} broadcast(u32[4]{0} %slice.41), dimensions={0} + %custom-call.46 = (u32[4]{0}, u32[4]{0}) custom-call(u32[4]{0} %broadcast.42, u32[4]{0} %broadcast.43, u32[4]{0} %broadcast.44, u32[4]{0} %broadcast.45), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[4]{0}, u32[4]{0}, u32[4]{0}, u32[4]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\004\000\000\000\000\000\000\000" + %get-tuple-element.47 = u32[4]{0} get-tuple-element((u32[4]{0}, u32[4]{0}) %custom-call.46), index=0 + %get-tuple-element.48 = u32[4]{0} get-tuple-element((u32[4]{0}, u32[4]{0}) %custom-call.46), index=1 + %concatenate.49 = u32[8]{0} concatenate(u32[4]{0} %get-tuple-element.47, u32[4]{0} %get-tuple-element.48), dimensions={0} + %reshape.50 = u32[4,2]{1,0} reshape(u32[8]{0} %concatenate.49) + %slice.53 = u32[1,2]{1,0} slice(u32[4,2]{1,0} %reshape.50), slice={[1:2], [0:2]} + %reshape.54 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.53) + %slice.57 = u32[1,2]{1,0} slice(u32[4,2]{1,0} %reshape.50), slice={[3:4], [0:2]} + %reshape.58 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.57) + %slice.51 = u32[1,2]{1,0} slice(u32[4,2]{1,0} %reshape.50), slice={[0:1], [0:2]} + %reshape.52 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.51) + %slice.60 = u32[1]{0} slice(u32[2]{0} %reshape.52), slice={[0:1]} + %reshape.61 = u32[] reshape(u32[1]{0} %slice.60) + %broadcast.66 = u32[2]{0} broadcast(u32[] %reshape.61), dimensions={} + %slice.62 = u32[1]{0} slice(u32[2]{0} %reshape.52), slice={[1:2]} + %reshape.63 = u32[] reshape(u32[1]{0} %slice.62) + %broadcast.67 = u32[2]{0} broadcast(u32[] %reshape.63), dimensions={} + %iota.59 = u32[4] iota(), iota_dimension=0 + %slice.64 = u32[2]{0} slice(u32[4] %iota.59), slice={[0:2]} + %broadcast.68 = u32[2]{0} broadcast(u32[2]{0} %slice.64), dimensions={0} + %slice.65 = u32[2]{0} slice(u32[4] %iota.59), slice={[2:4]} + %broadcast.69 = u32[2]{0} broadcast(u32[2]{0} %slice.65), dimensions={0} + %custom-call.70 = (u32[2]{0}, u32[2]{0}) custom-call(u32[2]{0} %broadcast.66, u32[2]{0} %broadcast.67, u32[2]{0} %broadcast.68, u32[2]{0} %broadcast.69), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[2]{0}, u32[2]{0}, u32[2]{0}, u32[2]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\002\000\000\000\000\000\000\000" + %get-tuple-element.71 = u32[2]{0} get-tuple-element((u32[2]{0}, u32[2]{0}) %custom-call.70), index=0 + %get-tuple-element.72 = u32[2]{0} get-tuple-element((u32[2]{0}, u32[2]{0}) %custom-call.70), index=1 + %concatenate.73 = u32[4]{0} concatenate(u32[2]{0} %get-tuple-element.71, u32[2]{0} %get-tuple-element.72), dimensions={0} + %reshape.74 = u32[2,2]{1,0} reshape(u32[4]{0} %concatenate.73) + %slice.77 = u32[1,2]{1,0} slice(u32[2,2]{1,0} %reshape.74), slice={[1:2], [0:2]} + %reshape.78 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.77) + %slice.75 = u32[1,2]{1,0} slice(u32[2,2]{1,0} %reshape.74), slice={[0:1], [0:2]} + %reshape.76 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.75) + %slice.88 = u32[1]{0} slice(u32[2]{0} %reshape.76), slice={[0:1]} + %reshape.89 = u32[] reshape(u32[1]{0} %slice.88) + %broadcast.94 = u32[3]{0} broadcast(u32[] %reshape.89), dimensions={} + %slice.90 = u32[1]{0} slice(u32[2]{0} %reshape.76), slice={[1:2]} + %reshape.91 = u32[] reshape(u32[1]{0} %slice.90) + %broadcast.95 = u32[3]{0} broadcast(u32[] %reshape.91), dimensions={} + %iota.87 = u32[6] iota(), iota_dimension=0 + %slice.92 = u32[3]{0} slice(u32[6] %iota.87), slice={[0:3]} + %broadcast.96 = u32[3]{0} broadcast(u32[3]{0} %slice.92), dimensions={0} + %slice.93 = u32[3]{0} slice(u32[6] %iota.87), slice={[3:6]} + %broadcast.97 = u32[3]{0} broadcast(u32[3]{0} %slice.93), dimensions={0} + %custom-call.98 = (u32[3]{0}, u32[3]{0}) custom-call(u32[3]{0} %broadcast.94, u32[3]{0} %broadcast.95, u32[3]{0} %broadcast.96, u32[3]{0} %broadcast.97), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[3]{0}, u32[3]{0}, u32[3]{0}, u32[3]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\003\000\000\000\000\000\000\000" + %get-tuple-element.99 = u32[3]{0} get-tuple-element((u32[3]{0}, u32[3]{0}) %custom-call.98), index=0 + %get-tuple-element.100 = u32[3]{0} get-tuple-element((u32[3]{0}, u32[3]{0}) %custom-call.98), index=1 + %concatenate.101 = u32[6]{0} concatenate(u32[3]{0} %get-tuple-element.99, u32[3]{0} %get-tuple-element.100), dimensions={0} + %reshape.102 = u32[3,2]{1,0} reshape(u32[6]{0} %concatenate.101) + %slice.103 = u32[1,2]{1,0} slice(u32[3,2]{1,0} %reshape.102), slice={[0:1], [0:2]} + %reshape.104 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.103) + %slice.107 = u32[1,2]{1,0} slice(u32[3,2]{1,0} %reshape.102), slice={[2:3], [0:2]} + %reshape.108 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.107) + %iota.153 = u32[4] iota(), iota_dimension=0 + %slice.154 = u32[2]{0} slice(u32[4] %iota.153), slice={[0:2]} + %slice.155 = u32[2]{0} slice(u32[4] %iota.153), slice={[2:4]} + %iota.156 = u32[8] iota(), iota_dimension=0 + %slice.157 = u32[4]{0} slice(u32[8] %iota.156), slice={[0:4]} + %slice.158 = u32[4]{0} slice(u32[8] %iota.156), slice={[4:8]} + %constant.160 = pred[] constant(false) + %constant.161 = pred[] constant(false) + %constant.162 = pred[] constant(false) + %constant.163 = pred[] constant(false) + %constant.164 = pred[] constant(false) + %constant.165 = pred[] constant(false) + %constant.166 = pred[] constant(false) + %constant.167 = pred[] constant(false) + %constant.168 = pred[] constant(false) + %slice.105 = u32[1,2]{1,0} slice(u32[3,2]{1,0} %reshape.102), slice={[1:2], [0:2]} + %reshape.106 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.105) + %slice.138 = u32[1]{0} slice(u32[2]{0} %reshape.106), slice={[0:1]} + %reshape.139 = u32[] reshape(u32[1]{0} %slice.138) + %broadcast.144 = u32[2]{0} broadcast(u32[] %reshape.139), dimensions={} + %slice.140 = u32[1]{0} slice(u32[2]{0} %reshape.106), slice={[1:2]} + %reshape.141 = u32[] reshape(u32[1]{0} %slice.140) + %broadcast.145 = u32[2]{0} broadcast(u32[] %reshape.141), dimensions={} + %iota.137 = u32[4] iota(), iota_dimension=0 + %slice.142 = u32[2]{0} slice(u32[4] %iota.137), slice={[0:2]} + %broadcast.146 = u32[2]{0} broadcast(u32[2]{0} %slice.142), dimensions={0} + %slice.143 = u32[2]{0} slice(u32[4] %iota.137), slice={[2:4]} + %broadcast.147 = u32[2]{0} broadcast(u32[2]{0} %slice.143), dimensions={0} + %custom-call.148 = (u32[2]{0}, u32[2]{0}) custom-call(u32[2]{0} %broadcast.144, u32[2]{0} %broadcast.145, u32[2]{0} %broadcast.146, u32[2]{0} %broadcast.147), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[2]{0}, u32[2]{0}, u32[2]{0}, u32[2]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\002\000\000\000\000\000\000\000" + %get-tuple-element.149 = u32[2]{0} get-tuple-element((u32[2]{0}, u32[2]{0}) %custom-call.148), index=0 + %get-tuple-element.150 = u32[2]{0} get-tuple-element((u32[2]{0}, u32[2]{0}) %custom-call.148), index=1 + %concatenate.151 = u32[4]{0} concatenate(u32[2]{0} %get-tuple-element.149, u32[2]{0} %get-tuple-element.150), dimensions={0} + %reshape.152 = u32[2,2]{1,0} reshape(u32[4]{0} %concatenate.151) + %parameter.1 = f32[2,16]{1,0} parameter(0) + %parameter.2 = f32[2,16]{1,0} parameter(1) + %parameter.3 = f32[2,3,3,8,16]{4,3,2,1,0} parameter(2) + %parameter.4 = f32[2,16]{1,0} parameter(3) + %parameter.5 = f32[2,16]{1,0} parameter(4) + %parameter.6 = f32[2,1,1,16,16]{4,3,2,1,0} parameter(5) + %parameter.7 = f32[2,8]{1,0} parameter(6) + %parameter.8 = f32[2,8]{1,0} parameter(7) + %constant.239 = s32[] constant(0) + %parameter.32 = f32[16,32,32,3]{3,2,1,0} parameter(31) + %constant.83 = s32[] constant(1) + %broadcast.84 = s32[1]{0} broadcast(s32[] %constant.83), dimensions={} + %gather.85 = f32[16,32,32,2]{3,2,1,0} gather(f32[16,32,32,3]{3,2,1,0} %parameter.32, s32[1]{0} %broadcast.84), offset_dims={0,1,2,3}, collapsed_slice_dims={}, start_index_map={3}, index_vector_dim=0, slice_sizes={16,32,32,2}, indices_are_sorted=true + %broadcast.86 = f32[16,32,32,2]{3,2,1,0} broadcast(f32[16,32,32,2]{3,2,1,0} %gather.85), dimensions={0,1,2,3} + %parameter.11 = f32[1,1,2,8]{3,2,1,0} parameter(10) + %multiply.109 = f32[1,1,2,8]{3,2,1,0} multiply(f32[1,1,2,8]{3,2,1,0} %parameter.11, f32[1,1,2,8]{3,2,1,0} %parameter.11) + %constant.113 = f32[] constant(0) + %reduce.118 = f32[8]{0} reduce(f32[1,1,2,8]{3,2,1,0} %multiply.109, f32[] %constant.113), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.114 + %rsqrt.119 = f32[8]{0} rsqrt(f32[8]{0} %reduce.118) + %broadcast.124 = f32[1,1,1,8]{3,2,1,0} broadcast(f32[8]{0} %rsqrt.119), dimensions={3} + %reshape.125 = f32[1,1,8]{2,1,0} reshape(f32[1,1,1,8]{3,2,1,0} %broadcast.124) + %broadcast.126 = f32[1,1,2,8]{3,2,1,0} broadcast(f32[1,1,8]{2,1,0} %reshape.125), dimensions={0,1,3} + %multiply.127 = f32[1,1,2,8]{3,2,1,0} multiply(f32[1,1,2,8]{3,2,1,0} %parameter.11, f32[1,1,2,8]{3,2,1,0} %broadcast.126) + %convolution.128 = f32[16,32,32,8]{3,2,1,0} convolution(f32[16,32,32,2]{3,2,1,0} %broadcast.86, f32[1,1,2,8]{3,2,1,0} %multiply.127), window={size=1x1}, dim_labels=b01f_01io->b01f + %parameter.10 = f32[8]{0} parameter(9) + %broadcast.129 = f32[1,1,1,8]{3,2,1,0} broadcast(f32[8]{0} %parameter.10), dimensions={3} + %reshape.130 = f32[8]{0} reshape(f32[1,1,1,8]{3,2,1,0} %broadcast.129) + %broadcast.131 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[8]{0} %reshape.130), dimensions={3} + %multiply.132 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %convolution.128, f32[16,32,32,8]{3,2,1,0} %broadcast.131) + %parameter.9 = f32[8]{0} parameter(8) + %broadcast.133 = f32[1,1,1,8]{3,2,1,0} broadcast(f32[8]{0} %parameter.9), dimensions={3} + %reshape.134 = f32[8]{0} reshape(f32[1,1,1,8]{3,2,1,0} %broadcast.133) + %broadcast.135 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[8]{0} %reshape.134), dimensions={3} + %add.136 = f32[16,32,32,8]{3,2,1,0} add(f32[16,32,32,8]{3,2,1,0} %multiply.132, f32[16,32,32,8]{3,2,1,0} %broadcast.135) + %constant.159 = pred[] constant(false) + %constant.240 = pred[] constant(false) + %constant.241 = pred[] constant(false) + %constant.242 = pred[] constant(false) + %constant.243 = pred[] constant(false) + %constant.244 = pred[] constant(false) + %constant.245 = pred[] constant(false) + %constant.246 = pred[] constant(false) + %constant.247 = pred[] constant(false) + %constant.169 = f32[] constant(0) + %broadcast.170 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.169), dimensions={} + %constant.171 = f32[] constant(0) + %broadcast.172 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.171), dimensions={} + %constant.173 = f32[] constant(0) + %broadcast.174 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.173), dimensions={} + %constant.175 = f32[] constant(0) + %broadcast.176 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.175), dimensions={} + %constant.177 = f32[] constant(0) + %broadcast.178 = f32[2,3,3,8,16]{4,3,2,1,0} broadcast(f32[] %constant.177), dimensions={} + %constant.179 = f32[] constant(0) + %broadcast.180 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.179), dimensions={} + %constant.181 = f32[] constant(0) + %broadcast.182 = f32[2,1,1,1,16]{4,3,2,1,0} broadcast(f32[] %constant.181), dimensions={} + %constant.183 = f32[] constant(0) + %broadcast.184 = f32[2,3,3,8,16]{4,3,2,1,0} broadcast(f32[] %constant.183), dimensions={} + %constant.185 = f32[] constant(0) + %broadcast.186 = f32[2,16]{1,0} broadcast(f32[] %constant.185), dimensions={} + %constant.187 = f32[] constant(0) + %broadcast.188 = f32[2,1,1,1,16]{4,3,2,1,0} broadcast(f32[] %constant.187), dimensions={} + %constant.189 = f32[] constant(0) + %broadcast.190 = f32[2,16,32,32,16]{4,3,2,1,0} broadcast(f32[] %constant.189), dimensions={} + %constant.191 = f32[] constant(0) + %broadcast.192 = f32[2,16,32,32,16]{4,3,2,1,0} broadcast(f32[] %constant.191), dimensions={} + %constant.193 = f32[] constant(0) + %broadcast.194 = f32[2,16,32,32,16]{4,3,2,1,0} broadcast(f32[] %constant.193), dimensions={} + %constant.195 = f32[] constant(0) + %broadcast.196 = f32[2,16,32,32,16]{4,3,2,1,0} broadcast(f32[] %constant.195), dimensions={} + %constant.197 = f32[] constant(0) + %broadcast.198 = f32[2,16,32,32,16]{4,3,2,1,0} broadcast(f32[] %constant.197), dimensions={} + %constant.199 = f32[] constant(0) + %broadcast.200 = f32[2,1,1,16,16]{4,3,2,1,0} broadcast(f32[] %constant.199), dimensions={} + %constant.201 = f32[] constant(0) + %broadcast.202 = f32[2,16,32,32,16]{4,3,2,1,0} broadcast(f32[] %constant.201), dimensions={} + %constant.203 = f32[] constant(0) + %broadcast.204 = f32[2,1,1,1,16]{4,3,2,1,0} broadcast(f32[] %constant.203), dimensions={} + %constant.205 = f32[] constant(0) + %broadcast.206 = f32[2,1,1,16,16]{4,3,2,1,0} broadcast(f32[] %constant.205), dimensions={} + %constant.207 = f32[] constant(0) + %broadcast.208 = f32[2,16]{1,0} broadcast(f32[] %constant.207), dimensions={} + %constant.209 = f32[] constant(0) + %broadcast.210 = f32[2,1,1,1,16]{4,3,2,1,0} broadcast(f32[] %constant.209), dimensions={} + %constant.211 = f32[] constant(0) + %broadcast.212 = f32[2,16,32,32,16]{4,3,2,1,0} broadcast(f32[] %constant.211), dimensions={} + %constant.213 = f32[] constant(0) + %broadcast.214 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.213), dimensions={} + %constant.215 = f32[] constant(0) + %broadcast.216 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.215), dimensions={} + %constant.217 = f32[] constant(0) + %broadcast.218 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.217), dimensions={} + %constant.219 = f32[] constant(0) + %broadcast.220 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.219), dimensions={} + %constant.221 = f32[] constant(0) + %broadcast.222 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.221), dimensions={} + %constant.223 = f32[] constant(0) + %broadcast.224 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.223), dimensions={} + %constant.225 = f32[] constant(0) + %broadcast.226 = f32[2,16,1,1,8]{4,3,2,1,0} broadcast(f32[] %constant.225), dimensions={} + %constant.227 = f32[] constant(0) + %broadcast.228 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.227), dimensions={} + %constant.229 = f32[] constant(0) + %broadcast.230 = f32[2,16,1024,8]{3,2,1,0} broadcast(f32[] %constant.229), dimensions={} + %constant.231 = f32[] constant(0) + %broadcast.232 = f32[2,16,8]{2,1,0} broadcast(f32[] %constant.231), dimensions={} + %constant.233 = f32[] constant(0) + %broadcast.234 = f32[2,16,8]{2,1,0} broadcast(f32[] %constant.233), dimensions={} + %constant.235 = f32[] constant(0) + %broadcast.236 = f32[2,1,1,1,8]{4,3,2,1,0} broadcast(f32[] %constant.235), dimensions={} + %constant.237 = f32[] constant(0) + %broadcast.238 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.237), dimensions={} + %tuple.248 = (u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) tuple(u32[2,2]{1,0} %reshape.152, f32[2,16]{1,0} %parameter.1, f32[2,16]{1,0} %parameter.2, f32[2,3,3,8,16]{4,3,2,1,0} %parameter.3, f32[2,16]{1,0} %parameter.4, /*index=5*/f32[2,16]{1,0} %parameter.5, f32[2,1,1,16,16]{4,3,2,1,0} %parameter.6, f32[2,8]{1,0} %parameter.7, f32[2,8]{1,0} %parameter.8, s32[] %constant.239, /*index=10*/f32[16,32,32,8]{3,2,1,0} %add.136, pred[] %constant.159, pred[] %constant.240, pred[] %constant.241, pred[] %constant.242, /*index=15*/pred[] %constant.243, pred[] %constant.244, pred[] %constant.245, pred[] %constant.246, pred[] %constant.247, /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.170, f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.172, f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.174, f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.176, f32[2,3,3,8,16]{4,3,2,1,0} %broadcast.178, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.180, f32[2,1,1,1,16]{4,3,2,1,0} %broadcast.182, f32[2,3,3,8,16]{4,3,2,1,0} %broadcast.184, f32[2,16]{1,0} %broadcast.186, f32[2,1,1,1,16]{4,3,2,1,0} %broadcast.188, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0} %broadcast.190, f32[2,16,32,32,16]{4,3,2,1,0} %broadcast.192, f32[2,16,32,32,16]{4,3,2,1,0} %broadcast.194, f32[2,16,32,32,16]{4,3,2,1,0} %broadcast.196, f32[2,16,32,32,16]{4,3,2,1,0} %broadcast.198, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0} %broadcast.200, f32[2,16,32,32,16]{4,3,2,1,0} %broadcast.202, f32[2,1,1,1,16]{4,3,2,1,0} %broadcast.204, f32[2,1,1,16,16]{4,3,2,1,0} %broadcast.206, f32[2,16]{1,0} %broadcast.208, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0} %broadcast.210, f32[2,16,32,32,16]{4,3,2,1,0} %broadcast.212, f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.214, f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.216, f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.218, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.220, f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.222, f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.224, f32[2,16,1,1,8]{4,3,2,1,0} %broadcast.226, f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.228, /*index=50*/f32[2,16,1024,8]{3,2,1,0} %broadcast.230, f32[2,16,8]{2,1,0} %broadcast.232, f32[2,16,8]{2,1,0} %broadcast.234, f32[2,1,1,1,8]{4,3,2,1,0} %broadcast.236, f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.238) + %while.2004 = (u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) while((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.248), condition=%cond_computation.1944, body=%body_computation.265 + %get-tuple-element.2005 = u32[2,2]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=0 + %get-tuple-element.2006 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=1 + %get-tuple-element.2007 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=2 + %get-tuple-element.2008 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=3 + %get-tuple-element.2009 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=4 + %get-tuple-element.2010 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=5 + %get-tuple-element.2011 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=6 + %get-tuple-element.2012 = f32[2,8]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=7 + %get-tuple-element.2013 = f32[2,8]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=8 + %get-tuple-element.2014 = s32[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=9 + %get-tuple-element.2015 = f32[16,32,32,8]{3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=10 + %get-tuple-element.2016 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=11 + %get-tuple-element.2017 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=12 + %get-tuple-element.2018 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=13 + %get-tuple-element.2019 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=14 + %get-tuple-element.2020 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=15 + %get-tuple-element.2021 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=16 + %get-tuple-element.2022 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=17 + %get-tuple-element.2023 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=18 + %get-tuple-element.2024 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=19 + %get-tuple-element.2025 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=20 + %get-tuple-element.2026 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=21 + %get-tuple-element.2027 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=22 + %get-tuple-element.2028 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=23 + %get-tuple-element.2029 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=24 + %get-tuple-element.2030 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=25 + %get-tuple-element.2031 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=26 + %get-tuple-element.2032 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=27 + %get-tuple-element.2033 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=28 + %get-tuple-element.2034 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=29 + %get-tuple-element.2035 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=30 + %get-tuple-element.2036 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=31 + %get-tuple-element.2037 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=32 + %get-tuple-element.2038 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=33 + %get-tuple-element.2039 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=34 + %get-tuple-element.2040 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=35 + %get-tuple-element.2041 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=36 + %get-tuple-element.2042 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=37 + %get-tuple-element.2043 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=38 + %get-tuple-element.2044 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=39 + %get-tuple-element.2045 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=40 + %get-tuple-element.2046 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=41 + %get-tuple-element.2047 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=42 + %get-tuple-element.2048 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=43 + %get-tuple-element.2049 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=44 + %get-tuple-element.2050 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=45 + %get-tuple-element.2051 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=46 + %get-tuple-element.2052 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=47 + %get-tuple-element.2053 = f32[2,16,1,1,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=48 + %get-tuple-element.2054 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=49 + %get-tuple-element.2055 = f32[2,16,1024,8]{3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=50 + %get-tuple-element.2056 = f32[2,16,8]{2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=51 + %get-tuple-element.2057 = f32[2,16,8]{2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=52 + %get-tuple-element.2058 = f32[2,1,1,1,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=53 + %get-tuple-element.2059 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.2004), index=54 + %tuple.2060 = (s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) tuple(s32[] %get-tuple-element.2014, f32[16,32,32,8]{3,2,1,0} %get-tuple-element.2015, pred[] %get-tuple-element.2016, pred[] %get-tuple-element.2017, pred[] %get-tuple-element.2018, /*index=5*/pred[] %get-tuple-element.2019, pred[] %get-tuple-element.2020, pred[] %get-tuple-element.2021, pred[] %get-tuple-element.2022, pred[] %get-tuple-element.2023, /*index=10*/pred[] %get-tuple-element.2024, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2025, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2026, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2027, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2028, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.2029, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2030, f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.2031, f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.2032, f32[2,16]{1,0} %get-tuple-element.2033, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.2034, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2035, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2036, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2037, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2038, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2039, f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.2040, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2041, f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.2042, f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.2043, /*index=30*/f32[2,16]{1,0} %get-tuple-element.2044, f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.2045, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2046, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2047, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2048, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2049, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2050, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2051, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2052, f32[2,16,1,1,8]{4,3,2,1,0} %get-tuple-element.2053, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2054, f32[2,16,1024,8]{3,2,1,0} %get-tuple-element.2055, f32[2,16,8]{2,1,0} %get-tuple-element.2056, f32[2,16,8]{2,1,0} %get-tuple-element.2057, f32[2,1,1,1,8]{4,3,2,1,0} %get-tuple-element.2058, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2059) + %get-tuple-element.2061 = s32[] get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=0 + %get-tuple-element.2062 = f32[16,32,32,8]{3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=1 + %get-tuple-element.2063 = pred[] get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=2 + %get-tuple-element.2064 = pred[] get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=3 + %get-tuple-element.2065 = pred[] get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=4 + %get-tuple-element.2066 = pred[] get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=5 + %get-tuple-element.2067 = pred[] get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=6 + %get-tuple-element.2068 = pred[] get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=7 + %get-tuple-element.2069 = pred[] get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=8 + %get-tuple-element.2070 = pred[] get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=9 + %get-tuple-element.2071 = pred[] get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=10 + %get-tuple-element.2072 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=11 + %get-tuple-element.2073 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=12 + %get-tuple-element.2074 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=13 + %get-tuple-element.2075 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=14 + %get-tuple-element.2076 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=15 + %get-tuple-element.2077 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=16 + %get-tuple-element.2078 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=17 + %get-tuple-element.2079 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=18 + %get-tuple-element.2080 = f32[2,16]{1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=19 + %get-tuple-element.2081 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=20 + %get-tuple-element.2082 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=21 + %get-tuple-element.2083 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=22 + %get-tuple-element.2084 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=23 + %get-tuple-element.2085 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=24 + %get-tuple-element.2086 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=25 + %get-tuple-element.2087 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=26 + %get-tuple-element.2088 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=27 + %get-tuple-element.2089 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=28 + %get-tuple-element.2090 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=29 + %get-tuple-element.2091 = f32[2,16]{1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=30 + %get-tuple-element.2092 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=31 + %get-tuple-element.2093 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=32 + %get-tuple-element.2094 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=33 + %get-tuple-element.2095 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=34 + %get-tuple-element.2096 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=35 + %get-tuple-element.2097 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=36 + %get-tuple-element.2098 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=37 + %get-tuple-element.2099 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=38 + %get-tuple-element.2100 = f32[2,16,1,1,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=39 + %get-tuple-element.2101 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=40 + %get-tuple-element.2102 = f32[2,16,1024,8]{3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=41 + %get-tuple-element.2103 = f32[2,16,8]{2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=42 + %get-tuple-element.2104 = f32[2,16,8]{2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=43 + %get-tuple-element.2105 = f32[2,1,1,1,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=44 + %get-tuple-element.2106 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2060), index=45 + %tuple.2107 = (f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) tuple(f32[16,32,32,8]{3,2,1,0} %get-tuple-element.2062, pred[] %get-tuple-element.2063, pred[] %get-tuple-element.2064, pred[] %get-tuple-element.2065, pred[] %get-tuple-element.2066, /*index=5*/pred[] %get-tuple-element.2067, pred[] %get-tuple-element.2068, pred[] %get-tuple-element.2069, pred[] %get-tuple-element.2070, pred[] %get-tuple-element.2071, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2072, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2073, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2074, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2075, f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.2076, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2077, f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.2078, f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.2079, f32[2,16]{1,0} %get-tuple-element.2080, f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.2081, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2082, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2083, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2084, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2085, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2086, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.2087, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2088, f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.2089, f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.2090, f32[2,16]{1,0} %get-tuple-element.2091, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.2092, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2093, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2094, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2095, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2096, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2097, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2098, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2099, f32[2,16,1,1,8]{4,3,2,1,0} %get-tuple-element.2100, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2101, /*index=40*/f32[2,16,1024,8]{3,2,1,0} %get-tuple-element.2102, f32[2,16,8]{2,1,0} %get-tuple-element.2103, f32[2,16,8]{2,1,0} %get-tuple-element.2104, f32[2,1,1,1,8]{4,3,2,1,0} %get-tuple-element.2105, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2106) + %get-tuple-element.2109 = pred[] get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=1 + %get-tuple-element.2110 = pred[] get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=2 + %get-tuple-element.2111 = pred[] get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=3 + %get-tuple-element.2112 = pred[] get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=4 + %get-tuple-element.2113 = pred[] get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=5 + %get-tuple-element.2114 = pred[] get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=6 + %get-tuple-element.2115 = pred[] get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=7 + %get-tuple-element.2116 = pred[] get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=8 + %get-tuple-element.2117 = pred[] get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=9 + %constant.2236 = f32[] constant(0) + %broadcast.2237 = f32[16,32,32,2]{3,2,1,0} broadcast(f32[] %constant.2236), dimensions={} + %constant.2243 = pred[] constant(false) + %parameter.16 = f32[3,3]{1,0} parameter(15) + %call.2387 = (f32[], f32[]) call(f32[3,3]{1,0} %parameter.16), to_apply=%jit_slogdet__1.2302 + %get-tuple-element.2388 = f32[] get-tuple-element((f32[], f32[]) %call.2387), index=0 + %get-tuple-element.2389 = f32[] get-tuple-element((f32[], f32[]) %call.2387), index=1 + %tuple.2390 = (f32[], f32[]) tuple(f32[] %get-tuple-element.2388, f32[] %get-tuple-element.2389) + %get-tuple-element.2391 = f32[] get-tuple-element((f32[], f32[]) %tuple.2390), index=0 + %constant.2393 = pred[] constant(false) + %call.2424 = (pred[], f32[3,3]{1,0}, f32[3,3]{1,0}, s32[3]{0}) call(f32[3,3]{1,0} %parameter.16, pred[] %constant.2393), to_apply=%jit_solve.2394 + %get-tuple-element.2425 = pred[] get-tuple-element((pred[], f32[3,3]{1,0}, f32[3,3]{1,0}, s32[3]{0}) %call.2424), index=0 + %iota.2429 = s32[3,3] iota(), iota_dimension=0 + %constant.2430 = s32[] constant(0) + %broadcast.2431 = s32[3,3]{1,0} broadcast(s32[] %constant.2430), dimensions={} + %add.2432 = s32[3,3]{1,0} add(s32[3,3] %iota.2429, s32[3,3]{1,0} %broadcast.2431) + %iota.2433 = s32[3,3] iota(), iota_dimension=1 + %compare.2434 = pred[3,3]{1,0} compare(s32[3,3]{1,0} %add.2432, s32[3,3] %iota.2433), direction=EQ + %convert.2435 = pred[3,3]{1,0} convert(pred[3,3]{1,0} %compare.2434) + %constant.2438 = pred[] constant(false) + %constant.2436 = f32[] constant(0) + %broadcast.2437 = f32[3,3]{1,0} broadcast(f32[] %constant.2436), dimensions={} + %call.2446 = (pred[], pred[3,3]{1,0}, f32[3,3]{1,0}) call(pred[3,3]{1,0} %convert.2435, pred[] %constant.2438, f32[3,3]{1,0} %broadcast.2437), to_apply=%jit__where__6.2439 + %get-tuple-element.2447 = pred[] get-tuple-element((pred[], pred[3,3]{1,0}, f32[3,3]{1,0}) %call.2446), index=0 + %slice.55 = u32[1,2]{1,0} slice(u32[4,2]{1,0} %reshape.50), slice={[2:3], [0:2]} + %reshape.56 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.55) + %slice.2460 = u32[1]{0} slice(u32[2]{0} %reshape.56), slice={[0:1]} + %reshape.2461 = u32[] reshape(u32[1]{0} %slice.2460) + %broadcast.2466 = u32[2]{0} broadcast(u32[] %reshape.2461), dimensions={} + %slice.2462 = u32[1]{0} slice(u32[2]{0} %reshape.56), slice={[1:2]} + %reshape.2463 = u32[] reshape(u32[1]{0} %slice.2462) + %broadcast.2467 = u32[2]{0} broadcast(u32[] %reshape.2463), dimensions={} + %iota.2459 = u32[4] iota(), iota_dimension=0 + %slice.2464 = u32[2]{0} slice(u32[4] %iota.2459), slice={[0:2]} + %broadcast.2468 = u32[2]{0} broadcast(u32[2]{0} %slice.2464), dimensions={0} + %slice.2465 = u32[2]{0} slice(u32[4] %iota.2459), slice={[2:4]} + %broadcast.2469 = u32[2]{0} broadcast(u32[2]{0} %slice.2465), dimensions={0} + %custom-call.2470 = (u32[2]{0}, u32[2]{0}) custom-call(u32[2]{0} %broadcast.2466, u32[2]{0} %broadcast.2467, u32[2]{0} %broadcast.2468, u32[2]{0} %broadcast.2469), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[2]{0}, u32[2]{0}, u32[2]{0}, u32[2]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\002\000\000\000\000\000\000\000" + %get-tuple-element.2471 = u32[2]{0} get-tuple-element((u32[2]{0}, u32[2]{0}) %custom-call.2470), index=0 + %get-tuple-element.2472 = u32[2]{0} get-tuple-element((u32[2]{0}, u32[2]{0}) %custom-call.2470), index=1 + %concatenate.2473 = u32[4]{0} concatenate(u32[2]{0} %get-tuple-element.2471, u32[2]{0} %get-tuple-element.2472), dimensions={0} + %reshape.2474 = u32[2,2]{1,0} reshape(u32[4]{0} %concatenate.2473) + %slice.2477 = u32[1,2]{1,0} slice(u32[2,2]{1,0} %reshape.2474), slice={[1:2], [0:2]} + %reshape.2478 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.2477) + %slice.2475 = u32[1,2]{1,0} slice(u32[2,2]{1,0} %reshape.2474), slice={[0:1], [0:2]} + %reshape.2476 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.2475) + %slice.2488 = u32[1]{0} slice(u32[2]{0} %reshape.2476), slice={[0:1]} + %reshape.2489 = u32[] reshape(u32[1]{0} %slice.2488) + %broadcast.2494 = u32[3]{0} broadcast(u32[] %reshape.2489), dimensions={} + %slice.2490 = u32[1]{0} slice(u32[2]{0} %reshape.2476), slice={[1:2]} + %reshape.2491 = u32[] reshape(u32[1]{0} %slice.2490) + %broadcast.2495 = u32[3]{0} broadcast(u32[] %reshape.2491), dimensions={} + %iota.2487 = u32[6] iota(), iota_dimension=0 + %slice.2492 = u32[3]{0} slice(u32[6] %iota.2487), slice={[0:3]} + %broadcast.2496 = u32[3]{0} broadcast(u32[3]{0} %slice.2492), dimensions={0} + %slice.2493 = u32[3]{0} slice(u32[6] %iota.2487), slice={[3:6]} + %broadcast.2497 = u32[3]{0} broadcast(u32[3]{0} %slice.2493), dimensions={0} + %custom-call.2498 = (u32[3]{0}, u32[3]{0}) custom-call(u32[3]{0} %broadcast.2494, u32[3]{0} %broadcast.2495, u32[3]{0} %broadcast.2496, u32[3]{0} %broadcast.2497), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[3]{0}, u32[3]{0}, u32[3]{0}, u32[3]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\003\000\000\000\000\000\000\000" + %get-tuple-element.2499 = u32[3]{0} get-tuple-element((u32[3]{0}, u32[3]{0}) %custom-call.2498), index=0 + %get-tuple-element.2500 = u32[3]{0} get-tuple-element((u32[3]{0}, u32[3]{0}) %custom-call.2498), index=1 + %concatenate.2501 = u32[6]{0} concatenate(u32[3]{0} %get-tuple-element.2499, u32[3]{0} %get-tuple-element.2500), dimensions={0} + %reshape.2502 = u32[3,2]{1,0} reshape(u32[6]{0} %concatenate.2501) + %slice.2503 = u32[1,2]{1,0} slice(u32[3,2]{1,0} %reshape.2502), slice={[0:1], [0:2]} + %reshape.2504 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.2503) + %slice.2507 = u32[1,2]{1,0} slice(u32[3,2]{1,0} %reshape.2502), slice={[2:3], [0:2]} + %reshape.2508 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.2507) + %iota.2553 = u32[4] iota(), iota_dimension=0 + %slice.2554 = u32[2]{0} slice(u32[4] %iota.2553), slice={[0:2]} + %slice.2555 = u32[2]{0} slice(u32[4] %iota.2553), slice={[2:4]} + %iota.2556 = u32[8] iota(), iota_dimension=0 + %slice.2557 = u32[4]{0} slice(u32[8] %iota.2556), slice={[0:4]} + %slice.2558 = u32[4]{0} slice(u32[8] %iota.2556), slice={[4:8]} + %constant.2560 = pred[] constant(false) + %constant.2561 = pred[] constant(false) + %constant.2562 = pred[] constant(false) + %constant.2563 = pred[] constant(false) + %constant.2564 = pred[] constant(false) + %constant.2565 = pred[] constant(false) + %constant.2566 = pred[] constant(false) + %constant.2567 = pred[] constant(false) + %constant.2568 = pred[] constant(false) + %slice.2505 = u32[1,2]{1,0} slice(u32[3,2]{1,0} %reshape.2502), slice={[1:2], [0:2]} + %reshape.2506 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.2505) + %slice.2538 = u32[1]{0} slice(u32[2]{0} %reshape.2506), slice={[0:1]} + %reshape.2539 = u32[] reshape(u32[1]{0} %slice.2538) + %broadcast.2544 = u32[2]{0} broadcast(u32[] %reshape.2539), dimensions={} + %slice.2540 = u32[1]{0} slice(u32[2]{0} %reshape.2506), slice={[1:2]} + %reshape.2541 = u32[] reshape(u32[1]{0} %slice.2540) + %broadcast.2545 = u32[2]{0} broadcast(u32[] %reshape.2541), dimensions={} + %iota.2537 = u32[4] iota(), iota_dimension=0 + %slice.2542 = u32[2]{0} slice(u32[4] %iota.2537), slice={[0:2]} + %broadcast.2546 = u32[2]{0} broadcast(u32[2]{0} %slice.2542), dimensions={0} + %slice.2543 = u32[2]{0} slice(u32[4] %iota.2537), slice={[2:4]} + %broadcast.2547 = u32[2]{0} broadcast(u32[2]{0} %slice.2543), dimensions={0} + %custom-call.2548 = (u32[2]{0}, u32[2]{0}) custom-call(u32[2]{0} %broadcast.2544, u32[2]{0} %broadcast.2545, u32[2]{0} %broadcast.2546, u32[2]{0} %broadcast.2547), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[2]{0}, u32[2]{0}, u32[2]{0}, u32[2]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\002\000\000\000\000\000\000\000" + %get-tuple-element.2549 = u32[2]{0} get-tuple-element((u32[2]{0}, u32[2]{0}) %custom-call.2548), index=0 + %get-tuple-element.2550 = u32[2]{0} get-tuple-element((u32[2]{0}, u32[2]{0}) %custom-call.2548), index=1 + %concatenate.2551 = u32[4]{0} concatenate(u32[2]{0} %get-tuple-element.2549, u32[2]{0} %get-tuple-element.2550), dimensions={0} + %reshape.2552 = u32[2,2]{1,0} reshape(u32[4]{0} %concatenate.2551) + %parameter.17 = f32[2,16]{1,0} parameter(16) + %parameter.18 = f32[2,16]{1,0} parameter(17) + %parameter.19 = f32[2,3,3,8,16]{4,3,2,1,0} parameter(18) + %parameter.20 = f32[2,16]{1,0} parameter(19) + %parameter.21 = f32[2,16]{1,0} parameter(20) + %parameter.22 = f32[2,1,1,16,16]{4,3,2,1,0} parameter(21) + %parameter.23 = f32[2,8]{1,0} parameter(22) + %parameter.24 = f32[2,8]{1,0} parameter(23) + %constant.2639 = s32[] constant(0) + %constant.79 = s32[] constant(0) + %broadcast.80 = s32[1]{0} broadcast(s32[] %constant.79), dimensions={} + %gather.81 = f32[16,32,32,1]{3,2,1,0} gather(f32[16,32,32,3]{3,2,1,0} %parameter.32, s32[1]{0} %broadcast.80), offset_dims={0,1,2,3}, collapsed_slice_dims={}, start_index_map={3}, index_vector_dim=0, slice_sizes={16,32,32,1}, indices_are_sorted=true + %broadcast.82 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[16,32,32,1]{3,2,1,0} %gather.81), dimensions={0,1,2,3} + %get-tuple-element.2108 = f32[16,32,32,8]{3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=0 + %parameter.14 = f32[1,1,8,2]{3,2,1,0} parameter(13) + %multiply.2153 = f32[1,1,8,2]{3,2,1,0} multiply(f32[1,1,8,2]{3,2,1,0} %parameter.14, f32[1,1,8,2]{3,2,1,0} %parameter.14) + %constant.2157 = f32[] constant(0) + %reduce.2162 = f32[2]{0} reduce(f32[1,1,8,2]{3,2,1,0} %multiply.2153, f32[] %constant.2157), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.2158 + %rsqrt.2163 = f32[2]{0} rsqrt(f32[2]{0} %reduce.2162) + %broadcast.2168 = f32[1,1,1,2]{3,2,1,0} broadcast(f32[2]{0} %rsqrt.2163), dimensions={3} + %reshape.2169 = f32[1,1,2]{2,1,0} reshape(f32[1,1,1,2]{3,2,1,0} %broadcast.2168) + %broadcast.2170 = f32[1,1,8,2]{3,2,1,0} broadcast(f32[1,1,2]{2,1,0} %reshape.2169), dimensions={0,1,3} + %multiply.2171 = f32[1,1,8,2]{3,2,1,0} multiply(f32[1,1,8,2]{3,2,1,0} %parameter.14, f32[1,1,8,2]{3,2,1,0} %broadcast.2170) + %convolution.2172 = f32[16,32,32,2]{3,2,1,0} convolution(f32[16,32,32,8]{3,2,1,0} %get-tuple-element.2108, f32[1,1,8,2]{3,2,1,0} %multiply.2171), window={size=1x1}, dim_labels=b01f_01io->b01f + %parameter.13 = f32[2]{0} parameter(12) + %broadcast.2173 = f32[1,1,1,2]{3,2,1,0} broadcast(f32[2]{0} %parameter.13), dimensions={3} + %reshape.2174 = f32[2]{0} reshape(f32[1,1,1,2]{3,2,1,0} %broadcast.2173) + %broadcast.2175 = f32[16,32,32,2]{3,2,1,0} broadcast(f32[2]{0} %reshape.2174), dimensions={3} + %multiply.2176 = f32[16,32,32,2]{3,2,1,0} multiply(f32[16,32,32,2]{3,2,1,0} %convolution.2172, f32[16,32,32,2]{3,2,1,0} %broadcast.2175) + %parameter.12 = f32[2]{0} parameter(11) + %broadcast.2177 = f32[1,1,1,2]{3,2,1,0} broadcast(f32[2]{0} %parameter.12), dimensions={3} + %reshape.2178 = f32[2]{0} reshape(f32[1,1,1,2]{3,2,1,0} %broadcast.2177) + %broadcast.2179 = f32[16,32,32,2]{3,2,1,0} broadcast(f32[2]{0} %reshape.2178), dimensions={3} + %add.2180 = f32[16,32,32,2]{3,2,1,0} add(f32[16,32,32,2]{3,2,1,0} %multiply.2176, f32[16,32,32,2]{3,2,1,0} %broadcast.2179) + %parameter.15 = f32[] parameter(14) + %broadcast.2181 = f32[16,32,32,2]{3,2,1,0} broadcast(f32[] %parameter.15), dimensions={} + %multiply.2182 = f32[16,32,32,2]{3,2,1,0} multiply(f32[16,32,32,2]{3,2,1,0} %add.2180, f32[16,32,32,2]{3,2,1,0} %broadcast.2181) + %slice.2184 = f32[16,32,32,1]{3,2,1,0} slice(f32[16,32,32,2]{3,2,1,0} %multiply.2182), slice={[0:16], [0:32], [0:32], [1:2]} + %subtract.2222 = f32[16,32,32,1]{3,2,1,0} subtract(f32[16,32,32,1]{3,2,1,0} %broadcast.82, f32[16,32,32,1]{3,2,1,0} %slice.2184) + %slice.2183 = f32[16,32,32,1]{3,2,1,0} slice(f32[16,32,32,2]{3,2,1,0} %multiply.2182), slice={[0:16], [0:32], [0:32], [0:1]} + %multiply.2185 = f32[16,32,32,1]{3,2,1,0} multiply(f32[16,32,32,1]{3,2,1,0} %slice.2183, f32[16,32,32,1]{3,2,1,0} %slice.2183) + %constant.2189 = f32[] constant(4) + %broadcast.2190 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.2189), dimensions={} + %add.2191 = f32[16,32,32,1]{3,2,1,0} add(f32[16,32,32,1]{3,2,1,0} %multiply.2185, f32[16,32,32,1]{3,2,1,0} %broadcast.2190) + %sqrt.2192 = f32[16,32,32,1]{3,2,1,0} sqrt(f32[16,32,32,1]{3,2,1,0} %add.2191) + %add.2196 = f32[16,32,32,1]{3,2,1,0} add(f32[16,32,32,1]{3,2,1,0} %slice.2183, f32[16,32,32,1]{3,2,1,0} %sqrt.2192) + %constant.2197 = f32[] constant(0.5) + %broadcast.2198 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.2197), dimensions={} + %multiply.2199 = f32[16,32,32,1]{3,2,1,0} multiply(f32[16,32,32,1]{3,2,1,0} %add.2196, f32[16,32,32,1]{3,2,1,0} %broadcast.2198) + %constant.2200 = f32[] constant(0) + %broadcast.2201 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.2200), dimensions={} + %maximum.2202 = f32[16,32,32,1]{3,2,1,0} maximum(f32[16,32,32,1]{3,2,1,0} %multiply.2199, f32[16,32,32,1]{3,2,1,0} %broadcast.2201) + %constant.2218 = f32[] constant(0.0001) + %broadcast.2219 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.2218), dimensions={} + %add.2220 = f32[16,32,32,1]{3,2,1,0} add(f32[16,32,32,1]{3,2,1,0} %maximum.2202, f32[16,32,32,1]{3,2,1,0} %broadcast.2219) + %divide.2223 = f32[16,32,32,1]{3,2,1,0} divide(f32[16,32,32,1]{3,2,1,0} %subtract.2222, f32[16,32,32,1]{3,2,1,0} %add.2220) + %concatenate.2235 = f32[16,32,32,3]{3,2,1,0} concatenate(f32[16,32,32,1]{3,2,1,0} %divide.2223, f32[16,32,32,2]{3,2,1,0} %broadcast.86), dimensions={3} + %broadcast.2241 = f32[1,1,3,3]{3,2,1,0} broadcast(f32[3,3]{1,0} %parameter.16), dimensions={2,3} + %convolution.2242 = f32[16,32,32,3]{3,2,1,0} convolution(f32[16,32,32,3]{3,2,1,0} %concatenate.2235, f32[1,1,3,3]{3,2,1,0} %broadcast.2241), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.2483 = s32[] constant(1) + %broadcast.2484 = s32[1]{0} broadcast(s32[] %constant.2483), dimensions={} + %gather.2485 = f32[16,32,32,2]{3,2,1,0} gather(f32[16,32,32,3]{3,2,1,0} %convolution.2242, s32[1]{0} %broadcast.2484), offset_dims={0,1,2,3}, collapsed_slice_dims={}, start_index_map={3}, index_vector_dim=0, slice_sizes={16,32,32,2}, indices_are_sorted=true + %broadcast.2486 = f32[16,32,32,2]{3,2,1,0} broadcast(f32[16,32,32,2]{3,2,1,0} %gather.2485), dimensions={0,1,2,3} + %parameter.27 = f32[1,1,2,8]{3,2,1,0} parameter(26) + %multiply.2509 = f32[1,1,2,8]{3,2,1,0} multiply(f32[1,1,2,8]{3,2,1,0} %parameter.27, f32[1,1,2,8]{3,2,1,0} %parameter.27) + %constant.2513 = f32[] constant(0) + %reduce.2518 = f32[8]{0} reduce(f32[1,1,2,8]{3,2,1,0} %multiply.2509, f32[] %constant.2513), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.2514 + %rsqrt.2519 = f32[8]{0} rsqrt(f32[8]{0} %reduce.2518) + %broadcast.2524 = f32[1,1,1,8]{3,2,1,0} broadcast(f32[8]{0} %rsqrt.2519), dimensions={3} + %reshape.2525 = f32[1,1,8]{2,1,0} reshape(f32[1,1,1,8]{3,2,1,0} %broadcast.2524) + %broadcast.2526 = f32[1,1,2,8]{3,2,1,0} broadcast(f32[1,1,8]{2,1,0} %reshape.2525), dimensions={0,1,3} + %multiply.2527 = f32[1,1,2,8]{3,2,1,0} multiply(f32[1,1,2,8]{3,2,1,0} %parameter.27, f32[1,1,2,8]{3,2,1,0} %broadcast.2526) + %convolution.2528 = f32[16,32,32,8]{3,2,1,0} convolution(f32[16,32,32,2]{3,2,1,0} %broadcast.2486, f32[1,1,2,8]{3,2,1,0} %multiply.2527), window={size=1x1}, dim_labels=b01f_01io->b01f + %parameter.26 = f32[8]{0} parameter(25) + %broadcast.2529 = f32[1,1,1,8]{3,2,1,0} broadcast(f32[8]{0} %parameter.26), dimensions={3} + %reshape.2530 = f32[8]{0} reshape(f32[1,1,1,8]{3,2,1,0} %broadcast.2529) + %broadcast.2531 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[8]{0} %reshape.2530), dimensions={3} + %multiply.2532 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %convolution.2528, f32[16,32,32,8]{3,2,1,0} %broadcast.2531) + %parameter.25 = f32[8]{0} parameter(24) + %broadcast.2533 = f32[1,1,1,8]{3,2,1,0} broadcast(f32[8]{0} %parameter.25), dimensions={3} + %reshape.2534 = f32[8]{0} reshape(f32[1,1,1,8]{3,2,1,0} %broadcast.2533) + %broadcast.2535 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[8]{0} %reshape.2534), dimensions={3} + %add.2536 = f32[16,32,32,8]{3,2,1,0} add(f32[16,32,32,8]{3,2,1,0} %multiply.2532, f32[16,32,32,8]{3,2,1,0} %broadcast.2535) + %constant.2559 = pred[] constant(false) + %constant.2640 = pred[] constant(false) + %constant.2641 = pred[] constant(false) + %constant.2642 = pred[] constant(false) + %constant.2643 = pred[] constant(false) + %constant.2644 = pred[] constant(false) + %constant.2645 = pred[] constant(false) + %constant.2646 = pred[] constant(false) + %constant.2647 = pred[] constant(false) + %constant.2569 = f32[] constant(0) + %broadcast.2570 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.2569), dimensions={} + %constant.2571 = f32[] constant(0) + %broadcast.2572 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.2571), dimensions={} + %constant.2573 = f32[] constant(0) + %broadcast.2574 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.2573), dimensions={} + %constant.2575 = f32[] constant(0) + %broadcast.2576 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.2575), dimensions={} + %constant.2577 = f32[] constant(0) + %broadcast.2578 = f32[2,3,3,8,16]{4,3,2,1,0} broadcast(f32[] %constant.2577), dimensions={} + %constant.2579 = f32[] constant(0) + %broadcast.2580 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.2579), dimensions={} + %constant.2581 = f32[] constant(0) + %broadcast.2582 = f32[2,1,1,1,16]{4,3,2,1,0} broadcast(f32[] %constant.2581), dimensions={} + %constant.2583 = f32[] constant(0) + %broadcast.2584 = f32[2,3,3,8,16]{4,3,2,1,0} broadcast(f32[] %constant.2583), dimensions={} + %constant.2585 = f32[] constant(0) + %broadcast.2586 = f32[2,16]{1,0} broadcast(f32[] %constant.2585), dimensions={} + %constant.2587 = f32[] constant(0) + %broadcast.2588 = f32[2,1,1,1,16]{4,3,2,1,0} broadcast(f32[] %constant.2587), dimensions={} + %constant.2589 = f32[] constant(0) + %broadcast.2590 = f32[2,16,32,32,16]{4,3,2,1,0} broadcast(f32[] %constant.2589), dimensions={} + %constant.2591 = f32[] constant(0) + %broadcast.2592 = f32[2,16,32,32,16]{4,3,2,1,0} broadcast(f32[] %constant.2591), dimensions={} + %constant.2593 = f32[] constant(0) + %broadcast.2594 = f32[2,16,32,32,16]{4,3,2,1,0} broadcast(f32[] %constant.2593), dimensions={} + %constant.2595 = f32[] constant(0) + %broadcast.2596 = f32[2,16,32,32,16]{4,3,2,1,0} broadcast(f32[] %constant.2595), dimensions={} + %constant.2597 = f32[] constant(0) + %broadcast.2598 = f32[2,16,32,32,16]{4,3,2,1,0} broadcast(f32[] %constant.2597), dimensions={} + %constant.2599 = f32[] constant(0) + %broadcast.2600 = f32[2,1,1,16,16]{4,3,2,1,0} broadcast(f32[] %constant.2599), dimensions={} + %constant.2601 = f32[] constant(0) + %broadcast.2602 = f32[2,16,32,32,16]{4,3,2,1,0} broadcast(f32[] %constant.2601), dimensions={} + %constant.2603 = f32[] constant(0) + %broadcast.2604 = f32[2,1,1,1,16]{4,3,2,1,0} broadcast(f32[] %constant.2603), dimensions={} + %constant.2605 = f32[] constant(0) + %broadcast.2606 = f32[2,1,1,16,16]{4,3,2,1,0} broadcast(f32[] %constant.2605), dimensions={} + %constant.2607 = f32[] constant(0) + %broadcast.2608 = f32[2,16]{1,0} broadcast(f32[] %constant.2607), dimensions={} + %constant.2609 = f32[] constant(0) + %broadcast.2610 = f32[2,1,1,1,16]{4,3,2,1,0} broadcast(f32[] %constant.2609), dimensions={} + %constant.2611 = f32[] constant(0) + %broadcast.2612 = f32[2,16,32,32,16]{4,3,2,1,0} broadcast(f32[] %constant.2611), dimensions={} + %constant.2613 = f32[] constant(0) + %broadcast.2614 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.2613), dimensions={} + %constant.2615 = f32[] constant(0) + %broadcast.2616 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.2615), dimensions={} + %constant.2617 = f32[] constant(0) + %broadcast.2618 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.2617), dimensions={} + %constant.2619 = f32[] constant(0) + %broadcast.2620 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.2619), dimensions={} + %constant.2621 = f32[] constant(0) + %broadcast.2622 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.2621), dimensions={} + %constant.2623 = f32[] constant(0) + %broadcast.2624 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.2623), dimensions={} + %constant.2625 = f32[] constant(0) + %broadcast.2626 = f32[2,16,1,1,8]{4,3,2,1,0} broadcast(f32[] %constant.2625), dimensions={} + %constant.2627 = f32[] constant(0) + %broadcast.2628 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.2627), dimensions={} + %constant.2629 = f32[] constant(0) + %broadcast.2630 = f32[2,16,1024,8]{3,2,1,0} broadcast(f32[] %constant.2629), dimensions={} + %constant.2631 = f32[] constant(0) + %broadcast.2632 = f32[2,16,8]{2,1,0} broadcast(f32[] %constant.2631), dimensions={} + %constant.2633 = f32[] constant(0) + %broadcast.2634 = f32[2,16,8]{2,1,0} broadcast(f32[] %constant.2633), dimensions={} + %constant.2635 = f32[] constant(0) + %broadcast.2636 = f32[2,1,1,1,8]{4,3,2,1,0} broadcast(f32[] %constant.2635), dimensions={} + %constant.2637 = f32[] constant(0) + %broadcast.2638 = f32[2,16,32,32,8]{4,3,2,1,0} broadcast(f32[] %constant.2637), dimensions={} + %tuple.2648 = (u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) tuple(u32[2,2]{1,0} %reshape.2552, f32[2,16]{1,0} %parameter.17, f32[2,16]{1,0} %parameter.18, f32[2,3,3,8,16]{4,3,2,1,0} %parameter.19, f32[2,16]{1,0} %parameter.20, /*index=5*/f32[2,16]{1,0} %parameter.21, f32[2,1,1,16,16]{4,3,2,1,0} %parameter.22, f32[2,8]{1,0} %parameter.23, f32[2,8]{1,0} %parameter.24, s32[] %constant.2639, /*index=10*/f32[16,32,32,8]{3,2,1,0} %add.2536, pred[] %constant.2559, pred[] %constant.2640, pred[] %constant.2641, pred[] %constant.2642, /*index=15*/pred[] %constant.2643, pred[] %constant.2644, pred[] %constant.2645, pred[] %constant.2646, pred[] %constant.2647, /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.2570, f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.2572, f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.2574, f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.2576, f32[2,3,3,8,16]{4,3,2,1,0} %broadcast.2578, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.2580, f32[2,1,1,1,16]{4,3,2,1,0} %broadcast.2582, f32[2,3,3,8,16]{4,3,2,1,0} %broadcast.2584, f32[2,16]{1,0} %broadcast.2586, f32[2,1,1,1,16]{4,3,2,1,0} %broadcast.2588, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0} %broadcast.2590, f32[2,16,32,32,16]{4,3,2,1,0} %broadcast.2592, f32[2,16,32,32,16]{4,3,2,1,0} %broadcast.2594, f32[2,16,32,32,16]{4,3,2,1,0} %broadcast.2596, f32[2,16,32,32,16]{4,3,2,1,0} %broadcast.2598, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0} %broadcast.2600, f32[2,16,32,32,16]{4,3,2,1,0} %broadcast.2602, f32[2,1,1,1,16]{4,3,2,1,0} %broadcast.2604, f32[2,1,1,16,16]{4,3,2,1,0} %broadcast.2606, f32[2,16]{1,0} %broadcast.2608, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0} %broadcast.2610, f32[2,16,32,32,16]{4,3,2,1,0} %broadcast.2612, f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.2614, f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.2616, f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.2618, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.2620, f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.2622, f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.2624, f32[2,16,1,1,8]{4,3,2,1,0} %broadcast.2626, f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.2628, /*index=50*/f32[2,16,1024,8]{3,2,1,0} %broadcast.2630, f32[2,16,8]{2,1,0} %broadcast.2632, f32[2,16,8]{2,1,0} %broadcast.2634, f32[2,1,1,1,8]{4,3,2,1,0} %broadcast.2636, f32[2,16,32,32,8]{4,3,2,1,0} %broadcast.2638) + %while.4404 = (u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) while((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2648), condition=%cond_computation__1.4344, body=%body_computation__1.2665 + %get-tuple-element.4405 = u32[2,2]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=0 + %get-tuple-element.4406 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=1 + %get-tuple-element.4407 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=2 + %get-tuple-element.4408 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=3 + %get-tuple-element.4409 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=4 + %get-tuple-element.4410 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=5 + %get-tuple-element.4411 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=6 + %get-tuple-element.4412 = f32[2,8]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=7 + %get-tuple-element.4413 = f32[2,8]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=8 + %get-tuple-element.4414 = s32[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=9 + %get-tuple-element.4415 = f32[16,32,32,8]{3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=10 + %get-tuple-element.4416 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=11 + %get-tuple-element.4417 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=12 + %get-tuple-element.4418 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=13 + %get-tuple-element.4419 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=14 + %get-tuple-element.4420 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=15 + %get-tuple-element.4421 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=16 + %get-tuple-element.4422 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=17 + %get-tuple-element.4423 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=18 + %get-tuple-element.4424 = pred[] get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=19 + %get-tuple-element.4425 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=20 + %get-tuple-element.4426 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=21 + %get-tuple-element.4427 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=22 + %get-tuple-element.4428 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=23 + %get-tuple-element.4429 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=24 + %get-tuple-element.4430 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=25 + %get-tuple-element.4431 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=26 + %get-tuple-element.4432 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=27 + %get-tuple-element.4433 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=28 + %get-tuple-element.4434 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=29 + %get-tuple-element.4435 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=30 + %get-tuple-element.4436 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=31 + %get-tuple-element.4437 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=32 + %get-tuple-element.4438 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=33 + %get-tuple-element.4439 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=34 + %get-tuple-element.4440 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=35 + %get-tuple-element.4441 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=36 + %get-tuple-element.4442 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=37 + %get-tuple-element.4443 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=38 + %get-tuple-element.4444 = f32[2,16]{1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=39 + %get-tuple-element.4445 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=40 + %get-tuple-element.4446 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=41 + %get-tuple-element.4447 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=42 + %get-tuple-element.4448 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=43 + %get-tuple-element.4449 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=44 + %get-tuple-element.4450 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=45 + %get-tuple-element.4451 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=46 + %get-tuple-element.4452 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=47 + %get-tuple-element.4453 = f32[2,16,1,1,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=48 + %get-tuple-element.4454 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=49 + %get-tuple-element.4455 = f32[2,16,1024,8]{3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=50 + %get-tuple-element.4456 = f32[2,16,8]{2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=51 + %get-tuple-element.4457 = f32[2,16,8]{2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=52 + %get-tuple-element.4458 = f32[2,1,1,1,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=53 + %get-tuple-element.4459 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((u32[2,2]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, s32[], /*index=10*/f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=15*/pred[], pred[], pred[], pred[], pred[], /*index=20*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=30*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=35*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=40*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=50*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %while.4404), index=54 + %tuple.4460 = (s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) tuple(s32[] %get-tuple-element.4414, f32[16,32,32,8]{3,2,1,0} %get-tuple-element.4415, pred[] %get-tuple-element.4416, pred[] %get-tuple-element.4417, pred[] %get-tuple-element.4418, /*index=5*/pred[] %get-tuple-element.4419, pred[] %get-tuple-element.4420, pred[] %get-tuple-element.4421, pred[] %get-tuple-element.4422, pred[] %get-tuple-element.4423, /*index=10*/pred[] %get-tuple-element.4424, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4425, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4426, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4427, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4428, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.4429, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4430, f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.4431, f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.4432, f32[2,16]{1,0} %get-tuple-element.4433, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.4434, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4435, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4436, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4437, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4438, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4439, f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.4440, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4441, f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.4442, f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.4443, /*index=30*/f32[2,16]{1,0} %get-tuple-element.4444, f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.4445, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4446, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4447, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4448, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4449, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4450, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4451, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4452, f32[2,16,1,1,8]{4,3,2,1,0} %get-tuple-element.4453, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4454, f32[2,16,1024,8]{3,2,1,0} %get-tuple-element.4455, f32[2,16,8]{2,1,0} %get-tuple-element.4456, f32[2,16,8]{2,1,0} %get-tuple-element.4457, f32[2,1,1,1,8]{4,3,2,1,0} %get-tuple-element.4458, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4459) + %get-tuple-element.4461 = s32[] get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=0 + %get-tuple-element.4462 = f32[16,32,32,8]{3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=1 + %get-tuple-element.4463 = pred[] get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=2 + %get-tuple-element.4464 = pred[] get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=3 + %get-tuple-element.4465 = pred[] get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=4 + %get-tuple-element.4466 = pred[] get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=5 + %get-tuple-element.4467 = pred[] get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=6 + %get-tuple-element.4468 = pred[] get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=7 + %get-tuple-element.4469 = pred[] get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=8 + %get-tuple-element.4470 = pred[] get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=9 + %get-tuple-element.4471 = pred[] get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=10 + %get-tuple-element.4472 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=11 + %get-tuple-element.4473 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=12 + %get-tuple-element.4474 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=13 + %get-tuple-element.4475 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=14 + %get-tuple-element.4476 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=15 + %get-tuple-element.4477 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=16 + %get-tuple-element.4478 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=17 + %get-tuple-element.4479 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=18 + %get-tuple-element.4480 = f32[2,16]{1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=19 + %get-tuple-element.4481 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=20 + %get-tuple-element.4482 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=21 + %get-tuple-element.4483 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=22 + %get-tuple-element.4484 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=23 + %get-tuple-element.4485 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=24 + %get-tuple-element.4486 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=25 + %get-tuple-element.4487 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=26 + %get-tuple-element.4488 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=27 + %get-tuple-element.4489 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=28 + %get-tuple-element.4490 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=29 + %get-tuple-element.4491 = f32[2,16]{1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=30 + %get-tuple-element.4492 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=31 + %get-tuple-element.4493 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=32 + %get-tuple-element.4494 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=33 + %get-tuple-element.4495 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=34 + %get-tuple-element.4496 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=35 + %get-tuple-element.4497 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=36 + %get-tuple-element.4498 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=37 + %get-tuple-element.4499 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=38 + %get-tuple-element.4500 = f32[2,16,1,1,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=39 + %get-tuple-element.4501 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=40 + %get-tuple-element.4502 = f32[2,16,1024,8]{3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=41 + %get-tuple-element.4503 = f32[2,16,8]{2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=42 + %get-tuple-element.4504 = f32[2,16,8]{2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=43 + %get-tuple-element.4505 = f32[2,1,1,1,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=44 + %get-tuple-element.4506 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((s32[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=20*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=30*/f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, /*index=40*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, /*index=45*/f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4460), index=45 + %tuple.4507 = (f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) tuple(f32[16,32,32,8]{3,2,1,0} %get-tuple-element.4462, pred[] %get-tuple-element.4463, pred[] %get-tuple-element.4464, pred[] %get-tuple-element.4465, pred[] %get-tuple-element.4466, /*index=5*/pred[] %get-tuple-element.4467, pred[] %get-tuple-element.4468, pred[] %get-tuple-element.4469, pred[] %get-tuple-element.4470, pred[] %get-tuple-element.4471, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4472, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4473, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4474, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4475, f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.4476, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4477, f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.4478, f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.4479, f32[2,16]{1,0} %get-tuple-element.4480, f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.4481, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4482, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4483, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4484, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4485, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4486, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.4487, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4488, f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.4489, f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.4490, f32[2,16]{1,0} %get-tuple-element.4491, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.4492, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4493, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4494, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4495, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4496, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4497, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4498, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4499, f32[2,16,1,1,8]{4,3,2,1,0} %get-tuple-element.4500, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4501, /*index=40*/f32[2,16,1024,8]{3,2,1,0} %get-tuple-element.4502, f32[2,16,8]{2,1,0} %get-tuple-element.4503, f32[2,16,8]{2,1,0} %get-tuple-element.4504, f32[2,1,1,1,8]{4,3,2,1,0} %get-tuple-element.4505, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4506) + %get-tuple-element.4509 = pred[] get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=1 + %get-tuple-element.4510 = pred[] get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=2 + %get-tuple-element.4511 = pred[] get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=3 + %get-tuple-element.4512 = pred[] get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=4 + %get-tuple-element.4513 = pred[] get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=5 + %get-tuple-element.4514 = pred[] get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=6 + %get-tuple-element.4515 = pred[] get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=7 + %get-tuple-element.4516 = pred[] get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=8 + %get-tuple-element.4517 = pred[] get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=9 + %constant.4797 = pred[] constant(false) + %constant.4798 = pred[] constant(false) + %constant.4799 = pred[] constant(false) + %constant.4800 = pred[] constant(false) + %constant.4801 = pred[] constant(false) + %constant.4802 = pred[] constant(false) + %constant.4803 = pred[] constant(false) + %constant.4804 = pred[] constant(false) + %constant.4805 = pred[] constant(false) + %constant.4780 = f32[] constant(0) + %broadcast.4781 = f32[2,16]{1,0} broadcast(f32[] %constant.4780), dimensions={} + %constant.4782 = f32[] constant(0) + %broadcast.4783 = f32[2,16]{1,0} broadcast(f32[] %constant.4782), dimensions={} + %constant.4784 = f32[] constant(0) + %broadcast.4785 = f32[2,3,3,8,16]{4,3,2,1,0} broadcast(f32[] %constant.4784), dimensions={} + %constant.4786 = f32[] constant(0) + %broadcast.4787 = f32[2,16]{1,0} broadcast(f32[] %constant.4786), dimensions={} + %constant.4788 = f32[] constant(0) + %broadcast.4789 = f32[2,16]{1,0} broadcast(f32[] %constant.4788), dimensions={} + %constant.4790 = f32[] constant(0) + %broadcast.4791 = f32[2,1,1,16,16]{4,3,2,1,0} broadcast(f32[] %constant.4790), dimensions={} + %constant.4792 = f32[] constant(0) + %broadcast.4793 = f32[2,8]{1,0} broadcast(f32[] %constant.4792), dimensions={} + %constant.4794 = f32[] constant(0) + %broadcast.4795 = f32[2,8]{1,0} broadcast(f32[] %constant.4794), dimensions={} + %get-tuple-element.4518 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=10 + %get-tuple-element.4519 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=11 + %get-tuple-element.4520 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=12 + %get-tuple-element.4521 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=13 + %get-tuple-element.4522 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=14 + %get-tuple-element.4523 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=15 + %get-tuple-element.4524 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=16 + %get-tuple-element.4525 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=17 + %get-tuple-element.4526 = f32[2,16]{1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=18 + %get-tuple-element.4527 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=19 + %get-tuple-element.4528 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=20 + %get-tuple-element.4529 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=21 + %get-tuple-element.4530 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=22 + %get-tuple-element.4531 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=23 + %get-tuple-element.4532 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=24 + %get-tuple-element.4533 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=25 + %get-tuple-element.4534 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=26 + %get-tuple-element.4535 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=27 + %get-tuple-element.4536 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=28 + %get-tuple-element.4537 = f32[2,16]{1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=29 + %get-tuple-element.4538 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=30 + %get-tuple-element.4539 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=31 + %get-tuple-element.4540 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=32 + %get-tuple-element.4541 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=33 + %get-tuple-element.4542 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=34 + %get-tuple-element.4543 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=35 + %get-tuple-element.4544 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=36 + %get-tuple-element.4545 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=37 + %get-tuple-element.4546 = f32[2,16,1,1,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=38 + %get-tuple-element.4547 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=39 + %get-tuple-element.4548 = f32[2,16,1024,8]{3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=40 + %get-tuple-element.4549 = f32[2,16,8]{2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=41 + %get-tuple-element.4550 = f32[2,16,8]{2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=42 + %get-tuple-element.4551 = f32[2,1,1,1,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=43 + %get-tuple-element.4552 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=44 + %constant.4822 = s32[] constant(0) + %constant.4796 = pred[] constant(false) + %constant.4667 = f32[] constant(1) + %negate.4668 = f32[] negate(f32[] %constant.4667) + %constant.4669 = f32[] constant(16) + %divide.4670 = f32[] divide(f32[] %negate.4668, f32[] %constant.4669) + %broadcast.4671 = f32[16]{0} broadcast(f32[] %divide.4670), dimensions={} + %constant.4672 = f32[] constant(-0.5) + %broadcast.4673 = f32[16]{0} broadcast(f32[] %constant.4672), dimensions={} + %multiply.4674 = f32[16]{0} multiply(f32[16]{0} %broadcast.4671, f32[16]{0} %broadcast.4673) + %broadcast.4675 = f32[16,32,32,3]{3,2,1,0} broadcast(f32[16]{0} %multiply.4674), dimensions={0} + %constant.4638 = f32[] constant(2) + %broadcast.4639 = f32[16,32,32,3]{3,2,1,0} broadcast(f32[] %constant.4638), dimensions={} + %constant.2479 = s32[] constant(0) + %broadcast.2480 = s32[1]{0} broadcast(s32[] %constant.2479), dimensions={} + %gather.2481 = f32[16,32,32,1]{3,2,1,0} gather(f32[16,32,32,3]{3,2,1,0} %convolution.2242, s32[1]{0} %broadcast.2480), offset_dims={0,1,2,3}, collapsed_slice_dims={}, start_index_map={3}, index_vector_dim=0, slice_sizes={16,32,32,1}, indices_are_sorted=true + %broadcast.2482 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[16,32,32,1]{3,2,1,0} %gather.2481), dimensions={0,1,2,3} + %get-tuple-element.4508 = f32[16,32,32,8]{3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.4507), index=0 + %parameter.30 = f32[1,1,8,2]{3,2,1,0} parameter(29) + %multiply.4553 = f32[1,1,8,2]{3,2,1,0} multiply(f32[1,1,8,2]{3,2,1,0} %parameter.30, f32[1,1,8,2]{3,2,1,0} %parameter.30) + %constant.4557 = f32[] constant(0) + %reduce.4562 = f32[2]{0} reduce(f32[1,1,8,2]{3,2,1,0} %multiply.4553, f32[] %constant.4557), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.4558 + %rsqrt.4563 = f32[2]{0} rsqrt(f32[2]{0} %reduce.4562) + %broadcast.4568 = f32[1,1,1,2]{3,2,1,0} broadcast(f32[2]{0} %rsqrt.4563), dimensions={3} + %reshape.4569 = f32[1,1,2]{2,1,0} reshape(f32[1,1,1,2]{3,2,1,0} %broadcast.4568) + %broadcast.4570 = f32[1,1,8,2]{3,2,1,0} broadcast(f32[1,1,2]{2,1,0} %reshape.4569), dimensions={0,1,3} + %multiply.4571 = f32[1,1,8,2]{3,2,1,0} multiply(f32[1,1,8,2]{3,2,1,0} %parameter.30, f32[1,1,8,2]{3,2,1,0} %broadcast.4570) + %convolution.4572 = f32[16,32,32,2]{3,2,1,0} convolution(f32[16,32,32,8]{3,2,1,0} %get-tuple-element.4508, f32[1,1,8,2]{3,2,1,0} %multiply.4571), window={size=1x1}, dim_labels=b01f_01io->b01f + %parameter.29 = f32[2]{0} parameter(28) + %broadcast.4573 = f32[1,1,1,2]{3,2,1,0} broadcast(f32[2]{0} %parameter.29), dimensions={3} + %reshape.4574 = f32[2]{0} reshape(f32[1,1,1,2]{3,2,1,0} %broadcast.4573) + %broadcast.4575 = f32[16,32,32,2]{3,2,1,0} broadcast(f32[2]{0} %reshape.4574), dimensions={3} + %multiply.4576 = f32[16,32,32,2]{3,2,1,0} multiply(f32[16,32,32,2]{3,2,1,0} %convolution.4572, f32[16,32,32,2]{3,2,1,0} %broadcast.4575) + %parameter.28 = f32[2]{0} parameter(27) + %broadcast.4577 = f32[1,1,1,2]{3,2,1,0} broadcast(f32[2]{0} %parameter.28), dimensions={3} + %reshape.4578 = f32[2]{0} reshape(f32[1,1,1,2]{3,2,1,0} %broadcast.4577) + %broadcast.4579 = f32[16,32,32,2]{3,2,1,0} broadcast(f32[2]{0} %reshape.4578), dimensions={3} + %add.4580 = f32[16,32,32,2]{3,2,1,0} add(f32[16,32,32,2]{3,2,1,0} %multiply.4576, f32[16,32,32,2]{3,2,1,0} %broadcast.4579) + %parameter.31 = f32[] parameter(30) + %broadcast.4581 = f32[16,32,32,2]{3,2,1,0} broadcast(f32[] %parameter.31), dimensions={} + %multiply.4582 = f32[16,32,32,2]{3,2,1,0} multiply(f32[16,32,32,2]{3,2,1,0} %add.4580, f32[16,32,32,2]{3,2,1,0} %broadcast.4581) + %slice.4584 = f32[16,32,32,1]{3,2,1,0} slice(f32[16,32,32,2]{3,2,1,0} %multiply.4582), slice={[0:16], [0:32], [0:32], [1:2]} + %subtract.4622 = f32[16,32,32,1]{3,2,1,0} subtract(f32[16,32,32,1]{3,2,1,0} %broadcast.2482, f32[16,32,32,1]{3,2,1,0} %slice.4584) + %slice.4583 = f32[16,32,32,1]{3,2,1,0} slice(f32[16,32,32,2]{3,2,1,0} %multiply.4582), slice={[0:16], [0:32], [0:32], [0:1]} + %multiply.4585 = f32[16,32,32,1]{3,2,1,0} multiply(f32[16,32,32,1]{3,2,1,0} %slice.4583, f32[16,32,32,1]{3,2,1,0} %slice.4583) + %constant.4589 = f32[] constant(4) + %broadcast.4590 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.4589), dimensions={} + %add.4591 = f32[16,32,32,1]{3,2,1,0} add(f32[16,32,32,1]{3,2,1,0} %multiply.4585, f32[16,32,32,1]{3,2,1,0} %broadcast.4590) + %sqrt.4592 = f32[16,32,32,1]{3,2,1,0} sqrt(f32[16,32,32,1]{3,2,1,0} %add.4591) + %add.4596 = f32[16,32,32,1]{3,2,1,0} add(f32[16,32,32,1]{3,2,1,0} %slice.4583, f32[16,32,32,1]{3,2,1,0} %sqrt.4592) + %constant.4597 = f32[] constant(0.5) + %broadcast.4598 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.4597), dimensions={} + %multiply.4599 = f32[16,32,32,1]{3,2,1,0} multiply(f32[16,32,32,1]{3,2,1,0} %add.4596, f32[16,32,32,1]{3,2,1,0} %broadcast.4598) + %constant.4600 = f32[] constant(0) + %broadcast.4601 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.4600), dimensions={} + %maximum.4602 = f32[16,32,32,1]{3,2,1,0} maximum(f32[16,32,32,1]{3,2,1,0} %multiply.4599, f32[16,32,32,1]{3,2,1,0} %broadcast.4601) + %constant.4618 = f32[] constant(0.0001) + %broadcast.4619 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.4618), dimensions={} + %add.4620 = f32[16,32,32,1]{3,2,1,0} add(f32[16,32,32,1]{3,2,1,0} %maximum.4602, f32[16,32,32,1]{3,2,1,0} %broadcast.4619) + %divide.4623 = f32[16,32,32,1]{3,2,1,0} divide(f32[16,32,32,1]{3,2,1,0} %subtract.4622, f32[16,32,32,1]{3,2,1,0} %add.4620) + %concatenate.4635 = f32[16,32,32,3]{3,2,1,0} concatenate(f32[16,32,32,1]{3,2,1,0} %divide.4623, f32[16,32,32,2]{3,2,1,0} %broadcast.2486), dimensions={3} + %multiply.4640 = f32[16,32,32,3]{3,2,1,0} multiply(f32[16,32,32,3]{3,2,1,0} %broadcast.4639, f32[16,32,32,3]{3,2,1,0} %concatenate.4635) + %multiply.4676 = f32[16,32,32,3]{3,2,1,0} multiply(f32[16,32,32,3]{3,2,1,0} %broadcast.4675, f32[16,32,32,3]{3,2,1,0} %multiply.4640) + %slice.4677 = f32[16,32,32,1]{3,2,1,0} slice(f32[16,32,32,3]{3,2,1,0} %multiply.4676), slice={[0:16], [0:32], [0:32], [0:1]} + %divide.4682 = f32[16,32,32,1]{3,2,1,0} divide(f32[16,32,32,1]{3,2,1,0} %slice.4677, f32[16,32,32,1]{3,2,1,0} %add.4620) + %negate.4683 = f32[16,32,32,1]{3,2,1,0} negate(f32[16,32,32,1]{3,2,1,0} %divide.4682) + %constant.4684 = f32[] constant(0) + %pad.4685 = f32[16,32,32,2]{3,2,1,0} pad(f32[16,32,32,1]{3,2,1,0} %negate.4683, f32[] %constant.4684), padding=0_0x0_0x0_0x1_0 + %constant.4625 = f32[] constant(1) + %broadcast.4626 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.4625), dimensions={} + %multiply.4624 = f32[16,32,32,1]{3,2,1,0} multiply(f32[16,32,32,1]{3,2,1,0} %add.4620, f32[16,32,32,1]{3,2,1,0} %add.4620) + %divide.4627 = f32[16,32,32,1]{3,2,1,0} divide(f32[16,32,32,1]{3,2,1,0} %broadcast.4626, f32[16,32,32,1]{3,2,1,0} %multiply.4624) + %multiply.4679 = f32[16,32,32,1]{3,2,1,0} multiply(f32[16,32,32,1]{3,2,1,0} %slice.4677, f32[16,32,32,1]{3,2,1,0} %divide.4627) + %multiply.4680 = f32[16,32,32,1]{3,2,1,0} multiply(f32[16,32,32,1]{3,2,1,0} %multiply.4679, f32[16,32,32,1]{3,2,1,0} %subtract.4622) + %negate.4681 = f32[16,32,32,1]{3,2,1,0} negate(f32[16,32,32,1]{3,2,1,0} %multiply.4680) + %negate.4700 = f32[16]{0} negate(f32[16]{0} %broadcast.4671) + %broadcast.4701 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[16]{0} %negate.4700), dimensions={0} + %divide.4702 = f32[16,32,32,1]{3,2,1,0} divide(f32[16,32,32,1]{3,2,1,0} %broadcast.4701, f32[16,32,32,1]{3,2,1,0} %add.4620) + %add.4703 = f32[16,32,32,1]{3,2,1,0} add(f32[16,32,32,1]{3,2,1,0} %negate.4681, f32[16,32,32,1]{3,2,1,0} %divide.4702) + %compare.4603 = pred[16,32,32,1]{3,2,1,0} compare(f32[16,32,32,1]{3,2,1,0} %multiply.4599, f32[16,32,32,1]{3,2,1,0} %maximum.4602), direction=EQ + %constant.4604 = f32[] constant(1) + %broadcast.4605 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.4604), dimensions={} + %constant.4606 = f32[] constant(0) + %broadcast.4607 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.4606), dimensions={} + %select.4608 = f32[16,32,32,1]{3,2,1,0} select(pred[16,32,32,1]{3,2,1,0} %compare.4603, f32[16,32,32,1]{3,2,1,0} %broadcast.4605, f32[16,32,32,1]{3,2,1,0} %broadcast.4607) + %constant.4609 = f32[] constant(0) + %broadcast.4610 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.4609), dimensions={} + %compare.4611 = pred[16,32,32,1]{3,2,1,0} compare(f32[16,32,32,1]{3,2,1,0} %broadcast.4610, f32[16,32,32,1]{3,2,1,0} %maximum.4602), direction=EQ + %constant.4612 = f32[] constant(2) + %broadcast.4613 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.4612), dimensions={} + %constant.4614 = f32[] constant(1) + %broadcast.4615 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.4614), dimensions={} + %select.4616 = f32[16,32,32,1]{3,2,1,0} select(pred[16,32,32,1]{3,2,1,0} %compare.4611, f32[16,32,32,1]{3,2,1,0} %broadcast.4613, f32[16,32,32,1]{3,2,1,0} %broadcast.4615) + %divide.4617 = f32[16,32,32,1]{3,2,1,0} divide(f32[16,32,32,1]{3,2,1,0} %select.4608, f32[16,32,32,1]{3,2,1,0} %select.4616) + %multiply.4704 = f32[16,32,32,1]{3,2,1,0} multiply(f32[16,32,32,1]{3,2,1,0} %add.4703, f32[16,32,32,1]{3,2,1,0} %divide.4617) + %constant.4705 = f32[] constant(0.5) + %broadcast.4706 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.4705), dimensions={} + %multiply.4707 = f32[16,32,32,1]{3,2,1,0} multiply(f32[16,32,32,1]{3,2,1,0} %multiply.4704, f32[16,32,32,1]{3,2,1,0} %broadcast.4706) + %constant.4593 = f32[] constant(0.5) + %broadcast.4594 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.4593), dimensions={} + %divide.4595 = f32[16,32,32,1]{3,2,1,0} divide(f32[16,32,32,1]{3,2,1,0} %broadcast.4594, f32[16,32,32,1]{3,2,1,0} %sqrt.4592) + %multiply.4708 = f32[16,32,32,1]{3,2,1,0} multiply(f32[16,32,32,1]{3,2,1,0} %multiply.4707, f32[16,32,32,1]{3,2,1,0} %divide.4595) + %constant.4586 = f32[] constant(2) + %broadcast.4587 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.4586), dimensions={} + %multiply.4588 = f32[16,32,32,1]{3,2,1,0} multiply(f32[16,32,32,1]{3,2,1,0} %broadcast.4587, f32[16,32,32,1]{3,2,1,0} %slice.4583) + %multiply.4709 = f32[16,32,32,1]{3,2,1,0} multiply(f32[16,32,32,1]{3,2,1,0} %multiply.4708, f32[16,32,32,1]{3,2,1,0} %multiply.4588) + %add.4710 = f32[16,32,32,1]{3,2,1,0} add(f32[16,32,32,1]{3,2,1,0} %multiply.4707, f32[16,32,32,1]{3,2,1,0} %multiply.4709) + %constant.4711 = f32[] constant(0) + %pad.4712 = f32[16,32,32,2]{3,2,1,0} pad(f32[16,32,32,1]{3,2,1,0} %add.4710, f32[] %constant.4711), padding=0_0x0_0x0_0x0_1 + %add.4713 = f32[16,32,32,2]{3,2,1,0} add(f32[16,32,32,2]{3,2,1,0} %pad.4685, f32[16,32,32,2]{3,2,1,0} %pad.4712) + %broadcast.4721 = f32[16,32,32,2]{3,2,1,0} broadcast(f32[] %parameter.31), dimensions={} + %multiply.4722 = f32[16,32,32,2]{3,2,1,0} multiply(f32[16,32,32,2]{3,2,1,0} %add.4713, f32[16,32,32,2]{3,2,1,0} %broadcast.4721) + %reshape.4752 = f32[2]{0} reshape(f32[1,1,1,2]{3,2,1,0} %broadcast.4573) + %broadcast.4753 = f32[16,32,32,2]{3,2,1,0} broadcast(f32[2]{0} %reshape.4752), dimensions={3} + %multiply.4754 = f32[16,32,32,2]{3,2,1,0} multiply(f32[16,32,32,2]{3,2,1,0} %multiply.4722, f32[16,32,32,2]{3,2,1,0} %broadcast.4753) + %reverse.4778 = f32[1,1,8,2]{3,2,1,0} reverse(f32[1,1,8,2]{3,2,1,0} %multiply.4571), dimensions={0,1} + %convolution.4779 = f32[16,32,32,8]{3,2,1,0} convolution(f32[16,32,32,2]{3,2,1,0} %multiply.4754, f32[1,1,8,2]{3,2,1,0} %reverse.4778), window={size=1x1}, dim_labels=b01f_01oi->b01f + %constant.4823 = pred[] constant(false) + %constant.4824 = pred[] constant(false) + %constant.4825 = pred[] constant(false) + %constant.4826 = pred[] constant(false) + %constant.4827 = pred[] constant(false) + %constant.4828 = pred[] constant(false) + %constant.4829 = pred[] constant(false) + %constant.4830 = pred[] constant(false) + %constant.4831 = pred[] constant(false) + %constant.4806 = f32[] constant(0) + %broadcast.4807 = f32[2,16]{1,0} broadcast(f32[] %constant.4806), dimensions={} + %constant.4808 = f32[] constant(0) + %broadcast.4809 = f32[2,16]{1,0} broadcast(f32[] %constant.4808), dimensions={} + %constant.4810 = f32[] constant(0) + %broadcast.4811 = f32[2,3,3,8,16]{4,3,2,1,0} broadcast(f32[] %constant.4810), dimensions={} + %constant.4812 = f32[] constant(0) + %broadcast.4813 = f32[2,16]{1,0} broadcast(f32[] %constant.4812), dimensions={} + %constant.4814 = f32[] constant(0) + %broadcast.4815 = f32[2,16]{1,0} broadcast(f32[] %constant.4814), dimensions={} + %constant.4816 = f32[] constant(0) + %broadcast.4817 = f32[2,1,1,16,16]{4,3,2,1,0} broadcast(f32[] %constant.4816), dimensions={} + %constant.4818 = f32[] constant(0) + %broadcast.4819 = f32[2,8]{1,0} broadcast(f32[] %constant.4818), dimensions={} + %constant.4820 = f32[] constant(0) + %broadcast.4821 = f32[2,8]{1,0} broadcast(f32[] %constant.4820), dimensions={} + %tuple.4832 = (f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) tuple(f32[2,16]{1,0} %broadcast.4781, f32[2,16]{1,0} %broadcast.4783, f32[2,3,3,8,16]{4,3,2,1,0} %broadcast.4785, f32[2,16]{1,0} %broadcast.4787, f32[2,16]{1,0} %broadcast.4789, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0} %broadcast.4791, f32[2,8]{1,0} %broadcast.4793, f32[2,8]{1,0} %broadcast.4795, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4518, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4519, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4520, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4521, f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.4522, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4523, f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.4524, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0} %parameter.19, f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.4525, f32[2,16]{1,0} %get-tuple-element.4526, f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.4527, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4528, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4529, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4530, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4531, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4532, f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.4533, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4534, f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.4535, f32[2,1,1,16,16]{4,3,2,1,0} %parameter.22, f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.4536, f32[2,16]{1,0} %get-tuple-element.4537, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.4538, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.4539, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4540, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4541, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4542, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4543, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4544, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4545, f32[2,16,1,1,8]{4,3,2,1,0} %get-tuple-element.4546, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4547, /*index=40*/f32[2,16,1024,8]{3,2,1,0} %get-tuple-element.4548, f32[2,16,8]{2,1,0} %get-tuple-element.4549, f32[2,16,8]{2,1,0} %get-tuple-element.4550, f32[2,1,1,1,8]{4,3,2,1,0} %get-tuple-element.4551, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.4552, /*index=45*/s32[] %constant.4822, pred[] %constant.4796, f32[16,32,32,8]{3,2,1,0} %convolution.4779, pred[] %constant.4823, pred[] %constant.4824, /*index=50*/pred[] %constant.4825, pred[] %constant.4826, pred[] %constant.4827, pred[] %constant.4828, pred[] %constant.4829, /*index=55*/pred[] %constant.4830, pred[] %constant.4831, f32[2,16]{1,0} %broadcast.4807, f32[2,16]{1,0} %broadcast.4809, f32[2,3,3,8,16]{4,3,2,1,0} %broadcast.4811, /*index=60*/f32[2,16]{1,0} %broadcast.4813, f32[2,16]{1,0} %broadcast.4815, f32[2,1,1,16,16]{4,3,2,1,0} %broadcast.4817, f32[2,8]{1,0} %broadcast.4819, f32[2,8]{1,0} %broadcast.4821) + %while.6916 = (f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) while((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.4832), condition=%cond_computation__2.6846, body=%body_computation__2.4913 + %get-tuple-element.6917 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=0 + %get-tuple-element.6918 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=1 + %get-tuple-element.6919 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=2 + %get-tuple-element.6920 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=3 + %get-tuple-element.6921 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=4 + %get-tuple-element.6922 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=5 + %get-tuple-element.6923 = f32[2,8]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=6 + %get-tuple-element.6924 = f32[2,8]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=7 + %get-tuple-element.6925 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=8 + %get-tuple-element.6926 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=9 + %get-tuple-element.6927 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=10 + %get-tuple-element.6928 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=11 + %get-tuple-element.6929 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=12 + %get-tuple-element.6930 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=13 + %get-tuple-element.6931 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=14 + %get-tuple-element.6932 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=15 + %get-tuple-element.6933 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=16 + %get-tuple-element.6934 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=17 + %get-tuple-element.6935 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=18 + %get-tuple-element.6936 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=19 + %get-tuple-element.6937 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=20 + %get-tuple-element.6938 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=21 + %get-tuple-element.6939 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=22 + %get-tuple-element.6940 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=23 + %get-tuple-element.6941 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=24 + %get-tuple-element.6942 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=25 + %get-tuple-element.6943 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=26 + %get-tuple-element.6944 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=27 + %get-tuple-element.6945 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=28 + %get-tuple-element.6946 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=29 + %get-tuple-element.6947 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=30 + %get-tuple-element.6948 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=31 + %get-tuple-element.6949 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=32 + %get-tuple-element.6950 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=33 + %get-tuple-element.6951 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=34 + %get-tuple-element.6952 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=35 + %get-tuple-element.6953 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=36 + %get-tuple-element.6954 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=37 + %get-tuple-element.6955 = f32[2,16,1,1,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=38 + %get-tuple-element.6956 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=39 + %get-tuple-element.6957 = f32[2,16,1024,8]{3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=40 + %get-tuple-element.6958 = f32[2,16,8]{2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=41 + %get-tuple-element.6959 = f32[2,16,8]{2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=42 + %get-tuple-element.6960 = f32[2,1,1,1,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=43 + %get-tuple-element.6961 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=44 + %get-tuple-element.6962 = s32[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=45 + %get-tuple-element.6963 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=46 + %get-tuple-element.6964 = f32[16,32,32,8]{3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=47 + %get-tuple-element.6965 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=48 + %get-tuple-element.6966 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=49 + %get-tuple-element.6967 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=50 + %get-tuple-element.6968 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=51 + %get-tuple-element.6969 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=52 + %get-tuple-element.6970 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=53 + %get-tuple-element.6971 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=54 + %get-tuple-element.6972 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=55 + %get-tuple-element.6973 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=56 + %get-tuple-element.6974 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=57 + %get-tuple-element.6975 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=58 + %get-tuple-element.6976 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=59 + %get-tuple-element.6977 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=60 + %get-tuple-element.6978 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=61 + %get-tuple-element.6979 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=62 + %get-tuple-element.6980 = f32[2,8]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=63 + %get-tuple-element.6981 = f32[2,8]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.6916), index=64 + %tuple.6982 = (s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) tuple(s32[] %get-tuple-element.6962, pred[] %get-tuple-element.6963, f32[16,32,32,8]{3,2,1,0} %get-tuple-element.6964, pred[] %get-tuple-element.6965, pred[] %get-tuple-element.6966, /*index=5*/pred[] %get-tuple-element.6967, pred[] %get-tuple-element.6968, pred[] %get-tuple-element.6969, pred[] %get-tuple-element.6970, pred[] %get-tuple-element.6971, /*index=10*/pred[] %get-tuple-element.6972, pred[] %get-tuple-element.6973, f32[2,16]{1,0} %get-tuple-element.6974, f32[2,16]{1,0} %get-tuple-element.6975, f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.6976, /*index=15*/f32[2,16]{1,0} %get-tuple-element.6977, f32[2,16]{1,0} %get-tuple-element.6978, f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.6979, f32[2,8]{1,0} %get-tuple-element.6980, f32[2,8]{1,0} %get-tuple-element.6981) + %get-tuple-element.6983 = s32[] get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.6982), index=0 + %get-tuple-element.6984 = pred[] get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.6982), index=1 + %get-tuple-element.6985 = f32[16,32,32,8]{3,2,1,0} get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.6982), index=2 + %get-tuple-element.6986 = pred[] get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.6982), index=3 + %get-tuple-element.6987 = pred[] get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.6982), index=4 + %get-tuple-element.6988 = pred[] get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.6982), index=5 + %get-tuple-element.6989 = pred[] get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.6982), index=6 + %get-tuple-element.6990 = pred[] get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.6982), index=7 + %get-tuple-element.6991 = pred[] get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.6982), index=8 + %get-tuple-element.6992 = pred[] get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.6982), index=9 + %get-tuple-element.6993 = pred[] get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.6982), index=10 + %get-tuple-element.6994 = pred[] get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.6982), index=11 + %get-tuple-element.6995 = f32[2,16]{1,0} get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.6982), index=12 + %get-tuple-element.6996 = f32[2,16]{1,0} get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.6982), index=13 + %get-tuple-element.6997 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.6982), index=14 + %get-tuple-element.6998 = f32[2,16]{1,0} get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.6982), index=15 + %get-tuple-element.6999 = f32[2,16]{1,0} get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.6982), index=16 + %get-tuple-element.7000 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.6982), index=17 + %get-tuple-element.7001 = f32[2,8]{1,0} get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.6982), index=18 + %get-tuple-element.7002 = f32[2,8]{1,0} get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.6982), index=19 + %tuple.7003 = (pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) tuple(pred[] %get-tuple-element.6984, f32[16,32,32,8]{3,2,1,0} %get-tuple-element.6985, pred[] %get-tuple-element.6986, pred[] %get-tuple-element.6987, pred[] %get-tuple-element.6988, /*index=5*/pred[] %get-tuple-element.6989, pred[] %get-tuple-element.6990, pred[] %get-tuple-element.6991, pred[] %get-tuple-element.6992, pred[] %get-tuple-element.6993, /*index=10*/pred[] %get-tuple-element.6994, f32[2,16]{1,0} %get-tuple-element.6995, f32[2,16]{1,0} %get-tuple-element.6996, f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.6997, f32[2,16]{1,0} %get-tuple-element.6998, /*index=15*/f32[2,16]{1,0} %get-tuple-element.6999, f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.7000, f32[2,8]{1,0} %get-tuple-element.7001, f32[2,8]{1,0} %get-tuple-element.7002) + %get-tuple-element.7004 = pred[] get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.7003), index=0 + %get-tuple-element.7006 = pred[] get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.7003), index=2 + %get-tuple-element.7007 = pred[] get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.7003), index=3 + %get-tuple-element.7008 = pred[] get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.7003), index=4 + %get-tuple-element.7009 = pred[] get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.7003), index=5 + %get-tuple-element.7010 = pred[] get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.7003), index=6 + %get-tuple-element.7011 = pred[] get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.7003), index=7 + %get-tuple-element.7012 = pred[] get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.7003), index=8 + %get-tuple-element.7013 = pred[] get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.7003), index=9 + %get-tuple-element.7014 = pred[] get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.7003), index=10 + %constant.7299 = pred[] constant(false) + %constant.7300 = pred[] constant(false) + %constant.7301 = pred[] constant(false) + %constant.7302 = pred[] constant(false) + %constant.7303 = pred[] constant(false) + %constant.7304 = pred[] constant(false) + %constant.7305 = pred[] constant(false) + %constant.7306 = pred[] constant(false) + %constant.7307 = pred[] constant(false) + %constant.7282 = f32[] constant(0) + %broadcast.7283 = f32[2,16]{1,0} broadcast(f32[] %constant.7282), dimensions={} + %constant.7284 = f32[] constant(0) + %broadcast.7285 = f32[2,16]{1,0} broadcast(f32[] %constant.7284), dimensions={} + %constant.7286 = f32[] constant(0) + %broadcast.7287 = f32[2,3,3,8,16]{4,3,2,1,0} broadcast(f32[] %constant.7286), dimensions={} + %constant.7288 = f32[] constant(0) + %broadcast.7289 = f32[2,16]{1,0} broadcast(f32[] %constant.7288), dimensions={} + %constant.7290 = f32[] constant(0) + %broadcast.7291 = f32[2,16]{1,0} broadcast(f32[] %constant.7290), dimensions={} + %constant.7292 = f32[] constant(0) + %broadcast.7293 = f32[2,1,1,16,16]{4,3,2,1,0} broadcast(f32[] %constant.7292), dimensions={} + %constant.7294 = f32[] constant(0) + %broadcast.7295 = f32[2,8]{1,0} broadcast(f32[] %constant.7294), dimensions={} + %constant.7296 = f32[] constant(0) + %broadcast.7297 = f32[2,8]{1,0} broadcast(f32[] %constant.7296), dimensions={} + %get-tuple-element.2118 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=10 + %get-tuple-element.2119 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=11 + %get-tuple-element.2120 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=12 + %get-tuple-element.2121 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=13 + %get-tuple-element.2122 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=14 + %get-tuple-element.2123 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=15 + %get-tuple-element.2124 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=16 + %get-tuple-element.2125 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=17 + %get-tuple-element.2126 = f32[2,16]{1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=18 + %get-tuple-element.2127 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=19 + %get-tuple-element.2128 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=20 + %get-tuple-element.2129 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=21 + %get-tuple-element.2130 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=22 + %get-tuple-element.2131 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=23 + %get-tuple-element.2132 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=24 + %get-tuple-element.2133 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=25 + %get-tuple-element.2134 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=26 + %get-tuple-element.2135 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=27 + %get-tuple-element.2136 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=28 + %get-tuple-element.2137 = f32[2,16]{1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=29 + %get-tuple-element.2138 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=30 + %get-tuple-element.2139 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=31 + %get-tuple-element.2140 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=32 + %get-tuple-element.2141 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=33 + %get-tuple-element.2142 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=34 + %get-tuple-element.2143 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=35 + %get-tuple-element.2144 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=36 + %get-tuple-element.2145 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=37 + %get-tuple-element.2146 = f32[2,16,1,1,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=38 + %get-tuple-element.2147 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=39 + %get-tuple-element.2148 = f32[2,16,1024,8]{3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=40 + %get-tuple-element.2149 = f32[2,16,8]{2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=41 + %get-tuple-element.2150 = f32[2,16,8]{2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=42 + %get-tuple-element.2151 = f32[2,1,1,1,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=43 + %get-tuple-element.2152 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=25*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}) %tuple.2107), index=44 + %constant.7324 = s32[] constant(0) + %constant.7298 = pred[] constant(false) + %constant.4693 = f32[] constant(0) + %broadcast.4694 = f32[16,32,32,3]{3,2,1,0} broadcast(f32[] %constant.4693), dimensions={} + %constant.4686 = f32[] constant(0) + %reduce.4691 = f32[16,32,32]{2,1,0} reduce(f32[16,32,32,1]{3,2,1,0} %divide.4682, f32[] %constant.4686), dimensions={3}, to_apply=%primitive_computation_add__1.4687 + %broadcast.4692 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[16,32,32]{2,1,0} %reduce.4691), dimensions={0,1,2} + %scatter.4699 = f32[16,32,32,3]{3,2,1,0} scatter(f32[16,32,32,3]{3,2,1,0} %broadcast.4694, s32[1]{0} %broadcast.2480, f32[16,32,32,1]{3,2,1,0} %broadcast.4692), update_window_dims={0,1,2,3}, inserted_window_dims={}, scatter_dims_to_operand_dims={3}, index_vector_dim=0, indices_are_sorted=true, unique_indices=true, to_apply=%scatter_add_reducer.4695 + %constant.7088 = f32[] constant(0) + %broadcast.7089 = f32[16,32,32,3]{3,2,1,0} broadcast(f32[] %constant.7088), dimensions={} + %slice.4678 = f32[16,32,32,2]{3,2,1,0} slice(f32[16,32,32,3]{3,2,1,0} %multiply.4676), slice={[0:16], [0:32], [0:32], [1:3]} + %get-tuple-element.7005 = f32[16,32,32,8]{3,2,1,0} get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.7003), index=1 + %reshape.7052 = f32[8]{0} reshape(f32[1,1,1,8]{3,2,1,0} %broadcast.2529) + %broadcast.7053 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[8]{0} %reshape.7052), dimensions={3} + %multiply.7054 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %get-tuple-element.7005, f32[16,32,32,8]{3,2,1,0} %broadcast.7053) + %reverse.7078 = f32[1,1,2,8]{3,2,1,0} reverse(f32[1,1,2,8]{3,2,1,0} %multiply.2527), dimensions={0,1} + %convolution.7079 = f32[16,32,32,2]{3,2,1,0} convolution(f32[16,32,32,8]{3,2,1,0} %multiply.7054, f32[1,1,2,8]{3,2,1,0} %reverse.7078), window={size=1x1}, dim_labels=b01f_01oi->b01f + %add.7080 = f32[16,32,32,2]{3,2,1,0} add(f32[16,32,32,2]{3,2,1,0} %slice.4678, f32[16,32,32,2]{3,2,1,0} %convolution.7079) + %constant.7081 = f32[] constant(0) + %reduce.7086 = f32[16,32,32,2]{3,2,1,0} reduce(f32[16,32,32,2]{3,2,1,0} %add.7080, f32[] %constant.7081), dimensions={}, to_apply=%primitive_computation_add__1.7082 + %broadcast.7087 = f32[16,32,32,2]{3,2,1,0} broadcast(f32[16,32,32,2]{3,2,1,0} %reduce.7086), dimensions={0,1,2,3} + %scatter.7094 = f32[16,32,32,3]{3,2,1,0} scatter(f32[16,32,32,3]{3,2,1,0} %broadcast.7089, s32[1]{0} %broadcast.2484, f32[16,32,32,2]{3,2,1,0} %broadcast.7087), update_window_dims={0,1,2,3}, inserted_window_dims={}, scatter_dims_to_operand_dims={3}, index_vector_dim=0, indices_are_sorted=true, unique_indices=true, to_apply=%scatter_add_reducer__1.7090 + %add.7095 = f32[16,32,32,3]{3,2,1,0} add(f32[16,32,32,3]{3,2,1,0} %scatter.4699, f32[16,32,32,3]{3,2,1,0} %scatter.7094) + %reverse.7104 = f32[1,1,3,3]{3,2,1,0} reverse(f32[1,1,3,3]{3,2,1,0} %broadcast.2241), dimensions={0,1} + %convolution.7105 = f32[16,32,32,3]{3,2,1,0} convolution(f32[16,32,32,3]{3,2,1,0} %add.7095, f32[1,1,3,3]{3,2,1,0} %reverse.7104), window={size=1x1}, dim_labels=b01f_01oi->b01f + %slice.7106 = f32[16,32,32,1]{3,2,1,0} slice(f32[16,32,32,3]{3,2,1,0} %convolution.7105), slice={[0:16], [0:32], [0:32], [0:1]} + %divide.7110 = f32[16,32,32,1]{3,2,1,0} divide(f32[16,32,32,1]{3,2,1,0} %slice.7106, f32[16,32,32,1]{3,2,1,0} %add.2220) + %negate.7111 = f32[16,32,32,1]{3,2,1,0} negate(f32[16,32,32,1]{3,2,1,0} %divide.7110) + %constant.7112 = f32[] constant(0) + %pad.7113 = f32[16,32,32,2]{3,2,1,0} pad(f32[16,32,32,1]{3,2,1,0} %negate.7111, f32[] %constant.7112), padding=0_0x0_0x0_0x1_0 + %constant.2225 = f32[] constant(1) + %broadcast.2226 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.2225), dimensions={} + %multiply.2224 = f32[16,32,32,1]{3,2,1,0} multiply(f32[16,32,32,1]{3,2,1,0} %add.2220, f32[16,32,32,1]{3,2,1,0} %add.2220) + %divide.2227 = f32[16,32,32,1]{3,2,1,0} divide(f32[16,32,32,1]{3,2,1,0} %broadcast.2226, f32[16,32,32,1]{3,2,1,0} %multiply.2224) + %multiply.7107 = f32[16,32,32,1]{3,2,1,0} multiply(f32[16,32,32,1]{3,2,1,0} %slice.7106, f32[16,32,32,1]{3,2,1,0} %divide.2227) + %multiply.7108 = f32[16,32,32,1]{3,2,1,0} multiply(f32[16,32,32,1]{3,2,1,0} %multiply.7107, f32[16,32,32,1]{3,2,1,0} %subtract.2222) + %negate.7109 = f32[16,32,32,1]{3,2,1,0} negate(f32[16,32,32,1]{3,2,1,0} %multiply.7108) + %negate.7202 = f32[16]{0} negate(f32[16]{0} %broadcast.4671) + %broadcast.7203 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[16]{0} %negate.7202), dimensions={0} + %divide.7204 = f32[16,32,32,1]{3,2,1,0} divide(f32[16,32,32,1]{3,2,1,0} %broadcast.7203, f32[16,32,32,1]{3,2,1,0} %add.2220) + %add.7205 = f32[16,32,32,1]{3,2,1,0} add(f32[16,32,32,1]{3,2,1,0} %negate.7109, f32[16,32,32,1]{3,2,1,0} %divide.7204) + %compare.2203 = pred[16,32,32,1]{3,2,1,0} compare(f32[16,32,32,1]{3,2,1,0} %multiply.2199, f32[16,32,32,1]{3,2,1,0} %maximum.2202), direction=EQ + %constant.2204 = f32[] constant(1) + %broadcast.2205 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.2204), dimensions={} + %constant.2206 = f32[] constant(0) + %broadcast.2207 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.2206), dimensions={} + %select.2208 = f32[16,32,32,1]{3,2,1,0} select(pred[16,32,32,1]{3,2,1,0} %compare.2203, f32[16,32,32,1]{3,2,1,0} %broadcast.2205, f32[16,32,32,1]{3,2,1,0} %broadcast.2207) + %constant.2209 = f32[] constant(0) + %broadcast.2210 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.2209), dimensions={} + %compare.2211 = pred[16,32,32,1]{3,2,1,0} compare(f32[16,32,32,1]{3,2,1,0} %broadcast.2210, f32[16,32,32,1]{3,2,1,0} %maximum.2202), direction=EQ + %constant.2212 = f32[] constant(2) + %broadcast.2213 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.2212), dimensions={} + %constant.2214 = f32[] constant(1) + %broadcast.2215 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.2214), dimensions={} + %select.2216 = f32[16,32,32,1]{3,2,1,0} select(pred[16,32,32,1]{3,2,1,0} %compare.2211, f32[16,32,32,1]{3,2,1,0} %broadcast.2213, f32[16,32,32,1]{3,2,1,0} %broadcast.2215) + %divide.2217 = f32[16,32,32,1]{3,2,1,0} divide(f32[16,32,32,1]{3,2,1,0} %select.2208, f32[16,32,32,1]{3,2,1,0} %select.2216) + %multiply.7206 = f32[16,32,32,1]{3,2,1,0} multiply(f32[16,32,32,1]{3,2,1,0} %add.7205, f32[16,32,32,1]{3,2,1,0} %divide.2217) + %constant.7207 = f32[] constant(0.5) + %broadcast.7208 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.7207), dimensions={} + %multiply.7209 = f32[16,32,32,1]{3,2,1,0} multiply(f32[16,32,32,1]{3,2,1,0} %multiply.7206, f32[16,32,32,1]{3,2,1,0} %broadcast.7208) + %constant.2193 = f32[] constant(0.5) + %broadcast.2194 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.2193), dimensions={} + %divide.2195 = f32[16,32,32,1]{3,2,1,0} divide(f32[16,32,32,1]{3,2,1,0} %broadcast.2194, f32[16,32,32,1]{3,2,1,0} %sqrt.2192) + %multiply.7210 = f32[16,32,32,1]{3,2,1,0} multiply(f32[16,32,32,1]{3,2,1,0} %multiply.7209, f32[16,32,32,1]{3,2,1,0} %divide.2195) + %constant.2186 = f32[] constant(2) + %broadcast.2187 = f32[16,32,32,1]{3,2,1,0} broadcast(f32[] %constant.2186), dimensions={} + %multiply.2188 = f32[16,32,32,1]{3,2,1,0} multiply(f32[16,32,32,1]{3,2,1,0} %broadcast.2187, f32[16,32,32,1]{3,2,1,0} %slice.2183) + %multiply.7211 = f32[16,32,32,1]{3,2,1,0} multiply(f32[16,32,32,1]{3,2,1,0} %multiply.7210, f32[16,32,32,1]{3,2,1,0} %multiply.2188) + %add.7212 = f32[16,32,32,1]{3,2,1,0} add(f32[16,32,32,1]{3,2,1,0} %multiply.7209, f32[16,32,32,1]{3,2,1,0} %multiply.7211) + %constant.7213 = f32[] constant(0) + %pad.7214 = f32[16,32,32,2]{3,2,1,0} pad(f32[16,32,32,1]{3,2,1,0} %add.7212, f32[] %constant.7213), padding=0_0x0_0x0_0x0_1 + %add.7215 = f32[16,32,32,2]{3,2,1,0} add(f32[16,32,32,2]{3,2,1,0} %pad.7113, f32[16,32,32,2]{3,2,1,0} %pad.7214) + %broadcast.7223 = f32[16,32,32,2]{3,2,1,0} broadcast(f32[] %parameter.15), dimensions={} + %multiply.7224 = f32[16,32,32,2]{3,2,1,0} multiply(f32[16,32,32,2]{3,2,1,0} %add.7215, f32[16,32,32,2]{3,2,1,0} %broadcast.7223) + %reshape.7254 = f32[2]{0} reshape(f32[1,1,1,2]{3,2,1,0} %broadcast.2173) + %broadcast.7255 = f32[16,32,32,2]{3,2,1,0} broadcast(f32[2]{0} %reshape.7254), dimensions={3} + %multiply.7256 = f32[16,32,32,2]{3,2,1,0} multiply(f32[16,32,32,2]{3,2,1,0} %multiply.7224, f32[16,32,32,2]{3,2,1,0} %broadcast.7255) + %reverse.7280 = f32[1,1,8,2]{3,2,1,0} reverse(f32[1,1,8,2]{3,2,1,0} %multiply.2171), dimensions={0,1} + %convolution.7281 = f32[16,32,32,8]{3,2,1,0} convolution(f32[16,32,32,2]{3,2,1,0} %multiply.7256, f32[1,1,8,2]{3,2,1,0} %reverse.7280), window={size=1x1}, dim_labels=b01f_01oi->b01f + %constant.7325 = pred[] constant(false) + %constant.7326 = pred[] constant(false) + %constant.7327 = pred[] constant(false) + %constant.7328 = pred[] constant(false) + %constant.7329 = pred[] constant(false) + %constant.7330 = pred[] constant(false) + %constant.7331 = pred[] constant(false) + %constant.7332 = pred[] constant(false) + %constant.7333 = pred[] constant(false) + %constant.7308 = f32[] constant(0) + %broadcast.7309 = f32[2,16]{1,0} broadcast(f32[] %constant.7308), dimensions={} + %constant.7310 = f32[] constant(0) + %broadcast.7311 = f32[2,16]{1,0} broadcast(f32[] %constant.7310), dimensions={} + %constant.7312 = f32[] constant(0) + %broadcast.7313 = f32[2,3,3,8,16]{4,3,2,1,0} broadcast(f32[] %constant.7312), dimensions={} + %constant.7314 = f32[] constant(0) + %broadcast.7315 = f32[2,16]{1,0} broadcast(f32[] %constant.7314), dimensions={} + %constant.7316 = f32[] constant(0) + %broadcast.7317 = f32[2,16]{1,0} broadcast(f32[] %constant.7316), dimensions={} + %constant.7318 = f32[] constant(0) + %broadcast.7319 = f32[2,1,1,16,16]{4,3,2,1,0} broadcast(f32[] %constant.7318), dimensions={} + %constant.7320 = f32[] constant(0) + %broadcast.7321 = f32[2,8]{1,0} broadcast(f32[] %constant.7320), dimensions={} + %constant.7322 = f32[] constant(0) + %broadcast.7323 = f32[2,8]{1,0} broadcast(f32[] %constant.7322), dimensions={} + %tuple.7334 = (f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) tuple(f32[2,16]{1,0} %broadcast.7283, f32[2,16]{1,0} %broadcast.7285, f32[2,3,3,8,16]{4,3,2,1,0} %broadcast.7287, f32[2,16]{1,0} %broadcast.7289, f32[2,16]{1,0} %broadcast.7291, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0} %broadcast.7293, f32[2,8]{1,0} %broadcast.7295, f32[2,8]{1,0} %broadcast.7297, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2118, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2119, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2120, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2121, f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.2122, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2123, f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.2124, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0} %parameter.3, f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.2125, f32[2,16]{1,0} %get-tuple-element.2126, f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.2127, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2128, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2129, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2130, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2131, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2132, f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.2133, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2134, f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.2135, f32[2,1,1,16,16]{4,3,2,1,0} %parameter.6, f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.2136, f32[2,16]{1,0} %get-tuple-element.2137, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0} %get-tuple-element.2138, f32[2,16,32,32,16]{4,3,2,1,0} %get-tuple-element.2139, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2140, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2141, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2142, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2143, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2144, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2145, f32[2,16,1,1,8]{4,3,2,1,0} %get-tuple-element.2146, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2147, /*index=40*/f32[2,16,1024,8]{3,2,1,0} %get-tuple-element.2148, f32[2,16,8]{2,1,0} %get-tuple-element.2149, f32[2,16,8]{2,1,0} %get-tuple-element.2150, f32[2,1,1,1,8]{4,3,2,1,0} %get-tuple-element.2151, f32[2,16,32,32,8]{4,3,2,1,0} %get-tuple-element.2152, /*index=45*/s32[] %constant.7324, pred[] %constant.7298, f32[16,32,32,8]{3,2,1,0} %convolution.7281, pred[] %constant.7325, pred[] %constant.7326, /*index=50*/pred[] %constant.7327, pred[] %constant.7328, pred[] %constant.7329, pred[] %constant.7330, pred[] %constant.7331, /*index=55*/pred[] %constant.7332, pred[] %constant.7333, f32[2,16]{1,0} %broadcast.7309, f32[2,16]{1,0} %broadcast.7311, f32[2,3,3,8,16]{4,3,2,1,0} %broadcast.7313, /*index=60*/f32[2,16]{1,0} %broadcast.7315, f32[2,16]{1,0} %broadcast.7317, f32[2,1,1,16,16]{4,3,2,1,0} %broadcast.7319, f32[2,8]{1,0} %broadcast.7321, f32[2,8]{1,0} %broadcast.7323) + %while.9418 = (f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) while((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.7334), condition=%cond_computation__3.9348, body=%body_computation__3.7415 + %get-tuple-element.9419 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=0 + %get-tuple-element.9420 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=1 + %get-tuple-element.9421 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=2 + %get-tuple-element.9422 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=3 + %get-tuple-element.9423 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=4 + %get-tuple-element.9424 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=5 + %get-tuple-element.9425 = f32[2,8]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=6 + %get-tuple-element.9426 = f32[2,8]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=7 + %get-tuple-element.9427 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=8 + %get-tuple-element.9428 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=9 + %get-tuple-element.9429 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=10 + %get-tuple-element.9430 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=11 + %get-tuple-element.9431 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=12 + %get-tuple-element.9432 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=13 + %get-tuple-element.9433 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=14 + %get-tuple-element.9434 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=15 + %get-tuple-element.9435 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=16 + %get-tuple-element.9436 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=17 + %get-tuple-element.9437 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=18 + %get-tuple-element.9438 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=19 + %get-tuple-element.9439 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=20 + %get-tuple-element.9440 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=21 + %get-tuple-element.9441 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=22 + %get-tuple-element.9442 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=23 + %get-tuple-element.9443 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=24 + %get-tuple-element.9444 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=25 + %get-tuple-element.9445 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=26 + %get-tuple-element.9446 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=27 + %get-tuple-element.9447 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=28 + %get-tuple-element.9448 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=29 + %get-tuple-element.9449 = f32[2,1,1,1,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=30 + %get-tuple-element.9450 = f32[2,16,32,32,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=31 + %get-tuple-element.9451 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=32 + %get-tuple-element.9452 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=33 + %get-tuple-element.9453 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=34 + %get-tuple-element.9454 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=35 + %get-tuple-element.9455 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=36 + %get-tuple-element.9456 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=37 + %get-tuple-element.9457 = f32[2,16,1,1,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=38 + %get-tuple-element.9458 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=39 + %get-tuple-element.9459 = f32[2,16,1024,8]{3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=40 + %get-tuple-element.9460 = f32[2,16,8]{2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=41 + %get-tuple-element.9461 = f32[2,16,8]{2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=42 + %get-tuple-element.9462 = f32[2,1,1,1,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=43 + %get-tuple-element.9463 = f32[2,16,32,32,8]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=44 + %get-tuple-element.9464 = s32[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=45 + %get-tuple-element.9465 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=46 + %get-tuple-element.9466 = f32[16,32,32,8]{3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=47 + %get-tuple-element.9467 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=48 + %get-tuple-element.9468 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=49 + %get-tuple-element.9469 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=50 + %get-tuple-element.9470 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=51 + %get-tuple-element.9471 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=52 + %get-tuple-element.9472 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=53 + %get-tuple-element.9473 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=54 + %get-tuple-element.9474 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=55 + %get-tuple-element.9475 = pred[] get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=56 + %get-tuple-element.9476 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=57 + %get-tuple-element.9477 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=58 + %get-tuple-element.9478 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=59 + %get-tuple-element.9479 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=60 + %get-tuple-element.9480 = f32[2,16]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=61 + %get-tuple-element.9481 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=62 + %get-tuple-element.9482 = f32[2,8]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=63 + %get-tuple-element.9483 = f32[2,8]{1,0} get-tuple-element((f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=10*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, /*index=15*/f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, /*index=20*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, /*index=25*/f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=30*/f32[2,1,1,1,16]{4,3,2,1,0}, f32[2,16,32,32,16]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=35*/f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, f32[2,16,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=40*/f32[2,16,1024,8]{3,2,1,0}, f32[2,16,8]{2,1,0}, f32[2,16,8]{2,1,0}, f32[2,1,1,1,8]{4,3,2,1,0}, f32[2,16,32,32,8]{4,3,2,1,0}, /*index=45*/s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=50*/pred[], pred[], pred[], pred[], pred[], /*index=55*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=60*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %while.9418), index=64 + %tuple.9484 = (s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) tuple(s32[] %get-tuple-element.9464, pred[] %get-tuple-element.9465, f32[16,32,32,8]{3,2,1,0} %get-tuple-element.9466, pred[] %get-tuple-element.9467, pred[] %get-tuple-element.9468, /*index=5*/pred[] %get-tuple-element.9469, pred[] %get-tuple-element.9470, pred[] %get-tuple-element.9471, pred[] %get-tuple-element.9472, pred[] %get-tuple-element.9473, /*index=10*/pred[] %get-tuple-element.9474, pred[] %get-tuple-element.9475, f32[2,16]{1,0} %get-tuple-element.9476, f32[2,16]{1,0} %get-tuple-element.9477, f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.9478, /*index=15*/f32[2,16]{1,0} %get-tuple-element.9479, f32[2,16]{1,0} %get-tuple-element.9480, f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.9481, f32[2,8]{1,0} %get-tuple-element.9482, f32[2,8]{1,0} %get-tuple-element.9483) + %get-tuple-element.9485 = s32[] get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9484), index=0 + %get-tuple-element.9486 = pred[] get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9484), index=1 + %get-tuple-element.9487 = f32[16,32,32,8]{3,2,1,0} get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9484), index=2 + %get-tuple-element.9488 = pred[] get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9484), index=3 + %get-tuple-element.9489 = pred[] get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9484), index=4 + %get-tuple-element.9490 = pred[] get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9484), index=5 + %get-tuple-element.9491 = pred[] get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9484), index=6 + %get-tuple-element.9492 = pred[] get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9484), index=7 + %get-tuple-element.9493 = pred[] get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9484), index=8 + %get-tuple-element.9494 = pred[] get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9484), index=9 + %get-tuple-element.9495 = pred[] get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9484), index=10 + %get-tuple-element.9496 = pred[] get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9484), index=11 + %get-tuple-element.9497 = f32[2,16]{1,0} get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9484), index=12 + %get-tuple-element.9498 = f32[2,16]{1,0} get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9484), index=13 + %get-tuple-element.9499 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9484), index=14 + %get-tuple-element.9500 = f32[2,16]{1,0} get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9484), index=15 + %get-tuple-element.9501 = f32[2,16]{1,0} get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9484), index=16 + %get-tuple-element.9502 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9484), index=17 + %get-tuple-element.9503 = f32[2,8]{1,0} get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9484), index=18 + %get-tuple-element.9504 = f32[2,8]{1,0} get-tuple-element((s32[], pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9484), index=19 + %tuple.9505 = (pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) tuple(pred[] %get-tuple-element.9486, f32[16,32,32,8]{3,2,1,0} %get-tuple-element.9487, pred[] %get-tuple-element.9488, pred[] %get-tuple-element.9489, pred[] %get-tuple-element.9490, /*index=5*/pred[] %get-tuple-element.9491, pred[] %get-tuple-element.9492, pred[] %get-tuple-element.9493, pred[] %get-tuple-element.9494, pred[] %get-tuple-element.9495, /*index=10*/pred[] %get-tuple-element.9496, f32[2,16]{1,0} %get-tuple-element.9497, f32[2,16]{1,0} %get-tuple-element.9498, f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.9499, f32[2,16]{1,0} %get-tuple-element.9500, /*index=15*/f32[2,16]{1,0} %get-tuple-element.9501, f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.9502, f32[2,8]{1,0} %get-tuple-element.9503, f32[2,8]{1,0} %get-tuple-element.9504) + %get-tuple-element.9506 = pred[] get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9505), index=0 + %get-tuple-element.9508 = pred[] get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9505), index=2 + %get-tuple-element.9509 = pred[] get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9505), index=3 + %get-tuple-element.9510 = pred[] get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9505), index=4 + %get-tuple-element.9511 = pred[] get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9505), index=5 + %get-tuple-element.9512 = pred[] get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9505), index=6 + %get-tuple-element.9513 = pred[] get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9505), index=7 + %get-tuple-element.9514 = pred[] get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9505), index=8 + %get-tuple-element.9515 = pred[] get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9505), index=9 + %get-tuple-element.9516 = pred[] get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9505), index=10 + %log.2221 = f32[16,32,32,1]{3,2,1,0} log(f32[16,32,32,1]{3,2,1,0} %add.2220) + %constant.2228 = f32[] constant(0) + %reduce.2233 = f32[16]{0} reduce(f32[16,32,32,1]{3,2,1,0} %log.2221, f32[] %constant.2228), dimensions={3,2,1}, to_apply=%primitive_computation_add__1.2229 + %negate.2234 = f32[16]{0} negate(f32[16]{0} %reduce.2233) + %constant.2238 = f32[] constant(0) + %broadcast.2239 = f32[16]{0} broadcast(f32[] %constant.2238), dimensions={} + %add.2240 = f32[16]{0} add(f32[16]{0} %negate.2234, f32[16]{0} %broadcast.2239) + %get-tuple-element.2392 = f32[] get-tuple-element((f32[], f32[]) %tuple.2390), index=1 + %constant.2450 = f32[] constant(32) + %multiply.2451 = f32[] multiply(f32[] %get-tuple-element.2392, f32[] %constant.2450) + %constant.2452 = f32[] constant(32) + %multiply.2453 = f32[] multiply(f32[] %multiply.2451, f32[] %constant.2452) + %broadcast.2456 = f32[16]{0} broadcast(f32[] %multiply.2453), dimensions={} + %constant.2454 = f32[] constant(1) + %broadcast.2455 = f32[16]{0} broadcast(f32[] %constant.2454), dimensions={} + %multiply.2457 = f32[16]{0} multiply(f32[16]{0} %broadcast.2456, f32[16]{0} %broadcast.2455) + %add.2458 = f32[16]{0} add(f32[16]{0} %add.2240, f32[16]{0} %multiply.2457) + %log.4621 = f32[16,32,32,1]{3,2,1,0} log(f32[16,32,32,1]{3,2,1,0} %add.4620) + %constant.4628 = f32[] constant(0) + %reduce.4633 = f32[16]{0} reduce(f32[16,32,32,1]{3,2,1,0} %log.4621, f32[] %constant.4628), dimensions={3,2,1}, to_apply=%primitive_computation_add__1.4629 + %negate.4634 = f32[16]{0} negate(f32[16]{0} %reduce.4633) + %add.4636 = f32[16]{0} add(f32[16]{0} %add.2458, f32[16]{0} %negate.4634) + %multiply.4637 = f32[16,32,32,3]{3,2,1,0} multiply(f32[16,32,32,3]{3,2,1,0} %concatenate.4635, f32[16,32,32,3]{3,2,1,0} %concatenate.4635) + %constant.4641 = f32[] constant(0) + %reduce.4646 = f32[16]{0} reduce(f32[16,32,32,3]{3,2,1,0} %multiply.4637, f32[] %constant.4641), dimensions={3,2,1}, to_apply=%primitive_computation_add__1.4642 + %constant.4647 = f32[] constant(-0.5) + %broadcast.4648 = f32[16]{0} broadcast(f32[] %constant.4647), dimensions={} + %multiply.4649 = f32[16]{0} multiply(f32[16]{0} %reduce.4646, f32[16]{0} %broadcast.4648) + %constant.4650 = f32[] constant(6.28318548) + %log.4651 = f32[] log(f32[] %constant.4650) + %convert.4652 = f32[] convert(f32[] %log.4651) + %constant.4653 = f32[] constant(1536) + %multiply.4654 = f32[] multiply(f32[] %convert.4652, f32[] %constant.4653) + %broadcast.4655 = f32[16]{0} broadcast(f32[] %multiply.4654), dimensions={} + %subtract.4656 = f32[16]{0} subtract(f32[16]{0} %multiply.4649, f32[16]{0} %broadcast.4655) + %add.4657 = f32[16]{0} add(f32[16]{0} %add.4636, f32[16]{0} %subtract.4656) + %constant.4658 = f32[] constant(0) + %reduce.4663 = f32[] reduce(f32[16]{0} %add.4657, f32[] %constant.4658), dimensions={0}, to_apply=%primitive_computation_add__1.4659 + %constant.4664 = f32[] constant(16) + %divide.4665 = f32[] divide(f32[] %reduce.4663, f32[] %constant.4664) + %negate.4666 = f32[] negate(f32[] %divide.4665) + %get-tuple-element.9517 = f32[2,16]{1,0} get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9505), index=11 + %get-tuple-element.9518 = f32[2,16]{1,0} get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9505), index=12 + %get-tuple-element.9519 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9505), index=13 + %get-tuple-element.9520 = f32[2,16]{1,0} get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9505), index=14 + %get-tuple-element.9521 = f32[2,16]{1,0} get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9505), index=15 + %get-tuple-element.9522 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9505), index=16 + %get-tuple-element.9523 = f32[2,8]{1,0} get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9505), index=17 + %get-tuple-element.9524 = f32[2,8]{1,0} get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9505), index=18 + %get-tuple-element.9507 = f32[16,32,32,8]{3,2,1,0} get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.9505), index=1 + %constant.9525 = f32[] constant(0) + %reduce.9530 = f32[8]{0} reduce(f32[16,32,32,8]{3,2,1,0} %get-tuple-element.9507, f32[] %constant.9525), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.9526 + %reshape.9531 = f32[1,1,1,8]{3,2,1,0} reshape(f32[8]{0} %reduce.9530) + %constant.9532 = f32[] constant(0) + %reduce.9537 = f32[8]{0} reduce(f32[1,1,1,8]{3,2,1,0} %reshape.9531, f32[] %constant.9532), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.9533 + %broadcast.9538 = f32[8]{0} broadcast(f32[8]{0} %reduce.9537), dimensions={0} + %multiply.9539 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %convolution.128, f32[16,32,32,8]{3,2,1,0} %get-tuple-element.9507) + %constant.9540 = f32[] constant(0) + %reduce.9545 = f32[8]{0} reduce(f32[16,32,32,8]{3,2,1,0} %multiply.9539, f32[] %constant.9540), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.9541 + %reshape.9546 = f32[1,1,1,8]{3,2,1,0} reshape(f32[8]{0} %reduce.9545) + %constant.9547 = f32[] constant(0) + %reduce.9552 = f32[8]{0} reduce(f32[1,1,1,8]{3,2,1,0} %reshape.9546, f32[] %constant.9547), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.9548 + %broadcast.9553 = f32[8]{0} broadcast(f32[8]{0} %reduce.9552), dimensions={0} + %reshape.9554 = f32[8]{0} reshape(f32[1,1,1,8]{3,2,1,0} %broadcast.129) + %broadcast.9555 = f32[16,32,32,8]{3,2,1,0} broadcast(f32[8]{0} %reshape.9554), dimensions={3} + %multiply.9556 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %get-tuple-element.9507, f32[16,32,32,8]{3,2,1,0} %broadcast.9555) + %convolution.9557 = f32[1,1,2,8]{3,2,1,0} convolution(f32[16,32,32,2]{3,2,1,0} %broadcast.86, f32[16,32,32,8]{3,2,1,0} %multiply.9556), window={size=32x32}, dim_labels=f01b_i01o->01bf + %reshape.9566 = f32[1,1,8]{2,1,0} reshape(f32[1,1,1,8]{3,2,1,0} %broadcast.124) + %broadcast.9567 = f32[1,1,2,8]{3,2,1,0} broadcast(f32[1,1,8]{2,1,0} %reshape.9566), dimensions={0,1,3} + %multiply.9568 = f32[1,1,2,8]{3,2,1,0} multiply(f32[1,1,2,8]{3,2,1,0} %convolution.9557, f32[1,1,2,8]{3,2,1,0} %broadcast.9567) + %multiply.9558 = f32[1,1,2,8]{3,2,1,0} multiply(f32[1,1,2,8]{3,2,1,0} %parameter.11, f32[1,1,2,8]{3,2,1,0} %convolution.9557) + %constant.9559 = f32[] constant(0) + %reduce.9564 = f32[1,1,8]{2,1,0} reduce(f32[1,1,2,8]{3,2,1,0} %multiply.9558, f32[] %constant.9559), dimensions={2}, to_apply=%primitive_computation_add__1.9560 + %reshape.9565 = f32[1,1,1,8]{3,2,1,0} reshape(f32[1,1,8]{2,1,0} %reduce.9564) + %constant.9569 = f32[] constant(0) + %reduce.9574 = f32[8]{0} reduce(f32[1,1,1,8]{3,2,1,0} %reshape.9565, f32[] %constant.9569), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.9570 + %broadcast.9575 = f32[8]{0} broadcast(f32[8]{0} %reduce.9574), dimensions={0} + %constant.121 = f32[] constant(-0.5) + %broadcast.122 = f32[8]{0} broadcast(f32[] %constant.121), dimensions={} + %divide.120 = f32[8]{0} divide(f32[8]{0} %rsqrt.119, f32[8]{0} %reduce.118) + %multiply.123 = f32[8]{0} multiply(f32[8]{0} %broadcast.122, f32[8]{0} %divide.120) + %multiply.9576 = f32[8]{0} multiply(f32[8]{0} %broadcast.9575, f32[8]{0} %multiply.123) + %broadcast.9577 = f32[1,1,2,8]{3,2,1,0} broadcast(f32[8]{0} %multiply.9576), dimensions={3} + %constant.110 = f32[] constant(2) + %broadcast.111 = f32[1,1,2,8]{3,2,1,0} broadcast(f32[] %constant.110), dimensions={} + %multiply.112 = f32[1,1,2,8]{3,2,1,0} multiply(f32[1,1,2,8]{3,2,1,0} %broadcast.111, f32[1,1,2,8]{3,2,1,0} %parameter.11) + %multiply.9578 = f32[1,1,2,8]{3,2,1,0} multiply(f32[1,1,2,8]{3,2,1,0} %broadcast.9577, f32[1,1,2,8]{3,2,1,0} %multiply.112) + %add.9579 = f32[1,1,2,8]{3,2,1,0} add(f32[1,1,2,8]{3,2,1,0} %multiply.9568, f32[1,1,2,8]{3,2,1,0} %multiply.9578) + %constant.7225 = f32[] constant(0) + %reduce.7230 = f32[2]{0} reduce(f32[16,32,32,2]{3,2,1,0} %multiply.7224, f32[] %constant.7225), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7226 + %reshape.7231 = f32[1,1,1,2]{3,2,1,0} reshape(f32[2]{0} %reduce.7230) + %constant.7232 = f32[] constant(0) + %reduce.7237 = f32[2]{0} reduce(f32[1,1,1,2]{3,2,1,0} %reshape.7231, f32[] %constant.7232), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7233 + %broadcast.7238 = f32[2]{0} broadcast(f32[2]{0} %reduce.7237), dimensions={0} + %multiply.7239 = f32[16,32,32,2]{3,2,1,0} multiply(f32[16,32,32,2]{3,2,1,0} %convolution.2172, f32[16,32,32,2]{3,2,1,0} %multiply.7224) + %constant.7240 = f32[] constant(0) + %reduce.7245 = f32[2]{0} reduce(f32[16,32,32,2]{3,2,1,0} %multiply.7239, f32[] %constant.7240), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7241 + %reshape.7246 = f32[1,1,1,2]{3,2,1,0} reshape(f32[2]{0} %reduce.7245) + %constant.7247 = f32[] constant(0) + %reduce.7252 = f32[2]{0} reduce(f32[1,1,1,2]{3,2,1,0} %reshape.7246, f32[] %constant.7247), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7248 + %broadcast.7253 = f32[2]{0} broadcast(f32[2]{0} %reduce.7252), dimensions={0} + %convolution.7257 = f32[1,1,8,2]{3,2,1,0} convolution(f32[16,32,32,8]{3,2,1,0} %get-tuple-element.2108, f32[16,32,32,2]{3,2,1,0} %multiply.7256), window={size=32x32}, dim_labels=f01b_i01o->01bf + %reshape.7266 = f32[1,1,2]{2,1,0} reshape(f32[1,1,1,2]{3,2,1,0} %broadcast.2168) + %broadcast.7267 = f32[1,1,8,2]{3,2,1,0} broadcast(f32[1,1,2]{2,1,0} %reshape.7266), dimensions={0,1,3} + %multiply.7268 = f32[1,1,8,2]{3,2,1,0} multiply(f32[1,1,8,2]{3,2,1,0} %convolution.7257, f32[1,1,8,2]{3,2,1,0} %broadcast.7267) + %multiply.7258 = f32[1,1,8,2]{3,2,1,0} multiply(f32[1,1,8,2]{3,2,1,0} %parameter.14, f32[1,1,8,2]{3,2,1,0} %convolution.7257) + %constant.7259 = f32[] constant(0) + %reduce.7264 = f32[1,1,2]{2,1,0} reduce(f32[1,1,8,2]{3,2,1,0} %multiply.7258, f32[] %constant.7259), dimensions={2}, to_apply=%primitive_computation_add__1.7260 + %reshape.7265 = f32[1,1,1,2]{3,2,1,0} reshape(f32[1,1,2]{2,1,0} %reduce.7264) + %constant.7269 = f32[] constant(0) + %reduce.7274 = f32[2]{0} reduce(f32[1,1,1,2]{3,2,1,0} %reshape.7265, f32[] %constant.7269), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7270 + %broadcast.7275 = f32[2]{0} broadcast(f32[2]{0} %reduce.7274), dimensions={0} + %constant.2165 = f32[] constant(-0.5) + %broadcast.2166 = f32[2]{0} broadcast(f32[] %constant.2165), dimensions={} + %divide.2164 = f32[2]{0} divide(f32[2]{0} %rsqrt.2163, f32[2]{0} %reduce.2162) + %multiply.2167 = f32[2]{0} multiply(f32[2]{0} %broadcast.2166, f32[2]{0} %divide.2164) + %multiply.7276 = f32[2]{0} multiply(f32[2]{0} %broadcast.7275, f32[2]{0} %multiply.2167) + %broadcast.7277 = f32[1,1,8,2]{3,2,1,0} broadcast(f32[2]{0} %multiply.7276), dimensions={3} + %constant.2154 = f32[] constant(2) + %broadcast.2155 = f32[1,1,8,2]{3,2,1,0} broadcast(f32[] %constant.2154), dimensions={} + %multiply.2156 = f32[1,1,8,2]{3,2,1,0} multiply(f32[1,1,8,2]{3,2,1,0} %broadcast.2155, f32[1,1,8,2]{3,2,1,0} %parameter.14) + %multiply.7278 = f32[1,1,8,2]{3,2,1,0} multiply(f32[1,1,8,2]{3,2,1,0} %broadcast.7277, f32[1,1,8,2]{3,2,1,0} %multiply.2156) + %add.7279 = f32[1,1,8,2]{3,2,1,0} add(f32[1,1,8,2]{3,2,1,0} %multiply.7268, f32[1,1,8,2]{3,2,1,0} %multiply.7278) + %multiply.7216 = f32[16,32,32,2]{3,2,1,0} multiply(f32[16,32,32,2]{3,2,1,0} %add.2180, f32[16,32,32,2]{3,2,1,0} %add.7215) + %constant.7217 = f32[] constant(0) + %reduce.7222 = f32[] reduce(f32[16,32,32,2]{3,2,1,0} %multiply.7216, f32[] %constant.7217), dimensions={0,1,2,3}, to_apply=%primitive_computation_add__1.7218 + %convolution.7096 = f32[1,1,3,3]{3,2,1,0} convolution(f32[16,32,32,3]{3,2,1,0} %concatenate.2235, f32[16,32,32,3]{3,2,1,0} %add.7095), window={size=32x32}, dim_labels=f01b_i01o->01bf + %constant.7097 = f32[] constant(0) + %reduce.7102 = f32[3,3]{1,0} reduce(f32[1,1,3,3]{3,2,1,0} %convolution.7096, f32[] %constant.7097), dimensions={0,1}, to_apply=%primitive_computation_add__1.7098 + %broadcast.7103 = f32[3,3]{1,0} broadcast(f32[3,3]{1,0} %reduce.7102), dimensions={0,1} + %get-tuple-element.2426 = f32[3,3]{1,0} get-tuple-element((pred[], f32[3,3]{1,0}, f32[3,3]{1,0}, s32[3]{0}) %call.2424), index=1 + %get-tuple-element.2427 = f32[3,3]{1,0} get-tuple-element((pred[], f32[3,3]{1,0}, f32[3,3]{1,0}, s32[3]{0}) %call.2424), index=2 + %get-tuple-element.2428 = s32[3]{0} get-tuple-element((pred[], f32[3,3]{1,0}, f32[3,3]{1,0}, s32[3]{0}) %call.2424), index=3 + %get-tuple-element.2448 = pred[3,3]{1,0} get-tuple-element((pred[], pred[3,3]{1,0}, f32[3,3]{1,0}) %call.2446), index=1 + %get-tuple-element.2449 = f32[3,3]{1,0} get-tuple-element((pred[], pred[3,3]{1,0}, f32[3,3]{1,0}) %call.2446), index=2 + %multiply.7114 = f32[16]{0} multiply(f32[16]{0} %broadcast.4671, f32[16]{0} %broadcast.2455) + %constant.7115 = f32[] constant(0) + %reduce.7120 = f32[] reduce(f32[16]{0} %multiply.7114, f32[] %constant.7115), dimensions={0}, to_apply=%primitive_computation_add__1.7116 + %constant.7121 = f32[] constant(32) + %multiply.7122 = f32[] multiply(f32[] %reduce.7120, f32[] %constant.7121) + %constant.7123 = f32[] constant(32) + %multiply.7124 = f32[] multiply(f32[] %multiply.7122, f32[] %constant.7123) + %broadcast.7125 = f32[3,3]{1,0} broadcast(f32[] %multiply.7124), dimensions={} + %call.7135 = (f32[3,3]{1,0}) call(pred[3,3]{1,0} %get-tuple-element.2448, f32[3,3]{1,0} %get-tuple-element.2449, f32[3,3]{1,0} %broadcast.7125), to_apply=%jit_transpose__where_.7126 + %get-tuple-element.7136 = f32[3,3]{1,0} get-tuple-element((f32[3,3]{1,0}) %call.7135), index=0 + %transpose.7137 = f32[3,3]{0,1} transpose(f32[3,3]{1,0} %get-tuple-element.7136), dimensions={1,0} + %call.7199 = (f32[3,3]{0,1}) call(f32[3,3]{1,0} %get-tuple-element.2426, f32[3,3]{1,0} %get-tuple-element.2427, s32[3]{0} %get-tuple-element.2428, f32[3,3]{0,1} %transpose.7137), to_apply=%jit_transpose_solve_.7185 + %get-tuple-element.7200 = f32[3,3]{0,1} get-tuple-element((f32[3,3]{0,1}) %call.7199), index=0 + %add.7201 = f32[3,3]{1,0} add(f32[3,3]{1,0} %broadcast.7103, f32[3,3]{0,1} %get-tuple-element.7200) + %get-tuple-element.7015 = f32[2,16]{1,0} get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.7003), index=11 + %get-tuple-element.7016 = f32[2,16]{1,0} get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.7003), index=12 + %get-tuple-element.7017 = f32[2,3,3,8,16]{4,3,2,1,0} get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.7003), index=13 + %get-tuple-element.7018 = f32[2,16]{1,0} get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.7003), index=14 + %get-tuple-element.7019 = f32[2,16]{1,0} get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.7003), index=15 + %get-tuple-element.7020 = f32[2,1,1,16,16]{4,3,2,1,0} get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.7003), index=16 + %get-tuple-element.7021 = f32[2,8]{1,0} get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.7003), index=17 + %get-tuple-element.7022 = f32[2,8]{1,0} get-tuple-element((pred[], f32[16,32,32,8]{3,2,1,0}, pred[], pred[], pred[], /*index=5*/pred[], pred[], pred[], pred[], pred[], /*index=10*/pred[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=15*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}) %tuple.7003), index=18 + %constant.7023 = f32[] constant(0) + %reduce.7028 = f32[8]{0} reduce(f32[16,32,32,8]{3,2,1,0} %get-tuple-element.7005, f32[] %constant.7023), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7024 + %reshape.7029 = f32[1,1,1,8]{3,2,1,0} reshape(f32[8]{0} %reduce.7028) + %constant.7030 = f32[] constant(0) + %reduce.7035 = f32[8]{0} reduce(f32[1,1,1,8]{3,2,1,0} %reshape.7029, f32[] %constant.7030), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7031 + %broadcast.7036 = f32[8]{0} broadcast(f32[8]{0} %reduce.7035), dimensions={0} + %multiply.7037 = f32[16,32,32,8]{3,2,1,0} multiply(f32[16,32,32,8]{3,2,1,0} %convolution.2528, f32[16,32,32,8]{3,2,1,0} %get-tuple-element.7005) + %constant.7038 = f32[] constant(0) + %reduce.7043 = f32[8]{0} reduce(f32[16,32,32,8]{3,2,1,0} %multiply.7037, f32[] %constant.7038), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7039 + %reshape.7044 = f32[1,1,1,8]{3,2,1,0} reshape(f32[8]{0} %reduce.7043) + %constant.7045 = f32[] constant(0) + %reduce.7050 = f32[8]{0} reduce(f32[1,1,1,8]{3,2,1,0} %reshape.7044, f32[] %constant.7045), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7046 + %broadcast.7051 = f32[8]{0} broadcast(f32[8]{0} %reduce.7050), dimensions={0} + %convolution.7055 = f32[1,1,2,8]{3,2,1,0} convolution(f32[16,32,32,2]{3,2,1,0} %broadcast.2486, f32[16,32,32,8]{3,2,1,0} %multiply.7054), window={size=32x32}, dim_labels=f01b_i01o->01bf + %reshape.7064 = f32[1,1,8]{2,1,0} reshape(f32[1,1,1,8]{3,2,1,0} %broadcast.2524) + %broadcast.7065 = f32[1,1,2,8]{3,2,1,0} broadcast(f32[1,1,8]{2,1,0} %reshape.7064), dimensions={0,1,3} + %multiply.7066 = f32[1,1,2,8]{3,2,1,0} multiply(f32[1,1,2,8]{3,2,1,0} %convolution.7055, f32[1,1,2,8]{3,2,1,0} %broadcast.7065) + %multiply.7056 = f32[1,1,2,8]{3,2,1,0} multiply(f32[1,1,2,8]{3,2,1,0} %parameter.27, f32[1,1,2,8]{3,2,1,0} %convolution.7055) + %constant.7057 = f32[] constant(0) + %reduce.7062 = f32[1,1,8]{2,1,0} reduce(f32[1,1,2,8]{3,2,1,0} %multiply.7056, f32[] %constant.7057), dimensions={2}, to_apply=%primitive_computation_add__1.7058 + %reshape.7063 = f32[1,1,1,8]{3,2,1,0} reshape(f32[1,1,8]{2,1,0} %reduce.7062) + %constant.7067 = f32[] constant(0) + %reduce.7072 = f32[8]{0} reduce(f32[1,1,1,8]{3,2,1,0} %reshape.7063, f32[] %constant.7067), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.7068 + %broadcast.7073 = f32[8]{0} broadcast(f32[8]{0} %reduce.7072), dimensions={0} + %constant.2521 = f32[] constant(-0.5) + %broadcast.2522 = f32[8]{0} broadcast(f32[] %constant.2521), dimensions={} + %divide.2520 = f32[8]{0} divide(f32[8]{0} %rsqrt.2519, f32[8]{0} %reduce.2518) + %multiply.2523 = f32[8]{0} multiply(f32[8]{0} %broadcast.2522, f32[8]{0} %divide.2520) + %multiply.7074 = f32[8]{0} multiply(f32[8]{0} %broadcast.7073, f32[8]{0} %multiply.2523) + %broadcast.7075 = f32[1,1,2,8]{3,2,1,0} broadcast(f32[8]{0} %multiply.7074), dimensions={3} + %constant.2510 = f32[] constant(2) + %broadcast.2511 = f32[1,1,2,8]{3,2,1,0} broadcast(f32[] %constant.2510), dimensions={} + %multiply.2512 = f32[1,1,2,8]{3,2,1,0} multiply(f32[1,1,2,8]{3,2,1,0} %broadcast.2511, f32[1,1,2,8]{3,2,1,0} %parameter.27) + %multiply.7076 = f32[1,1,2,8]{3,2,1,0} multiply(f32[1,1,2,8]{3,2,1,0} %broadcast.7075, f32[1,1,2,8]{3,2,1,0} %multiply.2512) + %add.7077 = f32[1,1,2,8]{3,2,1,0} add(f32[1,1,2,8]{3,2,1,0} %multiply.7066, f32[1,1,2,8]{3,2,1,0} %multiply.7076) + %constant.4723 = f32[] constant(0) + %reduce.4728 = f32[2]{0} reduce(f32[16,32,32,2]{3,2,1,0} %multiply.4722, f32[] %constant.4723), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.4724 + %reshape.4729 = f32[1,1,1,2]{3,2,1,0} reshape(f32[2]{0} %reduce.4728) + %constant.4730 = f32[] constant(0) + %reduce.4735 = f32[2]{0} reduce(f32[1,1,1,2]{3,2,1,0} %reshape.4729, f32[] %constant.4730), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.4731 + %broadcast.4736 = f32[2]{0} broadcast(f32[2]{0} %reduce.4735), dimensions={0} + %multiply.4737 = f32[16,32,32,2]{3,2,1,0} multiply(f32[16,32,32,2]{3,2,1,0} %convolution.4572, f32[16,32,32,2]{3,2,1,0} %multiply.4722) + %constant.4738 = f32[] constant(0) + %reduce.4743 = f32[2]{0} reduce(f32[16,32,32,2]{3,2,1,0} %multiply.4737, f32[] %constant.4738), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.4739 + %reshape.4744 = f32[1,1,1,2]{3,2,1,0} reshape(f32[2]{0} %reduce.4743) + %constant.4745 = f32[] constant(0) + %reduce.4750 = f32[2]{0} reduce(f32[1,1,1,2]{3,2,1,0} %reshape.4744, f32[] %constant.4745), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.4746 + %broadcast.4751 = f32[2]{0} broadcast(f32[2]{0} %reduce.4750), dimensions={0} + %convolution.4755 = f32[1,1,8,2]{3,2,1,0} convolution(f32[16,32,32,8]{3,2,1,0} %get-tuple-element.4508, f32[16,32,32,2]{3,2,1,0} %multiply.4754), window={size=32x32}, dim_labels=f01b_i01o->01bf + %reshape.4764 = f32[1,1,2]{2,1,0} reshape(f32[1,1,1,2]{3,2,1,0} %broadcast.4568) + %broadcast.4765 = f32[1,1,8,2]{3,2,1,0} broadcast(f32[1,1,2]{2,1,0} %reshape.4764), dimensions={0,1,3} + %multiply.4766 = f32[1,1,8,2]{3,2,1,0} multiply(f32[1,1,8,2]{3,2,1,0} %convolution.4755, f32[1,1,8,2]{3,2,1,0} %broadcast.4765) + %multiply.4756 = f32[1,1,8,2]{3,2,1,0} multiply(f32[1,1,8,2]{3,2,1,0} %parameter.30, f32[1,1,8,2]{3,2,1,0} %convolution.4755) + %constant.4757 = f32[] constant(0) + %reduce.4762 = f32[1,1,2]{2,1,0} reduce(f32[1,1,8,2]{3,2,1,0} %multiply.4756, f32[] %constant.4757), dimensions={2}, to_apply=%primitive_computation_add__1.4758 + %reshape.4763 = f32[1,1,1,2]{3,2,1,0} reshape(f32[1,1,2]{2,1,0} %reduce.4762) + %constant.4767 = f32[] constant(0) + %reduce.4772 = f32[2]{0} reduce(f32[1,1,1,2]{3,2,1,0} %reshape.4763, f32[] %constant.4767), dimensions={0,1,2}, to_apply=%primitive_computation_add__1.4768 + %broadcast.4773 = f32[2]{0} broadcast(f32[2]{0} %reduce.4772), dimensions={0} + %constant.4565 = f32[] constant(-0.5) + %broadcast.4566 = f32[2]{0} broadcast(f32[] %constant.4565), dimensions={} + %divide.4564 = f32[2]{0} divide(f32[2]{0} %rsqrt.4563, f32[2]{0} %reduce.4562) + %multiply.4567 = f32[2]{0} multiply(f32[2]{0} %broadcast.4566, f32[2]{0} %divide.4564) + %multiply.4774 = f32[2]{0} multiply(f32[2]{0} %broadcast.4773, f32[2]{0} %multiply.4567) + %broadcast.4775 = f32[1,1,8,2]{3,2,1,0} broadcast(f32[2]{0} %multiply.4774), dimensions={3} + %constant.4554 = f32[] constant(2) + %broadcast.4555 = f32[1,1,8,2]{3,2,1,0} broadcast(f32[] %constant.4554), dimensions={} + %multiply.4556 = f32[1,1,8,2]{3,2,1,0} multiply(f32[1,1,8,2]{3,2,1,0} %broadcast.4555, f32[1,1,8,2]{3,2,1,0} %parameter.30) + %multiply.4776 = f32[1,1,8,2]{3,2,1,0} multiply(f32[1,1,8,2]{3,2,1,0} %broadcast.4775, f32[1,1,8,2]{3,2,1,0} %multiply.4556) + %add.4777 = f32[1,1,8,2]{3,2,1,0} add(f32[1,1,8,2]{3,2,1,0} %multiply.4766, f32[1,1,8,2]{3,2,1,0} %multiply.4776) + %multiply.4714 = f32[16,32,32,2]{3,2,1,0} multiply(f32[16,32,32,2]{3,2,1,0} %add.4580, f32[16,32,32,2]{3,2,1,0} %add.4713) + %constant.4715 = f32[] constant(0) + %reduce.4720 = f32[] reduce(f32[16,32,32,2]{3,2,1,0} %multiply.4714, f32[] %constant.4715), dimensions={0,1,2,3}, to_apply=%primitive_computation_add__1.4716 + ROOT %tuple.9580 = (f32[], f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, f32[2,16]{1,0}, /*index=5*/f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, f32[8]{0}, /*index=10*/f32[8]{0}, f32[1,1,2,8]{3,2,1,0}, f32[2]{0}, f32[2]{0}, f32[1,1,8,2]{3,2,1,0}, /*index=15*/f32[], f32[3,3]{1,0}, f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,3,3,8,16]{4,3,2,1,0}, /*index=20*/f32[2,16]{1,0}, f32[2,16]{1,0}, f32[2,1,1,16,16]{4,3,2,1,0}, f32[2,8]{1,0}, f32[2,8]{1,0}, /*index=25*/f32[8]{0}, f32[8]{0}, f32[1,1,2,8]{3,2,1,0}, f32[2]{0}, f32[2]{0}, /*index=30*/f32[1,1,8,2]{3,2,1,0}, f32[]) tuple(f32[] %negate.4666, f32[2,16]{1,0} %get-tuple-element.9517, f32[2,16]{1,0} %get-tuple-element.9518, f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.9519, f32[2,16]{1,0} %get-tuple-element.9520, /*index=5*/f32[2,16]{1,0} %get-tuple-element.9521, f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.9522, f32[2,8]{1,0} %get-tuple-element.9523, f32[2,8]{1,0} %get-tuple-element.9524, f32[8]{0} %broadcast.9538, /*index=10*/f32[8]{0} %broadcast.9553, f32[1,1,2,8]{3,2,1,0} %add.9579, f32[2]{0} %broadcast.7238, f32[2]{0} %broadcast.7253, f32[1,1,8,2]{3,2,1,0} %add.7279, /*index=15*/f32[] %reduce.7222, f32[3,3]{1,0} %add.7201, f32[2,16]{1,0} %get-tuple-element.7015, f32[2,16]{1,0} %get-tuple-element.7016, f32[2,3,3,8,16]{4,3,2,1,0} %get-tuple-element.7017, /*index=20*/f32[2,16]{1,0} %get-tuple-element.7018, f32[2,16]{1,0} %get-tuple-element.7019, f32[2,1,1,16,16]{4,3,2,1,0} %get-tuple-element.7020, f32[2,8]{1,0} %get-tuple-element.7021, f32[2,8]{1,0} %get-tuple-element.7022, /*index=25*/f32[8]{0} %broadcast.7036, f32[8]{0} %broadcast.7051, f32[1,1,2,8]{3,2,1,0} %add.7077, f32[2]{0} %broadcast.4736, f32[2]{0} %broadcast.4751, /*index=30*/f32[1,1,8,2]{3,2,1,0} %add.4777, f32[] %reduce.4720) +} + diff --git a/tests/hlo_texts/test_hlos/Physics-informed-neural-network-in-JAX/module_0005.jit_fn.3.before_optimizations.txt b/tests/hlo_texts/test_hlos/Physics-informed-neural-network-in-JAX/module_0005.jit_fn.3.before_optimizations.txt new file mode 100644 index 0000000..d10a1c6 --- /dev/null +++ b/tests/hlo_texts/test_hlos/Physics-informed-neural-network-in-JAX/module_0005.jit_fn.3.before_optimizations.txt @@ -0,0 +1,10 @@ +HloModule jit_fn.3 + +ENTRY %main.6 (Arg_0.1: f32[1,1], Arg_1.2: s32[]) -> f32[1,1] { + %Arg_0.1 = f32[1,1]{1,0} parameter(0) + %Arg_1.2 = s32[] parameter(1) + %convert.3 = f32[] convert(s32[] %Arg_1.2) + %reshape.4 = f32[1,1]{1,0} reshape(f32[] %convert.3) + ROOT %multiply.5 = f32[1,1]{1,0} multiply(f32[1,1]{1,0} %Arg_0.1, f32[1,1]{1,0} %reshape.4) +} + diff --git a/tests/hlo_texts/test_hlos/Physics-informed-neural-network-in-JAX/module_0015.jit__threefry_split.8.before_optimizations.txt b/tests/hlo_texts/test_hlos/Physics-informed-neural-network-in-JAX/module_0015.jit__threefry_split.8.before_optimizations.txt new file mode 100644 index 0000000..4aa35a5 --- /dev/null +++ b/tests/hlo_texts/test_hlos/Physics-informed-neural-network-in-JAX/module_0015.jit__threefry_split.8.before_optimizations.txt @@ -0,0 +1,39 @@ +HloModule jit__threefry_split.8 + +%xla_fallback_threefry2x32.9 (Arg_0.10: u32[], Arg_1.11: u32[], Arg_2.12: u32[7], Arg_3.13: u32[7]) -> (u32[7], u32[7]) { + %Arg_0.10 = u32[] parameter(0) + %broadcast.14 = u32[7]{0} broadcast(u32[] %Arg_0.10), dimensions={} + %Arg_1.11 = u32[] parameter(1) + %broadcast.15 = u32[7]{0} broadcast(u32[] %Arg_1.11), dimensions={} + %Arg_2.12 = u32[7]{0} parameter(2) + %Arg_3.13 = u32[7]{0} parameter(3) + ROOT %custom-call.16 = (u32[7]{0}, u32[7]{0}) custom-call(u32[7]{0} %broadcast.14, u32[7]{0} %broadcast.15, u32[7]{0} %Arg_2.12, u32[7]{0} %Arg_3.13), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[7]{0}, u32[7]{0}, u32[7]{0}, u32[7]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\007\000\000\000\000\000\000\000" +} + +%threefry2x32.17 (Arg_0.18: u32[], Arg_1.19: u32[], Arg_2.20: u32[7], Arg_3.21: u32[7]) -> (u32[7], u32[7]) { + %Arg_0.18 = u32[] parameter(0) + %Arg_1.19 = u32[] parameter(1) + %Arg_2.20 = u32[7]{0} parameter(2) + %Arg_3.21 = u32[7]{0} parameter(3) + %call.22 = (u32[7]{0}, u32[7]{0}) call(u32[] %Arg_0.18, u32[] %Arg_1.19, u32[7]{0} %Arg_2.20, u32[7]{0} %Arg_3.21), to_apply=%xla_fallback_threefry2x32.9 + %get-tuple-element.23 = u32[7]{0} get-tuple-element((u32[7]{0}, u32[7]{0}) %call.22), index=0 + %get-tuple-element.24 = u32[7]{0} get-tuple-element((u32[7]{0}, u32[7]{0}) %call.22), index=1 + ROOT %tuple.25 = (u32[7]{0}, u32[7]{0}) tuple(u32[7]{0} %get-tuple-element.23, u32[7]{0} %get-tuple-element.24) +} + +ENTRY %main.31 (Arg_0.1: u32[2]) -> u32[7,2] { + %Arg_0.1 = u32[2]{0} parameter(0) + %slice.3 = u32[1]{0} slice(u32[2]{0} %Arg_0.1), slice={[0:1]} + %reshape.4 = u32[] reshape(u32[1]{0} %slice.3) + %slice.5 = u32[1]{0} slice(u32[2]{0} %Arg_0.1), slice={[1:2]} + %reshape.6 = u32[] reshape(u32[1]{0} %slice.5) + %iota.2 = u32[14]{0} iota(), iota_dimension=0 + %slice.7 = u32[7]{0} slice(u32[14]{0} %iota.2), slice={[0:7]} + %slice.8 = u32[7]{0} slice(u32[14]{0} %iota.2), slice={[7:14]} + %call.26 = (u32[7]{0}, u32[7]{0}) call(u32[] %reshape.4, u32[] %reshape.6, u32[7]{0} %slice.7, u32[7]{0} %slice.8), to_apply=%threefry2x32.17 + %get-tuple-element.27 = u32[7]{0} get-tuple-element((u32[7]{0}, u32[7]{0}) %call.26), index=0 + %get-tuple-element.28 = u32[7]{0} get-tuple-element((u32[7]{0}, u32[7]{0}) %call.26), index=1 + %concatenate.29 = u32[14]{0} concatenate(u32[7]{0} %get-tuple-element.27, u32[7]{0} %get-tuple-element.28), dimensions={0} + ROOT %reshape.30 = u32[7,2]{1,0} reshape(u32[14]{0} %concatenate.29) +} + diff --git a/tests/hlo_texts/test_hlos/Physics-informed-neural-network-in-JAX/module_0019.jit__unstack.9.before_optimizations.txt b/tests/hlo_texts/test_hlos/Physics-informed-neural-network-in-JAX/module_0019.jit__unstack.9.before_optimizations.txt new file mode 100644 index 0000000..4cb34b1 --- /dev/null +++ b/tests/hlo_texts/test_hlos/Physics-informed-neural-network-in-JAX/module_0019.jit__unstack.9.before_optimizations.txt @@ -0,0 +1,21 @@ +HloModule jit__unstack.9 + +ENTRY %main.17 (Arg_0.1: u32[7,2]) -> (u32[2], u32[2], u32[2], u32[2], u32[2], /*index=5*/u32[2], u32[2]) { + %Arg_0.1 = u32[7,2]{1,0} parameter(0) + %slice.2 = u32[1,2]{1,0} slice(u32[7,2]{1,0} %Arg_0.1), slice={[0:1], [0:2]} + %reshape.3 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.2) + %slice.4 = u32[1,2]{1,0} slice(u32[7,2]{1,0} %Arg_0.1), slice={[1:2], [0:2]} + %reshape.5 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.4) + %slice.6 = u32[1,2]{1,0} slice(u32[7,2]{1,0} %Arg_0.1), slice={[2:3], [0:2]} + %reshape.7 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.6) + %slice.8 = u32[1,2]{1,0} slice(u32[7,2]{1,0} %Arg_0.1), slice={[3:4], [0:2]} + %reshape.9 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.8) + %slice.10 = u32[1,2]{1,0} slice(u32[7,2]{1,0} %Arg_0.1), slice={[4:5], [0:2]} + %reshape.11 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.10) + %slice.12 = u32[1,2]{1,0} slice(u32[7,2]{1,0} %Arg_0.1), slice={[5:6], [0:2]} + %reshape.13 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.12) + %slice.14 = u32[1,2]{1,0} slice(u32[7,2]{1,0} %Arg_0.1), slice={[6:7], [0:2]} + %reshape.15 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.14) + ROOT %tuple.16 = (u32[2]{0}, u32[2]{0}, u32[2]{0}, u32[2]{0}, u32[2]{0}, /*index=5*/u32[2]{0}, u32[2]{0}) tuple(u32[2]{0} %reshape.3, u32[2]{0} %reshape.5, u32[2]{0} %reshape.7, u32[2]{0} %reshape.9, u32[2]{0} %reshape.11, /*index=5*/u32[2]{0} %reshape.13, u32[2]{0} %reshape.15) +} + diff --git a/tests/hlo_texts/test_hlos/Scale-Mixtures-of-NNGP/module_0010.jit__threefry_split.5.before_optimizations.txt b/tests/hlo_texts/test_hlos/Scale-Mixtures-of-NNGP/module_0010.jit__threefry_split.5.before_optimizations.txt new file mode 100644 index 0000000..eb01ec5 --- /dev/null +++ b/tests/hlo_texts/test_hlos/Scale-Mixtures-of-NNGP/module_0010.jit__threefry_split.5.before_optimizations.txt @@ -0,0 +1,39 @@ +HloModule jit__threefry_split.5 + +%xla_fallback_threefry2x32.9 (Arg_0.10: u32[], Arg_1.11: u32[], Arg_2.12: u32[3], Arg_3.13: u32[3]) -> (u32[3], u32[3]) { + %Arg_0.10 = u32[] parameter(0) + %broadcast.14 = u32[3]{0} broadcast(u32[] %Arg_0.10), dimensions={} + %Arg_1.11 = u32[] parameter(1) + %broadcast.15 = u32[3]{0} broadcast(u32[] %Arg_1.11), dimensions={} + %Arg_2.12 = u32[3]{0} parameter(2) + %Arg_3.13 = u32[3]{0} parameter(3) + ROOT %custom-call.16 = (u32[3]{0}, u32[3]{0}) custom-call(u32[3]{0} %broadcast.14, u32[3]{0} %broadcast.15, u32[3]{0} %Arg_2.12, u32[3]{0} %Arg_3.13), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[3]{0}, u32[3]{0}, u32[3]{0}, u32[3]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\003\000\000\000\000\000\000\000" +} + +%threefry2x32.17 (Arg_0.18: u32[], Arg_1.19: u32[], Arg_2.20: u32[3], Arg_3.21: u32[3]) -> (u32[3], u32[3]) { + %Arg_0.18 = u32[] parameter(0) + %Arg_1.19 = u32[] parameter(1) + %Arg_2.20 = u32[3]{0} parameter(2) + %Arg_3.21 = u32[3]{0} parameter(3) + %call.22 = (u32[3]{0}, u32[3]{0}) call(u32[] %Arg_0.18, u32[] %Arg_1.19, u32[3]{0} %Arg_2.20, u32[3]{0} %Arg_3.21), to_apply=%xla_fallback_threefry2x32.9 + %get-tuple-element.23 = u32[3]{0} get-tuple-element((u32[3]{0}, u32[3]{0}) %call.22), index=0 + %get-tuple-element.24 = u32[3]{0} get-tuple-element((u32[3]{0}, u32[3]{0}) %call.22), index=1 + ROOT %tuple.25 = (u32[3]{0}, u32[3]{0}) tuple(u32[3]{0} %get-tuple-element.23, u32[3]{0} %get-tuple-element.24) +} + +ENTRY %main.31 (Arg_0.1: u32[2]) -> u32[3,2] { + %Arg_0.1 = u32[2]{0} parameter(0) + %slice.3 = u32[1]{0} slice(u32[2]{0} %Arg_0.1), slice={[0:1]} + %reshape.4 = u32[] reshape(u32[1]{0} %slice.3) + %slice.5 = u32[1]{0} slice(u32[2]{0} %Arg_0.1), slice={[1:2]} + %reshape.6 = u32[] reshape(u32[1]{0} %slice.5) + %iota.2 = u32[6]{0} iota(), iota_dimension=0 + %slice.7 = u32[3]{0} slice(u32[6]{0} %iota.2), slice={[0:3]} + %slice.8 = u32[3]{0} slice(u32[6]{0} %iota.2), slice={[3:6]} + %call.26 = (u32[3]{0}, u32[3]{0}) call(u32[] %reshape.4, u32[] %reshape.6, u32[3]{0} %slice.7, u32[3]{0} %slice.8), to_apply=%threefry2x32.17 + %get-tuple-element.27 = u32[3]{0} get-tuple-element((u32[3]{0}, u32[3]{0}) %call.26), index=0 + %get-tuple-element.28 = u32[3]{0} get-tuple-element((u32[3]{0}, u32[3]{0}) %call.26), index=1 + %concatenate.29 = u32[6]{0} concatenate(u32[3]{0} %get-tuple-element.27, u32[3]{0} %get-tuple-element.28), dimensions={0} + ROOT %reshape.30 = u32[3,2]{1,0} reshape(u32[6]{0} %concatenate.29) +} + diff --git a/tests/hlo_texts/test_hlos/Scale-Mixtures-of-NNGP/module_0014.jit__unstack.6.before_optimizations.txt b/tests/hlo_texts/test_hlos/Scale-Mixtures-of-NNGP/module_0014.jit__unstack.6.before_optimizations.txt new file mode 100644 index 0000000..da213ca --- /dev/null +++ b/tests/hlo_texts/test_hlos/Scale-Mixtures-of-NNGP/module_0014.jit__unstack.6.before_optimizations.txt @@ -0,0 +1,13 @@ +HloModule jit__unstack.6 + +ENTRY %main.9 (Arg_0.1: u32[3,2]) -> (u32[2], u32[2], u32[2]) { + %Arg_0.1 = u32[3,2]{1,0} parameter(0) + %slice.2 = u32[1,2]{1,0} slice(u32[3,2]{1,0} %Arg_0.1), slice={[0:1], [0:2]} + %reshape.3 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.2) + %slice.4 = u32[1,2]{1,0} slice(u32[3,2]{1,0} %Arg_0.1), slice={[1:2], [0:2]} + %reshape.5 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.4) + %slice.6 = u32[1,2]{1,0} slice(u32[3,2]{1,0} %Arg_0.1), slice={[2:3], [0:2]} + %reshape.7 = u32[2]{0} reshape(u32[1,2]{1,0} %slice.6) + ROOT %tuple.8 = (u32[2]{0}, u32[2]{0}, u32[2]{0}) tuple(u32[2]{0} %reshape.3, u32[2]{0} %reshape.5, u32[2]{0} %reshape.7) +} + diff --git a/tests/hlo_texts/test_hlos/Scale-Mixtures-of-NNGP/module_0040.jit_serial.13.before_optimizations.txt b/tests/hlo_texts/test_hlos/Scale-Mixtures-of-NNGP/module_0040.jit_serial.13.before_optimizations.txt new file mode 100644 index 0000000..aea1cab --- /dev/null +++ b/tests/hlo_texts/test_hlos/Scale-Mixtures-of-NNGP/module_0040.jit_serial.13.before_optimizations.txt @@ -0,0 +1,118 @@ +HloModule jit_serial.13 + +ENTRY %main.114 (Arg_0.1: f32[40,1]) -> f32[40,40] { + %Arg_0.1 = f32[40,1]{1,0} parameter(0) + %dot.28 = f32[40,40]{1,0} dot(f32[40,1]{1,0} %Arg_0.1, f32[40,1]{1,0} %Arg_0.1), lhs_contracting_dims={1}, rhs_contracting_dims={1} + %constant.2 = f32[] constant(1) + %broadcast.3 = f32[40,40]{1,0} broadcast(f32[] %constant.2), dimensions={} + %divide.29 = f32[40,40]{1,0} divide(f32[40,40]{1,0} %dot.28, f32[40,40]{1,0} %broadcast.3) + %constant.22 = f32[] constant(0.0025) + %broadcast.23 = f32[40,40]{1,0} broadcast(f32[] %constant.22), dimensions={} + %add.31 = f32[40,40]{1,0} add(f32[40,40]{1,0} %divide.29, f32[40,40]{1,0} %broadcast.23) + %constant.18 = f32[] constant(2) + %broadcast.19 = f32[40,40]{1,0} broadcast(f32[] %constant.18), dimensions={} + %multiply.50 = f32[40,40]{1,0} multiply(f32[40,40]{1,0} %add.31, f32[40,40]{1,0} %broadcast.19) + %dot.26 = f32[40]{0} dot(f32[40,1]{1,0} %Arg_0.1, f32[40,1]{1,0} %Arg_0.1), lhs_batch_dims={0}, lhs_contracting_dims={1}, rhs_batch_dims={0}, rhs_contracting_dims={1} + %constant.4 = f32[] constant(1) + %broadcast.5 = f32[40]{0} broadcast(f32[] %constant.4), dimensions={} + %divide.27 = f32[40]{0} divide(f32[40]{0} %dot.26, f32[40]{0} %broadcast.5) + %constant.24 = f32[] constant(0.0025) + %broadcast.25 = f32[40]{0} broadcast(f32[] %constant.24), dimensions={} + %add.30 = f32[40]{0} add(f32[40]{0} %divide.27, f32[40]{0} %broadcast.25) + %constant.12 = f32[] constant(2) + %broadcast.13 = f32[40]{0} broadcast(f32[] %constant.12), dimensions={} + %multiply.32 = f32[40]{0} multiply(f32[40]{0} %add.30, f32[40]{0} %broadcast.13) + %add.33 = f32[40]{0} add(f32[40]{0} %multiply.32, f32[40]{0} %broadcast.5) + %divide.34 = f32[40]{0} divide(f32[40]{0} %add.33, f32[40]{0} %broadcast.5) + %reshape.35 = f32[40,1]{1,0} reshape(f32[40]{0} %divide.34) + %broadcast.37 = f32[40,1]{1,0} broadcast(f32[40,1]{1,0} %reshape.35), dimensions={0,1} + %reshape.38 = f32[40]{0} reshape(f32[40,1]{1,0} %broadcast.37) + %broadcast.39 = f32[40,40]{1,0} broadcast(f32[40]{0} %reshape.38), dimensions={0} + %reshape.36 = f32[1,40]{1,0} reshape(f32[40]{0} %divide.34) + %broadcast.40 = f32[1,40]{1,0} broadcast(f32[1,40]{1,0} %reshape.36), dimensions={0,1} + %reshape.41 = f32[40]{0} reshape(f32[1,40]{1,0} %broadcast.40) + %broadcast.42 = f32[40,40]{1,0} broadcast(f32[40]{0} %reshape.41), dimensions={1} + %multiply.43 = f32[40,40]{1,0} multiply(f32[40,40]{1,0} %broadcast.39, f32[40,40]{1,0} %broadcast.42) + %multiply.45 = f32[40,40]{1,0} multiply(f32[40,40]{1,0} %add.31, f32[40,40]{1,0} %add.31) + %constant.20 = f32[] constant(4) + %broadcast.21 = f32[40,40]{1,0} broadcast(f32[] %constant.20), dimensions={} + %multiply.46 = f32[40,40]{1,0} multiply(f32[40,40]{1,0} %multiply.45, f32[40,40]{1,0} %broadcast.21) + %subtract.47 = f32[40,40]{1,0} subtract(f32[40,40]{1,0} %multiply.43, f32[40,40]{1,0} %multiply.46) + %constant.6 = f32[] constant(0) + %broadcast.7 = f32[40,40]{1,0} broadcast(f32[] %constant.6), dimensions={} + %maximum.48 = f32[40,40]{1,0} maximum(f32[40,40]{1,0} %subtract.47, f32[40,40]{1,0} %broadcast.7) + %sqrt.49 = f32[40,40]{1,0} sqrt(f32[40,40]{1,0} %maximum.48) + %atan2.51 = f32[40,40]{1,0} atan2(f32[40,40]{1,0} %multiply.50, f32[40,40]{1,0} %sqrt.49) + %constant.16 = f32[] constant(0.636619747) + %broadcast.17 = f32[40,40]{1,0} broadcast(f32[] %constant.16), dimensions={} + %multiply.52 = f32[40,40]{1,0} multiply(f32[40,40]{1,0} %atan2.51, f32[40,40]{1,0} %broadcast.17) + %add.62 = f32[40,40]{1,0} add(f32[40,40]{1,0} %multiply.52, f32[40,40]{1,0} %broadcast.23) + %multiply.81 = f32[40,40]{1,0} multiply(f32[40,40]{1,0} %add.62, f32[40,40]{1,0} %broadcast.19) + %multiply.58 = f32[40]{0} multiply(f32[40]{0} %add.30, f32[40]{0} %broadcast.13) + %multiply.44 = f32[40]{0} multiply(f32[40]{0} %divide.34, f32[40]{0} %divide.34) + %multiply.53 = f32[40]{0} multiply(f32[40]{0} %add.30, f32[40]{0} %add.30) + %constant.14 = f32[] constant(4) + %broadcast.15 = f32[40]{0} broadcast(f32[] %constant.14), dimensions={} + %multiply.54 = f32[40]{0} multiply(f32[40]{0} %multiply.53, f32[40]{0} %broadcast.15) + %subtract.55 = f32[40]{0} subtract(f32[40]{0} %multiply.44, f32[40]{0} %multiply.54) + %constant.8 = f32[] constant(0) + %broadcast.9 = f32[40]{0} broadcast(f32[] %constant.8), dimensions={} + %maximum.56 = f32[40]{0} maximum(f32[40]{0} %subtract.55, f32[40]{0} %broadcast.9) + %sqrt.57 = f32[40]{0} sqrt(f32[40]{0} %maximum.56) + %atan2.59 = f32[40]{0} atan2(f32[40]{0} %multiply.58, f32[40]{0} %sqrt.57) + %constant.10 = f32[] constant(0.636619747) + %broadcast.11 = f32[40]{0} broadcast(f32[] %constant.10), dimensions={} + %multiply.60 = f32[40]{0} multiply(f32[40]{0} %atan2.59, f32[40]{0} %broadcast.11) + %add.61 = f32[40]{0} add(f32[40]{0} %multiply.60, f32[40]{0} %broadcast.25) + %multiply.63 = f32[40]{0} multiply(f32[40]{0} %add.61, f32[40]{0} %broadcast.13) + %add.64 = f32[40]{0} add(f32[40]{0} %multiply.63, f32[40]{0} %broadcast.5) + %divide.65 = f32[40]{0} divide(f32[40]{0} %add.64, f32[40]{0} %broadcast.5) + %reshape.66 = f32[40,1]{1,0} reshape(f32[40]{0} %divide.65) + %broadcast.68 = f32[40,1]{1,0} broadcast(f32[40,1]{1,0} %reshape.66), dimensions={0,1} + %reshape.69 = f32[40]{0} reshape(f32[40,1]{1,0} %broadcast.68) + %broadcast.70 = f32[40,40]{1,0} broadcast(f32[40]{0} %reshape.69), dimensions={0} + %reshape.67 = f32[1,40]{1,0} reshape(f32[40]{0} %divide.65) + %broadcast.71 = f32[1,40]{1,0} broadcast(f32[1,40]{1,0} %reshape.67), dimensions={0,1} + %reshape.72 = f32[40]{0} reshape(f32[1,40]{1,0} %broadcast.71) + %broadcast.73 = f32[40,40]{1,0} broadcast(f32[40]{0} %reshape.72), dimensions={1} + %multiply.74 = f32[40,40]{1,0} multiply(f32[40,40]{1,0} %broadcast.70, f32[40,40]{1,0} %broadcast.73) + %multiply.76 = f32[40,40]{1,0} multiply(f32[40,40]{1,0} %add.62, f32[40,40]{1,0} %add.62) + %multiply.77 = f32[40,40]{1,0} multiply(f32[40,40]{1,0} %multiply.76, f32[40,40]{1,0} %broadcast.21) + %subtract.78 = f32[40,40]{1,0} subtract(f32[40,40]{1,0} %multiply.74, f32[40,40]{1,0} %multiply.77) + %maximum.79 = f32[40,40]{1,0} maximum(f32[40,40]{1,0} %subtract.78, f32[40,40]{1,0} %broadcast.7) + %sqrt.80 = f32[40,40]{1,0} sqrt(f32[40,40]{1,0} %maximum.79) + %atan2.82 = f32[40,40]{1,0} atan2(f32[40,40]{1,0} %multiply.81, f32[40,40]{1,0} %sqrt.80) + %multiply.83 = f32[40,40]{1,0} multiply(f32[40,40]{1,0} %atan2.82, f32[40,40]{1,0} %broadcast.17) + %add.93 = f32[40,40]{1,0} add(f32[40,40]{1,0} %multiply.83, f32[40,40]{1,0} %broadcast.23) + %multiply.111 = f32[40,40]{1,0} multiply(f32[40,40]{1,0} %add.93, f32[40,40]{1,0} %broadcast.19) + %multiply.89 = f32[40]{0} multiply(f32[40]{0} %add.61, f32[40]{0} %broadcast.13) + %multiply.75 = f32[40]{0} multiply(f32[40]{0} %divide.65, f32[40]{0} %divide.65) + %multiply.84 = f32[40]{0} multiply(f32[40]{0} %add.61, f32[40]{0} %add.61) + %multiply.85 = f32[40]{0} multiply(f32[40]{0} %multiply.84, f32[40]{0} %broadcast.15) + %subtract.86 = f32[40]{0} subtract(f32[40]{0} %multiply.75, f32[40]{0} %multiply.85) + %maximum.87 = f32[40]{0} maximum(f32[40]{0} %subtract.86, f32[40]{0} %broadcast.9) + %sqrt.88 = f32[40]{0} sqrt(f32[40]{0} %maximum.87) + %atan2.90 = f32[40]{0} atan2(f32[40]{0} %multiply.89, f32[40]{0} %sqrt.88) + %multiply.91 = f32[40]{0} multiply(f32[40]{0} %atan2.90, f32[40]{0} %broadcast.11) + %add.92 = f32[40]{0} add(f32[40]{0} %multiply.91, f32[40]{0} %broadcast.25) + %multiply.94 = f32[40]{0} multiply(f32[40]{0} %add.92, f32[40]{0} %broadcast.13) + %add.95 = f32[40]{0} add(f32[40]{0} %multiply.94, f32[40]{0} %broadcast.5) + %divide.96 = f32[40]{0} divide(f32[40]{0} %add.95, f32[40]{0} %broadcast.5) + %reshape.97 = f32[40,1]{1,0} reshape(f32[40]{0} %divide.96) + %broadcast.99 = f32[40,1]{1,0} broadcast(f32[40,1]{1,0} %reshape.97), dimensions={0,1} + %reshape.100 = f32[40]{0} reshape(f32[40,1]{1,0} %broadcast.99) + %broadcast.101 = f32[40,40]{1,0} broadcast(f32[40]{0} %reshape.100), dimensions={0} + %reshape.98 = f32[1,40]{1,0} reshape(f32[40]{0} %divide.96) + %broadcast.102 = f32[1,40]{1,0} broadcast(f32[1,40]{1,0} %reshape.98), dimensions={0,1} + %reshape.103 = f32[40]{0} reshape(f32[1,40]{1,0} %broadcast.102) + %broadcast.104 = f32[40,40]{1,0} broadcast(f32[40]{0} %reshape.103), dimensions={1} + %multiply.105 = f32[40,40]{1,0} multiply(f32[40,40]{1,0} %broadcast.101, f32[40,40]{1,0} %broadcast.104) + %multiply.106 = f32[40,40]{1,0} multiply(f32[40,40]{1,0} %add.93, f32[40,40]{1,0} %add.93) + %multiply.107 = f32[40,40]{1,0} multiply(f32[40,40]{1,0} %multiply.106, f32[40,40]{1,0} %broadcast.21) + %subtract.108 = f32[40,40]{1,0} subtract(f32[40,40]{1,0} %multiply.105, f32[40,40]{1,0} %multiply.107) + %maximum.109 = f32[40,40]{1,0} maximum(f32[40,40]{1,0} %subtract.108, f32[40,40]{1,0} %broadcast.7) + %sqrt.110 = f32[40,40]{1,0} sqrt(f32[40,40]{1,0} %maximum.109) + %atan2.112 = f32[40,40]{1,0} atan2(f32[40,40]{1,0} %multiply.111, f32[40,40]{1,0} %sqrt.110) + ROOT %multiply.113 = f32[40,40]{1,0} multiply(f32[40,40]{1,0} %atan2.112, f32[40,40]{1,0} %broadcast.17) +} + diff --git a/tests/hlo_texts/test_hlos/Toy-neural-network-in-jax/module_0009.jit__threefry_split.5.before_optimizations.txt b/tests/hlo_texts/test_hlos/Toy-neural-network-in-jax/module_0009.jit__threefry_split.5.before_optimizations.txt new file mode 100644 index 0000000..f9449d3 --- /dev/null +++ b/tests/hlo_texts/test_hlos/Toy-neural-network-in-jax/module_0009.jit__threefry_split.5.before_optimizations.txt @@ -0,0 +1,20 @@ +HloModule jit__threefry_split.5 + +ENTRY main.16 { + Arg_0.1 = u32[2]{0} parameter(0) + slice.3 = u32[1]{0} slice(Arg_0.1), slice={[0:1]} + reshape.4 = u32[] reshape(slice.3) + broadcast.9 = u32[2]{0} broadcast(reshape.4), dimensions={} + slice.5 = u32[1]{0} slice(Arg_0.1), slice={[1:2]} + reshape.6 = u32[] reshape(slice.5) + broadcast.10 = u32[2]{0} broadcast(reshape.6), dimensions={} + iota.2 = u32[4]{0} iota(), iota_dimension=0 + slice.7 = u32[2]{0} slice(iota.2), slice={[0:2]} + slice.8 = u32[2]{0} slice(iota.2), slice={[2:4]} + custom-call.11 = (u32[2]{0}, u32[2]{0}) custom-call(broadcast.9, broadcast.10, slice.7, slice.8), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[2]{0}, u32[2]{0}, u32[2]{0}, u32[2]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\002\000\000\000\000\000\000\000" + get-tuple-element.12 = u32[2]{0} get-tuple-element(custom-call.11), index=0 + get-tuple-element.13 = u32[2]{0} get-tuple-element(custom-call.11), index=1 + concatenate.14 = u32[4]{0} concatenate(get-tuple-element.12, get-tuple-element.13), dimensions={0} + ROOT reshape.15 = u32[2,2]{1,0} reshape(concatenate.14) +} + diff --git a/tests/hlo_texts/test_hlos/Toy-neural-network-in-jax/module_0015.jit__uniform.7.before_optimizations.txt b/tests/hlo_texts/test_hlos/Toy-neural-network-in-jax/module_0015.jit__uniform.7.before_optimizations.txt new file mode 100644 index 0000000..6d63291 --- /dev/null +++ b/tests/hlo_texts/test_hlos/Toy-neural-network-in-jax/module_0015.jit__uniform.7.before_optimizations.txt @@ -0,0 +1,49 @@ +HloModule jit__uniform.7 + +ENTRY main.45 { + Arg_1.2 = f32[] parameter(1) + reshape.11 = f32[1]{0} reshape(Arg_1.2) + broadcast.41 = f32[1]{0} broadcast(reshape.11), dimensions={0} + reshape.42 = f32[] reshape(broadcast.41) + broadcast.43 = f32[31]{0} broadcast(reshape.42), dimensions={} + Arg_0.1 = u32[2]{0} parameter(0) + slice.14 = u32[1]{0} slice(Arg_0.1), slice={[0:1]} + reshape.15 = u32[] reshape(slice.14) + broadcast.21 = u32[16]{0} broadcast(reshape.15), dimensions={} + slice.16 = u32[1]{0} slice(Arg_0.1), slice={[1:2]} + reshape.17 = u32[] reshape(slice.16) + broadcast.22 = u32[16]{0} broadcast(reshape.17), dimensions={} + iota.13 = u32[31]{0} iota(), iota_dimension=0 + slice.19 = u32[16]{0} slice(iota.13), slice={[0:16]} + constant.10 = u32[1]{0} constant({0}) + concatenate.18 = u32[32]{0} concatenate(iota.13, constant.10), dimensions={0} + slice.20 = u32[16]{0} slice(concatenate.18), slice={[16:32]} + custom-call.23 = (u32[16]{0}, u32[16]{0}) custom-call(broadcast.21, broadcast.22, slice.19, slice.20), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[16]{0}, u32[16]{0}, u32[16]{0}, u32[16]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\020\000\000\000\000\000\000\000" + get-tuple-element.24 = u32[16]{0} get-tuple-element(custom-call.23), index=0 + get-tuple-element.25 = u32[16]{0} get-tuple-element(custom-call.23), index=1 + concatenate.26 = u32[32]{0} concatenate(get-tuple-element.24, get-tuple-element.25), dimensions={0} + slice.27 = u32[31]{0} slice(concatenate.26), slice={[0:31]} + constant.8 = u32[] constant(9) + broadcast.9 = u32[31]{0} broadcast(constant.8), dimensions={} + shift-right-logical.28 = u32[31]{0} shift-right-logical(slice.27, broadcast.9) + constant.6 = u32[] constant(1065353216) + broadcast.7 = u32[31]{0} broadcast(constant.6), dimensions={} + or.29 = u32[31]{0} or(shift-right-logical.28, broadcast.7) + bitcast-convert.30 = f32[31]{0} bitcast-convert(or.29) + constant.4 = f32[] constant(1) + broadcast.5 = f32[31]{0} broadcast(constant.4), dimensions={} + subtract.31 = f32[31]{0} subtract(bitcast-convert.30, broadcast.5) + Arg_2.3 = f32[] parameter(2) + reshape.12 = f32[1]{0} reshape(Arg_2.3) + subtract.32 = f32[1]{0} subtract(reshape.12, reshape.11) + broadcast.33 = f32[1]{0} broadcast(subtract.32), dimensions={0} + reshape.34 = f32[] reshape(broadcast.33) + broadcast.35 = f32[31]{0} broadcast(reshape.34), dimensions={} + multiply.36 = f32[31]{0} multiply(subtract.31, broadcast.35) + broadcast.37 = f32[1]{0} broadcast(reshape.11), dimensions={0} + reshape.38 = f32[] reshape(broadcast.37) + broadcast.39 = f32[31]{0} broadcast(reshape.38), dimensions={} + add.40 = f32[31]{0} add(multiply.36, broadcast.39) + ROOT maximum.44 = f32[31]{0} maximum(broadcast.43, add.40) +} + diff --git a/tests/hlo_texts/test_hlos/Toy-neural-network-in-jax/module_0084.jit__shuffle.43.before_optimizations.txt b/tests/hlo_texts/test_hlos/Toy-neural-network-in-jax/module_0084.jit__shuffle.43.before_optimizations.txt new file mode 100644 index 0000000..8908761 --- /dev/null +++ b/tests/hlo_texts/test_hlos/Toy-neural-network-in-jax/module_0084.jit__shuffle.43.before_optimizations.txt @@ -0,0 +1,50 @@ +HloModule jit__shuffle.43 + +region_0.35 { + Arg_2.38 = s32[] parameter(2) + Arg_3.39 = s32[] parameter(3) + Arg_0.36 = u32[] parameter(0) + Arg_1.37 = u32[] parameter(1) + ROOT compare.40 = pred[] compare(Arg_0.36, Arg_1.37), direction=LT +} + +ENTRY main.44 { + Arg_0.1 = u32[2]{0} parameter(0) + slice.5 = u32[1]{0} slice(Arg_0.1), slice={[0:1]} + reshape.6 = u32[] reshape(slice.5) + broadcast.11 = u32[2]{0} broadcast(reshape.6), dimensions={} + slice.7 = u32[1]{0} slice(Arg_0.1), slice={[1:2]} + reshape.8 = u32[] reshape(slice.7) + broadcast.12 = u32[2]{0} broadcast(reshape.8), dimensions={} + iota.4 = u32[4]{0} iota(), iota_dimension=0 + slice.9 = u32[2]{0} slice(iota.4), slice={[0:2]} + slice.10 = u32[2]{0} slice(iota.4), slice={[2:4]} + custom-call.13 = (u32[2]{0}, u32[2]{0}) custom-call(broadcast.11, broadcast.12, slice.9, slice.10), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[2]{0}, u32[2]{0}, u32[2]{0}, u32[2]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\002\000\000\000\000\000\000\000" + get-tuple-element.14 = u32[2]{0} get-tuple-element(custom-call.13), index=0 + get-tuple-element.15 = u32[2]{0} get-tuple-element(custom-call.13), index=1 + concatenate.16 = u32[4]{0} concatenate(get-tuple-element.14, get-tuple-element.15), dimensions={0} + reshape.17 = u32[2,2]{1,0} reshape(concatenate.16) + slice.18 = u32[1,2]{1,0} slice(reshape.17), slice={[1:2], [0:2]} + reshape.19 = u32[2]{0} reshape(slice.18) + slice.21 = u32[1]{0} slice(reshape.19), slice={[0:1]} + reshape.22 = u32[] reshape(slice.21) + broadcast.28 = u32[51]{0} broadcast(reshape.22), dimensions={} + slice.23 = u32[1]{0} slice(reshape.19), slice={[1:2]} + reshape.24 = u32[] reshape(slice.23) + broadcast.29 = u32[51]{0} broadcast(reshape.24), dimensions={} + iota.20 = u32[101]{0} iota(), iota_dimension=0 + slice.26 = u32[51]{0} slice(iota.20), slice={[0:51]} + constant.3 = u32[1]{0} constant({0}) + concatenate.25 = u32[102]{0} concatenate(iota.20, constant.3), dimensions={0} + slice.27 = u32[51]{0} slice(concatenate.25), slice={[51:102]} + custom-call.30 = (u32[51]{0}, u32[51]{0}) custom-call(broadcast.28, broadcast.29, slice.26, slice.27), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[51]{0}, u32[51]{0}, u32[51]{0}, u32[51]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="3\000\000\000\000\000\000\000" + get-tuple-element.31 = u32[51]{0} get-tuple-element(custom-call.30), index=0 + get-tuple-element.32 = u32[51]{0} get-tuple-element(custom-call.30), index=1 + concatenate.33 = u32[102]{0} concatenate(get-tuple-element.31, get-tuple-element.32), dimensions={0} + slice.34 = u32[101]{0} slice(concatenate.33), slice={[0:101]} + Arg_1.2 = s32[101]{0} parameter(1) + sort.41 = (u32[101]{0}, s32[101]{0}) sort(slice.34, Arg_1.2), dimensions={0}, is_stable=true, to_apply=region_0.35 + get-tuple-element.42 = u32[101]{0} get-tuple-element(sort.41), index=0 + ROOT get-tuple-element.43 = s32[101]{0} get-tuple-element(sort.41), index=1 +} + diff --git a/tests/hlo_texts/test_hlos/Toy-neural-network-in-jax/module_0093.jit_loss.44.before_optimizations.txt b/tests/hlo_texts/test_hlos/Toy-neural-network-in-jax/module_0093.jit_loss.44.before_optimizations.txt new file mode 100644 index 0000000..79d0481 --- /dev/null +++ b/tests/hlo_texts/test_hlos/Toy-neural-network-in-jax/module_0093.jit_loss.44.before_optimizations.txt @@ -0,0 +1,108 @@ +HloModule jit_loss.44 + +region_0.49 { + Arg_0.50 = f32[] parameter(0) + Arg_1.51 = f32[] parameter(1) + ROOT add.52 = f32[] add(Arg_0.50, Arg_1.51) +} + +region_1.55 { + Arg_0.56 = f32[] parameter(0) + Arg_1.57 = f32[] parameter(1) + ROOT add.58 = f32[] add(Arg_0.56, Arg_1.57) +} + +region_2.64 { + Arg_0.65 = f32[] parameter(0) + Arg_1.66 = f32[] parameter(1) + ROOT add.67 = f32[] add(Arg_0.65, Arg_1.66) +} + +region_3.71 { + Arg_0.72 = f32[] parameter(0) + Arg_1.73 = f32[] parameter(1) + ROOT add.74 = f32[] add(Arg_0.72, Arg_1.73) +} + +region_4.77 { + Arg_0.78 = f32[] parameter(0) + Arg_1.79 = f32[] parameter(1) + ROOT add.80 = f32[] add(Arg_0.78, Arg_1.79) +} + +region_5.86 { + Arg_0.87 = f32[] parameter(0) + Arg_1.88 = f32[] parameter(1) + ROOT add.89 = f32[] add(Arg_0.87, Arg_1.88) +} + +ENTRY main.92 { + constant.4 = f32[] constant(0) + broadcast.5 = f32[101,31]{1,0} broadcast(constant.4), dimensions={} + constant.15 = s32[1]{0} constant({30}) + Arg_2.3 = f32[101,1]{1,0} parameter(2) + reshape.44 = f32[101,1,1]{2,1,0} reshape(Arg_2.3) + Arg_0.1 = f32[101,1]{1,0} parameter(0) + Arg_1.2 = f32[31]{0} parameter(1) + slice.19 = f32[10]{0} slice(Arg_1.2), slice={[0:10]} + reshape.20 = f32[1,10]{1,0} reshape(slice.19) + dot.25 = f32[101,10]{1,0} dot(Arg_0.1, reshape.20), lhs_contracting_dims={1}, rhs_contracting_dims={0} + reshape.26 = f32[101,1,10]{2,1,0} reshape(dot.25) + slice.21 = f32[10]{0} slice(Arg_1.2), slice={[10:20]} + reshape.27 = f32[1,1,10]{2,1,0} reshape(slice.21) + broadcast.28 = f32[1,1,10]{2,1,0} broadcast(reshape.27), dimensions={0,1,2} + reshape.29 = f32[1,10]{1,0} reshape(broadcast.28) + broadcast.30 = f32[101,1,10]{2,1,0} broadcast(reshape.29), dimensions={1,2} + add.31 = f32[101,1,10]{2,1,0} add(reshape.26, broadcast.30) + constant.13 = f32[] constant(0) + broadcast.14 = f32[101,1,10]{2,1,0} broadcast(constant.13), dimensions={} + maximum.32 = f32[101,1,10]{2,1,0} maximum(add.31, broadcast.14) + slice.22 = f32[10]{0} slice(Arg_1.2), slice={[20:30]} + reshape.23 = f32[10,1]{1,0} reshape(slice.22) + dot.38 = f32[101,1,1]{2,1,0} dot(maximum.32, reshape.23), lhs_contracting_dims={2}, rhs_contracting_dims={0} + slice.24 = f32[1]{0} slice(Arg_1.2), slice={[30:31]} + reshape.39 = f32[1,1,1]{2,1,0} reshape(slice.24) + broadcast.40 = f32[1,1,1]{2,1,0} broadcast(reshape.39), dimensions={0,1,2} + reshape.41 = f32[1,1]{1,0} reshape(broadcast.40) + broadcast.42 = f32[101,1,1]{2,1,0} broadcast(reshape.41), dimensions={1,2} + add.43 = f32[101,1,1]{2,1,0} add(dot.38, broadcast.42) + subtract.45 = f32[101,1,1]{2,1,0} subtract(reshape.44, add.43) + constant.7 = f32[] constant(2) + broadcast.8 = f32[101,1,1]{2,1,0} broadcast(constant.7), dimensions={} + multiply.46 = f32[101,1,1]{2,1,0} multiply(subtract.45, broadcast.8) + negate.47 = f32[101,1,1]{2,1,0} negate(multiply.46) + reshape.48 = f32[101,1]{1,0} reshape(negate.47) + constant.6 = f32[] constant(0) + reduce.53 = f32[101]{0} reduce(reshape.48, constant.6), dimensions={1}, to_apply=region_0.49 + reshape.54 = f32[101,1]{1,0} reshape(reduce.53) + scatter.59 = f32[101,31]{1,0} scatter(broadcast.5, constant.15, reshape.54), update_window_dims={0,1}, inserted_window_dims={}, scatter_dims_to_operand_dims={1}, index_vector_dim=0, indices_are_sorted=true, unique_indices=true, to_apply=region_1.55 + constant.16 = s32[1]{0} constant({20}) + dot.60 = f32[101,1,10]{2,1,0} dot(negate.47, maximum.32), lhs_batch_dims={0}, lhs_contracting_dims={1}, rhs_batch_dims={0}, rhs_contracting_dims={1} + transpose.61 = f32[101,10,1]{1,2,0} transpose(dot.60), dimensions={0,2,1} + reshape.63 = f32[101,10]{1,0} reshape(transpose.61) + scatter.68 = f32[101,31]{1,0} scatter(broadcast.5, constant.16, reshape.63), update_window_dims={0,1}, inserted_window_dims={}, scatter_dims_to_operand_dims={1}, index_vector_dim=0, indices_are_sorted=true, unique_indices=true, to_apply=region_2.64 + add.69 = f32[101,31]{1,0} add(scatter.59, scatter.68) + constant.17 = s32[1]{0} constant({10}) + dot.62 = f32[101,1,10]{2,1,0} dot(negate.47, reshape.23), lhs_contracting_dims={2}, rhs_contracting_dims={1} + compare.33 = pred[101,1,10]{2,1,0} compare(add.31, maximum.32), direction=EQ + constant.11 = f32[] constant(1) + broadcast.12 = f32[101,1,10]{2,1,0} broadcast(constant.11), dimensions={} + select.34 = f32[101,1,10]{2,1,0} select(compare.33, broadcast.12, broadcast.14) + compare.35 = pred[101,1,10]{2,1,0} compare(broadcast.14, maximum.32), direction=EQ + constant.9 = f32[] constant(2) + broadcast.10 = f32[101,1,10]{2,1,0} broadcast(constant.9), dimensions={} + select.36 = f32[101,1,10]{2,1,0} select(compare.35, broadcast.10, broadcast.12) + divide.37 = f32[101,1,10]{2,1,0} divide(select.34, select.36) + multiply.70 = f32[101,1,10]{2,1,0} multiply(dot.62, divide.37) + reshape.76 = f32[101,10]{1,0} reshape(multiply.70) + scatter.81 = f32[101,31]{1,0} scatter(broadcast.5, constant.17, reshape.76), update_window_dims={0,1}, inserted_window_dims={}, scatter_dims_to_operand_dims={1}, index_vector_dim=0, indices_are_sorted=true, unique_indices=true, to_apply=region_4.77 + add.82 = f32[101,31]{1,0} add(add.69, scatter.81) + constant.18 = s32[1]{0} constant({0}) + reduce.75 = f32[101,10]{1,0} reduce(multiply.70, constant.6), dimensions={1}, to_apply=region_3.71 + dot.83 = f32[101,10,1]{2,1,0} dot(reduce.75, Arg_0.1), lhs_batch_dims={0}, lhs_contracting_dims={}, rhs_batch_dims={0}, rhs_contracting_dims={} + transpose.84 = f32[101,1,10]{1,2,0} transpose(dot.83), dimensions={0,2,1} + reshape.85 = f32[101,10]{1,0} reshape(transpose.84) + scatter.90 = f32[101,31]{1,0} scatter(broadcast.5, constant.18, reshape.85), update_window_dims={0,1}, inserted_window_dims={}, scatter_dims_to_operand_dims={1}, index_vector_dim=0, indices_are_sorted=true, unique_indices=true, to_apply=region_5.86 + ROOT add.91 = f32[101,31]{1,0} add(add.82, scatter.90) +} + diff --git a/tests/hlo_texts/test_hlos/brax/module_0196.jit__uniform.21.before_optimizations.txt b/tests/hlo_texts/test_hlos/brax/module_0196.jit__uniform.21.before_optimizations.txt new file mode 100644 index 0000000..419896d --- /dev/null +++ b/tests/hlo_texts/test_hlos/brax/module_0196.jit__uniform.21.before_optimizations.txt @@ -0,0 +1,48 @@ +HloModule jit__uniform.21 + +ENTRY main.44 { + Arg_1.2 = s32[] parameter(1) + convert.10 = f32[] convert(Arg_1.2) + reshape.11 = f32[1,1]{1,0} reshape(convert.10) + broadcast.40 = f32[1,1]{1,0} broadcast(reshape.11), dimensions={0,1} + reshape.41 = f32[] reshape(broadcast.40) + broadcast.42 = f32[87,32]{1,0} broadcast(reshape.41), dimensions={} + Arg_0.1 = u32[2]{0} parameter(0) + slice.14 = u32[1]{0} slice(Arg_0.1), slice={[0:1]} + reshape.15 = u32[] reshape(slice.14) + broadcast.20 = u32[1392]{0} broadcast(reshape.15), dimensions={} + slice.16 = u32[1]{0} slice(Arg_0.1), slice={[1:2]} + reshape.17 = u32[] reshape(slice.16) + broadcast.21 = u32[1392]{0} broadcast(reshape.17), dimensions={} + iota.13 = u32[2784]{0} iota(), iota_dimension=0 + slice.18 = u32[1392]{0} slice(iota.13), slice={[0:1392]} + slice.19 = u32[1392]{0} slice(iota.13), slice={[1392:2784]} + custom-call.22 = (u32[1392]{0}, u32[1392]{0}) custom-call(broadcast.20, broadcast.21, slice.18, slice.19), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[1392]{0}, u32[1392]{0}, u32[1392]{0}, u32[1392]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="p\005\000\000\000\000\000\000" + get-tuple-element.23 = u32[1392]{0} get-tuple-element(custom-call.22), index=0 + get-tuple-element.24 = u32[1392]{0} get-tuple-element(custom-call.22), index=1 + concatenate.25 = u32[2784]{0} concatenate(get-tuple-element.23, get-tuple-element.24), dimensions={0} + reshape.26 = u32[87,32]{1,0} reshape(concatenate.25) + constant.8 = u32[] constant(9) + broadcast.9 = u32[87,32]{1,0} broadcast(constant.8), dimensions={} + shift-right-logical.27 = u32[87,32]{1,0} shift-right-logical(reshape.26, broadcast.9) + constant.6 = u32[] constant(1065353216) + broadcast.7 = u32[87,32]{1,0} broadcast(constant.6), dimensions={} + or.28 = u32[87,32]{1,0} or(shift-right-logical.27, broadcast.7) + bitcast-convert.29 = f32[87,32]{1,0} bitcast-convert(or.28) + constant.4 = f32[] constant(1) + broadcast.5 = f32[87,32]{1,0} broadcast(constant.4), dimensions={} + subtract.30 = f32[87,32]{1,0} subtract(bitcast-convert.29, broadcast.5) + Arg_2.3 = f32[] parameter(2) + reshape.12 = f32[1,1]{1,0} reshape(Arg_2.3) + subtract.31 = f32[1,1]{1,0} subtract(reshape.12, reshape.11) + broadcast.32 = f32[1,1]{1,0} broadcast(subtract.31), dimensions={0,1} + reshape.33 = f32[] reshape(broadcast.32) + broadcast.34 = f32[87,32]{1,0} broadcast(reshape.33), dimensions={} + multiply.35 = f32[87,32]{1,0} multiply(subtract.30, broadcast.34) + broadcast.36 = f32[1,1]{1,0} broadcast(reshape.11), dimensions={0,1} + reshape.37 = f32[] reshape(broadcast.36) + broadcast.38 = f32[87,32]{1,0} broadcast(reshape.37), dimensions={} + add.39 = f32[87,32]{1,0} add(multiply.35, broadcast.38) + ROOT maximum.43 = f32[87,32]{1,0} maximum(broadcast.42, add.39) +} + diff --git a/tests/hlo_texts/test_hlos/brax/module_0215.jit__uniform.30.before_optimizations.txt b/tests/hlo_texts/test_hlos/brax/module_0215.jit__uniform.30.before_optimizations.txt new file mode 100644 index 0000000..958ff8c --- /dev/null +++ b/tests/hlo_texts/test_hlos/brax/module_0215.jit__uniform.30.before_optimizations.txt @@ -0,0 +1,48 @@ +HloModule jit__uniform.30 + +ENTRY main.44 { + Arg_1.2 = s32[] parameter(1) + convert.10 = f32[] convert(Arg_1.2) + reshape.11 = f32[1,1]{1,0} reshape(convert.10) + broadcast.40 = f32[1,1]{1,0} broadcast(reshape.11), dimensions={0,1} + reshape.41 = f32[] reshape(broadcast.40) + broadcast.42 = f32[32,32]{1,0} broadcast(reshape.41), dimensions={} + Arg_0.1 = u32[2]{0} parameter(0) + slice.14 = u32[1]{0} slice(Arg_0.1), slice={[0:1]} + reshape.15 = u32[] reshape(slice.14) + broadcast.20 = u32[512]{0} broadcast(reshape.15), dimensions={} + slice.16 = u32[1]{0} slice(Arg_0.1), slice={[1:2]} + reshape.17 = u32[] reshape(slice.16) + broadcast.21 = u32[512]{0} broadcast(reshape.17), dimensions={} + iota.13 = u32[1024]{0} iota(), iota_dimension=0 + slice.18 = u32[512]{0} slice(iota.13), slice={[0:512]} + slice.19 = u32[512]{0} slice(iota.13), slice={[512:1024]} + custom-call.22 = (u32[512]{0}, u32[512]{0}) custom-call(broadcast.20, broadcast.21, slice.18, slice.19), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[512]{0}, u32[512]{0}, u32[512]{0}, u32[512]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\000\002\000\000\000\000\000\000" + get-tuple-element.23 = u32[512]{0} get-tuple-element(custom-call.22), index=0 + get-tuple-element.24 = u32[512]{0} get-tuple-element(custom-call.22), index=1 + concatenate.25 = u32[1024]{0} concatenate(get-tuple-element.23, get-tuple-element.24), dimensions={0} + reshape.26 = u32[32,32]{1,0} reshape(concatenate.25) + constant.8 = u32[] constant(9) + broadcast.9 = u32[32,32]{1,0} broadcast(constant.8), dimensions={} + shift-right-logical.27 = u32[32,32]{1,0} shift-right-logical(reshape.26, broadcast.9) + constant.6 = u32[] constant(1065353216) + broadcast.7 = u32[32,32]{1,0} broadcast(constant.6), dimensions={} + or.28 = u32[32,32]{1,0} or(shift-right-logical.27, broadcast.7) + bitcast-convert.29 = f32[32,32]{1,0} bitcast-convert(or.28) + constant.4 = f32[] constant(1) + broadcast.5 = f32[32,32]{1,0} broadcast(constant.4), dimensions={} + subtract.30 = f32[32,32]{1,0} subtract(bitcast-convert.29, broadcast.5) + Arg_2.3 = f32[] parameter(2) + reshape.12 = f32[1,1]{1,0} reshape(Arg_2.3) + subtract.31 = f32[1,1]{1,0} subtract(reshape.12, reshape.11) + broadcast.32 = f32[1,1]{1,0} broadcast(subtract.31), dimensions={0,1} + reshape.33 = f32[] reshape(broadcast.32) + broadcast.34 = f32[32,32]{1,0} broadcast(reshape.33), dimensions={} + multiply.35 = f32[32,32]{1,0} multiply(subtract.30, broadcast.34) + broadcast.36 = f32[1,1]{1,0} broadcast(reshape.11), dimensions={0,1} + reshape.37 = f32[] reshape(broadcast.36) + broadcast.38 = f32[32,32]{1,0} broadcast(reshape.37), dimensions={} + add.39 = f32[32,32]{1,0} add(multiply.35, broadcast.38) + ROOT maximum.43 = f32[32,32]{1,0} maximum(broadcast.42, add.39) +} + diff --git a/tests/hlo_texts/test_hlos/brax/module_0223.jit__uniform.33.before_optimizations.txt b/tests/hlo_texts/test_hlos/brax/module_0223.jit__uniform.33.before_optimizations.txt new file mode 100644 index 0000000..394698f --- /dev/null +++ b/tests/hlo_texts/test_hlos/brax/module_0223.jit__uniform.33.before_optimizations.txt @@ -0,0 +1,48 @@ +HloModule jit__uniform.33 + +ENTRY main.44 { + Arg_1.2 = s32[] parameter(1) + convert.10 = f32[] convert(Arg_1.2) + reshape.11 = f32[1,1]{1,0} reshape(convert.10) + broadcast.40 = f32[1,1]{1,0} broadcast(reshape.11), dimensions={0,1} + reshape.41 = f32[] reshape(broadcast.40) + broadcast.42 = f32[32,16]{1,0} broadcast(reshape.41), dimensions={} + Arg_0.1 = u32[2]{0} parameter(0) + slice.14 = u32[1]{0} slice(Arg_0.1), slice={[0:1]} + reshape.15 = u32[] reshape(slice.14) + broadcast.20 = u32[256]{0} broadcast(reshape.15), dimensions={} + slice.16 = u32[1]{0} slice(Arg_0.1), slice={[1:2]} + reshape.17 = u32[] reshape(slice.16) + broadcast.21 = u32[256]{0} broadcast(reshape.17), dimensions={} + iota.13 = u32[512]{0} iota(), iota_dimension=0 + slice.18 = u32[256]{0} slice(iota.13), slice={[0:256]} + slice.19 = u32[256]{0} slice(iota.13), slice={[256:512]} + custom-call.22 = (u32[256]{0}, u32[256]{0}) custom-call(broadcast.20, broadcast.21, slice.18, slice.19), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[256]{0}, u32[256]{0}, u32[256]{0}, u32[256]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\000\001\000\000\000\000\000\000" + get-tuple-element.23 = u32[256]{0} get-tuple-element(custom-call.22), index=0 + get-tuple-element.24 = u32[256]{0} get-tuple-element(custom-call.22), index=1 + concatenate.25 = u32[512]{0} concatenate(get-tuple-element.23, get-tuple-element.24), dimensions={0} + reshape.26 = u32[32,16]{1,0} reshape(concatenate.25) + constant.8 = u32[] constant(9) + broadcast.9 = u32[32,16]{1,0} broadcast(constant.8), dimensions={} + shift-right-logical.27 = u32[32,16]{1,0} shift-right-logical(reshape.26, broadcast.9) + constant.6 = u32[] constant(1065353216) + broadcast.7 = u32[32,16]{1,0} broadcast(constant.6), dimensions={} + or.28 = u32[32,16]{1,0} or(shift-right-logical.27, broadcast.7) + bitcast-convert.29 = f32[32,16]{1,0} bitcast-convert(or.28) + constant.4 = f32[] constant(1) + broadcast.5 = f32[32,16]{1,0} broadcast(constant.4), dimensions={} + subtract.30 = f32[32,16]{1,0} subtract(bitcast-convert.29, broadcast.5) + Arg_2.3 = f32[] parameter(2) + reshape.12 = f32[1,1]{1,0} reshape(Arg_2.3) + subtract.31 = f32[1,1]{1,0} subtract(reshape.12, reshape.11) + broadcast.32 = f32[1,1]{1,0} broadcast(subtract.31), dimensions={0,1} + reshape.33 = f32[] reshape(broadcast.32) + broadcast.34 = f32[32,16]{1,0} broadcast(reshape.33), dimensions={} + multiply.35 = f32[32,16]{1,0} multiply(subtract.30, broadcast.34) + broadcast.36 = f32[1,1]{1,0} broadcast(reshape.11), dimensions={0,1} + reshape.37 = f32[] reshape(broadcast.36) + broadcast.38 = f32[32,16]{1,0} broadcast(reshape.37), dimensions={} + add.39 = f32[32,16]{1,0} add(multiply.35, broadcast.38) + ROOT maximum.43 = f32[32,16]{1,0} maximum(broadcast.42, add.39) +} + diff --git a/tests/hlo_texts/test_hlos/brax/module_0251.jit__uniform.46.before_optimizations.txt b/tests/hlo_texts/test_hlos/brax/module_0251.jit__uniform.46.before_optimizations.txt new file mode 100644 index 0000000..f1c8c39 --- /dev/null +++ b/tests/hlo_texts/test_hlos/brax/module_0251.jit__uniform.46.before_optimizations.txt @@ -0,0 +1,48 @@ +HloModule jit__uniform.46 + +ENTRY main.44 { + Arg_1.2 = s32[] parameter(1) + convert.10 = f32[] convert(Arg_1.2) + reshape.11 = f32[1,1]{1,0} reshape(convert.10) + broadcast.40 = f32[1,1]{1,0} broadcast(reshape.11), dimensions={0,1} + reshape.41 = f32[] reshape(broadcast.40) + broadcast.42 = f32[256,256]{1,0} broadcast(reshape.41), dimensions={} + Arg_0.1 = u32[2]{0} parameter(0) + slice.14 = u32[1]{0} slice(Arg_0.1), slice={[0:1]} + reshape.15 = u32[] reshape(slice.14) + broadcast.20 = u32[32768]{0} broadcast(reshape.15), dimensions={} + slice.16 = u32[1]{0} slice(Arg_0.1), slice={[1:2]} + reshape.17 = u32[] reshape(slice.16) + broadcast.21 = u32[32768]{0} broadcast(reshape.17), dimensions={} + iota.13 = u32[65536]{0} iota(), iota_dimension=0 + slice.18 = u32[32768]{0} slice(iota.13), slice={[0:32768]} + slice.19 = u32[32768]{0} slice(iota.13), slice={[32768:65536]} + custom-call.22 = (u32[32768]{0}, u32[32768]{0}) custom-call(broadcast.20, broadcast.21, slice.18, slice.19), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[32768]{0}, u32[32768]{0}, u32[32768]{0}, u32[32768]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\000\200\000\000\000\000\000\000" + get-tuple-element.23 = u32[32768]{0} get-tuple-element(custom-call.22), index=0 + get-tuple-element.24 = u32[32768]{0} get-tuple-element(custom-call.22), index=1 + concatenate.25 = u32[65536]{0} concatenate(get-tuple-element.23, get-tuple-element.24), dimensions={0} + reshape.26 = u32[256,256]{1,0} reshape(concatenate.25) + constant.8 = u32[] constant(9) + broadcast.9 = u32[256,256]{1,0} broadcast(constant.8), dimensions={} + shift-right-logical.27 = u32[256,256]{1,0} shift-right-logical(reshape.26, broadcast.9) + constant.6 = u32[] constant(1065353216) + broadcast.7 = u32[256,256]{1,0} broadcast(constant.6), dimensions={} + or.28 = u32[256,256]{1,0} or(shift-right-logical.27, broadcast.7) + bitcast-convert.29 = f32[256,256]{1,0} bitcast-convert(or.28) + constant.4 = f32[] constant(1) + broadcast.5 = f32[256,256]{1,0} broadcast(constant.4), dimensions={} + subtract.30 = f32[256,256]{1,0} subtract(bitcast-convert.29, broadcast.5) + Arg_2.3 = f32[] parameter(2) + reshape.12 = f32[1,1]{1,0} reshape(Arg_2.3) + subtract.31 = f32[1,1]{1,0} subtract(reshape.12, reshape.11) + broadcast.32 = f32[1,1]{1,0} broadcast(subtract.31), dimensions={0,1} + reshape.33 = f32[] reshape(broadcast.32) + broadcast.34 = f32[256,256]{1,0} broadcast(reshape.33), dimensions={} + multiply.35 = f32[256,256]{1,0} multiply(subtract.30, broadcast.34) + broadcast.36 = f32[1,1]{1,0} broadcast(reshape.11), dimensions={0,1} + reshape.37 = f32[] reshape(broadcast.36) + broadcast.38 = f32[256,256]{1,0} broadcast(reshape.37), dimensions={} + add.39 = f32[256,256]{1,0} add(multiply.35, broadcast.38) + ROOT maximum.43 = f32[256,256]{1,0} maximum(broadcast.42, add.39) +} + diff --git a/tests/hlo_texts/test_hlos/deeperwin/module_0407.jit_heaviside.238.before_optimizations.txt b/tests/hlo_texts/test_hlos/deeperwin/module_0407.jit_heaviside.238.before_optimizations.txt new file mode 100644 index 0000000..0449e91 --- /dev/null +++ b/tests/hlo_texts/test_hlos/deeperwin/module_0407.jit_heaviside.238.before_optimizations.txt @@ -0,0 +1,32 @@ +HloModule jit_heaviside.238 + +_where.9 { + Arg_0.10 = pred[2048,1,2]{2,1,0} parameter(0) + Arg_1.11 = f32[] parameter(1) + broadcast.13 = f32[2048,1,2]{2,1,0} broadcast(Arg_1.11), dimensions={} + Arg_2.12 = f32[] parameter(2) + broadcast.14 = f32[2048,1,2]{2,1,0} broadcast(Arg_2.12), dimensions={} + ROOT select.15 = f32[2048,1,2]{2,1,0} select(Arg_0.10, broadcast.13, broadcast.14) +} + +_where_0.17 { + Arg_0.18 = pred[2048,1,2]{2,1,0} parameter(0) + Arg_1.19 = f32[] parameter(1) + broadcast.21 = f32[2048,1,2]{2,1,0} broadcast(Arg_1.19), dimensions={} + Arg_2.20 = f32[2048,1,2]{2,1,0} parameter(2) + ROOT select.22 = f32[2048,1,2]{2,1,0} select(Arg_0.18, broadcast.21, Arg_2.20) +} + +ENTRY main.24 { + Arg_0.1 = f32[2048,1,2]{2,1,0} parameter(0) + constant.5 = f32[] constant(0) + broadcast.6 = f32[2048,1,2]{2,1,0} broadcast(constant.5), dimensions={} + compare.7 = pred[2048,1,2]{2,1,0} compare(Arg_0.1, broadcast.6), direction=LT + constant.3 = f32[] constant(0) + compare.8 = pred[2048,1,2]{2,1,0} compare(Arg_0.1, broadcast.6), direction=GT + constant.4 = f32[] constant(1) + Arg_1.2 = f32[] parameter(1) + call.16 = f32[2048,1,2]{2,1,0} call(compare.8, constant.4, Arg_1.2), to_apply=_where.9 + ROOT call.23 = f32[2048,1,2]{2,1,0} call(compare.7, constant.3, call.16), to_apply=_where_0.17 +} + diff --git a/tests/hlo_texts/test_hlos/deeperwin/module_0479.jit_slogdet.280.before_optimizations.txt b/tests/hlo_texts/test_hlos/deeperwin/module_0479.jit_slogdet.280.before_optimizations.txt new file mode 100644 index 0000000..568f60a --- /dev/null +++ b/tests/hlo_texts/test_hlos/deeperwin/module_0479.jit_slogdet.280.before_optimizations.txt @@ -0,0 +1,130 @@ +HloModule jit_slogdet.280 + +diagonal.28 { + Arg_0.29 = f32[2048,1,1,1]{3,2,1,0} parameter(0) + constant.30 = s32[] constant(0) + broadcast.31 = s32[1,2]{1,0} broadcast(constant.30), dimensions={} + ROOT gather.32 = f32[2048,1,1]{2,1,0} gather(Arg_0.29, broadcast.31), offset_dims={0,1}, collapsed_slice_dims={2,3}, start_index_map={2,3}, index_vector_dim=1, slice_sizes={2048,1,1,1} +} + +region_0.35 { + Arg_0.36 = pred[] parameter(0) + Arg_1.37 = pred[] parameter(1) + ROOT or.38 = pred[] or(Arg_0.36, Arg_1.37) +} + +region_1.41 { + Arg_0.42 = s32[] parameter(0) + Arg_1.43 = s32[] parameter(1) + ROOT add.44 = s32[] add(Arg_0.42, Arg_1.43) +} + +count_nonzero.45 { + Arg_0.46 = pred[2048,1,1]{2,1,0} parameter(0) + convert.48 = s32[2048,1,1]{2,1,0} convert(Arg_0.46) + constant.47 = s32[] constant(0) + ROOT reduce.49 = s32[2048,1]{1,0} reduce(convert.48, constant.47), dimensions={2}, to_apply=region_1.41 +} + +region_2.52 { + Arg_0.53 = s32[] parameter(0) + Arg_1.54 = s32[] parameter(1) + ROOT add.55 = s32[] add(Arg_0.53, Arg_1.54) +} + +count_nonzero_0.56 { + Arg_0.57 = pred[2048,1,1]{2,1,0} parameter(0) + convert.59 = s32[2048,1,1]{2,1,0} convert(Arg_0.57) + constant.58 = s32[] constant(0) + ROOT reduce.60 = s32[2048,1]{1,0} reduce(convert.59, constant.58), dimensions={2}, to_apply=region_2.52 +} + +remainder.63 { + Arg_0.64 = s32[2048,1]{1,0} parameter(0) + Arg_1.65 = s32[] parameter(1) + broadcast.69 = s32[2048,1]{1,0} broadcast(Arg_1.65), dimensions={} + remainder.70 = s32[2048,1]{1,0} remainder(Arg_0.64, broadcast.69) + constant.67 = s32[] constant(0) + broadcast.68 = s32[2048,1]{1,0} broadcast(constant.67), dimensions={} + compare.72 = pred[2048,1]{1,0} compare(remainder.70, broadcast.68), direction=LT + constant.66 = s32[] constant(0) + compare.73 = pred[] compare(Arg_1.65, constant.66), direction=LT + broadcast.74 = pred[2048,1]{1,0} broadcast(compare.73), dimensions={} + compare.75 = pred[2048,1]{1,0} compare(compare.72, broadcast.74), direction=NE + compare.71 = pred[2048,1]{1,0} compare(remainder.70, broadcast.68), direction=NE + and.76 = pred[2048,1]{1,0} and(compare.75, compare.71) + broadcast.77 = s32[2048,1]{1,0} broadcast(Arg_1.65), dimensions={} + add.78 = s32[2048,1]{1,0} add(remainder.70, broadcast.77) + ROOT select.79 = s32[2048,1]{1,0} select(and.76, add.78, remainder.70) +} + +_where.84 { + Arg_0.85 = pred[2048,1]{1,0} parameter(0) + Arg_1.86 = f32[] parameter(1) + broadcast.88 = f32[2048,1]{1,0} broadcast(Arg_1.86), dimensions={} + Arg_2.87 = f32[2048,1]{1,0} parameter(2) + ROOT select.89 = f32[2048,1]{1,0} select(Arg_0.85, broadcast.88, Arg_2.87) +} + +region_3.93 { + Arg_0.94 = f32[] parameter(0) + Arg_1.95 = f32[] parameter(1) + ROOT add.96 = f32[] add(Arg_0.94, Arg_1.95) +} + +_where_1.98 { + Arg_0.99 = pred[2048,1]{1,0} parameter(0) + Arg_1.100 = f32[] parameter(1) + broadcast.102 = f32[2048,1]{1,0} broadcast(Arg_1.100), dimensions={} + Arg_2.101 = f32[2048,1]{1,0} parameter(2) + ROOT select.103 = f32[2048,1]{1,0} select(Arg_0.99, broadcast.102, Arg_2.101) +} + +ENTRY main.106 { + Arg_0.1 = f32[2048,1,1,1]{3,2,1,0} parameter(0) + custom-call.20 = (f32[2048,1,1,1]{2,3,1,0}, s32[2048,1,1]{2,1,0}, s32[2048,1]{1,0}, s8[16384]{0}) custom-call(Arg_0.1), custom_call_target="cublas_getrf_batched", operand_layout_constraints={f32[2048,1,1,1]{2,3,1,0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\000\000\000\000\000\010\000\000\001\000\000\000" + get-tuple-element.23 = s32[2048,1]{1,0} get-tuple-element(custom-call.20), index=2 + constant.16 = s32[] constant(0) + broadcast.17 = s32[2048,1]{1,0} broadcast(constant.16), dimensions={} + compare.25 = pred[2048,1]{1,0} compare(get-tuple-element.23, broadcast.17), direction=GE + reshape.26 = pred[2048,1,1,1]{3,2,1,0} reshape(compare.25) + get-tuple-element.21 = f32[2048,1,1,1]{2,3,1,0} get-tuple-element(custom-call.20), index=0 + constant.14 = f32[] constant(nan) + broadcast.15 = f32[2048,1,1,1]{3,2,1,0} broadcast(constant.14), dimensions={} + select.27 = f32[2048,1,1,1]{3,2,1,0} select(reshape.26, get-tuple-element.21, broadcast.15) + call.33 = f32[2048,1,1]{2,1,0} call(select.27), to_apply=diagonal.28 + constant.9 = f32[] constant(0) + broadcast.10 = f32[2048,1,1]{2,1,0} broadcast(constant.9), dimensions={} + compare.34 = pred[2048,1,1]{2,1,0} compare(call.33, broadcast.10), direction=EQ + constant.13 = pred[] constant(false) + reduce.39 = pred[2048,1]{1,0} reduce(compare.34, constant.13), dimensions={2}, to_apply=region_0.35 + constant.3 = f32[] constant(0) + get-tuple-element.22 = s32[2048,1,1]{2,1,0} get-tuple-element(custom-call.20), index=1 + constant.18 = s32[] constant(1) + broadcast.19 = s32[2048,1,1]{2,1,0} broadcast(constant.18), dimensions={} + subtract.24 = s32[2048,1,1]{2,1,0} subtract(get-tuple-element.22, broadcast.19) + constant.11 = s32[] constant(0) + broadcast.12 = s32[2048,1,1]{2,1,0} broadcast(constant.11), dimensions={} + compare.40 = pred[2048,1,1]{2,1,0} compare(subtract.24, broadcast.12), direction=NE + call.50 = s32[2048,1]{1,0} call(compare.40), to_apply=count_nonzero.45 + compare.51 = pred[2048,1,1]{2,1,0} compare(call.33, broadcast.10), direction=LT + call.61 = s32[2048,1]{1,0} call(compare.51), to_apply=count_nonzero_0.56 + add.62 = s32[2048,1]{1,0} add(call.50, call.61) + constant.8 = s32[] constant(2) + call.80 = s32[2048,1]{1,0} call(add.62, constant.8), to_apply=remainder.63 + constant.6 = s32[] constant(-2) + broadcast.7 = s32[2048,1]{1,0} broadcast(constant.6), dimensions={} + multiply.81 = s32[2048,1]{1,0} multiply(call.80, broadcast.7) + constant.4 = s32[] constant(1) + broadcast.5 = s32[2048,1]{1,0} broadcast(constant.4), dimensions={} + add.82 = s32[2048,1]{1,0} add(multiply.81, broadcast.5) + convert.83 = f32[2048,1]{1,0} convert(add.82) + call.90 = f32[2048,1]{1,0} call(reduce.39, constant.3, convert.83), to_apply=_where.84 + constant.2 = f32[] constant(-inf) + abs.91 = f32[2048,1,1]{2,1,0} abs(call.33) + log.92 = f32[2048,1,1]{2,1,0} log(abs.91) + reduce.97 = f32[2048,1]{1,0} reduce(log.92, constant.3), dimensions={2}, to_apply=region_3.93 + call.104 = f32[2048,1]{1,0} call(reduce.39, constant.2, reduce.97), to_apply=_where_1.98 + ROOT tuple.105 = (f32[2048,1]{1,0}, f32[2048,1]{1,0}) tuple(call.90, call.104) +} + diff --git a/tests/hlo_texts/test_hlos/deeperwin/module_0500.jit__power.288.before_optimizations.txt b/tests/hlo_texts/test_hlos/deeperwin/module_0500.jit__power.288.before_optimizations.txt new file mode 100644 index 0000000..d5b637b --- /dev/null +++ b/tests/hlo_texts/test_hlos/deeperwin/module_0500.jit__power.288.before_optimizations.txt @@ -0,0 +1,16 @@ +HloModule jit__power.288 + +ENTRY main.12 { + Arg_0.1 = f32[2048,4,1,1,1]{4,3,2,1,0} parameter(0) + broadcast.5 = f32[2048,4,1,1,1]{4,3,2,1,0} broadcast(Arg_0.1), dimensions={0,1,2,3,4} + reshape.6 = f32[2048,4,1,1]{3,2,1,0} reshape(broadcast.5) + broadcast.7 = f32[2048,4,1,1,5]{4,3,2,1,0} broadcast(reshape.6), dimensions={0,1,2,3} + Arg_1.2 = s32[5]{0} parameter(1) + convert.3 = f32[5]{0} convert(Arg_1.2) + reshape.4 = f32[1,1,1,1,5]{4,3,2,1,0} reshape(convert.3) + broadcast.8 = f32[1,1,1,1,5]{4,3,2,1,0} broadcast(reshape.4), dimensions={0,1,2,3,4} + reshape.9 = f32[1,1,5]{2,1,0} reshape(broadcast.8) + broadcast.10 = f32[2048,4,1,1,5]{4,3,2,1,0} broadcast(reshape.9), dimensions={2,3,4} + ROOT power.11 = f32[2048,4,1,1,5]{4,3,2,1,0} power(broadcast.7, broadcast.10) +} + diff --git a/tests/hlo_texts/test_hlos/deeperwin/module_0667.jit_slogdet.385.before_optimizations.txt b/tests/hlo_texts/test_hlos/deeperwin/module_0667.jit_slogdet.385.before_optimizations.txt new file mode 100644 index 0000000..8349a1e --- /dev/null +++ b/tests/hlo_texts/test_hlos/deeperwin/module_0667.jit_slogdet.385.before_optimizations.txt @@ -0,0 +1,149 @@ +HloModule jit_slogdet.385 + +diagonal.29 { + Arg_0.30 = f32[2048,20,4,4]{3,2,1,0} parameter(0) + iota.35 = s32[4]{0} iota(), iota_dimension=0 + constant.33 = s32[] constant(0) + broadcast.34 = s32[4]{0} broadcast(constant.33), dimensions={} + compare.37 = pred[4]{0} compare(iota.35, broadcast.34), direction=LT + constant.31 = s32[] constant(4) + broadcast.32 = s32[4]{0} broadcast(constant.31), dimensions={} + add.38 = s32[4]{0} add(iota.35, broadcast.32) + select.39 = s32[4]{0} select(compare.37, add.38, iota.35) + reshape.43 = s32[4,1]{1,0} reshape(select.39) + iota.36 = s32[4]{0} iota(), iota_dimension=0 + compare.40 = pred[4]{0} compare(iota.36, broadcast.34), direction=LT + add.41 = s32[4]{0} add(iota.36, broadcast.32) + select.42 = s32[4]{0} select(compare.40, add.41, iota.36) + reshape.44 = s32[4,1]{1,0} reshape(select.42) + concatenate.45 = s32[4,2]{1,0} concatenate(reshape.43, reshape.44), dimensions={1} + ROOT gather.46 = f32[2048,20,4]{2,1,0} gather(Arg_0.30, concatenate.45), offset_dims={0,1}, collapsed_slice_dims={2,3}, start_index_map={2,3}, index_vector_dim=1, slice_sizes={2048,20,1,1} +} + +region_0.49 { + Arg_0.50 = pred[] parameter(0) + Arg_1.51 = pred[] parameter(1) + ROOT or.52 = pred[] or(Arg_0.50, Arg_1.51) +} + +region_1.60 { + Arg_0.61 = s32[] parameter(0) + Arg_1.62 = s32[] parameter(1) + ROOT add.63 = s32[] add(Arg_0.61, Arg_1.62) +} + +count_nonzero.64 { + Arg_0.65 = pred[2048,20,4]{2,1,0} parameter(0) + convert.67 = s32[2048,20,4]{2,1,0} convert(Arg_0.65) + constant.66 = s32[] constant(0) + ROOT reduce.68 = s32[2048,20]{1,0} reduce(convert.67, constant.66), dimensions={2}, to_apply=region_1.60 +} + +region_2.71 { + Arg_0.72 = s32[] parameter(0) + Arg_1.73 = s32[] parameter(1) + ROOT add.74 = s32[] add(Arg_0.72, Arg_1.73) +} + +count_nonzero_0.75 { + Arg_0.76 = pred[2048,20,4]{2,1,0} parameter(0) + convert.78 = s32[2048,20,4]{2,1,0} convert(Arg_0.76) + constant.77 = s32[] constant(0) + ROOT reduce.79 = s32[2048,20]{1,0} reduce(convert.78, constant.77), dimensions={2}, to_apply=region_2.71 +} + +remainder.82 { + Arg_0.83 = s32[2048,20]{1,0} parameter(0) + Arg_1.84 = s32[] parameter(1) + broadcast.88 = s32[2048,20]{1,0} broadcast(Arg_1.84), dimensions={} + remainder.89 = s32[2048,20]{1,0} remainder(Arg_0.83, broadcast.88) + constant.86 = s32[] constant(0) + broadcast.87 = s32[2048,20]{1,0} broadcast(constant.86), dimensions={} + compare.91 = pred[2048,20]{1,0} compare(remainder.89, broadcast.87), direction=LT + constant.85 = s32[] constant(0) + compare.92 = pred[] compare(Arg_1.84, constant.85), direction=LT + broadcast.93 = pred[2048,20]{1,0} broadcast(compare.92), dimensions={} + compare.94 = pred[2048,20]{1,0} compare(compare.91, broadcast.93), direction=NE + compare.90 = pred[2048,20]{1,0} compare(remainder.89, broadcast.87), direction=NE + and.95 = pred[2048,20]{1,0} and(compare.94, compare.90) + broadcast.96 = s32[2048,20]{1,0} broadcast(Arg_1.84), dimensions={} + add.97 = s32[2048,20]{1,0} add(remainder.89, broadcast.96) + ROOT select.98 = s32[2048,20]{1,0} select(and.95, add.97, remainder.89) +} + +_where.103 { + Arg_0.104 = pred[2048,20]{1,0} parameter(0) + Arg_1.105 = f32[] parameter(1) + broadcast.107 = f32[2048,20]{1,0} broadcast(Arg_1.105), dimensions={} + Arg_2.106 = f32[2048,20]{1,0} parameter(2) + ROOT select.108 = f32[2048,20]{1,0} select(Arg_0.104, broadcast.107, Arg_2.106) +} + +region_3.112 { + Arg_0.113 = f32[] parameter(0) + Arg_1.114 = f32[] parameter(1) + ROOT add.115 = f32[] add(Arg_0.113, Arg_1.114) +} + +_where_1.117 { + Arg_0.118 = pred[2048,20]{1,0} parameter(0) + Arg_1.119 = f32[] parameter(1) + broadcast.121 = f32[2048,20]{1,0} broadcast(Arg_1.119), dimensions={} + Arg_2.120 = f32[2048,20]{1,0} parameter(2) + ROOT select.122 = f32[2048,20]{1,0} select(Arg_0.118, broadcast.121, Arg_2.120) +} + +ENTRY main.125 { + Arg_0.1 = f32[2048,20,4,4]{3,2,1,0} parameter(0) + custom-call.18 = (f32[2048,20,4,4]{2,3,1,0}, s32[2048,20,4]{2,1,0}, s32[2048,20]{1,0}, s8[327680]{0}) custom-call(Arg_0.1), custom_call_target="cublas_getrf_batched", operand_layout_constraints={f32[2048,20,4,4]{2,3,1,0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\000\000\000\000\000\240\000\000\004\000\000\000" + get-tuple-element.21 = s32[2048,20]{1,0} get-tuple-element(custom-call.18), index=2 + constant.14 = s32[] constant(0) + broadcast.15 = s32[2048,20]{1,0} broadcast(constant.14), dimensions={} + compare.23 = pred[2048,20]{1,0} compare(get-tuple-element.21, broadcast.15), direction=GE + reshape.24 = pred[2048,20,1,1]{3,2,1,0} reshape(compare.23) + broadcast.25 = pred[2048,20,1,1]{3,2,1,0} broadcast(reshape.24), dimensions={0,1,2,3} + reshape.26 = pred[2048,20]{1,0} reshape(broadcast.25) + broadcast.27 = pred[2048,20,4,4]{3,2,1,0} broadcast(reshape.26), dimensions={0,1} + get-tuple-element.19 = f32[2048,20,4,4]{2,3,1,0} get-tuple-element(custom-call.18), index=0 + constant.12 = f32[] constant(nan) + broadcast.13 = f32[2048,20,4,4]{3,2,1,0} broadcast(constant.12), dimensions={} + select.28 = f32[2048,20,4,4]{3,2,1,0} select(broadcast.27, get-tuple-element.19, broadcast.13) + call.47 = f32[2048,20,4]{2,1,0} call(select.28), to_apply=diagonal.29 + constant.9 = f32[] constant(0) + broadcast.10 = f32[2048,20,4]{2,1,0} broadcast(constant.9), dimensions={} + compare.48 = pred[2048,20,4]{2,1,0} compare(call.47, broadcast.10), direction=EQ + constant.11 = pred[] constant(false) + reduce.53 = pred[2048,20]{1,0} reduce(compare.48, constant.11), dimensions={2}, to_apply=region_0.49 + constant.3 = f32[] constant(0) + get-tuple-element.20 = s32[2048,20,4]{2,1,0} get-tuple-element(custom-call.18), index=1 + constant.16 = s32[] constant(1) + broadcast.17 = s32[2048,20,4]{2,1,0} broadcast(constant.16), dimensions={} + subtract.22 = s32[2048,20,4]{2,1,0} subtract(get-tuple-element.20, broadcast.17) + iota.54 = s32[4]{0} iota(), iota_dimension=0 + reshape.55 = s32[1,1,4]{2,1,0} reshape(iota.54) + broadcast.56 = s32[1,1,4]{2,1,0} broadcast(reshape.55), dimensions={0,1,2} + reshape.57 = s32[4]{0} reshape(broadcast.56) + broadcast.58 = s32[2048,20,4]{2,1,0} broadcast(reshape.57), dimensions={2} + compare.59 = pred[2048,20,4]{2,1,0} compare(subtract.22, broadcast.58), direction=NE + call.69 = s32[2048,20]{1,0} call(compare.59), to_apply=count_nonzero.64 + compare.70 = pred[2048,20,4]{2,1,0} compare(call.47, broadcast.10), direction=LT + call.80 = s32[2048,20]{1,0} call(compare.70), to_apply=count_nonzero_0.75 + add.81 = s32[2048,20]{1,0} add(call.69, call.80) + constant.8 = s32[] constant(2) + call.99 = s32[2048,20]{1,0} call(add.81, constant.8), to_apply=remainder.82 + constant.6 = s32[] constant(-2) + broadcast.7 = s32[2048,20]{1,0} broadcast(constant.6), dimensions={} + multiply.100 = s32[2048,20]{1,0} multiply(call.99, broadcast.7) + constant.4 = s32[] constant(1) + broadcast.5 = s32[2048,20]{1,0} broadcast(constant.4), dimensions={} + add.101 = s32[2048,20]{1,0} add(multiply.100, broadcast.5) + convert.102 = f32[2048,20]{1,0} convert(add.101) + call.109 = f32[2048,20]{1,0} call(reduce.53, constant.3, convert.102), to_apply=_where.103 + constant.2 = f32[] constant(-inf) + abs.110 = f32[2048,20,4]{2,1,0} abs(call.47) + log.111 = f32[2048,20,4]{2,1,0} log(abs.110) + reduce.116 = f32[2048,20]{1,0} reduce(log.111, constant.3), dimensions={2}, to_apply=region_3.112 + call.123 = f32[2048,20]{1,0} call(reduce.53, constant.2, reduce.116), to_apply=_where_1.117 + ROOT tuple.124 = (f32[2048,20]{1,0}, f32[2048,20]{1,0}) tuple(call.109, call.123) +} + diff --git a/tests/hlo_texts/test_hlos/efficientnet-jax/module_0348.jit__lambda_.129.before_optimizations.txt b/tests/hlo_texts/test_hlos/efficientnet-jax/module_0348.jit__lambda_.129.before_optimizations.txt new file mode 100644 index 0000000..d71476e --- /dev/null +++ b/tests/hlo_texts/test_hlos/efficientnet-jax/module_0348.jit__lambda_.129.before_optimizations.txt @@ -0,0 +1,11 @@ +HloModule jit__lambda_.129 + +ENTRY %main.7 (Arg_0.1: f32[1,14,14,240], Arg_1.2: f32[1,1,1,240]) -> f32[1,14,14,240] { + %Arg_0.1 = f32[1,14,14,240]{3,2,1,0} parameter(0) + %Arg_1.2 = f32[1,1,1,240]{3,2,1,0} parameter(1) + %broadcast.3 = f32[1,1,1,240]{3,2,1,0} broadcast(f32[1,1,1,240]{3,2,1,0} %Arg_1.2), dimensions={0,1,2,3} + %reshape.4 = f32[1,240]{1,0} reshape(f32[1,1,1,240]{3,2,1,0} %broadcast.3) + %broadcast.5 = f32[1,14,14,240]{3,2,1,0} broadcast(f32[1,240]{1,0} %reshape.4), dimensions={0,3} + ROOT %subtract.6 = f32[1,14,14,240]{3,2,1,0} subtract(f32[1,14,14,240]{3,2,1,0} %Arg_0.1, f32[1,14,14,240]{3,2,1,0} %broadcast.5) +} + diff --git a/tests/hlo_texts/test_hlos/efficientnet-jax/module_0352.jit_fn.131.before_optimizations.txt b/tests/hlo_texts/test_hlos/efficientnet-jax/module_0352.jit_fn.131.before_optimizations.txt new file mode 100644 index 0000000..fc15294 --- /dev/null +++ b/tests/hlo_texts/test_hlos/efficientnet-jax/module_0352.jit_fn.131.before_optimizations.txt @@ -0,0 +1,11 @@ +HloModule jit_fn.131 + +ENTRY %main.7 (Arg_0.1: f32[1,14,14,240], Arg_1.2: f32[1,1,1,240]) -> f32[1,14,14,240] { + %Arg_0.1 = f32[1,14,14,240]{3,2,1,0} parameter(0) + %Arg_1.2 = f32[1,1,1,240]{3,2,1,0} parameter(1) + %broadcast.3 = f32[1,1,1,240]{3,2,1,0} broadcast(f32[1,1,1,240]{3,2,1,0} %Arg_1.2), dimensions={0,1,2,3} + %reshape.4 = f32[1,240]{1,0} reshape(f32[1,1,1,240]{3,2,1,0} %broadcast.3) + %broadcast.5 = f32[1,14,14,240]{3,2,1,0} broadcast(f32[1,240]{1,0} %reshape.4), dimensions={0,3} + ROOT %add.6 = f32[1,14,14,240]{3,2,1,0} add(f32[1,14,14,240]{3,2,1,0} %Arg_0.1, f32[1,14,14,240]{3,2,1,0} %broadcast.5) +} + diff --git a/tests/hlo_texts/test_hlos/efficientnet-jax/module_0698.jit__lambda_.256.before_optimizations.txt b/tests/hlo_texts/test_hlos/efficientnet-jax/module_0698.jit__lambda_.256.before_optimizations.txt new file mode 100644 index 0000000..b270abb --- /dev/null +++ b/tests/hlo_texts/test_hlos/efficientnet-jax/module_0698.jit__lambda_.256.before_optimizations.txt @@ -0,0 +1,2172 @@ +HloModule jit__lambda_.256 + +%jit_relu6.390 (Arg_0.391: f32[250,150,150,32]) -> f32[250,150,150,32] { + %Arg_0.391 = f32[250,150,150,32]{3,2,1,0} parameter(0) + %constant.394 = f32[] constant(0) + %broadcast.395 = f32[250,150,150,32]{3,2,1,0} broadcast(f32[] %constant.394), dimensions={} + %maximum.396 = f32[250,150,150,32]{3,2,1,0} maximum(f32[250,150,150,32]{3,2,1,0} %Arg_0.391, f32[250,150,150,32]{3,2,1,0} %broadcast.395) + %constant.392 = f32[] constant(6) + %broadcast.393 = f32[250,150,150,32]{3,2,1,0} broadcast(f32[] %constant.392), dimensions={} + ROOT %minimum.397 = f32[250,150,150,32]{3,2,1,0} minimum(f32[250,150,150,32]{3,2,1,0} %maximum.396, f32[250,150,150,32]{3,2,1,0} %broadcast.393) +} + +%jit_relu6_0.415 (Arg_0.416: f32[250,150,150,32]) -> f32[250,150,150,32] { + %Arg_0.416 = f32[250,150,150,32]{3,2,1,0} parameter(0) + %constant.419 = f32[] constant(0) + %broadcast.420 = f32[250,150,150,32]{3,2,1,0} broadcast(f32[] %constant.419), dimensions={} + %maximum.421 = f32[250,150,150,32]{3,2,1,0} maximum(f32[250,150,150,32]{3,2,1,0} %Arg_0.416, f32[250,150,150,32]{3,2,1,0} %broadcast.420) + %constant.417 = f32[] constant(6) + %broadcast.418 = f32[250,150,150,32]{3,2,1,0} broadcast(f32[] %constant.417), dimensions={} + ROOT %minimum.422 = f32[250,150,150,32]{3,2,1,0} minimum(f32[250,150,150,32]{3,2,1,0} %maximum.421, f32[250,150,150,32]{3,2,1,0} %broadcast.418) +} + +%jit_relu6_1.456 (Arg_0.457: f32[250,150,150,144]) -> f32[250,150,150,144] { + %Arg_0.457 = f32[250,150,150,144]{3,2,1,0} parameter(0) + %constant.460 = f32[] constant(0) + %broadcast.461 = f32[250,150,150,144]{3,2,1,0} broadcast(f32[] %constant.460), dimensions={} + %maximum.462 = f32[250,150,150,144]{3,2,1,0} maximum(f32[250,150,150,144]{3,2,1,0} %Arg_0.457, f32[250,150,150,144]{3,2,1,0} %broadcast.461) + %constant.458 = f32[] constant(6) + %broadcast.459 = f32[250,150,150,144]{3,2,1,0} broadcast(f32[] %constant.458), dimensions={} + ROOT %minimum.463 = f32[250,150,150,144]{3,2,1,0} minimum(f32[250,150,150,144]{3,2,1,0} %maximum.462, f32[250,150,150,144]{3,2,1,0} %broadcast.459) +} + +%jit_relu6_2.481 (Arg_0.482: f32[250,75,75,144]) -> f32[250,75,75,144] { + %Arg_0.482 = f32[250,75,75,144]{3,2,1,0} parameter(0) + %constant.485 = f32[] constant(0) + %broadcast.486 = f32[250,75,75,144]{3,2,1,0} broadcast(f32[] %constant.485), dimensions={} + %maximum.487 = f32[250,75,75,144]{3,2,1,0} maximum(f32[250,75,75,144]{3,2,1,0} %Arg_0.482, f32[250,75,75,144]{3,2,1,0} %broadcast.486) + %constant.483 = f32[] constant(6) + %broadcast.484 = f32[250,75,75,144]{3,2,1,0} broadcast(f32[] %constant.483), dimensions={} + ROOT %minimum.488 = f32[250,75,75,144]{3,2,1,0} minimum(f32[250,75,75,144]{3,2,1,0} %maximum.487, f32[250,75,75,144]{3,2,1,0} %broadcast.484) +} + +%jit_relu6_3.522 (Arg_0.523: f32[250,75,75,192]) -> f32[250,75,75,192] { + %Arg_0.523 = f32[250,75,75,192]{3,2,1,0} parameter(0) + %constant.526 = f32[] constant(0) + %broadcast.527 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[] %constant.526), dimensions={} + %maximum.528 = f32[250,75,75,192]{3,2,1,0} maximum(f32[250,75,75,192]{3,2,1,0} %Arg_0.523, f32[250,75,75,192]{3,2,1,0} %broadcast.527) + %constant.524 = f32[] constant(6) + %broadcast.525 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[] %constant.524), dimensions={} + ROOT %minimum.529 = f32[250,75,75,192]{3,2,1,0} minimum(f32[250,75,75,192]{3,2,1,0} %maximum.528, f32[250,75,75,192]{3,2,1,0} %broadcast.525) +} + +%jit_relu6_4.547 (Arg_0.548: f32[250,75,75,192]) -> f32[250,75,75,192] { + %Arg_0.548 = f32[250,75,75,192]{3,2,1,0} parameter(0) + %constant.551 = f32[] constant(0) + %broadcast.552 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[] %constant.551), dimensions={} + %maximum.553 = f32[250,75,75,192]{3,2,1,0} maximum(f32[250,75,75,192]{3,2,1,0} %Arg_0.548, f32[250,75,75,192]{3,2,1,0} %broadcast.552) + %constant.549 = f32[] constant(6) + %broadcast.550 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[] %constant.549), dimensions={} + ROOT %minimum.554 = f32[250,75,75,192]{3,2,1,0} minimum(f32[250,75,75,192]{3,2,1,0} %maximum.553, f32[250,75,75,192]{3,2,1,0} %broadcast.550) +} + +%jit_relu6_5.589 (Arg_0.590: f32[250,75,75,192]) -> f32[250,75,75,192] { + %Arg_0.590 = f32[250,75,75,192]{3,2,1,0} parameter(0) + %constant.593 = f32[] constant(0) + %broadcast.594 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[] %constant.593), dimensions={} + %maximum.595 = f32[250,75,75,192]{3,2,1,0} maximum(f32[250,75,75,192]{3,2,1,0} %Arg_0.590, f32[250,75,75,192]{3,2,1,0} %broadcast.594) + %constant.591 = f32[] constant(6) + %broadcast.592 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[] %constant.591), dimensions={} + ROOT %minimum.596 = f32[250,75,75,192]{3,2,1,0} minimum(f32[250,75,75,192]{3,2,1,0} %maximum.595, f32[250,75,75,192]{3,2,1,0} %broadcast.592) +} + +%jit_relu6_6.614 (Arg_0.615: f32[250,75,75,192]) -> f32[250,75,75,192] { + %Arg_0.615 = f32[250,75,75,192]{3,2,1,0} parameter(0) + %constant.618 = f32[] constant(0) + %broadcast.619 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[] %constant.618), dimensions={} + %maximum.620 = f32[250,75,75,192]{3,2,1,0} maximum(f32[250,75,75,192]{3,2,1,0} %Arg_0.615, f32[250,75,75,192]{3,2,1,0} %broadcast.619) + %constant.616 = f32[] constant(6) + %broadcast.617 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[] %constant.616), dimensions={} + ROOT %minimum.621 = f32[250,75,75,192]{3,2,1,0} minimum(f32[250,75,75,192]{3,2,1,0} %maximum.620, f32[250,75,75,192]{3,2,1,0} %broadcast.617) +} + +%jit_relu6_7.656 (Arg_0.657: f32[250,75,75,192]) -> f32[250,75,75,192] { + %Arg_0.657 = f32[250,75,75,192]{3,2,1,0} parameter(0) + %constant.660 = f32[] constant(0) + %broadcast.661 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[] %constant.660), dimensions={} + %maximum.662 = f32[250,75,75,192]{3,2,1,0} maximum(f32[250,75,75,192]{3,2,1,0} %Arg_0.657, f32[250,75,75,192]{3,2,1,0} %broadcast.661) + %constant.658 = f32[] constant(6) + %broadcast.659 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[] %constant.658), dimensions={} + ROOT %minimum.663 = f32[250,75,75,192]{3,2,1,0} minimum(f32[250,75,75,192]{3,2,1,0} %maximum.662, f32[250,75,75,192]{3,2,1,0} %broadcast.659) +} + +%jit_relu6_8.681 (Arg_0.682: f32[250,38,38,192]) -> f32[250,38,38,192] { + %Arg_0.682 = f32[250,38,38,192]{3,2,1,0} parameter(0) + %constant.685 = f32[] constant(0) + %broadcast.686 = f32[250,38,38,192]{3,2,1,0} broadcast(f32[] %constant.685), dimensions={} + %maximum.687 = f32[250,38,38,192]{3,2,1,0} maximum(f32[250,38,38,192]{3,2,1,0} %Arg_0.682, f32[250,38,38,192]{3,2,1,0} %broadcast.686) + %constant.683 = f32[] constant(6) + %broadcast.684 = f32[250,38,38,192]{3,2,1,0} broadcast(f32[] %constant.683), dimensions={} + ROOT %minimum.688 = f32[250,38,38,192]{3,2,1,0} minimum(f32[250,38,38,192]{3,2,1,0} %maximum.687, f32[250,38,38,192]{3,2,1,0} %broadcast.684) +} + +%jit_relu6_9.722 (Arg_0.723: f32[250,38,38,288]) -> f32[250,38,38,288] { + %Arg_0.723 = f32[250,38,38,288]{3,2,1,0} parameter(0) + %constant.726 = f32[] constant(0) + %broadcast.727 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[] %constant.726), dimensions={} + %maximum.728 = f32[250,38,38,288]{3,2,1,0} maximum(f32[250,38,38,288]{3,2,1,0} %Arg_0.723, f32[250,38,38,288]{3,2,1,0} %broadcast.727) + %constant.724 = f32[] constant(6) + %broadcast.725 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[] %constant.724), dimensions={} + ROOT %minimum.729 = f32[250,38,38,288]{3,2,1,0} minimum(f32[250,38,38,288]{3,2,1,0} %maximum.728, f32[250,38,38,288]{3,2,1,0} %broadcast.725) +} + +%jit_relu6_10.747 (Arg_0.748: f32[250,38,38,288]) -> f32[250,38,38,288] { + %Arg_0.748 = f32[250,38,38,288]{3,2,1,0} parameter(0) + %constant.751 = f32[] constant(0) + %broadcast.752 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[] %constant.751), dimensions={} + %maximum.753 = f32[250,38,38,288]{3,2,1,0} maximum(f32[250,38,38,288]{3,2,1,0} %Arg_0.748, f32[250,38,38,288]{3,2,1,0} %broadcast.752) + %constant.749 = f32[] constant(6) + %broadcast.750 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[] %constant.749), dimensions={} + ROOT %minimum.754 = f32[250,38,38,288]{3,2,1,0} minimum(f32[250,38,38,288]{3,2,1,0} %maximum.753, f32[250,38,38,288]{3,2,1,0} %broadcast.750) +} + +%jit_relu6_11.789 (Arg_0.790: f32[250,38,38,288]) -> f32[250,38,38,288] { + %Arg_0.790 = f32[250,38,38,288]{3,2,1,0} parameter(0) + %constant.793 = f32[] constant(0) + %broadcast.794 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[] %constant.793), dimensions={} + %maximum.795 = f32[250,38,38,288]{3,2,1,0} maximum(f32[250,38,38,288]{3,2,1,0} %Arg_0.790, f32[250,38,38,288]{3,2,1,0} %broadcast.794) + %constant.791 = f32[] constant(6) + %broadcast.792 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[] %constant.791), dimensions={} + ROOT %minimum.796 = f32[250,38,38,288]{3,2,1,0} minimum(f32[250,38,38,288]{3,2,1,0} %maximum.795, f32[250,38,38,288]{3,2,1,0} %broadcast.792) +} + +%jit_relu6_12.814 (Arg_0.815: f32[250,38,38,288]) -> f32[250,38,38,288] { + %Arg_0.815 = f32[250,38,38,288]{3,2,1,0} parameter(0) + %constant.818 = f32[] constant(0) + %broadcast.819 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[] %constant.818), dimensions={} + %maximum.820 = f32[250,38,38,288]{3,2,1,0} maximum(f32[250,38,38,288]{3,2,1,0} %Arg_0.815, f32[250,38,38,288]{3,2,1,0} %broadcast.819) + %constant.816 = f32[] constant(6) + %broadcast.817 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[] %constant.816), dimensions={} + ROOT %minimum.821 = f32[250,38,38,288]{3,2,1,0} minimum(f32[250,38,38,288]{3,2,1,0} %maximum.820, f32[250,38,38,288]{3,2,1,0} %broadcast.817) +} + +%jit_relu6_13.856 (Arg_0.857: f32[250,38,38,288]) -> f32[250,38,38,288] { + %Arg_0.857 = f32[250,38,38,288]{3,2,1,0} parameter(0) + %constant.860 = f32[] constant(0) + %broadcast.861 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[] %constant.860), dimensions={} + %maximum.862 = f32[250,38,38,288]{3,2,1,0} maximum(f32[250,38,38,288]{3,2,1,0} %Arg_0.857, f32[250,38,38,288]{3,2,1,0} %broadcast.861) + %constant.858 = f32[] constant(6) + %broadcast.859 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[] %constant.858), dimensions={} + ROOT %minimum.863 = f32[250,38,38,288]{3,2,1,0} minimum(f32[250,38,38,288]{3,2,1,0} %maximum.862, f32[250,38,38,288]{3,2,1,0} %broadcast.859) +} + +%jit_relu6_14.881 (Arg_0.882: f32[250,19,19,288]) -> f32[250,19,19,288] { + %Arg_0.882 = f32[250,19,19,288]{3,2,1,0} parameter(0) + %constant.885 = f32[] constant(0) + %broadcast.886 = f32[250,19,19,288]{3,2,1,0} broadcast(f32[] %constant.885), dimensions={} + %maximum.887 = f32[250,19,19,288]{3,2,1,0} maximum(f32[250,19,19,288]{3,2,1,0} %Arg_0.882, f32[250,19,19,288]{3,2,1,0} %broadcast.886) + %constant.883 = f32[] constant(6) + %broadcast.884 = f32[250,19,19,288]{3,2,1,0} broadcast(f32[] %constant.883), dimensions={} + ROOT %minimum.888 = f32[250,19,19,288]{3,2,1,0} minimum(f32[250,19,19,288]{3,2,1,0} %maximum.887, f32[250,19,19,288]{3,2,1,0} %broadcast.884) +} + +%jit_relu6_15.922 (Arg_0.923: f32[250,19,19,576]) -> f32[250,19,19,576] { + %Arg_0.923 = f32[250,19,19,576]{3,2,1,0} parameter(0) + %constant.926 = f32[] constant(0) + %broadcast.927 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[] %constant.926), dimensions={} + %maximum.928 = f32[250,19,19,576]{3,2,1,0} maximum(f32[250,19,19,576]{3,2,1,0} %Arg_0.923, f32[250,19,19,576]{3,2,1,0} %broadcast.927) + %constant.924 = f32[] constant(6) + %broadcast.925 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[] %constant.924), dimensions={} + ROOT %minimum.929 = f32[250,19,19,576]{3,2,1,0} minimum(f32[250,19,19,576]{3,2,1,0} %maximum.928, f32[250,19,19,576]{3,2,1,0} %broadcast.925) +} + +%jit_relu6_16.947 (Arg_0.948: f32[250,19,19,576]) -> f32[250,19,19,576] { + %Arg_0.948 = f32[250,19,19,576]{3,2,1,0} parameter(0) + %constant.951 = f32[] constant(0) + %broadcast.952 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[] %constant.951), dimensions={} + %maximum.953 = f32[250,19,19,576]{3,2,1,0} maximum(f32[250,19,19,576]{3,2,1,0} %Arg_0.948, f32[250,19,19,576]{3,2,1,0} %broadcast.952) + %constant.949 = f32[] constant(6) + %broadcast.950 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[] %constant.949), dimensions={} + ROOT %minimum.954 = f32[250,19,19,576]{3,2,1,0} minimum(f32[250,19,19,576]{3,2,1,0} %maximum.953, f32[250,19,19,576]{3,2,1,0} %broadcast.950) +} + +%jit_relu6_17.989 (Arg_0.990: f32[250,19,19,576]) -> f32[250,19,19,576] { + %Arg_0.990 = f32[250,19,19,576]{3,2,1,0} parameter(0) + %constant.993 = f32[] constant(0) + %broadcast.994 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[] %constant.993), dimensions={} + %maximum.995 = f32[250,19,19,576]{3,2,1,0} maximum(f32[250,19,19,576]{3,2,1,0} %Arg_0.990, f32[250,19,19,576]{3,2,1,0} %broadcast.994) + %constant.991 = f32[] constant(6) + %broadcast.992 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[] %constant.991), dimensions={} + ROOT %minimum.996 = f32[250,19,19,576]{3,2,1,0} minimum(f32[250,19,19,576]{3,2,1,0} %maximum.995, f32[250,19,19,576]{3,2,1,0} %broadcast.992) +} + +%jit_relu6_18.1014 (Arg_0.1015: f32[250,19,19,576]) -> f32[250,19,19,576] { + %Arg_0.1015 = f32[250,19,19,576]{3,2,1,0} parameter(0) + %constant.1018 = f32[] constant(0) + %broadcast.1019 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[] %constant.1018), dimensions={} + %maximum.1020 = f32[250,19,19,576]{3,2,1,0} maximum(f32[250,19,19,576]{3,2,1,0} %Arg_0.1015, f32[250,19,19,576]{3,2,1,0} %broadcast.1019) + %constant.1016 = f32[] constant(6) + %broadcast.1017 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[] %constant.1016), dimensions={} + ROOT %minimum.1021 = f32[250,19,19,576]{3,2,1,0} minimum(f32[250,19,19,576]{3,2,1,0} %maximum.1020, f32[250,19,19,576]{3,2,1,0} %broadcast.1017) +} + +%jit_relu6_19.1056 (Arg_0.1057: f32[250,19,19,576]) -> f32[250,19,19,576] { + %Arg_0.1057 = f32[250,19,19,576]{3,2,1,0} parameter(0) + %constant.1060 = f32[] constant(0) + %broadcast.1061 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[] %constant.1060), dimensions={} + %maximum.1062 = f32[250,19,19,576]{3,2,1,0} maximum(f32[250,19,19,576]{3,2,1,0} %Arg_0.1057, f32[250,19,19,576]{3,2,1,0} %broadcast.1061) + %constant.1058 = f32[] constant(6) + %broadcast.1059 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[] %constant.1058), dimensions={} + ROOT %minimum.1063 = f32[250,19,19,576]{3,2,1,0} minimum(f32[250,19,19,576]{3,2,1,0} %maximum.1062, f32[250,19,19,576]{3,2,1,0} %broadcast.1059) +} + +%jit_relu6_20.1081 (Arg_0.1082: f32[250,19,19,576]) -> f32[250,19,19,576] { + %Arg_0.1082 = f32[250,19,19,576]{3,2,1,0} parameter(0) + %constant.1085 = f32[] constant(0) + %broadcast.1086 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[] %constant.1085), dimensions={} + %maximum.1087 = f32[250,19,19,576]{3,2,1,0} maximum(f32[250,19,19,576]{3,2,1,0} %Arg_0.1082, f32[250,19,19,576]{3,2,1,0} %broadcast.1086) + %constant.1083 = f32[] constant(6) + %broadcast.1084 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[] %constant.1083), dimensions={} + ROOT %minimum.1088 = f32[250,19,19,576]{3,2,1,0} minimum(f32[250,19,19,576]{3,2,1,0} %maximum.1087, f32[250,19,19,576]{3,2,1,0} %broadcast.1084) +} + +%jit_relu6_21.1123 (Arg_0.1124: f32[250,19,19,576]) -> f32[250,19,19,576] { + %Arg_0.1124 = f32[250,19,19,576]{3,2,1,0} parameter(0) + %constant.1127 = f32[] constant(0) + %broadcast.1128 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[] %constant.1127), dimensions={} + %maximum.1129 = f32[250,19,19,576]{3,2,1,0} maximum(f32[250,19,19,576]{3,2,1,0} %Arg_0.1124, f32[250,19,19,576]{3,2,1,0} %broadcast.1128) + %constant.1125 = f32[] constant(6) + %broadcast.1126 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[] %constant.1125), dimensions={} + ROOT %minimum.1130 = f32[250,19,19,576]{3,2,1,0} minimum(f32[250,19,19,576]{3,2,1,0} %maximum.1129, f32[250,19,19,576]{3,2,1,0} %broadcast.1126) +} + +%jit_relu6_22.1148 (Arg_0.1149: f32[250,19,19,576]) -> f32[250,19,19,576] { + %Arg_0.1149 = f32[250,19,19,576]{3,2,1,0} parameter(0) + %constant.1152 = f32[] constant(0) + %broadcast.1153 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[] %constant.1152), dimensions={} + %maximum.1154 = f32[250,19,19,576]{3,2,1,0} maximum(f32[250,19,19,576]{3,2,1,0} %Arg_0.1149, f32[250,19,19,576]{3,2,1,0} %broadcast.1153) + %constant.1150 = f32[] constant(6) + %broadcast.1151 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[] %constant.1150), dimensions={} + ROOT %minimum.1155 = f32[250,19,19,576]{3,2,1,0} minimum(f32[250,19,19,576]{3,2,1,0} %maximum.1154, f32[250,19,19,576]{3,2,1,0} %broadcast.1151) +} + +%jit_relu6_23.1190 (Arg_0.1191: f32[250,19,19,576]) -> f32[250,19,19,576] { + %Arg_0.1191 = f32[250,19,19,576]{3,2,1,0} parameter(0) + %constant.1194 = f32[] constant(0) + %broadcast.1195 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[] %constant.1194), dimensions={} + %maximum.1196 = f32[250,19,19,576]{3,2,1,0} maximum(f32[250,19,19,576]{3,2,1,0} %Arg_0.1191, f32[250,19,19,576]{3,2,1,0} %broadcast.1195) + %constant.1192 = f32[] constant(6) + %broadcast.1193 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[] %constant.1192), dimensions={} + ROOT %minimum.1197 = f32[250,19,19,576]{3,2,1,0} minimum(f32[250,19,19,576]{3,2,1,0} %maximum.1196, f32[250,19,19,576]{3,2,1,0} %broadcast.1193) +} + +%jit_relu6_24.1215 (Arg_0.1216: f32[250,19,19,576]) -> f32[250,19,19,576] { + %Arg_0.1216 = f32[250,19,19,576]{3,2,1,0} parameter(0) + %constant.1219 = f32[] constant(0) + %broadcast.1220 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[] %constant.1219), dimensions={} + %maximum.1221 = f32[250,19,19,576]{3,2,1,0} maximum(f32[250,19,19,576]{3,2,1,0} %Arg_0.1216, f32[250,19,19,576]{3,2,1,0} %broadcast.1220) + %constant.1217 = f32[] constant(6) + %broadcast.1218 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[] %constant.1217), dimensions={} + ROOT %minimum.1222 = f32[250,19,19,576]{3,2,1,0} minimum(f32[250,19,19,576]{3,2,1,0} %maximum.1221, f32[250,19,19,576]{3,2,1,0} %broadcast.1218) +} + +%jit_relu6_25.1256 (Arg_0.1257: f32[250,19,19,816]) -> f32[250,19,19,816] { + %Arg_0.1257 = f32[250,19,19,816]{3,2,1,0} parameter(0) + %constant.1260 = f32[] constant(0) + %broadcast.1261 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[] %constant.1260), dimensions={} + %maximum.1262 = f32[250,19,19,816]{3,2,1,0} maximum(f32[250,19,19,816]{3,2,1,0} %Arg_0.1257, f32[250,19,19,816]{3,2,1,0} %broadcast.1261) + %constant.1258 = f32[] constant(6) + %broadcast.1259 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[] %constant.1258), dimensions={} + ROOT %minimum.1263 = f32[250,19,19,816]{3,2,1,0} minimum(f32[250,19,19,816]{3,2,1,0} %maximum.1262, f32[250,19,19,816]{3,2,1,0} %broadcast.1259) +} + +%jit_relu6_26.1281 (Arg_0.1282: f32[250,19,19,816]) -> f32[250,19,19,816] { + %Arg_0.1282 = f32[250,19,19,816]{3,2,1,0} parameter(0) + %constant.1285 = f32[] constant(0) + %broadcast.1286 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[] %constant.1285), dimensions={} + %maximum.1287 = f32[250,19,19,816]{3,2,1,0} maximum(f32[250,19,19,816]{3,2,1,0} %Arg_0.1282, f32[250,19,19,816]{3,2,1,0} %broadcast.1286) + %constant.1283 = f32[] constant(6) + %broadcast.1284 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[] %constant.1283), dimensions={} + ROOT %minimum.1288 = f32[250,19,19,816]{3,2,1,0} minimum(f32[250,19,19,816]{3,2,1,0} %maximum.1287, f32[250,19,19,816]{3,2,1,0} %broadcast.1284) +} + +%jit_relu6_27.1323 (Arg_0.1324: f32[250,19,19,816]) -> f32[250,19,19,816] { + %Arg_0.1324 = f32[250,19,19,816]{3,2,1,0} parameter(0) + %constant.1327 = f32[] constant(0) + %broadcast.1328 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[] %constant.1327), dimensions={} + %maximum.1329 = f32[250,19,19,816]{3,2,1,0} maximum(f32[250,19,19,816]{3,2,1,0} %Arg_0.1324, f32[250,19,19,816]{3,2,1,0} %broadcast.1328) + %constant.1325 = f32[] constant(6) + %broadcast.1326 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[] %constant.1325), dimensions={} + ROOT %minimum.1330 = f32[250,19,19,816]{3,2,1,0} minimum(f32[250,19,19,816]{3,2,1,0} %maximum.1329, f32[250,19,19,816]{3,2,1,0} %broadcast.1326) +} + +%jit_relu6_28.1348 (Arg_0.1349: f32[250,19,19,816]) -> f32[250,19,19,816] { + %Arg_0.1349 = f32[250,19,19,816]{3,2,1,0} parameter(0) + %constant.1352 = f32[] constant(0) + %broadcast.1353 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[] %constant.1352), dimensions={} + %maximum.1354 = f32[250,19,19,816]{3,2,1,0} maximum(f32[250,19,19,816]{3,2,1,0} %Arg_0.1349, f32[250,19,19,816]{3,2,1,0} %broadcast.1353) + %constant.1350 = f32[] constant(6) + %broadcast.1351 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[] %constant.1350), dimensions={} + ROOT %minimum.1355 = f32[250,19,19,816]{3,2,1,0} minimum(f32[250,19,19,816]{3,2,1,0} %maximum.1354, f32[250,19,19,816]{3,2,1,0} %broadcast.1351) +} + +%jit_relu6_29.1390 (Arg_0.1391: f32[250,19,19,816]) -> f32[250,19,19,816] { + %Arg_0.1391 = f32[250,19,19,816]{3,2,1,0} parameter(0) + %constant.1394 = f32[] constant(0) + %broadcast.1395 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[] %constant.1394), dimensions={} + %maximum.1396 = f32[250,19,19,816]{3,2,1,0} maximum(f32[250,19,19,816]{3,2,1,0} %Arg_0.1391, f32[250,19,19,816]{3,2,1,0} %broadcast.1395) + %constant.1392 = f32[] constant(6) + %broadcast.1393 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[] %constant.1392), dimensions={} + ROOT %minimum.1397 = f32[250,19,19,816]{3,2,1,0} minimum(f32[250,19,19,816]{3,2,1,0} %maximum.1396, f32[250,19,19,816]{3,2,1,0} %broadcast.1393) +} + +%jit_relu6_30.1415 (Arg_0.1416: f32[250,19,19,816]) -> f32[250,19,19,816] { + %Arg_0.1416 = f32[250,19,19,816]{3,2,1,0} parameter(0) + %constant.1419 = f32[] constant(0) + %broadcast.1420 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[] %constant.1419), dimensions={} + %maximum.1421 = f32[250,19,19,816]{3,2,1,0} maximum(f32[250,19,19,816]{3,2,1,0} %Arg_0.1416, f32[250,19,19,816]{3,2,1,0} %broadcast.1420) + %constant.1417 = f32[] constant(6) + %broadcast.1418 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[] %constant.1417), dimensions={} + ROOT %minimum.1422 = f32[250,19,19,816]{3,2,1,0} minimum(f32[250,19,19,816]{3,2,1,0} %maximum.1421, f32[250,19,19,816]{3,2,1,0} %broadcast.1418) +} + +%jit_relu6_31.1457 (Arg_0.1458: f32[250,19,19,816]) -> f32[250,19,19,816] { + %Arg_0.1458 = f32[250,19,19,816]{3,2,1,0} parameter(0) + %constant.1461 = f32[] constant(0) + %broadcast.1462 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[] %constant.1461), dimensions={} + %maximum.1463 = f32[250,19,19,816]{3,2,1,0} maximum(f32[250,19,19,816]{3,2,1,0} %Arg_0.1458, f32[250,19,19,816]{3,2,1,0} %broadcast.1462) + %constant.1459 = f32[] constant(6) + %broadcast.1460 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[] %constant.1459), dimensions={} + ROOT %minimum.1464 = f32[250,19,19,816]{3,2,1,0} minimum(f32[250,19,19,816]{3,2,1,0} %maximum.1463, f32[250,19,19,816]{3,2,1,0} %broadcast.1460) +} + +%jit_relu6_32.1482 (Arg_0.1483: f32[250,19,19,816]) -> f32[250,19,19,816] { + %Arg_0.1483 = f32[250,19,19,816]{3,2,1,0} parameter(0) + %constant.1486 = f32[] constant(0) + %broadcast.1487 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[] %constant.1486), dimensions={} + %maximum.1488 = f32[250,19,19,816]{3,2,1,0} maximum(f32[250,19,19,816]{3,2,1,0} %Arg_0.1483, f32[250,19,19,816]{3,2,1,0} %broadcast.1487) + %constant.1484 = f32[] constant(6) + %broadcast.1485 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[] %constant.1484), dimensions={} + ROOT %minimum.1489 = f32[250,19,19,816]{3,2,1,0} minimum(f32[250,19,19,816]{3,2,1,0} %maximum.1488, f32[250,19,19,816]{3,2,1,0} %broadcast.1485) +} + +%jit_relu6_33.1524 (Arg_0.1525: f32[250,19,19,816]) -> f32[250,19,19,816] { + %Arg_0.1525 = f32[250,19,19,816]{3,2,1,0} parameter(0) + %constant.1528 = f32[] constant(0) + %broadcast.1529 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[] %constant.1528), dimensions={} + %maximum.1530 = f32[250,19,19,816]{3,2,1,0} maximum(f32[250,19,19,816]{3,2,1,0} %Arg_0.1525, f32[250,19,19,816]{3,2,1,0} %broadcast.1529) + %constant.1526 = f32[] constant(6) + %broadcast.1527 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[] %constant.1526), dimensions={} + ROOT %minimum.1531 = f32[250,19,19,816]{3,2,1,0} minimum(f32[250,19,19,816]{3,2,1,0} %maximum.1530, f32[250,19,19,816]{3,2,1,0} %broadcast.1527) +} + +%jit_relu6_34.1549 (Arg_0.1550: f32[250,10,10,816]) -> f32[250,10,10,816] { + %Arg_0.1550 = f32[250,10,10,816]{3,2,1,0} parameter(0) + %constant.1553 = f32[] constant(0) + %broadcast.1554 = f32[250,10,10,816]{3,2,1,0} broadcast(f32[] %constant.1553), dimensions={} + %maximum.1555 = f32[250,10,10,816]{3,2,1,0} maximum(f32[250,10,10,816]{3,2,1,0} %Arg_0.1550, f32[250,10,10,816]{3,2,1,0} %broadcast.1554) + %constant.1551 = f32[] constant(6) + %broadcast.1552 = f32[250,10,10,816]{3,2,1,0} broadcast(f32[] %constant.1551), dimensions={} + ROOT %minimum.1556 = f32[250,10,10,816]{3,2,1,0} minimum(f32[250,10,10,816]{3,2,1,0} %maximum.1555, f32[250,10,10,816]{3,2,1,0} %broadcast.1552) +} + +%jit_relu6_35.1590 (Arg_0.1591: f32[250,10,10,1392]) -> f32[250,10,10,1392] { + %Arg_0.1591 = f32[250,10,10,1392]{3,2,1,0} parameter(0) + %constant.1594 = f32[] constant(0) + %broadcast.1595 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[] %constant.1594), dimensions={} + %maximum.1596 = f32[250,10,10,1392]{3,2,1,0} maximum(f32[250,10,10,1392]{3,2,1,0} %Arg_0.1591, f32[250,10,10,1392]{3,2,1,0} %broadcast.1595) + %constant.1592 = f32[] constant(6) + %broadcast.1593 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[] %constant.1592), dimensions={} + ROOT %minimum.1597 = f32[250,10,10,1392]{3,2,1,0} minimum(f32[250,10,10,1392]{3,2,1,0} %maximum.1596, f32[250,10,10,1392]{3,2,1,0} %broadcast.1593) +} + +%jit_relu6_36.1615 (Arg_0.1616: f32[250,10,10,1392]) -> f32[250,10,10,1392] { + %Arg_0.1616 = f32[250,10,10,1392]{3,2,1,0} parameter(0) + %constant.1619 = f32[] constant(0) + %broadcast.1620 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[] %constant.1619), dimensions={} + %maximum.1621 = f32[250,10,10,1392]{3,2,1,0} maximum(f32[250,10,10,1392]{3,2,1,0} %Arg_0.1616, f32[250,10,10,1392]{3,2,1,0} %broadcast.1620) + %constant.1617 = f32[] constant(6) + %broadcast.1618 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[] %constant.1617), dimensions={} + ROOT %minimum.1622 = f32[250,10,10,1392]{3,2,1,0} minimum(f32[250,10,10,1392]{3,2,1,0} %maximum.1621, f32[250,10,10,1392]{3,2,1,0} %broadcast.1618) +} + +%jit_relu6_37.1657 (Arg_0.1658: f32[250,10,10,1392]) -> f32[250,10,10,1392] { + %Arg_0.1658 = f32[250,10,10,1392]{3,2,1,0} parameter(0) + %constant.1661 = f32[] constant(0) + %broadcast.1662 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[] %constant.1661), dimensions={} + %maximum.1663 = f32[250,10,10,1392]{3,2,1,0} maximum(f32[250,10,10,1392]{3,2,1,0} %Arg_0.1658, f32[250,10,10,1392]{3,2,1,0} %broadcast.1662) + %constant.1659 = f32[] constant(6) + %broadcast.1660 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[] %constant.1659), dimensions={} + ROOT %minimum.1664 = f32[250,10,10,1392]{3,2,1,0} minimum(f32[250,10,10,1392]{3,2,1,0} %maximum.1663, f32[250,10,10,1392]{3,2,1,0} %broadcast.1660) +} + +%jit_relu6_38.1682 (Arg_0.1683: f32[250,10,10,1392]) -> f32[250,10,10,1392] { + %Arg_0.1683 = f32[250,10,10,1392]{3,2,1,0} parameter(0) + %constant.1686 = f32[] constant(0) + %broadcast.1687 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[] %constant.1686), dimensions={} + %maximum.1688 = f32[250,10,10,1392]{3,2,1,0} maximum(f32[250,10,10,1392]{3,2,1,0} %Arg_0.1683, f32[250,10,10,1392]{3,2,1,0} %broadcast.1687) + %constant.1684 = f32[] constant(6) + %broadcast.1685 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[] %constant.1684), dimensions={} + ROOT %minimum.1689 = f32[250,10,10,1392]{3,2,1,0} minimum(f32[250,10,10,1392]{3,2,1,0} %maximum.1688, f32[250,10,10,1392]{3,2,1,0} %broadcast.1685) +} + +%jit_relu6_39.1724 (Arg_0.1725: f32[250,10,10,1392]) -> f32[250,10,10,1392] { + %Arg_0.1725 = f32[250,10,10,1392]{3,2,1,0} parameter(0) + %constant.1728 = f32[] constant(0) + %broadcast.1729 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[] %constant.1728), dimensions={} + %maximum.1730 = f32[250,10,10,1392]{3,2,1,0} maximum(f32[250,10,10,1392]{3,2,1,0} %Arg_0.1725, f32[250,10,10,1392]{3,2,1,0} %broadcast.1729) + %constant.1726 = f32[] constant(6) + %broadcast.1727 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[] %constant.1726), dimensions={} + ROOT %minimum.1731 = f32[250,10,10,1392]{3,2,1,0} minimum(f32[250,10,10,1392]{3,2,1,0} %maximum.1730, f32[250,10,10,1392]{3,2,1,0} %broadcast.1727) +} + +%jit_relu6_40.1749 (Arg_0.1750: f32[250,10,10,1392]) -> f32[250,10,10,1392] { + %Arg_0.1750 = f32[250,10,10,1392]{3,2,1,0} parameter(0) + %constant.1753 = f32[] constant(0) + %broadcast.1754 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[] %constant.1753), dimensions={} + %maximum.1755 = f32[250,10,10,1392]{3,2,1,0} maximum(f32[250,10,10,1392]{3,2,1,0} %Arg_0.1750, f32[250,10,10,1392]{3,2,1,0} %broadcast.1754) + %constant.1751 = f32[] constant(6) + %broadcast.1752 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[] %constant.1751), dimensions={} + ROOT %minimum.1756 = f32[250,10,10,1392]{3,2,1,0} minimum(f32[250,10,10,1392]{3,2,1,0} %maximum.1755, f32[250,10,10,1392]{3,2,1,0} %broadcast.1752) +} + +%jit_relu6_41.1791 (Arg_0.1792: f32[250,10,10,1392]) -> f32[250,10,10,1392] { + %Arg_0.1792 = f32[250,10,10,1392]{3,2,1,0} parameter(0) + %constant.1795 = f32[] constant(0) + %broadcast.1796 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[] %constant.1795), dimensions={} + %maximum.1797 = f32[250,10,10,1392]{3,2,1,0} maximum(f32[250,10,10,1392]{3,2,1,0} %Arg_0.1792, f32[250,10,10,1392]{3,2,1,0} %broadcast.1796) + %constant.1793 = f32[] constant(6) + %broadcast.1794 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[] %constant.1793), dimensions={} + ROOT %minimum.1798 = f32[250,10,10,1392]{3,2,1,0} minimum(f32[250,10,10,1392]{3,2,1,0} %maximum.1797, f32[250,10,10,1392]{3,2,1,0} %broadcast.1794) +} + +%jit_relu6_42.1816 (Arg_0.1817: f32[250,10,10,1392]) -> f32[250,10,10,1392] { + %Arg_0.1817 = f32[250,10,10,1392]{3,2,1,0} parameter(0) + %constant.1820 = f32[] constant(0) + %broadcast.1821 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[] %constant.1820), dimensions={} + %maximum.1822 = f32[250,10,10,1392]{3,2,1,0} maximum(f32[250,10,10,1392]{3,2,1,0} %Arg_0.1817, f32[250,10,10,1392]{3,2,1,0} %broadcast.1821) + %constant.1818 = f32[] constant(6) + %broadcast.1819 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[] %constant.1818), dimensions={} + ROOT %minimum.1823 = f32[250,10,10,1392]{3,2,1,0} minimum(f32[250,10,10,1392]{3,2,1,0} %maximum.1822, f32[250,10,10,1392]{3,2,1,0} %broadcast.1819) +} + +%jit_relu6_43.1858 (Arg_0.1859: f32[250,10,10,1392]) -> f32[250,10,10,1392] { + %Arg_0.1859 = f32[250,10,10,1392]{3,2,1,0} parameter(0) + %constant.1862 = f32[] constant(0) + %broadcast.1863 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[] %constant.1862), dimensions={} + %maximum.1864 = f32[250,10,10,1392]{3,2,1,0} maximum(f32[250,10,10,1392]{3,2,1,0} %Arg_0.1859, f32[250,10,10,1392]{3,2,1,0} %broadcast.1863) + %constant.1860 = f32[] constant(6) + %broadcast.1861 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[] %constant.1860), dimensions={} + ROOT %minimum.1865 = f32[250,10,10,1392]{3,2,1,0} minimum(f32[250,10,10,1392]{3,2,1,0} %maximum.1864, f32[250,10,10,1392]{3,2,1,0} %broadcast.1861) +} + +%jit_relu6_44.1883 (Arg_0.1884: f32[250,10,10,1392]) -> f32[250,10,10,1392] { + %Arg_0.1884 = f32[250,10,10,1392]{3,2,1,0} parameter(0) + %constant.1887 = f32[] constant(0) + %broadcast.1888 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[] %constant.1887), dimensions={} + %maximum.1889 = f32[250,10,10,1392]{3,2,1,0} maximum(f32[250,10,10,1392]{3,2,1,0} %Arg_0.1884, f32[250,10,10,1392]{3,2,1,0} %broadcast.1888) + %constant.1885 = f32[] constant(6) + %broadcast.1886 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[] %constant.1885), dimensions={} + ROOT %minimum.1890 = f32[250,10,10,1392]{3,2,1,0} minimum(f32[250,10,10,1392]{3,2,1,0} %maximum.1889, f32[250,10,10,1392]{3,2,1,0} %broadcast.1886) +} + +%jit_relu6_45.1925 (Arg_0.1926: f32[250,10,10,1392]) -> f32[250,10,10,1392] { + %Arg_0.1926 = f32[250,10,10,1392]{3,2,1,0} parameter(0) + %constant.1929 = f32[] constant(0) + %broadcast.1930 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[] %constant.1929), dimensions={} + %maximum.1931 = f32[250,10,10,1392]{3,2,1,0} maximum(f32[250,10,10,1392]{3,2,1,0} %Arg_0.1926, f32[250,10,10,1392]{3,2,1,0} %broadcast.1930) + %constant.1927 = f32[] constant(6) + %broadcast.1928 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[] %constant.1927), dimensions={} + ROOT %minimum.1932 = f32[250,10,10,1392]{3,2,1,0} minimum(f32[250,10,10,1392]{3,2,1,0} %maximum.1931, f32[250,10,10,1392]{3,2,1,0} %broadcast.1928) +} + +%jit_relu6_46.1950 (Arg_0.1951: f32[250,10,10,1392]) -> f32[250,10,10,1392] { + %Arg_0.1951 = f32[250,10,10,1392]{3,2,1,0} parameter(0) + %constant.1954 = f32[] constant(0) + %broadcast.1955 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[] %constant.1954), dimensions={} + %maximum.1956 = f32[250,10,10,1392]{3,2,1,0} maximum(f32[250,10,10,1392]{3,2,1,0} %Arg_0.1951, f32[250,10,10,1392]{3,2,1,0} %broadcast.1955) + %constant.1952 = f32[] constant(6) + %broadcast.1953 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[] %constant.1952), dimensions={} + ROOT %minimum.1957 = f32[250,10,10,1392]{3,2,1,0} minimum(f32[250,10,10,1392]{3,2,1,0} %maximum.1956, f32[250,10,10,1392]{3,2,1,0} %broadcast.1953) +} + +%jit_relu6_47.1991 (Arg_0.1992: f32[250,10,10,1280]) -> f32[250,10,10,1280] { + %Arg_0.1992 = f32[250,10,10,1280]{3,2,1,0} parameter(0) + %constant.1995 = f32[] constant(0) + %broadcast.1996 = f32[250,10,10,1280]{3,2,1,0} broadcast(f32[] %constant.1995), dimensions={} + %maximum.1997 = f32[250,10,10,1280]{3,2,1,0} maximum(f32[250,10,10,1280]{3,2,1,0} %Arg_0.1992, f32[250,10,10,1280]{3,2,1,0} %broadcast.1996) + %constant.1993 = f32[] constant(6) + %broadcast.1994 = f32[250,10,10,1280]{3,2,1,0} broadcast(f32[] %constant.1993), dimensions={} + ROOT %minimum.1998 = f32[250,10,10,1280]{3,2,1,0} minimum(f32[250,10,10,1280]{3,2,1,0} %maximum.1997, f32[250,10,10,1280]{3,2,1,0} %broadcast.1994) +} + +%region_0.2000 (Arg_0.2001: f32[], Arg_1.2002: f32[]) -> f32[] { + %Arg_0.2001 = f32[] parameter(0) + %Arg_1.2002 = f32[] parameter(1) + ROOT %add.2003 = f32[] add(f32[] %Arg_0.2001, f32[] %Arg_1.2002) +} + +%region_1.2011 (Arg_0.2012: f32[], Arg_1.2013: f32[], Arg_2.2014: s32[], Arg_3.2015: s32[]) -> pred[] { + %Arg_2.2014 = s32[] parameter(2) + %Arg_3.2015 = s32[] parameter(3) + %Arg_0.2012 = f32[] parameter(0) + %Arg_1.2013 = f32[] parameter(1) + ROOT %compare.2016 = pred[] compare(f32[] %Arg_0.2012, f32[] %Arg_1.2013), direction=GT, type=TOTALORDER +} + +%xla_fallback_top_k.2017 (Arg_0.2018: f32[250,1000]) -> (f32[250,5], s32[250,5]) { + %Arg_0.2018 = f32[250,1000]{1,0} parameter(0) + %iota.2019 = s32[1000]{0} iota(), iota_dimension=0 + %broadcast.2020 = s32[250,1000]{1,0} broadcast(s32[1000]{0} %iota.2019), dimensions={1} + %sort.2021 = (f32[250,1000]{1,0}, s32[250,1000]{1,0}) sort(f32[250,1000]{1,0} %Arg_0.2018, s32[250,1000]{1,0} %broadcast.2020), dimensions={1}, is_stable=true, to_apply=%region_1.2011 + %get-tuple-element.2022 = f32[250,1000]{1,0} get-tuple-element((f32[250,1000]{1,0}, s32[250,1000]{1,0}) %sort.2021), index=0 + %slice.2024 = f32[250,5]{1,0} slice(f32[250,1000]{1,0} %get-tuple-element.2022), slice={[0:250], [0:5]} + %get-tuple-element.2023 = s32[250,1000]{1,0} get-tuple-element((f32[250,1000]{1,0}, s32[250,1000]{1,0}) %sort.2021), index=1 + %slice.2025 = s32[250,5]{1,0} slice(s32[250,1000]{1,0} %get-tuple-element.2023), slice={[0:250], [0:5]} + ROOT %tuple.2026 = (f32[250,5]{1,0}, s32[250,5]{1,0}) tuple(f32[250,5]{1,0} %slice.2024, s32[250,5]{1,0} %slice.2025) +} + +%top_k.2027 (Arg_0.2028: f32[250,1000]) -> (f32[250,5], s32[250,5]) { + %Arg_0.2028 = f32[250,1000]{1,0} parameter(0) + %call.2029 = (f32[250,5]{1,0}, s32[250,5]{1,0}) call(f32[250,1000]{1,0} %Arg_0.2028), to_apply=%xla_fallback_top_k.2017 + %get-tuple-element.2030 = f32[250,5]{1,0} get-tuple-element((f32[250,5]{1,0}, s32[250,5]{1,0}) %call.2029), index=0 + %get-tuple-element.2031 = s32[250,5]{1,0} get-tuple-element((f32[250,5]{1,0}, s32[250,5]{1,0}) %call.2029), index=1 + ROOT %tuple.2032 = (f32[250,5]{1,0}, s32[250,5]{1,0}) tuple(f32[250,5]{1,0} %get-tuple-element.2030, s32[250,5]{1,0} %get-tuple-element.2031) +} + +%region_2.2045 (Arg_0.2046: s32[], Arg_1.2047: s32[]) -> s32[] { + %Arg_0.2046 = s32[] parameter(0) + %Arg_1.2047 = s32[] parameter(1) + ROOT %add.2048 = s32[] add(s32[] %Arg_0.2046, s32[] %Arg_1.2047) +} + +%region_3.2052 (Arg_0.2053: s32[], Arg_1.2054: s32[]) -> s32[] { + %Arg_0.2053 = s32[] parameter(0) + %Arg_1.2054 = s32[] parameter(1) + ROOT %add.2055 = s32[] add(s32[] %Arg_0.2053, s32[] %Arg_1.2054) +} + +ENTRY %main.2058 (Arg_0.1: f32[250,300,300,3], Arg_1.2: s32[250]) -> (s32[], s32[]) { + %Arg_0.1 = f32[250,300,300,3]{3,2,1,0} parameter(0) + %constant.373 = f32[3,3,3,32]{3,2,1,0} constant({...}) + %convolution.374 = f32[250,150,150,32]{3,2,1,0} convolution(f32[250,300,300,3]{3,2,1,0} %Arg_0.1, f32[3,3,3,32]{3,2,1,0} %constant.373), window={size=3x3 stride=2x2 pad=0_1x0_1}, dim_labels=b01f_01io->b01f + %constant.299 = f32[1,1,1,32]{3,2,1,0} constant({...}) + %broadcast.375 = f32[1,1,1,32]{3,2,1,0} broadcast(f32[1,1,1,32]{3,2,1,0} %constant.299), dimensions={0,1,2,3} + %reshape.376 = f32[32]{0} reshape(f32[1,1,1,32]{3,2,1,0} %broadcast.375) + %broadcast.377 = f32[250,150,150,32]{3,2,1,0} broadcast(f32[32]{0} %reshape.376), dimensions={3} + %subtract.378 = f32[250,150,150,32]{3,2,1,0} subtract(f32[250,150,150,32]{3,2,1,0} %convolution.374, f32[250,150,150,32]{3,2,1,0} %broadcast.377) + %constant.298 = f32[32]{0} constant({...}) + %rsqrt.379 = f32[32]{0} rsqrt(f32[32]{0} %constant.298) + %reshape.380 = f32[1,1,1,32]{3,2,1,0} reshape(f32[32]{0} %rsqrt.379) + %constant.297 = f32[1,1,1,32]{3,2,1,0} constant({...}) + %multiply.381 = f32[1,1,1,32]{3,2,1,0} multiply(f32[1,1,1,32]{3,2,1,0} %reshape.380, f32[1,1,1,32]{3,2,1,0} %constant.297) + %broadcast.382 = f32[1,1,1,32]{3,2,1,0} broadcast(f32[1,1,1,32]{3,2,1,0} %multiply.381), dimensions={0,1,2,3} + %reshape.383 = f32[32]{0} reshape(f32[1,1,1,32]{3,2,1,0} %broadcast.382) + %broadcast.384 = f32[250,150,150,32]{3,2,1,0} broadcast(f32[32]{0} %reshape.383), dimensions={3} + %multiply.385 = f32[250,150,150,32]{3,2,1,0} multiply(f32[250,150,150,32]{3,2,1,0} %subtract.378, f32[250,150,150,32]{3,2,1,0} %broadcast.384) + %constant.296 = f32[1,1,1,32]{3,2,1,0} constant({...}) + %broadcast.386 = f32[1,1,1,32]{3,2,1,0} broadcast(f32[1,1,1,32]{3,2,1,0} %constant.296), dimensions={0,1,2,3} + %reshape.387 = f32[32]{0} reshape(f32[1,1,1,32]{3,2,1,0} %broadcast.386) + %broadcast.388 = f32[250,150,150,32]{3,2,1,0} broadcast(f32[32]{0} %reshape.387), dimensions={3} + %add.389 = f32[250,150,150,32]{3,2,1,0} add(f32[250,150,150,32]{3,2,1,0} %multiply.385, f32[250,150,150,32]{3,2,1,0} %broadcast.388) + %call.398 = f32[250,150,150,32]{3,2,1,0} call(f32[250,150,150,32]{3,2,1,0} %add.389), to_apply=%jit_relu6.390 + %constant.372 = f32[3,3,1,32]{3,2,1,0} constant({...}) + %convolution.399 = f32[250,150,150,32]{3,2,1,0} convolution(f32[250,150,150,32]{3,2,1,0} %call.398, f32[3,3,1,32]{3,2,1,0} %constant.372), window={size=3x3 pad=1_1x1_1}, dim_labels=b01f_01io->b01f, feature_group_count=32 + %constant.295 = f32[1,1,1,32]{3,2,1,0} constant({...}) + %broadcast.400 = f32[1,1,1,32]{3,2,1,0} broadcast(f32[1,1,1,32]{3,2,1,0} %constant.295), dimensions={0,1,2,3} + %reshape.401 = f32[32]{0} reshape(f32[1,1,1,32]{3,2,1,0} %broadcast.400) + %broadcast.402 = f32[250,150,150,32]{3,2,1,0} broadcast(f32[32]{0} %reshape.401), dimensions={3} + %subtract.403 = f32[250,150,150,32]{3,2,1,0} subtract(f32[250,150,150,32]{3,2,1,0} %convolution.399, f32[250,150,150,32]{3,2,1,0} %broadcast.402) + %constant.294 = f32[32]{0} constant({...}) + %rsqrt.404 = f32[32]{0} rsqrt(f32[32]{0} %constant.294) + %reshape.405 = f32[1,1,1,32]{3,2,1,0} reshape(f32[32]{0} %rsqrt.404) + %constant.293 = f32[1,1,1,32]{3,2,1,0} constant({...}) + %multiply.406 = f32[1,1,1,32]{3,2,1,0} multiply(f32[1,1,1,32]{3,2,1,0} %reshape.405, f32[1,1,1,32]{3,2,1,0} %constant.293) + %broadcast.407 = f32[1,1,1,32]{3,2,1,0} broadcast(f32[1,1,1,32]{3,2,1,0} %multiply.406), dimensions={0,1,2,3} + %reshape.408 = f32[32]{0} reshape(f32[1,1,1,32]{3,2,1,0} %broadcast.407) + %broadcast.409 = f32[250,150,150,32]{3,2,1,0} broadcast(f32[32]{0} %reshape.408), dimensions={3} + %multiply.410 = f32[250,150,150,32]{3,2,1,0} multiply(f32[250,150,150,32]{3,2,1,0} %subtract.403, f32[250,150,150,32]{3,2,1,0} %broadcast.409) + %constant.292 = f32[1,1,1,32]{3,2,1,0} constant({...}) + %broadcast.411 = f32[1,1,1,32]{3,2,1,0} broadcast(f32[1,1,1,32]{3,2,1,0} %constant.292), dimensions={0,1,2,3} + %reshape.412 = f32[32]{0} reshape(f32[1,1,1,32]{3,2,1,0} %broadcast.411) + %broadcast.413 = f32[250,150,150,32]{3,2,1,0} broadcast(f32[32]{0} %reshape.412), dimensions={3} + %add.414 = f32[250,150,150,32]{3,2,1,0} add(f32[250,150,150,32]{3,2,1,0} %multiply.410, f32[250,150,150,32]{3,2,1,0} %broadcast.413) + %call.423 = f32[250,150,150,32]{3,2,1,0} call(f32[250,150,150,32]{3,2,1,0} %add.414), to_apply=%jit_relu6_0.415 + %constant.371 = f32[1,1,32,24]{3,2,1,0} constant({...}) + %convolution.424 = f32[250,150,150,24]{3,2,1,0} convolution(f32[250,150,150,32]{3,2,1,0} %call.423, f32[1,1,32,24]{3,2,1,0} %constant.371), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.291 = f32[1,1,1,24]{3,2,1,0} constant({...}) + %broadcast.425 = f32[1,1,1,24]{3,2,1,0} broadcast(f32[1,1,1,24]{3,2,1,0} %constant.291), dimensions={0,1,2,3} + %reshape.426 = f32[24]{0} reshape(f32[1,1,1,24]{3,2,1,0} %broadcast.425) + %broadcast.427 = f32[250,150,150,24]{3,2,1,0} broadcast(f32[24]{0} %reshape.426), dimensions={3} + %subtract.428 = f32[250,150,150,24]{3,2,1,0} subtract(f32[250,150,150,24]{3,2,1,0} %convolution.424, f32[250,150,150,24]{3,2,1,0} %broadcast.427) + %constant.290 = f32[24]{0} constant({...}) + %rsqrt.429 = f32[24]{0} rsqrt(f32[24]{0} %constant.290) + %reshape.430 = f32[1,1,1,24]{3,2,1,0} reshape(f32[24]{0} %rsqrt.429) + %constant.289 = f32[1,1,1,24]{3,2,1,0} constant({...}) + %multiply.431 = f32[1,1,1,24]{3,2,1,0} multiply(f32[1,1,1,24]{3,2,1,0} %reshape.430, f32[1,1,1,24]{3,2,1,0} %constant.289) + %broadcast.432 = f32[1,1,1,24]{3,2,1,0} broadcast(f32[1,1,1,24]{3,2,1,0} %multiply.431), dimensions={0,1,2,3} + %reshape.433 = f32[24]{0} reshape(f32[1,1,1,24]{3,2,1,0} %broadcast.432) + %broadcast.434 = f32[250,150,150,24]{3,2,1,0} broadcast(f32[24]{0} %reshape.433), dimensions={3} + %multiply.435 = f32[250,150,150,24]{3,2,1,0} multiply(f32[250,150,150,24]{3,2,1,0} %subtract.428, f32[250,150,150,24]{3,2,1,0} %broadcast.434) + %constant.288 = f32[1,1,1,24]{3,2,1,0} constant({...}) + %broadcast.436 = f32[1,1,1,24]{3,2,1,0} broadcast(f32[1,1,1,24]{3,2,1,0} %constant.288), dimensions={0,1,2,3} + %reshape.437 = f32[24]{0} reshape(f32[1,1,1,24]{3,2,1,0} %broadcast.436) + %broadcast.438 = f32[250,150,150,24]{3,2,1,0} broadcast(f32[24]{0} %reshape.437), dimensions={3} + %add.439 = f32[250,150,150,24]{3,2,1,0} add(f32[250,150,150,24]{3,2,1,0} %multiply.435, f32[250,150,150,24]{3,2,1,0} %broadcast.438) + %constant.370 = f32[1,1,24,144]{3,2,1,0} constant({...}) + %convolution.440 = f32[250,150,150,144]{3,2,1,0} convolution(f32[250,150,150,24]{3,2,1,0} %add.439, f32[1,1,24,144]{3,2,1,0} %constant.370), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.287 = f32[1,1,1,144]{3,2,1,0} constant({...}) + %broadcast.441 = f32[1,1,1,144]{3,2,1,0} broadcast(f32[1,1,1,144]{3,2,1,0} %constant.287), dimensions={0,1,2,3} + %reshape.442 = f32[144]{0} reshape(f32[1,1,1,144]{3,2,1,0} %broadcast.441) + %broadcast.443 = f32[250,150,150,144]{3,2,1,0} broadcast(f32[144]{0} %reshape.442), dimensions={3} + %subtract.444 = f32[250,150,150,144]{3,2,1,0} subtract(f32[250,150,150,144]{3,2,1,0} %convolution.440, f32[250,150,150,144]{3,2,1,0} %broadcast.443) + %constant.286 = f32[144]{0} constant({...}) + %rsqrt.445 = f32[144]{0} rsqrt(f32[144]{0} %constant.286) + %reshape.446 = f32[1,1,1,144]{3,2,1,0} reshape(f32[144]{0} %rsqrt.445) + %constant.285 = f32[1,1,1,144]{3,2,1,0} constant({...}) + %multiply.447 = f32[1,1,1,144]{3,2,1,0} multiply(f32[1,1,1,144]{3,2,1,0} %reshape.446, f32[1,1,1,144]{3,2,1,0} %constant.285) + %broadcast.448 = f32[1,1,1,144]{3,2,1,0} broadcast(f32[1,1,1,144]{3,2,1,0} %multiply.447), dimensions={0,1,2,3} + %reshape.449 = f32[144]{0} reshape(f32[1,1,1,144]{3,2,1,0} %broadcast.448) + %broadcast.450 = f32[250,150,150,144]{3,2,1,0} broadcast(f32[144]{0} %reshape.449), dimensions={3} + %multiply.451 = f32[250,150,150,144]{3,2,1,0} multiply(f32[250,150,150,144]{3,2,1,0} %subtract.444, f32[250,150,150,144]{3,2,1,0} %broadcast.450) + %constant.284 = f32[1,1,1,144]{3,2,1,0} constant({...}) + %broadcast.452 = f32[1,1,1,144]{3,2,1,0} broadcast(f32[1,1,1,144]{3,2,1,0} %constant.284), dimensions={0,1,2,3} + %reshape.453 = f32[144]{0} reshape(f32[1,1,1,144]{3,2,1,0} %broadcast.452) + %broadcast.454 = f32[250,150,150,144]{3,2,1,0} broadcast(f32[144]{0} %reshape.453), dimensions={3} + %add.455 = f32[250,150,150,144]{3,2,1,0} add(f32[250,150,150,144]{3,2,1,0} %multiply.451, f32[250,150,150,144]{3,2,1,0} %broadcast.454) + %call.464 = f32[250,150,150,144]{3,2,1,0} call(f32[250,150,150,144]{3,2,1,0} %add.455), to_apply=%jit_relu6_1.456 + %constant.369 = f32[3,3,1,144]{3,2,1,0} constant({...}) + %convolution.465 = f32[250,75,75,144]{3,2,1,0} convolution(f32[250,150,150,144]{3,2,1,0} %call.464, f32[3,3,1,144]{3,2,1,0} %constant.369), window={size=3x3 stride=2x2 pad=0_1x0_1}, dim_labels=b01f_01io->b01f, feature_group_count=144 + %constant.283 = f32[1,1,1,144]{3,2,1,0} constant({...}) + %broadcast.466 = f32[1,1,1,144]{3,2,1,0} broadcast(f32[1,1,1,144]{3,2,1,0} %constant.283), dimensions={0,1,2,3} + %reshape.467 = f32[144]{0} reshape(f32[1,1,1,144]{3,2,1,0} %broadcast.466) + %broadcast.468 = f32[250,75,75,144]{3,2,1,0} broadcast(f32[144]{0} %reshape.467), dimensions={3} + %subtract.469 = f32[250,75,75,144]{3,2,1,0} subtract(f32[250,75,75,144]{3,2,1,0} %convolution.465, f32[250,75,75,144]{3,2,1,0} %broadcast.468) + %constant.282 = f32[144]{0} constant({...}) + %rsqrt.470 = f32[144]{0} rsqrt(f32[144]{0} %constant.282) + %reshape.471 = f32[1,1,1,144]{3,2,1,0} reshape(f32[144]{0} %rsqrt.470) + %constant.281 = f32[1,1,1,144]{3,2,1,0} constant({...}) + %multiply.472 = f32[1,1,1,144]{3,2,1,0} multiply(f32[1,1,1,144]{3,2,1,0} %reshape.471, f32[1,1,1,144]{3,2,1,0} %constant.281) + %broadcast.473 = f32[1,1,1,144]{3,2,1,0} broadcast(f32[1,1,1,144]{3,2,1,0} %multiply.472), dimensions={0,1,2,3} + %reshape.474 = f32[144]{0} reshape(f32[1,1,1,144]{3,2,1,0} %broadcast.473) + %broadcast.475 = f32[250,75,75,144]{3,2,1,0} broadcast(f32[144]{0} %reshape.474), dimensions={3} + %multiply.476 = f32[250,75,75,144]{3,2,1,0} multiply(f32[250,75,75,144]{3,2,1,0} %subtract.469, f32[250,75,75,144]{3,2,1,0} %broadcast.475) + %constant.280 = f32[1,1,1,144]{3,2,1,0} constant({...}) + %broadcast.477 = f32[1,1,1,144]{3,2,1,0} broadcast(f32[1,1,1,144]{3,2,1,0} %constant.280), dimensions={0,1,2,3} + %reshape.478 = f32[144]{0} reshape(f32[1,1,1,144]{3,2,1,0} %broadcast.477) + %broadcast.479 = f32[250,75,75,144]{3,2,1,0} broadcast(f32[144]{0} %reshape.478), dimensions={3} + %add.480 = f32[250,75,75,144]{3,2,1,0} add(f32[250,75,75,144]{3,2,1,0} %multiply.476, f32[250,75,75,144]{3,2,1,0} %broadcast.479) + %call.489 = f32[250,75,75,144]{3,2,1,0} call(f32[250,75,75,144]{3,2,1,0} %add.480), to_apply=%jit_relu6_2.481 + %constant.368 = f32[1,1,144,32]{3,2,1,0} constant({...}) + %convolution.490 = f32[250,75,75,32]{3,2,1,0} convolution(f32[250,75,75,144]{3,2,1,0} %call.489, f32[1,1,144,32]{3,2,1,0} %constant.368), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.279 = f32[1,1,1,32]{3,2,1,0} constant({...}) + %broadcast.491 = f32[1,1,1,32]{3,2,1,0} broadcast(f32[1,1,1,32]{3,2,1,0} %constant.279), dimensions={0,1,2,3} + %reshape.492 = f32[32]{0} reshape(f32[1,1,1,32]{3,2,1,0} %broadcast.491) + %broadcast.493 = f32[250,75,75,32]{3,2,1,0} broadcast(f32[32]{0} %reshape.492), dimensions={3} + %subtract.494 = f32[250,75,75,32]{3,2,1,0} subtract(f32[250,75,75,32]{3,2,1,0} %convolution.490, f32[250,75,75,32]{3,2,1,0} %broadcast.493) + %constant.278 = f32[32]{0} constant({...}) + %rsqrt.495 = f32[32]{0} rsqrt(f32[32]{0} %constant.278) + %reshape.496 = f32[1,1,1,32]{3,2,1,0} reshape(f32[32]{0} %rsqrt.495) + %constant.277 = f32[1,1,1,32]{3,2,1,0} constant({...}) + %multiply.497 = f32[1,1,1,32]{3,2,1,0} multiply(f32[1,1,1,32]{3,2,1,0} %reshape.496, f32[1,1,1,32]{3,2,1,0} %constant.277) + %broadcast.498 = f32[1,1,1,32]{3,2,1,0} broadcast(f32[1,1,1,32]{3,2,1,0} %multiply.497), dimensions={0,1,2,3} + %reshape.499 = f32[32]{0} reshape(f32[1,1,1,32]{3,2,1,0} %broadcast.498) + %broadcast.500 = f32[250,75,75,32]{3,2,1,0} broadcast(f32[32]{0} %reshape.499), dimensions={3} + %multiply.501 = f32[250,75,75,32]{3,2,1,0} multiply(f32[250,75,75,32]{3,2,1,0} %subtract.494, f32[250,75,75,32]{3,2,1,0} %broadcast.500) + %constant.276 = f32[1,1,1,32]{3,2,1,0} constant({...}) + %broadcast.502 = f32[1,1,1,32]{3,2,1,0} broadcast(f32[1,1,1,32]{3,2,1,0} %constant.276), dimensions={0,1,2,3} + %reshape.503 = f32[32]{0} reshape(f32[1,1,1,32]{3,2,1,0} %broadcast.502) + %broadcast.504 = f32[250,75,75,32]{3,2,1,0} broadcast(f32[32]{0} %reshape.503), dimensions={3} + %add.505 = f32[250,75,75,32]{3,2,1,0} add(f32[250,75,75,32]{3,2,1,0} %multiply.501, f32[250,75,75,32]{3,2,1,0} %broadcast.504) + %constant.367 = f32[1,1,32,192]{3,2,1,0} constant({...}) + %convolution.506 = f32[250,75,75,192]{3,2,1,0} convolution(f32[250,75,75,32]{3,2,1,0} %add.505, f32[1,1,32,192]{3,2,1,0} %constant.367), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.275 = f32[1,1,1,192]{3,2,1,0} constant({...}) + %broadcast.507 = f32[1,1,1,192]{3,2,1,0} broadcast(f32[1,1,1,192]{3,2,1,0} %constant.275), dimensions={0,1,2,3} + %reshape.508 = f32[192]{0} reshape(f32[1,1,1,192]{3,2,1,0} %broadcast.507) + %broadcast.509 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[192]{0} %reshape.508), dimensions={3} + %subtract.510 = f32[250,75,75,192]{3,2,1,0} subtract(f32[250,75,75,192]{3,2,1,0} %convolution.506, f32[250,75,75,192]{3,2,1,0} %broadcast.509) + %constant.274 = f32[192]{0} constant({...}) + %rsqrt.511 = f32[192]{0} rsqrt(f32[192]{0} %constant.274) + %reshape.512 = f32[1,1,1,192]{3,2,1,0} reshape(f32[192]{0} %rsqrt.511) + %constant.273 = f32[1,1,1,192]{3,2,1,0} constant({...}) + %multiply.513 = f32[1,1,1,192]{3,2,1,0} multiply(f32[1,1,1,192]{3,2,1,0} %reshape.512, f32[1,1,1,192]{3,2,1,0} %constant.273) + %broadcast.514 = f32[1,1,1,192]{3,2,1,0} broadcast(f32[1,1,1,192]{3,2,1,0} %multiply.513), dimensions={0,1,2,3} + %reshape.515 = f32[192]{0} reshape(f32[1,1,1,192]{3,2,1,0} %broadcast.514) + %broadcast.516 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[192]{0} %reshape.515), dimensions={3} + %multiply.517 = f32[250,75,75,192]{3,2,1,0} multiply(f32[250,75,75,192]{3,2,1,0} %subtract.510, f32[250,75,75,192]{3,2,1,0} %broadcast.516) + %constant.272 = f32[1,1,1,192]{3,2,1,0} constant({...}) + %broadcast.518 = f32[1,1,1,192]{3,2,1,0} broadcast(f32[1,1,1,192]{3,2,1,0} %constant.272), dimensions={0,1,2,3} + %reshape.519 = f32[192]{0} reshape(f32[1,1,1,192]{3,2,1,0} %broadcast.518) + %broadcast.520 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[192]{0} %reshape.519), dimensions={3} + %add.521 = f32[250,75,75,192]{3,2,1,0} add(f32[250,75,75,192]{3,2,1,0} %multiply.517, f32[250,75,75,192]{3,2,1,0} %broadcast.520) + %call.530 = f32[250,75,75,192]{3,2,1,0} call(f32[250,75,75,192]{3,2,1,0} %add.521), to_apply=%jit_relu6_3.522 + %constant.366 = f32[3,3,1,192]{3,2,1,0} constant({...}) + %convolution.531 = f32[250,75,75,192]{3,2,1,0} convolution(f32[250,75,75,192]{3,2,1,0} %call.530, f32[3,3,1,192]{3,2,1,0} %constant.366), window={size=3x3 pad=1_1x1_1}, dim_labels=b01f_01io->b01f, feature_group_count=192 + %constant.271 = f32[1,1,1,192]{3,2,1,0} constant({...}) + %broadcast.532 = f32[1,1,1,192]{3,2,1,0} broadcast(f32[1,1,1,192]{3,2,1,0} %constant.271), dimensions={0,1,2,3} + %reshape.533 = f32[192]{0} reshape(f32[1,1,1,192]{3,2,1,0} %broadcast.532) + %broadcast.534 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[192]{0} %reshape.533), dimensions={3} + %subtract.535 = f32[250,75,75,192]{3,2,1,0} subtract(f32[250,75,75,192]{3,2,1,0} %convolution.531, f32[250,75,75,192]{3,2,1,0} %broadcast.534) + %constant.270 = f32[192]{0} constant({...}) + %rsqrt.536 = f32[192]{0} rsqrt(f32[192]{0} %constant.270) + %reshape.537 = f32[1,1,1,192]{3,2,1,0} reshape(f32[192]{0} %rsqrt.536) + %constant.269 = f32[1,1,1,192]{3,2,1,0} constant({...}) + %multiply.538 = f32[1,1,1,192]{3,2,1,0} multiply(f32[1,1,1,192]{3,2,1,0} %reshape.537, f32[1,1,1,192]{3,2,1,0} %constant.269) + %broadcast.539 = f32[1,1,1,192]{3,2,1,0} broadcast(f32[1,1,1,192]{3,2,1,0} %multiply.538), dimensions={0,1,2,3} + %reshape.540 = f32[192]{0} reshape(f32[1,1,1,192]{3,2,1,0} %broadcast.539) + %broadcast.541 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[192]{0} %reshape.540), dimensions={3} + %multiply.542 = f32[250,75,75,192]{3,2,1,0} multiply(f32[250,75,75,192]{3,2,1,0} %subtract.535, f32[250,75,75,192]{3,2,1,0} %broadcast.541) + %constant.268 = f32[1,1,1,192]{3,2,1,0} constant({...}) + %broadcast.543 = f32[1,1,1,192]{3,2,1,0} broadcast(f32[1,1,1,192]{3,2,1,0} %constant.268), dimensions={0,1,2,3} + %reshape.544 = f32[192]{0} reshape(f32[1,1,1,192]{3,2,1,0} %broadcast.543) + %broadcast.545 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[192]{0} %reshape.544), dimensions={3} + %add.546 = f32[250,75,75,192]{3,2,1,0} add(f32[250,75,75,192]{3,2,1,0} %multiply.542, f32[250,75,75,192]{3,2,1,0} %broadcast.545) + %call.555 = f32[250,75,75,192]{3,2,1,0} call(f32[250,75,75,192]{3,2,1,0} %add.546), to_apply=%jit_relu6_4.547 + %constant.365 = f32[1,1,192,32]{3,2,1,0} constant({...}) + %convolution.556 = f32[250,75,75,32]{3,2,1,0} convolution(f32[250,75,75,192]{3,2,1,0} %call.555, f32[1,1,192,32]{3,2,1,0} %constant.365), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.267 = f32[1,1,1,32]{3,2,1,0} constant({...}) + %broadcast.557 = f32[1,1,1,32]{3,2,1,0} broadcast(f32[1,1,1,32]{3,2,1,0} %constant.267), dimensions={0,1,2,3} + %reshape.558 = f32[32]{0} reshape(f32[1,1,1,32]{3,2,1,0} %broadcast.557) + %broadcast.559 = f32[250,75,75,32]{3,2,1,0} broadcast(f32[32]{0} %reshape.558), dimensions={3} + %subtract.560 = f32[250,75,75,32]{3,2,1,0} subtract(f32[250,75,75,32]{3,2,1,0} %convolution.556, f32[250,75,75,32]{3,2,1,0} %broadcast.559) + %constant.266 = f32[32]{0} constant({...}) + %rsqrt.561 = f32[32]{0} rsqrt(f32[32]{0} %constant.266) + %reshape.562 = f32[1,1,1,32]{3,2,1,0} reshape(f32[32]{0} %rsqrt.561) + %constant.265 = f32[1,1,1,32]{3,2,1,0} constant({...}) + %multiply.563 = f32[1,1,1,32]{3,2,1,0} multiply(f32[1,1,1,32]{3,2,1,0} %reshape.562, f32[1,1,1,32]{3,2,1,0} %constant.265) + %broadcast.564 = f32[1,1,1,32]{3,2,1,0} broadcast(f32[1,1,1,32]{3,2,1,0} %multiply.563), dimensions={0,1,2,3} + %reshape.565 = f32[32]{0} reshape(f32[1,1,1,32]{3,2,1,0} %broadcast.564) + %broadcast.566 = f32[250,75,75,32]{3,2,1,0} broadcast(f32[32]{0} %reshape.565), dimensions={3} + %multiply.567 = f32[250,75,75,32]{3,2,1,0} multiply(f32[250,75,75,32]{3,2,1,0} %subtract.560, f32[250,75,75,32]{3,2,1,0} %broadcast.566) + %constant.264 = f32[1,1,1,32]{3,2,1,0} constant({...}) + %broadcast.568 = f32[1,1,1,32]{3,2,1,0} broadcast(f32[1,1,1,32]{3,2,1,0} %constant.264), dimensions={0,1,2,3} + %reshape.569 = f32[32]{0} reshape(f32[1,1,1,32]{3,2,1,0} %broadcast.568) + %broadcast.570 = f32[250,75,75,32]{3,2,1,0} broadcast(f32[32]{0} %reshape.569), dimensions={3} + %add.571 = f32[250,75,75,32]{3,2,1,0} add(f32[250,75,75,32]{3,2,1,0} %multiply.567, f32[250,75,75,32]{3,2,1,0} %broadcast.570) + %add.572 = f32[250,75,75,32]{3,2,1,0} add(f32[250,75,75,32]{3,2,1,0} %add.571, f32[250,75,75,32]{3,2,1,0} %add.505) + %constant.364 = f32[1,1,32,192]{3,2,1,0} constant({...}) + %convolution.573 = f32[250,75,75,192]{3,2,1,0} convolution(f32[250,75,75,32]{3,2,1,0} %add.572, f32[1,1,32,192]{3,2,1,0} %constant.364), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.263 = f32[1,1,1,192]{3,2,1,0} constant({...}) + %broadcast.574 = f32[1,1,1,192]{3,2,1,0} broadcast(f32[1,1,1,192]{3,2,1,0} %constant.263), dimensions={0,1,2,3} + %reshape.575 = f32[192]{0} reshape(f32[1,1,1,192]{3,2,1,0} %broadcast.574) + %broadcast.576 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[192]{0} %reshape.575), dimensions={3} + %subtract.577 = f32[250,75,75,192]{3,2,1,0} subtract(f32[250,75,75,192]{3,2,1,0} %convolution.573, f32[250,75,75,192]{3,2,1,0} %broadcast.576) + %constant.262 = f32[192]{0} constant({...}) + %rsqrt.578 = f32[192]{0} rsqrt(f32[192]{0} %constant.262) + %reshape.579 = f32[1,1,1,192]{3,2,1,0} reshape(f32[192]{0} %rsqrt.578) + %constant.261 = f32[1,1,1,192]{3,2,1,0} constant({...}) + %multiply.580 = f32[1,1,1,192]{3,2,1,0} multiply(f32[1,1,1,192]{3,2,1,0} %reshape.579, f32[1,1,1,192]{3,2,1,0} %constant.261) + %broadcast.581 = f32[1,1,1,192]{3,2,1,0} broadcast(f32[1,1,1,192]{3,2,1,0} %multiply.580), dimensions={0,1,2,3} + %reshape.582 = f32[192]{0} reshape(f32[1,1,1,192]{3,2,1,0} %broadcast.581) + %broadcast.583 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[192]{0} %reshape.582), dimensions={3} + %multiply.584 = f32[250,75,75,192]{3,2,1,0} multiply(f32[250,75,75,192]{3,2,1,0} %subtract.577, f32[250,75,75,192]{3,2,1,0} %broadcast.583) + %constant.260 = f32[1,1,1,192]{3,2,1,0} constant({...}) + %broadcast.585 = f32[1,1,1,192]{3,2,1,0} broadcast(f32[1,1,1,192]{3,2,1,0} %constant.260), dimensions={0,1,2,3} + %reshape.586 = f32[192]{0} reshape(f32[1,1,1,192]{3,2,1,0} %broadcast.585) + %broadcast.587 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[192]{0} %reshape.586), dimensions={3} + %add.588 = f32[250,75,75,192]{3,2,1,0} add(f32[250,75,75,192]{3,2,1,0} %multiply.584, f32[250,75,75,192]{3,2,1,0} %broadcast.587) + %call.597 = f32[250,75,75,192]{3,2,1,0} call(f32[250,75,75,192]{3,2,1,0} %add.588), to_apply=%jit_relu6_5.589 + %constant.363 = f32[3,3,1,192]{3,2,1,0} constant({...}) + %convolution.598 = f32[250,75,75,192]{3,2,1,0} convolution(f32[250,75,75,192]{3,2,1,0} %call.597, f32[3,3,1,192]{3,2,1,0} %constant.363), window={size=3x3 pad=1_1x1_1}, dim_labels=b01f_01io->b01f, feature_group_count=192 + %constant.259 = f32[1,1,1,192]{3,2,1,0} constant({...}) + %broadcast.599 = f32[1,1,1,192]{3,2,1,0} broadcast(f32[1,1,1,192]{3,2,1,0} %constant.259), dimensions={0,1,2,3} + %reshape.600 = f32[192]{0} reshape(f32[1,1,1,192]{3,2,1,0} %broadcast.599) + %broadcast.601 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[192]{0} %reshape.600), dimensions={3} + %subtract.602 = f32[250,75,75,192]{3,2,1,0} subtract(f32[250,75,75,192]{3,2,1,0} %convolution.598, f32[250,75,75,192]{3,2,1,0} %broadcast.601) + %constant.258 = f32[192]{0} constant({...}) + %rsqrt.603 = f32[192]{0} rsqrt(f32[192]{0} %constant.258) + %reshape.604 = f32[1,1,1,192]{3,2,1,0} reshape(f32[192]{0} %rsqrt.603) + %constant.257 = f32[1,1,1,192]{3,2,1,0} constant({...}) + %multiply.605 = f32[1,1,1,192]{3,2,1,0} multiply(f32[1,1,1,192]{3,2,1,0} %reshape.604, f32[1,1,1,192]{3,2,1,0} %constant.257) + %broadcast.606 = f32[1,1,1,192]{3,2,1,0} broadcast(f32[1,1,1,192]{3,2,1,0} %multiply.605), dimensions={0,1,2,3} + %reshape.607 = f32[192]{0} reshape(f32[1,1,1,192]{3,2,1,0} %broadcast.606) + %broadcast.608 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[192]{0} %reshape.607), dimensions={3} + %multiply.609 = f32[250,75,75,192]{3,2,1,0} multiply(f32[250,75,75,192]{3,2,1,0} %subtract.602, f32[250,75,75,192]{3,2,1,0} %broadcast.608) + %constant.256 = f32[1,1,1,192]{3,2,1,0} constant({...}) + %broadcast.610 = f32[1,1,1,192]{3,2,1,0} broadcast(f32[1,1,1,192]{3,2,1,0} %constant.256), dimensions={0,1,2,3} + %reshape.611 = f32[192]{0} reshape(f32[1,1,1,192]{3,2,1,0} %broadcast.610) + %broadcast.612 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[192]{0} %reshape.611), dimensions={3} + %add.613 = f32[250,75,75,192]{3,2,1,0} add(f32[250,75,75,192]{3,2,1,0} %multiply.609, f32[250,75,75,192]{3,2,1,0} %broadcast.612) + %call.622 = f32[250,75,75,192]{3,2,1,0} call(f32[250,75,75,192]{3,2,1,0} %add.613), to_apply=%jit_relu6_6.614 + %constant.362 = f32[1,1,192,32]{3,2,1,0} constant({...}) + %convolution.623 = f32[250,75,75,32]{3,2,1,0} convolution(f32[250,75,75,192]{3,2,1,0} %call.622, f32[1,1,192,32]{3,2,1,0} %constant.362), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.255 = f32[1,1,1,32]{3,2,1,0} constant({...}) + %broadcast.624 = f32[1,1,1,32]{3,2,1,0} broadcast(f32[1,1,1,32]{3,2,1,0} %constant.255), dimensions={0,1,2,3} + %reshape.625 = f32[32]{0} reshape(f32[1,1,1,32]{3,2,1,0} %broadcast.624) + %broadcast.626 = f32[250,75,75,32]{3,2,1,0} broadcast(f32[32]{0} %reshape.625), dimensions={3} + %subtract.627 = f32[250,75,75,32]{3,2,1,0} subtract(f32[250,75,75,32]{3,2,1,0} %convolution.623, f32[250,75,75,32]{3,2,1,0} %broadcast.626) + %constant.254 = f32[32]{0} constant({...}) + %rsqrt.628 = f32[32]{0} rsqrt(f32[32]{0} %constant.254) + %reshape.629 = f32[1,1,1,32]{3,2,1,0} reshape(f32[32]{0} %rsqrt.628) + %constant.253 = f32[1,1,1,32]{3,2,1,0} constant({...}) + %multiply.630 = f32[1,1,1,32]{3,2,1,0} multiply(f32[1,1,1,32]{3,2,1,0} %reshape.629, f32[1,1,1,32]{3,2,1,0} %constant.253) + %broadcast.631 = f32[1,1,1,32]{3,2,1,0} broadcast(f32[1,1,1,32]{3,2,1,0} %multiply.630), dimensions={0,1,2,3} + %reshape.632 = f32[32]{0} reshape(f32[1,1,1,32]{3,2,1,0} %broadcast.631) + %broadcast.633 = f32[250,75,75,32]{3,2,1,0} broadcast(f32[32]{0} %reshape.632), dimensions={3} + %multiply.634 = f32[250,75,75,32]{3,2,1,0} multiply(f32[250,75,75,32]{3,2,1,0} %subtract.627, f32[250,75,75,32]{3,2,1,0} %broadcast.633) + %constant.252 = f32[1,1,1,32]{3,2,1,0} constant({...}) + %broadcast.635 = f32[1,1,1,32]{3,2,1,0} broadcast(f32[1,1,1,32]{3,2,1,0} %constant.252), dimensions={0,1,2,3} + %reshape.636 = f32[32]{0} reshape(f32[1,1,1,32]{3,2,1,0} %broadcast.635) + %broadcast.637 = f32[250,75,75,32]{3,2,1,0} broadcast(f32[32]{0} %reshape.636), dimensions={3} + %add.638 = f32[250,75,75,32]{3,2,1,0} add(f32[250,75,75,32]{3,2,1,0} %multiply.634, f32[250,75,75,32]{3,2,1,0} %broadcast.637) + %add.639 = f32[250,75,75,32]{3,2,1,0} add(f32[250,75,75,32]{3,2,1,0} %add.638, f32[250,75,75,32]{3,2,1,0} %add.572) + %constant.361 = f32[1,1,32,192]{3,2,1,0} constant({...}) + %convolution.640 = f32[250,75,75,192]{3,2,1,0} convolution(f32[250,75,75,32]{3,2,1,0} %add.639, f32[1,1,32,192]{3,2,1,0} %constant.361), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.251 = f32[1,1,1,192]{3,2,1,0} constant({...}) + %broadcast.641 = f32[1,1,1,192]{3,2,1,0} broadcast(f32[1,1,1,192]{3,2,1,0} %constant.251), dimensions={0,1,2,3} + %reshape.642 = f32[192]{0} reshape(f32[1,1,1,192]{3,2,1,0} %broadcast.641) + %broadcast.643 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[192]{0} %reshape.642), dimensions={3} + %subtract.644 = f32[250,75,75,192]{3,2,1,0} subtract(f32[250,75,75,192]{3,2,1,0} %convolution.640, f32[250,75,75,192]{3,2,1,0} %broadcast.643) + %constant.250 = f32[192]{0} constant({...}) + %rsqrt.645 = f32[192]{0} rsqrt(f32[192]{0} %constant.250) + %reshape.646 = f32[1,1,1,192]{3,2,1,0} reshape(f32[192]{0} %rsqrt.645) + %constant.249 = f32[1,1,1,192]{3,2,1,0} constant({...}) + %multiply.647 = f32[1,1,1,192]{3,2,1,0} multiply(f32[1,1,1,192]{3,2,1,0} %reshape.646, f32[1,1,1,192]{3,2,1,0} %constant.249) + %broadcast.648 = f32[1,1,1,192]{3,2,1,0} broadcast(f32[1,1,1,192]{3,2,1,0} %multiply.647), dimensions={0,1,2,3} + %reshape.649 = f32[192]{0} reshape(f32[1,1,1,192]{3,2,1,0} %broadcast.648) + %broadcast.650 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[192]{0} %reshape.649), dimensions={3} + %multiply.651 = f32[250,75,75,192]{3,2,1,0} multiply(f32[250,75,75,192]{3,2,1,0} %subtract.644, f32[250,75,75,192]{3,2,1,0} %broadcast.650) + %constant.248 = f32[1,1,1,192]{3,2,1,0} constant({...}) + %broadcast.652 = f32[1,1,1,192]{3,2,1,0} broadcast(f32[1,1,1,192]{3,2,1,0} %constant.248), dimensions={0,1,2,3} + %reshape.653 = f32[192]{0} reshape(f32[1,1,1,192]{3,2,1,0} %broadcast.652) + %broadcast.654 = f32[250,75,75,192]{3,2,1,0} broadcast(f32[192]{0} %reshape.653), dimensions={3} + %add.655 = f32[250,75,75,192]{3,2,1,0} add(f32[250,75,75,192]{3,2,1,0} %multiply.651, f32[250,75,75,192]{3,2,1,0} %broadcast.654) + %call.664 = f32[250,75,75,192]{3,2,1,0} call(f32[250,75,75,192]{3,2,1,0} %add.655), to_apply=%jit_relu6_7.656 + %constant.360 = f32[5,5,1,192]{3,2,1,0} constant({...}) + %convolution.665 = f32[250,38,38,192]{3,2,1,0} convolution(f32[250,75,75,192]{3,2,1,0} %call.664, f32[5,5,1,192]{3,2,1,0} %constant.360), window={size=5x5 stride=2x2 pad=2_2x2_2}, dim_labels=b01f_01io->b01f, feature_group_count=192 + %constant.247 = f32[1,1,1,192]{3,2,1,0} constant({...}) + %broadcast.666 = f32[1,1,1,192]{3,2,1,0} broadcast(f32[1,1,1,192]{3,2,1,0} %constant.247), dimensions={0,1,2,3} + %reshape.667 = f32[192]{0} reshape(f32[1,1,1,192]{3,2,1,0} %broadcast.666) + %broadcast.668 = f32[250,38,38,192]{3,2,1,0} broadcast(f32[192]{0} %reshape.667), dimensions={3} + %subtract.669 = f32[250,38,38,192]{3,2,1,0} subtract(f32[250,38,38,192]{3,2,1,0} %convolution.665, f32[250,38,38,192]{3,2,1,0} %broadcast.668) + %constant.246 = f32[192]{0} constant({...}) + %rsqrt.670 = f32[192]{0} rsqrt(f32[192]{0} %constant.246) + %reshape.671 = f32[1,1,1,192]{3,2,1,0} reshape(f32[192]{0} %rsqrt.670) + %constant.245 = f32[1,1,1,192]{3,2,1,0} constant({...}) + %multiply.672 = f32[1,1,1,192]{3,2,1,0} multiply(f32[1,1,1,192]{3,2,1,0} %reshape.671, f32[1,1,1,192]{3,2,1,0} %constant.245) + %broadcast.673 = f32[1,1,1,192]{3,2,1,0} broadcast(f32[1,1,1,192]{3,2,1,0} %multiply.672), dimensions={0,1,2,3} + %reshape.674 = f32[192]{0} reshape(f32[1,1,1,192]{3,2,1,0} %broadcast.673) + %broadcast.675 = f32[250,38,38,192]{3,2,1,0} broadcast(f32[192]{0} %reshape.674), dimensions={3} + %multiply.676 = f32[250,38,38,192]{3,2,1,0} multiply(f32[250,38,38,192]{3,2,1,0} %subtract.669, f32[250,38,38,192]{3,2,1,0} %broadcast.675) + %constant.244 = f32[1,1,1,192]{3,2,1,0} constant({...}) + %broadcast.677 = f32[1,1,1,192]{3,2,1,0} broadcast(f32[1,1,1,192]{3,2,1,0} %constant.244), dimensions={0,1,2,3} + %reshape.678 = f32[192]{0} reshape(f32[1,1,1,192]{3,2,1,0} %broadcast.677) + %broadcast.679 = f32[250,38,38,192]{3,2,1,0} broadcast(f32[192]{0} %reshape.678), dimensions={3} + %add.680 = f32[250,38,38,192]{3,2,1,0} add(f32[250,38,38,192]{3,2,1,0} %multiply.676, f32[250,38,38,192]{3,2,1,0} %broadcast.679) + %call.689 = f32[250,38,38,192]{3,2,1,0} call(f32[250,38,38,192]{3,2,1,0} %add.680), to_apply=%jit_relu6_8.681 + %constant.359 = f32[1,1,192,48]{3,2,1,0} constant({...}) + %convolution.690 = f32[250,38,38,48]{3,2,1,0} convolution(f32[250,38,38,192]{3,2,1,0} %call.689, f32[1,1,192,48]{3,2,1,0} %constant.359), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.243 = f32[1,1,1,48]{3,2,1,0} constant({...}) + %broadcast.691 = f32[1,1,1,48]{3,2,1,0} broadcast(f32[1,1,1,48]{3,2,1,0} %constant.243), dimensions={0,1,2,3} + %reshape.692 = f32[48]{0} reshape(f32[1,1,1,48]{3,2,1,0} %broadcast.691) + %broadcast.693 = f32[250,38,38,48]{3,2,1,0} broadcast(f32[48]{0} %reshape.692), dimensions={3} + %subtract.694 = f32[250,38,38,48]{3,2,1,0} subtract(f32[250,38,38,48]{3,2,1,0} %convolution.690, f32[250,38,38,48]{3,2,1,0} %broadcast.693) + %constant.242 = f32[48]{0} constant({...}) + %rsqrt.695 = f32[48]{0} rsqrt(f32[48]{0} %constant.242) + %reshape.696 = f32[1,1,1,48]{3,2,1,0} reshape(f32[48]{0} %rsqrt.695) + %constant.241 = f32[1,1,1,48]{3,2,1,0} constant({...}) + %multiply.697 = f32[1,1,1,48]{3,2,1,0} multiply(f32[1,1,1,48]{3,2,1,0} %reshape.696, f32[1,1,1,48]{3,2,1,0} %constant.241) + %broadcast.698 = f32[1,1,1,48]{3,2,1,0} broadcast(f32[1,1,1,48]{3,2,1,0} %multiply.697), dimensions={0,1,2,3} + %reshape.699 = f32[48]{0} reshape(f32[1,1,1,48]{3,2,1,0} %broadcast.698) + %broadcast.700 = f32[250,38,38,48]{3,2,1,0} broadcast(f32[48]{0} %reshape.699), dimensions={3} + %multiply.701 = f32[250,38,38,48]{3,2,1,0} multiply(f32[250,38,38,48]{3,2,1,0} %subtract.694, f32[250,38,38,48]{3,2,1,0} %broadcast.700) + %constant.240 = f32[1,1,1,48]{3,2,1,0} constant({...}) + %broadcast.702 = f32[1,1,1,48]{3,2,1,0} broadcast(f32[1,1,1,48]{3,2,1,0} %constant.240), dimensions={0,1,2,3} + %reshape.703 = f32[48]{0} reshape(f32[1,1,1,48]{3,2,1,0} %broadcast.702) + %broadcast.704 = f32[250,38,38,48]{3,2,1,0} broadcast(f32[48]{0} %reshape.703), dimensions={3} + %add.705 = f32[250,38,38,48]{3,2,1,0} add(f32[250,38,38,48]{3,2,1,0} %multiply.701, f32[250,38,38,48]{3,2,1,0} %broadcast.704) + %constant.358 = f32[1,1,48,288]{3,2,1,0} constant({...}) + %convolution.706 = f32[250,38,38,288]{3,2,1,0} convolution(f32[250,38,38,48]{3,2,1,0} %add.705, f32[1,1,48,288]{3,2,1,0} %constant.358), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.239 = f32[1,1,1,288]{3,2,1,0} constant({...}) + %broadcast.707 = f32[1,1,1,288]{3,2,1,0} broadcast(f32[1,1,1,288]{3,2,1,0} %constant.239), dimensions={0,1,2,3} + %reshape.708 = f32[288]{0} reshape(f32[1,1,1,288]{3,2,1,0} %broadcast.707) + %broadcast.709 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[288]{0} %reshape.708), dimensions={3} + %subtract.710 = f32[250,38,38,288]{3,2,1,0} subtract(f32[250,38,38,288]{3,2,1,0} %convolution.706, f32[250,38,38,288]{3,2,1,0} %broadcast.709) + %constant.238 = f32[288]{0} constant({...}) + %rsqrt.711 = f32[288]{0} rsqrt(f32[288]{0} %constant.238) + %reshape.712 = f32[1,1,1,288]{3,2,1,0} reshape(f32[288]{0} %rsqrt.711) + %constant.237 = f32[1,1,1,288]{3,2,1,0} constant({...}) + %multiply.713 = f32[1,1,1,288]{3,2,1,0} multiply(f32[1,1,1,288]{3,2,1,0} %reshape.712, f32[1,1,1,288]{3,2,1,0} %constant.237) + %broadcast.714 = f32[1,1,1,288]{3,2,1,0} broadcast(f32[1,1,1,288]{3,2,1,0} %multiply.713), dimensions={0,1,2,3} + %reshape.715 = f32[288]{0} reshape(f32[1,1,1,288]{3,2,1,0} %broadcast.714) + %broadcast.716 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[288]{0} %reshape.715), dimensions={3} + %multiply.717 = f32[250,38,38,288]{3,2,1,0} multiply(f32[250,38,38,288]{3,2,1,0} %subtract.710, f32[250,38,38,288]{3,2,1,0} %broadcast.716) + %constant.236 = f32[1,1,1,288]{3,2,1,0} constant({...}) + %broadcast.718 = f32[1,1,1,288]{3,2,1,0} broadcast(f32[1,1,1,288]{3,2,1,0} %constant.236), dimensions={0,1,2,3} + %reshape.719 = f32[288]{0} reshape(f32[1,1,1,288]{3,2,1,0} %broadcast.718) + %broadcast.720 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[288]{0} %reshape.719), dimensions={3} + %add.721 = f32[250,38,38,288]{3,2,1,0} add(f32[250,38,38,288]{3,2,1,0} %multiply.717, f32[250,38,38,288]{3,2,1,0} %broadcast.720) + %call.730 = f32[250,38,38,288]{3,2,1,0} call(f32[250,38,38,288]{3,2,1,0} %add.721), to_apply=%jit_relu6_9.722 + %constant.357 = f32[5,5,1,288]{3,2,1,0} constant({...}) + %convolution.731 = f32[250,38,38,288]{3,2,1,0} convolution(f32[250,38,38,288]{3,2,1,0} %call.730, f32[5,5,1,288]{3,2,1,0} %constant.357), window={size=5x5 pad=2_2x2_2}, dim_labels=b01f_01io->b01f, feature_group_count=288 + %constant.235 = f32[1,1,1,288]{3,2,1,0} constant({...}) + %broadcast.732 = f32[1,1,1,288]{3,2,1,0} broadcast(f32[1,1,1,288]{3,2,1,0} %constant.235), dimensions={0,1,2,3} + %reshape.733 = f32[288]{0} reshape(f32[1,1,1,288]{3,2,1,0} %broadcast.732) + %broadcast.734 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[288]{0} %reshape.733), dimensions={3} + %subtract.735 = f32[250,38,38,288]{3,2,1,0} subtract(f32[250,38,38,288]{3,2,1,0} %convolution.731, f32[250,38,38,288]{3,2,1,0} %broadcast.734) + %constant.234 = f32[288]{0} constant({...}) + %rsqrt.736 = f32[288]{0} rsqrt(f32[288]{0} %constant.234) + %reshape.737 = f32[1,1,1,288]{3,2,1,0} reshape(f32[288]{0} %rsqrt.736) + %constant.233 = f32[1,1,1,288]{3,2,1,0} constant({...}) + %multiply.738 = f32[1,1,1,288]{3,2,1,0} multiply(f32[1,1,1,288]{3,2,1,0} %reshape.737, f32[1,1,1,288]{3,2,1,0} %constant.233) + %broadcast.739 = f32[1,1,1,288]{3,2,1,0} broadcast(f32[1,1,1,288]{3,2,1,0} %multiply.738), dimensions={0,1,2,3} + %reshape.740 = f32[288]{0} reshape(f32[1,1,1,288]{3,2,1,0} %broadcast.739) + %broadcast.741 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[288]{0} %reshape.740), dimensions={3} + %multiply.742 = f32[250,38,38,288]{3,2,1,0} multiply(f32[250,38,38,288]{3,2,1,0} %subtract.735, f32[250,38,38,288]{3,2,1,0} %broadcast.741) + %constant.232 = f32[1,1,1,288]{3,2,1,0} constant({...}) + %broadcast.743 = f32[1,1,1,288]{3,2,1,0} broadcast(f32[1,1,1,288]{3,2,1,0} %constant.232), dimensions={0,1,2,3} + %reshape.744 = f32[288]{0} reshape(f32[1,1,1,288]{3,2,1,0} %broadcast.743) + %broadcast.745 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[288]{0} %reshape.744), dimensions={3} + %add.746 = f32[250,38,38,288]{3,2,1,0} add(f32[250,38,38,288]{3,2,1,0} %multiply.742, f32[250,38,38,288]{3,2,1,0} %broadcast.745) + %call.755 = f32[250,38,38,288]{3,2,1,0} call(f32[250,38,38,288]{3,2,1,0} %add.746), to_apply=%jit_relu6_10.747 + %constant.356 = f32[1,1,288,48]{3,2,1,0} constant({...}) + %convolution.756 = f32[250,38,38,48]{3,2,1,0} convolution(f32[250,38,38,288]{3,2,1,0} %call.755, f32[1,1,288,48]{3,2,1,0} %constant.356), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.231 = f32[1,1,1,48]{3,2,1,0} constant({...}) + %broadcast.757 = f32[1,1,1,48]{3,2,1,0} broadcast(f32[1,1,1,48]{3,2,1,0} %constant.231), dimensions={0,1,2,3} + %reshape.758 = f32[48]{0} reshape(f32[1,1,1,48]{3,2,1,0} %broadcast.757) + %broadcast.759 = f32[250,38,38,48]{3,2,1,0} broadcast(f32[48]{0} %reshape.758), dimensions={3} + %subtract.760 = f32[250,38,38,48]{3,2,1,0} subtract(f32[250,38,38,48]{3,2,1,0} %convolution.756, f32[250,38,38,48]{3,2,1,0} %broadcast.759) + %constant.230 = f32[48]{0} constant({...}) + %rsqrt.761 = f32[48]{0} rsqrt(f32[48]{0} %constant.230) + %reshape.762 = f32[1,1,1,48]{3,2,1,0} reshape(f32[48]{0} %rsqrt.761) + %constant.229 = f32[1,1,1,48]{3,2,1,0} constant({...}) + %multiply.763 = f32[1,1,1,48]{3,2,1,0} multiply(f32[1,1,1,48]{3,2,1,0} %reshape.762, f32[1,1,1,48]{3,2,1,0} %constant.229) + %broadcast.764 = f32[1,1,1,48]{3,2,1,0} broadcast(f32[1,1,1,48]{3,2,1,0} %multiply.763), dimensions={0,1,2,3} + %reshape.765 = f32[48]{0} reshape(f32[1,1,1,48]{3,2,1,0} %broadcast.764) + %broadcast.766 = f32[250,38,38,48]{3,2,1,0} broadcast(f32[48]{0} %reshape.765), dimensions={3} + %multiply.767 = f32[250,38,38,48]{3,2,1,0} multiply(f32[250,38,38,48]{3,2,1,0} %subtract.760, f32[250,38,38,48]{3,2,1,0} %broadcast.766) + %constant.228 = f32[1,1,1,48]{3,2,1,0} constant({...}) + %broadcast.768 = f32[1,1,1,48]{3,2,1,0} broadcast(f32[1,1,1,48]{3,2,1,0} %constant.228), dimensions={0,1,2,3} + %reshape.769 = f32[48]{0} reshape(f32[1,1,1,48]{3,2,1,0} %broadcast.768) + %broadcast.770 = f32[250,38,38,48]{3,2,1,0} broadcast(f32[48]{0} %reshape.769), dimensions={3} + %add.771 = f32[250,38,38,48]{3,2,1,0} add(f32[250,38,38,48]{3,2,1,0} %multiply.767, f32[250,38,38,48]{3,2,1,0} %broadcast.770) + %add.772 = f32[250,38,38,48]{3,2,1,0} add(f32[250,38,38,48]{3,2,1,0} %add.771, f32[250,38,38,48]{3,2,1,0} %add.705) + %constant.355 = f32[1,1,48,288]{3,2,1,0} constant({...}) + %convolution.773 = f32[250,38,38,288]{3,2,1,0} convolution(f32[250,38,38,48]{3,2,1,0} %add.772, f32[1,1,48,288]{3,2,1,0} %constant.355), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.227 = f32[1,1,1,288]{3,2,1,0} constant({...}) + %broadcast.774 = f32[1,1,1,288]{3,2,1,0} broadcast(f32[1,1,1,288]{3,2,1,0} %constant.227), dimensions={0,1,2,3} + %reshape.775 = f32[288]{0} reshape(f32[1,1,1,288]{3,2,1,0} %broadcast.774) + %broadcast.776 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[288]{0} %reshape.775), dimensions={3} + %subtract.777 = f32[250,38,38,288]{3,2,1,0} subtract(f32[250,38,38,288]{3,2,1,0} %convolution.773, f32[250,38,38,288]{3,2,1,0} %broadcast.776) + %constant.226 = f32[288]{0} constant({...}) + %rsqrt.778 = f32[288]{0} rsqrt(f32[288]{0} %constant.226) + %reshape.779 = f32[1,1,1,288]{3,2,1,0} reshape(f32[288]{0} %rsqrt.778) + %constant.225 = f32[1,1,1,288]{3,2,1,0} constant({...}) + %multiply.780 = f32[1,1,1,288]{3,2,1,0} multiply(f32[1,1,1,288]{3,2,1,0} %reshape.779, f32[1,1,1,288]{3,2,1,0} %constant.225) + %broadcast.781 = f32[1,1,1,288]{3,2,1,0} broadcast(f32[1,1,1,288]{3,2,1,0} %multiply.780), dimensions={0,1,2,3} + %reshape.782 = f32[288]{0} reshape(f32[1,1,1,288]{3,2,1,0} %broadcast.781) + %broadcast.783 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[288]{0} %reshape.782), dimensions={3} + %multiply.784 = f32[250,38,38,288]{3,2,1,0} multiply(f32[250,38,38,288]{3,2,1,0} %subtract.777, f32[250,38,38,288]{3,2,1,0} %broadcast.783) + %constant.224 = f32[1,1,1,288]{3,2,1,0} constant({...}) + %broadcast.785 = f32[1,1,1,288]{3,2,1,0} broadcast(f32[1,1,1,288]{3,2,1,0} %constant.224), dimensions={0,1,2,3} + %reshape.786 = f32[288]{0} reshape(f32[1,1,1,288]{3,2,1,0} %broadcast.785) + %broadcast.787 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[288]{0} %reshape.786), dimensions={3} + %add.788 = f32[250,38,38,288]{3,2,1,0} add(f32[250,38,38,288]{3,2,1,0} %multiply.784, f32[250,38,38,288]{3,2,1,0} %broadcast.787) + %call.797 = f32[250,38,38,288]{3,2,1,0} call(f32[250,38,38,288]{3,2,1,0} %add.788), to_apply=%jit_relu6_11.789 + %constant.354 = f32[5,5,1,288]{3,2,1,0} constant({...}) + %convolution.798 = f32[250,38,38,288]{3,2,1,0} convolution(f32[250,38,38,288]{3,2,1,0} %call.797, f32[5,5,1,288]{3,2,1,0} %constant.354), window={size=5x5 pad=2_2x2_2}, dim_labels=b01f_01io->b01f, feature_group_count=288 + %constant.223 = f32[1,1,1,288]{3,2,1,0} constant({...}) + %broadcast.799 = f32[1,1,1,288]{3,2,1,0} broadcast(f32[1,1,1,288]{3,2,1,0} %constant.223), dimensions={0,1,2,3} + %reshape.800 = f32[288]{0} reshape(f32[1,1,1,288]{3,2,1,0} %broadcast.799) + %broadcast.801 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[288]{0} %reshape.800), dimensions={3} + %subtract.802 = f32[250,38,38,288]{3,2,1,0} subtract(f32[250,38,38,288]{3,2,1,0} %convolution.798, f32[250,38,38,288]{3,2,1,0} %broadcast.801) + %constant.222 = f32[288]{0} constant({...}) + %rsqrt.803 = f32[288]{0} rsqrt(f32[288]{0} %constant.222) + %reshape.804 = f32[1,1,1,288]{3,2,1,0} reshape(f32[288]{0} %rsqrt.803) + %constant.221 = f32[1,1,1,288]{3,2,1,0} constant({...}) + %multiply.805 = f32[1,1,1,288]{3,2,1,0} multiply(f32[1,1,1,288]{3,2,1,0} %reshape.804, f32[1,1,1,288]{3,2,1,0} %constant.221) + %broadcast.806 = f32[1,1,1,288]{3,2,1,0} broadcast(f32[1,1,1,288]{3,2,1,0} %multiply.805), dimensions={0,1,2,3} + %reshape.807 = f32[288]{0} reshape(f32[1,1,1,288]{3,2,1,0} %broadcast.806) + %broadcast.808 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[288]{0} %reshape.807), dimensions={3} + %multiply.809 = f32[250,38,38,288]{3,2,1,0} multiply(f32[250,38,38,288]{3,2,1,0} %subtract.802, f32[250,38,38,288]{3,2,1,0} %broadcast.808) + %constant.220 = f32[1,1,1,288]{3,2,1,0} constant({...}) + %broadcast.810 = f32[1,1,1,288]{3,2,1,0} broadcast(f32[1,1,1,288]{3,2,1,0} %constant.220), dimensions={0,1,2,3} + %reshape.811 = f32[288]{0} reshape(f32[1,1,1,288]{3,2,1,0} %broadcast.810) + %broadcast.812 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[288]{0} %reshape.811), dimensions={3} + %add.813 = f32[250,38,38,288]{3,2,1,0} add(f32[250,38,38,288]{3,2,1,0} %multiply.809, f32[250,38,38,288]{3,2,1,0} %broadcast.812) + %call.822 = f32[250,38,38,288]{3,2,1,0} call(f32[250,38,38,288]{3,2,1,0} %add.813), to_apply=%jit_relu6_12.814 + %constant.353 = f32[1,1,288,48]{3,2,1,0} constant({...}) + %convolution.823 = f32[250,38,38,48]{3,2,1,0} convolution(f32[250,38,38,288]{3,2,1,0} %call.822, f32[1,1,288,48]{3,2,1,0} %constant.353), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.219 = f32[1,1,1,48]{3,2,1,0} constant({...}) + %broadcast.824 = f32[1,1,1,48]{3,2,1,0} broadcast(f32[1,1,1,48]{3,2,1,0} %constant.219), dimensions={0,1,2,3} + %reshape.825 = f32[48]{0} reshape(f32[1,1,1,48]{3,2,1,0} %broadcast.824) + %broadcast.826 = f32[250,38,38,48]{3,2,1,0} broadcast(f32[48]{0} %reshape.825), dimensions={3} + %subtract.827 = f32[250,38,38,48]{3,2,1,0} subtract(f32[250,38,38,48]{3,2,1,0} %convolution.823, f32[250,38,38,48]{3,2,1,0} %broadcast.826) + %constant.218 = f32[48]{0} constant({...}) + %rsqrt.828 = f32[48]{0} rsqrt(f32[48]{0} %constant.218) + %reshape.829 = f32[1,1,1,48]{3,2,1,0} reshape(f32[48]{0} %rsqrt.828) + %constant.217 = f32[1,1,1,48]{3,2,1,0} constant({...}) + %multiply.830 = f32[1,1,1,48]{3,2,1,0} multiply(f32[1,1,1,48]{3,2,1,0} %reshape.829, f32[1,1,1,48]{3,2,1,0} %constant.217) + %broadcast.831 = f32[1,1,1,48]{3,2,1,0} broadcast(f32[1,1,1,48]{3,2,1,0} %multiply.830), dimensions={0,1,2,3} + %reshape.832 = f32[48]{0} reshape(f32[1,1,1,48]{3,2,1,0} %broadcast.831) + %broadcast.833 = f32[250,38,38,48]{3,2,1,0} broadcast(f32[48]{0} %reshape.832), dimensions={3} + %multiply.834 = f32[250,38,38,48]{3,2,1,0} multiply(f32[250,38,38,48]{3,2,1,0} %subtract.827, f32[250,38,38,48]{3,2,1,0} %broadcast.833) + %constant.216 = f32[1,1,1,48]{3,2,1,0} constant({...}) + %broadcast.835 = f32[1,1,1,48]{3,2,1,0} broadcast(f32[1,1,1,48]{3,2,1,0} %constant.216), dimensions={0,1,2,3} + %reshape.836 = f32[48]{0} reshape(f32[1,1,1,48]{3,2,1,0} %broadcast.835) + %broadcast.837 = f32[250,38,38,48]{3,2,1,0} broadcast(f32[48]{0} %reshape.836), dimensions={3} + %add.838 = f32[250,38,38,48]{3,2,1,0} add(f32[250,38,38,48]{3,2,1,0} %multiply.834, f32[250,38,38,48]{3,2,1,0} %broadcast.837) + %add.839 = f32[250,38,38,48]{3,2,1,0} add(f32[250,38,38,48]{3,2,1,0} %add.838, f32[250,38,38,48]{3,2,1,0} %add.772) + %constant.352 = f32[1,1,48,288]{3,2,1,0} constant({...}) + %convolution.840 = f32[250,38,38,288]{3,2,1,0} convolution(f32[250,38,38,48]{3,2,1,0} %add.839, f32[1,1,48,288]{3,2,1,0} %constant.352), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.215 = f32[1,1,1,288]{3,2,1,0} constant({...}) + %broadcast.841 = f32[1,1,1,288]{3,2,1,0} broadcast(f32[1,1,1,288]{3,2,1,0} %constant.215), dimensions={0,1,2,3} + %reshape.842 = f32[288]{0} reshape(f32[1,1,1,288]{3,2,1,0} %broadcast.841) + %broadcast.843 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[288]{0} %reshape.842), dimensions={3} + %subtract.844 = f32[250,38,38,288]{3,2,1,0} subtract(f32[250,38,38,288]{3,2,1,0} %convolution.840, f32[250,38,38,288]{3,2,1,0} %broadcast.843) + %constant.214 = f32[288]{0} constant({...}) + %rsqrt.845 = f32[288]{0} rsqrt(f32[288]{0} %constant.214) + %reshape.846 = f32[1,1,1,288]{3,2,1,0} reshape(f32[288]{0} %rsqrt.845) + %constant.213 = f32[1,1,1,288]{3,2,1,0} constant({...}) + %multiply.847 = f32[1,1,1,288]{3,2,1,0} multiply(f32[1,1,1,288]{3,2,1,0} %reshape.846, f32[1,1,1,288]{3,2,1,0} %constant.213) + %broadcast.848 = f32[1,1,1,288]{3,2,1,0} broadcast(f32[1,1,1,288]{3,2,1,0} %multiply.847), dimensions={0,1,2,3} + %reshape.849 = f32[288]{0} reshape(f32[1,1,1,288]{3,2,1,0} %broadcast.848) + %broadcast.850 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[288]{0} %reshape.849), dimensions={3} + %multiply.851 = f32[250,38,38,288]{3,2,1,0} multiply(f32[250,38,38,288]{3,2,1,0} %subtract.844, f32[250,38,38,288]{3,2,1,0} %broadcast.850) + %constant.212 = f32[1,1,1,288]{3,2,1,0} constant({...}) + %broadcast.852 = f32[1,1,1,288]{3,2,1,0} broadcast(f32[1,1,1,288]{3,2,1,0} %constant.212), dimensions={0,1,2,3} + %reshape.853 = f32[288]{0} reshape(f32[1,1,1,288]{3,2,1,0} %broadcast.852) + %broadcast.854 = f32[250,38,38,288]{3,2,1,0} broadcast(f32[288]{0} %reshape.853), dimensions={3} + %add.855 = f32[250,38,38,288]{3,2,1,0} add(f32[250,38,38,288]{3,2,1,0} %multiply.851, f32[250,38,38,288]{3,2,1,0} %broadcast.854) + %call.864 = f32[250,38,38,288]{3,2,1,0} call(f32[250,38,38,288]{3,2,1,0} %add.855), to_apply=%jit_relu6_13.856 + %constant.351 = f32[3,3,1,288]{3,2,1,0} constant({...}) + %convolution.865 = f32[250,19,19,288]{3,2,1,0} convolution(f32[250,38,38,288]{3,2,1,0} %call.864, f32[3,3,1,288]{3,2,1,0} %constant.351), window={size=3x3 stride=2x2 pad=0_1x0_1}, dim_labels=b01f_01io->b01f, feature_group_count=288 + %constant.211 = f32[1,1,1,288]{3,2,1,0} constant({...}) + %broadcast.866 = f32[1,1,1,288]{3,2,1,0} broadcast(f32[1,1,1,288]{3,2,1,0} %constant.211), dimensions={0,1,2,3} + %reshape.867 = f32[288]{0} reshape(f32[1,1,1,288]{3,2,1,0} %broadcast.866) + %broadcast.868 = f32[250,19,19,288]{3,2,1,0} broadcast(f32[288]{0} %reshape.867), dimensions={3} + %subtract.869 = f32[250,19,19,288]{3,2,1,0} subtract(f32[250,19,19,288]{3,2,1,0} %convolution.865, f32[250,19,19,288]{3,2,1,0} %broadcast.868) + %constant.210 = f32[288]{0} constant({...}) + %rsqrt.870 = f32[288]{0} rsqrt(f32[288]{0} %constant.210) + %reshape.871 = f32[1,1,1,288]{3,2,1,0} reshape(f32[288]{0} %rsqrt.870) + %constant.209 = f32[1,1,1,288]{3,2,1,0} constant({...}) + %multiply.872 = f32[1,1,1,288]{3,2,1,0} multiply(f32[1,1,1,288]{3,2,1,0} %reshape.871, f32[1,1,1,288]{3,2,1,0} %constant.209) + %broadcast.873 = f32[1,1,1,288]{3,2,1,0} broadcast(f32[1,1,1,288]{3,2,1,0} %multiply.872), dimensions={0,1,2,3} + %reshape.874 = f32[288]{0} reshape(f32[1,1,1,288]{3,2,1,0} %broadcast.873) + %broadcast.875 = f32[250,19,19,288]{3,2,1,0} broadcast(f32[288]{0} %reshape.874), dimensions={3} + %multiply.876 = f32[250,19,19,288]{3,2,1,0} multiply(f32[250,19,19,288]{3,2,1,0} %subtract.869, f32[250,19,19,288]{3,2,1,0} %broadcast.875) + %constant.208 = f32[1,1,1,288]{3,2,1,0} constant({...}) + %broadcast.877 = f32[1,1,1,288]{3,2,1,0} broadcast(f32[1,1,1,288]{3,2,1,0} %constant.208), dimensions={0,1,2,3} + %reshape.878 = f32[288]{0} reshape(f32[1,1,1,288]{3,2,1,0} %broadcast.877) + %broadcast.879 = f32[250,19,19,288]{3,2,1,0} broadcast(f32[288]{0} %reshape.878), dimensions={3} + %add.880 = f32[250,19,19,288]{3,2,1,0} add(f32[250,19,19,288]{3,2,1,0} %multiply.876, f32[250,19,19,288]{3,2,1,0} %broadcast.879) + %call.889 = f32[250,19,19,288]{3,2,1,0} call(f32[250,19,19,288]{3,2,1,0} %add.880), to_apply=%jit_relu6_14.881 + %constant.350 = f32[1,1,288,96]{3,2,1,0} constant({...}) + %convolution.890 = f32[250,19,19,96]{3,2,1,0} convolution(f32[250,19,19,288]{3,2,1,0} %call.889, f32[1,1,288,96]{3,2,1,0} %constant.350), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.207 = f32[1,1,1,96]{3,2,1,0} constant({...}) + %broadcast.891 = f32[1,1,1,96]{3,2,1,0} broadcast(f32[1,1,1,96]{3,2,1,0} %constant.207), dimensions={0,1,2,3} + %reshape.892 = f32[96]{0} reshape(f32[1,1,1,96]{3,2,1,0} %broadcast.891) + %broadcast.893 = f32[250,19,19,96]{3,2,1,0} broadcast(f32[96]{0} %reshape.892), dimensions={3} + %subtract.894 = f32[250,19,19,96]{3,2,1,0} subtract(f32[250,19,19,96]{3,2,1,0} %convolution.890, f32[250,19,19,96]{3,2,1,0} %broadcast.893) + %constant.206 = f32[96]{0} constant({...}) + %rsqrt.895 = f32[96]{0} rsqrt(f32[96]{0} %constant.206) + %reshape.896 = f32[1,1,1,96]{3,2,1,0} reshape(f32[96]{0} %rsqrt.895) + %constant.205 = f32[1,1,1,96]{3,2,1,0} constant({...}) + %multiply.897 = f32[1,1,1,96]{3,2,1,0} multiply(f32[1,1,1,96]{3,2,1,0} %reshape.896, f32[1,1,1,96]{3,2,1,0} %constant.205) + %broadcast.898 = f32[1,1,1,96]{3,2,1,0} broadcast(f32[1,1,1,96]{3,2,1,0} %multiply.897), dimensions={0,1,2,3} + %reshape.899 = f32[96]{0} reshape(f32[1,1,1,96]{3,2,1,0} %broadcast.898) + %broadcast.900 = f32[250,19,19,96]{3,2,1,0} broadcast(f32[96]{0} %reshape.899), dimensions={3} + %multiply.901 = f32[250,19,19,96]{3,2,1,0} multiply(f32[250,19,19,96]{3,2,1,0} %subtract.894, f32[250,19,19,96]{3,2,1,0} %broadcast.900) + %constant.204 = f32[1,1,1,96]{3,2,1,0} constant({...}) + %broadcast.902 = f32[1,1,1,96]{3,2,1,0} broadcast(f32[1,1,1,96]{3,2,1,0} %constant.204), dimensions={0,1,2,3} + %reshape.903 = f32[96]{0} reshape(f32[1,1,1,96]{3,2,1,0} %broadcast.902) + %broadcast.904 = f32[250,19,19,96]{3,2,1,0} broadcast(f32[96]{0} %reshape.903), dimensions={3} + %add.905 = f32[250,19,19,96]{3,2,1,0} add(f32[250,19,19,96]{3,2,1,0} %multiply.901, f32[250,19,19,96]{3,2,1,0} %broadcast.904) + %constant.349 = f32[1,1,96,576]{3,2,1,0} constant({...}) + %convolution.906 = f32[250,19,19,576]{3,2,1,0} convolution(f32[250,19,19,96]{3,2,1,0} %add.905, f32[1,1,96,576]{3,2,1,0} %constant.349), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.203 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %broadcast.907 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %constant.203), dimensions={0,1,2,3} + %reshape.908 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.907) + %broadcast.909 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.908), dimensions={3} + %subtract.910 = f32[250,19,19,576]{3,2,1,0} subtract(f32[250,19,19,576]{3,2,1,0} %convolution.906, f32[250,19,19,576]{3,2,1,0} %broadcast.909) + %constant.202 = f32[576]{0} constant({...}) + %rsqrt.911 = f32[576]{0} rsqrt(f32[576]{0} %constant.202) + %reshape.912 = f32[1,1,1,576]{3,2,1,0} reshape(f32[576]{0} %rsqrt.911) + %constant.201 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %multiply.913 = f32[1,1,1,576]{3,2,1,0} multiply(f32[1,1,1,576]{3,2,1,0} %reshape.912, f32[1,1,1,576]{3,2,1,0} %constant.201) + %broadcast.914 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %multiply.913), dimensions={0,1,2,3} + %reshape.915 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.914) + %broadcast.916 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.915), dimensions={3} + %multiply.917 = f32[250,19,19,576]{3,2,1,0} multiply(f32[250,19,19,576]{3,2,1,0} %subtract.910, f32[250,19,19,576]{3,2,1,0} %broadcast.916) + %constant.200 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %broadcast.918 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %constant.200), dimensions={0,1,2,3} + %reshape.919 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.918) + %broadcast.920 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.919), dimensions={3} + %add.921 = f32[250,19,19,576]{3,2,1,0} add(f32[250,19,19,576]{3,2,1,0} %multiply.917, f32[250,19,19,576]{3,2,1,0} %broadcast.920) + %call.930 = f32[250,19,19,576]{3,2,1,0} call(f32[250,19,19,576]{3,2,1,0} %add.921), to_apply=%jit_relu6_15.922 + %constant.348 = f32[3,3,1,576]{3,2,1,0} constant({...}) + %convolution.931 = f32[250,19,19,576]{3,2,1,0} convolution(f32[250,19,19,576]{3,2,1,0} %call.930, f32[3,3,1,576]{3,2,1,0} %constant.348), window={size=3x3 pad=1_1x1_1}, dim_labels=b01f_01io->b01f, feature_group_count=576 + %constant.199 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %broadcast.932 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %constant.199), dimensions={0,1,2,3} + %reshape.933 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.932) + %broadcast.934 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.933), dimensions={3} + %subtract.935 = f32[250,19,19,576]{3,2,1,0} subtract(f32[250,19,19,576]{3,2,1,0} %convolution.931, f32[250,19,19,576]{3,2,1,0} %broadcast.934) + %constant.198 = f32[576]{0} constant({...}) + %rsqrt.936 = f32[576]{0} rsqrt(f32[576]{0} %constant.198) + %reshape.937 = f32[1,1,1,576]{3,2,1,0} reshape(f32[576]{0} %rsqrt.936) + %constant.197 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %multiply.938 = f32[1,1,1,576]{3,2,1,0} multiply(f32[1,1,1,576]{3,2,1,0} %reshape.937, f32[1,1,1,576]{3,2,1,0} %constant.197) + %broadcast.939 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %multiply.938), dimensions={0,1,2,3} + %reshape.940 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.939) + %broadcast.941 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.940), dimensions={3} + %multiply.942 = f32[250,19,19,576]{3,2,1,0} multiply(f32[250,19,19,576]{3,2,1,0} %subtract.935, f32[250,19,19,576]{3,2,1,0} %broadcast.941) + %constant.196 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %broadcast.943 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %constant.196), dimensions={0,1,2,3} + %reshape.944 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.943) + %broadcast.945 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.944), dimensions={3} + %add.946 = f32[250,19,19,576]{3,2,1,0} add(f32[250,19,19,576]{3,2,1,0} %multiply.942, f32[250,19,19,576]{3,2,1,0} %broadcast.945) + %call.955 = f32[250,19,19,576]{3,2,1,0} call(f32[250,19,19,576]{3,2,1,0} %add.946), to_apply=%jit_relu6_16.947 + %constant.347 = f32[1,1,576,96]{3,2,1,0} constant({...}) + %convolution.956 = f32[250,19,19,96]{3,2,1,0} convolution(f32[250,19,19,576]{3,2,1,0} %call.955, f32[1,1,576,96]{3,2,1,0} %constant.347), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.195 = f32[1,1,1,96]{3,2,1,0} constant({...}) + %broadcast.957 = f32[1,1,1,96]{3,2,1,0} broadcast(f32[1,1,1,96]{3,2,1,0} %constant.195), dimensions={0,1,2,3} + %reshape.958 = f32[96]{0} reshape(f32[1,1,1,96]{3,2,1,0} %broadcast.957) + %broadcast.959 = f32[250,19,19,96]{3,2,1,0} broadcast(f32[96]{0} %reshape.958), dimensions={3} + %subtract.960 = f32[250,19,19,96]{3,2,1,0} subtract(f32[250,19,19,96]{3,2,1,0} %convolution.956, f32[250,19,19,96]{3,2,1,0} %broadcast.959) + %constant.194 = f32[96]{0} constant({...}) + %rsqrt.961 = f32[96]{0} rsqrt(f32[96]{0} %constant.194) + %reshape.962 = f32[1,1,1,96]{3,2,1,0} reshape(f32[96]{0} %rsqrt.961) + %constant.193 = f32[1,1,1,96]{3,2,1,0} constant({...}) + %multiply.963 = f32[1,1,1,96]{3,2,1,0} multiply(f32[1,1,1,96]{3,2,1,0} %reshape.962, f32[1,1,1,96]{3,2,1,0} %constant.193) + %broadcast.964 = f32[1,1,1,96]{3,2,1,0} broadcast(f32[1,1,1,96]{3,2,1,0} %multiply.963), dimensions={0,1,2,3} + %reshape.965 = f32[96]{0} reshape(f32[1,1,1,96]{3,2,1,0} %broadcast.964) + %broadcast.966 = f32[250,19,19,96]{3,2,1,0} broadcast(f32[96]{0} %reshape.965), dimensions={3} + %multiply.967 = f32[250,19,19,96]{3,2,1,0} multiply(f32[250,19,19,96]{3,2,1,0} %subtract.960, f32[250,19,19,96]{3,2,1,0} %broadcast.966) + %constant.192 = f32[1,1,1,96]{3,2,1,0} constant({...}) + %broadcast.968 = f32[1,1,1,96]{3,2,1,0} broadcast(f32[1,1,1,96]{3,2,1,0} %constant.192), dimensions={0,1,2,3} + %reshape.969 = f32[96]{0} reshape(f32[1,1,1,96]{3,2,1,0} %broadcast.968) + %broadcast.970 = f32[250,19,19,96]{3,2,1,0} broadcast(f32[96]{0} %reshape.969), dimensions={3} + %add.971 = f32[250,19,19,96]{3,2,1,0} add(f32[250,19,19,96]{3,2,1,0} %multiply.967, f32[250,19,19,96]{3,2,1,0} %broadcast.970) + %add.972 = f32[250,19,19,96]{3,2,1,0} add(f32[250,19,19,96]{3,2,1,0} %add.971, f32[250,19,19,96]{3,2,1,0} %add.905) + %constant.346 = f32[1,1,96,576]{3,2,1,0} constant({...}) + %convolution.973 = f32[250,19,19,576]{3,2,1,0} convolution(f32[250,19,19,96]{3,2,1,0} %add.972, f32[1,1,96,576]{3,2,1,0} %constant.346), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.191 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %broadcast.974 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %constant.191), dimensions={0,1,2,3} + %reshape.975 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.974) + %broadcast.976 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.975), dimensions={3} + %subtract.977 = f32[250,19,19,576]{3,2,1,0} subtract(f32[250,19,19,576]{3,2,1,0} %convolution.973, f32[250,19,19,576]{3,2,1,0} %broadcast.976) + %constant.190 = f32[576]{0} constant({...}) + %rsqrt.978 = f32[576]{0} rsqrt(f32[576]{0} %constant.190) + %reshape.979 = f32[1,1,1,576]{3,2,1,0} reshape(f32[576]{0} %rsqrt.978) + %constant.189 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %multiply.980 = f32[1,1,1,576]{3,2,1,0} multiply(f32[1,1,1,576]{3,2,1,0} %reshape.979, f32[1,1,1,576]{3,2,1,0} %constant.189) + %broadcast.981 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %multiply.980), dimensions={0,1,2,3} + %reshape.982 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.981) + %broadcast.983 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.982), dimensions={3} + %multiply.984 = f32[250,19,19,576]{3,2,1,0} multiply(f32[250,19,19,576]{3,2,1,0} %subtract.977, f32[250,19,19,576]{3,2,1,0} %broadcast.983) + %constant.188 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %broadcast.985 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %constant.188), dimensions={0,1,2,3} + %reshape.986 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.985) + %broadcast.987 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.986), dimensions={3} + %add.988 = f32[250,19,19,576]{3,2,1,0} add(f32[250,19,19,576]{3,2,1,0} %multiply.984, f32[250,19,19,576]{3,2,1,0} %broadcast.987) + %call.997 = f32[250,19,19,576]{3,2,1,0} call(f32[250,19,19,576]{3,2,1,0} %add.988), to_apply=%jit_relu6_17.989 + %constant.345 = f32[3,3,1,576]{3,2,1,0} constant({...}) + %convolution.998 = f32[250,19,19,576]{3,2,1,0} convolution(f32[250,19,19,576]{3,2,1,0} %call.997, f32[3,3,1,576]{3,2,1,0} %constant.345), window={size=3x3 pad=1_1x1_1}, dim_labels=b01f_01io->b01f, feature_group_count=576 + %constant.187 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %broadcast.999 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %constant.187), dimensions={0,1,2,3} + %reshape.1000 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.999) + %broadcast.1001 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.1000), dimensions={3} + %subtract.1002 = f32[250,19,19,576]{3,2,1,0} subtract(f32[250,19,19,576]{3,2,1,0} %convolution.998, f32[250,19,19,576]{3,2,1,0} %broadcast.1001) + %constant.186 = f32[576]{0} constant({...}) + %rsqrt.1003 = f32[576]{0} rsqrt(f32[576]{0} %constant.186) + %reshape.1004 = f32[1,1,1,576]{3,2,1,0} reshape(f32[576]{0} %rsqrt.1003) + %constant.185 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %multiply.1005 = f32[1,1,1,576]{3,2,1,0} multiply(f32[1,1,1,576]{3,2,1,0} %reshape.1004, f32[1,1,1,576]{3,2,1,0} %constant.185) + %broadcast.1006 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %multiply.1005), dimensions={0,1,2,3} + %reshape.1007 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.1006) + %broadcast.1008 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.1007), dimensions={3} + %multiply.1009 = f32[250,19,19,576]{3,2,1,0} multiply(f32[250,19,19,576]{3,2,1,0} %subtract.1002, f32[250,19,19,576]{3,2,1,0} %broadcast.1008) + %constant.184 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %broadcast.1010 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %constant.184), dimensions={0,1,2,3} + %reshape.1011 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.1010) + %broadcast.1012 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.1011), dimensions={3} + %add.1013 = f32[250,19,19,576]{3,2,1,0} add(f32[250,19,19,576]{3,2,1,0} %multiply.1009, f32[250,19,19,576]{3,2,1,0} %broadcast.1012) + %call.1022 = f32[250,19,19,576]{3,2,1,0} call(f32[250,19,19,576]{3,2,1,0} %add.1013), to_apply=%jit_relu6_18.1014 + %constant.344 = f32[1,1,576,96]{3,2,1,0} constant({...}) + %convolution.1023 = f32[250,19,19,96]{3,2,1,0} convolution(f32[250,19,19,576]{3,2,1,0} %call.1022, f32[1,1,576,96]{3,2,1,0} %constant.344), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.183 = f32[1,1,1,96]{3,2,1,0} constant({...}) + %broadcast.1024 = f32[1,1,1,96]{3,2,1,0} broadcast(f32[1,1,1,96]{3,2,1,0} %constant.183), dimensions={0,1,2,3} + %reshape.1025 = f32[96]{0} reshape(f32[1,1,1,96]{3,2,1,0} %broadcast.1024) + %broadcast.1026 = f32[250,19,19,96]{3,2,1,0} broadcast(f32[96]{0} %reshape.1025), dimensions={3} + %subtract.1027 = f32[250,19,19,96]{3,2,1,0} subtract(f32[250,19,19,96]{3,2,1,0} %convolution.1023, f32[250,19,19,96]{3,2,1,0} %broadcast.1026) + %constant.182 = f32[96]{0} constant({...}) + %rsqrt.1028 = f32[96]{0} rsqrt(f32[96]{0} %constant.182) + %reshape.1029 = f32[1,1,1,96]{3,2,1,0} reshape(f32[96]{0} %rsqrt.1028) + %constant.181 = f32[1,1,1,96]{3,2,1,0} constant({...}) + %multiply.1030 = f32[1,1,1,96]{3,2,1,0} multiply(f32[1,1,1,96]{3,2,1,0} %reshape.1029, f32[1,1,1,96]{3,2,1,0} %constant.181) + %broadcast.1031 = f32[1,1,1,96]{3,2,1,0} broadcast(f32[1,1,1,96]{3,2,1,0} %multiply.1030), dimensions={0,1,2,3} + %reshape.1032 = f32[96]{0} reshape(f32[1,1,1,96]{3,2,1,0} %broadcast.1031) + %broadcast.1033 = f32[250,19,19,96]{3,2,1,0} broadcast(f32[96]{0} %reshape.1032), dimensions={3} + %multiply.1034 = f32[250,19,19,96]{3,2,1,0} multiply(f32[250,19,19,96]{3,2,1,0} %subtract.1027, f32[250,19,19,96]{3,2,1,0} %broadcast.1033) + %constant.180 = f32[1,1,1,96]{3,2,1,0} constant({...}) + %broadcast.1035 = f32[1,1,1,96]{3,2,1,0} broadcast(f32[1,1,1,96]{3,2,1,0} %constant.180), dimensions={0,1,2,3} + %reshape.1036 = f32[96]{0} reshape(f32[1,1,1,96]{3,2,1,0} %broadcast.1035) + %broadcast.1037 = f32[250,19,19,96]{3,2,1,0} broadcast(f32[96]{0} %reshape.1036), dimensions={3} + %add.1038 = f32[250,19,19,96]{3,2,1,0} add(f32[250,19,19,96]{3,2,1,0} %multiply.1034, f32[250,19,19,96]{3,2,1,0} %broadcast.1037) + %add.1039 = f32[250,19,19,96]{3,2,1,0} add(f32[250,19,19,96]{3,2,1,0} %add.1038, f32[250,19,19,96]{3,2,1,0} %add.972) + %constant.343 = f32[1,1,96,576]{3,2,1,0} constant({...}) + %convolution.1040 = f32[250,19,19,576]{3,2,1,0} convolution(f32[250,19,19,96]{3,2,1,0} %add.1039, f32[1,1,96,576]{3,2,1,0} %constant.343), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.179 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %broadcast.1041 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %constant.179), dimensions={0,1,2,3} + %reshape.1042 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.1041) + %broadcast.1043 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.1042), dimensions={3} + %subtract.1044 = f32[250,19,19,576]{3,2,1,0} subtract(f32[250,19,19,576]{3,2,1,0} %convolution.1040, f32[250,19,19,576]{3,2,1,0} %broadcast.1043) + %constant.178 = f32[576]{0} constant({...}) + %rsqrt.1045 = f32[576]{0} rsqrt(f32[576]{0} %constant.178) + %reshape.1046 = f32[1,1,1,576]{3,2,1,0} reshape(f32[576]{0} %rsqrt.1045) + %constant.177 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %multiply.1047 = f32[1,1,1,576]{3,2,1,0} multiply(f32[1,1,1,576]{3,2,1,0} %reshape.1046, f32[1,1,1,576]{3,2,1,0} %constant.177) + %broadcast.1048 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %multiply.1047), dimensions={0,1,2,3} + %reshape.1049 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.1048) + %broadcast.1050 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.1049), dimensions={3} + %multiply.1051 = f32[250,19,19,576]{3,2,1,0} multiply(f32[250,19,19,576]{3,2,1,0} %subtract.1044, f32[250,19,19,576]{3,2,1,0} %broadcast.1050) + %constant.176 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %broadcast.1052 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %constant.176), dimensions={0,1,2,3} + %reshape.1053 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.1052) + %broadcast.1054 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.1053), dimensions={3} + %add.1055 = f32[250,19,19,576]{3,2,1,0} add(f32[250,19,19,576]{3,2,1,0} %multiply.1051, f32[250,19,19,576]{3,2,1,0} %broadcast.1054) + %call.1064 = f32[250,19,19,576]{3,2,1,0} call(f32[250,19,19,576]{3,2,1,0} %add.1055), to_apply=%jit_relu6_19.1056 + %constant.342 = f32[3,3,1,576]{3,2,1,0} constant({...}) + %convolution.1065 = f32[250,19,19,576]{3,2,1,0} convolution(f32[250,19,19,576]{3,2,1,0} %call.1064, f32[3,3,1,576]{3,2,1,0} %constant.342), window={size=3x3 pad=1_1x1_1}, dim_labels=b01f_01io->b01f, feature_group_count=576 + %constant.175 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %broadcast.1066 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %constant.175), dimensions={0,1,2,3} + %reshape.1067 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.1066) + %broadcast.1068 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.1067), dimensions={3} + %subtract.1069 = f32[250,19,19,576]{3,2,1,0} subtract(f32[250,19,19,576]{3,2,1,0} %convolution.1065, f32[250,19,19,576]{3,2,1,0} %broadcast.1068) + %constant.174 = f32[576]{0} constant({...}) + %rsqrt.1070 = f32[576]{0} rsqrt(f32[576]{0} %constant.174) + %reshape.1071 = f32[1,1,1,576]{3,2,1,0} reshape(f32[576]{0} %rsqrt.1070) + %constant.173 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %multiply.1072 = f32[1,1,1,576]{3,2,1,0} multiply(f32[1,1,1,576]{3,2,1,0} %reshape.1071, f32[1,1,1,576]{3,2,1,0} %constant.173) + %broadcast.1073 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %multiply.1072), dimensions={0,1,2,3} + %reshape.1074 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.1073) + %broadcast.1075 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.1074), dimensions={3} + %multiply.1076 = f32[250,19,19,576]{3,2,1,0} multiply(f32[250,19,19,576]{3,2,1,0} %subtract.1069, f32[250,19,19,576]{3,2,1,0} %broadcast.1075) + %constant.172 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %broadcast.1077 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %constant.172), dimensions={0,1,2,3} + %reshape.1078 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.1077) + %broadcast.1079 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.1078), dimensions={3} + %add.1080 = f32[250,19,19,576]{3,2,1,0} add(f32[250,19,19,576]{3,2,1,0} %multiply.1076, f32[250,19,19,576]{3,2,1,0} %broadcast.1079) + %call.1089 = f32[250,19,19,576]{3,2,1,0} call(f32[250,19,19,576]{3,2,1,0} %add.1080), to_apply=%jit_relu6_20.1081 + %constant.341 = f32[1,1,576,96]{3,2,1,0} constant({...}) + %convolution.1090 = f32[250,19,19,96]{3,2,1,0} convolution(f32[250,19,19,576]{3,2,1,0} %call.1089, f32[1,1,576,96]{3,2,1,0} %constant.341), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.171 = f32[1,1,1,96]{3,2,1,0} constant({...}) + %broadcast.1091 = f32[1,1,1,96]{3,2,1,0} broadcast(f32[1,1,1,96]{3,2,1,0} %constant.171), dimensions={0,1,2,3} + %reshape.1092 = f32[96]{0} reshape(f32[1,1,1,96]{3,2,1,0} %broadcast.1091) + %broadcast.1093 = f32[250,19,19,96]{3,2,1,0} broadcast(f32[96]{0} %reshape.1092), dimensions={3} + %subtract.1094 = f32[250,19,19,96]{3,2,1,0} subtract(f32[250,19,19,96]{3,2,1,0} %convolution.1090, f32[250,19,19,96]{3,2,1,0} %broadcast.1093) + %constant.170 = f32[96]{0} constant({...}) + %rsqrt.1095 = f32[96]{0} rsqrt(f32[96]{0} %constant.170) + %reshape.1096 = f32[1,1,1,96]{3,2,1,0} reshape(f32[96]{0} %rsqrt.1095) + %constant.169 = f32[1,1,1,96]{3,2,1,0} constant({...}) + %multiply.1097 = f32[1,1,1,96]{3,2,1,0} multiply(f32[1,1,1,96]{3,2,1,0} %reshape.1096, f32[1,1,1,96]{3,2,1,0} %constant.169) + %broadcast.1098 = f32[1,1,1,96]{3,2,1,0} broadcast(f32[1,1,1,96]{3,2,1,0} %multiply.1097), dimensions={0,1,2,3} + %reshape.1099 = f32[96]{0} reshape(f32[1,1,1,96]{3,2,1,0} %broadcast.1098) + %broadcast.1100 = f32[250,19,19,96]{3,2,1,0} broadcast(f32[96]{0} %reshape.1099), dimensions={3} + %multiply.1101 = f32[250,19,19,96]{3,2,1,0} multiply(f32[250,19,19,96]{3,2,1,0} %subtract.1094, f32[250,19,19,96]{3,2,1,0} %broadcast.1100) + %constant.168 = f32[1,1,1,96]{3,2,1,0} constant({...}) + %broadcast.1102 = f32[1,1,1,96]{3,2,1,0} broadcast(f32[1,1,1,96]{3,2,1,0} %constant.168), dimensions={0,1,2,3} + %reshape.1103 = f32[96]{0} reshape(f32[1,1,1,96]{3,2,1,0} %broadcast.1102) + %broadcast.1104 = f32[250,19,19,96]{3,2,1,0} broadcast(f32[96]{0} %reshape.1103), dimensions={3} + %add.1105 = f32[250,19,19,96]{3,2,1,0} add(f32[250,19,19,96]{3,2,1,0} %multiply.1101, f32[250,19,19,96]{3,2,1,0} %broadcast.1104) + %add.1106 = f32[250,19,19,96]{3,2,1,0} add(f32[250,19,19,96]{3,2,1,0} %add.1105, f32[250,19,19,96]{3,2,1,0} %add.1039) + %constant.340 = f32[1,1,96,576]{3,2,1,0} constant({...}) + %convolution.1107 = f32[250,19,19,576]{3,2,1,0} convolution(f32[250,19,19,96]{3,2,1,0} %add.1106, f32[1,1,96,576]{3,2,1,0} %constant.340), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.167 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %broadcast.1108 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %constant.167), dimensions={0,1,2,3} + %reshape.1109 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.1108) + %broadcast.1110 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.1109), dimensions={3} + %subtract.1111 = f32[250,19,19,576]{3,2,1,0} subtract(f32[250,19,19,576]{3,2,1,0} %convolution.1107, f32[250,19,19,576]{3,2,1,0} %broadcast.1110) + %constant.166 = f32[576]{0} constant({...}) + %rsqrt.1112 = f32[576]{0} rsqrt(f32[576]{0} %constant.166) + %reshape.1113 = f32[1,1,1,576]{3,2,1,0} reshape(f32[576]{0} %rsqrt.1112) + %constant.165 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %multiply.1114 = f32[1,1,1,576]{3,2,1,0} multiply(f32[1,1,1,576]{3,2,1,0} %reshape.1113, f32[1,1,1,576]{3,2,1,0} %constant.165) + %broadcast.1115 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %multiply.1114), dimensions={0,1,2,3} + %reshape.1116 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.1115) + %broadcast.1117 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.1116), dimensions={3} + %multiply.1118 = f32[250,19,19,576]{3,2,1,0} multiply(f32[250,19,19,576]{3,2,1,0} %subtract.1111, f32[250,19,19,576]{3,2,1,0} %broadcast.1117) + %constant.164 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %broadcast.1119 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %constant.164), dimensions={0,1,2,3} + %reshape.1120 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.1119) + %broadcast.1121 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.1120), dimensions={3} + %add.1122 = f32[250,19,19,576]{3,2,1,0} add(f32[250,19,19,576]{3,2,1,0} %multiply.1118, f32[250,19,19,576]{3,2,1,0} %broadcast.1121) + %call.1131 = f32[250,19,19,576]{3,2,1,0} call(f32[250,19,19,576]{3,2,1,0} %add.1122), to_apply=%jit_relu6_21.1123 + %constant.339 = f32[3,3,1,576]{3,2,1,0} constant({...}) + %convolution.1132 = f32[250,19,19,576]{3,2,1,0} convolution(f32[250,19,19,576]{3,2,1,0} %call.1131, f32[3,3,1,576]{3,2,1,0} %constant.339), window={size=3x3 pad=1_1x1_1}, dim_labels=b01f_01io->b01f, feature_group_count=576 + %constant.163 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %broadcast.1133 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %constant.163), dimensions={0,1,2,3} + %reshape.1134 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.1133) + %broadcast.1135 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.1134), dimensions={3} + %subtract.1136 = f32[250,19,19,576]{3,2,1,0} subtract(f32[250,19,19,576]{3,2,1,0} %convolution.1132, f32[250,19,19,576]{3,2,1,0} %broadcast.1135) + %constant.162 = f32[576]{0} constant({...}) + %rsqrt.1137 = f32[576]{0} rsqrt(f32[576]{0} %constant.162) + %reshape.1138 = f32[1,1,1,576]{3,2,1,0} reshape(f32[576]{0} %rsqrt.1137) + %constant.161 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %multiply.1139 = f32[1,1,1,576]{3,2,1,0} multiply(f32[1,1,1,576]{3,2,1,0} %reshape.1138, f32[1,1,1,576]{3,2,1,0} %constant.161) + %broadcast.1140 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %multiply.1139), dimensions={0,1,2,3} + %reshape.1141 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.1140) + %broadcast.1142 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.1141), dimensions={3} + %multiply.1143 = f32[250,19,19,576]{3,2,1,0} multiply(f32[250,19,19,576]{3,2,1,0} %subtract.1136, f32[250,19,19,576]{3,2,1,0} %broadcast.1142) + %constant.160 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %broadcast.1144 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %constant.160), dimensions={0,1,2,3} + %reshape.1145 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.1144) + %broadcast.1146 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.1145), dimensions={3} + %add.1147 = f32[250,19,19,576]{3,2,1,0} add(f32[250,19,19,576]{3,2,1,0} %multiply.1143, f32[250,19,19,576]{3,2,1,0} %broadcast.1146) + %call.1156 = f32[250,19,19,576]{3,2,1,0} call(f32[250,19,19,576]{3,2,1,0} %add.1147), to_apply=%jit_relu6_22.1148 + %constant.338 = f32[1,1,576,96]{3,2,1,0} constant({...}) + %convolution.1157 = f32[250,19,19,96]{3,2,1,0} convolution(f32[250,19,19,576]{3,2,1,0} %call.1156, f32[1,1,576,96]{3,2,1,0} %constant.338), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.159 = f32[1,1,1,96]{3,2,1,0} constant({...}) + %broadcast.1158 = f32[1,1,1,96]{3,2,1,0} broadcast(f32[1,1,1,96]{3,2,1,0} %constant.159), dimensions={0,1,2,3} + %reshape.1159 = f32[96]{0} reshape(f32[1,1,1,96]{3,2,1,0} %broadcast.1158) + %broadcast.1160 = f32[250,19,19,96]{3,2,1,0} broadcast(f32[96]{0} %reshape.1159), dimensions={3} + %subtract.1161 = f32[250,19,19,96]{3,2,1,0} subtract(f32[250,19,19,96]{3,2,1,0} %convolution.1157, f32[250,19,19,96]{3,2,1,0} %broadcast.1160) + %constant.158 = f32[96]{0} constant({...}) + %rsqrt.1162 = f32[96]{0} rsqrt(f32[96]{0} %constant.158) + %reshape.1163 = f32[1,1,1,96]{3,2,1,0} reshape(f32[96]{0} %rsqrt.1162) + %constant.157 = f32[1,1,1,96]{3,2,1,0} constant({...}) + %multiply.1164 = f32[1,1,1,96]{3,2,1,0} multiply(f32[1,1,1,96]{3,2,1,0} %reshape.1163, f32[1,1,1,96]{3,2,1,0} %constant.157) + %broadcast.1165 = f32[1,1,1,96]{3,2,1,0} broadcast(f32[1,1,1,96]{3,2,1,0} %multiply.1164), dimensions={0,1,2,3} + %reshape.1166 = f32[96]{0} reshape(f32[1,1,1,96]{3,2,1,0} %broadcast.1165) + %broadcast.1167 = f32[250,19,19,96]{3,2,1,0} broadcast(f32[96]{0} %reshape.1166), dimensions={3} + %multiply.1168 = f32[250,19,19,96]{3,2,1,0} multiply(f32[250,19,19,96]{3,2,1,0} %subtract.1161, f32[250,19,19,96]{3,2,1,0} %broadcast.1167) + %constant.156 = f32[1,1,1,96]{3,2,1,0} constant({...}) + %broadcast.1169 = f32[1,1,1,96]{3,2,1,0} broadcast(f32[1,1,1,96]{3,2,1,0} %constant.156), dimensions={0,1,2,3} + %reshape.1170 = f32[96]{0} reshape(f32[1,1,1,96]{3,2,1,0} %broadcast.1169) + %broadcast.1171 = f32[250,19,19,96]{3,2,1,0} broadcast(f32[96]{0} %reshape.1170), dimensions={3} + %add.1172 = f32[250,19,19,96]{3,2,1,0} add(f32[250,19,19,96]{3,2,1,0} %multiply.1168, f32[250,19,19,96]{3,2,1,0} %broadcast.1171) + %add.1173 = f32[250,19,19,96]{3,2,1,0} add(f32[250,19,19,96]{3,2,1,0} %add.1172, f32[250,19,19,96]{3,2,1,0} %add.1106) + %constant.337 = f32[1,1,96,576]{3,2,1,0} constant({...}) + %convolution.1174 = f32[250,19,19,576]{3,2,1,0} convolution(f32[250,19,19,96]{3,2,1,0} %add.1173, f32[1,1,96,576]{3,2,1,0} %constant.337), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.155 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %broadcast.1175 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %constant.155), dimensions={0,1,2,3} + %reshape.1176 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.1175) + %broadcast.1177 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.1176), dimensions={3} + %subtract.1178 = f32[250,19,19,576]{3,2,1,0} subtract(f32[250,19,19,576]{3,2,1,0} %convolution.1174, f32[250,19,19,576]{3,2,1,0} %broadcast.1177) + %constant.154 = f32[576]{0} constant({...}) + %rsqrt.1179 = f32[576]{0} rsqrt(f32[576]{0} %constant.154) + %reshape.1180 = f32[1,1,1,576]{3,2,1,0} reshape(f32[576]{0} %rsqrt.1179) + %constant.153 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %multiply.1181 = f32[1,1,1,576]{3,2,1,0} multiply(f32[1,1,1,576]{3,2,1,0} %reshape.1180, f32[1,1,1,576]{3,2,1,0} %constant.153) + %broadcast.1182 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %multiply.1181), dimensions={0,1,2,3} + %reshape.1183 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.1182) + %broadcast.1184 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.1183), dimensions={3} + %multiply.1185 = f32[250,19,19,576]{3,2,1,0} multiply(f32[250,19,19,576]{3,2,1,0} %subtract.1178, f32[250,19,19,576]{3,2,1,0} %broadcast.1184) + %constant.152 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %broadcast.1186 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %constant.152), dimensions={0,1,2,3} + %reshape.1187 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.1186) + %broadcast.1188 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.1187), dimensions={3} + %add.1189 = f32[250,19,19,576]{3,2,1,0} add(f32[250,19,19,576]{3,2,1,0} %multiply.1185, f32[250,19,19,576]{3,2,1,0} %broadcast.1188) + %call.1198 = f32[250,19,19,576]{3,2,1,0} call(f32[250,19,19,576]{3,2,1,0} %add.1189), to_apply=%jit_relu6_23.1190 + %constant.336 = f32[5,5,1,576]{3,2,1,0} constant({...}) + %convolution.1199 = f32[250,19,19,576]{3,2,1,0} convolution(f32[250,19,19,576]{3,2,1,0} %call.1198, f32[5,5,1,576]{3,2,1,0} %constant.336), window={size=5x5 pad=2_2x2_2}, dim_labels=b01f_01io->b01f, feature_group_count=576 + %constant.151 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %broadcast.1200 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %constant.151), dimensions={0,1,2,3} + %reshape.1201 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.1200) + %broadcast.1202 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.1201), dimensions={3} + %subtract.1203 = f32[250,19,19,576]{3,2,1,0} subtract(f32[250,19,19,576]{3,2,1,0} %convolution.1199, f32[250,19,19,576]{3,2,1,0} %broadcast.1202) + %constant.150 = f32[576]{0} constant({...}) + %rsqrt.1204 = f32[576]{0} rsqrt(f32[576]{0} %constant.150) + %reshape.1205 = f32[1,1,1,576]{3,2,1,0} reshape(f32[576]{0} %rsqrt.1204) + %constant.149 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %multiply.1206 = f32[1,1,1,576]{3,2,1,0} multiply(f32[1,1,1,576]{3,2,1,0} %reshape.1205, f32[1,1,1,576]{3,2,1,0} %constant.149) + %broadcast.1207 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %multiply.1206), dimensions={0,1,2,3} + %reshape.1208 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.1207) + %broadcast.1209 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.1208), dimensions={3} + %multiply.1210 = f32[250,19,19,576]{3,2,1,0} multiply(f32[250,19,19,576]{3,2,1,0} %subtract.1203, f32[250,19,19,576]{3,2,1,0} %broadcast.1209) + %constant.148 = f32[1,1,1,576]{3,2,1,0} constant({...}) + %broadcast.1211 = f32[1,1,1,576]{3,2,1,0} broadcast(f32[1,1,1,576]{3,2,1,0} %constant.148), dimensions={0,1,2,3} + %reshape.1212 = f32[576]{0} reshape(f32[1,1,1,576]{3,2,1,0} %broadcast.1211) + %broadcast.1213 = f32[250,19,19,576]{3,2,1,0} broadcast(f32[576]{0} %reshape.1212), dimensions={3} + %add.1214 = f32[250,19,19,576]{3,2,1,0} add(f32[250,19,19,576]{3,2,1,0} %multiply.1210, f32[250,19,19,576]{3,2,1,0} %broadcast.1213) + %call.1223 = f32[250,19,19,576]{3,2,1,0} call(f32[250,19,19,576]{3,2,1,0} %add.1214), to_apply=%jit_relu6_24.1215 + %constant.335 = f32[1,1,576,136]{3,2,1,0} constant({...}) + %convolution.1224 = f32[250,19,19,136]{3,2,1,0} convolution(f32[250,19,19,576]{3,2,1,0} %call.1223, f32[1,1,576,136]{3,2,1,0} %constant.335), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.147 = f32[1,1,1,136]{3,2,1,0} constant({...}) + %broadcast.1225 = f32[1,1,1,136]{3,2,1,0} broadcast(f32[1,1,1,136]{3,2,1,0} %constant.147), dimensions={0,1,2,3} + %reshape.1226 = f32[136]{0} reshape(f32[1,1,1,136]{3,2,1,0} %broadcast.1225) + %broadcast.1227 = f32[250,19,19,136]{3,2,1,0} broadcast(f32[136]{0} %reshape.1226), dimensions={3} + %subtract.1228 = f32[250,19,19,136]{3,2,1,0} subtract(f32[250,19,19,136]{3,2,1,0} %convolution.1224, f32[250,19,19,136]{3,2,1,0} %broadcast.1227) + %constant.146 = f32[136]{0} constant({...}) + %rsqrt.1229 = f32[136]{0} rsqrt(f32[136]{0} %constant.146) + %reshape.1230 = f32[1,1,1,136]{3,2,1,0} reshape(f32[136]{0} %rsqrt.1229) + %constant.145 = f32[1,1,1,136]{3,2,1,0} constant({...}) + %multiply.1231 = f32[1,1,1,136]{3,2,1,0} multiply(f32[1,1,1,136]{3,2,1,0} %reshape.1230, f32[1,1,1,136]{3,2,1,0} %constant.145) + %broadcast.1232 = f32[1,1,1,136]{3,2,1,0} broadcast(f32[1,1,1,136]{3,2,1,0} %multiply.1231), dimensions={0,1,2,3} + %reshape.1233 = f32[136]{0} reshape(f32[1,1,1,136]{3,2,1,0} %broadcast.1232) + %broadcast.1234 = f32[250,19,19,136]{3,2,1,0} broadcast(f32[136]{0} %reshape.1233), dimensions={3} + %multiply.1235 = f32[250,19,19,136]{3,2,1,0} multiply(f32[250,19,19,136]{3,2,1,0} %subtract.1228, f32[250,19,19,136]{3,2,1,0} %broadcast.1234) + %constant.144 = f32[1,1,1,136]{3,2,1,0} constant({...}) + %broadcast.1236 = f32[1,1,1,136]{3,2,1,0} broadcast(f32[1,1,1,136]{3,2,1,0} %constant.144), dimensions={0,1,2,3} + %reshape.1237 = f32[136]{0} reshape(f32[1,1,1,136]{3,2,1,0} %broadcast.1236) + %broadcast.1238 = f32[250,19,19,136]{3,2,1,0} broadcast(f32[136]{0} %reshape.1237), dimensions={3} + %add.1239 = f32[250,19,19,136]{3,2,1,0} add(f32[250,19,19,136]{3,2,1,0} %multiply.1235, f32[250,19,19,136]{3,2,1,0} %broadcast.1238) + %constant.334 = f32[1,1,136,816]{3,2,1,0} constant({...}) + %convolution.1240 = f32[250,19,19,816]{3,2,1,0} convolution(f32[250,19,19,136]{3,2,1,0} %add.1239, f32[1,1,136,816]{3,2,1,0} %constant.334), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.143 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %broadcast.1241 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %constant.143), dimensions={0,1,2,3} + %reshape.1242 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1241) + %broadcast.1243 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1242), dimensions={3} + %subtract.1244 = f32[250,19,19,816]{3,2,1,0} subtract(f32[250,19,19,816]{3,2,1,0} %convolution.1240, f32[250,19,19,816]{3,2,1,0} %broadcast.1243) + %constant.142 = f32[816]{0} constant({...}) + %rsqrt.1245 = f32[816]{0} rsqrt(f32[816]{0} %constant.142) + %reshape.1246 = f32[1,1,1,816]{3,2,1,0} reshape(f32[816]{0} %rsqrt.1245) + %constant.141 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %multiply.1247 = f32[1,1,1,816]{3,2,1,0} multiply(f32[1,1,1,816]{3,2,1,0} %reshape.1246, f32[1,1,1,816]{3,2,1,0} %constant.141) + %broadcast.1248 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %multiply.1247), dimensions={0,1,2,3} + %reshape.1249 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1248) + %broadcast.1250 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1249), dimensions={3} + %multiply.1251 = f32[250,19,19,816]{3,2,1,0} multiply(f32[250,19,19,816]{3,2,1,0} %subtract.1244, f32[250,19,19,816]{3,2,1,0} %broadcast.1250) + %constant.140 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %broadcast.1252 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %constant.140), dimensions={0,1,2,3} + %reshape.1253 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1252) + %broadcast.1254 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1253), dimensions={3} + %add.1255 = f32[250,19,19,816]{3,2,1,0} add(f32[250,19,19,816]{3,2,1,0} %multiply.1251, f32[250,19,19,816]{3,2,1,0} %broadcast.1254) + %call.1264 = f32[250,19,19,816]{3,2,1,0} call(f32[250,19,19,816]{3,2,1,0} %add.1255), to_apply=%jit_relu6_25.1256 + %constant.333 = f32[5,5,1,816]{3,2,1,0} constant({...}) + %convolution.1265 = f32[250,19,19,816]{3,2,1,0} convolution(f32[250,19,19,816]{3,2,1,0} %call.1264, f32[5,5,1,816]{3,2,1,0} %constant.333), window={size=5x5 pad=2_2x2_2}, dim_labels=b01f_01io->b01f, feature_group_count=816 + %constant.139 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %broadcast.1266 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %constant.139), dimensions={0,1,2,3} + %reshape.1267 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1266) + %broadcast.1268 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1267), dimensions={3} + %subtract.1269 = f32[250,19,19,816]{3,2,1,0} subtract(f32[250,19,19,816]{3,2,1,0} %convolution.1265, f32[250,19,19,816]{3,2,1,0} %broadcast.1268) + %constant.138 = f32[816]{0} constant({...}) + %rsqrt.1270 = f32[816]{0} rsqrt(f32[816]{0} %constant.138) + %reshape.1271 = f32[1,1,1,816]{3,2,1,0} reshape(f32[816]{0} %rsqrt.1270) + %constant.137 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %multiply.1272 = f32[1,1,1,816]{3,2,1,0} multiply(f32[1,1,1,816]{3,2,1,0} %reshape.1271, f32[1,1,1,816]{3,2,1,0} %constant.137) + %broadcast.1273 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %multiply.1272), dimensions={0,1,2,3} + %reshape.1274 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1273) + %broadcast.1275 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1274), dimensions={3} + %multiply.1276 = f32[250,19,19,816]{3,2,1,0} multiply(f32[250,19,19,816]{3,2,1,0} %subtract.1269, f32[250,19,19,816]{3,2,1,0} %broadcast.1275) + %constant.136 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %broadcast.1277 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %constant.136), dimensions={0,1,2,3} + %reshape.1278 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1277) + %broadcast.1279 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1278), dimensions={3} + %add.1280 = f32[250,19,19,816]{3,2,1,0} add(f32[250,19,19,816]{3,2,1,0} %multiply.1276, f32[250,19,19,816]{3,2,1,0} %broadcast.1279) + %call.1289 = f32[250,19,19,816]{3,2,1,0} call(f32[250,19,19,816]{3,2,1,0} %add.1280), to_apply=%jit_relu6_26.1281 + %constant.332 = f32[1,1,816,136]{3,2,1,0} constant({...}) + %convolution.1290 = f32[250,19,19,136]{3,2,1,0} convolution(f32[250,19,19,816]{3,2,1,0} %call.1289, f32[1,1,816,136]{3,2,1,0} %constant.332), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.135 = f32[1,1,1,136]{3,2,1,0} constant({...}) + %broadcast.1291 = f32[1,1,1,136]{3,2,1,0} broadcast(f32[1,1,1,136]{3,2,1,0} %constant.135), dimensions={0,1,2,3} + %reshape.1292 = f32[136]{0} reshape(f32[1,1,1,136]{3,2,1,0} %broadcast.1291) + %broadcast.1293 = f32[250,19,19,136]{3,2,1,0} broadcast(f32[136]{0} %reshape.1292), dimensions={3} + %subtract.1294 = f32[250,19,19,136]{3,2,1,0} subtract(f32[250,19,19,136]{3,2,1,0} %convolution.1290, f32[250,19,19,136]{3,2,1,0} %broadcast.1293) + %constant.134 = f32[136]{0} constant({...}) + %rsqrt.1295 = f32[136]{0} rsqrt(f32[136]{0} %constant.134) + %reshape.1296 = f32[1,1,1,136]{3,2,1,0} reshape(f32[136]{0} %rsqrt.1295) + %constant.133 = f32[1,1,1,136]{3,2,1,0} constant({...}) + %multiply.1297 = f32[1,1,1,136]{3,2,1,0} multiply(f32[1,1,1,136]{3,2,1,0} %reshape.1296, f32[1,1,1,136]{3,2,1,0} %constant.133) + %broadcast.1298 = f32[1,1,1,136]{3,2,1,0} broadcast(f32[1,1,1,136]{3,2,1,0} %multiply.1297), dimensions={0,1,2,3} + %reshape.1299 = f32[136]{0} reshape(f32[1,1,1,136]{3,2,1,0} %broadcast.1298) + %broadcast.1300 = f32[250,19,19,136]{3,2,1,0} broadcast(f32[136]{0} %reshape.1299), dimensions={3} + %multiply.1301 = f32[250,19,19,136]{3,2,1,0} multiply(f32[250,19,19,136]{3,2,1,0} %subtract.1294, f32[250,19,19,136]{3,2,1,0} %broadcast.1300) + %constant.132 = f32[1,1,1,136]{3,2,1,0} constant({...}) + %broadcast.1302 = f32[1,1,1,136]{3,2,1,0} broadcast(f32[1,1,1,136]{3,2,1,0} %constant.132), dimensions={0,1,2,3} + %reshape.1303 = f32[136]{0} reshape(f32[1,1,1,136]{3,2,1,0} %broadcast.1302) + %broadcast.1304 = f32[250,19,19,136]{3,2,1,0} broadcast(f32[136]{0} %reshape.1303), dimensions={3} + %add.1305 = f32[250,19,19,136]{3,2,1,0} add(f32[250,19,19,136]{3,2,1,0} %multiply.1301, f32[250,19,19,136]{3,2,1,0} %broadcast.1304) + %add.1306 = f32[250,19,19,136]{3,2,1,0} add(f32[250,19,19,136]{3,2,1,0} %add.1305, f32[250,19,19,136]{3,2,1,0} %add.1239) + %constant.331 = f32[1,1,136,816]{3,2,1,0} constant({...}) + %convolution.1307 = f32[250,19,19,816]{3,2,1,0} convolution(f32[250,19,19,136]{3,2,1,0} %add.1306, f32[1,1,136,816]{3,2,1,0} %constant.331), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.131 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %broadcast.1308 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %constant.131), dimensions={0,1,2,3} + %reshape.1309 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1308) + %broadcast.1310 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1309), dimensions={3} + %subtract.1311 = f32[250,19,19,816]{3,2,1,0} subtract(f32[250,19,19,816]{3,2,1,0} %convolution.1307, f32[250,19,19,816]{3,2,1,0} %broadcast.1310) + %constant.130 = f32[816]{0} constant({...}) + %rsqrt.1312 = f32[816]{0} rsqrt(f32[816]{0} %constant.130) + %reshape.1313 = f32[1,1,1,816]{3,2,1,0} reshape(f32[816]{0} %rsqrt.1312) + %constant.129 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %multiply.1314 = f32[1,1,1,816]{3,2,1,0} multiply(f32[1,1,1,816]{3,2,1,0} %reshape.1313, f32[1,1,1,816]{3,2,1,0} %constant.129) + %broadcast.1315 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %multiply.1314), dimensions={0,1,2,3} + %reshape.1316 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1315) + %broadcast.1317 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1316), dimensions={3} + %multiply.1318 = f32[250,19,19,816]{3,2,1,0} multiply(f32[250,19,19,816]{3,2,1,0} %subtract.1311, f32[250,19,19,816]{3,2,1,0} %broadcast.1317) + %constant.128 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %broadcast.1319 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %constant.128), dimensions={0,1,2,3} + %reshape.1320 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1319) + %broadcast.1321 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1320), dimensions={3} + %add.1322 = f32[250,19,19,816]{3,2,1,0} add(f32[250,19,19,816]{3,2,1,0} %multiply.1318, f32[250,19,19,816]{3,2,1,0} %broadcast.1321) + %call.1331 = f32[250,19,19,816]{3,2,1,0} call(f32[250,19,19,816]{3,2,1,0} %add.1322), to_apply=%jit_relu6_27.1323 + %constant.330 = f32[5,5,1,816]{3,2,1,0} constant({...}) + %convolution.1332 = f32[250,19,19,816]{3,2,1,0} convolution(f32[250,19,19,816]{3,2,1,0} %call.1331, f32[5,5,1,816]{3,2,1,0} %constant.330), window={size=5x5 pad=2_2x2_2}, dim_labels=b01f_01io->b01f, feature_group_count=816 + %constant.127 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %broadcast.1333 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %constant.127), dimensions={0,1,2,3} + %reshape.1334 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1333) + %broadcast.1335 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1334), dimensions={3} + %subtract.1336 = f32[250,19,19,816]{3,2,1,0} subtract(f32[250,19,19,816]{3,2,1,0} %convolution.1332, f32[250,19,19,816]{3,2,1,0} %broadcast.1335) + %constant.126 = f32[816]{0} constant({...}) + %rsqrt.1337 = f32[816]{0} rsqrt(f32[816]{0} %constant.126) + %reshape.1338 = f32[1,1,1,816]{3,2,1,0} reshape(f32[816]{0} %rsqrt.1337) + %constant.125 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %multiply.1339 = f32[1,1,1,816]{3,2,1,0} multiply(f32[1,1,1,816]{3,2,1,0} %reshape.1338, f32[1,1,1,816]{3,2,1,0} %constant.125) + %broadcast.1340 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %multiply.1339), dimensions={0,1,2,3} + %reshape.1341 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1340) + %broadcast.1342 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1341), dimensions={3} + %multiply.1343 = f32[250,19,19,816]{3,2,1,0} multiply(f32[250,19,19,816]{3,2,1,0} %subtract.1336, f32[250,19,19,816]{3,2,1,0} %broadcast.1342) + %constant.124 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %broadcast.1344 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %constant.124), dimensions={0,1,2,3} + %reshape.1345 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1344) + %broadcast.1346 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1345), dimensions={3} + %add.1347 = f32[250,19,19,816]{3,2,1,0} add(f32[250,19,19,816]{3,2,1,0} %multiply.1343, f32[250,19,19,816]{3,2,1,0} %broadcast.1346) + %call.1356 = f32[250,19,19,816]{3,2,1,0} call(f32[250,19,19,816]{3,2,1,0} %add.1347), to_apply=%jit_relu6_28.1348 + %constant.329 = f32[1,1,816,136]{3,2,1,0} constant({...}) + %convolution.1357 = f32[250,19,19,136]{3,2,1,0} convolution(f32[250,19,19,816]{3,2,1,0} %call.1356, f32[1,1,816,136]{3,2,1,0} %constant.329), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.123 = f32[1,1,1,136]{3,2,1,0} constant({...}) + %broadcast.1358 = f32[1,1,1,136]{3,2,1,0} broadcast(f32[1,1,1,136]{3,2,1,0} %constant.123), dimensions={0,1,2,3} + %reshape.1359 = f32[136]{0} reshape(f32[1,1,1,136]{3,2,1,0} %broadcast.1358) + %broadcast.1360 = f32[250,19,19,136]{3,2,1,0} broadcast(f32[136]{0} %reshape.1359), dimensions={3} + %subtract.1361 = f32[250,19,19,136]{3,2,1,0} subtract(f32[250,19,19,136]{3,2,1,0} %convolution.1357, f32[250,19,19,136]{3,2,1,0} %broadcast.1360) + %constant.122 = f32[136]{0} constant({...}) + %rsqrt.1362 = f32[136]{0} rsqrt(f32[136]{0} %constant.122) + %reshape.1363 = f32[1,1,1,136]{3,2,1,0} reshape(f32[136]{0} %rsqrt.1362) + %constant.121 = f32[1,1,1,136]{3,2,1,0} constant({...}) + %multiply.1364 = f32[1,1,1,136]{3,2,1,0} multiply(f32[1,1,1,136]{3,2,1,0} %reshape.1363, f32[1,1,1,136]{3,2,1,0} %constant.121) + %broadcast.1365 = f32[1,1,1,136]{3,2,1,0} broadcast(f32[1,1,1,136]{3,2,1,0} %multiply.1364), dimensions={0,1,2,3} + %reshape.1366 = f32[136]{0} reshape(f32[1,1,1,136]{3,2,1,0} %broadcast.1365) + %broadcast.1367 = f32[250,19,19,136]{3,2,1,0} broadcast(f32[136]{0} %reshape.1366), dimensions={3} + %multiply.1368 = f32[250,19,19,136]{3,2,1,0} multiply(f32[250,19,19,136]{3,2,1,0} %subtract.1361, f32[250,19,19,136]{3,2,1,0} %broadcast.1367) + %constant.120 = f32[1,1,1,136]{3,2,1,0} constant({...}) + %broadcast.1369 = f32[1,1,1,136]{3,2,1,0} broadcast(f32[1,1,1,136]{3,2,1,0} %constant.120), dimensions={0,1,2,3} + %reshape.1370 = f32[136]{0} reshape(f32[1,1,1,136]{3,2,1,0} %broadcast.1369) + %broadcast.1371 = f32[250,19,19,136]{3,2,1,0} broadcast(f32[136]{0} %reshape.1370), dimensions={3} + %add.1372 = f32[250,19,19,136]{3,2,1,0} add(f32[250,19,19,136]{3,2,1,0} %multiply.1368, f32[250,19,19,136]{3,2,1,0} %broadcast.1371) + %add.1373 = f32[250,19,19,136]{3,2,1,0} add(f32[250,19,19,136]{3,2,1,0} %add.1372, f32[250,19,19,136]{3,2,1,0} %add.1306) + %constant.328 = f32[1,1,136,816]{3,2,1,0} constant({...}) + %convolution.1374 = f32[250,19,19,816]{3,2,1,0} convolution(f32[250,19,19,136]{3,2,1,0} %add.1373, f32[1,1,136,816]{3,2,1,0} %constant.328), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.119 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %broadcast.1375 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %constant.119), dimensions={0,1,2,3} + %reshape.1376 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1375) + %broadcast.1377 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1376), dimensions={3} + %subtract.1378 = f32[250,19,19,816]{3,2,1,0} subtract(f32[250,19,19,816]{3,2,1,0} %convolution.1374, f32[250,19,19,816]{3,2,1,0} %broadcast.1377) + %constant.118 = f32[816]{0} constant({...}) + %rsqrt.1379 = f32[816]{0} rsqrt(f32[816]{0} %constant.118) + %reshape.1380 = f32[1,1,1,816]{3,2,1,0} reshape(f32[816]{0} %rsqrt.1379) + %constant.117 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %multiply.1381 = f32[1,1,1,816]{3,2,1,0} multiply(f32[1,1,1,816]{3,2,1,0} %reshape.1380, f32[1,1,1,816]{3,2,1,0} %constant.117) + %broadcast.1382 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %multiply.1381), dimensions={0,1,2,3} + %reshape.1383 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1382) + %broadcast.1384 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1383), dimensions={3} + %multiply.1385 = f32[250,19,19,816]{3,2,1,0} multiply(f32[250,19,19,816]{3,2,1,0} %subtract.1378, f32[250,19,19,816]{3,2,1,0} %broadcast.1384) + %constant.116 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %broadcast.1386 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %constant.116), dimensions={0,1,2,3} + %reshape.1387 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1386) + %broadcast.1388 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1387), dimensions={3} + %add.1389 = f32[250,19,19,816]{3,2,1,0} add(f32[250,19,19,816]{3,2,1,0} %multiply.1385, f32[250,19,19,816]{3,2,1,0} %broadcast.1388) + %call.1398 = f32[250,19,19,816]{3,2,1,0} call(f32[250,19,19,816]{3,2,1,0} %add.1389), to_apply=%jit_relu6_29.1390 + %constant.327 = f32[5,5,1,816]{3,2,1,0} constant({...}) + %convolution.1399 = f32[250,19,19,816]{3,2,1,0} convolution(f32[250,19,19,816]{3,2,1,0} %call.1398, f32[5,5,1,816]{3,2,1,0} %constant.327), window={size=5x5 pad=2_2x2_2}, dim_labels=b01f_01io->b01f, feature_group_count=816 + %constant.115 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %broadcast.1400 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %constant.115), dimensions={0,1,2,3} + %reshape.1401 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1400) + %broadcast.1402 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1401), dimensions={3} + %subtract.1403 = f32[250,19,19,816]{3,2,1,0} subtract(f32[250,19,19,816]{3,2,1,0} %convolution.1399, f32[250,19,19,816]{3,2,1,0} %broadcast.1402) + %constant.114 = f32[816]{0} constant({...}) + %rsqrt.1404 = f32[816]{0} rsqrt(f32[816]{0} %constant.114) + %reshape.1405 = f32[1,1,1,816]{3,2,1,0} reshape(f32[816]{0} %rsqrt.1404) + %constant.113 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %multiply.1406 = f32[1,1,1,816]{3,2,1,0} multiply(f32[1,1,1,816]{3,2,1,0} %reshape.1405, f32[1,1,1,816]{3,2,1,0} %constant.113) + %broadcast.1407 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %multiply.1406), dimensions={0,1,2,3} + %reshape.1408 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1407) + %broadcast.1409 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1408), dimensions={3} + %multiply.1410 = f32[250,19,19,816]{3,2,1,0} multiply(f32[250,19,19,816]{3,2,1,0} %subtract.1403, f32[250,19,19,816]{3,2,1,0} %broadcast.1409) + %constant.112 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %broadcast.1411 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %constant.112), dimensions={0,1,2,3} + %reshape.1412 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1411) + %broadcast.1413 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1412), dimensions={3} + %add.1414 = f32[250,19,19,816]{3,2,1,0} add(f32[250,19,19,816]{3,2,1,0} %multiply.1410, f32[250,19,19,816]{3,2,1,0} %broadcast.1413) + %call.1423 = f32[250,19,19,816]{3,2,1,0} call(f32[250,19,19,816]{3,2,1,0} %add.1414), to_apply=%jit_relu6_30.1415 + %constant.326 = f32[1,1,816,136]{3,2,1,0} constant({...}) + %convolution.1424 = f32[250,19,19,136]{3,2,1,0} convolution(f32[250,19,19,816]{3,2,1,0} %call.1423, f32[1,1,816,136]{3,2,1,0} %constant.326), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.111 = f32[1,1,1,136]{3,2,1,0} constant({...}) + %broadcast.1425 = f32[1,1,1,136]{3,2,1,0} broadcast(f32[1,1,1,136]{3,2,1,0} %constant.111), dimensions={0,1,2,3} + %reshape.1426 = f32[136]{0} reshape(f32[1,1,1,136]{3,2,1,0} %broadcast.1425) + %broadcast.1427 = f32[250,19,19,136]{3,2,1,0} broadcast(f32[136]{0} %reshape.1426), dimensions={3} + %subtract.1428 = f32[250,19,19,136]{3,2,1,0} subtract(f32[250,19,19,136]{3,2,1,0} %convolution.1424, f32[250,19,19,136]{3,2,1,0} %broadcast.1427) + %constant.110 = f32[136]{0} constant({...}) + %rsqrt.1429 = f32[136]{0} rsqrt(f32[136]{0} %constant.110) + %reshape.1430 = f32[1,1,1,136]{3,2,1,0} reshape(f32[136]{0} %rsqrt.1429) + %constant.109 = f32[1,1,1,136]{3,2,1,0} constant({...}) + %multiply.1431 = f32[1,1,1,136]{3,2,1,0} multiply(f32[1,1,1,136]{3,2,1,0} %reshape.1430, f32[1,1,1,136]{3,2,1,0} %constant.109) + %broadcast.1432 = f32[1,1,1,136]{3,2,1,0} broadcast(f32[1,1,1,136]{3,2,1,0} %multiply.1431), dimensions={0,1,2,3} + %reshape.1433 = f32[136]{0} reshape(f32[1,1,1,136]{3,2,1,0} %broadcast.1432) + %broadcast.1434 = f32[250,19,19,136]{3,2,1,0} broadcast(f32[136]{0} %reshape.1433), dimensions={3} + %multiply.1435 = f32[250,19,19,136]{3,2,1,0} multiply(f32[250,19,19,136]{3,2,1,0} %subtract.1428, f32[250,19,19,136]{3,2,1,0} %broadcast.1434) + %constant.108 = f32[1,1,1,136]{3,2,1,0} constant({...}) + %broadcast.1436 = f32[1,1,1,136]{3,2,1,0} broadcast(f32[1,1,1,136]{3,2,1,0} %constant.108), dimensions={0,1,2,3} + %reshape.1437 = f32[136]{0} reshape(f32[1,1,1,136]{3,2,1,0} %broadcast.1436) + %broadcast.1438 = f32[250,19,19,136]{3,2,1,0} broadcast(f32[136]{0} %reshape.1437), dimensions={3} + %add.1439 = f32[250,19,19,136]{3,2,1,0} add(f32[250,19,19,136]{3,2,1,0} %multiply.1435, f32[250,19,19,136]{3,2,1,0} %broadcast.1438) + %add.1440 = f32[250,19,19,136]{3,2,1,0} add(f32[250,19,19,136]{3,2,1,0} %add.1439, f32[250,19,19,136]{3,2,1,0} %add.1373) + %constant.325 = f32[1,1,136,816]{3,2,1,0} constant({...}) + %convolution.1441 = f32[250,19,19,816]{3,2,1,0} convolution(f32[250,19,19,136]{3,2,1,0} %add.1440, f32[1,1,136,816]{3,2,1,0} %constant.325), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.107 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %broadcast.1442 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %constant.107), dimensions={0,1,2,3} + %reshape.1443 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1442) + %broadcast.1444 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1443), dimensions={3} + %subtract.1445 = f32[250,19,19,816]{3,2,1,0} subtract(f32[250,19,19,816]{3,2,1,0} %convolution.1441, f32[250,19,19,816]{3,2,1,0} %broadcast.1444) + %constant.106 = f32[816]{0} constant({...}) + %rsqrt.1446 = f32[816]{0} rsqrt(f32[816]{0} %constant.106) + %reshape.1447 = f32[1,1,1,816]{3,2,1,0} reshape(f32[816]{0} %rsqrt.1446) + %constant.105 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %multiply.1448 = f32[1,1,1,816]{3,2,1,0} multiply(f32[1,1,1,816]{3,2,1,0} %reshape.1447, f32[1,1,1,816]{3,2,1,0} %constant.105) + %broadcast.1449 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %multiply.1448), dimensions={0,1,2,3} + %reshape.1450 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1449) + %broadcast.1451 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1450), dimensions={3} + %multiply.1452 = f32[250,19,19,816]{3,2,1,0} multiply(f32[250,19,19,816]{3,2,1,0} %subtract.1445, f32[250,19,19,816]{3,2,1,0} %broadcast.1451) + %constant.104 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %broadcast.1453 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %constant.104), dimensions={0,1,2,3} + %reshape.1454 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1453) + %broadcast.1455 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1454), dimensions={3} + %add.1456 = f32[250,19,19,816]{3,2,1,0} add(f32[250,19,19,816]{3,2,1,0} %multiply.1452, f32[250,19,19,816]{3,2,1,0} %broadcast.1455) + %call.1465 = f32[250,19,19,816]{3,2,1,0} call(f32[250,19,19,816]{3,2,1,0} %add.1456), to_apply=%jit_relu6_31.1457 + %constant.324 = f32[5,5,1,816]{3,2,1,0} constant({...}) + %convolution.1466 = f32[250,19,19,816]{3,2,1,0} convolution(f32[250,19,19,816]{3,2,1,0} %call.1465, f32[5,5,1,816]{3,2,1,0} %constant.324), window={size=5x5 pad=2_2x2_2}, dim_labels=b01f_01io->b01f, feature_group_count=816 + %constant.103 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %broadcast.1467 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %constant.103), dimensions={0,1,2,3} + %reshape.1468 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1467) + %broadcast.1469 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1468), dimensions={3} + %subtract.1470 = f32[250,19,19,816]{3,2,1,0} subtract(f32[250,19,19,816]{3,2,1,0} %convolution.1466, f32[250,19,19,816]{3,2,1,0} %broadcast.1469) + %constant.102 = f32[816]{0} constant({...}) + %rsqrt.1471 = f32[816]{0} rsqrt(f32[816]{0} %constant.102) + %reshape.1472 = f32[1,1,1,816]{3,2,1,0} reshape(f32[816]{0} %rsqrt.1471) + %constant.101 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %multiply.1473 = f32[1,1,1,816]{3,2,1,0} multiply(f32[1,1,1,816]{3,2,1,0} %reshape.1472, f32[1,1,1,816]{3,2,1,0} %constant.101) + %broadcast.1474 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %multiply.1473), dimensions={0,1,2,3} + %reshape.1475 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1474) + %broadcast.1476 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1475), dimensions={3} + %multiply.1477 = f32[250,19,19,816]{3,2,1,0} multiply(f32[250,19,19,816]{3,2,1,0} %subtract.1470, f32[250,19,19,816]{3,2,1,0} %broadcast.1476) + %constant.100 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %broadcast.1478 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %constant.100), dimensions={0,1,2,3} + %reshape.1479 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1478) + %broadcast.1480 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1479), dimensions={3} + %add.1481 = f32[250,19,19,816]{3,2,1,0} add(f32[250,19,19,816]{3,2,1,0} %multiply.1477, f32[250,19,19,816]{3,2,1,0} %broadcast.1480) + %call.1490 = f32[250,19,19,816]{3,2,1,0} call(f32[250,19,19,816]{3,2,1,0} %add.1481), to_apply=%jit_relu6_32.1482 + %constant.323 = f32[1,1,816,136]{3,2,1,0} constant({...}) + %convolution.1491 = f32[250,19,19,136]{3,2,1,0} convolution(f32[250,19,19,816]{3,2,1,0} %call.1490, f32[1,1,816,136]{3,2,1,0} %constant.323), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.99 = f32[1,1,1,136]{3,2,1,0} constant({...}) + %broadcast.1492 = f32[1,1,1,136]{3,2,1,0} broadcast(f32[1,1,1,136]{3,2,1,0} %constant.99), dimensions={0,1,2,3} + %reshape.1493 = f32[136]{0} reshape(f32[1,1,1,136]{3,2,1,0} %broadcast.1492) + %broadcast.1494 = f32[250,19,19,136]{3,2,1,0} broadcast(f32[136]{0} %reshape.1493), dimensions={3} + %subtract.1495 = f32[250,19,19,136]{3,2,1,0} subtract(f32[250,19,19,136]{3,2,1,0} %convolution.1491, f32[250,19,19,136]{3,2,1,0} %broadcast.1494) + %constant.98 = f32[136]{0} constant({...}) + %rsqrt.1496 = f32[136]{0} rsqrt(f32[136]{0} %constant.98) + %reshape.1497 = f32[1,1,1,136]{3,2,1,0} reshape(f32[136]{0} %rsqrt.1496) + %constant.97 = f32[1,1,1,136]{3,2,1,0} constant({...}) + %multiply.1498 = f32[1,1,1,136]{3,2,1,0} multiply(f32[1,1,1,136]{3,2,1,0} %reshape.1497, f32[1,1,1,136]{3,2,1,0} %constant.97) + %broadcast.1499 = f32[1,1,1,136]{3,2,1,0} broadcast(f32[1,1,1,136]{3,2,1,0} %multiply.1498), dimensions={0,1,2,3} + %reshape.1500 = f32[136]{0} reshape(f32[1,1,1,136]{3,2,1,0} %broadcast.1499) + %broadcast.1501 = f32[250,19,19,136]{3,2,1,0} broadcast(f32[136]{0} %reshape.1500), dimensions={3} + %multiply.1502 = f32[250,19,19,136]{3,2,1,0} multiply(f32[250,19,19,136]{3,2,1,0} %subtract.1495, f32[250,19,19,136]{3,2,1,0} %broadcast.1501) + %constant.96 = f32[1,1,1,136]{3,2,1,0} constant({...}) + %broadcast.1503 = f32[1,1,1,136]{3,2,1,0} broadcast(f32[1,1,1,136]{3,2,1,0} %constant.96), dimensions={0,1,2,3} + %reshape.1504 = f32[136]{0} reshape(f32[1,1,1,136]{3,2,1,0} %broadcast.1503) + %broadcast.1505 = f32[250,19,19,136]{3,2,1,0} broadcast(f32[136]{0} %reshape.1504), dimensions={3} + %add.1506 = f32[250,19,19,136]{3,2,1,0} add(f32[250,19,19,136]{3,2,1,0} %multiply.1502, f32[250,19,19,136]{3,2,1,0} %broadcast.1505) + %add.1507 = f32[250,19,19,136]{3,2,1,0} add(f32[250,19,19,136]{3,2,1,0} %add.1506, f32[250,19,19,136]{3,2,1,0} %add.1440) + %constant.322 = f32[1,1,136,816]{3,2,1,0} constant({...}) + %convolution.1508 = f32[250,19,19,816]{3,2,1,0} convolution(f32[250,19,19,136]{3,2,1,0} %add.1507, f32[1,1,136,816]{3,2,1,0} %constant.322), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.95 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %broadcast.1509 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %constant.95), dimensions={0,1,2,3} + %reshape.1510 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1509) + %broadcast.1511 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1510), dimensions={3} + %subtract.1512 = f32[250,19,19,816]{3,2,1,0} subtract(f32[250,19,19,816]{3,2,1,0} %convolution.1508, f32[250,19,19,816]{3,2,1,0} %broadcast.1511) + %constant.94 = f32[816]{0} constant({...}) + %rsqrt.1513 = f32[816]{0} rsqrt(f32[816]{0} %constant.94) + %reshape.1514 = f32[1,1,1,816]{3,2,1,0} reshape(f32[816]{0} %rsqrt.1513) + %constant.93 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %multiply.1515 = f32[1,1,1,816]{3,2,1,0} multiply(f32[1,1,1,816]{3,2,1,0} %reshape.1514, f32[1,1,1,816]{3,2,1,0} %constant.93) + %broadcast.1516 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %multiply.1515), dimensions={0,1,2,3} + %reshape.1517 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1516) + %broadcast.1518 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1517), dimensions={3} + %multiply.1519 = f32[250,19,19,816]{3,2,1,0} multiply(f32[250,19,19,816]{3,2,1,0} %subtract.1512, f32[250,19,19,816]{3,2,1,0} %broadcast.1518) + %constant.92 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %broadcast.1520 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %constant.92), dimensions={0,1,2,3} + %reshape.1521 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1520) + %broadcast.1522 = f32[250,19,19,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1521), dimensions={3} + %add.1523 = f32[250,19,19,816]{3,2,1,0} add(f32[250,19,19,816]{3,2,1,0} %multiply.1519, f32[250,19,19,816]{3,2,1,0} %broadcast.1522) + %call.1532 = f32[250,19,19,816]{3,2,1,0} call(f32[250,19,19,816]{3,2,1,0} %add.1523), to_apply=%jit_relu6_33.1524 + %constant.321 = f32[5,5,1,816]{3,2,1,0} constant({...}) + %convolution.1533 = f32[250,10,10,816]{3,2,1,0} convolution(f32[250,19,19,816]{3,2,1,0} %call.1532, f32[5,5,1,816]{3,2,1,0} %constant.321), window={size=5x5 stride=2x2 pad=2_2x2_2}, dim_labels=b01f_01io->b01f, feature_group_count=816 + %constant.91 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %broadcast.1534 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %constant.91), dimensions={0,1,2,3} + %reshape.1535 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1534) + %broadcast.1536 = f32[250,10,10,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1535), dimensions={3} + %subtract.1537 = f32[250,10,10,816]{3,2,1,0} subtract(f32[250,10,10,816]{3,2,1,0} %convolution.1533, f32[250,10,10,816]{3,2,1,0} %broadcast.1536) + %constant.90 = f32[816]{0} constant({...}) + %rsqrt.1538 = f32[816]{0} rsqrt(f32[816]{0} %constant.90) + %reshape.1539 = f32[1,1,1,816]{3,2,1,0} reshape(f32[816]{0} %rsqrt.1538) + %constant.89 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %multiply.1540 = f32[1,1,1,816]{3,2,1,0} multiply(f32[1,1,1,816]{3,2,1,0} %reshape.1539, f32[1,1,1,816]{3,2,1,0} %constant.89) + %broadcast.1541 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %multiply.1540), dimensions={0,1,2,3} + %reshape.1542 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1541) + %broadcast.1543 = f32[250,10,10,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1542), dimensions={3} + %multiply.1544 = f32[250,10,10,816]{3,2,1,0} multiply(f32[250,10,10,816]{3,2,1,0} %subtract.1537, f32[250,10,10,816]{3,2,1,0} %broadcast.1543) + %constant.88 = f32[1,1,1,816]{3,2,1,0} constant({...}) + %broadcast.1545 = f32[1,1,1,816]{3,2,1,0} broadcast(f32[1,1,1,816]{3,2,1,0} %constant.88), dimensions={0,1,2,3} + %reshape.1546 = f32[816]{0} reshape(f32[1,1,1,816]{3,2,1,0} %broadcast.1545) + %broadcast.1547 = f32[250,10,10,816]{3,2,1,0} broadcast(f32[816]{0} %reshape.1546), dimensions={3} + %add.1548 = f32[250,10,10,816]{3,2,1,0} add(f32[250,10,10,816]{3,2,1,0} %multiply.1544, f32[250,10,10,816]{3,2,1,0} %broadcast.1547) + %call.1557 = f32[250,10,10,816]{3,2,1,0} call(f32[250,10,10,816]{3,2,1,0} %add.1548), to_apply=%jit_relu6_34.1549 + %constant.320 = f32[1,1,816,232]{3,2,1,0} constant({...}) + %convolution.1558 = f32[250,10,10,232]{3,2,1,0} convolution(f32[250,10,10,816]{3,2,1,0} %call.1557, f32[1,1,816,232]{3,2,1,0} %constant.320), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.87 = f32[1,1,1,232]{3,2,1,0} constant({...}) + %broadcast.1559 = f32[1,1,1,232]{3,2,1,0} broadcast(f32[1,1,1,232]{3,2,1,0} %constant.87), dimensions={0,1,2,3} + %reshape.1560 = f32[232]{0} reshape(f32[1,1,1,232]{3,2,1,0} %broadcast.1559) + %broadcast.1561 = f32[250,10,10,232]{3,2,1,0} broadcast(f32[232]{0} %reshape.1560), dimensions={3} + %subtract.1562 = f32[250,10,10,232]{3,2,1,0} subtract(f32[250,10,10,232]{3,2,1,0} %convolution.1558, f32[250,10,10,232]{3,2,1,0} %broadcast.1561) + %constant.86 = f32[232]{0} constant({...}) + %rsqrt.1563 = f32[232]{0} rsqrt(f32[232]{0} %constant.86) + %reshape.1564 = f32[1,1,1,232]{3,2,1,0} reshape(f32[232]{0} %rsqrt.1563) + %constant.85 = f32[1,1,1,232]{3,2,1,0} constant({...}) + %multiply.1565 = f32[1,1,1,232]{3,2,1,0} multiply(f32[1,1,1,232]{3,2,1,0} %reshape.1564, f32[1,1,1,232]{3,2,1,0} %constant.85) + %broadcast.1566 = f32[1,1,1,232]{3,2,1,0} broadcast(f32[1,1,1,232]{3,2,1,0} %multiply.1565), dimensions={0,1,2,3} + %reshape.1567 = f32[232]{0} reshape(f32[1,1,1,232]{3,2,1,0} %broadcast.1566) + %broadcast.1568 = f32[250,10,10,232]{3,2,1,0} broadcast(f32[232]{0} %reshape.1567), dimensions={3} + %multiply.1569 = f32[250,10,10,232]{3,2,1,0} multiply(f32[250,10,10,232]{3,2,1,0} %subtract.1562, f32[250,10,10,232]{3,2,1,0} %broadcast.1568) + %constant.84 = f32[1,1,1,232]{3,2,1,0} constant({...}) + %broadcast.1570 = f32[1,1,1,232]{3,2,1,0} broadcast(f32[1,1,1,232]{3,2,1,0} %constant.84), dimensions={0,1,2,3} + %reshape.1571 = f32[232]{0} reshape(f32[1,1,1,232]{3,2,1,0} %broadcast.1570) + %broadcast.1572 = f32[250,10,10,232]{3,2,1,0} broadcast(f32[232]{0} %reshape.1571), dimensions={3} + %add.1573 = f32[250,10,10,232]{3,2,1,0} add(f32[250,10,10,232]{3,2,1,0} %multiply.1569, f32[250,10,10,232]{3,2,1,0} %broadcast.1572) + %constant.319 = f32[1,1,232,1392]{3,2,1,0} constant({...}) + %convolution.1574 = f32[250,10,10,1392]{3,2,1,0} convolution(f32[250,10,10,232]{3,2,1,0} %add.1573, f32[1,1,232,1392]{3,2,1,0} %constant.319), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.83 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %broadcast.1575 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %constant.83), dimensions={0,1,2,3} + %reshape.1576 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1575) + %broadcast.1577 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1576), dimensions={3} + %subtract.1578 = f32[250,10,10,1392]{3,2,1,0} subtract(f32[250,10,10,1392]{3,2,1,0} %convolution.1574, f32[250,10,10,1392]{3,2,1,0} %broadcast.1577) + %constant.82 = f32[1392]{0} constant({...}) + %rsqrt.1579 = f32[1392]{0} rsqrt(f32[1392]{0} %constant.82) + %reshape.1580 = f32[1,1,1,1392]{3,2,1,0} reshape(f32[1392]{0} %rsqrt.1579) + %constant.81 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %multiply.1581 = f32[1,1,1,1392]{3,2,1,0} multiply(f32[1,1,1,1392]{3,2,1,0} %reshape.1580, f32[1,1,1,1392]{3,2,1,0} %constant.81) + %broadcast.1582 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %multiply.1581), dimensions={0,1,2,3} + %reshape.1583 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1582) + %broadcast.1584 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1583), dimensions={3} + %multiply.1585 = f32[250,10,10,1392]{3,2,1,0} multiply(f32[250,10,10,1392]{3,2,1,0} %subtract.1578, f32[250,10,10,1392]{3,2,1,0} %broadcast.1584) + %constant.80 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %broadcast.1586 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %constant.80), dimensions={0,1,2,3} + %reshape.1587 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1586) + %broadcast.1588 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1587), dimensions={3} + %add.1589 = f32[250,10,10,1392]{3,2,1,0} add(f32[250,10,10,1392]{3,2,1,0} %multiply.1585, f32[250,10,10,1392]{3,2,1,0} %broadcast.1588) + %call.1598 = f32[250,10,10,1392]{3,2,1,0} call(f32[250,10,10,1392]{3,2,1,0} %add.1589), to_apply=%jit_relu6_35.1590 + %constant.318 = f32[5,5,1,1392]{3,2,1,0} constant({...}) + %convolution.1599 = f32[250,10,10,1392]{3,2,1,0} convolution(f32[250,10,10,1392]{3,2,1,0} %call.1598, f32[5,5,1,1392]{3,2,1,0} %constant.318), window={size=5x5 pad=2_2x2_2}, dim_labels=b01f_01io->b01f, feature_group_count=1392 + %constant.79 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %broadcast.1600 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %constant.79), dimensions={0,1,2,3} + %reshape.1601 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1600) + %broadcast.1602 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1601), dimensions={3} + %subtract.1603 = f32[250,10,10,1392]{3,2,1,0} subtract(f32[250,10,10,1392]{3,2,1,0} %convolution.1599, f32[250,10,10,1392]{3,2,1,0} %broadcast.1602) + %constant.78 = f32[1392]{0} constant({...}) + %rsqrt.1604 = f32[1392]{0} rsqrt(f32[1392]{0} %constant.78) + %reshape.1605 = f32[1,1,1,1392]{3,2,1,0} reshape(f32[1392]{0} %rsqrt.1604) + %constant.77 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %multiply.1606 = f32[1,1,1,1392]{3,2,1,0} multiply(f32[1,1,1,1392]{3,2,1,0} %reshape.1605, f32[1,1,1,1392]{3,2,1,0} %constant.77) + %broadcast.1607 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %multiply.1606), dimensions={0,1,2,3} + %reshape.1608 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1607) + %broadcast.1609 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1608), dimensions={3} + %multiply.1610 = f32[250,10,10,1392]{3,2,1,0} multiply(f32[250,10,10,1392]{3,2,1,0} %subtract.1603, f32[250,10,10,1392]{3,2,1,0} %broadcast.1609) + %constant.76 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %broadcast.1611 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %constant.76), dimensions={0,1,2,3} + %reshape.1612 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1611) + %broadcast.1613 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1612), dimensions={3} + %add.1614 = f32[250,10,10,1392]{3,2,1,0} add(f32[250,10,10,1392]{3,2,1,0} %multiply.1610, f32[250,10,10,1392]{3,2,1,0} %broadcast.1613) + %call.1623 = f32[250,10,10,1392]{3,2,1,0} call(f32[250,10,10,1392]{3,2,1,0} %add.1614), to_apply=%jit_relu6_36.1615 + %constant.317 = f32[1,1,1392,232]{3,2,1,0} constant({...}) + %convolution.1624 = f32[250,10,10,232]{3,2,1,0} convolution(f32[250,10,10,1392]{3,2,1,0} %call.1623, f32[1,1,1392,232]{3,2,1,0} %constant.317), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.75 = f32[1,1,1,232]{3,2,1,0} constant({...}) + %broadcast.1625 = f32[1,1,1,232]{3,2,1,0} broadcast(f32[1,1,1,232]{3,2,1,0} %constant.75), dimensions={0,1,2,3} + %reshape.1626 = f32[232]{0} reshape(f32[1,1,1,232]{3,2,1,0} %broadcast.1625) + %broadcast.1627 = f32[250,10,10,232]{3,2,1,0} broadcast(f32[232]{0} %reshape.1626), dimensions={3} + %subtract.1628 = f32[250,10,10,232]{3,2,1,0} subtract(f32[250,10,10,232]{3,2,1,0} %convolution.1624, f32[250,10,10,232]{3,2,1,0} %broadcast.1627) + %constant.74 = f32[232]{0} constant({...}) + %rsqrt.1629 = f32[232]{0} rsqrt(f32[232]{0} %constant.74) + %reshape.1630 = f32[1,1,1,232]{3,2,1,0} reshape(f32[232]{0} %rsqrt.1629) + %constant.73 = f32[1,1,1,232]{3,2,1,0} constant({...}) + %multiply.1631 = f32[1,1,1,232]{3,2,1,0} multiply(f32[1,1,1,232]{3,2,1,0} %reshape.1630, f32[1,1,1,232]{3,2,1,0} %constant.73) + %broadcast.1632 = f32[1,1,1,232]{3,2,1,0} broadcast(f32[1,1,1,232]{3,2,1,0} %multiply.1631), dimensions={0,1,2,3} + %reshape.1633 = f32[232]{0} reshape(f32[1,1,1,232]{3,2,1,0} %broadcast.1632) + %broadcast.1634 = f32[250,10,10,232]{3,2,1,0} broadcast(f32[232]{0} %reshape.1633), dimensions={3} + %multiply.1635 = f32[250,10,10,232]{3,2,1,0} multiply(f32[250,10,10,232]{3,2,1,0} %subtract.1628, f32[250,10,10,232]{3,2,1,0} %broadcast.1634) + %constant.72 = f32[1,1,1,232]{3,2,1,0} constant({...}) + %broadcast.1636 = f32[1,1,1,232]{3,2,1,0} broadcast(f32[1,1,1,232]{3,2,1,0} %constant.72), dimensions={0,1,2,3} + %reshape.1637 = f32[232]{0} reshape(f32[1,1,1,232]{3,2,1,0} %broadcast.1636) + %broadcast.1638 = f32[250,10,10,232]{3,2,1,0} broadcast(f32[232]{0} %reshape.1637), dimensions={3} + %add.1639 = f32[250,10,10,232]{3,2,1,0} add(f32[250,10,10,232]{3,2,1,0} %multiply.1635, f32[250,10,10,232]{3,2,1,0} %broadcast.1638) + %add.1640 = f32[250,10,10,232]{3,2,1,0} add(f32[250,10,10,232]{3,2,1,0} %add.1639, f32[250,10,10,232]{3,2,1,0} %add.1573) + %constant.316 = f32[1,1,232,1392]{3,2,1,0} constant({...}) + %convolution.1641 = f32[250,10,10,1392]{3,2,1,0} convolution(f32[250,10,10,232]{3,2,1,0} %add.1640, f32[1,1,232,1392]{3,2,1,0} %constant.316), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.71 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %broadcast.1642 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %constant.71), dimensions={0,1,2,3} + %reshape.1643 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1642) + %broadcast.1644 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1643), dimensions={3} + %subtract.1645 = f32[250,10,10,1392]{3,2,1,0} subtract(f32[250,10,10,1392]{3,2,1,0} %convolution.1641, f32[250,10,10,1392]{3,2,1,0} %broadcast.1644) + %constant.70 = f32[1392]{0} constant({...}) + %rsqrt.1646 = f32[1392]{0} rsqrt(f32[1392]{0} %constant.70) + %reshape.1647 = f32[1,1,1,1392]{3,2,1,0} reshape(f32[1392]{0} %rsqrt.1646) + %constant.69 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %multiply.1648 = f32[1,1,1,1392]{3,2,1,0} multiply(f32[1,1,1,1392]{3,2,1,0} %reshape.1647, f32[1,1,1,1392]{3,2,1,0} %constant.69) + %broadcast.1649 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %multiply.1648), dimensions={0,1,2,3} + %reshape.1650 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1649) + %broadcast.1651 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1650), dimensions={3} + %multiply.1652 = f32[250,10,10,1392]{3,2,1,0} multiply(f32[250,10,10,1392]{3,2,1,0} %subtract.1645, f32[250,10,10,1392]{3,2,1,0} %broadcast.1651) + %constant.68 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %broadcast.1653 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %constant.68), dimensions={0,1,2,3} + %reshape.1654 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1653) + %broadcast.1655 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1654), dimensions={3} + %add.1656 = f32[250,10,10,1392]{3,2,1,0} add(f32[250,10,10,1392]{3,2,1,0} %multiply.1652, f32[250,10,10,1392]{3,2,1,0} %broadcast.1655) + %call.1665 = f32[250,10,10,1392]{3,2,1,0} call(f32[250,10,10,1392]{3,2,1,0} %add.1656), to_apply=%jit_relu6_37.1657 + %constant.315 = f32[5,5,1,1392]{3,2,1,0} constant({...}) + %convolution.1666 = f32[250,10,10,1392]{3,2,1,0} convolution(f32[250,10,10,1392]{3,2,1,0} %call.1665, f32[5,5,1,1392]{3,2,1,0} %constant.315), window={size=5x5 pad=2_2x2_2}, dim_labels=b01f_01io->b01f, feature_group_count=1392 + %constant.67 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %broadcast.1667 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %constant.67), dimensions={0,1,2,3} + %reshape.1668 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1667) + %broadcast.1669 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1668), dimensions={3} + %subtract.1670 = f32[250,10,10,1392]{3,2,1,0} subtract(f32[250,10,10,1392]{3,2,1,0} %convolution.1666, f32[250,10,10,1392]{3,2,1,0} %broadcast.1669) + %constant.66 = f32[1392]{0} constant({...}) + %rsqrt.1671 = f32[1392]{0} rsqrt(f32[1392]{0} %constant.66) + %reshape.1672 = f32[1,1,1,1392]{3,2,1,0} reshape(f32[1392]{0} %rsqrt.1671) + %constant.65 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %multiply.1673 = f32[1,1,1,1392]{3,2,1,0} multiply(f32[1,1,1,1392]{3,2,1,0} %reshape.1672, f32[1,1,1,1392]{3,2,1,0} %constant.65) + %broadcast.1674 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %multiply.1673), dimensions={0,1,2,3} + %reshape.1675 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1674) + %broadcast.1676 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1675), dimensions={3} + %multiply.1677 = f32[250,10,10,1392]{3,2,1,0} multiply(f32[250,10,10,1392]{3,2,1,0} %subtract.1670, f32[250,10,10,1392]{3,2,1,0} %broadcast.1676) + %constant.64 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %broadcast.1678 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %constant.64), dimensions={0,1,2,3} + %reshape.1679 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1678) + %broadcast.1680 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1679), dimensions={3} + %add.1681 = f32[250,10,10,1392]{3,2,1,0} add(f32[250,10,10,1392]{3,2,1,0} %multiply.1677, f32[250,10,10,1392]{3,2,1,0} %broadcast.1680) + %call.1690 = f32[250,10,10,1392]{3,2,1,0} call(f32[250,10,10,1392]{3,2,1,0} %add.1681), to_apply=%jit_relu6_38.1682 + %constant.314 = f32[1,1,1392,232]{3,2,1,0} constant({...}) + %convolution.1691 = f32[250,10,10,232]{3,2,1,0} convolution(f32[250,10,10,1392]{3,2,1,0} %call.1690, f32[1,1,1392,232]{3,2,1,0} %constant.314), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.63 = f32[1,1,1,232]{3,2,1,0} constant({...}) + %broadcast.1692 = f32[1,1,1,232]{3,2,1,0} broadcast(f32[1,1,1,232]{3,2,1,0} %constant.63), dimensions={0,1,2,3} + %reshape.1693 = f32[232]{0} reshape(f32[1,1,1,232]{3,2,1,0} %broadcast.1692) + %broadcast.1694 = f32[250,10,10,232]{3,2,1,0} broadcast(f32[232]{0} %reshape.1693), dimensions={3} + %subtract.1695 = f32[250,10,10,232]{3,2,1,0} subtract(f32[250,10,10,232]{3,2,1,0} %convolution.1691, f32[250,10,10,232]{3,2,1,0} %broadcast.1694) + %constant.62 = f32[232]{0} constant({...}) + %rsqrt.1696 = f32[232]{0} rsqrt(f32[232]{0} %constant.62) + %reshape.1697 = f32[1,1,1,232]{3,2,1,0} reshape(f32[232]{0} %rsqrt.1696) + %constant.61 = f32[1,1,1,232]{3,2,1,0} constant({...}) + %multiply.1698 = f32[1,1,1,232]{3,2,1,0} multiply(f32[1,1,1,232]{3,2,1,0} %reshape.1697, f32[1,1,1,232]{3,2,1,0} %constant.61) + %broadcast.1699 = f32[1,1,1,232]{3,2,1,0} broadcast(f32[1,1,1,232]{3,2,1,0} %multiply.1698), dimensions={0,1,2,3} + %reshape.1700 = f32[232]{0} reshape(f32[1,1,1,232]{3,2,1,0} %broadcast.1699) + %broadcast.1701 = f32[250,10,10,232]{3,2,1,0} broadcast(f32[232]{0} %reshape.1700), dimensions={3} + %multiply.1702 = f32[250,10,10,232]{3,2,1,0} multiply(f32[250,10,10,232]{3,2,1,0} %subtract.1695, f32[250,10,10,232]{3,2,1,0} %broadcast.1701) + %constant.60 = f32[1,1,1,232]{3,2,1,0} constant({...}) + %broadcast.1703 = f32[1,1,1,232]{3,2,1,0} broadcast(f32[1,1,1,232]{3,2,1,0} %constant.60), dimensions={0,1,2,3} + %reshape.1704 = f32[232]{0} reshape(f32[1,1,1,232]{3,2,1,0} %broadcast.1703) + %broadcast.1705 = f32[250,10,10,232]{3,2,1,0} broadcast(f32[232]{0} %reshape.1704), dimensions={3} + %add.1706 = f32[250,10,10,232]{3,2,1,0} add(f32[250,10,10,232]{3,2,1,0} %multiply.1702, f32[250,10,10,232]{3,2,1,0} %broadcast.1705) + %add.1707 = f32[250,10,10,232]{3,2,1,0} add(f32[250,10,10,232]{3,2,1,0} %add.1706, f32[250,10,10,232]{3,2,1,0} %add.1640) + %constant.313 = f32[1,1,232,1392]{3,2,1,0} constant({...}) + %convolution.1708 = f32[250,10,10,1392]{3,2,1,0} convolution(f32[250,10,10,232]{3,2,1,0} %add.1707, f32[1,1,232,1392]{3,2,1,0} %constant.313), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.59 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %broadcast.1709 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %constant.59), dimensions={0,1,2,3} + %reshape.1710 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1709) + %broadcast.1711 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1710), dimensions={3} + %subtract.1712 = f32[250,10,10,1392]{3,2,1,0} subtract(f32[250,10,10,1392]{3,2,1,0} %convolution.1708, f32[250,10,10,1392]{3,2,1,0} %broadcast.1711) + %constant.58 = f32[1392]{0} constant({...}) + %rsqrt.1713 = f32[1392]{0} rsqrt(f32[1392]{0} %constant.58) + %reshape.1714 = f32[1,1,1,1392]{3,2,1,0} reshape(f32[1392]{0} %rsqrt.1713) + %constant.57 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %multiply.1715 = f32[1,1,1,1392]{3,2,1,0} multiply(f32[1,1,1,1392]{3,2,1,0} %reshape.1714, f32[1,1,1,1392]{3,2,1,0} %constant.57) + %broadcast.1716 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %multiply.1715), dimensions={0,1,2,3} + %reshape.1717 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1716) + %broadcast.1718 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1717), dimensions={3} + %multiply.1719 = f32[250,10,10,1392]{3,2,1,0} multiply(f32[250,10,10,1392]{3,2,1,0} %subtract.1712, f32[250,10,10,1392]{3,2,1,0} %broadcast.1718) + %constant.56 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %broadcast.1720 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %constant.56), dimensions={0,1,2,3} + %reshape.1721 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1720) + %broadcast.1722 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1721), dimensions={3} + %add.1723 = f32[250,10,10,1392]{3,2,1,0} add(f32[250,10,10,1392]{3,2,1,0} %multiply.1719, f32[250,10,10,1392]{3,2,1,0} %broadcast.1722) + %call.1732 = f32[250,10,10,1392]{3,2,1,0} call(f32[250,10,10,1392]{3,2,1,0} %add.1723), to_apply=%jit_relu6_39.1724 + %constant.312 = f32[5,5,1,1392]{3,2,1,0} constant({...}) + %convolution.1733 = f32[250,10,10,1392]{3,2,1,0} convolution(f32[250,10,10,1392]{3,2,1,0} %call.1732, f32[5,5,1,1392]{3,2,1,0} %constant.312), window={size=5x5 pad=2_2x2_2}, dim_labels=b01f_01io->b01f, feature_group_count=1392 + %constant.55 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %broadcast.1734 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %constant.55), dimensions={0,1,2,3} + %reshape.1735 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1734) + %broadcast.1736 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1735), dimensions={3} + %subtract.1737 = f32[250,10,10,1392]{3,2,1,0} subtract(f32[250,10,10,1392]{3,2,1,0} %convolution.1733, f32[250,10,10,1392]{3,2,1,0} %broadcast.1736) + %constant.54 = f32[1392]{0} constant({...}) + %rsqrt.1738 = f32[1392]{0} rsqrt(f32[1392]{0} %constant.54) + %reshape.1739 = f32[1,1,1,1392]{3,2,1,0} reshape(f32[1392]{0} %rsqrt.1738) + %constant.53 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %multiply.1740 = f32[1,1,1,1392]{3,2,1,0} multiply(f32[1,1,1,1392]{3,2,1,0} %reshape.1739, f32[1,1,1,1392]{3,2,1,0} %constant.53) + %broadcast.1741 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %multiply.1740), dimensions={0,1,2,3} + %reshape.1742 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1741) + %broadcast.1743 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1742), dimensions={3} + %multiply.1744 = f32[250,10,10,1392]{3,2,1,0} multiply(f32[250,10,10,1392]{3,2,1,0} %subtract.1737, f32[250,10,10,1392]{3,2,1,0} %broadcast.1743) + %constant.52 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %broadcast.1745 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %constant.52), dimensions={0,1,2,3} + %reshape.1746 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1745) + %broadcast.1747 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1746), dimensions={3} + %add.1748 = f32[250,10,10,1392]{3,2,1,0} add(f32[250,10,10,1392]{3,2,1,0} %multiply.1744, f32[250,10,10,1392]{3,2,1,0} %broadcast.1747) + %call.1757 = f32[250,10,10,1392]{3,2,1,0} call(f32[250,10,10,1392]{3,2,1,0} %add.1748), to_apply=%jit_relu6_40.1749 + %constant.311 = f32[1,1,1392,232]{3,2,1,0} constant({...}) + %convolution.1758 = f32[250,10,10,232]{3,2,1,0} convolution(f32[250,10,10,1392]{3,2,1,0} %call.1757, f32[1,1,1392,232]{3,2,1,0} %constant.311), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.51 = f32[1,1,1,232]{3,2,1,0} constant({...}) + %broadcast.1759 = f32[1,1,1,232]{3,2,1,0} broadcast(f32[1,1,1,232]{3,2,1,0} %constant.51), dimensions={0,1,2,3} + %reshape.1760 = f32[232]{0} reshape(f32[1,1,1,232]{3,2,1,0} %broadcast.1759) + %broadcast.1761 = f32[250,10,10,232]{3,2,1,0} broadcast(f32[232]{0} %reshape.1760), dimensions={3} + %subtract.1762 = f32[250,10,10,232]{3,2,1,0} subtract(f32[250,10,10,232]{3,2,1,0} %convolution.1758, f32[250,10,10,232]{3,2,1,0} %broadcast.1761) + %constant.50 = f32[232]{0} constant({...}) + %rsqrt.1763 = f32[232]{0} rsqrt(f32[232]{0} %constant.50) + %reshape.1764 = f32[1,1,1,232]{3,2,1,0} reshape(f32[232]{0} %rsqrt.1763) + %constant.49 = f32[1,1,1,232]{3,2,1,0} constant({...}) + %multiply.1765 = f32[1,1,1,232]{3,2,1,0} multiply(f32[1,1,1,232]{3,2,1,0} %reshape.1764, f32[1,1,1,232]{3,2,1,0} %constant.49) + %broadcast.1766 = f32[1,1,1,232]{3,2,1,0} broadcast(f32[1,1,1,232]{3,2,1,0} %multiply.1765), dimensions={0,1,2,3} + %reshape.1767 = f32[232]{0} reshape(f32[1,1,1,232]{3,2,1,0} %broadcast.1766) + %broadcast.1768 = f32[250,10,10,232]{3,2,1,0} broadcast(f32[232]{0} %reshape.1767), dimensions={3} + %multiply.1769 = f32[250,10,10,232]{3,2,1,0} multiply(f32[250,10,10,232]{3,2,1,0} %subtract.1762, f32[250,10,10,232]{3,2,1,0} %broadcast.1768) + %constant.48 = f32[1,1,1,232]{3,2,1,0} constant({...}) + %broadcast.1770 = f32[1,1,1,232]{3,2,1,0} broadcast(f32[1,1,1,232]{3,2,1,0} %constant.48), dimensions={0,1,2,3} + %reshape.1771 = f32[232]{0} reshape(f32[1,1,1,232]{3,2,1,0} %broadcast.1770) + %broadcast.1772 = f32[250,10,10,232]{3,2,1,0} broadcast(f32[232]{0} %reshape.1771), dimensions={3} + %add.1773 = f32[250,10,10,232]{3,2,1,0} add(f32[250,10,10,232]{3,2,1,0} %multiply.1769, f32[250,10,10,232]{3,2,1,0} %broadcast.1772) + %add.1774 = f32[250,10,10,232]{3,2,1,0} add(f32[250,10,10,232]{3,2,1,0} %add.1773, f32[250,10,10,232]{3,2,1,0} %add.1707) + %constant.310 = f32[1,1,232,1392]{3,2,1,0} constant({...}) + %convolution.1775 = f32[250,10,10,1392]{3,2,1,0} convolution(f32[250,10,10,232]{3,2,1,0} %add.1774, f32[1,1,232,1392]{3,2,1,0} %constant.310), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.47 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %broadcast.1776 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %constant.47), dimensions={0,1,2,3} + %reshape.1777 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1776) + %broadcast.1778 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1777), dimensions={3} + %subtract.1779 = f32[250,10,10,1392]{3,2,1,0} subtract(f32[250,10,10,1392]{3,2,1,0} %convolution.1775, f32[250,10,10,1392]{3,2,1,0} %broadcast.1778) + %constant.46 = f32[1392]{0} constant({...}) + %rsqrt.1780 = f32[1392]{0} rsqrt(f32[1392]{0} %constant.46) + %reshape.1781 = f32[1,1,1,1392]{3,2,1,0} reshape(f32[1392]{0} %rsqrt.1780) + %constant.45 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %multiply.1782 = f32[1,1,1,1392]{3,2,1,0} multiply(f32[1,1,1,1392]{3,2,1,0} %reshape.1781, f32[1,1,1,1392]{3,2,1,0} %constant.45) + %broadcast.1783 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %multiply.1782), dimensions={0,1,2,3} + %reshape.1784 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1783) + %broadcast.1785 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1784), dimensions={3} + %multiply.1786 = f32[250,10,10,1392]{3,2,1,0} multiply(f32[250,10,10,1392]{3,2,1,0} %subtract.1779, f32[250,10,10,1392]{3,2,1,0} %broadcast.1785) + %constant.44 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %broadcast.1787 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %constant.44), dimensions={0,1,2,3} + %reshape.1788 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1787) + %broadcast.1789 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1788), dimensions={3} + %add.1790 = f32[250,10,10,1392]{3,2,1,0} add(f32[250,10,10,1392]{3,2,1,0} %multiply.1786, f32[250,10,10,1392]{3,2,1,0} %broadcast.1789) + %call.1799 = f32[250,10,10,1392]{3,2,1,0} call(f32[250,10,10,1392]{3,2,1,0} %add.1790), to_apply=%jit_relu6_41.1791 + %constant.309 = f32[5,5,1,1392]{3,2,1,0} constant({...}) + %convolution.1800 = f32[250,10,10,1392]{3,2,1,0} convolution(f32[250,10,10,1392]{3,2,1,0} %call.1799, f32[5,5,1,1392]{3,2,1,0} %constant.309), window={size=5x5 pad=2_2x2_2}, dim_labels=b01f_01io->b01f, feature_group_count=1392 + %constant.43 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %broadcast.1801 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %constant.43), dimensions={0,1,2,3} + %reshape.1802 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1801) + %broadcast.1803 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1802), dimensions={3} + %subtract.1804 = f32[250,10,10,1392]{3,2,1,0} subtract(f32[250,10,10,1392]{3,2,1,0} %convolution.1800, f32[250,10,10,1392]{3,2,1,0} %broadcast.1803) + %constant.42 = f32[1392]{0} constant({...}) + %rsqrt.1805 = f32[1392]{0} rsqrt(f32[1392]{0} %constant.42) + %reshape.1806 = f32[1,1,1,1392]{3,2,1,0} reshape(f32[1392]{0} %rsqrt.1805) + %constant.41 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %multiply.1807 = f32[1,1,1,1392]{3,2,1,0} multiply(f32[1,1,1,1392]{3,2,1,0} %reshape.1806, f32[1,1,1,1392]{3,2,1,0} %constant.41) + %broadcast.1808 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %multiply.1807), dimensions={0,1,2,3} + %reshape.1809 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1808) + %broadcast.1810 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1809), dimensions={3} + %multiply.1811 = f32[250,10,10,1392]{3,2,1,0} multiply(f32[250,10,10,1392]{3,2,1,0} %subtract.1804, f32[250,10,10,1392]{3,2,1,0} %broadcast.1810) + %constant.40 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %broadcast.1812 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %constant.40), dimensions={0,1,2,3} + %reshape.1813 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1812) + %broadcast.1814 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1813), dimensions={3} + %add.1815 = f32[250,10,10,1392]{3,2,1,0} add(f32[250,10,10,1392]{3,2,1,0} %multiply.1811, f32[250,10,10,1392]{3,2,1,0} %broadcast.1814) + %call.1824 = f32[250,10,10,1392]{3,2,1,0} call(f32[250,10,10,1392]{3,2,1,0} %add.1815), to_apply=%jit_relu6_42.1816 + %constant.308 = f32[1,1,1392,232]{3,2,1,0} constant({...}) + %convolution.1825 = f32[250,10,10,232]{3,2,1,0} convolution(f32[250,10,10,1392]{3,2,1,0} %call.1824, f32[1,1,1392,232]{3,2,1,0} %constant.308), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.39 = f32[1,1,1,232]{3,2,1,0} constant({...}) + %broadcast.1826 = f32[1,1,1,232]{3,2,1,0} broadcast(f32[1,1,1,232]{3,2,1,0} %constant.39), dimensions={0,1,2,3} + %reshape.1827 = f32[232]{0} reshape(f32[1,1,1,232]{3,2,1,0} %broadcast.1826) + %broadcast.1828 = f32[250,10,10,232]{3,2,1,0} broadcast(f32[232]{0} %reshape.1827), dimensions={3} + %subtract.1829 = f32[250,10,10,232]{3,2,1,0} subtract(f32[250,10,10,232]{3,2,1,0} %convolution.1825, f32[250,10,10,232]{3,2,1,0} %broadcast.1828) + %constant.38 = f32[232]{0} constant({...}) + %rsqrt.1830 = f32[232]{0} rsqrt(f32[232]{0} %constant.38) + %reshape.1831 = f32[1,1,1,232]{3,2,1,0} reshape(f32[232]{0} %rsqrt.1830) + %constant.37 = f32[1,1,1,232]{3,2,1,0} constant({...}) + %multiply.1832 = f32[1,1,1,232]{3,2,1,0} multiply(f32[1,1,1,232]{3,2,1,0} %reshape.1831, f32[1,1,1,232]{3,2,1,0} %constant.37) + %broadcast.1833 = f32[1,1,1,232]{3,2,1,0} broadcast(f32[1,1,1,232]{3,2,1,0} %multiply.1832), dimensions={0,1,2,3} + %reshape.1834 = f32[232]{0} reshape(f32[1,1,1,232]{3,2,1,0} %broadcast.1833) + %broadcast.1835 = f32[250,10,10,232]{3,2,1,0} broadcast(f32[232]{0} %reshape.1834), dimensions={3} + %multiply.1836 = f32[250,10,10,232]{3,2,1,0} multiply(f32[250,10,10,232]{3,2,1,0} %subtract.1829, f32[250,10,10,232]{3,2,1,0} %broadcast.1835) + %constant.36 = f32[1,1,1,232]{3,2,1,0} constant({...}) + %broadcast.1837 = f32[1,1,1,232]{3,2,1,0} broadcast(f32[1,1,1,232]{3,2,1,0} %constant.36), dimensions={0,1,2,3} + %reshape.1838 = f32[232]{0} reshape(f32[1,1,1,232]{3,2,1,0} %broadcast.1837) + %broadcast.1839 = f32[250,10,10,232]{3,2,1,0} broadcast(f32[232]{0} %reshape.1838), dimensions={3} + %add.1840 = f32[250,10,10,232]{3,2,1,0} add(f32[250,10,10,232]{3,2,1,0} %multiply.1836, f32[250,10,10,232]{3,2,1,0} %broadcast.1839) + %add.1841 = f32[250,10,10,232]{3,2,1,0} add(f32[250,10,10,232]{3,2,1,0} %add.1840, f32[250,10,10,232]{3,2,1,0} %add.1774) + %constant.307 = f32[1,1,232,1392]{3,2,1,0} constant({...}) + %convolution.1842 = f32[250,10,10,1392]{3,2,1,0} convolution(f32[250,10,10,232]{3,2,1,0} %add.1841, f32[1,1,232,1392]{3,2,1,0} %constant.307), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.35 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %broadcast.1843 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %constant.35), dimensions={0,1,2,3} + %reshape.1844 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1843) + %broadcast.1845 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1844), dimensions={3} + %subtract.1846 = f32[250,10,10,1392]{3,2,1,0} subtract(f32[250,10,10,1392]{3,2,1,0} %convolution.1842, f32[250,10,10,1392]{3,2,1,0} %broadcast.1845) + %constant.34 = f32[1392]{0} constant({...}) + %rsqrt.1847 = f32[1392]{0} rsqrt(f32[1392]{0} %constant.34) + %reshape.1848 = f32[1,1,1,1392]{3,2,1,0} reshape(f32[1392]{0} %rsqrt.1847) + %constant.33 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %multiply.1849 = f32[1,1,1,1392]{3,2,1,0} multiply(f32[1,1,1,1392]{3,2,1,0} %reshape.1848, f32[1,1,1,1392]{3,2,1,0} %constant.33) + %broadcast.1850 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %multiply.1849), dimensions={0,1,2,3} + %reshape.1851 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1850) + %broadcast.1852 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1851), dimensions={3} + %multiply.1853 = f32[250,10,10,1392]{3,2,1,0} multiply(f32[250,10,10,1392]{3,2,1,0} %subtract.1846, f32[250,10,10,1392]{3,2,1,0} %broadcast.1852) + %constant.32 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %broadcast.1854 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %constant.32), dimensions={0,1,2,3} + %reshape.1855 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1854) + %broadcast.1856 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1855), dimensions={3} + %add.1857 = f32[250,10,10,1392]{3,2,1,0} add(f32[250,10,10,1392]{3,2,1,0} %multiply.1853, f32[250,10,10,1392]{3,2,1,0} %broadcast.1856) + %call.1866 = f32[250,10,10,1392]{3,2,1,0} call(f32[250,10,10,1392]{3,2,1,0} %add.1857), to_apply=%jit_relu6_43.1858 + %constant.306 = f32[5,5,1,1392]{3,2,1,0} constant({...}) + %convolution.1867 = f32[250,10,10,1392]{3,2,1,0} convolution(f32[250,10,10,1392]{3,2,1,0} %call.1866, f32[5,5,1,1392]{3,2,1,0} %constant.306), window={size=5x5 pad=2_2x2_2}, dim_labels=b01f_01io->b01f, feature_group_count=1392 + %constant.31 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %broadcast.1868 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %constant.31), dimensions={0,1,2,3} + %reshape.1869 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1868) + %broadcast.1870 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1869), dimensions={3} + %subtract.1871 = f32[250,10,10,1392]{3,2,1,0} subtract(f32[250,10,10,1392]{3,2,1,0} %convolution.1867, f32[250,10,10,1392]{3,2,1,0} %broadcast.1870) + %constant.30 = f32[1392]{0} constant({...}) + %rsqrt.1872 = f32[1392]{0} rsqrt(f32[1392]{0} %constant.30) + %reshape.1873 = f32[1,1,1,1392]{3,2,1,0} reshape(f32[1392]{0} %rsqrt.1872) + %constant.29 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %multiply.1874 = f32[1,1,1,1392]{3,2,1,0} multiply(f32[1,1,1,1392]{3,2,1,0} %reshape.1873, f32[1,1,1,1392]{3,2,1,0} %constant.29) + %broadcast.1875 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %multiply.1874), dimensions={0,1,2,3} + %reshape.1876 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1875) + %broadcast.1877 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1876), dimensions={3} + %multiply.1878 = f32[250,10,10,1392]{3,2,1,0} multiply(f32[250,10,10,1392]{3,2,1,0} %subtract.1871, f32[250,10,10,1392]{3,2,1,0} %broadcast.1877) + %constant.28 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %broadcast.1879 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %constant.28), dimensions={0,1,2,3} + %reshape.1880 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1879) + %broadcast.1881 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1880), dimensions={3} + %add.1882 = f32[250,10,10,1392]{3,2,1,0} add(f32[250,10,10,1392]{3,2,1,0} %multiply.1878, f32[250,10,10,1392]{3,2,1,0} %broadcast.1881) + %call.1891 = f32[250,10,10,1392]{3,2,1,0} call(f32[250,10,10,1392]{3,2,1,0} %add.1882), to_apply=%jit_relu6_44.1883 + %constant.305 = f32[1,1,1392,232]{3,2,1,0} constant({...}) + %convolution.1892 = f32[250,10,10,232]{3,2,1,0} convolution(f32[250,10,10,1392]{3,2,1,0} %call.1891, f32[1,1,1392,232]{3,2,1,0} %constant.305), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.27 = f32[1,1,1,232]{3,2,1,0} constant({...}) + %broadcast.1893 = f32[1,1,1,232]{3,2,1,0} broadcast(f32[1,1,1,232]{3,2,1,0} %constant.27), dimensions={0,1,2,3} + %reshape.1894 = f32[232]{0} reshape(f32[1,1,1,232]{3,2,1,0} %broadcast.1893) + %broadcast.1895 = f32[250,10,10,232]{3,2,1,0} broadcast(f32[232]{0} %reshape.1894), dimensions={3} + %subtract.1896 = f32[250,10,10,232]{3,2,1,0} subtract(f32[250,10,10,232]{3,2,1,0} %convolution.1892, f32[250,10,10,232]{3,2,1,0} %broadcast.1895) + %constant.26 = f32[232]{0} constant({...}) + %rsqrt.1897 = f32[232]{0} rsqrt(f32[232]{0} %constant.26) + %reshape.1898 = f32[1,1,1,232]{3,2,1,0} reshape(f32[232]{0} %rsqrt.1897) + %constant.25 = f32[1,1,1,232]{3,2,1,0} constant({...}) + %multiply.1899 = f32[1,1,1,232]{3,2,1,0} multiply(f32[1,1,1,232]{3,2,1,0} %reshape.1898, f32[1,1,1,232]{3,2,1,0} %constant.25) + %broadcast.1900 = f32[1,1,1,232]{3,2,1,0} broadcast(f32[1,1,1,232]{3,2,1,0} %multiply.1899), dimensions={0,1,2,3} + %reshape.1901 = f32[232]{0} reshape(f32[1,1,1,232]{3,2,1,0} %broadcast.1900) + %broadcast.1902 = f32[250,10,10,232]{3,2,1,0} broadcast(f32[232]{0} %reshape.1901), dimensions={3} + %multiply.1903 = f32[250,10,10,232]{3,2,1,0} multiply(f32[250,10,10,232]{3,2,1,0} %subtract.1896, f32[250,10,10,232]{3,2,1,0} %broadcast.1902) + %constant.24 = f32[1,1,1,232]{3,2,1,0} constant({...}) + %broadcast.1904 = f32[1,1,1,232]{3,2,1,0} broadcast(f32[1,1,1,232]{3,2,1,0} %constant.24), dimensions={0,1,2,3} + %reshape.1905 = f32[232]{0} reshape(f32[1,1,1,232]{3,2,1,0} %broadcast.1904) + %broadcast.1906 = f32[250,10,10,232]{3,2,1,0} broadcast(f32[232]{0} %reshape.1905), dimensions={3} + %add.1907 = f32[250,10,10,232]{3,2,1,0} add(f32[250,10,10,232]{3,2,1,0} %multiply.1903, f32[250,10,10,232]{3,2,1,0} %broadcast.1906) + %add.1908 = f32[250,10,10,232]{3,2,1,0} add(f32[250,10,10,232]{3,2,1,0} %add.1907, f32[250,10,10,232]{3,2,1,0} %add.1841) + %constant.304 = f32[1,1,232,1392]{3,2,1,0} constant({...}) + %convolution.1909 = f32[250,10,10,1392]{3,2,1,0} convolution(f32[250,10,10,232]{3,2,1,0} %add.1908, f32[1,1,232,1392]{3,2,1,0} %constant.304), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.23 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %broadcast.1910 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %constant.23), dimensions={0,1,2,3} + %reshape.1911 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1910) + %broadcast.1912 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1911), dimensions={3} + %subtract.1913 = f32[250,10,10,1392]{3,2,1,0} subtract(f32[250,10,10,1392]{3,2,1,0} %convolution.1909, f32[250,10,10,1392]{3,2,1,0} %broadcast.1912) + %constant.22 = f32[1392]{0} constant({...}) + %rsqrt.1914 = f32[1392]{0} rsqrt(f32[1392]{0} %constant.22) + %reshape.1915 = f32[1,1,1,1392]{3,2,1,0} reshape(f32[1392]{0} %rsqrt.1914) + %constant.21 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %multiply.1916 = f32[1,1,1,1392]{3,2,1,0} multiply(f32[1,1,1,1392]{3,2,1,0} %reshape.1915, f32[1,1,1,1392]{3,2,1,0} %constant.21) + %broadcast.1917 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %multiply.1916), dimensions={0,1,2,3} + %reshape.1918 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1917) + %broadcast.1919 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1918), dimensions={3} + %multiply.1920 = f32[250,10,10,1392]{3,2,1,0} multiply(f32[250,10,10,1392]{3,2,1,0} %subtract.1913, f32[250,10,10,1392]{3,2,1,0} %broadcast.1919) + %constant.20 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %broadcast.1921 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %constant.20), dimensions={0,1,2,3} + %reshape.1922 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1921) + %broadcast.1923 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1922), dimensions={3} + %add.1924 = f32[250,10,10,1392]{3,2,1,0} add(f32[250,10,10,1392]{3,2,1,0} %multiply.1920, f32[250,10,10,1392]{3,2,1,0} %broadcast.1923) + %call.1933 = f32[250,10,10,1392]{3,2,1,0} call(f32[250,10,10,1392]{3,2,1,0} %add.1924), to_apply=%jit_relu6_45.1925 + %constant.303 = f32[3,3,1,1392]{3,2,1,0} constant({...}) + %convolution.1934 = f32[250,10,10,1392]{3,2,1,0} convolution(f32[250,10,10,1392]{3,2,1,0} %call.1933, f32[3,3,1,1392]{3,2,1,0} %constant.303), window={size=3x3 pad=1_1x1_1}, dim_labels=b01f_01io->b01f, feature_group_count=1392 + %constant.19 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %broadcast.1935 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %constant.19), dimensions={0,1,2,3} + %reshape.1936 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1935) + %broadcast.1937 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1936), dimensions={3} + %subtract.1938 = f32[250,10,10,1392]{3,2,1,0} subtract(f32[250,10,10,1392]{3,2,1,0} %convolution.1934, f32[250,10,10,1392]{3,2,1,0} %broadcast.1937) + %constant.18 = f32[1392]{0} constant({...}) + %rsqrt.1939 = f32[1392]{0} rsqrt(f32[1392]{0} %constant.18) + %reshape.1940 = f32[1,1,1,1392]{3,2,1,0} reshape(f32[1392]{0} %rsqrt.1939) + %constant.17 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %multiply.1941 = f32[1,1,1,1392]{3,2,1,0} multiply(f32[1,1,1,1392]{3,2,1,0} %reshape.1940, f32[1,1,1,1392]{3,2,1,0} %constant.17) + %broadcast.1942 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %multiply.1941), dimensions={0,1,2,3} + %reshape.1943 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1942) + %broadcast.1944 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1943), dimensions={3} + %multiply.1945 = f32[250,10,10,1392]{3,2,1,0} multiply(f32[250,10,10,1392]{3,2,1,0} %subtract.1938, f32[250,10,10,1392]{3,2,1,0} %broadcast.1944) + %constant.16 = f32[1,1,1,1392]{3,2,1,0} constant({...}) + %broadcast.1946 = f32[1,1,1,1392]{3,2,1,0} broadcast(f32[1,1,1,1392]{3,2,1,0} %constant.16), dimensions={0,1,2,3} + %reshape.1947 = f32[1392]{0} reshape(f32[1,1,1,1392]{3,2,1,0} %broadcast.1946) + %broadcast.1948 = f32[250,10,10,1392]{3,2,1,0} broadcast(f32[1392]{0} %reshape.1947), dimensions={3} + %add.1949 = f32[250,10,10,1392]{3,2,1,0} add(f32[250,10,10,1392]{3,2,1,0} %multiply.1945, f32[250,10,10,1392]{3,2,1,0} %broadcast.1948) + %call.1958 = f32[250,10,10,1392]{3,2,1,0} call(f32[250,10,10,1392]{3,2,1,0} %add.1949), to_apply=%jit_relu6_46.1950 + %constant.302 = f32[1,1,1392,384]{3,2,1,0} constant({...}) + %convolution.1959 = f32[250,10,10,384]{3,2,1,0} convolution(f32[250,10,10,1392]{3,2,1,0} %call.1958, f32[1,1,1392,384]{3,2,1,0} %constant.302), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.15 = f32[1,1,1,384]{3,2,1,0} constant({...}) + %broadcast.1960 = f32[1,1,1,384]{3,2,1,0} broadcast(f32[1,1,1,384]{3,2,1,0} %constant.15), dimensions={0,1,2,3} + %reshape.1961 = f32[384]{0} reshape(f32[1,1,1,384]{3,2,1,0} %broadcast.1960) + %broadcast.1962 = f32[250,10,10,384]{3,2,1,0} broadcast(f32[384]{0} %reshape.1961), dimensions={3} + %subtract.1963 = f32[250,10,10,384]{3,2,1,0} subtract(f32[250,10,10,384]{3,2,1,0} %convolution.1959, f32[250,10,10,384]{3,2,1,0} %broadcast.1962) + %constant.14 = f32[384]{0} constant({...}) + %rsqrt.1964 = f32[384]{0} rsqrt(f32[384]{0} %constant.14) + %reshape.1965 = f32[1,1,1,384]{3,2,1,0} reshape(f32[384]{0} %rsqrt.1964) + %constant.13 = f32[1,1,1,384]{3,2,1,0} constant({...}) + %multiply.1966 = f32[1,1,1,384]{3,2,1,0} multiply(f32[1,1,1,384]{3,2,1,0} %reshape.1965, f32[1,1,1,384]{3,2,1,0} %constant.13) + %broadcast.1967 = f32[1,1,1,384]{3,2,1,0} broadcast(f32[1,1,1,384]{3,2,1,0} %multiply.1966), dimensions={0,1,2,3} + %reshape.1968 = f32[384]{0} reshape(f32[1,1,1,384]{3,2,1,0} %broadcast.1967) + %broadcast.1969 = f32[250,10,10,384]{3,2,1,0} broadcast(f32[384]{0} %reshape.1968), dimensions={3} + %multiply.1970 = f32[250,10,10,384]{3,2,1,0} multiply(f32[250,10,10,384]{3,2,1,0} %subtract.1963, f32[250,10,10,384]{3,2,1,0} %broadcast.1969) + %constant.12 = f32[1,1,1,384]{3,2,1,0} constant({...}) + %broadcast.1971 = f32[1,1,1,384]{3,2,1,0} broadcast(f32[1,1,1,384]{3,2,1,0} %constant.12), dimensions={0,1,2,3} + %reshape.1972 = f32[384]{0} reshape(f32[1,1,1,384]{3,2,1,0} %broadcast.1971) + %broadcast.1973 = f32[250,10,10,384]{3,2,1,0} broadcast(f32[384]{0} %reshape.1972), dimensions={3} + %add.1974 = f32[250,10,10,384]{3,2,1,0} add(f32[250,10,10,384]{3,2,1,0} %multiply.1970, f32[250,10,10,384]{3,2,1,0} %broadcast.1973) + %constant.301 = f32[1,1,384,1280]{3,2,1,0} constant({...}) + %convolution.1975 = f32[250,10,10,1280]{3,2,1,0} convolution(f32[250,10,10,384]{3,2,1,0} %add.1974, f32[1,1,384,1280]{3,2,1,0} %constant.301), window={size=1x1}, dim_labels=b01f_01io->b01f + %constant.11 = f32[1,1,1,1280]{3,2,1,0} constant({...}) + %broadcast.1976 = f32[1,1,1,1280]{3,2,1,0} broadcast(f32[1,1,1,1280]{3,2,1,0} %constant.11), dimensions={0,1,2,3} + %reshape.1977 = f32[1280]{0} reshape(f32[1,1,1,1280]{3,2,1,0} %broadcast.1976) + %broadcast.1978 = f32[250,10,10,1280]{3,2,1,0} broadcast(f32[1280]{0} %reshape.1977), dimensions={3} + %subtract.1979 = f32[250,10,10,1280]{3,2,1,0} subtract(f32[250,10,10,1280]{3,2,1,0} %convolution.1975, f32[250,10,10,1280]{3,2,1,0} %broadcast.1978) + %constant.10 = f32[1280]{0} constant({...}) + %rsqrt.1980 = f32[1280]{0} rsqrt(f32[1280]{0} %constant.10) + %reshape.1981 = f32[1,1,1,1280]{3,2,1,0} reshape(f32[1280]{0} %rsqrt.1980) + %constant.9 = f32[1,1,1,1280]{3,2,1,0} constant({...}) + %multiply.1982 = f32[1,1,1,1280]{3,2,1,0} multiply(f32[1,1,1,1280]{3,2,1,0} %reshape.1981, f32[1,1,1,1280]{3,2,1,0} %constant.9) + %broadcast.1983 = f32[1,1,1,1280]{3,2,1,0} broadcast(f32[1,1,1,1280]{3,2,1,0} %multiply.1982), dimensions={0,1,2,3} + %reshape.1984 = f32[1280]{0} reshape(f32[1,1,1,1280]{3,2,1,0} %broadcast.1983) + %broadcast.1985 = f32[250,10,10,1280]{3,2,1,0} broadcast(f32[1280]{0} %reshape.1984), dimensions={3} + %multiply.1986 = f32[250,10,10,1280]{3,2,1,0} multiply(f32[250,10,10,1280]{3,2,1,0} %subtract.1979, f32[250,10,10,1280]{3,2,1,0} %broadcast.1985) + %constant.8 = f32[1,1,1,1280]{3,2,1,0} constant({...}) + %broadcast.1987 = f32[1,1,1,1280]{3,2,1,0} broadcast(f32[1,1,1,1280]{3,2,1,0} %constant.8), dimensions={0,1,2,3} + %reshape.1988 = f32[1280]{0} reshape(f32[1,1,1,1280]{3,2,1,0} %broadcast.1987) + %broadcast.1989 = f32[250,10,10,1280]{3,2,1,0} broadcast(f32[1280]{0} %reshape.1988), dimensions={3} + %add.1990 = f32[250,10,10,1280]{3,2,1,0} add(f32[250,10,10,1280]{3,2,1,0} %multiply.1986, f32[250,10,10,1280]{3,2,1,0} %broadcast.1989) + %call.1999 = f32[250,10,10,1280]{3,2,1,0} call(f32[250,10,10,1280]{3,2,1,0} %add.1990), to_apply=%jit_relu6_47.1991 + %constant.7 = f32[] constant(0) + %reduce.2004 = f32[250,1280]{1,0} reduce(f32[250,10,10,1280]{3,2,1,0} %call.1999, f32[] %constant.7), dimensions={1,2}, to_apply=%region_0.2000 + %constant.5 = f32[] constant(100) + %broadcast.6 = f32[250,1280]{1,0} broadcast(f32[] %constant.5), dimensions={} + %divide.2005 = f32[250,1280]{1,0} divide(f32[250,1280]{1,0} %reduce.2004, f32[250,1280]{1,0} %broadcast.6) + %constant.300 = f32[1280,1000]{1,0} constant({...}) + %dot.2006 = f32[250,1000]{1,0} dot(f32[250,1280]{1,0} %divide.2005, f32[1280,1000]{1,0} %constant.300), lhs_contracting_dims={1}, rhs_contracting_dims={0} + %constant.4 = f32[1,1000]{1,0} constant({...}) + %broadcast.2007 = f32[1,1000]{1,0} broadcast(f32[1,1000]{1,0} %constant.4), dimensions={0,1} + %reshape.2008 = f32[1000]{0} reshape(f32[1,1000]{1,0} %broadcast.2007) + %broadcast.2009 = f32[250,1000]{1,0} broadcast(f32[1000]{0} %reshape.2008), dimensions={1} + %add.2010 = f32[250,1000]{1,0} add(f32[250,1000]{1,0} %dot.2006, f32[250,1000]{1,0} %broadcast.2009) + %call.2033 = (f32[250,5]{1,0}, s32[250,5]{1,0}) call(f32[250,1000]{1,0} %add.2010), to_apply=%top_k.2027 + %get-tuple-element.2034 = f32[250,5]{1,0} get-tuple-element((f32[250,5]{1,0}, s32[250,5]{1,0}) %call.2033), index=0 + %get-tuple-element.2035 = s32[250,5]{1,0} get-tuple-element((f32[250,5]{1,0}, s32[250,5]{1,0}) %call.2033), index=1 + %transpose.2036 = s32[5,250]{0,1} transpose(s32[250,5]{1,0} %get-tuple-element.2035), dimensions={1,0} + %Arg_1.2 = s32[250]{0} parameter(1) + %reshape.2037 = s32[1,250]{1,0} reshape(s32[250]{0} %Arg_1.2) + %broadcast.2038 = s32[1,250]{1,0} broadcast(s32[1,250]{1,0} %reshape.2037), dimensions={0,1} + %reshape.2039 = s32[250]{0} reshape(s32[1,250]{1,0} %broadcast.2038) + %broadcast.2040 = s32[5,250]{1,0} broadcast(s32[250]{0} %reshape.2039), dimensions={1} + %compare.2041 = pred[5,250]{0,1} compare(s32[5,250]{0,1} %transpose.2036, s32[5,250]{1,0} %broadcast.2040), direction=EQ + %slice.2042 = pred[1,250]{1,0} slice(pred[5,250]{0,1} %compare.2041), slice={[0:1], [0:250]} + %reshape.2043 = pred[250]{0} reshape(pred[1,250]{1,0} %slice.2042) + %convert.2044 = s32[250]{0} convert(pred[250]{0} %reshape.2043) + %constant.3 = s32[] constant(0) + %reduce.2049 = s32[] reduce(s32[250]{0} %convert.2044, s32[] %constant.3), dimensions={0}, to_apply=%region_2.2045 + %reshape.2050 = pred[1250]{0} reshape(pred[5,250]{0,1} %compare.2041) + %convert.2051 = s32[1250]{0} convert(pred[1250]{0} %reshape.2050) + %reduce.2056 = s32[] reduce(s32[1250]{0} %convert.2051, s32[] %constant.3), dimensions={0}, to_apply=%region_3.2052 + ROOT %tuple.2057 = (s32[], s32[]) tuple(s32[] %reduce.2049, s32[] %reduce.2056) +} + diff --git a/tests/hlo_texts/test_hlos/efficientnet-jax/module_1116.jit__normal__49.159.before_optimizations.txt b/tests/hlo_texts/test_hlos/efficientnet-jax/module_1116.jit__normal__49.159.before_optimizations.txt new file mode 100644 index 0000000..a0ccf12 --- /dev/null +++ b/tests/hlo_texts/test_hlos/efficientnet-jax/module_1116.jit__normal__49.159.before_optimizations.txt @@ -0,0 +1,171 @@ +HloModule jit__normal__49.159 + +%jit_threefry_2x32__51.3 (parameter.4: u32[2], parameter.5: u32[20736]) -> (u32[20736]) { + %constant.6 = pred[] constant(false) + %parameter.4 = u32[2]{0} parameter(0) + %slice.7 = u32[1]{0} slice(u32[2]{0} %parameter.4), slice={[0:1]} + %reshape.8 = u32[] reshape(u32[1]{0} %slice.7) + %broadcast.13 = u32[10368]{0} broadcast(u32[] %reshape.8), dimensions={} + %slice.9 = u32[1]{0} slice(u32[2]{0} %parameter.4), slice={[1:2]} + %reshape.10 = u32[] reshape(u32[1]{0} %slice.9) + %broadcast.14 = u32[10368]{0} broadcast(u32[] %reshape.10), dimensions={} + %parameter.5 = u32[20736]{0} parameter(1) + %slice.11 = u32[10368]{0} slice(u32[20736]{0} %parameter.5), slice={[0:10368]} + %broadcast.15 = u32[10368]{0} broadcast(u32[10368]{0} %slice.11), dimensions={0} + %slice.12 = u32[10368]{0} slice(u32[20736]{0} %parameter.5), slice={[10368:20736]} + %broadcast.16 = u32[10368]{0} broadcast(u32[10368]{0} %slice.12), dimensions={0} + %custom-call.17 = (u32[10368]{0}, u32[10368]{0}) custom-call(u32[10368]{0} %broadcast.13, u32[10368]{0} %broadcast.14, u32[10368]{0} %broadcast.15, u32[10368]{0} %broadcast.16), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[10368]{0}, u32[10368]{0}, u32[10368]{0}, u32[10368]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\200(\000\000\000\000\000\000" + %get-tuple-element.18 = u32[10368]{0} get-tuple-element((u32[10368]{0}, u32[10368]{0}) %custom-call.17), index=0 + %get-tuple-element.19 = u32[10368]{0} get-tuple-element((u32[10368]{0}, u32[10368]{0}) %custom-call.17), index=1 + %concatenate.20 = u32[20736]{0} concatenate(u32[10368]{0} %get-tuple-element.18, u32[10368]{0} %get-tuple-element.19), dimensions={0} + ROOT %tuple.21 = (u32[20736]{0}) tuple(u32[20736]{0} %concatenate.20) +} + +%jit__random_bits__49.22 (parameter.23: u32[2]) -> (u32[3,3,1,2304]) { + %constant.24 = pred[] constant(false) + %parameter.23 = u32[2]{0} parameter(0) + %iota.25 = u32[20736] iota(), iota_dimension=0 + %call.26 = (u32[20736]{0}) call(u32[2]{0} %parameter.23, u32[20736] %iota.25), to_apply=%jit_threefry_2x32__51.3 + %get-tuple-element.27 = u32[20736]{0} get-tuple-element((u32[20736]{0}) %call.26), index=0 + %reshape.28 = u32[3,3,1,2304]{3,2,1,0} reshape(u32[20736]{0} %get-tuple-element.27) + ROOT %tuple.29 = (u32[3,3,1,2304]{3,2,1,0}) tuple(u32[3,3,1,2304]{3,2,1,0} %reshape.28) +} + +%jit__uniform__49.30 (parameter.31: u32[2], parameter.32: f32[], parameter.33: f32[]) -> (f32[3,3,1,2304]) { + %constant.34 = pred[] constant(false) + %parameter.32 = f32[] parameter(1) + %broadcast.35 = f32[1,1,1,1]{3,2,1,0} broadcast(f32[] %parameter.32), dimensions={} + %reshape.56 = f32[1]{0} reshape(f32[1,1,1,1]{3,2,1,0} %broadcast.35) + %broadcast.57 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[1]{0} %reshape.56), dimensions={2} + %parameter.31 = u32[2]{0} parameter(0) + %call.37 = (u32[3,3,1,2304]{3,2,1,0}) call(u32[2]{0} %parameter.31), to_apply=%jit__random_bits__49.22 + %get-tuple-element.38 = u32[3,3,1,2304]{3,2,1,0} get-tuple-element((u32[3,3,1,2304]{3,2,1,0}) %call.37), index=0 + %constant.39 = u32[] constant(9) + %broadcast.40 = u32[3,3,1,2304]{3,2,1,0} broadcast(u32[] %constant.39), dimensions={} + %shift-right-logical.41 = u32[3,3,1,2304]{3,2,1,0} shift-right-logical(u32[3,3,1,2304]{3,2,1,0} %get-tuple-element.38, u32[3,3,1,2304]{3,2,1,0} %broadcast.40) + %constant.42 = u32[] constant(1065353216) + %broadcast.43 = u32[3,3,1,2304]{3,2,1,0} broadcast(u32[] %constant.42), dimensions={} + %or.44 = u32[3,3,1,2304]{3,2,1,0} or(u32[3,3,1,2304]{3,2,1,0} %shift-right-logical.41, u32[3,3,1,2304]{3,2,1,0} %broadcast.43) + %bitcast-convert.45 = f32[3,3,1,2304]{3,2,1,0} bitcast-convert(u32[3,3,1,2304]{3,2,1,0} %or.44) + %constant.46 = f32[] constant(1) + %broadcast.47 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.46), dimensions={} + %subtract.48 = f32[3,3,1,2304]{3,2,1,0} subtract(f32[3,3,1,2304]{3,2,1,0} %bitcast-convert.45, f32[3,3,1,2304]{3,2,1,0} %broadcast.47) + %parameter.33 = f32[] parameter(2) + %broadcast.36 = f32[1,1,1,1]{3,2,1,0} broadcast(f32[] %parameter.33), dimensions={} + %subtract.49 = f32[1,1,1,1]{3,2,1,0} subtract(f32[1,1,1,1]{3,2,1,0} %broadcast.36, f32[1,1,1,1]{3,2,1,0} %broadcast.35) + %reshape.50 = f32[1]{0} reshape(f32[1,1,1,1]{3,2,1,0} %subtract.49) + %broadcast.51 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[1]{0} %reshape.50), dimensions={2} + %multiply.52 = f32[3,3,1,2304]{3,2,1,0} multiply(f32[3,3,1,2304]{3,2,1,0} %subtract.48, f32[3,3,1,2304]{3,2,1,0} %broadcast.51) + %reshape.53 = f32[1]{0} reshape(f32[1,1,1,1]{3,2,1,0} %broadcast.35) + %broadcast.54 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[1]{0} %reshape.53), dimensions={2} + %add.55 = f32[3,3,1,2304]{3,2,1,0} add(f32[3,3,1,2304]{3,2,1,0} %multiply.52, f32[3,3,1,2304]{3,2,1,0} %broadcast.54) + %maximum.58 = f32[3,3,1,2304]{3,2,1,0} maximum(f32[3,3,1,2304]{3,2,1,0} %broadcast.57, f32[3,3,1,2304]{3,2,1,0} %add.55) + ROOT %tuple.59 = (f32[3,3,1,2304]{3,2,1,0}) tuple(f32[3,3,1,2304]{3,2,1,0} %maximum.58) +} + +%jit__normal_real__49.60 (parameter.61: u32[2]) -> (f32[3,3,1,2304]) { + %constant.62 = pred[] constant(false) + %parameter.61 = u32[2]{0} parameter(0) + %constant.63 = f32[] constant(-0.99999994) + %constant.64 = f32[] constant(1) + %call.65 = (f32[3,3,1,2304]{3,2,1,0}) call(u32[2]{0} %parameter.61, f32[] %constant.63, f32[] %constant.64), to_apply=%jit__uniform__49.30 + %get-tuple-element.66 = f32[3,3,1,2304]{3,2,1,0} get-tuple-element((f32[3,3,1,2304]{3,2,1,0}) %call.65), index=0 + %abs.148 = f32[3,3,1,2304]{3,2,1,0} abs(f32[3,3,1,2304]{3,2,1,0} %get-tuple-element.66) + %constant.147 = f32[] constant(1) + %broadcast.149 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.147), dimensions={} + %compare.150 = pred[3,3,1,2304]{3,2,1,0} compare(f32[3,3,1,2304]{3,2,1,0} %abs.148, f32[3,3,1,2304]{3,2,1,0} %broadcast.149), direction=EQ + %constant.144 = f32[] constant(inf) + %broadcast.145 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.144), dimensions={} + %multiply.146 = f32[3,3,1,2304]{3,2,1,0} multiply(f32[3,3,1,2304]{3,2,1,0} %get-tuple-element.66, f32[3,3,1,2304]{3,2,1,0} %broadcast.145) + %negate.67 = f32[3,3,1,2304]{3,2,1,0} negate(f32[3,3,1,2304]{3,2,1,0} %get-tuple-element.66) + %multiply.68 = f32[3,3,1,2304]{3,2,1,0} multiply(f32[3,3,1,2304]{3,2,1,0} %negate.67, f32[3,3,1,2304]{3,2,1,0} %get-tuple-element.66) + %log-plus-one.69 = f32[3,3,1,2304]{3,2,1,0} log-plus-one(f32[3,3,1,2304]{3,2,1,0} %multiply.68) + %negate.70 = f32[3,3,1,2304]{3,2,1,0} negate(f32[3,3,1,2304]{3,2,1,0} %log-plus-one.69) + %constant.71 = f32[] constant(5) + %broadcast.72 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.71), dimensions={} + %compare.73 = pred[3,3,1,2304]{3,2,1,0} compare(f32[3,3,1,2304]{3,2,1,0} %negate.70, f32[3,3,1,2304]{3,2,1,0} %broadcast.72), direction=LT + %constant.139 = f32[] constant(1.50140941) + %broadcast.140 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.139), dimensions={} + %constant.137 = f32[] constant(2.83297682) + %broadcast.138 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.137), dimensions={} + %select.141 = f32[3,3,1,2304]{3,2,1,0} select(pred[3,3,1,2304]{3,2,1,0} %compare.73, f32[3,3,1,2304]{3,2,1,0} %broadcast.140, f32[3,3,1,2304]{3,2,1,0} %broadcast.138) + %constant.132 = f32[] constant(0.246640727) + %broadcast.133 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.132), dimensions={} + %constant.130 = f32[] constant(1.00167406) + %broadcast.131 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.130), dimensions={} + %select.134 = f32[3,3,1,2304]{3,2,1,0} select(pred[3,3,1,2304]{3,2,1,0} %compare.73, f32[3,3,1,2304]{3,2,1,0} %broadcast.133, f32[3,3,1,2304]{3,2,1,0} %broadcast.131) + %constant.125 = f32[] constant(-0.00417768164) + %broadcast.126 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.125), dimensions={} + %constant.123 = f32[] constant(0.00943887047) + %broadcast.124 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.123), dimensions={} + %select.127 = f32[3,3,1,2304]{3,2,1,0} select(pred[3,3,1,2304]{3,2,1,0} %compare.73, f32[3,3,1,2304]{3,2,1,0} %broadcast.126, f32[3,3,1,2304]{3,2,1,0} %broadcast.124) + %constant.118 = f32[] constant(-0.00125372503) + %broadcast.119 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.118), dimensions={} + %constant.116 = f32[] constant(-0.0076224613) + %broadcast.117 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.116), dimensions={} + %select.120 = f32[3,3,1,2304]{3,2,1,0} select(pred[3,3,1,2304]{3,2,1,0} %compare.73, f32[3,3,1,2304]{3,2,1,0} %broadcast.119, f32[3,3,1,2304]{3,2,1,0} %broadcast.117) + %constant.111 = f32[] constant(0.00021858087) + %broadcast.112 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.111), dimensions={} + %constant.109 = f32[] constant(0.00573950773) + %broadcast.110 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.109), dimensions={} + %select.113 = f32[3,3,1,2304]{3,2,1,0} select(pred[3,3,1,2304]{3,2,1,0} %compare.73, f32[3,3,1,2304]{3,2,1,0} %broadcast.112, f32[3,3,1,2304]{3,2,1,0} %broadcast.110) + %constant.104 = f32[] constant(-4.39150654e-06) + %broadcast.105 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.104), dimensions={} + %constant.102 = f32[] constant(-0.00367342844) + %broadcast.103 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.102), dimensions={} + %select.106 = f32[3,3,1,2304]{3,2,1,0} select(pred[3,3,1,2304]{3,2,1,0} %compare.73, f32[3,3,1,2304]{3,2,1,0} %broadcast.105, f32[3,3,1,2304]{3,2,1,0} %broadcast.103) + %constant.97 = f32[] constant(-3.5233877e-06) + %broadcast.98 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.97), dimensions={} + %constant.95 = f32[] constant(0.00134934322) + %broadcast.96 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.95), dimensions={} + %select.99 = f32[3,3,1,2304]{3,2,1,0} select(pred[3,3,1,2304]{3,2,1,0} %compare.73, f32[3,3,1,2304]{3,2,1,0} %broadcast.98, f32[3,3,1,2304]{3,2,1,0} %broadcast.96) + %constant.90 = f32[] constant(3.43273939e-07) + %broadcast.91 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.90), dimensions={} + %constant.88 = f32[] constant(0.000100950558) + %broadcast.89 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.88), dimensions={} + %select.92 = f32[3,3,1,2304]{3,2,1,0} select(pred[3,3,1,2304]{3,2,1,0} %compare.73, f32[3,3,1,2304]{3,2,1,0} %broadcast.91, f32[3,3,1,2304]{3,2,1,0} %broadcast.89) + %constant.84 = f32[] constant(2.81022636e-08) + %broadcast.85 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.84), dimensions={} + %constant.82 = f32[] constant(-0.000200214257) + %broadcast.83 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.82), dimensions={} + %select.86 = f32[3,3,1,2304]{3,2,1,0} select(pred[3,3,1,2304]{3,2,1,0} %compare.73, f32[3,3,1,2304]{3,2,1,0} %broadcast.85, f32[3,3,1,2304]{3,2,1,0} %broadcast.83) + %constant.78 = f32[] constant(2.5) + %broadcast.79 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.78), dimensions={} + %subtract.80 = f32[3,3,1,2304]{3,2,1,0} subtract(f32[3,3,1,2304]{3,2,1,0} %negate.70, f32[3,3,1,2304]{3,2,1,0} %broadcast.79) + %sqrt.75 = f32[3,3,1,2304]{3,2,1,0} sqrt(f32[3,3,1,2304]{3,2,1,0} %negate.70) + %constant.74 = f32[] constant(3) + %broadcast.76 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.74), dimensions={} + %subtract.77 = f32[3,3,1,2304]{3,2,1,0} subtract(f32[3,3,1,2304]{3,2,1,0} %sqrt.75, f32[3,3,1,2304]{3,2,1,0} %broadcast.76) + %select.81 = f32[3,3,1,2304]{3,2,1,0} select(pred[3,3,1,2304]{3,2,1,0} %compare.73, f32[3,3,1,2304]{3,2,1,0} %subtract.80, f32[3,3,1,2304]{3,2,1,0} %subtract.77) + %multiply.87 = f32[3,3,1,2304]{3,2,1,0} multiply(f32[3,3,1,2304]{3,2,1,0} %select.86, f32[3,3,1,2304]{3,2,1,0} %select.81) + %add.93 = f32[3,3,1,2304]{3,2,1,0} add(f32[3,3,1,2304]{3,2,1,0} %select.92, f32[3,3,1,2304]{3,2,1,0} %multiply.87) + %multiply.94 = f32[3,3,1,2304]{3,2,1,0} multiply(f32[3,3,1,2304]{3,2,1,0} %add.93, f32[3,3,1,2304]{3,2,1,0} %select.81) + %add.100 = f32[3,3,1,2304]{3,2,1,0} add(f32[3,3,1,2304]{3,2,1,0} %select.99, f32[3,3,1,2304]{3,2,1,0} %multiply.94) + %multiply.101 = f32[3,3,1,2304]{3,2,1,0} multiply(f32[3,3,1,2304]{3,2,1,0} %add.100, f32[3,3,1,2304]{3,2,1,0} %select.81) + %add.107 = f32[3,3,1,2304]{3,2,1,0} add(f32[3,3,1,2304]{3,2,1,0} %select.106, f32[3,3,1,2304]{3,2,1,0} %multiply.101) + %multiply.108 = f32[3,3,1,2304]{3,2,1,0} multiply(f32[3,3,1,2304]{3,2,1,0} %add.107, f32[3,3,1,2304]{3,2,1,0} %select.81) + %add.114 = f32[3,3,1,2304]{3,2,1,0} add(f32[3,3,1,2304]{3,2,1,0} %select.113, f32[3,3,1,2304]{3,2,1,0} %multiply.108) + %multiply.115 = f32[3,3,1,2304]{3,2,1,0} multiply(f32[3,3,1,2304]{3,2,1,0} %add.114, f32[3,3,1,2304]{3,2,1,0} %select.81) + %add.121 = f32[3,3,1,2304]{3,2,1,0} add(f32[3,3,1,2304]{3,2,1,0} %select.120, f32[3,3,1,2304]{3,2,1,0} %multiply.115) + %multiply.122 = f32[3,3,1,2304]{3,2,1,0} multiply(f32[3,3,1,2304]{3,2,1,0} %add.121, f32[3,3,1,2304]{3,2,1,0} %select.81) + %add.128 = f32[3,3,1,2304]{3,2,1,0} add(f32[3,3,1,2304]{3,2,1,0} %select.127, f32[3,3,1,2304]{3,2,1,0} %multiply.122) + %multiply.129 = f32[3,3,1,2304]{3,2,1,0} multiply(f32[3,3,1,2304]{3,2,1,0} %add.128, f32[3,3,1,2304]{3,2,1,0} %select.81) + %add.135 = f32[3,3,1,2304]{3,2,1,0} add(f32[3,3,1,2304]{3,2,1,0} %select.134, f32[3,3,1,2304]{3,2,1,0} %multiply.129) + %multiply.136 = f32[3,3,1,2304]{3,2,1,0} multiply(f32[3,3,1,2304]{3,2,1,0} %add.135, f32[3,3,1,2304]{3,2,1,0} %select.81) + %add.142 = f32[3,3,1,2304]{3,2,1,0} add(f32[3,3,1,2304]{3,2,1,0} %select.141, f32[3,3,1,2304]{3,2,1,0} %multiply.136) + %multiply.143 = f32[3,3,1,2304]{3,2,1,0} multiply(f32[3,3,1,2304]{3,2,1,0} %add.142, f32[3,3,1,2304]{3,2,1,0} %get-tuple-element.66) + %select.151 = f32[3,3,1,2304]{3,2,1,0} select(pred[3,3,1,2304]{3,2,1,0} %compare.150, f32[3,3,1,2304]{3,2,1,0} %multiply.146, f32[3,3,1,2304]{3,2,1,0} %multiply.143) + %constant.152 = f32[] constant(1.41421354) + %broadcast.153 = f32[3,3,1,2304]{3,2,1,0} broadcast(f32[] %constant.152), dimensions={} + %multiply.154 = f32[3,3,1,2304]{3,2,1,0} multiply(f32[3,3,1,2304]{3,2,1,0} %select.151, f32[3,3,1,2304]{3,2,1,0} %broadcast.153) + ROOT %tuple.155 = (f32[3,3,1,2304]{3,2,1,0}) tuple(f32[3,3,1,2304]{3,2,1,0} %multiply.154) +} + +ENTRY %jit__normal__49.159 (parameter.1: u32[2]) -> (f32[3,3,1,2304]) { + %constant.2 = pred[] constant(false) + %parameter.1 = u32[2]{0} parameter(0) + %call.156 = (f32[3,3,1,2304]{3,2,1,0}) call(u32[2]{0} %parameter.1), to_apply=%jit__normal_real__49.60 + %get-tuple-element.157 = f32[3,3,1,2304]{3,2,1,0} get-tuple-element((f32[3,3,1,2304]{3,2,1,0}) %call.156), index=0 + ROOT %tuple.158 = (f32[3,3,1,2304]{3,2,1,0}) tuple(f32[3,3,1,2304]{3,2,1,0} %get-tuple-element.157) +} + diff --git a/tests/hlo_texts/test_hlos/jax-bayes/module_0018.jit__threefry_split.8.before_optimizations.txt b/tests/hlo_texts/test_hlos/jax-bayes/module_0018.jit__threefry_split.8.before_optimizations.txt new file mode 100644 index 0000000..7bfce8a --- /dev/null +++ b/tests/hlo_texts/test_hlos/jax-bayes/module_0018.jit__threefry_split.8.before_optimizations.txt @@ -0,0 +1,39 @@ +HloModule jit__threefry_split.8 + +xla_fallback_threefry2x32.9 { + Arg_0.10 = u32[] parameter(0) + broadcast.14 = u32[2]{0} broadcast(Arg_0.10), dimensions={} + Arg_1.11 = u32[] parameter(1) + broadcast.15 = u32[2]{0} broadcast(Arg_1.11), dimensions={} + Arg_2.12 = u32[2]{0} parameter(2) + Arg_3.13 = u32[2]{0} parameter(3) + ROOT custom-call.16 = (u32[2]{0}, u32[2]{0}) custom-call(broadcast.14, broadcast.15, Arg_2.12, Arg_3.13), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[2]{0}, u32[2]{0}, u32[2]{0}, u32[2]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\002\000\000\000\000\000\000\000" +} + +threefry2x32.17 { + Arg_0.18 = u32[] parameter(0) + Arg_1.19 = u32[] parameter(1) + Arg_2.20 = u32[2]{0} parameter(2) + Arg_3.21 = u32[2]{0} parameter(3) + call.22 = (u32[2]{0}, u32[2]{0}) call(Arg_0.18, Arg_1.19, Arg_2.20, Arg_3.21), to_apply=xla_fallback_threefry2x32.9 + get-tuple-element.23 = u32[2]{0} get-tuple-element(call.22), index=0 + get-tuple-element.24 = u32[2]{0} get-tuple-element(call.22), index=1 + ROOT tuple.25 = (u32[2]{0}, u32[2]{0}) tuple(get-tuple-element.23, get-tuple-element.24) +} + +ENTRY main.31 { + Arg_0.1 = u32[2]{0} parameter(0) + slice.3 = u32[1]{0} slice(Arg_0.1), slice={[0:1]} + reshape.4 = u32[] reshape(slice.3) + slice.5 = u32[1]{0} slice(Arg_0.1), slice={[1:2]} + reshape.6 = u32[] reshape(slice.5) + iota.2 = u32[4]{0} iota(), iota_dimension=0 + slice.7 = u32[2]{0} slice(iota.2), slice={[0:2]} + slice.8 = u32[2]{0} slice(iota.2), slice={[2:4]} + call.26 = (u32[2]{0}, u32[2]{0}) call(reshape.4, reshape.6, slice.7, slice.8), to_apply=threefry2x32.17 + get-tuple-element.27 = u32[2]{0} get-tuple-element(call.26), index=0 + get-tuple-element.28 = u32[2]{0} get-tuple-element(call.26), index=1 + concatenate.29 = u32[4]{0} concatenate(get-tuple-element.27, get-tuple-element.28), dimensions={0} + ROOT reshape.30 = u32[2,2]{1,0} reshape(concatenate.29) +} + diff --git a/tests/hlo_texts/test_hlos/jax-bayes/module_0032.jit_fn.12.before_optimizations.txt b/tests/hlo_texts/test_hlos/jax-bayes/module_0032.jit_fn.12.before_optimizations.txt new file mode 100644 index 0000000..11a58cc --- /dev/null +++ b/tests/hlo_texts/test_hlos/jax-bayes/module_0032.jit_fn.12.before_optimizations.txt @@ -0,0 +1,12 @@ +HloModule jit_fn.12 + +ENTRY main.8 { + Arg_0.1 = f32[2]{0} parameter(0) + reshape.3 = f32[1,2]{1,0} reshape(Arg_0.1) + broadcast.4 = f32[1,2]{1,0} broadcast(reshape.3), dimensions={0,1} + reshape.5 = f32[2]{0} reshape(broadcast.4) + broadcast.6 = f32[2000,2]{1,0} broadcast(reshape.5), dimensions={1} + Arg_1.2 = f32[2000,2]{1,0} parameter(1) + ROOT add.7 = f32[2000,2]{1,0} add(broadcast.6, Arg_1.2) +} + diff --git a/tests/hlo_texts/test_hlos/jax-bayes/module_0094.jit__normal.39.before_optimizations.txt b/tests/hlo_texts/test_hlos/jax-bayes/module_0094.jit__normal.39.before_optimizations.txt new file mode 100644 index 0000000..150fc69 --- /dev/null +++ b/tests/hlo_texts/test_hlos/jax-bayes/module_0094.jit__normal.39.before_optimizations.txt @@ -0,0 +1,154 @@ +HloModule jit__normal.39 + +xla_fallback_threefry2x32.21 { + Arg_0.22 = u32[] parameter(0) + broadcast.26 = u32[64]{0} broadcast(Arg_0.22), dimensions={} + Arg_1.23 = u32[] parameter(1) + broadcast.27 = u32[64]{0} broadcast(Arg_1.23), dimensions={} + Arg_2.24 = u32[64]{0} parameter(2) + Arg_3.25 = u32[64]{0} parameter(3) + ROOT custom-call.28 = (u32[64]{0}, u32[64]{0}) custom-call(broadcast.26, broadcast.27, Arg_2.24, Arg_3.25), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[64]{0}, u32[64]{0}, u32[64]{0}, u32[64]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="@\000\000\000\000\000\000\000" +} + +threefry2x32.29 { + Arg_0.30 = u32[] parameter(0) + Arg_1.31 = u32[] parameter(1) + Arg_2.32 = u32[64]{0} parameter(2) + Arg_3.33 = u32[64]{0} parameter(3) + call.34 = (u32[64]{0}, u32[64]{0}) call(Arg_0.30, Arg_1.31, Arg_2.32, Arg_3.33), to_apply=xla_fallback_threefry2x32.21 + get-tuple-element.35 = u32[64]{0} get-tuple-element(call.34), index=0 + get-tuple-element.36 = u32[64]{0} get-tuple-element(call.34), index=1 + ROOT tuple.37 = (u32[64]{0}, u32[64]{0}) tuple(get-tuple-element.35, get-tuple-element.36) +} + +xla_fallback_erf_inv.50 { + Arg_0.51 = f32[128,1]{1,0} parameter(0) + abs.98 = f32[128,1]{1,0} abs(Arg_0.51) + constant.96 = f32[] constant(1) + broadcast.97 = f32[128,1]{1,0} broadcast(constant.96), dimensions={} + compare.99 = pred[128,1]{1,0} compare(abs.98, broadcast.97), direction=EQ + constant.94 = f32[] constant(inf) + broadcast.95 = f32[128,1]{1,0} broadcast(constant.94), dimensions={} + multiply.100 = f32[128,1]{1,0} multiply(Arg_0.51, broadcast.95) + negate.101 = f32[128,1]{1,0} negate(Arg_0.51) + multiply.102 = f32[128,1]{1,0} multiply(negate.101, Arg_0.51) + log-plus-one.103 = f32[128,1]{1,0} log-plus-one(multiply.102) + negate.104 = f32[128,1]{1,0} negate(log-plus-one.103) + constant.92 = f32[] constant(5) + broadcast.93 = f32[128,1]{1,0} broadcast(constant.92), dimensions={} + compare.105 = pred[128,1]{1,0} compare(negate.104, broadcast.93), direction=LT + constant.90 = f32[] constant(1.50140941) + broadcast.91 = f32[128,1]{1,0} broadcast(constant.90), dimensions={} + constant.88 = f32[] constant(2.83297682) + broadcast.89 = f32[128,1]{1,0} broadcast(constant.88), dimensions={} + select.106 = f32[128,1]{1,0} select(compare.105, broadcast.91, broadcast.89) + constant.86 = f32[] constant(0.246640727) + broadcast.87 = f32[128,1]{1,0} broadcast(constant.86), dimensions={} + constant.84 = f32[] constant(1.00167406) + broadcast.85 = f32[128,1]{1,0} broadcast(constant.84), dimensions={} + select.107 = f32[128,1]{1,0} select(compare.105, broadcast.87, broadcast.85) + constant.82 = f32[] constant(-0.00417768164) + broadcast.83 = f32[128,1]{1,0} broadcast(constant.82), dimensions={} + constant.80 = f32[] constant(0.00943887047) + broadcast.81 = f32[128,1]{1,0} broadcast(constant.80), dimensions={} + select.108 = f32[128,1]{1,0} select(compare.105, broadcast.83, broadcast.81) + constant.78 = f32[] constant(-0.00125372503) + broadcast.79 = f32[128,1]{1,0} broadcast(constant.78), dimensions={} + constant.76 = f32[] constant(-0.0076224613) + broadcast.77 = f32[128,1]{1,0} broadcast(constant.76), dimensions={} + select.109 = f32[128,1]{1,0} select(compare.105, broadcast.79, broadcast.77) + constant.74 = f32[] constant(0.00021858087) + broadcast.75 = f32[128,1]{1,0} broadcast(constant.74), dimensions={} + constant.72 = f32[] constant(0.00573950773) + broadcast.73 = f32[128,1]{1,0} broadcast(constant.72), dimensions={} + select.110 = f32[128,1]{1,0} select(compare.105, broadcast.75, broadcast.73) + constant.70 = f32[] constant(-4.39150654e-06) + broadcast.71 = f32[128,1]{1,0} broadcast(constant.70), dimensions={} + constant.68 = f32[] constant(-0.00367342844) + broadcast.69 = f32[128,1]{1,0} broadcast(constant.68), dimensions={} + select.111 = f32[128,1]{1,0} select(compare.105, broadcast.71, broadcast.69) + constant.66 = f32[] constant(-3.5233877e-06) + broadcast.67 = f32[128,1]{1,0} broadcast(constant.66), dimensions={} + constant.64 = f32[] constant(0.00134934322) + broadcast.65 = f32[128,1]{1,0} broadcast(constant.64), dimensions={} + select.112 = f32[128,1]{1,0} select(compare.105, broadcast.67, broadcast.65) + constant.62 = f32[] constant(3.43273939e-07) + broadcast.63 = f32[128,1]{1,0} broadcast(constant.62), dimensions={} + constant.60 = f32[] constant(0.000100950558) + broadcast.61 = f32[128,1]{1,0} broadcast(constant.60), dimensions={} + select.113 = f32[128,1]{1,0} select(compare.105, broadcast.63, broadcast.61) + constant.58 = f32[] constant(2.81022636e-08) + broadcast.59 = f32[128,1]{1,0} broadcast(constant.58), dimensions={} + constant.56 = f32[] constant(-0.000200214257) + broadcast.57 = f32[128,1]{1,0} broadcast(constant.56), dimensions={} + select.114 = f32[128,1]{1,0} select(compare.105, broadcast.59, broadcast.57) + constant.54 = f32[] constant(2.5) + broadcast.55 = f32[128,1]{1,0} broadcast(constant.54), dimensions={} + subtract.115 = f32[128,1]{1,0} subtract(negate.104, broadcast.55) + sqrt.116 = f32[128,1]{1,0} sqrt(negate.104) + constant.52 = f32[] constant(3) + broadcast.53 = f32[128,1]{1,0} broadcast(constant.52), dimensions={} + subtract.117 = f32[128,1]{1,0} subtract(sqrt.116, broadcast.53) + select.118 = f32[128,1]{1,0} select(compare.105, subtract.115, subtract.117) + multiply.119 = f32[128,1]{1,0} multiply(select.114, select.118) + add.120 = f32[128,1]{1,0} add(select.113, multiply.119) + multiply.121 = f32[128,1]{1,0} multiply(add.120, select.118) + add.122 = f32[128,1]{1,0} add(select.112, multiply.121) + multiply.123 = f32[128,1]{1,0} multiply(add.122, select.118) + add.124 = f32[128,1]{1,0} add(select.111, multiply.123) + multiply.125 = f32[128,1]{1,0} multiply(add.124, select.118) + add.126 = f32[128,1]{1,0} add(select.110, multiply.125) + multiply.127 = f32[128,1]{1,0} multiply(add.126, select.118) + add.128 = f32[128,1]{1,0} add(select.109, multiply.127) + multiply.129 = f32[128,1]{1,0} multiply(add.128, select.118) + add.130 = f32[128,1]{1,0} add(select.108, multiply.129) + multiply.131 = f32[128,1]{1,0} multiply(add.130, select.118) + add.132 = f32[128,1]{1,0} add(select.107, multiply.131) + multiply.133 = f32[128,1]{1,0} multiply(add.132, select.118) + add.134 = f32[128,1]{1,0} add(select.106, multiply.133) + multiply.135 = f32[128,1]{1,0} multiply(add.134, Arg_0.51) + ROOT select.136 = f32[128,1]{1,0} select(compare.99, multiply.100, multiply.135) +} + +erf_inv.137 { + Arg_0.138 = f32[128,1]{1,0} parameter(0) + ROOT call.139 = f32[128,1]{1,0} call(Arg_0.138), to_apply=xla_fallback_erf_inv.50 +} + +ENTRY main.142 { + Arg_0.1 = u32[2]{0} parameter(0) + slice.15 = u32[1]{0} slice(Arg_0.1), slice={[0:1]} + reshape.16 = u32[] reshape(slice.15) + slice.17 = u32[1]{0} slice(Arg_0.1), slice={[1:2]} + reshape.18 = u32[] reshape(slice.17) + iota.14 = u32[128]{0} iota(), iota_dimension=0 + slice.19 = u32[64]{0} slice(iota.14), slice={[0:64]} + slice.20 = u32[64]{0} slice(iota.14), slice={[64:128]} + call.38 = (u32[64]{0}, u32[64]{0}) call(reshape.16, reshape.18, slice.19, slice.20), to_apply=threefry2x32.29 + get-tuple-element.39 = u32[64]{0} get-tuple-element(call.38), index=0 + get-tuple-element.40 = u32[64]{0} get-tuple-element(call.38), index=1 + concatenate.41 = u32[128]{0} concatenate(get-tuple-element.39, get-tuple-element.40), dimensions={0} + reshape.42 = u32[128,1]{1,0} reshape(concatenate.41) + constant.12 = u32[] constant(9) + broadcast.13 = u32[128,1]{1,0} broadcast(constant.12), dimensions={} + shift-right-logical.43 = u32[128,1]{1,0} shift-right-logical(reshape.42, broadcast.13) + constant.10 = u32[] constant(1065353216) + broadcast.11 = u32[128,1]{1,0} broadcast(constant.10), dimensions={} + or.44 = u32[128,1]{1,0} or(shift-right-logical.43, broadcast.11) + bitcast-convert.45 = f32[128,1]{1,0} bitcast-convert(or.44) + constant.8 = f32[] constant(1) + broadcast.9 = f32[128,1]{1,0} broadcast(constant.8), dimensions={} + subtract.46 = f32[128,1]{1,0} subtract(bitcast-convert.45, broadcast.9) + constant.6 = f32[] constant(2) + broadcast.7 = f32[128,1]{1,0} broadcast(constant.6), dimensions={} + multiply.47 = f32[128,1]{1,0} multiply(subtract.46, broadcast.7) + constant.4 = f32[] constant(-0.99999994) + broadcast.5 = f32[128,1]{1,0} broadcast(constant.4), dimensions={} + add.48 = f32[128,1]{1,0} add(multiply.47, broadcast.5) + maximum.49 = f32[128,1]{1,0} maximum(add.48, broadcast.5) + call.140 = f32[128,1]{1,0} call(maximum.49), to_apply=erf_inv.137 + constant.2 = f32[] constant(1.41421354) + broadcast.3 = f32[128,1]{1,0} broadcast(constant.2), dimensions={} + ROOT multiply.141 = f32[128,1]{1,0} multiply(call.140, broadcast.3) +} + diff --git a/tests/hlo_texts/test_hlos/jax-enhance/module_0015.jit__threefry_fold_in.8.before_optimizations.txt b/tests/hlo_texts/test_hlos/jax-enhance/module_0015.jit__threefry_fold_in.8.before_optimizations.txt new file mode 100644 index 0000000..390ffe5 --- /dev/null +++ b/tests/hlo_texts/test_hlos/jax-enhance/module_0015.jit__threefry_fold_in.8.before_optimizations.txt @@ -0,0 +1,40 @@ +HloModule jit__threefry_fold_in.8 + +%xla_fallback_threefry2x32.11 (Arg_0.12: u32[], Arg_1.13: u32[], Arg_2.14: u32[1], Arg_3.15: u32[1]) -> (u32[1], u32[1]) { + %Arg_0.12 = u32[] parameter(0) + %reshape.16 = u32[1]{0} reshape(u32[] %Arg_0.12) + %Arg_1.13 = u32[] parameter(1) + %reshape.17 = u32[1]{0} reshape(u32[] %Arg_1.13) + %Arg_2.14 = u32[1]{0} parameter(2) + %Arg_3.15 = u32[1]{0} parameter(3) + ROOT %custom-call.18 = (u32[1]{0}, u32[1]{0}) custom-call(u32[1]{0} %reshape.16, u32[1]{0} %reshape.17, u32[1]{0} %Arg_2.14, u32[1]{0} %Arg_3.15), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[1]{0}, u32[1]{0}, u32[1]{0}, u32[1]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\001\000\000\000\000\000\000\000" +} + +%threefry2x32.19 (Arg_0.20: u32[], Arg_1.21: u32[], Arg_2.22: u32[1], Arg_3.23: u32[1]) -> (u32[1], u32[1]) { + %Arg_0.20 = u32[] parameter(0) + %Arg_1.21 = u32[] parameter(1) + %Arg_2.22 = u32[1]{0} parameter(2) + %Arg_3.23 = u32[1]{0} parameter(3) + %call.24 = (u32[1]{0}, u32[1]{0}) call(u32[] %Arg_0.20, u32[] %Arg_1.21, u32[1]{0} %Arg_2.22, u32[1]{0} %Arg_3.23), to_apply=%xla_fallback_threefry2x32.11 + %get-tuple-element.25 = u32[1]{0} get-tuple-element((u32[1]{0}, u32[1]{0}) %call.24), index=0 + %get-tuple-element.26 = u32[1]{0} get-tuple-element((u32[1]{0}, u32[1]{0}) %call.24), index=1 + ROOT %tuple.27 = (u32[1]{0}, u32[1]{0}) tuple(u32[1]{0} %get-tuple-element.25, u32[1]{0} %get-tuple-element.26) +} + +ENTRY %main.32 (Arg_0.1: u32[2], Arg_1.2: u32[]) -> u32[2] { + %Arg_0.1 = u32[2]{0} parameter(0) + %slice.7 = u32[1]{0} slice(u32[2]{0} %Arg_0.1), slice={[0:1]} + %reshape.8 = u32[] reshape(u32[1]{0} %slice.7) + %slice.9 = u32[1]{0} slice(u32[2]{0} %Arg_0.1), slice={[1:2]} + %reshape.10 = u32[] reshape(u32[1]{0} %slice.9) + %Arg_1.2 = u32[] parameter(1) + %constant.3 = u32[] constant(32) + %shift-right-logical.4 = u32[] shift-right-logical(u32[] %Arg_1.2, u32[] %constant.3) + %reshape.5 = u32[1]{0} reshape(u32[] %shift-right-logical.4) + %reshape.6 = u32[1]{0} reshape(u32[] %Arg_1.2) + %call.28 = (u32[1]{0}, u32[1]{0}) call(u32[] %reshape.8, u32[] %reshape.10, u32[1]{0} %reshape.5, u32[1]{0} %reshape.6), to_apply=%threefry2x32.19 + %get-tuple-element.29 = u32[1]{0} get-tuple-element((u32[1]{0}, u32[1]{0}) %call.28), index=0 + %get-tuple-element.30 = u32[1]{0} get-tuple-element((u32[1]{0}, u32[1]{0}) %call.28), index=1 + ROOT %concatenate.31 = u32[2]{0} concatenate(u32[1]{0} %get-tuple-element.29, u32[1]{0} %get-tuple-element.30), dimensions={0} +} + diff --git a/tests/hlo_texts/test_hlos/jax-enhance/module_0033.jit_prim_fun.13.before_optimizations.txt b/tests/hlo_texts/test_hlos/jax-enhance/module_0033.jit_prim_fun.13.before_optimizations.txt new file mode 100644 index 0000000..021a9b9 --- /dev/null +++ b/tests/hlo_texts/test_hlos/jax-enhance/module_0033.jit_prim_fun.13.before_optimizations.txt @@ -0,0 +1,8 @@ +HloModule jit_prim_fun.13 + +ENTRY %main.4 (Arg_0.1: f32[64,128,128,3], Arg_1.2: f32[5,5,3,64]) -> f32[64,128,128,64] { + %Arg_0.1 = f32[64,128,128,3]{3,2,1,0} parameter(0) + %Arg_1.2 = f32[5,5,3,64]{3,2,1,0} parameter(1) + ROOT %convolution.3 = f32[64,128,128,64]{3,2,1,0} convolution(f32[64,128,128,3]{3,2,1,0} %Arg_0.1, f32[5,5,3,64]{3,2,1,0} %Arg_1.2), window={size=5x5 pad=2_2x2_2}, dim_labels=b01f_01io->b01f +} + diff --git a/tests/hlo_texts/test_hlos/jax-enhance/module_0039.jit_fn.15.before_optimizations.txt b/tests/hlo_texts/test_hlos/jax-enhance/module_0039.jit_fn.15.before_optimizations.txt new file mode 100644 index 0000000..0590072 --- /dev/null +++ b/tests/hlo_texts/test_hlos/jax-enhance/module_0039.jit_fn.15.before_optimizations.txt @@ -0,0 +1,12 @@ +HloModule jit_fn.15 + +ENTRY %main.8 (Arg_0.1: f32[64,128,128,64], Arg_1.2: f32[64]) -> f32[64,128,128,64] { + %Arg_0.1 = f32[64,128,128,64]{3,2,1,0} parameter(0) + %Arg_1.2 = f32[64]{0} parameter(1) + %reshape.3 = f32[1,1,1,64]{3,2,1,0} reshape(f32[64]{0} %Arg_1.2) + %broadcast.4 = f32[1,1,1,64]{3,2,1,0} broadcast(f32[1,1,1,64]{3,2,1,0} %reshape.3), dimensions={0,1,2,3} + %reshape.5 = f32[64]{0} reshape(f32[1,1,1,64]{3,2,1,0} %broadcast.4) + %broadcast.6 = f32[64,128,128,64]{3,2,1,0} broadcast(f32[64]{0} %reshape.5), dimensions={3} + ROOT %add.7 = f32[64,128,128,64]{3,2,1,0} add(f32[64,128,128,64]{3,2,1,0} %Arg_0.1, f32[64,128,128,64]{3,2,1,0} %broadcast.6) +} + diff --git a/tests/hlo_texts/test_hlos/jax-md/module_0013.jit__lambda_.7.before_optimizations.txt b/tests/hlo_texts/test_hlos/jax-md/module_0013.jit__lambda_.7.before_optimizations.txt new file mode 100644 index 0000000..ab0ff65 --- /dev/null +++ b/tests/hlo_texts/test_hlos/jax-md/module_0013.jit__lambda_.7.before_optimizations.txt @@ -0,0 +1,16 @@ +HloModule jit__lambda_.7 + +ENTRY main.12 { + Arg_0.1 = f32[3,3]{1,0} parameter(0) + reshape.4 = f32[1,3,3]{2,1,0} reshape(Arg_0.1) + broadcast.5 = f32[1,3,3]{2,1,0} broadcast(reshape.4), dimensions={0,1,2} + reshape.6 = f32[3,3]{1,0} reshape(broadcast.5) + broadcast.7 = f32[3,3,3]{2,1,0} broadcast(reshape.6), dimensions={1,2} + Arg_1.2 = f32[3,3]{1,0} parameter(1) + reshape.3 = f32[3,1,3]{2,1,0} reshape(Arg_1.2) + broadcast.8 = f32[3,1,3]{2,1,0} broadcast(reshape.3), dimensions={0,1,2} + reshape.9 = f32[3,3]{1,0} reshape(broadcast.8) + broadcast.10 = f32[3,3,3]{2,1,0} broadcast(reshape.9), dimensions={0,2} + ROOT subtract.11 = f32[3,3,3]{2,1,0} subtract(broadcast.7, broadcast.10) +} + diff --git a/tests/hlo_texts/test_hlos/jax-md/module_0029.jit_safe_mask.15.before_optimizations.txt b/tests/hlo_texts/test_hlos/jax-md/module_0029.jit_safe_mask.15.before_optimizations.txt new file mode 100644 index 0000000..68d28d9 --- /dev/null +++ b/tests/hlo_texts/test_hlos/jax-md/module_0029.jit_safe_mask.15.before_optimizations.txt @@ -0,0 +1,29 @@ +HloModule jit_safe_mask.15 + +jit_vmap_vmap__where__.4 { + Arg_0.5 = pred[3,3]{1,0} parameter(0) + Arg_1.6 = f32[3,3]{1,0} parameter(1) + Arg_2.7 = s32[] parameter(2) + convert.8 = f32[] convert(Arg_2.7) + broadcast.9 = f32[3,3]{1,0} broadcast(convert.8), dimensions={} + ROOT select.10 = f32[3,3]{1,0} select(Arg_0.5, Arg_1.6, broadcast.9) +} + +jit_vmap_vmap__where___0.13 { + Arg_0.14 = pred[3,3]{1,0} parameter(0) + Arg_1.15 = f32[3,3]{1,0} parameter(1) + Arg_2.16 = s32[] parameter(2) + convert.17 = f32[] convert(Arg_2.16) + broadcast.18 = f32[3,3]{1,0} broadcast(convert.17), dimensions={} + ROOT select.19 = f32[3,3]{1,0} select(Arg_0.14, Arg_1.15, broadcast.18) +} + +ENTRY main.21 { + Arg_0.1 = pred[3,3]{1,0} parameter(0) + Arg_1.2 = f32[3,3]{1,0} parameter(1) + constant.3 = s32[] constant(0) + call.11 = f32[3,3]{1,0} call(Arg_0.1, Arg_1.2, constant.3), to_apply=jit_vmap_vmap__where__.4 + sqrt.12 = f32[3,3]{1,0} sqrt(call.11) + ROOT call.20 = f32[3,3]{1,0} call(Arg_0.1, sqrt.12, constant.3), to_apply=jit_vmap_vmap__where___0.13 +} + diff --git a/tests/hlo_texts/test_hlos/jax-md/module_0190.jit_safe_mask.61.before_optimizations.txt b/tests/hlo_texts/test_hlos/jax-md/module_0190.jit_safe_mask.61.before_optimizations.txt new file mode 100644 index 0000000..3e80e0a --- /dev/null +++ b/tests/hlo_texts/test_hlos/jax-md/module_0190.jit_safe_mask.61.before_optimizations.txt @@ -0,0 +1,53 @@ +HloModule jit_safe_mask.61 + +jit_jvp__where_.12 { + Arg_0.13 = pred[64,64]{1,0} parameter(0) + Arg_1.14 = f32[64,64]{1,0} parameter(1) + Arg_2.15 = s32[] parameter(2) + convert.18 = f32[] convert(Arg_2.15) + broadcast.19 = f32[64,64]{1,0} broadcast(convert.18), dimensions={} + select.20 = f32[64,64]{1,0} select(Arg_0.13, Arg_1.14, broadcast.19) + constant.16 = f32[] constant(0) + broadcast.17 = f32[64,64]{1,0} broadcast(constant.16), dimensions={} + ROOT tuple.21 = (f32[64,64]{1,0}, pred[64,64]{1,0}, f32[64,64]{1,0}) tuple(select.20, Arg_0.13, broadcast.17) +} + +jit_jvp__where__0.31 { + Arg_0.32 = pred[64,64]{1,0} parameter(0) + Arg_1.33 = f32[64,64]{1,0} parameter(1) + Arg_2.34 = f32[] parameter(2) + broadcast.37 = f32[64,64]{1,0} broadcast(Arg_2.34), dimensions={} + select.38 = f32[64,64]{1,0} select(Arg_0.32, Arg_1.33, broadcast.37) + constant.35 = f32[] constant(0) + broadcast.36 = f32[64,64]{1,0} broadcast(constant.35), dimensions={} + ROOT tuple.39 = (f32[64,64]{1,0}, pred[64,64]{1,0}, f32[64,64]{1,0}) tuple(select.38, Arg_0.32, broadcast.36) +} + +ENTRY main.45 { + Arg_0.1 = pred[64,64]{1,0} parameter(0) + constant.8 = f32[] constant(1) + broadcast.9 = f32[64,64]{1,0} broadcast(constant.8), dimensions={} + Arg_1.2 = f32[64,64]{1,0} parameter(1) + constant.11 = s32[] constant(0) + call.22 = (f32[64,64]{1,0}, pred[64,64]{1,0}, f32[64,64]{1,0}) call(Arg_0.1, Arg_1.2, constant.11), to_apply=jit_jvp__where_.12 + get-tuple-element.23 = f32[64,64]{1,0} get-tuple-element(call.22), index=0 + subtract.26 = f32[64,64]{1,0} subtract(broadcast.9, get-tuple-element.23) + constant.6 = f32[] constant(2) + broadcast.7 = f32[64,64]{1,0} broadcast(constant.6), dimensions={} + power.27 = f32[64,64]{1,0} power(subtract.26, broadcast.7) + constant.4 = f32[] constant(0.5) + broadcast.5 = f32[64,64]{1,0} broadcast(constant.4), dimensions={} + multiply.30 = f32[64,64]{1,0} multiply(power.27, broadcast.5) + Arg_2.3 = f32[] parameter(2) + call.40 = (f32[64,64]{1,0}, pred[64,64]{1,0}, f32[64,64]{1,0}) call(Arg_0.1, multiply.30, Arg_2.3), to_apply=jit_jvp__where__0.31 + get-tuple-element.41 = f32[64,64]{1,0} get-tuple-element(call.40), index=0 + get-tuple-element.42 = pred[64,64]{1,0} get-tuple-element(call.40), index=1 + get-tuple-element.43 = f32[64,64]{1,0} get-tuple-element(call.40), index=2 + constant.10 = f32[] constant(0.5) + power.28 = f32[64,64]{1,0} power(subtract.26, broadcast.9) + multiply.29 = f32[64,64]{1,0} multiply(power.28, broadcast.7) + get-tuple-element.24 = pred[64,64]{1,0} get-tuple-element(call.22), index=1 + get-tuple-element.25 = f32[64,64]{1,0} get-tuple-element(call.22), index=2 + ROOT tuple.44 = (f32[64,64]{1,0}, pred[64,64]{1,0}, f32[64,64]{1,0}, f32[], f32[64,64]{1,0}, /*index=5*/pred[64,64]{1,0}, f32[64,64]{1,0}) tuple(get-tuple-element.41, get-tuple-element.42, get-tuple-element.43, constant.10, multiply.29, get-tuple-element.24, get-tuple-element.25) +} + diff --git a/tests/hlo_texts/test_hlos/jax-models/1648622084550459.module_0235.jit_fn__34.7.before_optimizations.txt b/tests/hlo_texts/test_hlos/jax-models/1648622084550459.module_0235.jit_fn__34.7.before_optimizations.txt new file mode 100644 index 0000000..22914ce --- /dev/null +++ b/tests/hlo_texts/test_hlos/jax-models/1648622084550459.module_0235.jit_fn__34.7.before_optimizations.txt @@ -0,0 +1,11 @@ +HloModule jit_fn__34.7 + +ENTRY %jit_fn__34.7 (parameter.1: f32[64,16,16,384], parameter.2: f32[]) -> f32[64,16,16,384] { + %constant.3 = pred[] constant(false) + %parameter.1 = f32[64,16,16,384]{3,2,1,0} parameter(0) + %parameter.2 = f32[] parameter(1) + %convert.4 = f32[] convert(f32[] %parameter.2) + %broadcast.5 = f32[64,16,16,384]{3,2,1,0} broadcast(f32[] %convert.4), dimensions={} + ROOT %multiply.6 = f32[64,16,16,384]{3,2,1,0} multiply(f32[64,16,16,384]{3,2,1,0} %parameter.1, f32[64,16,16,384]{3,2,1,0} %broadcast.5) +} + diff --git a/tests/hlo_texts/test_hlos/jax-models/1648627826626299.module_0161.jit__reduce_max.11.before_optimizations.txt b/tests/hlo_texts/test_hlos/jax-models/1648627826626299.module_0161.jit__reduce_max.11.before_optimizations.txt new file mode 100644 index 0000000..ead776a --- /dev/null +++ b/tests/hlo_texts/test_hlos/jax-models/1648627826626299.module_0161.jit__reduce_max.11.before_optimizations.txt @@ -0,0 +1,17 @@ +HloModule jit__reduce_max.11 + +%primitive_computation_max.4 (parameter.5: f32[], parameter.6: f32[]) -> f32[] { + %constant.7 = pred[] constant(false) + %parameter.5 = f32[] parameter(0) + %parameter.6 = f32[] parameter(1) + ROOT %maximum.8 = f32[] maximum(f32[] %parameter.5, f32[] %parameter.6) +} + +ENTRY %jit__reduce_max.11 (parameter.1: f32[4096,3,49,49]) -> f32[4096,3,49,1] { + %constant.2 = pred[] constant(false) + %parameter.1 = f32[4096,3,49,49]{3,2,1,0} parameter(0) + %constant.3 = f32[] constant(-inf) + %reduce.9 = f32[4096,3,49]{2,1,0} reduce(f32[4096,3,49,49]{3,2,1,0} %parameter.1, f32[] %constant.3), dimensions={3}, to_apply=%primitive_computation_max.4 + ROOT %broadcast.10 = f32[4096,3,49,1]{3,2,1,0} broadcast(f32[4096,3,49]{2,1,0} %reduce.9), dimensions={0,1,2} +} + diff --git a/tests/hlo_texts/test_hlos/jax-models/module_0471.jit__uniform.218.before_optimizations.txt b/tests/hlo_texts/test_hlos/jax-models/module_0471.jit__uniform.218.before_optimizations.txt new file mode 100644 index 0000000..9882d14 --- /dev/null +++ b/tests/hlo_texts/test_hlos/jax-models/module_0471.jit__uniform.218.before_optimizations.txt @@ -0,0 +1,67 @@ +HloModule jit__uniform.218 + +%xla_fallback_threefry2x32.20 (Arg_0.21: u32[], Arg_1.22: u32[], Arg_2.23: u32[65536], Arg_3.24: u32[65536]) -> (u32[65536], u32[65536]) { + %Arg_0.21 = u32[] parameter(0) + %broadcast.25 = u32[65536]{0} broadcast(u32[] %Arg_0.21), dimensions={} + %Arg_1.22 = u32[] parameter(1) + %broadcast.26 = u32[65536]{0} broadcast(u32[] %Arg_1.22), dimensions={} + %Arg_2.23 = u32[65536]{0} parameter(2) + %Arg_3.24 = u32[65536]{0} parameter(3) + ROOT %custom-call.27 = (u32[65536]{0}, u32[65536]{0}) custom-call(u32[65536]{0} %broadcast.25, u32[65536]{0} %broadcast.26, u32[65536]{0} %Arg_2.23, u32[65536]{0} %Arg_3.24), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[65536]{0}, u32[65536]{0}, u32[65536]{0}, u32[65536]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\000\000\001\000\000\000\000\000" +} + +%threefry2x32.28 (Arg_0.29: u32[], Arg_1.30: u32[], Arg_2.31: u32[65536], Arg_3.32: u32[65536]) -> (u32[65536], u32[65536]) { + %Arg_0.29 = u32[] parameter(0) + %Arg_1.30 = u32[] parameter(1) + %Arg_2.31 = u32[65536]{0} parameter(2) + %Arg_3.32 = u32[65536]{0} parameter(3) + %call.33 = (u32[65536]{0}, u32[65536]{0}) call(u32[] %Arg_0.29, u32[] %Arg_1.30, u32[65536]{0} %Arg_2.31, u32[65536]{0} %Arg_3.32), to_apply=%xla_fallback_threefry2x32.20 + %get-tuple-element.34 = u32[65536]{0} get-tuple-element((u32[65536]{0}, u32[65536]{0}) %call.33), index=0 + %get-tuple-element.35 = u32[65536]{0} get-tuple-element((u32[65536]{0}, u32[65536]{0}) %call.33), index=1 + ROOT %tuple.36 = (u32[65536]{0}, u32[65536]{0}) tuple(u32[65536]{0} %get-tuple-element.34, u32[65536]{0} %get-tuple-element.35) +} + +ENTRY %main.59 (Arg_0.1: u32[2], Arg_1.2: s32[], Arg_2.3: f32[]) -> f32[128,1024] { + %Arg_1.2 = s32[] parameter(1) + %convert.10 = f32[] convert(s32[] %Arg_1.2) + %reshape.11 = f32[1,1]{1,0} reshape(f32[] %convert.10) + %broadcast.55 = f32[1,1]{1,0} broadcast(f32[1,1]{1,0} %reshape.11), dimensions={0,1} + %reshape.56 = f32[] reshape(f32[1,1]{1,0} %broadcast.55) + %broadcast.57 = f32[128,1024]{1,0} broadcast(f32[] %reshape.56), dimensions={} + %Arg_0.1 = u32[2]{0} parameter(0) + %slice.14 = u32[1]{0} slice(u32[2]{0} %Arg_0.1), slice={[0:1]} + %reshape.15 = u32[] reshape(u32[1]{0} %slice.14) + %slice.16 = u32[1]{0} slice(u32[2]{0} %Arg_0.1), slice={[1:2]} + %reshape.17 = u32[] reshape(u32[1]{0} %slice.16) + %iota.13 = u32[131072]{0} iota(), iota_dimension=0 + %slice.18 = u32[65536]{0} slice(u32[131072]{0} %iota.13), slice={[0:65536]} + %slice.19 = u32[65536]{0} slice(u32[131072]{0} %iota.13), slice={[65536:131072]} + %call.37 = (u32[65536]{0}, u32[65536]{0}) call(u32[] %reshape.15, u32[] %reshape.17, u32[65536]{0} %slice.18, u32[65536]{0} %slice.19), to_apply=%threefry2x32.28 + %get-tuple-element.38 = u32[65536]{0} get-tuple-element((u32[65536]{0}, u32[65536]{0}) %call.37), index=0 + %get-tuple-element.39 = u32[65536]{0} get-tuple-element((u32[65536]{0}, u32[65536]{0}) %call.37), index=1 + %concatenate.40 = u32[131072]{0} concatenate(u32[65536]{0} %get-tuple-element.38, u32[65536]{0} %get-tuple-element.39), dimensions={0} + %reshape.41 = u32[128,1024]{1,0} reshape(u32[131072]{0} %concatenate.40) + %constant.8 = u32[] constant(9) + %broadcast.9 = u32[128,1024]{1,0} broadcast(u32[] %constant.8), dimensions={} + %shift-right-logical.42 = u32[128,1024]{1,0} shift-right-logical(u32[128,1024]{1,0} %reshape.41, u32[128,1024]{1,0} %broadcast.9) + %constant.6 = u32[] constant(1065353216) + %broadcast.7 = u32[128,1024]{1,0} broadcast(u32[] %constant.6), dimensions={} + %or.43 = u32[128,1024]{1,0} or(u32[128,1024]{1,0} %shift-right-logical.42, u32[128,1024]{1,0} %broadcast.7) + %bitcast-convert.44 = f32[128,1024]{1,0} bitcast-convert(u32[128,1024]{1,0} %or.43) + %constant.4 = f32[] constant(1) + %broadcast.5 = f32[128,1024]{1,0} broadcast(f32[] %constant.4), dimensions={} + %subtract.45 = f32[128,1024]{1,0} subtract(f32[128,1024]{1,0} %bitcast-convert.44, f32[128,1024]{1,0} %broadcast.5) + %Arg_2.3 = f32[] parameter(2) + %reshape.12 = f32[1,1]{1,0} reshape(f32[] %Arg_2.3) + %subtract.46 = f32[1,1]{1,0} subtract(f32[1,1]{1,0} %reshape.12, f32[1,1]{1,0} %reshape.11) + %broadcast.47 = f32[1,1]{1,0} broadcast(f32[1,1]{1,0} %subtract.46), dimensions={0,1} + %reshape.48 = f32[] reshape(f32[1,1]{1,0} %broadcast.47) + %broadcast.49 = f32[128,1024]{1,0} broadcast(f32[] %reshape.48), dimensions={} + %multiply.50 = f32[128,1024]{1,0} multiply(f32[128,1024]{1,0} %subtract.45, f32[128,1024]{1,0} %broadcast.49) + %broadcast.51 = f32[1,1]{1,0} broadcast(f32[1,1]{1,0} %reshape.11), dimensions={0,1} + %reshape.52 = f32[] reshape(f32[1,1]{1,0} %broadcast.51) + %broadcast.53 = f32[128,1024]{1,0} broadcast(f32[] %reshape.52), dimensions={} + %add.54 = f32[128,1024]{1,0} add(f32[128,1024]{1,0} %multiply.50, f32[128,1024]{1,0} %broadcast.53) + ROOT %maximum.58 = f32[128,1024]{1,0} maximum(f32[128,1024]{1,0} %broadcast.57, f32[128,1024]{1,0} %add.54) +} + diff --git a/tests/hlo_texts/test_hlos/jax-unirep/module_0050.jit__threefry_split.22.before_optimizations.txt b/tests/hlo_texts/test_hlos/jax-unirep/module_0050.jit__threefry_split.22.before_optimizations.txt new file mode 100644 index 0000000..6678911 --- /dev/null +++ b/tests/hlo_texts/test_hlos/jax-unirep/module_0050.jit__threefry_split.22.before_optimizations.txt @@ -0,0 +1,39 @@ +HloModule jit__threefry_split.22 + +xla_fallback_threefry2x32.9 { + Arg_0.10 = u32[] parameter(0) + broadcast.14 = u32[4]{0} broadcast(Arg_0.10), dimensions={} + Arg_1.11 = u32[] parameter(1) + broadcast.15 = u32[4]{0} broadcast(Arg_1.11), dimensions={} + Arg_2.12 = u32[4]{0} parameter(2) + Arg_3.13 = u32[4]{0} parameter(3) + ROOT custom-call.16 = (u32[4]{0}, u32[4]{0}) custom-call(broadcast.14, broadcast.15, Arg_2.12, Arg_3.13), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[4]{0}, u32[4]{0}, u32[4]{0}, u32[4]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\004\000\000\000\000\000\000\000" +} + +threefry2x32.17 { + Arg_0.18 = u32[] parameter(0) + Arg_1.19 = u32[] parameter(1) + Arg_2.20 = u32[4]{0} parameter(2) + Arg_3.21 = u32[4]{0} parameter(3) + call.22 = (u32[4]{0}, u32[4]{0}) call(Arg_0.18, Arg_1.19, Arg_2.20, Arg_3.21), to_apply=xla_fallback_threefry2x32.9 + get-tuple-element.23 = u32[4]{0} get-tuple-element(call.22), index=0 + get-tuple-element.24 = u32[4]{0} get-tuple-element(call.22), index=1 + ROOT tuple.25 = (u32[4]{0}, u32[4]{0}) tuple(get-tuple-element.23, get-tuple-element.24) +} + +ENTRY main.31 { + Arg_0.1 = u32[2]{0} parameter(0) + slice.3 = u32[1]{0} slice(Arg_0.1), slice={[0:1]} + reshape.4 = u32[] reshape(slice.3) + slice.5 = u32[1]{0} slice(Arg_0.1), slice={[1:2]} + reshape.6 = u32[] reshape(slice.5) + iota.2 = u32[8]{0} iota(), iota_dimension=0 + slice.7 = u32[4]{0} slice(iota.2), slice={[0:4]} + slice.8 = u32[4]{0} slice(iota.2), slice={[4:8]} + call.26 = (u32[4]{0}, u32[4]{0}) call(reshape.4, reshape.6, slice.7, slice.8), to_apply=threefry2x32.17 + get-tuple-element.27 = u32[4]{0} get-tuple-element(call.26), index=0 + get-tuple-element.28 = u32[4]{0} get-tuple-element(call.26), index=1 + concatenate.29 = u32[8]{0} concatenate(get-tuple-element.27, get-tuple-element.28), dimensions={0} + ROOT reshape.30 = u32[4,2]{1,0} reshape(concatenate.29) +} + diff --git a/tests/hlo_texts/test_hlos/jax-unirep/module_0054.jit__unstack.23.before_optimizations.txt b/tests/hlo_texts/test_hlos/jax-unirep/module_0054.jit__unstack.23.before_optimizations.txt new file mode 100644 index 0000000..893d25b --- /dev/null +++ b/tests/hlo_texts/test_hlos/jax-unirep/module_0054.jit__unstack.23.before_optimizations.txt @@ -0,0 +1,15 @@ +HloModule jit__unstack.23 + +ENTRY main.11 { + Arg_0.1 = u32[4,2]{1,0} parameter(0) + slice.2 = u32[1,2]{1,0} slice(Arg_0.1), slice={[0:1], [0:2]} + reshape.3 = u32[2]{0} reshape(slice.2) + slice.4 = u32[1,2]{1,0} slice(Arg_0.1), slice={[1:2], [0:2]} + reshape.5 = u32[2]{0} reshape(slice.4) + slice.6 = u32[1,2]{1,0} slice(Arg_0.1), slice={[2:3], [0:2]} + reshape.7 = u32[2]{0} reshape(slice.6) + slice.8 = u32[1,2]{1,0} slice(Arg_0.1), slice={[3:4], [0:2]} + reshape.9 = u32[2]{0} reshape(slice.8) + ROOT tuple.10 = (u32[2]{0}, u32[2]{0}, u32[2]{0}, u32[2]{0}) tuple(reshape.3, reshape.5, reshape.7, reshape.9) +} + diff --git a/tests/hlo_texts/test_hlos/jax-unirep/module_0119.jit__normal.38.before_optimizations.txt b/tests/hlo_texts/test_hlos/jax-unirep/module_0119.jit__normal.38.before_optimizations.txt new file mode 100644 index 0000000..c8f6658 --- /dev/null +++ b/tests/hlo_texts/test_hlos/jax-unirep/module_0119.jit__normal.38.before_optimizations.txt @@ -0,0 +1,156 @@ +HloModule jit__normal.38 + +xla_fallback_threefry2x32.23 { + Arg_0.24 = u32[] parameter(0) + broadcast.28 = u32[13]{0} broadcast(Arg_0.24), dimensions={} + Arg_1.25 = u32[] parameter(1) + broadcast.29 = u32[13]{0} broadcast(Arg_1.25), dimensions={} + Arg_2.26 = u32[13]{0} parameter(2) + Arg_3.27 = u32[13]{0} parameter(3) + ROOT custom-call.30 = (u32[13]{0}, u32[13]{0}) custom-call(broadcast.28, broadcast.29, Arg_2.26, Arg_3.27), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[13]{0}, u32[13]{0}, u32[13]{0}, u32[13]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\r\000\000\000\000\000\000\000" +} + +threefry2x32.31 { + Arg_0.32 = u32[] parameter(0) + Arg_1.33 = u32[] parameter(1) + Arg_2.34 = u32[13]{0} parameter(2) + Arg_3.35 = u32[13]{0} parameter(3) + call.36 = (u32[13]{0}, u32[13]{0}) call(Arg_0.32, Arg_1.33, Arg_2.34, Arg_3.35), to_apply=xla_fallback_threefry2x32.23 + get-tuple-element.37 = u32[13]{0} get-tuple-element(call.36), index=0 + get-tuple-element.38 = u32[13]{0} get-tuple-element(call.36), index=1 + ROOT tuple.39 = (u32[13]{0}, u32[13]{0}) tuple(get-tuple-element.37, get-tuple-element.38) +} + +xla_fallback_erf_inv.52 { + Arg_0.53 = f32[25]{0} parameter(0) + abs.100 = f32[25]{0} abs(Arg_0.53) + constant.98 = f32[] constant(1) + broadcast.99 = f32[25]{0} broadcast(constant.98), dimensions={} + compare.101 = pred[25]{0} compare(abs.100, broadcast.99), direction=EQ + constant.96 = f32[] constant(inf) + broadcast.97 = f32[25]{0} broadcast(constant.96), dimensions={} + multiply.102 = f32[25]{0} multiply(Arg_0.53, broadcast.97) + negate.103 = f32[25]{0} negate(Arg_0.53) + multiply.104 = f32[25]{0} multiply(negate.103, Arg_0.53) + log-plus-one.105 = f32[25]{0} log-plus-one(multiply.104) + negate.106 = f32[25]{0} negate(log-plus-one.105) + constant.94 = f32[] constant(5) + broadcast.95 = f32[25]{0} broadcast(constant.94), dimensions={} + compare.107 = pred[25]{0} compare(negate.106, broadcast.95), direction=LT + constant.92 = f32[] constant(1.50140941) + broadcast.93 = f32[25]{0} broadcast(constant.92), dimensions={} + constant.90 = f32[] constant(2.83297682) + broadcast.91 = f32[25]{0} broadcast(constant.90), dimensions={} + select.108 = f32[25]{0} select(compare.107, broadcast.93, broadcast.91) + constant.88 = f32[] constant(0.246640727) + broadcast.89 = f32[25]{0} broadcast(constant.88), dimensions={} + constant.86 = f32[] constant(1.00167406) + broadcast.87 = f32[25]{0} broadcast(constant.86), dimensions={} + select.109 = f32[25]{0} select(compare.107, broadcast.89, broadcast.87) + constant.84 = f32[] constant(-0.00417768164) + broadcast.85 = f32[25]{0} broadcast(constant.84), dimensions={} + constant.82 = f32[] constant(0.00943887047) + broadcast.83 = f32[25]{0} broadcast(constant.82), dimensions={} + select.110 = f32[25]{0} select(compare.107, broadcast.85, broadcast.83) + constant.80 = f32[] constant(-0.00125372503) + broadcast.81 = f32[25]{0} broadcast(constant.80), dimensions={} + constant.78 = f32[] constant(-0.0076224613) + broadcast.79 = f32[25]{0} broadcast(constant.78), dimensions={} + select.111 = f32[25]{0} select(compare.107, broadcast.81, broadcast.79) + constant.76 = f32[] constant(0.00021858087) + broadcast.77 = f32[25]{0} broadcast(constant.76), dimensions={} + constant.74 = f32[] constant(0.00573950773) + broadcast.75 = f32[25]{0} broadcast(constant.74), dimensions={} + select.112 = f32[25]{0} select(compare.107, broadcast.77, broadcast.75) + constant.72 = f32[] constant(-4.39150654e-06) + broadcast.73 = f32[25]{0} broadcast(constant.72), dimensions={} + constant.70 = f32[] constant(-0.00367342844) + broadcast.71 = f32[25]{0} broadcast(constant.70), dimensions={} + select.113 = f32[25]{0} select(compare.107, broadcast.73, broadcast.71) + constant.68 = f32[] constant(-3.5233877e-06) + broadcast.69 = f32[25]{0} broadcast(constant.68), dimensions={} + constant.66 = f32[] constant(0.00134934322) + broadcast.67 = f32[25]{0} broadcast(constant.66), dimensions={} + select.114 = f32[25]{0} select(compare.107, broadcast.69, broadcast.67) + constant.64 = f32[] constant(3.43273939e-07) + broadcast.65 = f32[25]{0} broadcast(constant.64), dimensions={} + constant.62 = f32[] constant(0.000100950558) + broadcast.63 = f32[25]{0} broadcast(constant.62), dimensions={} + select.115 = f32[25]{0} select(compare.107, broadcast.65, broadcast.63) + constant.60 = f32[] constant(2.81022636e-08) + broadcast.61 = f32[25]{0} broadcast(constant.60), dimensions={} + constant.58 = f32[] constant(-0.000200214257) + broadcast.59 = f32[25]{0} broadcast(constant.58), dimensions={} + select.116 = f32[25]{0} select(compare.107, broadcast.61, broadcast.59) + constant.56 = f32[] constant(2.5) + broadcast.57 = f32[25]{0} broadcast(constant.56), dimensions={} + subtract.117 = f32[25]{0} subtract(negate.106, broadcast.57) + sqrt.118 = f32[25]{0} sqrt(negate.106) + constant.54 = f32[] constant(3) + broadcast.55 = f32[25]{0} broadcast(constant.54), dimensions={} + subtract.119 = f32[25]{0} subtract(sqrt.118, broadcast.55) + select.120 = f32[25]{0} select(compare.107, subtract.117, subtract.119) + multiply.121 = f32[25]{0} multiply(select.116, select.120) + add.122 = f32[25]{0} add(select.115, multiply.121) + multiply.123 = f32[25]{0} multiply(add.122, select.120) + add.124 = f32[25]{0} add(select.114, multiply.123) + multiply.125 = f32[25]{0} multiply(add.124, select.120) + add.126 = f32[25]{0} add(select.113, multiply.125) + multiply.127 = f32[25]{0} multiply(add.126, select.120) + add.128 = f32[25]{0} add(select.112, multiply.127) + multiply.129 = f32[25]{0} multiply(add.128, select.120) + add.130 = f32[25]{0} add(select.111, multiply.129) + multiply.131 = f32[25]{0} multiply(add.130, select.120) + add.132 = f32[25]{0} add(select.110, multiply.131) + multiply.133 = f32[25]{0} multiply(add.132, select.120) + add.134 = f32[25]{0} add(select.109, multiply.133) + multiply.135 = f32[25]{0} multiply(add.134, select.120) + add.136 = f32[25]{0} add(select.108, multiply.135) + multiply.137 = f32[25]{0} multiply(add.136, Arg_0.53) + ROOT select.138 = f32[25]{0} select(compare.101, multiply.102, multiply.137) +} + +erf_inv.139 { + Arg_0.140 = f32[25]{0} parameter(0) + ROOT call.141 = f32[25]{0} call(Arg_0.140), to_apply=xla_fallback_erf_inv.52 +} + +ENTRY main.144 { + Arg_0.1 = u32[2]{0} parameter(0) + slice.16 = u32[1]{0} slice(Arg_0.1), slice={[0:1]} + reshape.17 = u32[] reshape(slice.16) + slice.18 = u32[1]{0} slice(Arg_0.1), slice={[1:2]} + reshape.19 = u32[] reshape(slice.18) + iota.15 = u32[25]{0} iota(), iota_dimension=0 + slice.21 = u32[13]{0} slice(iota.15), slice={[0:13]} + constant.14 = u32[1]{0} constant({0}) + concatenate.20 = u32[26]{0} concatenate(iota.15, constant.14), dimensions={0} + slice.22 = u32[13]{0} slice(concatenate.20), slice={[13:26]} + call.40 = (u32[13]{0}, u32[13]{0}) call(reshape.17, reshape.19, slice.21, slice.22), to_apply=threefry2x32.31 + get-tuple-element.41 = u32[13]{0} get-tuple-element(call.40), index=0 + get-tuple-element.42 = u32[13]{0} get-tuple-element(call.40), index=1 + concatenate.43 = u32[26]{0} concatenate(get-tuple-element.41, get-tuple-element.42), dimensions={0} + slice.44 = u32[25]{0} slice(concatenate.43), slice={[0:25]} + constant.12 = u32[] constant(9) + broadcast.13 = u32[25]{0} broadcast(constant.12), dimensions={} + shift-right-logical.45 = u32[25]{0} shift-right-logical(slice.44, broadcast.13) + constant.10 = u32[] constant(1065353216) + broadcast.11 = u32[25]{0} broadcast(constant.10), dimensions={} + or.46 = u32[25]{0} or(shift-right-logical.45, broadcast.11) + bitcast-convert.47 = f32[25]{0} bitcast-convert(or.46) + constant.8 = f32[] constant(1) + broadcast.9 = f32[25]{0} broadcast(constant.8), dimensions={} + subtract.48 = f32[25]{0} subtract(bitcast-convert.47, broadcast.9) + constant.6 = f32[] constant(2) + broadcast.7 = f32[25]{0} broadcast(constant.6), dimensions={} + multiply.49 = f32[25]{0} multiply(subtract.48, broadcast.7) + constant.4 = f32[] constant(-0.99999994) + broadcast.5 = f32[25]{0} broadcast(constant.4), dimensions={} + add.50 = f32[25]{0} add(multiply.49, broadcast.5) + maximum.51 = f32[25]{0} maximum(add.50, broadcast.5) + call.142 = f32[25]{0} call(maximum.51), to_apply=erf_inv.139 + constant.2 = f32[] constant(1.41421354) + broadcast.3 = f32[25]{0} broadcast(constant.2), dimensions={} + ROOT multiply.143 = f32[25]{0} multiply(call.142, broadcast.3) +} + diff --git a/tests/hlo_texts/test_hlos/jax_muzero/1649835456716499.module_0095.jit__var__1.31.before_optimizations.txt b/tests/hlo_texts/test_hlos/jax_muzero/1649835456716499.module_0095.jit__var__1.31.before_optimizations.txt new file mode 100644 index 0000000..dff2817 --- /dev/null +++ b/tests/hlo_texts/test_hlos/jax_muzero/1649835456716499.module_0095.jit__var__1.31.before_optimizations.txt @@ -0,0 +1,39 @@ +HloModule jit__var__1.31 + +%primitive_computation_add.5 (parameter.6: f32[], parameter.7: f32[]) -> f32[] { + %parameter.6 = f32[] parameter(0) + %parameter.7 = f32[] parameter(1) + ROOT %add.8 = f32[] add(f32[] %parameter.6, f32[] %parameter.7) +} + +%primitive_computation_add.21 (parameter.22: f32[], parameter.23: f32[]) -> f32[] { + %parameter.22 = f32[] parameter(0) + %parameter.23 = f32[] parameter(1) + ROOT %add.24 = f32[] add(f32[] %parameter.22, f32[] %parameter.23) +} + +ENTRY %jit__var__1.31 (parameter.1: f32[24,24,64], parameter.2: s32[]) -> (f32[1,1,1]) { + %constant.3 = pred[] constant(false) + %parameter.1 = f32[24,24,64]{2,1,0} parameter(0) + %constant.4 = f32[] constant(0) + %reduce.9 = f32[] reduce(f32[24,24,64]{2,1,0} %parameter.1, f32[] %constant.4), dimensions={0,1,2}, to_apply=%primitive_computation_add.5 + %broadcast.10 = f32[1,1,1]{2,1,0} broadcast(f32[] %reduce.9), dimensions={} + %constant.11 = f32[] constant(36864) + %broadcast.12 = f32[1,1,1]{2,1,0} broadcast(f32[] %constant.11), dimensions={} + %divide.13 = f32[1,1,1]{2,1,0} divide(f32[1,1,1]{2,1,0} %broadcast.10, f32[1,1,1]{2,1,0} %broadcast.12) + %reshape.14 = f32[] reshape(f32[1,1,1]{2,1,0} %divide.13) + %broadcast.15 = f32[24,24,64]{2,1,0} broadcast(f32[] %reshape.14), dimensions={} + %subtract.16 = f32[24,24,64]{2,1,0} subtract(f32[24,24,64]{2,1,0} %parameter.1, f32[24,24,64]{2,1,0} %broadcast.15) + %multiply.17 = f32[24,24,64]{2,1,0} multiply(f32[24,24,64]{2,1,0} %subtract.16, f32[24,24,64]{2,1,0} %subtract.16) + %constant.20 = f32[] constant(0) + %reduce.25 = f32[] reduce(f32[24,24,64]{2,1,0} %multiply.17, f32[] %constant.20), dimensions={0,1,2}, to_apply=%primitive_computation_add.21 + %broadcast.26 = f32[1,1,1]{2,1,0} broadcast(f32[] %reduce.25), dimensions={} + %constant.18 = s32[] constant(36864) + %parameter.2 = s32[] parameter(1) + %subtract.19 = s32[] subtract(s32[] %constant.18, s32[] %parameter.2) + %convert.27 = f32[] convert(s32[] %subtract.19) + %broadcast.28 = f32[1,1,1]{2,1,0} broadcast(f32[] %convert.27), dimensions={} + %divide.29 = f32[1,1,1]{2,1,0} divide(f32[1,1,1]{2,1,0} %broadcast.26, f32[1,1,1]{2,1,0} %broadcast.28) + ROOT %tuple.30 = (f32[1,1,1]{2,1,0}) tuple(f32[1,1,1]{2,1,0} %divide.29) +} + diff --git a/tests/hlo_texts/test_hlos/jax_muzero/1649835462650207.module_0259.jit__lambda___12.8.before_optimizations.txt b/tests/hlo_texts/test_hlos/jax_muzero/1649835462650207.module_0259.jit__lambda___12.8.before_optimizations.txt new file mode 100644 index 0000000..559e091 --- /dev/null +++ b/tests/hlo_texts/test_hlos/jax_muzero/1649835462650207.module_0259.jit__lambda___12.8.before_optimizations.txt @@ -0,0 +1,12 @@ +HloModule jit__lambda___12.8 + +ENTRY %jit__lambda___12.8 (parameter.1: f32[32], parameter.2: s32[]) -> (f32[32]) { + %constant.3 = pred[] constant(false) + %parameter.1 = f32[32]{0} parameter(0) + %parameter.2 = s32[] parameter(1) + %convert.4 = f32[] convert(s32[] %parameter.2) + %broadcast.5 = f32[32]{0} broadcast(f32[] %convert.4), dimensions={} + %maximum.6 = f32[32]{0} maximum(f32[32]{0} %parameter.1, f32[32]{0} %broadcast.5) + ROOT %tuple.7 = (f32[32]{0}) tuple(f32[32]{0} %maximum.6) +} + diff --git a/tests/hlo_texts/test_hlos/jax_muzero/1649835463509413.module_0275.jit__truncated_normal__7.318.before_optimizations.txt b/tests/hlo_texts/test_hlos/jax_muzero/1649835463509413.module_0275.jit__truncated_normal__7.318.before_optimizations.txt new file mode 100644 index 0000000..fcfbf22 --- /dev/null +++ b/tests/hlo_texts/test_hlos/jax_muzero/1649835463509413.module_0275.jit__truncated_normal__7.318.before_optimizations.txt @@ -0,0 +1,324 @@ +HloModule jit__truncated_normal__7.318 + +%jit_clip__7.305 (parameter.306: f32[32,4], parameter.307: f32[], parameter.308: f32[]) -> (f32[32,4]) { + %constant.309 = pred[] constant(false) + %parameter.308 = f32[] parameter(2) + %broadcast.312 = f32[32,4]{1,0} broadcast(f32[] %parameter.308), dimensions={} + %parameter.307 = f32[] parameter(1) + %broadcast.310 = f32[32,4]{1,0} broadcast(f32[] %parameter.307), dimensions={} + %parameter.306 = f32[32,4]{1,0} parameter(0) + %maximum.311 = f32[32,4]{1,0} maximum(f32[32,4]{1,0} %broadcast.310, f32[32,4]{1,0} %parameter.306) + %minimum.313 = f32[32,4]{1,0} minimum(f32[32,4]{1,0} %broadcast.312, f32[32,4]{1,0} %maximum.311) + ROOT %tuple.314 = (f32[32,4]{1,0}) tuple(f32[32,4]{1,0} %minimum.313) +} + +ENTRY %jit__truncated_normal__7.318 (parameter.1: u32[2], parameter.2: f32[], parameter.3: f32[]) -> (f32[32,4]) { + %constant.4 = pred[] constant(false) + %constant.10 = f32[] constant(-4) + %parameter.2 = f32[] parameter(1) + %convert.5 = f32[] convert(f32[] %parameter.2) + %constant.7 = f32[] constant(1.41421354) + %divide.8 = f32[] divide(f32[] %convert.5, f32[] %constant.7) + %constant.9 = f32[] constant(4) + %clamp.11 = f32[] clamp(f32[] %constant.10, f32[] %divide.8, f32[] %constant.9) + %constant.29 = f32[] constant(0) + %multiply.12 = f32[] multiply(f32[] %clamp.11, f32[] %clamp.11) + %multiply.31 = f32[] multiply(f32[] %constant.29, f32[] %multiply.12) + %constant.30 = f32[] constant(-2.72614237e-10) + %add.32 = f32[] add(f32[] %multiply.31, f32[] %constant.30) + %multiply.34 = f32[] multiply(f32[] %add.32, f32[] %multiply.12) + %constant.33 = f32[] constant(2.77068146e-08) + %add.35 = f32[] add(f32[] %multiply.34, f32[] %constant.33) + %multiply.37 = f32[] multiply(f32[] %add.35, f32[] %multiply.12) + %constant.36 = f32[] constant(-2.10102394e-06) + %add.38 = f32[] add(f32[] %multiply.37, f32[] %constant.36) + %multiply.40 = f32[] multiply(f32[] %add.38, f32[] %multiply.12) + %constant.39 = f32[] constant(-5.69250624e-05) + %add.41 = f32[] add(f32[] %multiply.40, f32[] %constant.39) + %multiply.43 = f32[] multiply(f32[] %add.41, f32[] %multiply.12) + %constant.42 = f32[] constant(-0.000734990637) + %add.44 = f32[] add(f32[] %multiply.43, f32[] %constant.42) + %multiply.46 = f32[] multiply(f32[] %add.44, f32[] %multiply.12) + %constant.45 = f32[] constant(-0.0029546) + %add.47 = f32[] add(f32[] %multiply.46, f32[] %constant.45) + %multiply.49 = f32[] multiply(f32[] %add.47, f32[] %multiply.12) + %constant.48 = f32[] constant(-0.0160960332) + %add.50 = f32[] add(f32[] %multiply.49, f32[] %constant.48) + %multiply.51 = f32[] multiply(f32[] %clamp.11, f32[] %add.50) + %constant.13 = f32[] constant(0) + %multiply.15 = f32[] multiply(f32[] %constant.13, f32[] %multiply.12) + %constant.14 = f32[] constant(-1.45660715e-05) + %add.16 = f32[] add(f32[] %multiply.15, f32[] %constant.14) + %multiply.18 = f32[] multiply(f32[] %add.16, f32[] %multiply.12) + %constant.17 = f32[] constant(-0.000213374049) + %add.19 = f32[] add(f32[] %multiply.18, f32[] %constant.17) + %multiply.21 = f32[] multiply(f32[] %add.19, f32[] %multiply.12) + %constant.20 = f32[] constant(-0.00168282702) + %add.22 = f32[] add(f32[] %multiply.21, f32[] %constant.20) + %multiply.24 = f32[] multiply(f32[] %add.22, f32[] %multiply.12) + %constant.23 = f32[] constant(-0.00737332925) + %add.25 = f32[] add(f32[] %multiply.24, f32[] %constant.23) + %multiply.27 = f32[] multiply(f32[] %add.25, f32[] %multiply.12) + %constant.26 = f32[] constant(-0.0142647391) + %add.28 = f32[] add(f32[] %multiply.27, f32[] %constant.26) + %divide.52 = f32[] divide(f32[] %multiply.51, f32[] %add.28) + %broadcast.99 = f32[1,1]{1,0} broadcast(f32[] %divide.52), dimensions={} + %reshape.134 = f32[] reshape(f32[1,1]{1,0} %broadcast.99) + %broadcast.135 = f32[32,4]{1,0} broadcast(f32[] %reshape.134), dimensions={} + %parameter.1 = u32[2]{0} parameter(0) + %slice.102 = u32[1]{0} slice(u32[2]{0} %parameter.1), slice={[0:1]} + %reshape.103 = u32[] reshape(u32[1]{0} %slice.102) + %broadcast.108 = u32[64]{0} broadcast(u32[] %reshape.103), dimensions={} + %slice.104 = u32[1]{0} slice(u32[2]{0} %parameter.1), slice={[1:2]} + %reshape.105 = u32[] reshape(u32[1]{0} %slice.104) + %broadcast.109 = u32[64]{0} broadcast(u32[] %reshape.105), dimensions={} + %iota.101 = u32[128] iota(), iota_dimension=0 + %slice.106 = u32[64]{0} slice(u32[128] %iota.101), slice={[0:64]} + %broadcast.110 = u32[64]{0} broadcast(u32[64]{0} %slice.106), dimensions={0} + %slice.107 = u32[64]{0} slice(u32[128] %iota.101), slice={[64:128]} + %broadcast.111 = u32[64]{0} broadcast(u32[64]{0} %slice.107), dimensions={0} + %custom-call.112 = (u32[64]{0}, u32[64]{0}) custom-call(u32[64]{0} %broadcast.108, u32[64]{0} %broadcast.109, u32[64]{0} %broadcast.110, u32[64]{0} %broadcast.111), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[64]{0}, u32[64]{0}, u32[64]{0}, u32[64]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="@\000\000\000\000\000\000\000" + %get-tuple-element.113 = u32[64]{0} get-tuple-element((u32[64]{0}, u32[64]{0}) %custom-call.112), index=0 + %get-tuple-element.114 = u32[64]{0} get-tuple-element((u32[64]{0}, u32[64]{0}) %custom-call.112), index=1 + %concatenate.115 = u32[128]{0} concatenate(u32[64]{0} %get-tuple-element.113, u32[64]{0} %get-tuple-element.114), dimensions={0} + %reshape.116 = u32[32,4]{1,0} reshape(u32[128]{0} %concatenate.115) + %constant.117 = u32[] constant(9) + %broadcast.118 = u32[32,4]{1,0} broadcast(u32[] %constant.117), dimensions={} + %shift-right-logical.119 = u32[32,4]{1,0} shift-right-logical(u32[32,4]{1,0} %reshape.116, u32[32,4]{1,0} %broadcast.118) + %constant.120 = u32[] constant(1065353216) + %broadcast.121 = u32[32,4]{1,0} broadcast(u32[] %constant.120), dimensions={} + %or.122 = u32[32,4]{1,0} or(u32[32,4]{1,0} %shift-right-logical.119, u32[32,4]{1,0} %broadcast.121) + %bitcast-convert.123 = f32[32,4]{1,0} bitcast-convert(u32[32,4]{1,0} %or.122) + %constant.124 = f32[] constant(1) + %broadcast.125 = f32[32,4]{1,0} broadcast(f32[] %constant.124), dimensions={} + %subtract.126 = f32[32,4]{1,0} subtract(f32[32,4]{1,0} %bitcast-convert.123, f32[32,4]{1,0} %broadcast.125) + %constant.56 = f32[] constant(-4) + %parameter.3 = f32[] parameter(2) + %convert.6 = f32[] convert(f32[] %parameter.3) + %constant.53 = f32[] constant(1.41421354) + %divide.54 = f32[] divide(f32[] %convert.6, f32[] %constant.53) + %constant.55 = f32[] constant(4) + %clamp.57 = f32[] clamp(f32[] %constant.56, f32[] %divide.54, f32[] %constant.55) + %constant.75 = f32[] constant(0) + %multiply.58 = f32[] multiply(f32[] %clamp.57, f32[] %clamp.57) + %multiply.77 = f32[] multiply(f32[] %constant.75, f32[] %multiply.58) + %constant.76 = f32[] constant(-2.72614237e-10) + %add.78 = f32[] add(f32[] %multiply.77, f32[] %constant.76) + %multiply.80 = f32[] multiply(f32[] %add.78, f32[] %multiply.58) + %constant.79 = f32[] constant(2.77068146e-08) + %add.81 = f32[] add(f32[] %multiply.80, f32[] %constant.79) + %multiply.83 = f32[] multiply(f32[] %add.81, f32[] %multiply.58) + %constant.82 = f32[] constant(-2.10102394e-06) + %add.84 = f32[] add(f32[] %multiply.83, f32[] %constant.82) + %multiply.86 = f32[] multiply(f32[] %add.84, f32[] %multiply.58) + %constant.85 = f32[] constant(-5.69250624e-05) + %add.87 = f32[] add(f32[] %multiply.86, f32[] %constant.85) + %multiply.89 = f32[] multiply(f32[] %add.87, f32[] %multiply.58) + %constant.88 = f32[] constant(-0.000734990637) + %add.90 = f32[] add(f32[] %multiply.89, f32[] %constant.88) + %multiply.92 = f32[] multiply(f32[] %add.90, f32[] %multiply.58) + %constant.91 = f32[] constant(-0.0029546) + %add.93 = f32[] add(f32[] %multiply.92, f32[] %constant.91) + %multiply.95 = f32[] multiply(f32[] %add.93, f32[] %multiply.58) + %constant.94 = f32[] constant(-0.0160960332) + %add.96 = f32[] add(f32[] %multiply.95, f32[] %constant.94) + %multiply.97 = f32[] multiply(f32[] %clamp.57, f32[] %add.96) + %constant.59 = f32[] constant(0) + %multiply.61 = f32[] multiply(f32[] %constant.59, f32[] %multiply.58) + %constant.60 = f32[] constant(-1.45660715e-05) + %add.62 = f32[] add(f32[] %multiply.61, f32[] %constant.60) + %multiply.64 = f32[] multiply(f32[] %add.62, f32[] %multiply.58) + %constant.63 = f32[] constant(-0.000213374049) + %add.65 = f32[] add(f32[] %multiply.64, f32[] %constant.63) + %multiply.67 = f32[] multiply(f32[] %add.65, f32[] %multiply.58) + %constant.66 = f32[] constant(-0.00168282702) + %add.68 = f32[] add(f32[] %multiply.67, f32[] %constant.66) + %multiply.70 = f32[] multiply(f32[] %add.68, f32[] %multiply.58) + %constant.69 = f32[] constant(-0.00737332925) + %add.71 = f32[] add(f32[] %multiply.70, f32[] %constant.69) + %multiply.73 = f32[] multiply(f32[] %add.71, f32[] %multiply.58) + %constant.72 = f32[] constant(-0.0142647391) + %add.74 = f32[] add(f32[] %multiply.73, f32[] %constant.72) + %divide.98 = f32[] divide(f32[] %multiply.97, f32[] %add.74) + %broadcast.100 = f32[1,1]{1,0} broadcast(f32[] %divide.98), dimensions={} + %subtract.127 = f32[1,1]{1,0} subtract(f32[1,1]{1,0} %broadcast.100, f32[1,1]{1,0} %broadcast.99) + %reshape.128 = f32[] reshape(f32[1,1]{1,0} %subtract.127) + %broadcast.129 = f32[32,4]{1,0} broadcast(f32[] %reshape.128), dimensions={} + %multiply.130 = f32[32,4]{1,0} multiply(f32[32,4]{1,0} %subtract.126, f32[32,4]{1,0} %broadcast.129) + %reshape.131 = f32[] reshape(f32[1,1]{1,0} %broadcast.99) + %broadcast.132 = f32[32,4]{1,0} broadcast(f32[] %reshape.131), dimensions={} + %add.133 = f32[32,4]{1,0} add(f32[32,4]{1,0} %multiply.130, f32[32,4]{1,0} %broadcast.132) + %maximum.136 = f32[32,4]{1,0} maximum(f32[32,4]{1,0} %broadcast.135, f32[32,4]{1,0} %add.133) + %abs.218 = f32[32,4]{1,0} abs(f32[32,4]{1,0} %maximum.136) + %constant.217 = f32[] constant(1) + %broadcast.219 = f32[32,4]{1,0} broadcast(f32[] %constant.217), dimensions={} + %compare.220 = pred[32,4]{1,0} compare(f32[32,4]{1,0} %abs.218, f32[32,4]{1,0} %broadcast.219), direction=EQ + %constant.214 = f32[] constant(inf) + %broadcast.215 = f32[32,4]{1,0} broadcast(f32[] %constant.214), dimensions={} + %multiply.216 = f32[32,4]{1,0} multiply(f32[32,4]{1,0} %maximum.136, f32[32,4]{1,0} %broadcast.215) + %negate.137 = f32[32,4]{1,0} negate(f32[32,4]{1,0} %maximum.136) + %multiply.138 = f32[32,4]{1,0} multiply(f32[32,4]{1,0} %negate.137, f32[32,4]{1,0} %maximum.136) + %log-plus-one.139 = f32[32,4]{1,0} log-plus-one(f32[32,4]{1,0} %multiply.138) + %negate.140 = f32[32,4]{1,0} negate(f32[32,4]{1,0} %log-plus-one.139) + %constant.141 = f32[] constant(5) + %broadcast.142 = f32[32,4]{1,0} broadcast(f32[] %constant.141), dimensions={} + %compare.143 = pred[32,4]{1,0} compare(f32[32,4]{1,0} %negate.140, f32[32,4]{1,0} %broadcast.142), direction=LT + %constant.209 = f32[] constant(1.50140941) + %broadcast.210 = f32[32,4]{1,0} broadcast(f32[] %constant.209), dimensions={} + %constant.207 = f32[] constant(2.83297682) + %broadcast.208 = f32[32,4]{1,0} broadcast(f32[] %constant.207), dimensions={} + %select.211 = f32[32,4]{1,0} select(pred[32,4]{1,0} %compare.143, f32[32,4]{1,0} %broadcast.210, f32[32,4]{1,0} %broadcast.208) + %constant.202 = f32[] constant(0.246640727) + %broadcast.203 = f32[32,4]{1,0} broadcast(f32[] %constant.202), dimensions={} + %constant.200 = f32[] constant(1.00167406) + %broadcast.201 = f32[32,4]{1,0} broadcast(f32[] %constant.200), dimensions={} + %select.204 = f32[32,4]{1,0} select(pred[32,4]{1,0} %compare.143, f32[32,4]{1,0} %broadcast.203, f32[32,4]{1,0} %broadcast.201) + %constant.195 = f32[] constant(-0.00417768164) + %broadcast.196 = f32[32,4]{1,0} broadcast(f32[] %constant.195), dimensions={} + %constant.193 = f32[] constant(0.00943887047) + %broadcast.194 = f32[32,4]{1,0} broadcast(f32[] %constant.193), dimensions={} + %select.197 = f32[32,4]{1,0} select(pred[32,4]{1,0} %compare.143, f32[32,4]{1,0} %broadcast.196, f32[32,4]{1,0} %broadcast.194) + %constant.188 = f32[] constant(-0.00125372503) + %broadcast.189 = f32[32,4]{1,0} broadcast(f32[] %constant.188), dimensions={} + %constant.186 = f32[] constant(-0.0076224613) + %broadcast.187 = f32[32,4]{1,0} broadcast(f32[] %constant.186), dimensions={} + %select.190 = f32[32,4]{1,0} select(pred[32,4]{1,0} %compare.143, f32[32,4]{1,0} %broadcast.189, f32[32,4]{1,0} %broadcast.187) + %constant.181 = f32[] constant(0.00021858087) + %broadcast.182 = f32[32,4]{1,0} broadcast(f32[] %constant.181), dimensions={} + %constant.179 = f32[] constant(0.00573950773) + %broadcast.180 = f32[32,4]{1,0} broadcast(f32[] %constant.179), dimensions={} + %select.183 = f32[32,4]{1,0} select(pred[32,4]{1,0} %compare.143, f32[32,4]{1,0} %broadcast.182, f32[32,4]{1,0} %broadcast.180) + %constant.174 = f32[] constant(-4.39150654e-06) + %broadcast.175 = f32[32,4]{1,0} broadcast(f32[] %constant.174), dimensions={} + %constant.172 = f32[] constant(-0.00367342844) + %broadcast.173 = f32[32,4]{1,0} broadcast(f32[] %constant.172), dimensions={} + %select.176 = f32[32,4]{1,0} select(pred[32,4]{1,0} %compare.143, f32[32,4]{1,0} %broadcast.175, f32[32,4]{1,0} %broadcast.173) + %constant.167 = f32[] constant(-3.5233877e-06) + %broadcast.168 = f32[32,4]{1,0} broadcast(f32[] %constant.167), dimensions={} + %constant.165 = f32[] constant(0.00134934322) + %broadcast.166 = f32[32,4]{1,0} broadcast(f32[] %constant.165), dimensions={} + %select.169 = f32[32,4]{1,0} select(pred[32,4]{1,0} %compare.143, f32[32,4]{1,0} %broadcast.168, f32[32,4]{1,0} %broadcast.166) + %constant.160 = f32[] constant(3.43273939e-07) + %broadcast.161 = f32[32,4]{1,0} broadcast(f32[] %constant.160), dimensions={} + %constant.158 = f32[] constant(0.000100950558) + %broadcast.159 = f32[32,4]{1,0} broadcast(f32[] %constant.158), dimensions={} + %select.162 = f32[32,4]{1,0} select(pred[32,4]{1,0} %compare.143, f32[32,4]{1,0} %broadcast.161, f32[32,4]{1,0} %broadcast.159) + %constant.154 = f32[] constant(2.81022636e-08) + %broadcast.155 = f32[32,4]{1,0} broadcast(f32[] %constant.154), dimensions={} + %constant.152 = f32[] constant(-0.000200214257) + %broadcast.153 = f32[32,4]{1,0} broadcast(f32[] %constant.152), dimensions={} + %select.156 = f32[32,4]{1,0} select(pred[32,4]{1,0} %compare.143, f32[32,4]{1,0} %broadcast.155, f32[32,4]{1,0} %broadcast.153) + %constant.148 = f32[] constant(2.5) + %broadcast.149 = f32[32,4]{1,0} broadcast(f32[] %constant.148), dimensions={} + %subtract.150 = f32[32,4]{1,0} subtract(f32[32,4]{1,0} %negate.140, f32[32,4]{1,0} %broadcast.149) + %sqrt.145 = f32[32,4]{1,0} sqrt(f32[32,4]{1,0} %negate.140) + %constant.144 = f32[] constant(3) + %broadcast.146 = f32[32,4]{1,0} broadcast(f32[] %constant.144), dimensions={} + %subtract.147 = f32[32,4]{1,0} subtract(f32[32,4]{1,0} %sqrt.145, f32[32,4]{1,0} %broadcast.146) + %select.151 = f32[32,4]{1,0} select(pred[32,4]{1,0} %compare.143, f32[32,4]{1,0} %subtract.150, f32[32,4]{1,0} %subtract.147) + %multiply.157 = f32[32,4]{1,0} multiply(f32[32,4]{1,0} %select.156, f32[32,4]{1,0} %select.151) + %add.163 = f32[32,4]{1,0} add(f32[32,4]{1,0} %select.162, f32[32,4]{1,0} %multiply.157) + %multiply.164 = f32[32,4]{1,0} multiply(f32[32,4]{1,0} %add.163, f32[32,4]{1,0} %select.151) + %add.170 = f32[32,4]{1,0} add(f32[32,4]{1,0} %select.169, f32[32,4]{1,0} %multiply.164) + %multiply.171 = f32[32,4]{1,0} multiply(f32[32,4]{1,0} %add.170, f32[32,4]{1,0} %select.151) + %add.177 = f32[32,4]{1,0} add(f32[32,4]{1,0} %select.176, f32[32,4]{1,0} %multiply.171) + %multiply.178 = f32[32,4]{1,0} multiply(f32[32,4]{1,0} %add.177, f32[32,4]{1,0} %select.151) + %add.184 = f32[32,4]{1,0} add(f32[32,4]{1,0} %select.183, f32[32,4]{1,0} %multiply.178) + %multiply.185 = f32[32,4]{1,0} multiply(f32[32,4]{1,0} %add.184, f32[32,4]{1,0} %select.151) + %add.191 = f32[32,4]{1,0} add(f32[32,4]{1,0} %select.190, f32[32,4]{1,0} %multiply.185) + %multiply.192 = f32[32,4]{1,0} multiply(f32[32,4]{1,0} %add.191, f32[32,4]{1,0} %select.151) + %add.198 = f32[32,4]{1,0} add(f32[32,4]{1,0} %select.197, f32[32,4]{1,0} %multiply.192) + %multiply.199 = f32[32,4]{1,0} multiply(f32[32,4]{1,0} %add.198, f32[32,4]{1,0} %select.151) + %add.205 = f32[32,4]{1,0} add(f32[32,4]{1,0} %select.204, f32[32,4]{1,0} %multiply.199) + %multiply.206 = f32[32,4]{1,0} multiply(f32[32,4]{1,0} %add.205, f32[32,4]{1,0} %select.151) + %add.212 = f32[32,4]{1,0} add(f32[32,4]{1,0} %select.211, f32[32,4]{1,0} %multiply.206) + %multiply.213 = f32[32,4]{1,0} multiply(f32[32,4]{1,0} %add.212, f32[32,4]{1,0} %maximum.136) + %select.221 = f32[32,4]{1,0} select(pred[32,4]{1,0} %compare.220, f32[32,4]{1,0} %multiply.216, f32[32,4]{1,0} %multiply.213) + %constant.222 = f32[] constant(1.41421354) + %broadcast.223 = f32[32,4]{1,0} broadcast(f32[] %constant.222), dimensions={} + %multiply.224 = f32[32,4]{1,0} multiply(f32[32,4]{1,0} %select.221, f32[32,4]{1,0} %broadcast.223) + %compare.228 = pred[] compare(f32[] %convert.5, f32[] %convert.5), direction=NE + %constant.225 = f32[] constant(inf) + %compare.229 = pred[] compare(f32[] %constant.225, f32[] %constant.225), direction=NE + %or.230 = pred[] or(pred[] %compare.228, pred[] %compare.229) + %constant.231 = f32[] constant(nan) + %broadcast.232 = f32[] broadcast(f32[] %constant.231), dimensions={} + %bitcast-convert.233 = u32[] bitcast-convert(f32[] %broadcast.232) + %bitcast-convert.226 = u32[] bitcast-convert(f32[] %convert.5) + %bitcast-convert.227 = u32[] bitcast-convert(f32[] %constant.225) + %compare.238 = pred[] compare(u32[] %bitcast-convert.226, u32[] %bitcast-convert.227), direction=EQ + %constant.234 = u32[] constant(2147483647) + %and.235 = u32[] and(u32[] %bitcast-convert.226, u32[] %constant.234) + %constant.239 = u32[] constant(0) + %broadcast.240 = u32[] broadcast(u32[] %constant.239), dimensions={} + %compare.241 = pred[] compare(u32[] %and.235, u32[] %broadcast.240), direction=EQ + %constant.236 = u32[] constant(2147483647) + %and.237 = u32[] and(u32[] %bitcast-convert.227, u32[] %constant.236) + %constant.242 = u32[] constant(0) + %broadcast.243 = u32[] broadcast(u32[] %constant.242), dimensions={} + %compare.244 = pred[] compare(u32[] %and.237, u32[] %broadcast.243), direction=EQ + %constant.247 = u32[] constant(2147483648) + %and.248 = u32[] and(u32[] %bitcast-convert.227, u32[] %constant.247) + %constant.249 = u32[] constant(1) + %or.250 = u32[] or(u32[] %and.248, u32[] %constant.249) + %select.260 = u32[] select(pred[] %compare.244, u32[] %bitcast-convert.227, u32[] %or.250) + %compare.252 = pred[] compare(u32[] %and.235, u32[] %and.237), direction=GT + %constant.245 = u32[] constant(2147483648) + %and.246 = u32[] and(u32[] %bitcast-convert.226, u32[] %constant.245) + %compare.251 = pred[] compare(u32[] %and.246, u32[] %and.248), direction=NE + %or.253 = pred[] or(pred[] %compare.252, pred[] %compare.251) + %constant.256 = u32[] constant(4294967295) + %broadcast.257 = u32[] broadcast(u32[] %constant.256), dimensions={} + %constant.254 = u32[] constant(1) + %broadcast.255 = u32[] broadcast(u32[] %constant.254), dimensions={} + %select.258 = u32[] select(pred[] %or.253, u32[] %broadcast.257, u32[] %broadcast.255) + %add.259 = u32[] add(u32[] %bitcast-convert.226, u32[] %select.258) + %select.261 = u32[] select(pred[] %compare.241, u32[] %select.260, u32[] %add.259) + %select.262 = u32[] select(pred[] %compare.238, u32[] %bitcast-convert.227, u32[] %select.261) + %select.263 = u32[] select(pred[] %or.230, u32[] %bitcast-convert.233, u32[] %select.262) + %bitcast-convert.264 = f32[] bitcast-convert(u32[] %select.263) + %compare.268 = pred[] compare(f32[] %convert.6, f32[] %convert.6), direction=NE + %constant.265 = f32[] constant(-inf) + %compare.269 = pred[] compare(f32[] %constant.265, f32[] %constant.265), direction=NE + %or.270 = pred[] or(pred[] %compare.268, pred[] %compare.269) + %constant.271 = f32[] constant(nan) + %broadcast.272 = f32[] broadcast(f32[] %constant.271), dimensions={} + %bitcast-convert.273 = u32[] bitcast-convert(f32[] %broadcast.272) + %bitcast-convert.266 = u32[] bitcast-convert(f32[] %convert.6) + %bitcast-convert.267 = u32[] bitcast-convert(f32[] %constant.265) + %compare.278 = pred[] compare(u32[] %bitcast-convert.266, u32[] %bitcast-convert.267), direction=EQ + %constant.274 = u32[] constant(2147483647) + %and.275 = u32[] and(u32[] %bitcast-convert.266, u32[] %constant.274) + %constant.279 = u32[] constant(0) + %broadcast.280 = u32[] broadcast(u32[] %constant.279), dimensions={} + %compare.281 = pred[] compare(u32[] %and.275, u32[] %broadcast.280), direction=EQ + %constant.276 = u32[] constant(2147483647) + %and.277 = u32[] and(u32[] %bitcast-convert.267, u32[] %constant.276) + %constant.282 = u32[] constant(0) + %broadcast.283 = u32[] broadcast(u32[] %constant.282), dimensions={} + %compare.284 = pred[] compare(u32[] %and.277, u32[] %broadcast.283), direction=EQ + %constant.287 = u32[] constant(2147483648) + %and.288 = u32[] and(u32[] %bitcast-convert.267, u32[] %constant.287) + %constant.289 = u32[] constant(1) + %or.290 = u32[] or(u32[] %and.288, u32[] %constant.289) + %select.300 = u32[] select(pred[] %compare.284, u32[] %bitcast-convert.267, u32[] %or.290) + %compare.292 = pred[] compare(u32[] %and.275, u32[] %and.277), direction=GT + %constant.285 = u32[] constant(2147483648) + %and.286 = u32[] and(u32[] %bitcast-convert.266, u32[] %constant.285) + %compare.291 = pred[] compare(u32[] %and.286, u32[] %and.288), direction=NE + %or.293 = pred[] or(pred[] %compare.292, pred[] %compare.291) + %constant.296 = u32[] constant(4294967295) + %broadcast.297 = u32[] broadcast(u32[] %constant.296), dimensions={} + %constant.294 = u32[] constant(1) + %broadcast.295 = u32[] broadcast(u32[] %constant.294), dimensions={} + %select.298 = u32[] select(pred[] %or.293, u32[] %broadcast.297, u32[] %broadcast.295) + %add.299 = u32[] add(u32[] %bitcast-convert.266, u32[] %select.298) + %select.301 = u32[] select(pred[] %compare.281, u32[] %select.300, u32[] %add.299) + %select.302 = u32[] select(pred[] %compare.278, u32[] %bitcast-convert.267, u32[] %select.301) + %select.303 = u32[] select(pred[] %or.270, u32[] %bitcast-convert.273, u32[] %select.302) + %bitcast-convert.304 = f32[] bitcast-convert(u32[] %select.303) + %call.315 = (f32[32,4]{1,0}) call(f32[32,4]{1,0} %multiply.224, f32[] %bitcast-convert.264, f32[] %bitcast-convert.304), to_apply=%jit_clip__7.305 + %get-tuple-element.316 = f32[32,4]{1,0} get-tuple-element((f32[32,4]{1,0}) %call.315), index=0 + ROOT %tuple.317 = (f32[32,4]{1,0}) tuple(f32[32,4]{1,0} %get-tuple-element.316) +} + diff --git a/tests/hlo_texts/test_hlos/jaxlie/module_0009.jit_round.2.before_optimizations.txt b/tests/hlo_texts/test_hlos/jaxlie/module_0009.jit_round.2.before_optimizations.txt new file mode 100644 index 0000000..5ba7c11 --- /dev/null +++ b/tests/hlo_texts/test_hlos/jaxlie/module_0009.jit_round.2.before_optimizations.txt @@ -0,0 +1,34 @@ +HloModule jit_round.2 + +round.5 { + Arg_0.6 = f32[4]{0} parameter(0) + floor.13 = f32[4]{0} floor(Arg_0.6) + subtract.14 = f32[4]{0} subtract(Arg_0.6, floor.13) + constant.9 = f32[] constant(0.5) + broadcast.10 = f32[4]{0} broadcast(constant.9), dimensions={} + compare.20 = pred[4]{0} compare(subtract.14, broadcast.10), direction=GT + compare.21 = pred[4]{0} compare(subtract.14, broadcast.10), direction=EQ + multiply.15 = f32[4]{0} multiply(Arg_0.6, broadcast.10) + floor.16 = f32[4]{0} floor(multiply.15) + constant.11 = f32[] constant(2) + broadcast.12 = f32[4]{0} broadcast(constant.11), dimensions={} + multiply.17 = f32[4]{0} multiply(floor.16, broadcast.12) + subtract.18 = f32[4]{0} subtract(floor.13, multiply.17) + constant.7 = f32[] constant(1) + broadcast.8 = f32[4]{0} broadcast(constant.7), dimensions={} + compare.19 = pred[4]{0} compare(subtract.18, broadcast.8), direction=EQ + and.22 = pred[4]{0} and(compare.21, compare.19) + or.23 = pred[4]{0} or(compare.20, and.22) + add.24 = f32[4]{0} add(floor.13, broadcast.8) + ROOT select.25 = f32[4]{0} select(or.23, add.24, floor.13) +} + +ENTRY main.28 { + Arg_0.1 = f32[4]{0} parameter(0) + constant.2 = f32[] constant(100000) + broadcast.3 = f32[4]{0} broadcast(constant.2), dimensions={} + multiply.4 = f32[4]{0} multiply(Arg_0.1, broadcast.3) + call.26 = f32[4]{0} call(multiply.4), to_apply=round.5 + ROOT divide.27 = f32[4]{0} divide(call.26, broadcast.3) +} + diff --git a/tests/hlo_texts/test_hlos/jaxlie/module_0025.jit_apply.7.before_optimizations.txt b/tests/hlo_texts/test_hlos/jaxlie/module_0025.jit_apply.7.before_optimizations.txt new file mode 100644 index 0000000..f1f9f64 --- /dev/null +++ b/tests/hlo_texts/test_hlos/jaxlie/module_0025.jit_apply.7.before_optimizations.txt @@ -0,0 +1,160 @@ +HloModule jit_apply.7 + +jit_rotation.4 { + Arg_0.5 = f32[7]{0} parameter(0) + ROOT slice.6 = f32[4]{0} slice(Arg_0.5), slice={[0:4]} +} + +region_0.8 { + Arg_0.9 = f32[] parameter(0) + ROOT Arg_1.10 = f32[] parameter(1) +} + +jit_multiply.11 { + Arg_0.12 = f32[4]{0} parameter(0) + slice.16 = f32[1]{0} slice(Arg_0.12), slice={[1:2]} + reshape.17 = f32[] reshape(slice.16) + negate.30 = f32[] negate(reshape.17) + Arg_1.13 = f32[4]{0} parameter(1) + slice.24 = f32[1]{0} slice(Arg_1.13), slice={[1:2]} + reshape.25 = f32[] reshape(slice.24) + multiply.31 = f32[] multiply(negate.30, reshape.25) + slice.18 = f32[1]{0} slice(Arg_0.12), slice={[2:3]} + reshape.19 = f32[] reshape(slice.18) + slice.26 = f32[1]{0} slice(Arg_1.13), slice={[2:3]} + reshape.27 = f32[] reshape(slice.26) + multiply.32 = f32[] multiply(reshape.19, reshape.27) + subtract.33 = f32[] subtract(multiply.31, multiply.32) + slice.20 = f32[1]{0} slice(Arg_0.12), slice={[3:4]} + reshape.21 = f32[] reshape(slice.20) + slice.28 = f32[1]{0} slice(Arg_1.13), slice={[3:4]} + reshape.29 = f32[] reshape(slice.28) + multiply.34 = f32[] multiply(reshape.21, reshape.29) + subtract.35 = f32[] subtract(subtract.33, multiply.34) + slice.14 = f32[1]{0} slice(Arg_0.12), slice={[0:1]} + reshape.15 = f32[] reshape(slice.14) + slice.22 = f32[1]{0} slice(Arg_1.13), slice={[0:1]} + reshape.23 = f32[] reshape(slice.22) + multiply.36 = f32[] multiply(reshape.15, reshape.23) + add.37 = f32[] add(subtract.35, multiply.36) + reshape.60 = f32[1]{0} reshape(add.37) + multiply.38 = f32[] multiply(reshape.17, reshape.23) + multiply.39 = f32[] multiply(reshape.19, reshape.29) + add.40 = f32[] add(multiply.38, multiply.39) + multiply.41 = f32[] multiply(reshape.21, reshape.27) + subtract.42 = f32[] subtract(add.40, multiply.41) + multiply.43 = f32[] multiply(reshape.15, reshape.25) + add.44 = f32[] add(subtract.42, multiply.43) + reshape.61 = f32[1]{0} reshape(add.44) + negate.45 = f32[] negate(reshape.17) + multiply.46 = f32[] multiply(negate.45, reshape.29) + multiply.47 = f32[] multiply(reshape.19, reshape.23) + add.48 = f32[] add(multiply.46, multiply.47) + multiply.49 = f32[] multiply(reshape.21, reshape.25) + add.50 = f32[] add(add.48, multiply.49) + multiply.51 = f32[] multiply(reshape.15, reshape.27) + add.52 = f32[] add(add.50, multiply.51) + reshape.62 = f32[1]{0} reshape(add.52) + multiply.53 = f32[] multiply(reshape.17, reshape.27) + multiply.54 = f32[] multiply(reshape.19, reshape.25) + subtract.55 = f32[] subtract(multiply.53, multiply.54) + multiply.56 = f32[] multiply(reshape.21, reshape.23) + add.57 = f32[] add(subtract.55, multiply.56) + multiply.58 = f32[] multiply(reshape.15, reshape.29) + add.59 = f32[] add(add.57, multiply.58) + reshape.63 = f32[1]{0} reshape(add.59) + ROOT concatenate.64 = f32[4]{0} concatenate(reshape.60, reshape.61, reshape.62, reshape.63), dimensions={0} +} + +jit_inverse.65 { + Arg_1.67 = f32[4]{0} parameter(1) + Arg_0.66 = s32[4]{0} parameter(0) + convert.68 = f32[4]{0} convert(Arg_0.66) + ROOT multiply.69 = f32[4]{0} multiply(Arg_1.67, convert.68) +} + +jit_multiply_0.70 { + Arg_0.71 = f32[4]{0} parameter(0) + slice.75 = f32[1]{0} slice(Arg_0.71), slice={[1:2]} + reshape.76 = f32[] reshape(slice.75) + negate.89 = f32[] negate(reshape.76) + Arg_1.72 = f32[4]{0} parameter(1) + slice.83 = f32[1]{0} slice(Arg_1.72), slice={[1:2]} + reshape.84 = f32[] reshape(slice.83) + multiply.90 = f32[] multiply(negate.89, reshape.84) + slice.77 = f32[1]{0} slice(Arg_0.71), slice={[2:3]} + reshape.78 = f32[] reshape(slice.77) + slice.85 = f32[1]{0} slice(Arg_1.72), slice={[2:3]} + reshape.86 = f32[] reshape(slice.85) + multiply.91 = f32[] multiply(reshape.78, reshape.86) + subtract.92 = f32[] subtract(multiply.90, multiply.91) + slice.79 = f32[1]{0} slice(Arg_0.71), slice={[3:4]} + reshape.80 = f32[] reshape(slice.79) + slice.87 = f32[1]{0} slice(Arg_1.72), slice={[3:4]} + reshape.88 = f32[] reshape(slice.87) + multiply.93 = f32[] multiply(reshape.80, reshape.88) + subtract.94 = f32[] subtract(subtract.92, multiply.93) + slice.73 = f32[1]{0} slice(Arg_0.71), slice={[0:1]} + reshape.74 = f32[] reshape(slice.73) + slice.81 = f32[1]{0} slice(Arg_1.72), slice={[0:1]} + reshape.82 = f32[] reshape(slice.81) + multiply.95 = f32[] multiply(reshape.74, reshape.82) + add.96 = f32[] add(subtract.94, multiply.95) + reshape.119 = f32[1]{0} reshape(add.96) + multiply.97 = f32[] multiply(reshape.76, reshape.82) + multiply.98 = f32[] multiply(reshape.78, reshape.88) + add.99 = f32[] add(multiply.97, multiply.98) + multiply.100 = f32[] multiply(reshape.80, reshape.86) + subtract.101 = f32[] subtract(add.99, multiply.100) + multiply.102 = f32[] multiply(reshape.74, reshape.84) + add.103 = f32[] add(subtract.101, multiply.102) + reshape.120 = f32[1]{0} reshape(add.103) + negate.104 = f32[] negate(reshape.76) + multiply.105 = f32[] multiply(negate.104, reshape.88) + multiply.106 = f32[] multiply(reshape.78, reshape.82) + add.107 = f32[] add(multiply.105, multiply.106) + multiply.108 = f32[] multiply(reshape.80, reshape.84) + add.109 = f32[] add(add.107, multiply.108) + multiply.110 = f32[] multiply(reshape.74, reshape.86) + add.111 = f32[] add(add.109, multiply.110) + reshape.121 = f32[1]{0} reshape(add.111) + multiply.112 = f32[] multiply(reshape.76, reshape.86) + multiply.113 = f32[] multiply(reshape.78, reshape.84) + subtract.114 = f32[] subtract(multiply.112, multiply.113) + multiply.115 = f32[] multiply(reshape.80, reshape.82) + add.116 = f32[] add(subtract.114, multiply.115) + multiply.117 = f32[] multiply(reshape.74, reshape.88) + add.118 = f32[] add(add.116, multiply.117) + reshape.122 = f32[1]{0} reshape(add.118) + ROOT concatenate.123 = f32[4]{0} concatenate(reshape.119, reshape.120, reshape.121, reshape.122), dimensions={0} +} + +jit_apply.124 { + Arg_1.126 = f32[4]{0} parameter(1) + constant.129 = f32[] constant(0) + broadcast.130 = f32[4]{0} broadcast(constant.129), dimensions={} + constant.128 = s32[1]{0} constant({1}) + Arg_2.127 = f32[3]{0} parameter(2) + scatter.131 = f32[4]{0} scatter(broadcast.130, constant.128, Arg_2.127), update_window_dims={0}, inserted_window_dims={}, scatter_dims_to_operand_dims={0}, index_vector_dim=0, indices_are_sorted=true, unique_indices=true, to_apply=region_0.8 + call.132 = f32[4]{0} call(Arg_1.126, scatter.131), to_apply=jit_multiply.11 + Arg_0.125 = s32[4]{0} parameter(0) + call.133 = f32[4]{0} call(Arg_0.125, Arg_1.126), to_apply=jit_inverse.65 + call.134 = f32[4]{0} call(call.132, call.133), to_apply=jit_multiply_0.70 + ROOT slice.135 = f32[3]{0} slice(call.134), slice={[1:4]} +} + +jit_translation.137 { + Arg_0.138 = f32[7]{0} parameter(0) + ROOT slice.139 = f32[3]{0} slice(Arg_0.138), slice={[4:7]} +} + +ENTRY main.142 { + constant.3 = s32[4]{0} constant({1, -1, -1, -1}) + Arg_0.1 = f32[7]{0} parameter(0) + call.7 = f32[4]{0} call(Arg_0.1), to_apply=jit_rotation.4 + Arg_1.2 = f32[3]{0} parameter(1) + call.136 = f32[3]{0} call(constant.3, call.7, Arg_1.2), to_apply=jit_apply.124 + call.140 = f32[3]{0} call(Arg_0.1), to_apply=jit_translation.137 + ROOT add.141 = f32[3]{0} add(call.136, call.140) +} + diff --git a/tests/hlo_texts/test_hlos/jaxlie/module_0041.jit_prim_fun.14.before_optimizations.txt b/tests/hlo_texts/test_hlos/jaxlie/module_0041.jit_prim_fun.14.before_optimizations.txt new file mode 100644 index 0000000..966a063 --- /dev/null +++ b/tests/hlo_texts/test_hlos/jaxlie/module_0041.jit_prim_fun.14.before_optimizations.txt @@ -0,0 +1,8 @@ +HloModule jit_prim_fun.14 + +ENTRY main.4 { + Arg_0.1 = f32[7]{0} parameter(0) + Arg_1.2 = s32[1]{0} parameter(1) + ROOT gather.3 = f32[3]{0} gather(Arg_0.1, Arg_1.2), offset_dims={0}, collapsed_slice_dims={}, start_index_map={0}, index_vector_dim=0, slice_sizes={3}, indices_are_sorted=true +} + diff --git a/tests/hlo_texts/test_hlos/jaxrl/1652091810809638.module_0083.jit_get_td_target.657.before_optimizations.txt b/tests/hlo_texts/test_hlos/jaxrl/1652091810809638.module_0083.jit_get_td_target.657.before_optimizations.txt new file mode 100644 index 0000000..34456fc --- /dev/null +++ b/tests/hlo_texts/test_hlos/jaxrl/1652091810809638.module_0083.jit_get_td_target.657.before_optimizations.txt @@ -0,0 +1,701 @@ +HloModule jit_get_td_target.657 + +%primitive_computation_add__4.31 (parameter.32: f32[], parameter.33: f32[]) -> f32[] { + %constant.34 = pred[] constant(false) + %parameter.32 = f32[] parameter(0) + %parameter.33 = f32[] parameter(1) + ROOT %add.35 = f32[] add(f32[] %parameter.32, f32[] %parameter.33) +} + +%primitive_computation_add__5.36 (parameter.37: f32[], parameter.38: f32[]) -> f32[] { + %constant.39 = pred[] constant(false) + %parameter.37 = f32[] parameter(0) + %parameter.38 = f32[] parameter(1) + ROOT %add.40 = f32[] add(f32[] %parameter.37, f32[] %parameter.38) +} + +%jit__where__6.41 (parameter.42: pred[256,200], parameter.43: f32[], parameter.44: f32[256,200]) -> (f32[256,200]) { + %constant.45 = pred[] constant(false) + %parameter.42 = pred[256,200]{1,0} parameter(0) + %parameter.43 = f32[] parameter(1) + %convert.46 = f32[] convert(f32[] %parameter.43) + %broadcast.47 = f32[256,200]{1,0} broadcast(f32[] %convert.46), dimensions={} + %parameter.44 = f32[256,200]{1,0} parameter(2) + %select.48 = f32[256,200]{1,0} select(pred[256,200]{1,0} %parameter.42, f32[256,200]{1,0} %broadcast.47, f32[256,200]{1,0} %parameter.44) + ROOT %tuple.49 = (f32[256,200]{1,0}) tuple(f32[256,200]{1,0} %select.48) +} + +%jit__where__7.50 (parameter.51: pred[256,200], parameter.52: f32[256,200], parameter.53: f32[256,200]) -> (f32[256,200]) { + %constant.54 = pred[] constant(false) + %parameter.51 = pred[256,200]{1,0} parameter(0) + %parameter.52 = f32[256,200]{1,0} parameter(1) + %parameter.53 = f32[256,200]{1,0} parameter(2) + %select.55 = f32[256,200]{1,0} select(pred[256,200]{1,0} %parameter.51, f32[256,200]{1,0} %parameter.52, f32[256,200]{1,0} %parameter.53) + ROOT %tuple.56 = (f32[256,200]{1,0}) tuple(f32[256,200]{1,0} %select.55) +} + +%jit_clip__12.57 (parameter.58: f32[256,1], parameter.59: f32[]) -> (f32[256,1]) { + %constant.60 = pred[] constant(false) + %parameter.59 = f32[] parameter(1) + %convert.61 = f32[] convert(f32[] %parameter.59) + %broadcast.62 = f32[256,1]{1,0} broadcast(f32[] %convert.61), dimensions={} + %parameter.58 = f32[256,1]{1,0} parameter(0) + %maximum.63 = f32[256,1]{1,0} maximum(f32[256,1]{1,0} %broadcast.62, f32[256,1]{1,0} %parameter.58) + ROOT %tuple.64 = (f32[256,1]{1,0}) tuple(f32[256,1]{1,0} %maximum.63) +} + +%body_computation__11.65 (parameter.66: (s32[], s32[], u32[128], u32[128], u32[], /*index=5*/u32[], u32[], u32[4], u32[4])) -> (s32[], s32[], u32[128], u32[128], u32[], /*index=5*/u32[], u32[], u32[4], u32[4]) { + %constant.76 = pred[] constant(false) + %parameter.66 = (s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) parameter(0) + %get-tuple-element.67 = s32[] get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %parameter.66), index=0 + %constant.132 = s32[] constant(1) + %add.133 = s32[] add(s32[] %get-tuple-element.67, s32[] %constant.132) + %get-tuple-element.68 = s32[] get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %parameter.66), index=1 + %constant.77 = s32[] constant(1) + %add.78 = s32[] add(s32[] %get-tuple-element.68, s32[] %constant.77) + %get-tuple-element.69 = u32[128]{0} get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %parameter.66), index=2 + %get-tuple-element.70 = u32[128]{0} get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %parameter.66), index=3 + %add.87 = u32[128]{0} add(u32[128]{0} %get-tuple-element.69, u32[128]{0} %get-tuple-element.70) + %get-tuple-element.74 = u32[4]{0} get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %parameter.66), index=7 + %slice.79 = u32[1]{0} slice(u32[4]{0} %get-tuple-element.74), slice={[0:1]} + %reshape.80 = u32[] reshape(u32[1]{0} %slice.79) + %broadcast.88 = u32[128]{0} broadcast(u32[] %reshape.80), dimensions={} + %shift-left.89 = u32[128]{0} shift-left(u32[128]{0} %get-tuple-element.70, u32[128]{0} %broadcast.88) + %constant.90 = u32[] constant(32) + %subtract.91 = u32[] subtract(u32[] %constant.90, u32[] %reshape.80) + %broadcast.92 = u32[128]{0} broadcast(u32[] %subtract.91), dimensions={} + %shift-right-logical.93 = u32[128]{0} shift-right-logical(u32[128]{0} %get-tuple-element.70, u32[128]{0} %broadcast.92) + %or.94 = u32[128]{0} or(u32[128]{0} %shift-left.89, u32[128]{0} %shift-right-logical.93) + %xor.95 = u32[128]{0} xor(u32[128]{0} %add.87, u32[128]{0} %or.94) + %add.96 = u32[128]{0} add(u32[128]{0} %add.87, u32[128]{0} %xor.95) + %slice.81 = u32[1]{0} slice(u32[4]{0} %get-tuple-element.74), slice={[1:2]} + %reshape.82 = u32[] reshape(u32[1]{0} %slice.81) + %broadcast.97 = u32[128]{0} broadcast(u32[] %reshape.82), dimensions={} + %shift-left.98 = u32[128]{0} shift-left(u32[128]{0} %xor.95, u32[128]{0} %broadcast.97) + %constant.99 = u32[] constant(32) + %subtract.100 = u32[] subtract(u32[] %constant.99, u32[] %reshape.82) + %broadcast.101 = u32[128]{0} broadcast(u32[] %subtract.100), dimensions={} + %shift-right-logical.102 = u32[128]{0} shift-right-logical(u32[128]{0} %xor.95, u32[128]{0} %broadcast.101) + %or.103 = u32[128]{0} or(u32[128]{0} %shift-left.98, u32[128]{0} %shift-right-logical.102) + %xor.104 = u32[128]{0} xor(u32[128]{0} %add.96, u32[128]{0} %or.103) + %add.105 = u32[128]{0} add(u32[128]{0} %add.96, u32[128]{0} %xor.104) + %slice.83 = u32[1]{0} slice(u32[4]{0} %get-tuple-element.74), slice={[2:3]} + %reshape.84 = u32[] reshape(u32[1]{0} %slice.83) + %broadcast.106 = u32[128]{0} broadcast(u32[] %reshape.84), dimensions={} + %shift-left.107 = u32[128]{0} shift-left(u32[128]{0} %xor.104, u32[128]{0} %broadcast.106) + %constant.108 = u32[] constant(32) + %subtract.109 = u32[] subtract(u32[] %constant.108, u32[] %reshape.84) + %broadcast.110 = u32[128]{0} broadcast(u32[] %subtract.109), dimensions={} + %shift-right-logical.111 = u32[128]{0} shift-right-logical(u32[128]{0} %xor.104, u32[128]{0} %broadcast.110) + %or.112 = u32[128]{0} or(u32[128]{0} %shift-left.107, u32[128]{0} %shift-right-logical.111) + %xor.113 = u32[128]{0} xor(u32[128]{0} %add.105, u32[128]{0} %or.112) + %add.114 = u32[128]{0} add(u32[128]{0} %add.105, u32[128]{0} %xor.113) + %get-tuple-element.71 = u32[] get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %parameter.66), index=4 + %broadcast.123 = u32[128]{0} broadcast(u32[] %get-tuple-element.71), dimensions={} + %add.124 = u32[128]{0} add(u32[128]{0} %add.114, u32[128]{0} %broadcast.123) + %slice.85 = u32[1]{0} slice(u32[4]{0} %get-tuple-element.74), slice={[3:4]} + %reshape.86 = u32[] reshape(u32[1]{0} %slice.85) + %broadcast.115 = u32[128]{0} broadcast(u32[] %reshape.86), dimensions={} + %shift-left.116 = u32[128]{0} shift-left(u32[128]{0} %xor.113, u32[128]{0} %broadcast.115) + %constant.117 = u32[] constant(32) + %subtract.118 = u32[] subtract(u32[] %constant.117, u32[] %reshape.86) + %broadcast.119 = u32[128]{0} broadcast(u32[] %subtract.118), dimensions={} + %shift-right-logical.120 = u32[128]{0} shift-right-logical(u32[128]{0} %xor.113, u32[128]{0} %broadcast.119) + %or.121 = u32[128]{0} or(u32[128]{0} %shift-left.116, u32[128]{0} %shift-right-logical.120) + %xor.122 = u32[128]{0} xor(u32[128]{0} %add.114, u32[128]{0} %or.121) + %get-tuple-element.72 = u32[] get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %parameter.66), index=5 + %broadcast.125 = u32[128]{0} broadcast(u32[] %get-tuple-element.72), dimensions={} + %add.126 = u32[128]{0} add(u32[128]{0} %xor.122, u32[128]{0} %broadcast.125) + %constant.127 = s32[] constant(1) + %add.128 = s32[] add(s32[] %get-tuple-element.68, s32[] %constant.127) + %convert.129 = u32[] convert(s32[] %add.128) + %broadcast.130 = u32[128]{0} broadcast(u32[] %convert.129), dimensions={} + %add.131 = u32[128]{0} add(u32[128]{0} %add.126, u32[128]{0} %broadcast.130) + %get-tuple-element.73 = u32[] get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %parameter.66), index=6 + %get-tuple-element.75 = u32[4]{0} get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %parameter.66), index=8 + ROOT %tuple.134 = (s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) tuple(s32[] %add.133, s32[] %add.78, u32[128]{0} %add.124, u32[128]{0} %add.131, u32[] %get-tuple-element.72, /*index=5*/u32[] %get-tuple-element.73, u32[] %get-tuple-element.71, u32[4]{0} %get-tuple-element.75, u32[4]{0} %get-tuple-element.74) +} + +%cond_computation__11.135 (parameter.136: (s32[], s32[], u32[128], u32[128], u32[], /*index=5*/u32[], u32[], u32[4], u32[4])) -> pred[] { + %parameter.136 = (s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) parameter(0) + %get-tuple-element.138 = s32[] get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %parameter.136), index=1 + %get-tuple-element.139 = u32[128]{0} get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %parameter.136), index=2 + %get-tuple-element.140 = u32[128]{0} get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %parameter.136), index=3 + %get-tuple-element.141 = u32[] get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %parameter.136), index=4 + %get-tuple-element.142 = u32[] get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %parameter.136), index=5 + %get-tuple-element.143 = u32[] get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %parameter.136), index=6 + %get-tuple-element.144 = u32[4]{0} get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %parameter.136), index=7 + %get-tuple-element.145 = u32[4]{0} get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %parameter.136), index=8 + %constant.146 = pred[] constant(false) + %get-tuple-element.137 = s32[] get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %parameter.136), index=0 + %constant.147 = s32[] constant(5) + ROOT %compare.148 = pred[] compare(s32[] %get-tuple-element.137, s32[] %constant.147), direction=LT +} + +%jit_gaussian_likelihood.149 (parameter.150: f32[256,1], parameter.151: f32[256,1], parameter.152: f32[256,1]) -> (f32[256,1]) { + %constant.153 = pred[] constant(false) + %parameter.150 = f32[256,1]{1,0} parameter(0) + %parameter.151 = f32[256,1]{1,0} parameter(1) + %subtract.154 = f32[256,1]{1,0} subtract(f32[256,1]{1,0} %parameter.150, f32[256,1]{1,0} %parameter.151) + %parameter.152 = f32[256,1]{1,0} parameter(2) + %exponential.155 = f32[256,1]{1,0} exponential(f32[256,1]{1,0} %parameter.152) + %constant.156 = f32[] constant(1e-06) + %broadcast.157 = f32[256,1]{1,0} broadcast(f32[] %constant.156), dimensions={} + %add.158 = f32[256,1]{1,0} add(f32[256,1]{1,0} %exponential.155, f32[256,1]{1,0} %broadcast.157) + %divide.159 = f32[256,1]{1,0} divide(f32[256,1]{1,0} %subtract.154, f32[256,1]{1,0} %add.158) + %multiply.160 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %divide.159, f32[256,1]{1,0} %divide.159) + %constant.161 = f32[] constant(2) + %broadcast.162 = f32[256,1]{1,0} broadcast(f32[] %constant.161), dimensions={} + %multiply.163 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %parameter.152, f32[256,1]{1,0} %broadcast.162) + %add.164 = f32[256,1]{1,0} add(f32[256,1]{1,0} %multiply.160, f32[256,1]{1,0} %multiply.163) + %constant.165 = f32[] constant(6.28318548) + %log.166 = f32[] log(f32[] %constant.165) + %convert.167 = f32[] convert(f32[] %log.166) + %broadcast.168 = f32[256,1]{1,0} broadcast(f32[] %convert.167), dimensions={} + %add.169 = f32[256,1]{1,0} add(f32[256,1]{1,0} %add.164, f32[256,1]{1,0} %broadcast.168) + %constant.170 = f32[] constant(-0.5) + %broadcast.171 = f32[256,1]{1,0} broadcast(f32[] %constant.170), dimensions={} + %multiply.172 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %add.169, f32[256,1]{1,0} %broadcast.171) + ROOT %tuple.173 = (f32[256,1]{1,0}) tuple(f32[256,1]{1,0} %multiply.172) +} + +%primitive_computation_add__6.174 (parameter.175: f32[], parameter.176: f32[]) -> f32[] { + %constant.177 = pred[] constant(false) + %parameter.175 = f32[] parameter(0) + %parameter.176 = f32[] parameter(1) + ROOT %add.178 = f32[] add(f32[] %parameter.175, f32[] %parameter.176) +} + +%jit_apply_gaussian_policy_model__1.179 (parameter.180: f32[200], parameter.181: f32[5,200], parameter.182: f32[200], parameter.183: f32[200,200], parameter.184: f32[2], parameter.185: f32[200,2], parameter.186: f32[200], parameter.187: f32[200], parameter.188: f32[256,5], parameter.189: u32[2]) -> (f32[256,1], f32[256,1]) { + %constant.190 = pred[] constant(false) + %constant.274 = pred[] constant(false) + %constant.283 = pred[] constant(false) + %constant.284 = s32[] constant(0) + %constant.282 = s32[] constant(0) + %iota.265 = u32[256] iota(), iota_dimension=0 + %slice.270 = u32[128]{0} slice(u32[256] %iota.265), slice={[0:128]} + %parameter.189 = u32[2]{0} parameter(9) + %slice.266 = u32[1]{0} slice(u32[2]{0} %parameter.189), slice={[0:1]} + %reshape.267 = u32[] reshape(u32[1]{0} %slice.266) + %broadcast.278 = u32[128]{0} broadcast(u32[] %reshape.267), dimensions={} + %add.279 = u32[128]{0} add(u32[128]{0} %slice.270, u32[128]{0} %broadcast.278) + %slice.271 = u32[128]{0} slice(u32[256] %iota.265), slice={[128:256]} + %slice.268 = u32[1]{0} slice(u32[2]{0} %parameter.189), slice={[1:2]} + %reshape.269 = u32[] reshape(u32[1]{0} %slice.268) + %broadcast.280 = u32[128]{0} broadcast(u32[] %reshape.269), dimensions={} + %add.281 = u32[128]{0} add(u32[128]{0} %slice.271, u32[128]{0} %broadcast.280) + %xor.275 = u32[] xor(u32[] %reshape.267, u32[] %reshape.269) + %constant.276 = u32[] constant(466688986) + %xor.277 = u32[] xor(u32[] %xor.275, u32[] %constant.276) + %constant.272 = u32[4]{0} constant({13, 15, 26, 6}) + %constant.273 = u32[4]{0} constant({17, 29, 16, 24}) + %tuple.285 = (s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) tuple(s32[] %constant.284, s32[] %constant.282, u32[128]{0} %add.279, u32[128]{0} %add.281, u32[] %reshape.269, /*index=5*/u32[] %xor.277, u32[] %reshape.267, u32[4]{0} %constant.272, u32[4]{0} %constant.273) + %while.286 = (s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) while((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %tuple.285), condition=%cond_computation__11.135, body=%body_computation__11.65 + %get-tuple-element.287 = s32[] get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %while.286), index=0 + %get-tuple-element.288 = s32[] get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %while.286), index=1 + %get-tuple-element.291 = u32[] get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %while.286), index=4 + %get-tuple-element.292 = u32[] get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %while.286), index=5 + %get-tuple-element.293 = u32[] get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %while.286), index=6 + %get-tuple-element.294 = u32[4]{0} get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %while.286), index=7 + %get-tuple-element.295 = u32[4]{0} get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %while.286), index=8 + %constant.415 = pred[] constant(false) + %parameter.188 = f32[256,5]{1,0} parameter(8) + %parameter.181 = f32[5,200]{1,0} parameter(1) + %dot.191 = f32[256,200]{1,0} dot(f32[256,5]{1,0} %parameter.188, f32[5,200]{1,0} %parameter.181), lhs_contracting_dims={1}, rhs_contracting_dims={0} + %parameter.180 = f32[200]{0} parameter(0) + %broadcast.192 = f32[1,200]{1,0} broadcast(f32[200]{0} %parameter.180), dimensions={1} + %reshape.193 = f32[200]{0} reshape(f32[1,200]{1,0} %broadcast.192) + %broadcast.194 = f32[256,200]{1,0} broadcast(f32[200]{0} %reshape.193), dimensions={1} + %add.195 = f32[256,200]{1,0} add(f32[256,200]{1,0} %dot.191, f32[256,200]{1,0} %broadcast.194) + %constant.196 = f32[] constant(0) + %reduce.197 = f32[256]{0} reduce(f32[256,200]{1,0} %add.195, f32[] %constant.196), dimensions={1}, to_apply=%primitive_computation_add__4.31 + %broadcast.198 = f32[256,1]{1,0} broadcast(f32[256]{0} %reduce.197), dimensions={0} + %constant.199 = f32[] constant(200) + %broadcast.200 = f32[256,1]{1,0} broadcast(f32[] %constant.199), dimensions={} + %divide.201 = f32[256,1]{1,0} divide(f32[256,1]{1,0} %broadcast.198, f32[256,1]{1,0} %broadcast.200) + %reshape.221 = f32[256]{0} reshape(f32[256,1]{1,0} %divide.201) + %broadcast.222 = f32[256,200]{1,0} broadcast(f32[256]{0} %reshape.221), dimensions={0} + %subtract.223 = f32[256,200]{1,0} subtract(f32[256,200]{1,0} %add.195, f32[256,200]{1,0} %broadcast.222) + %multiply.202 = f32[256,200]{1,0} multiply(f32[256,200]{1,0} %add.195, f32[256,200]{1,0} %add.195) + %constant.203 = f32[] constant(0) + %reduce.204 = f32[256]{0} reduce(f32[256,200]{1,0} %multiply.202, f32[] %constant.203), dimensions={1}, to_apply=%primitive_computation_add__5.36 + %broadcast.205 = f32[256,1]{1,0} broadcast(f32[256]{0} %reduce.204), dimensions={0} + %constant.206 = f32[] constant(200) + %broadcast.207 = f32[256,1]{1,0} broadcast(f32[] %constant.206), dimensions={} + %divide.208 = f32[256,1]{1,0} divide(f32[256,1]{1,0} %broadcast.205, f32[256,1]{1,0} %broadcast.207) + %multiply.209 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %divide.201, f32[256,1]{1,0} %divide.201) + %subtract.210 = f32[256,1]{1,0} subtract(f32[256,1]{1,0} %divide.208, f32[256,1]{1,0} %multiply.209) + %constant.211 = f32[] constant(1e-06) + %broadcast.212 = f32[256,1]{1,0} broadcast(f32[] %constant.211), dimensions={} + %add.213 = f32[256,1]{1,0} add(f32[256,1]{1,0} %subtract.210, f32[256,1]{1,0} %broadcast.212) + %rsqrt.214 = f32[256,1]{1,0} rsqrt(f32[256,1]{1,0} %add.213) + %reshape.216 = f32[256]{0} reshape(f32[256,1]{1,0} %rsqrt.214) + %broadcast.217 = f32[256,200]{1,0} broadcast(f32[256]{0} %reshape.216), dimensions={0} + %parameter.187 = f32[200]{0} parameter(7) + %broadcast.215 = f32[1,200]{1,0} broadcast(f32[200]{0} %parameter.187), dimensions={1} + %reshape.218 = f32[200]{0} reshape(f32[1,200]{1,0} %broadcast.215) + %broadcast.219 = f32[256,200]{1,0} broadcast(f32[200]{0} %reshape.218), dimensions={1} + %multiply.220 = f32[256,200]{1,0} multiply(f32[256,200]{1,0} %broadcast.217, f32[256,200]{1,0} %broadcast.219) + %multiply.224 = f32[256,200]{1,0} multiply(f32[256,200]{1,0} %subtract.223, f32[256,200]{1,0} %multiply.220) + %parameter.186 = f32[200]{0} parameter(6) + %broadcast.225 = f32[1,200]{1,0} broadcast(f32[200]{0} %parameter.186), dimensions={1} + %reshape.226 = f32[200]{0} reshape(f32[1,200]{1,0} %broadcast.225) + %broadcast.227 = f32[256,200]{1,0} broadcast(f32[200]{0} %reshape.226), dimensions={1} + %add.228 = f32[256,200]{1,0} add(f32[256,200]{1,0} %multiply.224, f32[256,200]{1,0} %broadcast.227) + %tanh.229 = f32[256,200]{1,0} tanh(f32[256,200]{1,0} %add.228) + %parameter.183 = f32[200,200]{1,0} parameter(3) + %dot.230 = f32[256,200]{1,0} dot(f32[256,200]{1,0} %tanh.229, f32[200,200]{1,0} %parameter.183), lhs_contracting_dims={1}, rhs_contracting_dims={0} + %parameter.182 = f32[200]{0} parameter(2) + %broadcast.231 = f32[1,200]{1,0} broadcast(f32[200]{0} %parameter.182), dimensions={1} + %reshape.232 = f32[200]{0} reshape(f32[1,200]{1,0} %broadcast.231) + %broadcast.233 = f32[256,200]{1,0} broadcast(f32[200]{0} %reshape.232), dimensions={1} + %add.234 = f32[256,200]{1,0} add(f32[256,200]{1,0} %dot.230, f32[256,200]{1,0} %broadcast.233) + %constant.241 = f32[] constant(0) + %broadcast.242 = f32[256,200]{1,0} broadcast(f32[] %constant.241), dimensions={} + %compare.243 = pred[256,200]{1,0} compare(f32[256,200]{1,0} %add.234, f32[256,200]{1,0} %broadcast.242), direction=GT + %constant.235 = f32[] constant(0) + %broadcast.236 = f32[256,200]{1,0} broadcast(f32[] %constant.235), dimensions={} + %compare.237 = pred[256,200]{1,0} compare(f32[256,200]{1,0} %add.234, f32[256,200]{1,0} %broadcast.236), direction=GT + %constant.238 = f32[] constant(0) + %call.239 = (f32[256,200]{1,0}) call(pred[256,200]{1,0} %compare.237, f32[] %constant.238, f32[256,200]{1,0} %add.234), to_apply=%jit__where__6.41 + %get-tuple-element.240 = f32[256,200]{1,0} get-tuple-element((f32[256,200]{1,0}) %call.239), index=0 + %exponential-minus-one.244 = f32[256,200]{1,0} exponential-minus-one(f32[256,200]{1,0} %get-tuple-element.240) + %constant.245 = f32[] constant(1) + %broadcast.246 = f32[256,200]{1,0} broadcast(f32[] %constant.245), dimensions={} + %multiply.247 = f32[256,200]{1,0} multiply(f32[256,200]{1,0} %exponential-minus-one.244, f32[256,200]{1,0} %broadcast.246) + %call.248 = (f32[256,200]{1,0}) call(pred[256,200]{1,0} %compare.243, f32[256,200]{1,0} %add.234, f32[256,200]{1,0} %multiply.247), to_apply=%jit__where__7.50 + %get-tuple-element.249 = f32[256,200]{1,0} get-tuple-element((f32[256,200]{1,0}) %call.248), index=0 + %parameter.185 = f32[200,2]{1,0} parameter(5) + %dot.250 = f32[256,2]{1,0} dot(f32[256,200]{1,0} %get-tuple-element.249, f32[200,2]{1,0} %parameter.185), lhs_contracting_dims={1}, rhs_contracting_dims={0} + %parameter.184 = f32[2]{0} parameter(4) + %broadcast.251 = f32[1,2]{1,0} broadcast(f32[2]{0} %parameter.184), dimensions={1} + %reshape.252 = f32[2]{0} reshape(f32[1,2]{1,0} %broadcast.251) + %broadcast.253 = f32[256,2]{1,0} broadcast(f32[2]{0} %reshape.252), dimensions={1} + %add.254 = f32[256,2]{1,0} add(f32[256,2]{1,0} %dot.250, f32[256,2]{1,0} %broadcast.253) + %slice.255 = f32[256,1]{1,0} slice(f32[256,2]{1,0} %add.254), slice={[0:256], [0:1]} + %constant.261 = f32[] constant(-0.99999994) + %broadcast.262 = f32[1,1]{1,0} broadcast(f32[] %constant.261), dimensions={} + %reshape.315 = f32[1]{0} reshape(f32[1,1]{1,0} %broadcast.262) + %broadcast.316 = f32[256,1]{1,0} broadcast(f32[1]{0} %reshape.315), dimensions={1} + %get-tuple-element.289 = u32[128]{0} get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %while.286), index=2 + %get-tuple-element.290 = u32[128]{0} get-tuple-element((s32[], s32[], u32[128]{0}, u32[128]{0}, u32[], /*index=5*/u32[], u32[], u32[4]{0}, u32[4]{0}) %while.286), index=3 + %concatenate.296 = u32[256]{0} concatenate(u32[128]{0} %get-tuple-element.289, u32[128]{0} %get-tuple-element.290), dimensions={0} + %reshape.297 = u32[256,1]{1,0} reshape(u32[256]{0} %concatenate.296) + %constant.298 = u32[] constant(9) + %broadcast.299 = u32[256,1]{1,0} broadcast(u32[] %constant.298), dimensions={} + %shift-right-logical.300 = u32[256,1]{1,0} shift-right-logical(u32[256,1]{1,0} %reshape.297, u32[256,1]{1,0} %broadcast.299) + %constant.301 = u32[] constant(1065353216) + %broadcast.302 = u32[256,1]{1,0} broadcast(u32[] %constant.301), dimensions={} + %or.303 = u32[256,1]{1,0} or(u32[256,1]{1,0} %shift-right-logical.300, u32[256,1]{1,0} %broadcast.302) + %bitcast-convert.304 = f32[256,1]{1,0} bitcast-convert(u32[256,1]{1,0} %or.303) + %constant.305 = f32[] constant(1) + %broadcast.306 = f32[256,1]{1,0} broadcast(f32[] %constant.305), dimensions={} + %subtract.307 = f32[256,1]{1,0} subtract(f32[256,1]{1,0} %bitcast-convert.304, f32[256,1]{1,0} %broadcast.306) + %constant.263 = f32[] constant(1) + %broadcast.264 = f32[1,1]{1,0} broadcast(f32[] %constant.263), dimensions={} + %subtract.308 = f32[1,1]{1,0} subtract(f32[1,1]{1,0} %broadcast.264, f32[1,1]{1,0} %broadcast.262) + %reshape.309 = f32[1]{0} reshape(f32[1,1]{1,0} %subtract.308) + %broadcast.310 = f32[256,1]{1,0} broadcast(f32[1]{0} %reshape.309), dimensions={1} + %multiply.311 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %subtract.307, f32[256,1]{1,0} %broadcast.310) + %reshape.312 = f32[1]{0} reshape(f32[1,1]{1,0} %broadcast.262) + %broadcast.313 = f32[256,1]{1,0} broadcast(f32[1]{0} %reshape.312), dimensions={1} + %add.314 = f32[256,1]{1,0} add(f32[256,1]{1,0} %multiply.311, f32[256,1]{1,0} %broadcast.313) + %maximum.317 = f32[256,1]{1,0} maximum(f32[256,1]{1,0} %broadcast.316, f32[256,1]{1,0} %add.314) + %abs.399 = f32[256,1]{1,0} abs(f32[256,1]{1,0} %maximum.317) + %constant.398 = f32[] constant(1) + %broadcast.400 = f32[256,1]{1,0} broadcast(f32[] %constant.398), dimensions={} + %compare.401 = pred[256,1]{1,0} compare(f32[256,1]{1,0} %abs.399, f32[256,1]{1,0} %broadcast.400), direction=EQ + %constant.395 = f32[] constant(inf) + %broadcast.396 = f32[256,1]{1,0} broadcast(f32[] %constant.395), dimensions={} + %multiply.397 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %maximum.317, f32[256,1]{1,0} %broadcast.396) + %negate.318 = f32[256,1]{1,0} negate(f32[256,1]{1,0} %maximum.317) + %multiply.319 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %negate.318, f32[256,1]{1,0} %maximum.317) + %log-plus-one.320 = f32[256,1]{1,0} log-plus-one(f32[256,1]{1,0} %multiply.319) + %negate.321 = f32[256,1]{1,0} negate(f32[256,1]{1,0} %log-plus-one.320) + %constant.322 = f32[] constant(5) + %broadcast.323 = f32[256,1]{1,0} broadcast(f32[] %constant.322), dimensions={} + %compare.324 = pred[256,1]{1,0} compare(f32[256,1]{1,0} %negate.321, f32[256,1]{1,0} %broadcast.323), direction=LT + %constant.390 = f32[] constant(1.50140941) + %broadcast.391 = f32[256,1]{1,0} broadcast(f32[] %constant.390), dimensions={} + %constant.388 = f32[] constant(2.83297682) + %broadcast.389 = f32[256,1]{1,0} broadcast(f32[] %constant.388), dimensions={} + %select.392 = f32[256,1]{1,0} select(pred[256,1]{1,0} %compare.324, f32[256,1]{1,0} %broadcast.391, f32[256,1]{1,0} %broadcast.389) + %constant.383 = f32[] constant(0.246640727) + %broadcast.384 = f32[256,1]{1,0} broadcast(f32[] %constant.383), dimensions={} + %constant.381 = f32[] constant(1.00167406) + %broadcast.382 = f32[256,1]{1,0} broadcast(f32[] %constant.381), dimensions={} + %select.385 = f32[256,1]{1,0} select(pred[256,1]{1,0} %compare.324, f32[256,1]{1,0} %broadcast.384, f32[256,1]{1,0} %broadcast.382) + %constant.376 = f32[] constant(-0.00417768164) + %broadcast.377 = f32[256,1]{1,0} broadcast(f32[] %constant.376), dimensions={} + %constant.374 = f32[] constant(0.00943887047) + %broadcast.375 = f32[256,1]{1,0} broadcast(f32[] %constant.374), dimensions={} + %select.378 = f32[256,1]{1,0} select(pred[256,1]{1,0} %compare.324, f32[256,1]{1,0} %broadcast.377, f32[256,1]{1,0} %broadcast.375) + %constant.369 = f32[] constant(-0.00125372503) + %broadcast.370 = f32[256,1]{1,0} broadcast(f32[] %constant.369), dimensions={} + %constant.367 = f32[] constant(-0.0076224613) + %broadcast.368 = f32[256,1]{1,0} broadcast(f32[] %constant.367), dimensions={} + %select.371 = f32[256,1]{1,0} select(pred[256,1]{1,0} %compare.324, f32[256,1]{1,0} %broadcast.370, f32[256,1]{1,0} %broadcast.368) + %constant.362 = f32[] constant(0.00021858087) + %broadcast.363 = f32[256,1]{1,0} broadcast(f32[] %constant.362), dimensions={} + %constant.360 = f32[] constant(0.00573950773) + %broadcast.361 = f32[256,1]{1,0} broadcast(f32[] %constant.360), dimensions={} + %select.364 = f32[256,1]{1,0} select(pred[256,1]{1,0} %compare.324, f32[256,1]{1,0} %broadcast.363, f32[256,1]{1,0} %broadcast.361) + %constant.355 = f32[] constant(-4.39150654e-06) + %broadcast.356 = f32[256,1]{1,0} broadcast(f32[] %constant.355), dimensions={} + %constant.353 = f32[] constant(-0.00367342844) + %broadcast.354 = f32[256,1]{1,0} broadcast(f32[] %constant.353), dimensions={} + %select.357 = f32[256,1]{1,0} select(pred[256,1]{1,0} %compare.324, f32[256,1]{1,0} %broadcast.356, f32[256,1]{1,0} %broadcast.354) + %constant.348 = f32[] constant(-3.5233877e-06) + %broadcast.349 = f32[256,1]{1,0} broadcast(f32[] %constant.348), dimensions={} + %constant.346 = f32[] constant(0.00134934322) + %broadcast.347 = f32[256,1]{1,0} broadcast(f32[] %constant.346), dimensions={} + %select.350 = f32[256,1]{1,0} select(pred[256,1]{1,0} %compare.324, f32[256,1]{1,0} %broadcast.349, f32[256,1]{1,0} %broadcast.347) + %constant.341 = f32[] constant(3.43273939e-07) + %broadcast.342 = f32[256,1]{1,0} broadcast(f32[] %constant.341), dimensions={} + %constant.339 = f32[] constant(0.000100950558) + %broadcast.340 = f32[256,1]{1,0} broadcast(f32[] %constant.339), dimensions={} + %select.343 = f32[256,1]{1,0} select(pred[256,1]{1,0} %compare.324, f32[256,1]{1,0} %broadcast.342, f32[256,1]{1,0} %broadcast.340) + %constant.335 = f32[] constant(2.81022636e-08) + %broadcast.336 = f32[256,1]{1,0} broadcast(f32[] %constant.335), dimensions={} + %constant.333 = f32[] constant(-0.000200214257) + %broadcast.334 = f32[256,1]{1,0} broadcast(f32[] %constant.333), dimensions={} + %select.337 = f32[256,1]{1,0} select(pred[256,1]{1,0} %compare.324, f32[256,1]{1,0} %broadcast.336, f32[256,1]{1,0} %broadcast.334) + %constant.329 = f32[] constant(2.5) + %broadcast.330 = f32[256,1]{1,0} broadcast(f32[] %constant.329), dimensions={} + %subtract.331 = f32[256,1]{1,0} subtract(f32[256,1]{1,0} %negate.321, f32[256,1]{1,0} %broadcast.330) + %sqrt.326 = f32[256,1]{1,0} sqrt(f32[256,1]{1,0} %negate.321) + %constant.325 = f32[] constant(3) + %broadcast.327 = f32[256,1]{1,0} broadcast(f32[] %constant.325), dimensions={} + %subtract.328 = f32[256,1]{1,0} subtract(f32[256,1]{1,0} %sqrt.326, f32[256,1]{1,0} %broadcast.327) + %select.332 = f32[256,1]{1,0} select(pred[256,1]{1,0} %compare.324, f32[256,1]{1,0} %subtract.331, f32[256,1]{1,0} %subtract.328) + %multiply.338 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %select.337, f32[256,1]{1,0} %select.332) + %add.344 = f32[256,1]{1,0} add(f32[256,1]{1,0} %select.343, f32[256,1]{1,0} %multiply.338) + %multiply.345 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %add.344, f32[256,1]{1,0} %select.332) + %add.351 = f32[256,1]{1,0} add(f32[256,1]{1,0} %select.350, f32[256,1]{1,0} %multiply.345) + %multiply.352 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %add.351, f32[256,1]{1,0} %select.332) + %add.358 = f32[256,1]{1,0} add(f32[256,1]{1,0} %select.357, f32[256,1]{1,0} %multiply.352) + %multiply.359 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %add.358, f32[256,1]{1,0} %select.332) + %add.365 = f32[256,1]{1,0} add(f32[256,1]{1,0} %select.364, f32[256,1]{1,0} %multiply.359) + %multiply.366 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %add.365, f32[256,1]{1,0} %select.332) + %add.372 = f32[256,1]{1,0} add(f32[256,1]{1,0} %select.371, f32[256,1]{1,0} %multiply.366) + %multiply.373 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %add.372, f32[256,1]{1,0} %select.332) + %add.379 = f32[256,1]{1,0} add(f32[256,1]{1,0} %select.378, f32[256,1]{1,0} %multiply.373) + %multiply.380 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %add.379, f32[256,1]{1,0} %select.332) + %add.386 = f32[256,1]{1,0} add(f32[256,1]{1,0} %select.385, f32[256,1]{1,0} %multiply.380) + %multiply.387 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %add.386, f32[256,1]{1,0} %select.332) + %add.393 = f32[256,1]{1,0} add(f32[256,1]{1,0} %select.392, f32[256,1]{1,0} %multiply.387) + %multiply.394 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %add.393, f32[256,1]{1,0} %maximum.317) + %select.402 = f32[256,1]{1,0} select(pred[256,1]{1,0} %compare.401, f32[256,1]{1,0} %multiply.397, f32[256,1]{1,0} %multiply.394) + %constant.403 = f32[] constant(1.41421354) + %broadcast.404 = f32[256,1]{1,0} broadcast(f32[] %constant.403), dimensions={} + %multiply.405 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %select.402, f32[256,1]{1,0} %broadcast.404) + %slice.256 = f32[256,1]{1,0} slice(f32[256,2]{1,0} %add.254), slice={[0:256], [1:2]} + %constant.257 = f32[] constant(-20) + %call.258 = (f32[256,1]{1,0}) call(f32[256,1]{1,0} %slice.256, f32[] %constant.257), to_apply=%jit_clip__12.57 + %get-tuple-element.259 = f32[256,1]{1,0} get-tuple-element((f32[256,1]{1,0}) %call.258), index=0 + %exponential.260 = f32[256,1]{1,0} exponential(f32[256,1]{1,0} %get-tuple-element.259) + %multiply.406 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %multiply.405, f32[256,1]{1,0} %exponential.260) + %add.407 = f32[256,1]{1,0} add(f32[256,1]{1,0} %slice.255, f32[256,1]{1,0} %multiply.406) + %tanh.410 = f32[256,1]{1,0} tanh(f32[256,1]{1,0} %add.407) + %constant.427 = f32[] constant(1) + %broadcast.428 = f32[256,1]{1,0} broadcast(f32[] %constant.427), dimensions={} + %multiply.429 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %tanh.410, f32[256,1]{1,0} %broadcast.428) + %call.408 = (f32[256,1]{1,0}) call(f32[256,1]{1,0} %add.407, f32[256,1]{1,0} %slice.255, f32[256,1]{1,0} %get-tuple-element.259), to_apply=%jit_gaussian_likelihood.149 + %get-tuple-element.409 = f32[256,1]{1,0} get-tuple-element((f32[256,1]{1,0}) %call.408), index=0 + %constant.412 = f32[] constant(1) + %broadcast.413 = f32[256,1]{1,0} broadcast(f32[] %constant.412), dimensions={} + %multiply.411 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %tanh.410, f32[256,1]{1,0} %tanh.410) + %subtract.414 = f32[256,1]{1,0} subtract(f32[256,1]{1,0} %broadcast.413, f32[256,1]{1,0} %multiply.411) + %constant.416 = f32[] constant(0) + %broadcast.417 = f32[256,1]{1,0} broadcast(f32[] %constant.416), dimensions={} + %maximum.418 = f32[256,1]{1,0} maximum(f32[256,1]{1,0} %subtract.414, f32[256,1]{1,0} %broadcast.417) + %constant.419 = f32[] constant(1e-06) + %broadcast.420 = f32[256,1]{1,0} broadcast(f32[] %constant.419), dimensions={} + %add.421 = f32[256,1]{1,0} add(f32[256,1]{1,0} %maximum.418, f32[256,1]{1,0} %broadcast.420) + %log.422 = f32[256,1]{1,0} log(f32[256,1]{1,0} %add.421) + %constant.423 = f32[] constant(0) + %reduce.424 = f32[256]{0} reduce(f32[256,1]{1,0} %log.422, f32[] %constant.423), dimensions={1}, to_apply=%primitive_computation_add__6.174 + %broadcast.425 = f32[256,1]{1,0} broadcast(f32[256]{0} %reduce.424), dimensions={0} + %subtract.426 = f32[256,1]{1,0} subtract(f32[256,1]{1,0} %get-tuple-element.409, f32[256,1]{1,0} %broadcast.425) + ROOT %tuple.430 = (f32[256,1]{1,0}, f32[256,1]{1,0}) tuple(f32[256,1]{1,0} %multiply.429, f32[256,1]{1,0} %subtract.426) +} + +%primitive_computation_add__7.434 (parameter.435: f32[], parameter.436: f32[]) -> f32[] { + %constant.437 = pred[] constant(false) + %parameter.435 = f32[] parameter(0) + %parameter.436 = f32[] parameter(1) + ROOT %add.438 = f32[] add(f32[] %parameter.435, f32[] %parameter.436) +} + +%primitive_computation_add__8.439 (parameter.440: f32[], parameter.441: f32[]) -> f32[] { + %constant.442 = pred[] constant(false) + %parameter.440 = f32[] parameter(0) + %parameter.441 = f32[] parameter(1) + ROOT %add.443 = f32[] add(f32[] %parameter.440, f32[] %parameter.441) +} + +%jit__where__8.444 (parameter.445: pred[256,500], parameter.446: f32[], parameter.447: f32[256,500]) -> (f32[256,500]) { + %constant.448 = pred[] constant(false) + %parameter.445 = pred[256,500]{1,0} parameter(0) + %parameter.446 = f32[] parameter(1) + %convert.449 = f32[] convert(f32[] %parameter.446) + %broadcast.450 = f32[256,500]{1,0} broadcast(f32[] %convert.449), dimensions={} + %parameter.447 = f32[256,500]{1,0} parameter(2) + %select.451 = f32[256,500]{1,0} select(pred[256,500]{1,0} %parameter.445, f32[256,500]{1,0} %broadcast.450, f32[256,500]{1,0} %parameter.447) + ROOT %tuple.452 = (f32[256,500]{1,0}) tuple(f32[256,500]{1,0} %select.451) +} + +%jit__where__9.453 (parameter.454: pred[256,500], parameter.455: f32[256,500], parameter.456: f32[256,500]) -> (f32[256,500]) { + %constant.457 = pred[] constant(false) + %parameter.454 = pred[256,500]{1,0} parameter(0) + %parameter.455 = f32[256,500]{1,0} parameter(1) + %parameter.456 = f32[256,500]{1,0} parameter(2) + %select.458 = f32[256,500]{1,0} select(pred[256,500]{1,0} %parameter.454, f32[256,500]{1,0} %parameter.455, f32[256,500]{1,0} %parameter.456) + ROOT %tuple.459 = (f32[256,500]{1,0}) tuple(f32[256,500]{1,0} %select.458) +} + +%primitive_computation_add__9.460 (parameter.461: f32[], parameter.462: f32[]) -> f32[] { + %constant.463 = pred[] constant(false) + %parameter.461 = f32[] parameter(0) + %parameter.462 = f32[] parameter(1) + ROOT %add.464 = f32[] add(f32[] %parameter.461, f32[] %parameter.462) +} + +%primitive_computation_add__10.465 (parameter.466: f32[], parameter.467: f32[]) -> f32[] { + %constant.468 = pred[] constant(false) + %parameter.466 = f32[] parameter(0) + %parameter.467 = f32[] parameter(1) + ROOT %add.469 = f32[] add(f32[] %parameter.466, f32[] %parameter.467) +} + +%jit__where__10.470 (parameter.471: pred[256,500], parameter.472: f32[], parameter.473: f32[256,500]) -> (f32[256,500]) { + %constant.474 = pred[] constant(false) + %parameter.471 = pred[256,500]{1,0} parameter(0) + %parameter.472 = f32[] parameter(1) + %convert.475 = f32[] convert(f32[] %parameter.472) + %broadcast.476 = f32[256,500]{1,0} broadcast(f32[] %convert.475), dimensions={} + %parameter.473 = f32[256,500]{1,0} parameter(2) + %select.477 = f32[256,500]{1,0} select(pred[256,500]{1,0} %parameter.471, f32[256,500]{1,0} %broadcast.476, f32[256,500]{1,0} %parameter.473) + ROOT %tuple.478 = (f32[256,500]{1,0}) tuple(f32[256,500]{1,0} %select.477) +} + +%jit__where__11.479 (parameter.480: pred[256,500], parameter.481: f32[256,500], parameter.482: f32[256,500]) -> (f32[256,500]) { + %constant.483 = pred[] constant(false) + %parameter.480 = pred[256,500]{1,0} parameter(0) + %parameter.481 = f32[256,500]{1,0} parameter(1) + %parameter.482 = f32[256,500]{1,0} parameter(2) + %select.484 = f32[256,500]{1,0} select(pred[256,500]{1,0} %parameter.480, f32[256,500]{1,0} %parameter.481, f32[256,500]{1,0} %parameter.482) + ROOT %tuple.485 = (f32[256,500]{1,0}) tuple(f32[256,500]{1,0} %select.484) +} + +%jit_apply_double_critic_model.486 (parameter.487: f32[500], parameter.488: f32[6,500], parameter.489: f32[500], parameter.490: f32[500,500], parameter.491: f32[1], parameter.492: f32[500,1], parameter.493: f32[500], parameter.494: f32[6,500], parameter.495: f32[500], parameter.496: f32[500,500], parameter.497: f32[1], parameter.498: f32[500,1], parameter.499: f32[500], parameter.500: f32[500], parameter.501: f32[500], parameter.502: f32[500], parameter.503: f32[256,5], parameter.504: f32[256,1]) -> (f32[256,1], f32[256,1]) { + %constant.505 = pred[] constant(false) + %parameter.503 = f32[256,5]{1,0} parameter(16) + %parameter.504 = f32[256,1]{1,0} parameter(17) + %concatenate.506 = f32[256,6]{1,0} concatenate(f32[256,5]{1,0} %parameter.503, f32[256,1]{1,0} %parameter.504), dimensions={1} + %parameter.488 = f32[6,500]{1,0} parameter(1) + %dot.507 = f32[256,500]{1,0} dot(f32[256,6]{1,0} %concatenate.506, f32[6,500]{1,0} %parameter.488), lhs_contracting_dims={1}, rhs_contracting_dims={0} + %parameter.487 = f32[500]{0} parameter(0) + %broadcast.508 = f32[1,500]{1,0} broadcast(f32[500]{0} %parameter.487), dimensions={1} + %reshape.509 = f32[500]{0} reshape(f32[1,500]{1,0} %broadcast.508) + %broadcast.510 = f32[256,500]{1,0} broadcast(f32[500]{0} %reshape.509), dimensions={1} + %add.511 = f32[256,500]{1,0} add(f32[256,500]{1,0} %dot.507, f32[256,500]{1,0} %broadcast.510) + %constant.512 = f32[] constant(0) + %reduce.513 = f32[256]{0} reduce(f32[256,500]{1,0} %add.511, f32[] %constant.512), dimensions={1}, to_apply=%primitive_computation_add__7.434 + %broadcast.514 = f32[256,1]{1,0} broadcast(f32[256]{0} %reduce.513), dimensions={0} + %constant.515 = f32[] constant(500) + %broadcast.516 = f32[256,1]{1,0} broadcast(f32[] %constant.515), dimensions={} + %divide.517 = f32[256,1]{1,0} divide(f32[256,1]{1,0} %broadcast.514, f32[256,1]{1,0} %broadcast.516) + %reshape.537 = f32[256]{0} reshape(f32[256,1]{1,0} %divide.517) + %broadcast.538 = f32[256,500]{1,0} broadcast(f32[256]{0} %reshape.537), dimensions={0} + %subtract.539 = f32[256,500]{1,0} subtract(f32[256,500]{1,0} %add.511, f32[256,500]{1,0} %broadcast.538) + %multiply.518 = f32[256,500]{1,0} multiply(f32[256,500]{1,0} %add.511, f32[256,500]{1,0} %add.511) + %constant.519 = f32[] constant(0) + %reduce.520 = f32[256]{0} reduce(f32[256,500]{1,0} %multiply.518, f32[] %constant.519), dimensions={1}, to_apply=%primitive_computation_add__8.439 + %broadcast.521 = f32[256,1]{1,0} broadcast(f32[256]{0} %reduce.520), dimensions={0} + %constant.522 = f32[] constant(500) + %broadcast.523 = f32[256,1]{1,0} broadcast(f32[] %constant.522), dimensions={} + %divide.524 = f32[256,1]{1,0} divide(f32[256,1]{1,0} %broadcast.521, f32[256,1]{1,0} %broadcast.523) + %multiply.525 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %divide.517, f32[256,1]{1,0} %divide.517) + %subtract.526 = f32[256,1]{1,0} subtract(f32[256,1]{1,0} %divide.524, f32[256,1]{1,0} %multiply.525) + %constant.527 = f32[] constant(1e-06) + %broadcast.528 = f32[256,1]{1,0} broadcast(f32[] %constant.527), dimensions={} + %add.529 = f32[256,1]{1,0} add(f32[256,1]{1,0} %subtract.526, f32[256,1]{1,0} %broadcast.528) + %rsqrt.530 = f32[256,1]{1,0} rsqrt(f32[256,1]{1,0} %add.529) + %reshape.532 = f32[256]{0} reshape(f32[256,1]{1,0} %rsqrt.530) + %broadcast.533 = f32[256,500]{1,0} broadcast(f32[256]{0} %reshape.532), dimensions={0} + %parameter.500 = f32[500]{0} parameter(13) + %broadcast.531 = f32[1,500]{1,0} broadcast(f32[500]{0} %parameter.500), dimensions={1} + %reshape.534 = f32[500]{0} reshape(f32[1,500]{1,0} %broadcast.531) + %broadcast.535 = f32[256,500]{1,0} broadcast(f32[500]{0} %reshape.534), dimensions={1} + %multiply.536 = f32[256,500]{1,0} multiply(f32[256,500]{1,0} %broadcast.533, f32[256,500]{1,0} %broadcast.535) + %multiply.540 = f32[256,500]{1,0} multiply(f32[256,500]{1,0} %subtract.539, f32[256,500]{1,0} %multiply.536) + %parameter.499 = f32[500]{0} parameter(12) + %broadcast.541 = f32[1,500]{1,0} broadcast(f32[500]{0} %parameter.499), dimensions={1} + %reshape.542 = f32[500]{0} reshape(f32[1,500]{1,0} %broadcast.541) + %broadcast.543 = f32[256,500]{1,0} broadcast(f32[500]{0} %reshape.542), dimensions={1} + %add.544 = f32[256,500]{1,0} add(f32[256,500]{1,0} %multiply.540, f32[256,500]{1,0} %broadcast.543) + %tanh.545 = f32[256,500]{1,0} tanh(f32[256,500]{1,0} %add.544) + %parameter.490 = f32[500,500]{1,0} parameter(3) + %dot.546 = f32[256,500]{1,0} dot(f32[256,500]{1,0} %tanh.545, f32[500,500]{1,0} %parameter.490), lhs_contracting_dims={1}, rhs_contracting_dims={0} + %parameter.489 = f32[500]{0} parameter(2) + %broadcast.547 = f32[1,500]{1,0} broadcast(f32[500]{0} %parameter.489), dimensions={1} + %reshape.548 = f32[500]{0} reshape(f32[1,500]{1,0} %broadcast.547) + %broadcast.549 = f32[256,500]{1,0} broadcast(f32[500]{0} %reshape.548), dimensions={1} + %add.550 = f32[256,500]{1,0} add(f32[256,500]{1,0} %dot.546, f32[256,500]{1,0} %broadcast.549) + %constant.557 = f32[] constant(0) + %broadcast.558 = f32[256,500]{1,0} broadcast(f32[] %constant.557), dimensions={} + %compare.559 = pred[256,500]{1,0} compare(f32[256,500]{1,0} %add.550, f32[256,500]{1,0} %broadcast.558), direction=GT + %constant.551 = f32[] constant(0) + %broadcast.552 = f32[256,500]{1,0} broadcast(f32[] %constant.551), dimensions={} + %compare.553 = pred[256,500]{1,0} compare(f32[256,500]{1,0} %add.550, f32[256,500]{1,0} %broadcast.552), direction=GT + %constant.554 = f32[] constant(0) + %call.555 = (f32[256,500]{1,0}) call(pred[256,500]{1,0} %compare.553, f32[] %constant.554, f32[256,500]{1,0} %add.550), to_apply=%jit__where__8.444 + %get-tuple-element.556 = f32[256,500]{1,0} get-tuple-element((f32[256,500]{1,0}) %call.555), index=0 + %exponential-minus-one.560 = f32[256,500]{1,0} exponential-minus-one(f32[256,500]{1,0} %get-tuple-element.556) + %constant.561 = f32[] constant(1) + %broadcast.562 = f32[256,500]{1,0} broadcast(f32[] %constant.561), dimensions={} + %multiply.563 = f32[256,500]{1,0} multiply(f32[256,500]{1,0} %exponential-minus-one.560, f32[256,500]{1,0} %broadcast.562) + %call.564 = (f32[256,500]{1,0}) call(pred[256,500]{1,0} %compare.559, f32[256,500]{1,0} %add.550, f32[256,500]{1,0} %multiply.563), to_apply=%jit__where__9.453 + %get-tuple-element.565 = f32[256,500]{1,0} get-tuple-element((f32[256,500]{1,0}) %call.564), index=0 + %parameter.492 = f32[500,1]{1,0} parameter(5) + %dot.566 = f32[256,1]{1,0} dot(f32[256,500]{1,0} %get-tuple-element.565, f32[500,1]{1,0} %parameter.492), lhs_contracting_dims={1}, rhs_contracting_dims={0} + %parameter.491 = f32[1]{0} parameter(4) + %broadcast.567 = f32[1,1]{1,0} broadcast(f32[1]{0} %parameter.491), dimensions={1} + %reshape.568 = f32[1]{0} reshape(f32[1,1]{1,0} %broadcast.567) + %broadcast.569 = f32[256,1]{1,0} broadcast(f32[1]{0} %reshape.568), dimensions={1} + %add.570 = f32[256,1]{1,0} add(f32[256,1]{1,0} %dot.566, f32[256,1]{1,0} %broadcast.569) + %parameter.494 = f32[6,500]{1,0} parameter(7) + %dot.571 = f32[256,500]{1,0} dot(f32[256,6]{1,0} %concatenate.506, f32[6,500]{1,0} %parameter.494), lhs_contracting_dims={1}, rhs_contracting_dims={0} + %parameter.493 = f32[500]{0} parameter(6) + %broadcast.572 = f32[1,500]{1,0} broadcast(f32[500]{0} %parameter.493), dimensions={1} + %reshape.573 = f32[500]{0} reshape(f32[1,500]{1,0} %broadcast.572) + %broadcast.574 = f32[256,500]{1,0} broadcast(f32[500]{0} %reshape.573), dimensions={1} + %add.575 = f32[256,500]{1,0} add(f32[256,500]{1,0} %dot.571, f32[256,500]{1,0} %broadcast.574) + %constant.576 = f32[] constant(0) + %reduce.577 = f32[256]{0} reduce(f32[256,500]{1,0} %add.575, f32[] %constant.576), dimensions={1}, to_apply=%primitive_computation_add__9.460 + %broadcast.578 = f32[256,1]{1,0} broadcast(f32[256]{0} %reduce.577), dimensions={0} + %constant.579 = f32[] constant(500) + %broadcast.580 = f32[256,1]{1,0} broadcast(f32[] %constant.579), dimensions={} + %divide.581 = f32[256,1]{1,0} divide(f32[256,1]{1,0} %broadcast.578, f32[256,1]{1,0} %broadcast.580) + %reshape.601 = f32[256]{0} reshape(f32[256,1]{1,0} %divide.581) + %broadcast.602 = f32[256,500]{1,0} broadcast(f32[256]{0} %reshape.601), dimensions={0} + %subtract.603 = f32[256,500]{1,0} subtract(f32[256,500]{1,0} %add.575, f32[256,500]{1,0} %broadcast.602) + %multiply.582 = f32[256,500]{1,0} multiply(f32[256,500]{1,0} %add.575, f32[256,500]{1,0} %add.575) + %constant.583 = f32[] constant(0) + %reduce.584 = f32[256]{0} reduce(f32[256,500]{1,0} %multiply.582, f32[] %constant.583), dimensions={1}, to_apply=%primitive_computation_add__10.465 + %broadcast.585 = f32[256,1]{1,0} broadcast(f32[256]{0} %reduce.584), dimensions={0} + %constant.586 = f32[] constant(500) + %broadcast.587 = f32[256,1]{1,0} broadcast(f32[] %constant.586), dimensions={} + %divide.588 = f32[256,1]{1,0} divide(f32[256,1]{1,0} %broadcast.585, f32[256,1]{1,0} %broadcast.587) + %multiply.589 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %divide.581, f32[256,1]{1,0} %divide.581) + %subtract.590 = f32[256,1]{1,0} subtract(f32[256,1]{1,0} %divide.588, f32[256,1]{1,0} %multiply.589) + %constant.591 = f32[] constant(1e-06) + %broadcast.592 = f32[256,1]{1,0} broadcast(f32[] %constant.591), dimensions={} + %add.593 = f32[256,1]{1,0} add(f32[256,1]{1,0} %subtract.590, f32[256,1]{1,0} %broadcast.592) + %rsqrt.594 = f32[256,1]{1,0} rsqrt(f32[256,1]{1,0} %add.593) + %reshape.596 = f32[256]{0} reshape(f32[256,1]{1,0} %rsqrt.594) + %broadcast.597 = f32[256,500]{1,0} broadcast(f32[256]{0} %reshape.596), dimensions={0} + %parameter.502 = f32[500]{0} parameter(15) + %broadcast.595 = f32[1,500]{1,0} broadcast(f32[500]{0} %parameter.502), dimensions={1} + %reshape.598 = f32[500]{0} reshape(f32[1,500]{1,0} %broadcast.595) + %broadcast.599 = f32[256,500]{1,0} broadcast(f32[500]{0} %reshape.598), dimensions={1} + %multiply.600 = f32[256,500]{1,0} multiply(f32[256,500]{1,0} %broadcast.597, f32[256,500]{1,0} %broadcast.599) + %multiply.604 = f32[256,500]{1,0} multiply(f32[256,500]{1,0} %subtract.603, f32[256,500]{1,0} %multiply.600) + %parameter.501 = f32[500]{0} parameter(14) + %broadcast.605 = f32[1,500]{1,0} broadcast(f32[500]{0} %parameter.501), dimensions={1} + %reshape.606 = f32[500]{0} reshape(f32[1,500]{1,0} %broadcast.605) + %broadcast.607 = f32[256,500]{1,0} broadcast(f32[500]{0} %reshape.606), dimensions={1} + %add.608 = f32[256,500]{1,0} add(f32[256,500]{1,0} %multiply.604, f32[256,500]{1,0} %broadcast.607) + %tanh.609 = f32[256,500]{1,0} tanh(f32[256,500]{1,0} %add.608) + %parameter.496 = f32[500,500]{1,0} parameter(9) + %dot.610 = f32[256,500]{1,0} dot(f32[256,500]{1,0} %tanh.609, f32[500,500]{1,0} %parameter.496), lhs_contracting_dims={1}, rhs_contracting_dims={0} + %parameter.495 = f32[500]{0} parameter(8) + %broadcast.611 = f32[1,500]{1,0} broadcast(f32[500]{0} %parameter.495), dimensions={1} + %reshape.612 = f32[500]{0} reshape(f32[1,500]{1,0} %broadcast.611) + %broadcast.613 = f32[256,500]{1,0} broadcast(f32[500]{0} %reshape.612), dimensions={1} + %add.614 = f32[256,500]{1,0} add(f32[256,500]{1,0} %dot.610, f32[256,500]{1,0} %broadcast.613) + %constant.621 = f32[] constant(0) + %broadcast.622 = f32[256,500]{1,0} broadcast(f32[] %constant.621), dimensions={} + %compare.623 = pred[256,500]{1,0} compare(f32[256,500]{1,0} %add.614, f32[256,500]{1,0} %broadcast.622), direction=GT + %constant.615 = f32[] constant(0) + %broadcast.616 = f32[256,500]{1,0} broadcast(f32[] %constant.615), dimensions={} + %compare.617 = pred[256,500]{1,0} compare(f32[256,500]{1,0} %add.614, f32[256,500]{1,0} %broadcast.616), direction=GT + %constant.618 = f32[] constant(0) + %call.619 = (f32[256,500]{1,0}) call(pred[256,500]{1,0} %compare.617, f32[] %constant.618, f32[256,500]{1,0} %add.614), to_apply=%jit__where__10.470 + %get-tuple-element.620 = f32[256,500]{1,0} get-tuple-element((f32[256,500]{1,0}) %call.619), index=0 + %exponential-minus-one.624 = f32[256,500]{1,0} exponential-minus-one(f32[256,500]{1,0} %get-tuple-element.620) + %constant.625 = f32[] constant(1) + %broadcast.626 = f32[256,500]{1,0} broadcast(f32[] %constant.625), dimensions={} + %multiply.627 = f32[256,500]{1,0} multiply(f32[256,500]{1,0} %exponential-minus-one.624, f32[256,500]{1,0} %broadcast.626) + %call.628 = (f32[256,500]{1,0}) call(pred[256,500]{1,0} %compare.623, f32[256,500]{1,0} %add.614, f32[256,500]{1,0} %multiply.627), to_apply=%jit__where__11.479 + %get-tuple-element.629 = f32[256,500]{1,0} get-tuple-element((f32[256,500]{1,0}) %call.628), index=0 + %parameter.498 = f32[500,1]{1,0} parameter(11) + %dot.630 = f32[256,1]{1,0} dot(f32[256,500]{1,0} %get-tuple-element.629, f32[500,1]{1,0} %parameter.498), lhs_contracting_dims={1}, rhs_contracting_dims={0} + %parameter.497 = f32[1]{0} parameter(10) + %broadcast.631 = f32[1,1]{1,0} broadcast(f32[1]{0} %parameter.497), dimensions={1} + %reshape.632 = f32[1]{0} reshape(f32[1,1]{1,0} %broadcast.631) + %broadcast.633 = f32[256,1]{1,0} broadcast(f32[1]{0} %reshape.632), dimensions={1} + %add.634 = f32[256,1]{1,0} add(f32[256,1]{1,0} %dot.630, f32[256,1]{1,0} %broadcast.633) + ROOT %tuple.635 = (f32[256,1]{1,0}, f32[256,1]{1,0}) tuple(f32[256,1]{1,0} %add.570, f32[256,1]{1,0} %add.634) +} + +%jit_apply_constant_model.640 (parameter.641: f32[1]) -> (f32[1]) { + %constant.642 = pred[] constant(false) + %parameter.641 = f32[1]{0} parameter(0) + ROOT %tuple.643 = (f32[1]{0}) tuple(f32[1]{0} %parameter.641) +} + +ENTRY %jit_get_td_target.657 (parameter.1: u32[2], parameter.2: f32[256,5], parameter.3: f32[256,1], parameter.4: f32[256,1], parameter.5: f32[200], parameter.6: f32[5,200], parameter.7: f32[200], parameter.8: f32[200,200], parameter.9: f32[2], parameter.10: f32[200,2], parameter.11: f32[200], parameter.12: f32[200], parameter.13: f32[500], parameter.14: f32[6,500], parameter.15: f32[500], parameter.16: f32[500,500], parameter.17: f32[1], parameter.18: f32[500,1], parameter.19: f32[500], parameter.20: f32[6,500], parameter.21: f32[500], parameter.22: f32[500,500], parameter.23: f32[1], parameter.24: f32[500,1], parameter.25: f32[500], parameter.26: f32[500], parameter.27: f32[500], parameter.28: f32[500], parameter.29: f32[1]) -> f32[256,1] { + %constant.30 = pred[] constant(false) + %parameter.3 = f32[256,1]{1,0} parameter(2) + %parameter.4 = f32[256,1]{1,0} parameter(3) + %constant.652 = f32[] constant(0.99) + %broadcast.653 = f32[256,1]{1,0} broadcast(f32[] %constant.652), dimensions={} + %multiply.654 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %parameter.4, f32[256,1]{1,0} %broadcast.653) + %parameter.13 = f32[500]{0} parameter(12) + %parameter.14 = f32[6,500]{1,0} parameter(13) + %parameter.15 = f32[500]{0} parameter(14) + %parameter.16 = f32[500,500]{1,0} parameter(15) + %parameter.17 = f32[1]{0} parameter(16) + %parameter.18 = f32[500,1]{1,0} parameter(17) + %parameter.19 = f32[500]{0} parameter(18) + %parameter.20 = f32[6,500]{1,0} parameter(19) + %parameter.21 = f32[500]{0} parameter(20) + %parameter.22 = f32[500,500]{1,0} parameter(21) + %parameter.23 = f32[1]{0} parameter(22) + %parameter.24 = f32[500,1]{1,0} parameter(23) + %parameter.25 = f32[500]{0} parameter(24) + %parameter.26 = f32[500]{0} parameter(25) + %parameter.27 = f32[500]{0} parameter(26) + %parameter.28 = f32[500]{0} parameter(27) + %parameter.2 = f32[256,5]{1,0} parameter(1) + %parameter.5 = f32[200]{0} parameter(4) + %parameter.6 = f32[5,200]{1,0} parameter(5) + %parameter.7 = f32[200]{0} parameter(6) + %parameter.8 = f32[200,200]{1,0} parameter(7) + %parameter.9 = f32[2]{0} parameter(8) + %parameter.10 = f32[200,2]{1,0} parameter(9) + %parameter.11 = f32[200]{0} parameter(10) + %parameter.12 = f32[200]{0} parameter(11) + %parameter.1 = u32[2]{0} parameter(0) + %call.431 = (f32[256,1]{1,0}, f32[256,1]{1,0}) call(f32[200]{0} %parameter.5, f32[5,200]{1,0} %parameter.6, f32[200]{0} %parameter.7, f32[200,200]{1,0} %parameter.8, f32[2]{0} %parameter.9, /*index=5*/f32[200,2]{1,0} %parameter.10, f32[200]{0} %parameter.11, f32[200]{0} %parameter.12, f32[256,5]{1,0} %parameter.2, u32[2]{0} %parameter.1), to_apply=%jit_apply_gaussian_policy_model__1.179 + %get-tuple-element.432 = f32[256,1]{1,0} get-tuple-element((f32[256,1]{1,0}, f32[256,1]{1,0}) %call.431), index=0 + %call.636 = (f32[256,1]{1,0}, f32[256,1]{1,0}) call(f32[500]{0} %parameter.13, f32[6,500]{1,0} %parameter.14, f32[500]{0} %parameter.15, f32[500,500]{1,0} %parameter.16, f32[1]{0} %parameter.17, /*index=5*/f32[500,1]{1,0} %parameter.18, f32[500]{0} %parameter.19, f32[6,500]{1,0} %parameter.20, f32[500]{0} %parameter.21, f32[500,500]{1,0} %parameter.22, /*index=10*/f32[1]{0} %parameter.23, f32[500,1]{1,0} %parameter.24, f32[500]{0} %parameter.25, f32[500]{0} %parameter.26, f32[500]{0} %parameter.27, /*index=15*/f32[500]{0} %parameter.28, f32[256,5]{1,0} %parameter.2, f32[256,1]{1,0} %get-tuple-element.432), to_apply=%jit_apply_double_critic_model.486 + %get-tuple-element.637 = f32[256,1]{1,0} get-tuple-element((f32[256,1]{1,0}, f32[256,1]{1,0}) %call.636), index=0 + %get-tuple-element.638 = f32[256,1]{1,0} get-tuple-element((f32[256,1]{1,0}, f32[256,1]{1,0}) %call.636), index=1 + %minimum.639 = f32[256,1]{1,0} minimum(f32[256,1]{1,0} %get-tuple-element.637, f32[256,1]{1,0} %get-tuple-element.638) + %parameter.29 = f32[1]{0} parameter(28) + %call.644 = (f32[1]{0}) call(f32[1]{0} %parameter.29), to_apply=%jit_apply_constant_model.640 + %get-tuple-element.645 = f32[1]{0} get-tuple-element((f32[1]{0}) %call.644), index=0 + %exponential.646 = f32[1]{0} exponential(f32[1]{0} %get-tuple-element.645) + %broadcast.647 = f32[1,1]{1,0} broadcast(f32[1]{0} %exponential.646), dimensions={1} + %reshape.648 = f32[1]{0} reshape(f32[1,1]{1,0} %broadcast.647) + %broadcast.649 = f32[256,1]{1,0} broadcast(f32[1]{0} %reshape.648), dimensions={1} + %get-tuple-element.433 = f32[256,1]{1,0} get-tuple-element((f32[256,1]{1,0}, f32[256,1]{1,0}) %call.431), index=1 + %multiply.650 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %broadcast.649, f32[256,1]{1,0} %get-tuple-element.433) + %subtract.651 = f32[256,1]{1,0} subtract(f32[256,1]{1,0} %minimum.639, f32[256,1]{1,0} %multiply.650) + %multiply.655 = f32[256,1]{1,0} multiply(f32[256,1]{1,0} %multiply.654, f32[256,1]{1,0} %subtract.651) + ROOT %add.656 = f32[256,1]{1,0} add(f32[256,1]{1,0} %parameter.3, f32[256,1]{1,0} %multiply.655) +} + diff --git a/tests/hlo_texts/test_hlos/jaxrl/module_0140.jit_qr.53.before_optimizations.txt b/tests/hlo_texts/test_hlos/jaxrl/module_0140.jit_qr.53.before_optimizations.txt new file mode 100644 index 0000000..d69c894 --- /dev/null +++ b/tests/hlo_texts/test_hlos/jaxrl/module_0140.jit_qr.53.before_optimizations.txt @@ -0,0 +1,61 @@ +HloModule jit_qr.53 + +jit_triu__3.37.2 { + iota.8 = s32[23]{0} iota(), iota_dimension=0 + broadcast.9 = s32[23,23]{1,0} broadcast(iota.8), dimensions={0} + constant.6 = s32[] constant(-1) + broadcast.7 = s32[23,23]{1,0} broadcast(constant.6), dimensions={} + add.10 = s32[23,23]{1,0} add(broadcast.9, broadcast.7) + iota.11 = s32[23]{0} iota(), iota_dimension=0 + broadcast.12 = s32[23,23]{1,0} broadcast(iota.11), dimensions={1} + compare.13 = pred[23,23]{1,0} compare(add.10, broadcast.12), direction=GE + broadcast.14 = pred[2,23,23]{2,1,0} broadcast(compare.13), dimensions={1,2} + constant.4 = f32[] constant(0) + broadcast.5 = f32[2,23,23]{2,1,0} broadcast(constant.4), dimensions={} + Arg_0.3 = f32[2,23,23]{2,1,0} parameter(0) + ROOT select.15 = f32[2,23,23]{2,1,0} select(broadcast.14, broadcast.5, Arg_0.3) +} + +xla_fallback_qr.16 { + Arg_0.17 = f32[2,256,23]{2,1,0} parameter(0) + custom-call.24 = (f32[2,256,23]{1,2,0}, f32[2,23]{1,0}, s32[2]{0}, f32[196608]{0}) custom-call(Arg_0.17), custom_call_target="cusolver_geqrf", operand_layout_constraints={f32[2,256,23]{1,2,0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\000\000\000\000\002\000\000\000\000\001\000\000\027\000\000\000\000\000\003\000" + get-tuple-element.25 = s32[2]{0} get-tuple-element(custom-call.24), index=2 + constant.22 = s32[] constant(0) + broadcast.23 = s32[2]{0} broadcast(constant.22), dimensions={} + compare.26 = pred[2]{0} compare(get-tuple-element.25, broadcast.23), direction=EQ + get-tuple-element.27 = f32[2,256,23]{1,2,0} get-tuple-element(custom-call.24), index=0 + get-tuple-element.28 = f32[2,23]{1,0} get-tuple-element(custom-call.24), index=1 + custom-call.29 = (f32[2,256,23]{1,2,0}, s32[2]{0}, f32[38912]{0}) custom-call(get-tuple-element.27, get-tuple-element.28), custom_call_target="cusolver_orgqr", operand_layout_constraints={f32[2,256,23]{1,2,0}, f32[2,23]{1,0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\000\000\000\000\002\000\000\000\000\001\000\000\027\000\000\000\027\000\000\000\000\230\000\000" + get-tuple-element.30 = s32[2]{0} get-tuple-element(custom-call.29), index=1 + compare.31 = pred[2]{0} compare(get-tuple-element.30, broadcast.23), direction=EQ + and.32 = pred[2]{0} and(compare.26, compare.31) + broadcast.33 = pred[2,256,23]{2,1,0} broadcast(and.32), dimensions={0} + get-tuple-element.34 = f32[2,256,23]{1,2,0} get-tuple-element(custom-call.29), index=0 + constant.20 = f32[] constant(nan) + broadcast.21 = f32[2,256,23]{2,1,0} broadcast(constant.20), dimensions={} + select.35 = f32[2,256,23]{2,1,0} select(broadcast.33, get-tuple-element.34, broadcast.21) + broadcast.36 = pred[2,23,23]{2,1,0} broadcast(and.32), dimensions={0} + slice.37 = f32[2,23,23]{2,1,0} slice(get-tuple-element.27), slice={[0:2], [0:23], [0:23]} + constant.18 = f32[] constant(nan) + broadcast.19 = f32[2,23,23]{2,1,0} broadcast(constant.18), dimensions={} + select.38 = f32[2,23,23]{2,1,0} select(broadcast.36, slice.37, broadcast.19) + call.39 = f32[2,23,23]{2,1,0} call(select.38), to_apply=jit_triu__3.37.2 + ROOT tuple.40 = (f32[2,256,23]{2,1,0}, f32[2,23,23]{2,1,0}) tuple(select.35, call.39) +} + +qr.41 { + Arg_0.42 = f32[2,256,23]{2,1,0} parameter(0) + call.43 = (f32[2,256,23]{2,1,0}, f32[2,23,23]{2,1,0}) call(Arg_0.42), to_apply=xla_fallback_qr.16 + get-tuple-element.44 = f32[2,256,23]{2,1,0} get-tuple-element(call.43), index=0 + get-tuple-element.45 = f32[2,23,23]{2,1,0} get-tuple-element(call.43), index=1 + ROOT tuple.46 = (f32[2,256,23]{2,1,0}, f32[2,23,23]{2,1,0}) tuple(get-tuple-element.44, get-tuple-element.45) +} + +ENTRY main.51 { + Arg_0.1 = f32[2,256,23]{2,1,0} parameter(0) + call.47 = (f32[2,256,23]{2,1,0}, f32[2,23,23]{2,1,0}) call(Arg_0.1), to_apply=qr.41 + get-tuple-element.48 = f32[2,256,23]{2,1,0} get-tuple-element(call.47), index=0 + get-tuple-element.49 = f32[2,23,23]{2,1,0} get-tuple-element(call.47), index=1 + ROOT tuple.50 = (f32[2,256,23]{2,1,0}, f32[2,23,23]{2,1,0}) tuple(get-tuple-element.48, get-tuple-element.49) +} + diff --git a/tests/hlo_texts/test_hlos/jaxrl/module_0145.jit__diag.54.before_optimizations.txt b/tests/hlo_texts/test_hlos/jaxrl/module_0145.jit__diag.54.before_optimizations.txt new file mode 100644 index 0000000..fdcc7b2 --- /dev/null +++ b/tests/hlo_texts/test_hlos/jaxrl/module_0145.jit__diag.54.before_optimizations.txt @@ -0,0 +1,36 @@ +HloModule jit__diag.54 + +jit_vmap__where_.2 { + Arg_0.3 = pred[23,23]{1,0} parameter(0) + broadcast.6 = pred[2,23,23]{2,1,0} broadcast(Arg_0.3), dimensions={1,2} + Arg_1.4 = f32[2,23,23]{2,1,0} parameter(1) + Arg_2.5 = f32[23,23]{1,0} parameter(2) + broadcast.7 = f32[2,23,23]{2,1,0} broadcast(Arg_2.5), dimensions={1,2} + ROOT select.8 = f32[2,23,23]{2,1,0} select(broadcast.6, Arg_1.4, broadcast.7) +} + +region_0.9 { + Arg_0.10 = f32[] parameter(0) + Arg_1.11 = f32[] parameter(1) + ROOT add.12 = f32[] add(Arg_0.10, Arg_1.11) +} + +jit_vmap_diagonal_.13 { + iota.18 = s32[23]{0} iota(), iota_dimension=0 + broadcast.19 = s32[23,23]{1,0} broadcast(iota.18), dimensions={0} + iota.20 = s32[23]{0} iota(), iota_dimension=0 + broadcast.21 = s32[23,23]{1,0} broadcast(iota.20), dimensions={1} + compare.22 = pred[23,23]{1,0} compare(broadcast.19, broadcast.21), direction=EQ + Arg_0.14 = f32[2,23,23]{2,1,0} parameter(0) + constant.16 = f32[] constant(0) + broadcast.17 = f32[23,23]{1,0} broadcast(constant.16), dimensions={} + call.23 = f32[2,23,23]{2,1,0} call(compare.22, Arg_0.14, broadcast.17), to_apply=jit_vmap__where_.2 + constant.15 = f32[] constant(0) + ROOT reduce.24 = f32[2,23]{1,0} reduce(call.23, constant.15), dimensions={2}, to_apply=region_0.9 +} + +ENTRY main.26 { + Arg_0.1 = f32[2,23,23]{2,1,0} parameter(0) + ROOT call.25 = f32[2,23]{1,0} call(Arg_0.1), to_apply=jit_vmap_diagonal_.13 +} + diff --git a/tests/hlo_texts/test_hlos/jaxrl/module_0183.jit_fn.71.before_optimizations.txt b/tests/hlo_texts/test_hlos/jaxrl/module_0183.jit_fn.71.before_optimizations.txt new file mode 100644 index 0000000..eae055c --- /dev/null +++ b/tests/hlo_texts/test_hlos/jaxrl/module_0183.jit_fn.71.before_optimizations.txt @@ -0,0 +1,12 @@ +HloModule jit_fn.71 + +ENTRY main.8 { + Arg_0.1 = f32[2,1,256]{2,1,0} parameter(0) + Arg_1.2 = f32[1,256]{1,0} parameter(1) + reshape.3 = f32[1,1,256]{2,1,0} reshape(Arg_1.2) + broadcast.4 = f32[1,1,256]{2,1,0} broadcast(reshape.3), dimensions={0,1,2} + reshape.5 = f32[1,256]{1,0} reshape(broadcast.4) + broadcast.6 = f32[2,1,256]{2,1,0} broadcast(reshape.5), dimensions={1,2} + ROOT add.7 = f32[2,1,256]{2,1,0} add(Arg_0.1, broadcast.6) +} + diff --git a/tests/hlo_texts/test_hlos/jraph/module_0047.jit__truncated_normal.20.before_optimizations.txt b/tests/hlo_texts/test_hlos/jraph/module_0047.jit__truncated_normal.20.before_optimizations.txt new file mode 100644 index 0000000..3752509 --- /dev/null +++ b/tests/hlo_texts/test_hlos/jraph/module_0047.jit__truncated_normal.20.before_optimizations.txt @@ -0,0 +1,319 @@ +HloModule jit__truncated_normal.20 + +xla_fallback_erf.24 { + constant.40 = f32[] constant(-4) + Arg_0.25 = f32[] parameter(0) + constant.39 = f32[] constant(4) + clamp.41 = f32[] clamp(constant.40, Arg_0.25, constant.39) + multiply.42 = f32[] multiply(clamp.41, clamp.41) + constant.31 = f32[] constant(0) + multiply.43 = f32[] multiply(multiply.42, constant.31) + constant.38 = f32[] constant(-2.72614237e-10) + add.44 = f32[] add(multiply.43, constant.38) + multiply.45 = f32[] multiply(add.44, multiply.42) + constant.37 = f32[] constant(2.77068146e-08) + add.46 = f32[] add(multiply.45, constant.37) + multiply.47 = f32[] multiply(add.46, multiply.42) + constant.36 = f32[] constant(-2.10102394e-06) + add.48 = f32[] add(multiply.47, constant.36) + multiply.49 = f32[] multiply(add.48, multiply.42) + constant.35 = f32[] constant(-5.69250624e-05) + add.50 = f32[] add(multiply.49, constant.35) + multiply.51 = f32[] multiply(add.50, multiply.42) + constant.34 = f32[] constant(-0.000734990637) + add.52 = f32[] add(multiply.51, constant.34) + multiply.53 = f32[] multiply(add.52, multiply.42) + constant.33 = f32[] constant(-0.0029546) + add.54 = f32[] add(multiply.53, constant.33) + multiply.55 = f32[] multiply(add.54, multiply.42) + constant.32 = f32[] constant(-0.0160960332) + add.56 = f32[] add(multiply.55, constant.32) + multiply.57 = f32[] multiply(clamp.41, add.56) + multiply.58 = f32[] multiply(multiply.42, constant.31) + constant.30 = f32[] constant(-1.45660715e-05) + add.59 = f32[] add(multiply.58, constant.30) + multiply.60 = f32[] multiply(add.59, multiply.42) + constant.29 = f32[] constant(-0.000213374049) + add.61 = f32[] add(multiply.60, constant.29) + multiply.62 = f32[] multiply(add.61, multiply.42) + constant.28 = f32[] constant(-0.00168282702) + add.63 = f32[] add(multiply.62, constant.28) + multiply.64 = f32[] multiply(add.63, multiply.42) + constant.27 = f32[] constant(-0.00737332925) + add.65 = f32[] add(multiply.64, constant.27) + multiply.66 = f32[] multiply(add.65, multiply.42) + constant.26 = f32[] constant(-0.0142647391) + add.67 = f32[] add(multiply.66, constant.26) + ROOT divide.68 = f32[] divide(multiply.57, add.67) +} + +erf.69 { + Arg_0.70 = f32[] parameter(0) + ROOT call.71 = f32[] call(Arg_0.70), to_apply=xla_fallback_erf.24 +} + +xla_fallback_erf.74 { + constant.90 = f32[] constant(-4) + Arg_0.75 = f32[] parameter(0) + constant.89 = f32[] constant(4) + clamp.91 = f32[] clamp(constant.90, Arg_0.75, constant.89) + multiply.92 = f32[] multiply(clamp.91, clamp.91) + constant.81 = f32[] constant(0) + multiply.93 = f32[] multiply(multiply.92, constant.81) + constant.88 = f32[] constant(-2.72614237e-10) + add.94 = f32[] add(multiply.93, constant.88) + multiply.95 = f32[] multiply(add.94, multiply.92) + constant.87 = f32[] constant(2.77068146e-08) + add.96 = f32[] add(multiply.95, constant.87) + multiply.97 = f32[] multiply(add.96, multiply.92) + constant.86 = f32[] constant(-2.10102394e-06) + add.98 = f32[] add(multiply.97, constant.86) + multiply.99 = f32[] multiply(add.98, multiply.92) + constant.85 = f32[] constant(-5.69250624e-05) + add.100 = f32[] add(multiply.99, constant.85) + multiply.101 = f32[] multiply(add.100, multiply.92) + constant.84 = f32[] constant(-0.000734990637) + add.102 = f32[] add(multiply.101, constant.84) + multiply.103 = f32[] multiply(add.102, multiply.92) + constant.83 = f32[] constant(-0.0029546) + add.104 = f32[] add(multiply.103, constant.83) + multiply.105 = f32[] multiply(add.104, multiply.92) + constant.82 = f32[] constant(-0.0160960332) + add.106 = f32[] add(multiply.105, constant.82) + multiply.107 = f32[] multiply(clamp.91, add.106) + multiply.108 = f32[] multiply(multiply.92, constant.81) + constant.80 = f32[] constant(-1.45660715e-05) + add.109 = f32[] add(multiply.108, constant.80) + multiply.110 = f32[] multiply(add.109, multiply.92) + constant.79 = f32[] constant(-0.000213374049) + add.111 = f32[] add(multiply.110, constant.79) + multiply.112 = f32[] multiply(add.111, multiply.92) + constant.78 = f32[] constant(-0.00168282702) + add.113 = f32[] add(multiply.112, constant.78) + multiply.114 = f32[] multiply(add.113, multiply.92) + constant.77 = f32[] constant(-0.00737332925) + add.115 = f32[] add(multiply.114, constant.77) + multiply.116 = f32[] multiply(add.115, multiply.92) + constant.76 = f32[] constant(-0.0142647391) + add.117 = f32[] add(multiply.116, constant.76) + ROOT divide.118 = f32[] divide(multiply.107, add.117) +} + +erf.119 { + Arg_0.120 = f32[] parameter(0) + ROOT call.121 = f32[] call(Arg_0.120), to_apply=xla_fallback_erf.74 +} + +xla_fallback_erf_inv.156 { + Arg_0.157 = f32[1,128]{1,0} parameter(0) + abs.204 = f32[1,128]{1,0} abs(Arg_0.157) + constant.202 = f32[] constant(1) + broadcast.203 = f32[1,128]{1,0} broadcast(constant.202), dimensions={} + compare.205 = pred[1,128]{1,0} compare(abs.204, broadcast.203), direction=EQ + constant.200 = f32[] constant(inf) + broadcast.201 = f32[1,128]{1,0} broadcast(constant.200), dimensions={} + multiply.206 = f32[1,128]{1,0} multiply(Arg_0.157, broadcast.201) + negate.207 = f32[1,128]{1,0} negate(Arg_0.157) + multiply.208 = f32[1,128]{1,0} multiply(negate.207, Arg_0.157) + log-plus-one.209 = f32[1,128]{1,0} log-plus-one(multiply.208) + negate.210 = f32[1,128]{1,0} negate(log-plus-one.209) + constant.198 = f32[] constant(5) + broadcast.199 = f32[1,128]{1,0} broadcast(constant.198), dimensions={} + compare.211 = pred[1,128]{1,0} compare(negate.210, broadcast.199), direction=LT + constant.196 = f32[] constant(1.50140941) + broadcast.197 = f32[1,128]{1,0} broadcast(constant.196), dimensions={} + constant.194 = f32[] constant(2.83297682) + broadcast.195 = f32[1,128]{1,0} broadcast(constant.194), dimensions={} + select.212 = f32[1,128]{1,0} select(compare.211, broadcast.197, broadcast.195) + constant.192 = f32[] constant(0.246640727) + broadcast.193 = f32[1,128]{1,0} broadcast(constant.192), dimensions={} + constant.190 = f32[] constant(1.00167406) + broadcast.191 = f32[1,128]{1,0} broadcast(constant.190), dimensions={} + select.213 = f32[1,128]{1,0} select(compare.211, broadcast.193, broadcast.191) + constant.188 = f32[] constant(-0.00417768164) + broadcast.189 = f32[1,128]{1,0} broadcast(constant.188), dimensions={} + constant.186 = f32[] constant(0.00943887047) + broadcast.187 = f32[1,128]{1,0} broadcast(constant.186), dimensions={} + select.214 = f32[1,128]{1,0} select(compare.211, broadcast.189, broadcast.187) + constant.184 = f32[] constant(-0.00125372503) + broadcast.185 = f32[1,128]{1,0} broadcast(constant.184), dimensions={} + constant.182 = f32[] constant(-0.0076224613) + broadcast.183 = f32[1,128]{1,0} broadcast(constant.182), dimensions={} + select.215 = f32[1,128]{1,0} select(compare.211, broadcast.185, broadcast.183) + constant.180 = f32[] constant(0.00021858087) + broadcast.181 = f32[1,128]{1,0} broadcast(constant.180), dimensions={} + constant.178 = f32[] constant(0.00573950773) + broadcast.179 = f32[1,128]{1,0} broadcast(constant.178), dimensions={} + select.216 = f32[1,128]{1,0} select(compare.211, broadcast.181, broadcast.179) + constant.176 = f32[] constant(-4.39150654e-06) + broadcast.177 = f32[1,128]{1,0} broadcast(constant.176), dimensions={} + constant.174 = f32[] constant(-0.00367342844) + broadcast.175 = f32[1,128]{1,0} broadcast(constant.174), dimensions={} + select.217 = f32[1,128]{1,0} select(compare.211, broadcast.177, broadcast.175) + constant.172 = f32[] constant(-3.5233877e-06) + broadcast.173 = f32[1,128]{1,0} broadcast(constant.172), dimensions={} + constant.170 = f32[] constant(0.00134934322) + broadcast.171 = f32[1,128]{1,0} broadcast(constant.170), dimensions={} + select.218 = f32[1,128]{1,0} select(compare.211, broadcast.173, broadcast.171) + constant.168 = f32[] constant(3.43273939e-07) + broadcast.169 = f32[1,128]{1,0} broadcast(constant.168), dimensions={} + constant.166 = f32[] constant(0.000100950558) + broadcast.167 = f32[1,128]{1,0} broadcast(constant.166), dimensions={} + select.219 = f32[1,128]{1,0} select(compare.211, broadcast.169, broadcast.167) + constant.164 = f32[] constant(2.81022636e-08) + broadcast.165 = f32[1,128]{1,0} broadcast(constant.164), dimensions={} + constant.162 = f32[] constant(-0.000200214257) + broadcast.163 = f32[1,128]{1,0} broadcast(constant.162), dimensions={} + select.220 = f32[1,128]{1,0} select(compare.211, broadcast.165, broadcast.163) + constant.160 = f32[] constant(2.5) + broadcast.161 = f32[1,128]{1,0} broadcast(constant.160), dimensions={} + subtract.221 = f32[1,128]{1,0} subtract(negate.210, broadcast.161) + sqrt.222 = f32[1,128]{1,0} sqrt(negate.210) + constant.158 = f32[] constant(3) + broadcast.159 = f32[1,128]{1,0} broadcast(constant.158), dimensions={} + subtract.223 = f32[1,128]{1,0} subtract(sqrt.222, broadcast.159) + select.224 = f32[1,128]{1,0} select(compare.211, subtract.221, subtract.223) + multiply.225 = f32[1,128]{1,0} multiply(select.220, select.224) + add.226 = f32[1,128]{1,0} add(select.219, multiply.225) + multiply.227 = f32[1,128]{1,0} multiply(add.226, select.224) + add.228 = f32[1,128]{1,0} add(select.218, multiply.227) + multiply.229 = f32[1,128]{1,0} multiply(add.228, select.224) + add.230 = f32[1,128]{1,0} add(select.217, multiply.229) + multiply.231 = f32[1,128]{1,0} multiply(add.230, select.224) + add.232 = f32[1,128]{1,0} add(select.216, multiply.231) + multiply.233 = f32[1,128]{1,0} multiply(add.232, select.224) + add.234 = f32[1,128]{1,0} add(select.215, multiply.233) + multiply.235 = f32[1,128]{1,0} multiply(add.234, select.224) + add.236 = f32[1,128]{1,0} add(select.214, multiply.235) + multiply.237 = f32[1,128]{1,0} multiply(add.236, select.224) + add.238 = f32[1,128]{1,0} add(select.213, multiply.237) + multiply.239 = f32[1,128]{1,0} multiply(add.238, select.224) + add.240 = f32[1,128]{1,0} add(select.212, multiply.239) + multiply.241 = f32[1,128]{1,0} multiply(add.240, Arg_0.157) + ROOT select.242 = f32[1,128]{1,0} select(compare.205, multiply.206, multiply.241) +} + +erf_inv.243 { + Arg_0.244 = f32[1,128]{1,0} parameter(0) + ROOT call.245 = f32[1,128]{1,0} call(Arg_0.244), to_apply=xla_fallback_erf_inv.156 +} + +jit_clip.292 { + Arg_2.295 = f32[] parameter(2) + broadcast.298 = f32[1,128]{1,0} broadcast(Arg_2.295), dimensions={} + Arg_1.294 = f32[] parameter(1) + broadcast.296 = f32[1,128]{1,0} broadcast(Arg_1.294), dimensions={} + Arg_0.293 = f32[1,128]{1,0} parameter(0) + maximum.297 = f32[1,128]{1,0} maximum(broadcast.296, Arg_0.293) + ROOT minimum.299 = f32[1,128]{1,0} minimum(broadcast.298, maximum.297) +} + +ENTRY main.301 { + Arg_1.2 = s32[] parameter(1) + convert.21 = f32[] convert(Arg_1.2) + constant.14 = f32[] constant(1.41421354) + divide.23 = f32[] divide(convert.21, constant.14) + call.72 = f32[] call(divide.23), to_apply=erf.69 + reshape.123 = f32[1,1]{1,0} reshape(call.72) + broadcast.152 = f32[1,1]{1,0} broadcast(reshape.123), dimensions={0,1} + reshape.153 = f32[1]{0} reshape(broadcast.152) + broadcast.154 = f32[1,128]{1,0} broadcast(reshape.153), dimensions={0} + Arg_0.1 = u32[2]{0} parameter(0) + slice.126 = u32[1]{0} slice(Arg_0.1), slice={[0:1]} + reshape.127 = u32[] reshape(slice.126) + broadcast.132 = u32[64]{0} broadcast(reshape.127), dimensions={} + slice.128 = u32[1]{0} slice(Arg_0.1), slice={[1:2]} + reshape.129 = u32[] reshape(slice.128) + broadcast.133 = u32[64]{0} broadcast(reshape.129), dimensions={} + iota.125 = u32[128]{0} iota(), iota_dimension=0 + slice.130 = u32[64]{0} slice(iota.125), slice={[0:64]} + slice.131 = u32[64]{0} slice(iota.125), slice={[64:128]} + custom-call.134 = (u32[64]{0}, u32[64]{0}) custom-call(broadcast.132, broadcast.133, slice.130, slice.131), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[64]{0}, u32[64]{0}, u32[64]{0}, u32[64]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="@\000\000\000\000\000\000\000" + get-tuple-element.135 = u32[64]{0} get-tuple-element(custom-call.134), index=0 + get-tuple-element.136 = u32[64]{0} get-tuple-element(custom-call.134), index=1 + concatenate.137 = u32[128]{0} concatenate(get-tuple-element.135, get-tuple-element.136), dimensions={0} + reshape.138 = u32[1,128]{1,0} reshape(concatenate.137) + constant.19 = u32[] constant(9) + broadcast.20 = u32[1,128]{1,0} broadcast(constant.19), dimensions={} + shift-right-logical.139 = u32[1,128]{1,0} shift-right-logical(reshape.138, broadcast.20) + constant.17 = u32[] constant(1065353216) + broadcast.18 = u32[1,128]{1,0} broadcast(constant.17), dimensions={} + or.140 = u32[1,128]{1,0} or(shift-right-logical.139, broadcast.18) + bitcast-convert.141 = f32[1,128]{1,0} bitcast-convert(or.140) + constant.15 = f32[] constant(1) + broadcast.16 = f32[1,128]{1,0} broadcast(constant.15), dimensions={} + subtract.142 = f32[1,128]{1,0} subtract(bitcast-convert.141, broadcast.16) + Arg_2.3 = s32[] parameter(2) + convert.22 = f32[] convert(Arg_2.3) + divide.73 = f32[] divide(convert.22, constant.14) + call.122 = f32[] call(divide.73), to_apply=erf.119 + reshape.124 = f32[1,1]{1,0} reshape(call.122) + subtract.143 = f32[1,1]{1,0} subtract(reshape.124, reshape.123) + broadcast.144 = f32[1,1]{1,0} broadcast(subtract.143), dimensions={0,1} + reshape.145 = f32[1]{0} reshape(broadcast.144) + broadcast.146 = f32[1,128]{1,0} broadcast(reshape.145), dimensions={0} + multiply.147 = f32[1,128]{1,0} multiply(subtract.142, broadcast.146) + broadcast.148 = f32[1,1]{1,0} broadcast(reshape.123), dimensions={0,1} + reshape.149 = f32[1]{0} reshape(broadcast.148) + broadcast.150 = f32[1,128]{1,0} broadcast(reshape.149), dimensions={0} + add.151 = f32[1,128]{1,0} add(multiply.147, broadcast.150) + maximum.155 = f32[1,128]{1,0} maximum(broadcast.154, add.151) + call.246 = f32[1,128]{1,0} call(maximum.155), to_apply=erf_inv.243 + constant.12 = f32[] constant(1.41421354) + broadcast.13 = f32[1,128]{1,0} broadcast(constant.12), dimensions={} + multiply.247 = f32[1,128]{1,0} multiply(call.246, broadcast.13) + compare.250 = pred[] compare(convert.21, convert.21), direction=NE + constant.9 = f32[] constant(nan) + bitcast-convert.251 = s32[] bitcast-convert(constant.9) + constant.11 = f32[] constant(inf) + compare.254 = pred[] compare(convert.21, constant.11), direction=EQ + bitcast-convert.249 = s32[] bitcast-convert(constant.11) + bitcast-convert.248 = s32[] bitcast-convert(convert.21) + constant.7 = s32[] constant(2147483647) + and.252 = s32[] and(bitcast-convert.248, constant.7) + constant.6 = s32[] constant(0) + compare.255 = pred[] compare(and.252, constant.6), direction=EQ + and.253 = s32[] and(bitcast-convert.249, constant.7) + compare.256 = pred[] compare(and.253, constant.6), direction=EQ + constant.8 = s32[] constant(-2147483648) + and.258 = s32[] and(bitcast-convert.249, constant.8) + constant.5 = s32[] constant(1) + or.259 = s32[] or(and.258, constant.5) + select.265 = s32[] select(compare.256, bitcast-convert.249, or.259) + compare.261 = pred[] compare(and.252, and.253), direction=GT + and.257 = s32[] and(bitcast-convert.248, constant.8) + compare.260 = pred[] compare(and.257, and.258), direction=NE + or.262 = pred[] or(compare.261, compare.260) + constant.4 = s32[] constant(-1) + select.263 = s32[] select(or.262, constant.4, constant.5) + add.264 = s32[] add(bitcast-convert.248, select.263) + select.266 = s32[] select(compare.255, select.265, add.264) + select.267 = s32[] select(compare.254, bitcast-convert.249, select.266) + select.268 = s32[] select(compare.250, bitcast-convert.251, select.267) + bitcast-convert.269 = f32[] bitcast-convert(select.268) + compare.272 = pred[] compare(convert.22, convert.22), direction=NE + bitcast-convert.273 = s32[] bitcast-convert(constant.9) + constant.10 = f32[] constant(-inf) + compare.276 = pred[] compare(convert.22, constant.10), direction=EQ + bitcast-convert.271 = s32[] bitcast-convert(constant.10) + bitcast-convert.270 = s32[] bitcast-convert(convert.22) + and.274 = s32[] and(bitcast-convert.270, constant.7) + compare.277 = pred[] compare(and.274, constant.6), direction=EQ + and.275 = s32[] and(bitcast-convert.271, constant.7) + compare.278 = pred[] compare(and.275, constant.6), direction=EQ + and.280 = s32[] and(bitcast-convert.271, constant.8) + or.281 = s32[] or(and.280, constant.5) + select.287 = s32[] select(compare.278, bitcast-convert.271, or.281) + compare.283 = pred[] compare(and.274, and.275), direction=GT + and.279 = s32[] and(bitcast-convert.270, constant.8) + compare.282 = pred[] compare(and.279, and.280), direction=NE + or.284 = pred[] or(compare.283, compare.282) + select.285 = s32[] select(or.284, constant.4, constant.5) + add.286 = s32[] add(bitcast-convert.270, select.285) + select.288 = s32[] select(compare.277, select.287, add.286) + select.289 = s32[] select(compare.276, bitcast-convert.271, select.288) + select.290 = s32[] select(compare.272, bitcast-convert.273, select.289) + bitcast-convert.291 = f32[] bitcast-convert(select.290) + ROOT call.300 = f32[1,128]{1,0} call(multiply.247, bitcast-convert.269, bitcast-convert.291), to_apply=jit_clip.292 +} + diff --git a/tests/hlo_texts/test_hlos/jraph/module_0101.jit_accuracy.49.before_optimizations.txt b/tests/hlo_texts/test_hlos/jraph/module_0101.jit_accuracy.49.before_optimizations.txt new file mode 100644 index 0000000..4d80384 --- /dev/null +++ b/tests/hlo_texts/test_hlos/jraph/module_0101.jit_accuracy.49.before_optimizations.txt @@ -0,0 +1,167 @@ +HloModule jit_accuracy.49 + +region_0.33 { + Arg_0.34 = s32[] parameter(0) + Arg_1.35 = s32[] parameter(1) + ROOT add.36 = s32[] add(Arg_0.34, Arg_1.35) +} + +region_1.39 { + Arg_0.40 = s32[] parameter(0) + Arg_1.41 = s32[] parameter(1) + ROOT add.42 = s32[] add(Arg_0.40, Arg_1.41) +} + +region_2.58 { + Arg_0.59 = f32[] parameter(0) + Arg_1.60 = f32[] parameter(1) + ROOT add.61 = f32[] add(Arg_0.59, Arg_1.60) +} + +jit_relu.71 { + Arg_0.72 = f32[34,5]{1,0} parameter(0) + constant.73 = f32[] constant(0) + broadcast.74 = f32[34,5]{1,0} broadcast(constant.73), dimensions={} + ROOT maximum.75 = f32[34,5]{1,0} maximum(Arg_0.72, broadcast.74) +} + +region_3.78 { + Arg_0.79 = s32[] parameter(0) + Arg_1.80 = s32[] parameter(1) + ROOT add.81 = s32[] add(Arg_0.79, Arg_1.80) +} + +region_4.83 { + Arg_0.84 = s32[] parameter(0) + Arg_1.85 = s32[] parameter(1) + ROOT add.86 = s32[] add(Arg_0.84, Arg_1.85) +} + +region_5.97 { + Arg_0.98 = f32[] parameter(0) + Arg_1.99 = f32[] parameter(1) + ROOT add.100 = f32[] add(Arg_0.98, Arg_1.99) +} + +region_6.110 { + Arg_0.111 = f32[] parameter(0) + Arg_2.113 = f32[] parameter(2) + compare.115 = pred[] compare(Arg_0.111, Arg_2.113), direction=GT + compare.116 = pred[] compare(Arg_0.111, Arg_0.111), direction=NE + or.117 = pred[] or(compare.115, compare.116) + select.122 = f32[] select(or.117, Arg_0.111, Arg_2.113) + compare.118 = pred[] compare(Arg_0.111, Arg_2.113), direction=EQ + Arg_1.112 = s32[] parameter(1) + Arg_3.114 = s32[] parameter(3) + compare.119 = pred[] compare(Arg_1.112, Arg_3.114), direction=LT + and.120 = pred[] and(compare.118, compare.119) + or.121 = pred[] or(or.117, and.120) + select.123 = s32[] select(or.121, Arg_1.112, Arg_3.114) + ROOT tuple.124 = (f32[], s32[]) tuple(select.122, select.123) +} + +argmax.125 { + Arg_0.126 = f32[34,2]{1,0} parameter(0) + iota.129 = s32[2]{0} iota(), iota_dimension=0 + broadcast.130 = s32[34,2]{1,0} broadcast(iota.129), dimensions={1} + constant.128 = f32[] constant(-inf) + constant.127 = s32[] constant(0) + reduce.131 = (f32[34]{0}, s32[34]{0}) reduce(Arg_0.126, broadcast.130, constant.128, constant.127), dimensions={1}, to_apply=region_6.110 + get-tuple-element.132 = f32[34]{0} get-tuple-element(reduce.131), index=0 + ROOT get-tuple-element.133 = s32[34]{0} get-tuple-element(reduce.131), index=1 +} + +region_7.137 { + Arg_0.138 = f32[] parameter(0) + Arg_1.139 = f32[] parameter(1) + ROOT add.140 = f32[] add(Arg_0.138, Arg_1.139) +} + +ENTRY main.143 { + constant.8 = f32[] constant(0) + broadcast.9 = f32[34,2]{1,0} broadcast(constant.8), dimensions={} + constant.7 = s32[156,1]{1,0} constant({...}) + constant.15 = f32[] constant(0) + broadcast.16 = f32[34,5]{1,0} broadcast(constant.15), dimensions={} + constant.25 = s32[156]{0} constant({...}) + iota.28 = s32[34]{0} iota(), iota_dimension=0 + concatenate.29 = s32[190]{0} concatenate(constant.25, iota.28), dimensions={0} + reshape.57 = s32[190,1]{1,0} reshape(concatenate.29) + constant.26 = f32[34,34]{1,0} constant({...}) + Arg_0.1 = f32[34,5]{1,0} parameter(0) + dot.27 = f32[34,5]{1,0} dot(constant.26, Arg_0.1), lhs_contracting_dims={1}, rhs_contracting_dims={0} + constant.11 = s32[] constant(0) + broadcast.12 = s32[34]{0} broadcast(constant.11), dimensions={} + constant.24 = s32[156]{0} constant({...}) + iota.30 = s32[34]{0} iota(), iota_dimension=0 + concatenate.31 = s32[190]{0} concatenate(constant.24, iota.30), dimensions={0} + reshape.32 = s32[190,1]{1,0} reshape(concatenate.31) + constant.21 = s32[] constant(1) + broadcast.22 = s32[190]{0} broadcast(constant.21), dimensions={} + scatter.37 = s32[34]{0} scatter(broadcast.12, reshape.32, broadcast.22), update_window_dims={}, inserted_window_dims={0}, scatter_dims_to_operand_dims={0}, index_vector_dim=1, to_apply=region_0.33 + convert.44 = f32[34]{0} convert(scatter.37) + constant.5 = f32[] constant(1) + broadcast.6 = f32[34]{0} broadcast(constant.5), dimensions={} + maximum.45 = f32[34]{0} maximum(convert.44, broadcast.6) + rsqrt.46 = f32[34]{0} rsqrt(maximum.45) + reshape.47 = f32[34,1]{1,0} reshape(rsqrt.46) + broadcast.48 = f32[34,1]{1,0} broadcast(reshape.47), dimensions={0,1} + reshape.49 = f32[34]{0} reshape(broadcast.48) + broadcast.50 = f32[34,5]{1,0} broadcast(reshape.49), dimensions={0} + multiply.51 = f32[34,5]{1,0} multiply(dot.27, broadcast.50) + constant.19 = s32[] constant(0) + broadcast.20 = s32[190]{0} broadcast(constant.19), dimensions={} + compare.52 = pred[190]{0} compare(concatenate.31, broadcast.20), direction=LT + constant.17 = s32[] constant(34) + broadcast.18 = s32[190]{0} broadcast(constant.17), dimensions={} + add.53 = s32[190]{0} add(concatenate.31, broadcast.18) + select.54 = s32[190]{0} select(compare.52, add.53, concatenate.31) + reshape.55 = s32[190,1]{1,0} reshape(select.54) + gather.56 = f32[190,5]{1,0} gather(multiply.51, reshape.55), offset_dims={1}, collapsed_slice_dims={0}, start_index_map={0}, index_vector_dim=1, slice_sizes={1,5} + scatter.62 = f32[34,5]{1,0} scatter(broadcast.16, reshape.57, gather.56), update_window_dims={1}, inserted_window_dims={0}, scatter_dims_to_operand_dims={0}, index_vector_dim=1, to_apply=region_2.58 + reshape.38 = s32[190,1]{1,0} reshape(concatenate.29) + scatter.43 = s32[34]{0} scatter(broadcast.12, reshape.38, broadcast.22), update_window_dims={}, inserted_window_dims={0}, scatter_dims_to_operand_dims={0}, index_vector_dim=1, to_apply=region_1.39 + convert.63 = f32[34]{0} convert(scatter.43) + maximum.64 = f32[34]{0} maximum(convert.63, broadcast.6) + rsqrt.65 = f32[34]{0} rsqrt(maximum.64) + reshape.66 = f32[34,1]{1,0} reshape(rsqrt.65) + broadcast.67 = f32[34,1]{1,0} broadcast(reshape.66), dimensions={0,1} + reshape.68 = f32[34]{0} reshape(broadcast.67) + broadcast.69 = f32[34,5]{1,0} broadcast(reshape.68), dimensions={0} + multiply.70 = f32[34,5]{1,0} multiply(scatter.62, broadcast.69) + call.76 = f32[34,5]{1,0} call(multiply.70), to_apply=jit_relu.71 + Arg_1.2 = f32[5,2]{1,0} parameter(1) + dot.77 = f32[34,2]{1,0} dot(call.76, Arg_1.2), lhs_contracting_dims={1}, rhs_contracting_dims={0} + constant.10 = s32[156,1]{1,0} constant({...}) + constant.13 = s32[] constant(1) + broadcast.14 = s32[156]{0} broadcast(constant.13), dimensions={} + scatter.82 = s32[34]{0} scatter(broadcast.12, constant.10, broadcast.14), update_window_dims={}, inserted_window_dims={0}, scatter_dims_to_operand_dims={0}, index_vector_dim=1, to_apply=region_3.78 + convert.88 = f32[34]{0} convert(scatter.82) + maximum.89 = f32[34]{0} maximum(convert.88, broadcast.6) + rsqrt.90 = f32[34]{0} rsqrt(maximum.89) + reshape.91 = f32[34,1]{1,0} reshape(rsqrt.90) + broadcast.92 = f32[34,1]{1,0} broadcast(reshape.91), dimensions={0,1} + reshape.93 = f32[34]{0} reshape(broadcast.92) + broadcast.94 = f32[34,2]{1,0} broadcast(reshape.93), dimensions={0} + multiply.95 = f32[34,2]{1,0} multiply(dot.77, broadcast.94) + gather.96 = f32[156,2]{1,0} gather(multiply.95, constant.10), offset_dims={1}, collapsed_slice_dims={0}, start_index_map={0}, index_vector_dim=1, slice_sizes={1,2} + scatter.101 = f32[34,2]{1,0} scatter(broadcast.9, constant.7, gather.96), update_window_dims={1}, inserted_window_dims={0}, scatter_dims_to_operand_dims={0}, index_vector_dim=1, to_apply=region_5.97 + scatter.87 = s32[34]{0} scatter(broadcast.12, constant.7, broadcast.14), update_window_dims={}, inserted_window_dims={0}, scatter_dims_to_operand_dims={0}, index_vector_dim=1, to_apply=region_4.83 + convert.102 = f32[34]{0} convert(scatter.87) + maximum.103 = f32[34]{0} maximum(convert.102, broadcast.6) + rsqrt.104 = f32[34]{0} rsqrt(maximum.103) + reshape.105 = f32[34,1]{1,0} reshape(rsqrt.104) + broadcast.106 = f32[34,1]{1,0} broadcast(reshape.105), dimensions={0,1} + reshape.107 = f32[34]{0} reshape(broadcast.106) + broadcast.108 = f32[34,2]{1,0} broadcast(reshape.107), dimensions={0} + multiply.109 = f32[34,2]{1,0} multiply(scatter.101, broadcast.108) + call.134 = s32[34]{0} call(multiply.109), to_apply=argmax.125 + constant.23 = s32[34]{0} constant({...}) + compare.135 = pred[34]{0} compare(call.134, constant.23), direction=EQ + convert.136 = f32[34]{0} convert(compare.135) + constant.4 = f32[] constant(0) + reduce.141 = f32[] reduce(convert.136, constant.4), dimensions={0}, to_apply=region_7.137 + constant.3 = f32[] constant(34) + ROOT divide.142 = f32[] divide(reduce.141, constant.3) +} + diff --git a/tests/hlo_texts/test_hlos/jraph/module_0104.jit_prim_fun.56.before_optimizations.txt b/tests/hlo_texts/test_hlos/jraph/module_0104.jit_prim_fun.56.before_optimizations.txt new file mode 100644 index 0000000..c2177ae --- /dev/null +++ b/tests/hlo_texts/test_hlos/jraph/module_0104.jit_prim_fun.56.before_optimizations.txt @@ -0,0 +1,15 @@ +HloModule jit_prim_fun.56 + +region_0.4 { + Arg_0.5 = f32[] parameter(0) + Arg_1.6 = f32[] parameter(1) + ROOT add.7 = f32[] add(Arg_0.5, Arg_1.6) +} + +ENTRY main.9 { + Arg_0.1 = f32[3,5]{1,0} parameter(0) + Arg_1.2 = s32[2,1]{1,0} parameter(1) + Arg_2.3 = f32[2,5]{1,0} parameter(2) + ROOT scatter.8 = f32[3,5]{1,0} scatter(Arg_0.1, Arg_1.2, Arg_2.3), update_window_dims={1}, inserted_window_dims={0}, scatter_dims_to_operand_dims={0}, index_vector_dim=1, to_apply=region_0.4 +} + diff --git a/tests/hlo_texts/test_hlos/jraph/module_0243.jit_prim_fun.115.before_optimizations.txt b/tests/hlo_texts/test_hlos/jraph/module_0243.jit_prim_fun.115.before_optimizations.txt new file mode 100644 index 0000000..a821abc --- /dev/null +++ b/tests/hlo_texts/test_hlos/jraph/module_0243.jit_prim_fun.115.before_optimizations.txt @@ -0,0 +1,7 @@ +HloModule jit_prim_fun.115 + +ENTRY main.3 { + Arg_0.1 = s32[] parameter(0) + ROOT broadcast.2 = s32[2]{0} broadcast(Arg_0.1), dimensions={} +} + diff --git a/tests/hlo_texts/test_hlos/maml_flax/module_0033.jit_fn.13.before_optimizations.txt b/tests/hlo_texts/test_hlos/maml_flax/module_0033.jit_fn.13.before_optimizations.txt new file mode 100644 index 0000000..0515378 --- /dev/null +++ b/tests/hlo_texts/test_hlos/maml_flax/module_0033.jit_fn.13.before_optimizations.txt @@ -0,0 +1,12 @@ +HloModule jit_fn.13 + +ENTRY %main.8 (Arg_0.1: f32[200,32], Arg_1.2: f32[32]) -> f32[200,32] { + %Arg_0.1 = f32[200,32]{1,0} parameter(0) + %Arg_1.2 = f32[32]{0} parameter(1) + %reshape.3 = f32[1,32]{1,0} reshape(f32[32]{0} %Arg_1.2) + %broadcast.4 = f32[1,32]{1,0} broadcast(f32[1,32]{1,0} %reshape.3), dimensions={0,1} + %reshape.5 = f32[32]{0} reshape(f32[1,32]{1,0} %broadcast.4) + %broadcast.6 = f32[200,32]{1,0} broadcast(f32[32]{0} %reshape.5), dimensions={1} + ROOT %add.7 = f32[200,32]{1,0} add(f32[200,32]{1,0} %Arg_0.1, f32[200,32]{1,0} %broadcast.6) +} + diff --git a/tests/hlo_texts/test_hlos/maml_flax/module_0067.jit_train_step.26.before_optimizations.txt b/tests/hlo_texts/test_hlos/maml_flax/module_0067.jit_train_step.26.before_optimizations.txt new file mode 100644 index 0000000..822adbb --- /dev/null +++ b/tests/hlo_texts/test_hlos/maml_flax/module_0067.jit_train_step.26.before_optimizations.txt @@ -0,0 +1,178 @@ +HloModule jit_train_step.26 + +%jit_relu.49 (Arg_0.50: f32[200,32]) -> f32[200,32] { + %Arg_0.50 = f32[200,32]{1,0} parameter(0) + %constant.51 = f32[] constant(0) + %broadcast.52 = f32[200,32]{1,0} broadcast(f32[] %constant.51), dimensions={} + ROOT %maximum.53 = f32[200,32]{1,0} maximum(f32[200,32]{1,0} %Arg_0.50, f32[200,32]{1,0} %broadcast.52) +} + +%jit_relu_0.62 (Arg_0.63: f32[200,32]) -> f32[200,32] { + %Arg_0.63 = f32[200,32]{1,0} parameter(0) + %constant.64 = f32[] constant(0) + %broadcast.65 = f32[200,32]{1,0} broadcast(f32[] %constant.64), dimensions={} + ROOT %maximum.66 = f32[200,32]{1,0} maximum(f32[200,32]{1,0} %Arg_0.63, f32[200,32]{1,0} %broadcast.65) +} + +%region_0.78 (Arg_0.79: f32[], Arg_1.80: f32[]) -> f32[] { + %Arg_0.79 = f32[] parameter(0) + %Arg_1.80 = f32[] parameter(1) + ROOT %add.81 = f32[] add(f32[] %Arg_0.79, f32[] %Arg_1.80) +} + +%region_1.86 (Arg_0.87: f32[], Arg_1.88: f32[]) -> f32[] { + %Arg_0.87 = f32[] parameter(0) + %Arg_1.88 = f32[] parameter(1) + ROOT %add.89 = f32[] add(f32[] %Arg_0.87, f32[] %Arg_1.88) +} + +%region_2.92 (Arg_0.93: f32[], Arg_1.94: f32[]) -> f32[] { + %Arg_0.93 = f32[] parameter(0) + %Arg_1.94 = f32[] parameter(1) + ROOT %add.95 = f32[] add(f32[] %Arg_0.93, f32[] %Arg_1.94) +} + +%region_3.102 (Arg_0.103: f32[], Arg_1.104: f32[]) -> f32[] { + %Arg_0.103 = f32[] parameter(0) + %Arg_1.104 = f32[] parameter(1) + ROOT %add.105 = f32[] add(f32[] %Arg_0.103, f32[] %Arg_1.104) +} + +%region_4.108 (Arg_0.109: f32[], Arg_1.110: f32[]) -> f32[] { + %Arg_0.109 = f32[] parameter(0) + %Arg_1.110 = f32[] parameter(1) + ROOT %add.111 = f32[] add(f32[] %Arg_0.109, f32[] %Arg_1.110) +} + +%region_5.117 (Arg_0.118: f32[], Arg_1.119: f32[]) -> f32[] { + %Arg_0.118 = f32[] parameter(0) + %Arg_1.119 = f32[] parameter(1) + ROOT %add.120 = f32[] add(f32[] %Arg_0.118, f32[] %Arg_1.119) +} + +%region_6.123 (Arg_0.124: f32[], Arg_1.125: f32[]) -> f32[] { + %Arg_0.124 = f32[] parameter(0) + %Arg_1.125 = f32[] parameter(1) + ROOT %add.126 = f32[] add(f32[] %Arg_0.124, f32[] %Arg_1.125) +} + +ENTRY %main.156 (Arg_0.1: s32[], Arg_1.2: f32[32], Arg_2.3: f32[1,32], Arg_3.4: f32[32], Arg_4.5: f32[32,32], Arg_5.6: f32[1], Arg_6.7: f32[32,1], Arg_7.8: f32[32], Arg_8.9: f32[1,32], Arg_9.10: f32[32], Arg_10.11: f32[32,32], Arg_11.12: f32[1], Arg_12.13: f32[32,1], Arg_13.14: f32[200,1], Arg_14.15: f32[200,1]) -> (s32[], f32[32], f32[1,32], f32[32], f32[32,32], /*index=5*/f32[1], f32[32,1], f32[32], f32[1,32], f32[32], /*index=10*/f32[32,32], f32[1], f32[32,1], f32[]) { + %Arg_0.1 = s32[] parameter(0) + %constant.16 = s32[] constant(1) + %add.154 = s32[] add(s32[] %Arg_0.1, s32[] %constant.16) + %Arg_1.2 = f32[32]{0} parameter(1) + %constant.29 = f32[] constant(0.9) + %broadcast.30 = f32[32]{0} broadcast(f32[] %constant.29), dimensions={} + %multiply.130 = f32[32]{0} multiply(f32[32]{0} %Arg_1.2, f32[32]{0} %broadcast.30) + %Arg_13.14 = f32[200,1]{1,0} parameter(13) + %Arg_8.9 = f32[1,32]{1,0} parameter(8) + %dot.43 = f32[200,32]{1,0} dot(f32[200,1]{1,0} %Arg_13.14, f32[1,32]{1,0} %Arg_8.9), lhs_contracting_dims={1}, rhs_contracting_dims={0} + %Arg_7.8 = f32[32]{0} parameter(7) + %reshape.44 = f32[1,32]{1,0} reshape(f32[32]{0} %Arg_7.8) + %broadcast.45 = f32[1,32]{1,0} broadcast(f32[1,32]{1,0} %reshape.44), dimensions={0,1} + %reshape.46 = f32[32]{0} reshape(f32[1,32]{1,0} %broadcast.45) + %broadcast.47 = f32[200,32]{1,0} broadcast(f32[32]{0} %reshape.46), dimensions={1} + %add.48 = f32[200,32]{1,0} add(f32[200,32]{1,0} %dot.43, f32[200,32]{1,0} %broadcast.47) + %constant.36 = f32[] constant(0) + %broadcast.37 = f32[200,32]{1,0} broadcast(f32[] %constant.36), dimensions={} + %compare.55 = pred[200,32]{1,0} compare(f32[200,32]{1,0} %add.48, f32[200,32]{1,0} %broadcast.37), direction=GT + %call.54 = f32[200,32]{1,0} call(f32[200,32]{1,0} %add.48), to_apply=%jit_relu.49 + %Arg_10.11 = f32[32,32]{1,0} parameter(10) + %dot.56 = f32[200,32]{1,0} dot(f32[200,32]{1,0} %call.54, f32[32,32]{1,0} %Arg_10.11), lhs_contracting_dims={1}, rhs_contracting_dims={0} + %Arg_9.10 = f32[32]{0} parameter(9) + %reshape.57 = f32[1,32]{1,0} reshape(f32[32]{0} %Arg_9.10) + %broadcast.58 = f32[1,32]{1,0} broadcast(f32[1,32]{1,0} %reshape.57), dimensions={0,1} + %reshape.59 = f32[32]{0} reshape(f32[1,32]{1,0} %broadcast.58) + %broadcast.60 = f32[200,32]{1,0} broadcast(f32[32]{0} %reshape.59), dimensions={1} + %add.61 = f32[200,32]{1,0} add(f32[200,32]{1,0} %dot.56, f32[200,32]{1,0} %broadcast.60) + %compare.68 = pred[200,32]{1,0} compare(f32[200,32]{1,0} %add.61, f32[200,32]{1,0} %broadcast.37), direction=GT + %Arg_14.15 = f32[200,1]{1,0} parameter(14) + %call.67 = f32[200,32]{1,0} call(f32[200,32]{1,0} %add.61), to_apply=%jit_relu_0.62 + %Arg_12.13 = f32[32,1]{1,0} parameter(12) + %dot.69 = f32[200,1]{1,0} dot(f32[200,32]{1,0} %call.67, f32[32,1]{1,0} %Arg_12.13), lhs_contracting_dims={1}, rhs_contracting_dims={0} + %Arg_11.12 = f32[1]{0} parameter(11) + %reshape.70 = f32[1,1]{1,0} reshape(f32[1]{0} %Arg_11.12) + %broadcast.71 = f32[1,1]{1,0} broadcast(f32[1,1]{1,0} %reshape.70), dimensions={0,1} + %reshape.72 = f32[1]{0} reshape(f32[1,1]{1,0} %broadcast.71) + %broadcast.73 = f32[200,1]{1,0} broadcast(f32[1]{0} %reshape.72), dimensions={1} + %add.74 = f32[200,1]{1,0} add(f32[200,1]{1,0} %dot.69, f32[200,1]{1,0} %broadcast.73) + %subtract.75 = f32[200,1]{1,0} subtract(f32[200,1]{1,0} %Arg_14.15, f32[200,1]{1,0} %add.74) + %constant.41 = f32[] constant(2) + %broadcast.42 = f32[200,1]{1,0} broadcast(f32[] %constant.41), dimensions={} + %multiply.77 = f32[200,1]{1,0} multiply(f32[200,1]{1,0} %subtract.75, f32[200,1]{1,0} %broadcast.42) + %constant.38 = f32[] constant(0.005) + %broadcast.39 = f32[200,1]{1,0} broadcast(f32[] %constant.38), dimensions={} + %multiply.84 = f32[200,1]{1,0} multiply(f32[200,1]{1,0} %multiply.77, f32[200,1]{1,0} %broadcast.39) + %negate.85 = f32[200,1]{1,0} negate(f32[200,1]{1,0} %multiply.84) + %dot.100 = f32[200,32]{1,0} dot(f32[200,1]{1,0} %negate.85, f32[32,1]{1,0} %Arg_12.13), lhs_contracting_dims={1}, rhs_contracting_dims={1} + %select.101 = f32[200,32]{1,0} select(pred[200,32]{1,0} %compare.68, f32[200,32]{1,0} %dot.100, f32[200,32]{1,0} %broadcast.37) + %dot.115 = f32[200,32]{1,0} dot(f32[200,32]{1,0} %select.101, f32[32,32]{1,0} %Arg_10.11), lhs_contracting_dims={1}, rhs_contracting_dims={1} + %select.116 = f32[200,32]{1,0} select(pred[200,32]{1,0} %compare.55, f32[200,32]{1,0} %dot.115, f32[200,32]{1,0} %broadcast.37) + %constant.35 = f32[] constant(0) + %reduce.121 = f32[32]{0} reduce(f32[200,32]{1,0} %select.116, f32[] %constant.35), dimensions={0}, to_apply=%region_5.117 + %reshape.122 = f32[1,32]{1,0} reshape(f32[32]{0} %reduce.121) + %reduce.127 = f32[32]{0} reduce(f32[1,32]{1,0} %reshape.122, f32[] %constant.35), dimensions={0}, to_apply=%region_6.123 + %add.131 = f32[32]{0} add(f32[32]{0} %multiply.130, f32[32]{0} %reduce.127) + %Arg_2.3 = f32[1,32]{1,0} parameter(2) + %constant.33 = f32[] constant(0.9) + %broadcast.34 = f32[1,32]{1,0} broadcast(f32[] %constant.33), dimensions={} + %multiply.134 = f32[1,32]{1,0} multiply(f32[1,32]{1,0} %Arg_2.3, f32[1,32]{1,0} %broadcast.34) + %dot.128 = f32[32,1]{1,0} dot(f32[200,32]{1,0} %select.116, f32[200,1]{1,0} %Arg_13.14), lhs_contracting_dims={0}, rhs_contracting_dims={0} + %transpose.129 = f32[1,32]{0,1} transpose(f32[32,1]{1,0} %dot.128), dimensions={1,0} + %add.135 = f32[1,32]{1,0} add(f32[1,32]{1,0} %multiply.134, f32[1,32]{0,1} %transpose.129) + %Arg_3.4 = f32[32]{0} parameter(3) + %multiply.138 = f32[32]{0} multiply(f32[32]{0} %Arg_3.4, f32[32]{0} %broadcast.30) + %reduce.106 = f32[32]{0} reduce(f32[200,32]{1,0} %select.101, f32[] %constant.35), dimensions={0}, to_apply=%region_3.102 + %reshape.107 = f32[1,32]{1,0} reshape(f32[32]{0} %reduce.106) + %reduce.112 = f32[32]{0} reduce(f32[1,32]{1,0} %reshape.107, f32[] %constant.35), dimensions={0}, to_apply=%region_4.108 + %add.139 = f32[32]{0} add(f32[32]{0} %multiply.138, f32[32]{0} %reduce.112) + %Arg_4.5 = f32[32,32]{1,0} parameter(4) + %constant.25 = f32[] constant(0.9) + %broadcast.26 = f32[32,32]{1,0} broadcast(f32[] %constant.25), dimensions={} + %multiply.142 = f32[32,32]{1,0} multiply(f32[32,32]{1,0} %Arg_4.5, f32[32,32]{1,0} %broadcast.26) + %dot.113 = f32[32,32]{1,0} dot(f32[200,32]{1,0} %select.101, f32[200,32]{1,0} %call.54), lhs_contracting_dims={0}, rhs_contracting_dims={0} + %transpose.114 = f32[32,32]{0,1} transpose(f32[32,32]{1,0} %dot.113), dimensions={1,0} + %add.143 = f32[32,32]{1,0} add(f32[32,32]{1,0} %multiply.142, f32[32,32]{0,1} %transpose.114) + %Arg_5.6 = f32[1]{0} parameter(5) + %constant.22 = f32[1]{0} constant({0.9}) + %multiply.146 = f32[1]{0} multiply(f32[1]{0} %Arg_5.6, f32[1]{0} %constant.22) + %reduce.90 = f32[1]{0} reduce(f32[200,1]{1,0} %negate.85, f32[] %constant.35), dimensions={0}, to_apply=%region_1.86 + %reshape.91 = f32[1,1]{1,0} reshape(f32[1]{0} %reduce.90) + %reduce.96 = f32[] reduce(f32[1,1]{1,0} %reshape.91, f32[] %constant.35), dimensions={0,1}, to_apply=%region_2.92 + %reshape.97 = f32[1]{0} reshape(f32[] %reduce.96) + %add.147 = f32[1]{0} add(f32[1]{0} %multiply.146, f32[1]{0} %reshape.97) + %Arg_6.7 = f32[32,1]{1,0} parameter(6) + %constant.19 = f32[] constant(0.9) + %broadcast.20 = f32[32,1]{1,0} broadcast(f32[] %constant.19), dimensions={} + %multiply.150 = f32[32,1]{1,0} multiply(f32[32,1]{1,0} %Arg_6.7, f32[32,1]{1,0} %broadcast.20) + %dot.98 = f32[1,32]{1,0} dot(f32[200,1]{1,0} %negate.85, f32[200,32]{1,0} %call.67), lhs_contracting_dims={0}, rhs_contracting_dims={0} + %transpose.99 = f32[32,1]{0,1} transpose(f32[1,32]{1,0} %dot.98), dimensions={1,0} + %add.151 = f32[32,1]{1,0} add(f32[32,1]{1,0} %multiply.150, f32[32,1]{0,1} %transpose.99) + %constant.27 = f32[] constant(0.01) + %broadcast.28 = f32[32]{0} broadcast(f32[] %constant.27), dimensions={} + %multiply.132 = f32[32]{0} multiply(f32[32]{0} %add.131, f32[32]{0} %broadcast.28) + %subtract.133 = f32[32]{0} subtract(f32[32]{0} %Arg_7.8, f32[32]{0} %multiply.132) + %constant.31 = f32[] constant(0.01) + %broadcast.32 = f32[1,32]{1,0} broadcast(f32[] %constant.31), dimensions={} + %multiply.136 = f32[1,32]{1,0} multiply(f32[1,32]{1,0} %add.135, f32[1,32]{1,0} %broadcast.32) + %subtract.137 = f32[1,32]{1,0} subtract(f32[1,32]{1,0} %Arg_8.9, f32[1,32]{1,0} %multiply.136) + %multiply.140 = f32[32]{0} multiply(f32[32]{0} %add.139, f32[32]{0} %broadcast.28) + %subtract.141 = f32[32]{0} subtract(f32[32]{0} %Arg_9.10, f32[32]{0} %multiply.140) + %constant.23 = f32[] constant(0.01) + %broadcast.24 = f32[32,32]{1,0} broadcast(f32[] %constant.23), dimensions={} + %multiply.144 = f32[32,32]{1,0} multiply(f32[32,32]{1,0} %add.143, f32[32,32]{1,0} %broadcast.24) + %subtract.145 = f32[32,32]{1,0} subtract(f32[32,32]{1,0} %Arg_10.11, f32[32,32]{1,0} %multiply.144) + %constant.21 = f32[1]{0} constant({0.01}) + %multiply.148 = f32[1]{0} multiply(f32[1]{0} %add.147, f32[1]{0} %constant.21) + %subtract.149 = f32[1]{0} subtract(f32[1]{0} %Arg_11.12, f32[1]{0} %multiply.148) + %constant.17 = f32[] constant(0.01) + %broadcast.18 = f32[32,1]{1,0} broadcast(f32[] %constant.17), dimensions={} + %multiply.152 = f32[32,1]{1,0} multiply(f32[32,1]{1,0} %add.151, f32[32,1]{1,0} %broadcast.18) + %subtract.153 = f32[32,1]{1,0} subtract(f32[32,1]{1,0} %Arg_12.13, f32[32,1]{1,0} %multiply.152) + %multiply.76 = f32[200,1]{1,0} multiply(f32[200,1]{1,0} %subtract.75, f32[200,1]{1,0} %subtract.75) + %reduce.82 = f32[] reduce(f32[200,1]{1,0} %multiply.76, f32[] %constant.35), dimensions={0,1}, to_apply=%region_0.78 + %constant.40 = f32[] constant(200) + %divide.83 = f32[] divide(f32[] %reduce.82, f32[] %constant.40) + ROOT %tuple.155 = (s32[], f32[32]{0}, f32[1,32]{1,0}, f32[32]{0}, f32[32,32]{1,0}, /*index=5*/f32[1]{0}, f32[32,1]{1,0}, f32[32]{0}, f32[1,32]{1,0}, f32[32]{0}, /*index=10*/f32[32,32]{1,0}, f32[1]{0}, f32[32,1]{1,0}, f32[]) tuple(s32[] %add.154, f32[32]{0} %add.131, f32[1,32]{1,0} %add.135, f32[32]{0} %add.139, f32[32,32]{1,0} %add.143, /*index=5*/f32[1]{0} %add.147, f32[32,1]{1,0} %add.151, f32[32]{0} %subtract.133, f32[1,32]{1,0} %subtract.137, f32[32]{0} %subtract.141, /*index=10*/f32[32,32]{1,0} %subtract.145, f32[1]{0} %subtract.149, f32[32,1]{1,0} %subtract.153, f32[] %divide.83) +} + diff --git a/tests/hlo_texts/test_hlos/maml_flax/module_0082.jit_divmod.28.before_optimizations.txt b/tests/hlo_texts/test_hlos/maml_flax/module_0082.jit_divmod.28.before_optimizations.txt new file mode 100644 index 0000000..9844c63 --- /dev/null +++ b/tests/hlo_texts/test_hlos/maml_flax/module_0082.jit_divmod.28.before_optimizations.txt @@ -0,0 +1,47 @@ +HloModule jit_divmod.28 + +%jit__where.3 (Arg_0.4: pred[], Arg_1.5: s32[], Arg_2.6: s32[]) -> s32[] { + %Arg_0.4 = pred[] parameter(0) + %Arg_1.5 = s32[] parameter(1) + %Arg_2.6 = s32[] parameter(2) + ROOT %select.7 = s32[] select(pred[] %Arg_0.4, s32[] %Arg_1.5, s32[] %Arg_2.6) +} + +%jit_floor_divide.8 (Arg_0.9: s32[], Arg_1.10: s32[]) -> s32[] { + %Arg_0.9 = s32[] parameter(0) + %sign.14 = s32[] sign(s32[] %Arg_0.9) + %Arg_1.10 = s32[] parameter(1) + %sign.15 = s32[] sign(s32[] %Arg_1.10) + %compare.16 = pred[] compare(s32[] %sign.14, s32[] %sign.15), direction=NE + %remainder.17 = s32[] remainder(s32[] %Arg_0.9, s32[] %Arg_1.10) + %constant.12 = s32[] constant(0) + %compare.18 = pred[] compare(s32[] %remainder.17, s32[] %constant.12), direction=NE + %and.19 = pred[] and(pred[] %compare.16, pred[] %compare.18) + %divide.13 = s32[] divide(s32[] %Arg_0.9, s32[] %Arg_1.10) + %constant.11 = s32[] constant(1) + %subtract.20 = s32[] subtract(s32[] %divide.13, s32[] %constant.11) + ROOT %call.21 = s32[] call(pred[] %and.19, s32[] %subtract.20, s32[] %divide.13), to_apply=%jit__where.3 +} + +%jit_remainder.23 (Arg_0.24: s32[], Arg_1.25: s32[]) -> s32[] { + %Arg_0.24 = s32[] parameter(0) + %Arg_1.25 = s32[] parameter(1) + %remainder.27 = s32[] remainder(s32[] %Arg_0.24, s32[] %Arg_1.25) + %constant.26 = s32[] constant(0) + %compare.29 = pred[] compare(s32[] %remainder.27, s32[] %constant.26), direction=LT + %compare.30 = pred[] compare(s32[] %Arg_1.25, s32[] %constant.26), direction=LT + %compare.31 = pred[] compare(pred[] %compare.29, pred[] %compare.30), direction=NE + %compare.28 = pred[] compare(s32[] %remainder.27, s32[] %constant.26), direction=NE + %and.32 = pred[] and(pred[] %compare.31, pred[] %compare.28) + %add.33 = s32[] add(s32[] %remainder.27, s32[] %Arg_1.25) + ROOT %select.34 = s32[] select(pred[] %and.32, s32[] %add.33, s32[] %remainder.27) +} + +ENTRY %main.37 (Arg_0.1: s32[], Arg_1.2: s32[]) -> (s32[], s32[]) { + %Arg_0.1 = s32[] parameter(0) + %Arg_1.2 = s32[] parameter(1) + %call.22 = s32[] call(s32[] %Arg_0.1, s32[] %Arg_1.2), to_apply=%jit_floor_divide.8 + %call.35 = s32[] call(s32[] %Arg_0.1, s32[] %Arg_1.2), to_apply=%jit_remainder.23 + ROOT %tuple.36 = (s32[], s32[]) tuple(s32[] %call.22, s32[] %call.35) +} + diff --git a/tests/hlo_texts/test_hlos/neural-tangents/module_0000.jit__f.0.before_optimizations.txt b/tests/hlo_texts/test_hlos/neural-tangents/module_0000.jit__f.0.before_optimizations.txt new file mode 100644 index 0000000..8084241 --- /dev/null +++ b/tests/hlo_texts/test_hlos/neural-tangents/module_0000.jit__f.0.before_optimizations.txt @@ -0,0 +1,93 @@ +HloModule jit__f.0 + +jit__where.52 { + Arg_0.53 = pred[1000,1000]{1,0} parameter(0) + Arg_1.54 = f32[] parameter(1) + broadcast.56 = f32[1000,1000]{1,0} broadcast(Arg_1.54), dimensions={} + Arg_2.55 = f32[1000,1000]{1,0} parameter(2) + ROOT select.57 = f32[1000,1000]{1,0} select(Arg_0.53, broadcast.56, Arg_2.55) +} + +jit__where_0.73 { + Arg_0.74 = pred[1000]{0} parameter(0) + Arg_1.75 = f32[] parameter(1) + broadcast.77 = f32[1000]{0} broadcast(Arg_1.75), dimensions={} + Arg_2.76 = f32[1000]{0} parameter(2) + ROOT select.78 = f32[1000]{0} select(Arg_0.74, broadcast.77, Arg_2.76) +} + +ENTRY main.85 { + Arg_0.1 = f32[1000,3072]{1,0} parameter(0) + dot.25 = f32[1000]{0} dot(Arg_0.1, Arg_0.1), lhs_batch_dims={0}, lhs_contracting_dims={1}, rhs_batch_dims={0}, rhs_contracting_dims={1} + constant.23 = f32[] constant(3072) + broadcast.24 = f32[1000]{0} broadcast(constant.23), dimensions={} + divide.26 = f32[1000]{0} divide(dot.25, broadcast.24) + constant.8 = f32[] constant(4) + broadcast.9 = f32[1000]{0} broadcast(constant.8), dimensions={} + multiply.29 = f32[1000]{0} multiply(divide.26, broadcast.9) + constant.6 = f32[] constant(0.0025) + broadcast.7 = f32[1000]{0} broadcast(constant.6), dimensions={} + add.30 = f32[1000]{0} add(multiply.29, broadcast.7) + constant.19 = f32[] constant(1) + broadcast.20 = f32[1000]{0} broadcast(constant.19), dimensions={} + divide.33 = f32[1000]{0} divide(add.30, broadcast.20) + multiply.43 = f32[1000]{0} multiply(divide.33, divide.33) + multiply.65 = f32[1000]{0} multiply(add.30, add.30) + subtract.66 = f32[1000]{0} subtract(multiply.43, multiply.65) + constant.11 = f32[] constant(0) + broadcast.12 = f32[1000]{0} broadcast(constant.11), dimensions={} + maximum.67 = f32[1000]{0} maximum(subtract.66, broadcast.12) + sqrt.68 = f32[1000]{0} sqrt(maximum.67) + compare.69 = pred[1000]{0} compare(sqrt.68, broadcast.12), direction=EQ + compare.70 = pred[1000]{0} compare(add.30, broadcast.12), direction=EQ + and.71 = pred[1000]{0} and(compare.69, compare.70) + constant.10 = f32[] constant(1.57079637) + atan2.72 = f32[1000]{0} atan2(sqrt.68, add.30) + call.79 = f32[1000]{0} call(and.71, constant.10, atan2.72), to_apply=jit__where_0.73 + reshape.34 = f32[1000,1]{1,0} reshape(divide.33) + broadcast.36 = f32[1000,1]{1,0} broadcast(reshape.34), dimensions={0,1} + reshape.37 = f32[1000]{0} reshape(broadcast.36) + broadcast.38 = f32[1000,1000]{1,0} broadcast(reshape.37), dimensions={0} + reshape.35 = f32[1,1000]{1,0} reshape(divide.33) + broadcast.39 = f32[1,1000]{1,0} broadcast(reshape.35), dimensions={0,1} + reshape.40 = f32[1000]{0} reshape(broadcast.39) + broadcast.41 = f32[1000,1000]{1,0} broadcast(reshape.40), dimensions={1} + multiply.42 = f32[1000,1000]{1,0} multiply(broadcast.38, broadcast.41) + dot.27 = f32[1000,1000]{1,0} dot(Arg_0.1, Arg_0.1), lhs_contracting_dims={1}, rhs_contracting_dims={1} + constant.21 = f32[] constant(3072) + broadcast.22 = f32[1000,1000]{1,0} broadcast(constant.21), dimensions={} + divide.28 = f32[1000,1000]{1,0} divide(dot.27, broadcast.22) + constant.2 = f32[] constant(4) + broadcast.3 = f32[1000,1000]{1,0} broadcast(constant.2), dimensions={} + multiply.31 = f32[1000,1000]{1,0} multiply(divide.28, broadcast.3) + constant.4 = f32[] constant(0.0025) + broadcast.5 = f32[1000,1000]{1,0} broadcast(constant.4), dimensions={} + add.32 = f32[1000,1000]{1,0} add(multiply.31, broadcast.5) + multiply.44 = f32[1000,1000]{1,0} multiply(add.32, add.32) + subtract.45 = f32[1000,1000]{1,0} subtract(multiply.42, multiply.44) + constant.17 = f32[] constant(0) + broadcast.18 = f32[1000,1000]{1,0} broadcast(constant.17), dimensions={} + maximum.46 = f32[1000,1000]{1,0} maximum(subtract.45, broadcast.18) + sqrt.47 = f32[1000,1000]{1,0} sqrt(maximum.46) + constant.13 = f32[] constant(0.159154937) + broadcast.14 = f32[1000,1000]{1,0} broadcast(constant.13), dimensions={} + multiply.61 = f32[1000,1000]{1,0} multiply(sqrt.47, broadcast.14) + constant.15 = f32[] constant(0.5) + broadcast.16 = f32[1000,1000]{1,0} broadcast(constant.15), dimensions={} + compare.48 = pred[1000,1000]{1,0} compare(sqrt.47, broadcast.18), direction=EQ + compare.49 = pred[1000,1000]{1,0} compare(add.32, broadcast.18), direction=EQ + and.50 = pred[1000,1000]{1,0} and(compare.48, compare.49) + atan2.51 = f32[1000,1000]{1,0} atan2(sqrt.47, add.32) + call.58 = f32[1000,1000]{1,0} call(and.50, constant.10, atan2.51), to_apply=jit__where.52 + multiply.59 = f32[1000,1000]{1,0} multiply(call.58, broadcast.14) + subtract.60 = f32[1000,1000]{1,0} subtract(broadcast.16, multiply.59) + multiply.62 = f32[1000,1000]{1,0} multiply(subtract.60, add.32) + add.63 = f32[1000,1000]{1,0} add(multiply.61, multiply.62) + multiply.80 = f32[1000,1000]{1,0} multiply(add.63, broadcast.3) + add.81 = f32[1000,1000]{1,0} add(multiply.80, broadcast.5) + multiply.64 = f32[1000,1000]{1,0} multiply(add.32, subtract.60) + multiply.82 = f32[1000,1000]{1,0} multiply(multiply.64, broadcast.3) + add.83 = f32[1000,1000]{1,0} add(add.81, multiply.82) + ROOT tuple.84 = (f32[1000,1000]{1,0}, f32[1000,1000]{1,0}) tuple(add.81, add.83) +} + diff --git a/tests/hlo_texts/test_hlos/neural-tangents/module_0011.jit_fn.7.before_optimizations.txt b/tests/hlo_texts/test_hlos/neural-tangents/module_0011.jit_fn.7.before_optimizations.txt new file mode 100644 index 0000000..d7ce7c9 --- /dev/null +++ b/tests/hlo_texts/test_hlos/neural-tangents/module_0011.jit_fn.7.before_optimizations.txt @@ -0,0 +1,12 @@ +HloModule jit_fn.7 + +ENTRY main.8 { + Arg_0.1 = f32[1,1]{1,0} parameter(0) + broadcast.4 = f32[1,1]{1,0} broadcast(Arg_0.1), dimensions={0,1} + reshape.5 = f32[] reshape(broadcast.4) + broadcast.6 = f32[492,492]{1,0} broadcast(reshape.5), dimensions={} + Arg_1.2 = s32[492,492]{1,0} parameter(1) + convert.3 = f32[492,492]{1,0} convert(Arg_1.2) + ROOT add.7 = f32[492,492]{1,0} add(broadcast.6, convert.3) +} + diff --git a/tests/hlo_texts/test_hlos/neural-tangents/module_0028.jit__cholesky.12.before_optimizations.txt b/tests/hlo_texts/test_hlos/neural-tangents/module_0028.jit__cholesky.12.before_optimizations.txt new file mode 100644 index 0000000..0f1a62c --- /dev/null +++ b/tests/hlo_texts/test_hlos/neural-tangents/module_0028.jit__cholesky.12.before_optimizations.txt @@ -0,0 +1,40 @@ +HloModule jit__cholesky.12 + +xla_fallback_cholesky.3 { + Arg_0.4 = f32[1000,1000]{1,0} parameter(0) + custom-call.8 = (f32[1000,1000]{0,1}, s32[], s8[128]{0}) custom-call(Arg_0.4), custom_call_target="cusolver_potrf", operand_layout_constraints={f32[1000,1000]{0,1}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\350\003\000\000\000\000\000\000 \000\000\000&\177\000\000" + get-tuple-element.9 = s32[] get-tuple-element(custom-call.8), index=1 + constant.7 = s32[] constant(0) + compare.10 = pred[] compare(get-tuple-element.9, constant.7), direction=EQ + broadcast.11 = pred[1000,1000]{1,0} broadcast(compare.10), dimensions={} + get-tuple-element.12 = f32[1000,1000]{0,1} get-tuple-element(custom-call.8), index=0 + constant.5 = f32[] constant(nan) + broadcast.6 = f32[1000,1000]{1,0} broadcast(constant.5), dimensions={} + ROOT select.13 = f32[1000,1000]{1,0} select(broadcast.11, get-tuple-element.12, broadcast.6) +} + +cholesky.14 { + Arg_0.15 = f32[1000,1000]{1,0} parameter(0) + ROOT call.16 = f32[1000,1000]{1,0} call(Arg_0.15), to_apply=xla_fallback_cholesky.3 +} + +jit_tril.18 { + iota.22 = s32[1000]{0} iota(), iota_dimension=0 + broadcast.23 = s32[1000,1000]{1,0} broadcast(iota.22), dimensions={0} + iota.24 = s32[1000]{0} iota(), iota_dimension=0 + broadcast.25 = s32[1000,1000]{1,0} broadcast(iota.24), dimensions={1} + compare.26 = pred[1000,1000]{1,0} compare(broadcast.23, broadcast.25), direction=GE + Arg_0.19 = f32[1000,1000]{1,0} parameter(0) + constant.20 = f32[] constant(0) + broadcast.21 = f32[1000,1000]{1,0} broadcast(constant.20), dimensions={} + ROOT select.27 = f32[1000,1000]{1,0} select(compare.26, Arg_0.19, broadcast.21) +} + +ENTRY main.30 { + Arg_0.1 = f32[1000,1000]{1,0} parameter(0) + transpose.2 = f32[1000,1000]{0,1} transpose(Arg_0.1), dimensions={1,0} + call.17 = f32[1000,1000]{1,0} call(transpose.2), to_apply=cholesky.14 + call.28 = f32[1000,1000]{1,0} call(call.17), to_apply=jit_tril.18 + ROOT transpose.29 = f32[1000,1000]{0,1} transpose(call.28), dimensions={1,0} +} + diff --git a/tests/hlo_texts/test_hlos/ott/module_0059.jit__uniform.25.before_optimizations.txt b/tests/hlo_texts/test_hlos/ott/module_0059.jit__uniform.25.before_optimizations.txt new file mode 100644 index 0000000..072eafa --- /dev/null +++ b/tests/hlo_texts/test_hlos/ott/module_0059.jit__uniform.25.before_optimizations.txt @@ -0,0 +1,49 @@ +HloModule jit__uniform.25 + +ENTRY main.45 { + Arg_1.2 = f32[] parameter(1) + reshape.11 = f32[1]{0} reshape(Arg_1.2) + broadcast.41 = f32[1]{0} broadcast(reshape.11), dimensions={0} + reshape.42 = f32[] reshape(broadcast.41) + broadcast.43 = f32[27]{0} broadcast(reshape.42), dimensions={} + Arg_0.1 = u32[2]{0} parameter(0) + slice.14 = u32[1]{0} slice(Arg_0.1), slice={[0:1]} + reshape.15 = u32[] reshape(slice.14) + broadcast.21 = u32[14]{0} broadcast(reshape.15), dimensions={} + slice.16 = u32[1]{0} slice(Arg_0.1), slice={[1:2]} + reshape.17 = u32[] reshape(slice.16) + broadcast.22 = u32[14]{0} broadcast(reshape.17), dimensions={} + iota.13 = u32[27]{0} iota(), iota_dimension=0 + slice.19 = u32[14]{0} slice(iota.13), slice={[0:14]} + constant.10 = u32[1]{0} constant({0}) + concatenate.18 = u32[28]{0} concatenate(iota.13, constant.10), dimensions={0} + slice.20 = u32[14]{0} slice(concatenate.18), slice={[14:28]} + custom-call.23 = (u32[14]{0}, u32[14]{0}) custom-call(broadcast.21, broadcast.22, slice.19, slice.20), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[14]{0}, u32[14]{0}, u32[14]{0}, u32[14]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\016\000\000\000\000\000\000\000" + get-tuple-element.24 = u32[14]{0} get-tuple-element(custom-call.23), index=0 + get-tuple-element.25 = u32[14]{0} get-tuple-element(custom-call.23), index=1 + concatenate.26 = u32[28]{0} concatenate(get-tuple-element.24, get-tuple-element.25), dimensions={0} + slice.27 = u32[27]{0} slice(concatenate.26), slice={[0:27]} + constant.8 = u32[] constant(9) + broadcast.9 = u32[27]{0} broadcast(constant.8), dimensions={} + shift-right-logical.28 = u32[27]{0} shift-right-logical(slice.27, broadcast.9) + constant.6 = u32[] constant(1065353216) + broadcast.7 = u32[27]{0} broadcast(constant.6), dimensions={} + or.29 = u32[27]{0} or(shift-right-logical.28, broadcast.7) + bitcast-convert.30 = f32[27]{0} bitcast-convert(or.29) + constant.4 = f32[] constant(1) + broadcast.5 = f32[27]{0} broadcast(constant.4), dimensions={} + subtract.31 = f32[27]{0} subtract(bitcast-convert.30, broadcast.5) + Arg_2.3 = f32[] parameter(2) + reshape.12 = f32[1]{0} reshape(Arg_2.3) + subtract.32 = f32[1]{0} subtract(reshape.12, reshape.11) + broadcast.33 = f32[1]{0} broadcast(subtract.32), dimensions={0} + reshape.34 = f32[] reshape(broadcast.33) + broadcast.35 = f32[27]{0} broadcast(reshape.34), dimensions={} + multiply.36 = f32[27]{0} multiply(subtract.31, broadcast.35) + broadcast.37 = f32[1]{0} broadcast(reshape.11), dimensions={0} + reshape.38 = f32[] reshape(broadcast.37) + broadcast.39 = f32[27]{0} broadcast(reshape.38), dimensions={} + add.40 = f32[27]{0} add(multiply.36, broadcast.39) + ROOT maximum.44 = f32[27]{0} maximum(broadcast.43, add.40) +} + diff --git a/tests/hlo_texts/test_hlos/ott/module_0164.jit_leaky_relu.74.before_optimizations.txt b/tests/hlo_texts/test_hlos/ott/module_0164.jit_leaky_relu.74.before_optimizations.txt new file mode 100644 index 0000000..4d3dbc9 --- /dev/null +++ b/tests/hlo_texts/test_hlos/ott/module_0164.jit_leaky_relu.74.before_optimizations.txt @@ -0,0 +1,34 @@ +HloModule jit_leaky_relu.74 + +vmap_jvp_jvp__where___.13 { + Arg_0.14 = pred[64]{0} parameter(0) + Arg_1.15 = f32[64]{0} parameter(1) + Arg_2.16 = f32[64]{0} parameter(2) + select.19 = f32[64]{0} select(Arg_0.14, Arg_1.15, Arg_2.16) + broadcast.20 = pred[10,64]{1,0} broadcast(Arg_0.14), dimensions={1} + Arg_3.17 = f32[10,64]{1,0} parameter(3) + Arg_4.18 = f32[10,64]{1,0} parameter(4) + select.21 = f32[10,64]{1,0} select(broadcast.20, Arg_3.17, Arg_4.18) + ROOT tuple.22 = (f32[64]{0}, pred[64]{0}, f32[10,64]{1,0}) tuple(select.19, Arg_0.14, select.21) +} + +ENTRY main.28 { + Arg_0.1 = f32[64]{0} parameter(0) + constant.8 = f32[] constant(0) + broadcast.9 = f32[64]{0} broadcast(constant.8), dimensions={} + compare.10 = pred[64]{0} compare(Arg_0.1, broadcast.9), direction=GE + constant.6 = f32[] constant(0.01) + broadcast.7 = f32[64]{0} broadcast(constant.6), dimensions={} + multiply.11 = f32[64]{0} multiply(Arg_0.1, broadcast.7) + Arg_1.2 = f32[10,64]{1,0} parameter(1) + constant.4 = f32[] constant(0.01) + broadcast.5 = f32[10,64]{1,0} broadcast(constant.4), dimensions={} + multiply.12 = f32[10,64]{1,0} multiply(Arg_1.2, broadcast.5) + call.23 = (f32[64]{0}, pred[64]{0}, f32[10,64]{1,0}) call(compare.10, Arg_0.1, multiply.11, Arg_1.2, multiply.12), to_apply=vmap_jvp_jvp__where___.13 + get-tuple-element.24 = f32[64]{0} get-tuple-element(call.23), index=0 + get-tuple-element.25 = pred[64]{0} get-tuple-element(call.23), index=1 + constant.3 = f32[] constant(0.01) + get-tuple-element.26 = f32[10,64]{1,0} get-tuple-element(call.23), index=2 + ROOT tuple.27 = (f32[64]{0}, pred[64]{0}, f32[], f32[10,64]{1,0}) tuple(get-tuple-element.24, get-tuple-element.25, constant.3, get-tuple-element.26) +} + diff --git a/tests/hlo_texts/test_hlos/ott/module_0308.jit__lambda_.59.before_optimizations.txt b/tests/hlo_texts/test_hlos/ott/module_0308.jit__lambda_.59.before_optimizations.txt new file mode 100644 index 0000000..9fab5f7 --- /dev/null +++ b/tests/hlo_texts/test_hlos/ott/module_0308.jit__lambda_.59.before_optimizations.txt @@ -0,0 +1,7 @@ +HloModule jit__lambda_.59 + +ENTRY main.3 { + Arg_0.1 = f32[] parameter(0) + ROOT negate.2 = f32[] negate(Arg_0.1) +} + diff --git a/tests/hlo_texts/test_hlos/ott/module_0308.jit_median.138.before_optimizations.txt b/tests/hlo_texts/test_hlos/ott/module_0308.jit_median.138.before_optimizations.txt new file mode 100644 index 0000000..4c8955f --- /dev/null +++ b/tests/hlo_texts/test_hlos/ott/module_0308.jit_median.138.before_optimizations.txt @@ -0,0 +1,88 @@ +HloModule jit_median.138 + +isnan.3 { + Arg_0.4 = f32[63]{0} parameter(0) + ROOT compare.5 = pred[63]{0} compare(Arg_0.4, Arg_0.4), direction=NE +} + +region_0.6 { + Arg_0.7 = pred[] parameter(0) + Arg_1.8 = pred[] parameter(1) + ROOT or.9 = pred[] or(Arg_0.7, Arg_1.8) +} + +_where.10 { + Arg_0.11 = pred[1]{0} parameter(0) + reshape.14 = pred[] reshape(Arg_0.11) + broadcast.15 = pred[63]{0} broadcast(reshape.14), dimensions={} + Arg_1.12 = f32[] parameter(1) + broadcast.16 = f32[63]{0} broadcast(Arg_1.12), dimensions={} + Arg_2.13 = f32[63]{0} parameter(2) + ROOT select.17 = f32[63]{0} select(broadcast.15, broadcast.16, Arg_2.13) +} + +region_1.18 { + Arg_0.19 = f32[] parameter(0) + compare.29 = pred[] compare(Arg_0.19, Arg_0.19), direction=NE + constant.22 = s32[] constant(2143289344) + constant.24 = f32[] constant(0) + compare.27 = pred[] compare(Arg_0.19, constant.24), direction=EQ + constant.23 = s32[] constant(0) + bitcast-convert.25 = s32[] bitcast-convert(Arg_0.19) + select.28 = s32[] select(compare.27, constant.23, bitcast-convert.25) + select.30 = s32[] select(compare.29, constant.22, select.28) + compare.33 = pred[] compare(select.30, constant.23), direction=LT + constant.21 = u32[] constant(2147483647) + bitcast-convert.26 = u32[] bitcast-convert(Arg_0.19) + subtract.31 = u32[] subtract(constant.21, bitcast-convert.26) + bitcast-convert.32 = s32[] bitcast-convert(subtract.31) + select.34 = s32[] select(compare.33, bitcast-convert.32, select.30) + Arg_1.20 = f32[] parameter(1) + compare.39 = pred[] compare(Arg_1.20, Arg_1.20), direction=NE + compare.37 = pred[] compare(Arg_1.20, constant.24), direction=EQ + bitcast-convert.35 = s32[] bitcast-convert(Arg_1.20) + select.38 = s32[] select(compare.37, constant.23, bitcast-convert.35) + select.40 = s32[] select(compare.39, constant.22, select.38) + compare.43 = pred[] compare(select.40, constant.23), direction=LT + bitcast-convert.36 = u32[] bitcast-convert(Arg_1.20) + subtract.41 = u32[] subtract(constant.21, bitcast-convert.36) + bitcast-convert.42 = s32[] bitcast-convert(subtract.41) + select.44 = s32[] select(compare.43, bitcast-convert.42, select.40) + ROOT compare.45 = pred[] compare(select.34, select.44), direction=LT +} + +quantile.46 { + Arg_0.47 = f32[7,9]{1,0} parameter(0) + reshape.54 = f32[63]{0} reshape(Arg_0.47) + call.55 = pred[63]{0} call(reshape.54), to_apply=isnan.3 + constant.53 = pred[] constant(false) + reduce.56 = pred[] reduce(call.55, constant.53), dimensions={0}, to_apply=region_0.6 + reshape.57 = pred[1]{0} reshape(reduce.56) + constant.52 = f32[] constant(nan) + call.58 = f32[63]{0} call(reshape.57, constant.52, reshape.54), to_apply=_where.10 + sort.59 = f32[63]{0} sort(call.58), dimensions={0}, is_stable=true, to_apply=region_1.18 + constant.51 = f32[] constant(0) + Arg_1.48 = f32[] parameter(1) + constant.50 = f32[] constant(62) + multiply.60 = f32[] multiply(Arg_1.48, constant.50) + floor.61 = f32[] floor(multiply.60) + clamp.63 = f32[] clamp(constant.51, floor.61, constant.50) + convert.65 = s32[] convert(clamp.63) + reshape.67 = s32[1]{0} reshape(convert.65) + gather.68 = f32[] gather(sort.59, reshape.67), offset_dims={}, collapsed_slice_dims={0}, start_index_map={0}, index_vector_dim=0, slice_sizes={1} + ceil.62 = f32[] ceil(multiply.60) + clamp.64 = f32[] clamp(constant.51, ceil.62, constant.50) + convert.66 = s32[] convert(clamp.64) + reshape.69 = s32[1]{0} reshape(convert.66) + gather.70 = f32[] gather(sort.59, reshape.69), offset_dims={}, collapsed_slice_dims={0}, start_index_map={0}, index_vector_dim=0, slice_sizes={1} + add.71 = f32[] add(gather.68, gather.70) + constant.49 = f32[] constant(0.5) + ROOT multiply.72 = f32[] multiply(add.71, constant.49) +} + +ENTRY main.74 { + Arg_0.1 = f32[7,9]{1,0} parameter(0) + constant.2 = f32[] constant(0.5) + ROOT call.73 = f32[] call(Arg_0.1, constant.2), to_apply=quantile.46 +} + diff --git a/tests/hlo_texts/test_hlos/siren-jax/module_0010.jit__threefry_split.5.before_optimizations.txt b/tests/hlo_texts/test_hlos/siren-jax/module_0010.jit__threefry_split.5.before_optimizations.txt new file mode 100644 index 0000000..fc3469b --- /dev/null +++ b/tests/hlo_texts/test_hlos/siren-jax/module_0010.jit__threefry_split.5.before_optimizations.txt @@ -0,0 +1,39 @@ +HloModule jit__threefry_split.5 + +xla_fallback_threefry2x32.9 { + Arg_0.10 = u32[] parameter(0) + broadcast.14 = u32[2]{0} broadcast(Arg_0.10), dimensions={} + Arg_1.11 = u32[] parameter(1) + broadcast.15 = u32[2]{0} broadcast(Arg_1.11), dimensions={} + Arg_2.12 = u32[2]{0} parameter(2) + Arg_3.13 = u32[2]{0} parameter(3) + ROOT custom-call.16 = (u32[2]{0}, u32[2]{0}) custom-call(broadcast.14, broadcast.15, Arg_2.12, Arg_3.13), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[2]{0}, u32[2]{0}, u32[2]{0}, u32[2]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\002\000\000\000\000\000\000\000" +} + +threefry2x32.17 { + Arg_0.18 = u32[] parameter(0) + Arg_1.19 = u32[] parameter(1) + Arg_2.20 = u32[2]{0} parameter(2) + Arg_3.21 = u32[2]{0} parameter(3) + call.22 = (u32[2]{0}, u32[2]{0}) call(Arg_0.18, Arg_1.19, Arg_2.20, Arg_3.21), to_apply=xla_fallback_threefry2x32.9 + get-tuple-element.23 = u32[2]{0} get-tuple-element(call.22), index=0 + get-tuple-element.24 = u32[2]{0} get-tuple-element(call.22), index=1 + ROOT tuple.25 = (u32[2]{0}, u32[2]{0}) tuple(get-tuple-element.23, get-tuple-element.24) +} + +ENTRY main.31 { + Arg_0.1 = u32[2]{0} parameter(0) + slice.3 = u32[1]{0} slice(Arg_0.1), slice={[0:1]} + reshape.4 = u32[] reshape(slice.3) + slice.5 = u32[1]{0} slice(Arg_0.1), slice={[1:2]} + reshape.6 = u32[] reshape(slice.5) + iota.2 = u32[4]{0} iota(), iota_dimension=0 + slice.7 = u32[2]{0} slice(iota.2), slice={[0:2]} + slice.8 = u32[2]{0} slice(iota.2), slice={[2:4]} + call.26 = (u32[2]{0}, u32[2]{0}) call(reshape.4, reshape.6, slice.7, slice.8), to_apply=threefry2x32.17 + get-tuple-element.27 = u32[2]{0} get-tuple-element(call.26), index=0 + get-tuple-element.28 = u32[2]{0} get-tuple-element(call.26), index=1 + concatenate.29 = u32[4]{0} concatenate(get-tuple-element.27, get-tuple-element.28), dimensions={0} + ROOT reshape.30 = u32[2,2]{1,0} reshape(concatenate.29) +} + diff --git a/tests/hlo_texts/test_hlos/siren-jax/module_0014.jit__unstack.6.before_optimizations.txt b/tests/hlo_texts/test_hlos/siren-jax/module_0014.jit__unstack.6.before_optimizations.txt new file mode 100644 index 0000000..90673bc --- /dev/null +++ b/tests/hlo_texts/test_hlos/siren-jax/module_0014.jit__unstack.6.before_optimizations.txt @@ -0,0 +1,11 @@ +HloModule jit__unstack.6 + +ENTRY main.7 { + Arg_0.1 = u32[2,2]{1,0} parameter(0) + slice.2 = u32[1,2]{1,0} slice(Arg_0.1), slice={[0:1], [0:2]} + reshape.3 = u32[2]{0} reshape(slice.2) + slice.4 = u32[1,2]{1,0} slice(Arg_0.1), slice={[1:2], [0:2]} + reshape.5 = u32[2]{0} reshape(slice.4) + ROOT tuple.6 = (u32[2]{0}, u32[2]{0}) tuple(reshape.3, reshape.5) +} + diff --git a/tests/hlo_texts/test_hlos/siren-jax/module_0017.jit__uniform.7.before_optimizations.txt b/tests/hlo_texts/test_hlos/siren-jax/module_0017.jit__uniform.7.before_optimizations.txt new file mode 100644 index 0000000..8096968 --- /dev/null +++ b/tests/hlo_texts/test_hlos/siren-jax/module_0017.jit__uniform.7.before_optimizations.txt @@ -0,0 +1,66 @@ +HloModule jit__uniform.7 + +xla_fallback_threefry2x32.19 { + Arg_0.20 = u32[] parameter(0) + broadcast.24 = u32[256]{0} broadcast(Arg_0.20), dimensions={} + Arg_1.21 = u32[] parameter(1) + broadcast.25 = u32[256]{0} broadcast(Arg_1.21), dimensions={} + Arg_2.22 = u32[256]{0} parameter(2) + Arg_3.23 = u32[256]{0} parameter(3) + ROOT custom-call.26 = (u32[256]{0}, u32[256]{0}) custom-call(broadcast.24, broadcast.25, Arg_2.22, Arg_3.23), custom_call_target="cuda_threefry2x32", operand_layout_constraints={u32[256]{0}, u32[256]{0}, u32[256]{0}, u32[256]{0}}, api_version=API_VERSION_STATUS_RETURNING, backend_config="\000\001\000\000\000\000\000\000" +} + +threefry2x32.27 { + Arg_0.28 = u32[] parameter(0) + Arg_1.29 = u32[] parameter(1) + Arg_2.30 = u32[256]{0} parameter(2) + Arg_3.31 = u32[256]{0} parameter(3) + call.32 = (u32[256]{0}, u32[256]{0}) call(Arg_0.28, Arg_1.29, Arg_2.30, Arg_3.31), to_apply=xla_fallback_threefry2x32.19 + get-tuple-element.33 = u32[256]{0} get-tuple-element(call.32), index=0 + get-tuple-element.34 = u32[256]{0} get-tuple-element(call.32), index=1 + ROOT tuple.35 = (u32[256]{0}, u32[256]{0}) tuple(get-tuple-element.33, get-tuple-element.34) +} + +ENTRY main.58 { + Arg_1.2 = f32[] parameter(1) + reshape.10 = f32[1,1]{1,0} reshape(Arg_1.2) + broadcast.54 = f32[1,1]{1,0} broadcast(reshape.10), dimensions={0,1} + reshape.55 = f32[] reshape(broadcast.54) + broadcast.56 = f32[2,256]{1,0} broadcast(reshape.55), dimensions={} + Arg_0.1 = u32[2]{0} parameter(0) + slice.13 = u32[1]{0} slice(Arg_0.1), slice={[0:1]} + reshape.14 = u32[] reshape(slice.13) + slice.15 = u32[1]{0} slice(Arg_0.1), slice={[1:2]} + reshape.16 = u32[] reshape(slice.15) + iota.12 = u32[512]{0} iota(), iota_dimension=0 + slice.17 = u32[256]{0} slice(iota.12), slice={[0:256]} + slice.18 = u32[256]{0} slice(iota.12), slice={[256:512]} + call.36 = (u32[256]{0}, u32[256]{0}) call(reshape.14, reshape.16, slice.17, slice.18), to_apply=threefry2x32.27 + get-tuple-element.37 = u32[256]{0} get-tuple-element(call.36), index=0 + get-tuple-element.38 = u32[256]{0} get-tuple-element(call.36), index=1 + concatenate.39 = u32[512]{0} concatenate(get-tuple-element.37, get-tuple-element.38), dimensions={0} + reshape.40 = u32[2,256]{1,0} reshape(concatenate.39) + constant.8 = u32[] constant(9) + broadcast.9 = u32[2,256]{1,0} broadcast(constant.8), dimensions={} + shift-right-logical.41 = u32[2,256]{1,0} shift-right-logical(reshape.40, broadcast.9) + constant.6 = u32[] constant(1065353216) + broadcast.7 = u32[2,256]{1,0} broadcast(constant.6), dimensions={} + or.42 = u32[2,256]{1,0} or(shift-right-logical.41, broadcast.7) + bitcast-convert.43 = f32[2,256]{1,0} bitcast-convert(or.42) + constant.4 = f32[] constant(1) + broadcast.5 = f32[2,256]{1,0} broadcast(constant.4), dimensions={} + subtract.44 = f32[2,256]{1,0} subtract(bitcast-convert.43, broadcast.5) + Arg_2.3 = f32[] parameter(2) + reshape.11 = f32[1,1]{1,0} reshape(Arg_2.3) + subtract.45 = f32[1,1]{1,0} subtract(reshape.11, reshape.10) + broadcast.46 = f32[1,1]{1,0} broadcast(subtract.45), dimensions={0,1} + reshape.47 = f32[] reshape(broadcast.46) + broadcast.48 = f32[2,256]{1,0} broadcast(reshape.47), dimensions={} + multiply.49 = f32[2,256]{1,0} multiply(subtract.44, broadcast.48) + broadcast.50 = f32[1,1]{1,0} broadcast(reshape.10), dimensions={0,1} + reshape.51 = f32[] reshape(broadcast.50) + broadcast.52 = f32[2,256]{1,0} broadcast(reshape.51), dimensions={} + add.53 = f32[2,256]{1,0} add(multiply.49, broadcast.52) + ROOT maximum.57 = f32[2,256]{1,0} maximum(broadcast.56, add.53) +} + diff --git a/tests/pass_pipelines.py b/tests/pass_pipelines.py new file mode 100644 index 0000000..2a83280 --- /dev/null +++ b/tests/pass_pipelines.py @@ -0,0 +1,434 @@ +# Copyright 2022 Garena Online Private Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from abc import ABC, abstractmethod, abstractproperty +from hloenv import HloEnv, HloModule, Pass, HloPass, AltPipeline, Pipeline, GpuBackend + + +class PassPipelines(ABC): + + @abstractproperty + def pre_pass_optimizations(self): + pass + + @abstractproperty + def post_pass_optimizations(self): + pass + + @abstractproperty + def pre_dry_pass_passes(self): + pass + + @abstractproperty + def post_dry_pass_passes(self): + pass + + @abstractproperty + def xla_passes(self): + pass + + @abstractproperty + def pass_dry_run(self): + pass + + +class SingleFusionPipeline(PassPipelines): + + def __init__(self, hlo_ir: HloEnv) -> None: + self._hlo_ir = hlo_ir + + hlo_module = self._hlo_ir.get_hlo_module() + config = hlo_module.config + debug_options = config.debug_options + + self.pre_fusion_optimizations = Pipeline("pre-fusion-optimizations") + + optimization_pipeline = Pipeline("optimization") + optimization_pipeline.add_pass(HloPass.AllToAllDecomposer()) + optimization_pipeline.add_pass(HloPass.OperandUpcaster()) + optimization_pipeline.add_pass(HloPass.ResultCaster()) + optimization_pipeline.add_pass(HloPass.RngExpander()) + optimization_pipeline.add_pass( + HloPass.RngBitGeneratorExpander( + HloPass.RngBitGeneratorExpander.RandomAlgorithm.RNG_PHILOX + ) + ) + optimization_pipeline.add_pass(HloPass.ComparisonExpander()) + optimization_pipeline.add_pass(HloPass.ZeroSizedHloElimination()) + + if debug_options.xla_gpu_deterministic_ops: + optimization_pipeline.add_pass( + HloPass.ScatterExpander( + HloPass.ScatterExpander.Mode.kEliminateAllScatters + ) + ) + else: + optimization_pipeline.add_pass(HloPass.GpuScatterExpander()) + + optimization_pipeline.add_pass(HloPass.QrExpander()) + optimization_pipeline.add_pass(HloPass.EighExpander()) + optimization_pipeline.add_pass(HloPass.DynamicIndexSplitter()) + optimization_pipeline.add_pass(HloPass.CallInliner()) + optimization_pipeline.add_pass(HloPass.DotDecomposer()) + optimization_pipeline.add_pass(HloPass.Convolution4DExpander()) + optimization_pipeline.add_pass(HloPass.StableSortExpander()) + + optimization_pipeline.add_pass(HloPass.BFloat16Normalization(True)) + optimization_pipeline.add_pass(HloPass.BatchNormExpander(True, True, True)) + optimization_pipeline.add_pass( + HloPass.LogisticExpander( + HloPass.LogisticExpander.LogisticExpansionType.kExp + ) + ) + optimization_pipeline.add_pass(HloPass.ConditionalCanonicalizer()) + optimization_pipeline.add_pass(HloPass.DynamicDimensionSimplifier()) + dp_options = { + "shape_check_mode": HloPass.DynamicPadder.ShapeCheckMode.kCompileTime + } + optimization_pipeline.add_pass(HloPass.DynamicPadder(dp_options)) + + # *********************************************************************** + + simplification_pipeline = Pipeline("simplification", loop_count=-1) + simplification_pipeline.add_pass(HloPass.ZeroSizedHloElimination()) + simplification_pipeline.add_pass( + HloPass.GatherExpander( + HloPass.GatherExpander.Mode.kEliminateSimpleGathers + ) + ) + simplification_pipeline.add_pass( + HloPass.ScatterExpander( + HloPass.ScatterExpander.Mode.kEliminateSimpleScatters + ) + ) + algebraic_config_options = { + "replace_transpose_with_bitcast": False, + "minmax_propagate_nan": debug_options.xla_gpu_enable_fast_min_max, + } + if (GpuBackend.stream_exec_platform == "ROCM"): + algebraic_config_options["enable_conv_operand_swap"] = False + + simplification_pipeline.add_pass( + HloPass.AlgebraicSimplifier(options=algebraic_config_options) + ) + + simplification_pipeline.add_pass(HloPass.BitcastDtypesExpander()) + simplification_pipeline.add_pass(HloPass.DotDecomposer()) + simplification_pipeline.add_pass( + HloPass.DotMerger(max_size_to_merge=16 << 20) + ) + simplification_pipeline.add_pass(HloPass.SortSimplifier()) + simplification_pipeline.add_pass(HloPass.TupleSimplifier()) + simplification_pipeline.add_pass(HloPass.WhileLoopConstantSinking()) + simplification_pipeline.add_pass(HloPass.WhileLoopSimplifier()) + simplification_pipeline.add_pass(HloPass.ReshapeMover()) + simplification_pipeline.add_pass(HloPass.HloConstantFolding()) + simplification_pipeline.add_pass(HloPass.ConditionalSimplifier()) + simplification_pipeline.add_pass(HloPass.RealImagExpander()) + simplification_pipeline.add_pass(HloPass.TransposeFolding()) + simplification_pipeline.add_pass(HloPass.HloCSE(is_layout_sensitive=False)) + simplification_pipeline.add_pass(HloPass.HloDCE()) + optimization_pipeline.add_pass(simplification_pipeline) + + # Run WhileLoopTripCountAnnotator at the end of the simplification + # pipeline, before layout assignment and fusion. This pass does some + # pattern-matching on while bodies/conditions, and this is where the HLO is + # "nicest". + # + # It's important that we don't make semantic changes (e.g. unrolling) to + # any `while` loops after this point, because otherwise the trip-count + # annotations added by this pass may not be correct after the + # modifications. + optimization_pipeline.add_pass(HloPass.WhileLoopTripCountAnnotator()) + # pre_fusion_pipeline.add_pass(optmiization_pipeline) + self.pre_fusion_optimizations.add_pass(optimization_pipeline) + + # -------------------------------------------- + # Collectives Pipeline + # -------------------------------------------- + + collectives_pipeline = Pipeline("collective-optimizations") + collectives_pipeline.add_pass(HloPass.AllReduceFolder()) + collectives_pipeline.add_pass(HloPass.ReduceScatterCreator()) + collectives_pipeline.add_pass(HloPass.AllReduceReassociate()) + algebraic_config_options = { + "replace_transpose_with_bitcast": False, + "enable_conv_operand_swap": False, + "minmax_propagate_nan": debug_options.xla_gpu_enable_fast_min_max, + } + collectives_pipeline.add_pass( + HloPass.AlgebraicSimplifier(options=algebraic_config_options) + ) + collectives_pipeline.add_pass(HloPass.AllGatherBroadcastReorder()) + self.pre_fusion_optimizations.add_pass(collectives_pipeline) + + # -------------------------------------------- + # Convolution Canonicalization Pipeline + # -------------------------------------------- + + # TODO(ohcy): Account for AMD GPU case + # Note, this is specific to Nvidia GPUs. For AMD GPUs, some of the passes, + # e.g. Cudnn passes should be excluded + conv_canon_pipeline = Pipeline("conv-canonicalization") + conv_canon_pipeline.add_pass(HloPass.GpusolverRewriter()) + conv_canon_pipeline.add_pass(HloPass.GpuConvRewriter()) + conv_canon_pipeline.add_pass(HloPass.CudnnFusedConvRewriter()) + conv_canon_pipeline.add_pass(HloPass.GpuConvPaddingLegalization()) + conv_canon_pipeline.add_pass(HloPass.CudnnPadForConvolutions()) + conv_canon_pipeline.add_pass(HloPass.CudnnVectorizeConvolutions()) + conv_canon_pipeline.add_pass(HloPass.CallInliner()) + conv_canon_pipeline.add_pass(HloPass.TupleSimplifier()) + algebraic_config_options = { + "replace_transpose_with_bitcast": False, + "enable_conv_operand_swap": False, + } + conv_canon_pipeline.add_pass( + HloPass.AlgebraicSimplifier(options=algebraic_config_options), + loop_count=-1 + ) + conv_canon_pipeline.add_pass(HloPass.HloConstantFolding()) + self.pre_fusion_optimizations.add_pass(conv_canon_pipeline) + + # -------------------------------------------- + # Layout Assignment Pipeline + # -------------------------------------------- + + layout_assignment_pipeline = Pipeline("layout-assignment") + layout_assignment_pipeline.add_pass(HloPass.FlattenCallGraph()) + layout_assignment_pipeline.add_pass( + HloPass.GpuLayoutAssignment(hlo_module) + ) + self.pre_fusion_optimizations.add_pass(layout_assignment_pipeline) + + # -------------------------------------------- + # Post Layout Assignment Pipeline + # -------------------------------------------- + + # ******************* + # NVIDIA GPU Specific Passes Stage 1 - START + post_layout_ass_pipeline_nv_pre = Pipeline("post-layout-assignment-nv-pre") + if (GpuBackend.cuda_is_at_least(GpuBackend.CudaComputeCapability.AMPERE)): + post_layout_ass_pipeline_nv_pre.add_pass( + HloPass.CublasPadForGemms( + datatype=HloPass.CublasPadForGemms.PrimitiveType.BF16, + pad_to_multiple_of=8 + ) + ) + + if (GpuBackend.cuda_is_at_least(GpuBackend.CudaComputeCapability.VOLTA)): + post_layout_ass_pipeline_nv_pre.add_pass( + HloPass.CublasPadForGemms( + datatype=HloPass.CublasPadForGemms.PrimitiveType.S8, + pad_to_multiple_of=4 + ) + ) + post_layout_ass_pipeline_nv_pre.add_pass( + HloPass.CublasPadForGemms( + datatype=HloPass.CublasPadForGemms.PrimitiveType.F16, + pad_to_multiple_of=8 + ) + ) + + post_layout_ass_pipeline_nv_pre.add_pass(HloPass.HloConstantFolding()) + # NVIDIA GPU Specific Passes Stage 1 - END + # ******************* + + post_layout_ass_pipeline = Pipeline("post-layout-assignment") + post_layout_ass_pipeline.add_pass(HloPass.ReductionDegenerateDimRemover()) + post_layout_ass_pipeline.add_pass(HloPass.ReductionLayoutNormalizer()) + post_layout_ass_pipeline.add_pass(HloPass.ReductionDimensionGrouper()) + post_layout_ass_pipeline.add_pass( + HloPass.ReductionSplitter(), loop_count=-1 + ) + post_layout_ass_pipeline.add_pass( + HloPass.GpuTreeReductionRewriter(), loop_count=-1 + ) + + algebraic_config_options = { + "is_layout_sensitive": True, + "replace_transpose_with_bitcast": False, + "enable_conv_operand_swap": False, + "minmax_propagate_nan": debug_options.xla_gpu_enable_fast_min_max, + } + post_layout_ass_pipeline.add_pass( + HloPass.AlgebraicSimplifier(algebraic_config_options), loop_count=-1 + ) + post_layout_ass_pipeline.add_pass(HloPass.TransposeFolding()) + post_layout_ass_pipeline.add_pass(HloPass.GemmRewriter()) + post_layout_ass_pipeline.add_pass(HloPass.GemmBroadcastFoldingRewriter()) + post_layout_ass_pipeline.add_pass(HloPass.BFloat16Normalization(False)) + post_layout_ass_pipeline.add_pass(HloPass.GpuConvAlgorithmPicker()) + post_layout_ass_pipeline.add_pass(HloPass.TupleSimplifier()) + post_layout_ass_pipeline.add_pass(HloPass.HloCSE(True)) + + # ******************* + # NVIDIA GPU Specific Passes Stage 2 - START + post_layout_ass_pipeline_nv_post = Pipeline( + "post-layout-assignment-nv-post" + ) + + post_layout_ass_pipeline_nv_post.add_pass(HloPass.GemmAlgorithmPicker()) + if (hlo_module.is_bef_enabled): + post_layout_ass_pipeline_nv_post.add_pass( + HloPass.TriangularSolveRewriter() + ) + # NVIDIA GPU Specific Passes Stage 2 - END + # ******************* + + self.pre_fusion_optimizations.add_pass(post_layout_ass_pipeline_nv_pre) + self.pre_fusion_optimizations.add_pass(post_layout_ass_pipeline) + self.pre_fusion_optimizations.add_pass(post_layout_ass_pipeline_nv_post) + + # ----------------------------------------------------------------------- + # FUSION PIPELINE + # ----------------------------------------------------------------------- + + # -------------------------------------------- + # Original Vertical Fusion Pipeline + # -------------------------------------------- + + self.vert_fusion_pipeline = Pipeline("vertical-fusion", loop_count=-1) + self.vert_fusion_pipeline.add_pass(HloPass.VariadicOpSplitter()) + self.vert_fusion_pipeline.add_pass(HloPass.GpuInstructionFusion(False)) + self.vert_fusion_pipeline.add_pass(HloPass.GpuInstructionFusion(True)) + self.vert_fusion_pipeline.add_pass(HloPass.FusionMerger()) + self.vert_fusion_pipeline.add_pass(HloPass.GpuMultiOutputFusion()) + self.vert_fusion_pipeline.add_pass(HloPass.HloCSE(True, True)) + self.vert_fusion_pipeline.add_pass(HloPass.HloDCE()) + + # -------------------------------------------- + # Vertical Fusion Pipeline + # -------------------------------------------- + + self.fusion_pipeline_pre = Pipeline("fusion-pre") + self.fusion_pipeline_pre.add_pass(HloPass.VariadicOpSplitter()) + + self.fusion_dry_pass = AltPipeline( + Pass( + HloPass.GpuInstructionFusion(True), # may_duplicate + ) + ) + + self.fusion_pipeline_post = Pipeline("fusion-post") + self.fusion_pipeline_post.add_pass(HloPass.FusionMerger()) + self.fusion_pipeline_post.add_pass(HloPass.GpuMultiOutputFusion()) + self.fusion_pipeline_post.add_pass(HloPass.HloCSE(True, True)) + self.fusion_pipeline_post.add_pass(HloPass.HloDCE()) + + # -------------------------------------------- + # Horizontal Fusion Pipeline + # -------------------------------------------- + self.post_fusion_optimizations = Pipeline("post-fusion-optimizations") + + hori_fusion_pipeline = Pipeline("horizontal-fusion", loop_count=-1) + hori_fusion_pipeline.add_pass(HloPass.GpuHorizontalLoopFusion()) + hori_fusion_pipeline.add_pass(HloPass.GpuHorizontalInputFusion()) + hori_fusion_pipeline.add_pass(HloPass.HloCSE(True, True)) + hori_fusion_pipeline.add_pass(HloPass.HloDCE()) + + self.post_fusion_optimizations.add_pass(hori_fusion_pipeline) + # ----------------------------------------------------------------------- + # POST PIPELINE + # ----------------------------------------------------------------------- + + post_fusion_pipeline = Pipeline("post-fusion") + + post_fusion_pipeline.add_pass( + HloPass.AllGatherCombiner( + combine_threshold_in_bytes=1024 * 1024 * 1024, + combine_threshold_count=256 + ) + ) + post_fusion_pipeline.add_pass( + HloPass.AllReduceCombiner( + combine_threshold_in_bytes=debug_options + .xla_gpu_all_reduce_combine_threshold_bytes, + combine_threshold_count=256 + ) + ) + post_fusion_pipeline.add_pass( + HloPass.ReduceScatterCombiner( + combine_threshold_in_bytes=30 * 1024 * 1024, + combine_threshold_count=256 + ) + ) + + if debug_options.xla_gpu_all_reduce_contiguous: + post_fusion_pipeline.add_pass(HloPass.AllReduceContiguous()) + + blueconnect_num_devices_per_host = debug_options.xla_gpu_all_reduce_blueconnect_num_devices_per_host + if (blueconnect_num_devices_per_host > 0): + post_fusion_pipeline.add_pass( + HloPass.AllReduceBlueConnect(blueconnect_num_devices_per_host) + ) + + if debug_options.xla_gpu_enable_async_all_reduce: + post_fusion_pipeline.add_pass(HloPass.AsyncCollectiveCreator()) + + post_fusion_pipeline.add_pass(HloPass.CollectivesScheduleLinearizer()) + algebraic_config_options = { + "is_layout_sensitive": True, + "replace_transpose_with_bitcast": False, + "enable_conv_operand_swap": False, + "minmax_propagate_nan": debug_options.xla_gpu_enable_fast_min_max, + } + post_fusion_pipeline.add_pass( + HloPass.AlgebraicSimplifier(algebraic_config_options) + ) + post_fusion_pipeline.add_pass(HloPass.OptimizationBarrierExpander()) + post_fusion_pipeline.add_pass(HloPass.TupleSimplifier()) + + self.post_fusion_optimizations.add_pass(post_fusion_pipeline) + + self.xla_pipeline = Pipeline("xla-pipeline") + self.xla_pipeline.add_pass(self.pre_fusion_optimizations) + self.xla_pipeline.add_pass(self.vert_fusion_pipeline) + self.xla_pipeline.add_pass(self.post_fusion_optimizations) + # ------------------------------------------- + + @property + def pre_pass_optimizations(self): + return self.pre_fusion_optimizations + + @property + def post_pass_optimizations(self): + return self.post_fusion_optimizations + + @property + def pre_dry_pass_passes(self): + return self.fusion_pipeline_pre + + @property + def post_dry_pass_passes(self): + return self.fusion_pipeline_post + + @property + def xla_passes(self): + return self.xla_pipeline + + @property + def pass_dry_run(self): + return self.fusion_dry_pass + + +class GeneralFusionPipeline(SingleFusionPipeline): + + def __init__(self, hlo_ir: HloEnv) -> None: + super(GeneralFusionPipeline, self).__init__(hlo_ir) + + self.fusion_dry_pass = AltPipeline(Pass(HloPass.GeneralFusion(),)) + self.fusion_pipeline_post = Pipeline("post-general-fusion") + # self.fusion_pipeline_post.add_pass(HloPass.GpuMultiOutputFusion()) + self.fusion_pipeline_post.add_pass(HloPass.HloCSE(True, True)) + self.fusion_pipeline_post.add_pass(HloPass.HloDCE()) diff --git a/third_party/pip_requirements/BUILD b/third_party/pip_requirements/BUILD new file mode 100755 index 0000000..eb91a95 --- /dev/null +++ b/third_party/pip_requirements/BUILD @@ -0,0 +1,3 @@ +package(default_visibility = ["//visibility:public"]) + +exports_files(["requirements.txt"]) diff --git a/third_party/pip_requirements/requirements.txt b/third_party/pip_requirements/requirements.txt new file mode 100755 index 0000000..1e9e9cd --- /dev/null +++ b/third_party/pip_requirements/requirements.txt @@ -0,0 +1 @@ +tensorflow==2.9.0 diff --git a/third_party/tensorflow/BUILD b/third_party/tensorflow/BUILD new file mode 100644 index 0000000..e69de29 diff --git a/third_party/tensorflow/org_tensorflow_hloenv.patch b/third_party/tensorflow/org_tensorflow_hloenv.patch new file mode 100644 index 0000000..6b66d72 --- /dev/null +++ b/third_party/tensorflow/org_tensorflow_hloenv.patch @@ -0,0 +1,4486 @@ +diff --git a/WORKSPACE b/WORKSPACE +deleted file mode 100644 +index 1286ef9ac03..00000000000 +--- a/WORKSPACE ++++ /dev/null +@@ -1,23 +0,0 @@ +-workspace(name = "org_tensorflow") +- +-# Initialize the TensorFlow repository and all dependencies. +-# +-# The cascade of load() statements and tf_workspace?() calls works around the +-# restriction that load() statements need to be at the top of .bzl files. +-# E.g. we can not retrieve a new repository with http_archive and then load() +-# a macro from that repository in the same file. +-load("@//tensorflow:workspace3.bzl", "tf_workspace3") +- +-tf_workspace3() +- +-load("@//tensorflow:workspace2.bzl", "tf_workspace2") +- +-tf_workspace2() +- +-load("@//tensorflow:workspace1.bzl", "tf_workspace1") +- +-tf_workspace1() +- +-load("@//tensorflow:workspace0.bzl", "tf_workspace0") +- +-tf_workspace0() +diff --git a/passes.txt b/passes.txt +new file mode 100644 +index 00000000000..b1fd72d56f1 +--- /dev/null ++++ b/passes.txt +@@ -0,0 +1,62 @@ ++algsimp ++all-gather-bcast-reorder ++all-reduce-folder ++all-reduce-reassociate ++all_to_all_decomposer ++batchnorm_expander ++bf16-normalization ++bitcast_dtypes_expander ++CallInliner ++comparison-expander ++conditional canonicalizer ++constant_folding ++convolution_4d_expander ++cse ++cublas-gemm-broadcast-folding-rewriter ++cublas-gemm-rewriter ++cublas-pad-for-gemms ++cudnn-fused-convolution-rewriter ++cudnn_pad_for_convolutions ++cudnn_vectorize_convolutions ++dce ++dot_decomposer ++dot-merger ++dynamic dimension simplifier ++dynamic-index-splitter ++dynamic_padder ++eigh_expander ++flatten-call-graph ++fusion ++fusion_merger ++gather_expander ++gemm-algorithm-picker ++gpu-conv-algorithm-picker ++gpu-conv-padding-legalization ++gpu-conv-rewriter ++gpu_scatter_expander ++gpusolver-rewriter ++layout-assignment ++logistic-expander ++multi_output_fusion ++operand_upcaster ++qr_expander ++real_imag_expander ++reduce-scatter-creator ++reduction-degenerate-dim-remover ++reduction-dimension-grouper ++reduction-layout-normalizer ++reshape-mover ++result_caster ++rng-bit-generator-expander ++rng-expander ++scatter_expander ++simplify-conditional ++simplify-sorts ++simplify-while-loops ++stable-sort-expander ++transpose-folding ++tuple-simplifier ++variadic-op-splitter ++while-loop-constant-sinking ++while-loop-trip-count-annotator ++zero_sized_hlo_elimination +diff --git a/tensorflow/compiler/xla/BUILD b/tensorflow/compiler/xla/BUILD +index 364111160f2..35c628af43b 100644 +--- a/tensorflow/compiler/xla/BUILD ++++ b/tensorflow/compiler/xla/BUILD +@@ -156,7 +156,7 @@ cc_library( + name = "types", + hdrs = ["types.h"], + compatible_with = get_compatible_with_portable(), +- visibility = [":friends"], ++ visibility = ["//visibility:public"], + deps = [ + "//third_party/eigen3", + ], +@@ -549,7 +549,7 @@ cc_library( + name = "literal_comparison", + srcs = ["literal_comparison.cc"], + hdrs = ["literal_comparison.h"], +- visibility = [":friends"], ++ visibility = ["//visibility:public"], + deps = [ + ":error_spec", + ":literal", +diff --git a/tensorflow/compiler/xla/client/local_client.h b/tensorflow/compiler/xla/client/local_client.h +index a0ff1ced9c1..2d649c164cf 100644 +--- a/tensorflow/compiler/xla/client/local_client.h ++++ b/tensorflow/compiler/xla/client/local_client.h +@@ -141,6 +141,7 @@ class LocalClient : public Client { + // + // The given ExecutableBuildOptions overrides any values from XLA_FLAGS + // environment variable. ++ // MARK: compilation call chain + StatusOr>> Compile( + const XlaComputation& computation, + const absl::Span argument_layouts, +diff --git a/tensorflow/compiler/xla/pjrt/BUILD b/tensorflow/compiler/xla/pjrt/BUILD +index 97417b3ad93..0705d4c144a 100644 +--- a/tensorflow/compiler/xla/pjrt/BUILD ++++ b/tensorflow/compiler/xla/pjrt/BUILD +@@ -136,7 +136,7 @@ cc_library( + name = "pjrt_client", + srcs = ["pjrt_client.cc"], + hdrs = ["pjrt_client.h"], +- visibility = ["//tensorflow/compiler/xla:friends"], ++ visibility = ["//visibility:public"], + deps = [ + ":pjrt_future", + "//tensorflow/compiler/xla:literal", +@@ -309,7 +309,7 @@ cc_library( + srcs = ["cpu_device.cc"], + hdrs = ["cpu_device.h"], + compatible_with = [], +- visibility = [":friends"], ++ visibility = ["//visibility:public"], + deps = [ + ":pjrt_stream_executor_client", + "//tensorflow/compiler/xla:statusor", +@@ -325,7 +325,7 @@ cc_library( + srcs = ["gpu_device.cc"], + hdrs = ["gpu_device.h"], + defines = if_cuda(["GOOGLE_CUDA=1"]) + if_rocm(["TENSORFLOW_USE_ROCM=1"]), +- visibility = [":friends"], ++ visibility = ["//visibility:public"], + deps = [ + ":pjrt_stream_executor_client", + "@com_google_absl//absl/base:core_headers", +diff --git a/tensorflow/compiler/xla/pjrt/pjrt_client.h b/tensorflow/compiler/xla/pjrt/pjrt_client.h +index d2274a1fd7b..a2cc93dd832 100644 +--- a/tensorflow/compiler/xla/pjrt/pjrt_client.h ++++ b/tensorflow/compiler/xla/pjrt/pjrt_client.h +@@ -857,6 +857,9 @@ struct CompiledMemoryStats { + // when passed to the execution. + class PjRtExecutable { + public: ++ mutable uint64_t compute_time_ns = 0; ++ mutable uint64_t async_exec_time_ns = 0; ++ + virtual ~PjRtExecutable() = default; + + virtual PjRtClient* client() const = 0; +diff --git a/tensorflow/compiler/xla/pjrt/pjrt_stream_executor_client.cc b/tensorflow/compiler/xla/pjrt/pjrt_stream_executor_client.cc +index b0e31850d43..df74a1f4755 100644 +--- a/tensorflow/compiler/xla/pjrt/pjrt_stream_executor_client.cc ++++ b/tensorflow/compiler/xla/pjrt/pjrt_stream_executor_client.cc +@@ -1982,6 +1982,7 @@ StatusOr PjRtStreamExecutorExecutable::EnqueueExecution( + argument_handles, *device_buffers, events)); + + ExecutableRunOptions run_options; ++ ExecutionProfile exec_profile; + run_options.set_stream(device_state->compute_stream()); + run_options.set_host_to_device_stream(device_state->host_to_device_stream()); + run_options.set_allocator(client_->allocator()); +@@ -1992,6 +1993,7 @@ StatusOr PjRtStreamExecutorExecutable::EnqueueExecution( + run_options.set_rng_seed(device_state->GetNewPrngSeed()); + run_options.set_gpu_executable_run_options(client_->gpu_run_options()); + run_options.set_launch_id(options.launch_id); ++ run_options.set_execution_profile(&exec_profile); + if (run_options.launch_id() != 0) { + VLOG(3) << "launch id for " << name() << ": " << run_options.launch_id(); + } +@@ -2008,9 +2010,12 @@ StatusOr PjRtStreamExecutorExecutable::EnqueueExecution( + device_state->compute_semaphore().ScopedAcquire(1)); + } + ++ uint64_t start_time_ns = tensorflow::Env::Default()->NowNanos(); + StatusOr result_buffer_or_status = +- executables_[executable_idx]->RunAsync(std::move(execution_inputs), +- run_options); ++ executables_[executable_idx]->Run(std::move(execution_inputs), ++ run_options); ++ compute_time_ns = run_options.execution_profile()->compute_time_ns(); ++ async_exec_time_ns = tensorflow::Env::Default()->NowNanos() - start_time_ns; + + VLOG(1) << "Replica " << replica << " partition " << partition + << " completed; ok=" << result_buffer_or_status.ok(); +@@ -2454,6 +2459,7 @@ PjRtStreamExecutorClient::GetExecutableExtras(CompileOptions* options) { + return extras; + } + ++// MARK: compilation call chain + StatusOr> PjRtStreamExecutorClient::Compile( + const XlaComputation& computation, CompileOptions options) { + tensorflow::profiler::TraceMe traceme("PjRtStreamExecutorClient::Compile"); +diff --git a/tensorflow/compiler/xla/python/BUILD b/tensorflow/compiler/xla/python/BUILD +index c62f94be19e..7e68f283983 100644 +--- a/tensorflow/compiler/xla/python/BUILD ++++ b/tensorflow/compiler/xla/python/BUILD +@@ -147,6 +147,7 @@ cc_library( + "@pybind11", + "@pybind11_abseil//pybind11_abseil:absl_casters", + ], ++ visibility = ["//visibility:public"], + ) + + cc_library( +diff --git a/tensorflow/compiler/xla/service/BUILD b/tensorflow/compiler/xla/service/BUILD +index bfd1014a694..4107ff5e203 100644 +--- a/tensorflow/compiler/xla/service/BUILD ++++ b/tensorflow/compiler/xla/service/BUILD +@@ -551,6 +551,7 @@ cc_library( + "hlo_module_metadata.h", + "hlo_op_metadata.h", + "hlo_opcode.h", ++ "hlo_reachability.h", + "hlo_schedule.h", + "hlo_sharding.h", + "hlo_sharding_metadata.h", +@@ -588,6 +589,7 @@ cc_library( + "@com_google_absl//absl/types:optional", + "@com_google_absl//absl/types:span", + ], ++ visibility = ["//visibility:public"], + ) + + cc_library( +@@ -1086,6 +1088,7 @@ cc_library( + name = "service", + srcs = ["service.cc"], + hdrs = ["service.h"], ++ visibility = ["//visibility:public"], + deps = [ + ":allocation_tracker", + ":backend", +@@ -1981,6 +1984,17 @@ cc_library( + ], + ) + ++cc_library( ++ name = "dry_mode", ++ srcs = ["dry_mode.cc"], ++ hdrs = ["dry_mode.h"], ++ deps = [ ++ ":hlo", ++ ":hlo_creation_utils", ++ ":hlo_pass", ++ ], ++) ++ + cc_library( + name = "gather_expander", + srcs = ["gather_expander.cc"], +@@ -4630,6 +4644,7 @@ cc_library( + ], + deps = [ + ":compilation_stats", ++ ":dry_mode", + ":dump", + ":hlo", + ":hlo_graph_dumper", +@@ -4640,12 +4655,14 @@ cc_library( + "//tensorflow/compiler/xla:types", + "//tensorflow/compiler/xla:util", + "//tensorflow/core:lib", ++ "//tensorflow/core/util:env_var", + "@com_google_absl//absl/container:flat_hash_map", + "@com_google_absl//absl/container:flat_hash_set", + "@com_google_absl//absl/memory", + "@com_google_absl//absl/strings", + "@com_google_absl//absl/strings:str_format", + ], ++ visibility = ["//visibility:public"], + ) + + tf_cc_test( +diff --git a/tensorflow/compiler/xla/service/bfloat16_normalization.h b/tensorflow/compiler/xla/service/bfloat16_normalization.h +index 3c4e7f641e4..870a1419d2a 100644 +--- a/tensorflow/compiler/xla/service/bfloat16_normalization.h ++++ b/tensorflow/compiler/xla/service/bfloat16_normalization.h +@@ -32,6 +32,7 @@ class BFloat16Normalization : public HloModulePass { + + ~BFloat16Normalization() override = default; + absl::string_view name() const override { return "bf16-normalization"; } ++ const BFloat16Support* bfloat16_support() { return bfloat16_support_; } + + // Run BF16 normalization on the given computation. Returns whether the + // computation was changed. +diff --git a/tensorflow/compiler/xla/service/compiler.h b/tensorflow/compiler/xla/service/compiler.h +index 5ec03f07f87..2ee74ef0f3d 100644 +--- a/tensorflow/compiler/xla/service/compiler.h ++++ b/tensorflow/compiler/xla/service/compiler.h +@@ -359,6 +359,21 @@ class Compiler { + GetPlatformCompilers(); + }; + ++template ++class Intercept : public std::exception { ++ public: ++ Intercept() {} ++ Intercept(XlaCompiler* c, std::unique_ptr m, ++ se::StreamExecutor* s, const Compiler::CompileOptions& o) ++ : compiler(c), module(std::move(m)), stream_exec(s), options(o) {} ++ Intercept(XlaCompiler* c, std::unique_ptr m) ++ : compiler(c), module(std::move(m)) {} ++ XlaCompiler* compiler; ++ std::unique_ptr module; ++ se::StreamExecutor* stream_exec; ++ Compiler::CompileOptions options; ++}; ++ + } // namespace xla + + #endif // TENSORFLOW_COMPILER_XLA_SERVICE_COMPILER_H_ +diff --git a/tensorflow/compiler/xla/service/cpu/cpu_compiler.cc b/tensorflow/compiler/xla/service/cpu/cpu_compiler.cc +index 64f44245a4b..700ee1afcde 100644 +--- a/tensorflow/compiler/xla/service/cpu/cpu_compiler.cc ++++ b/tensorflow/compiler/xla/service/cpu/cpu_compiler.cc +@@ -777,6 +777,8 @@ Status CreateHloProfilingArtifacts( + StatusOr> CpuCompiler::RunHloPasses( + std::unique_ptr module, se::StreamExecutor* /*stream_exec*/, + const CompileOptions& /*options*/) { ++ throw Intercept(this, std::move(module)); // This is where we handover control ++ + std::unique_ptr jit_target_machine = + SimpleOrcJIT::InferTargetMachineForJIT( + CompilerTargetOptions(module->config()), +diff --git a/tensorflow/compiler/xla/service/dfs_hlo_visitor.h b/tensorflow/compiler/xla/service/dfs_hlo_visitor.h +index 6849149c74b..2913ea780a3 100644 +--- a/tensorflow/compiler/xla/service/dfs_hlo_visitor.h ++++ b/tensorflow/compiler/xla/service/dfs_hlo_visitor.h +@@ -291,6 +291,8 @@ class DfsHloVisitorBase { + virtual Status HandleAddDependency(HloInstructionPtr add_dependency) = 0; + virtual Status HandleAfterAll(HloInstructionPtr token) = 0; + ++ virtual Status HandleAlternatives(HloInstructionPtr alternatives) = 0; ++ + // Invoked to inform the visitor that the traversal has completed, and that + // the root was "root". + virtual Status FinishVisit(HloInstructionPtr root) = 0; +diff --git a/tensorflow/compiler/xla/service/dfs_hlo_visitor_with_default.h b/tensorflow/compiler/xla/service/dfs_hlo_visitor_with_default.h +index 55e9d83e565..beec11f9685 100644 +--- a/tensorflow/compiler/xla/service/dfs_hlo_visitor_with_default.h ++++ b/tensorflow/compiler/xla/service/dfs_hlo_visitor_with_default.h +@@ -274,7 +274,9 @@ class DfsHloVisitorWithDefaultBase + Status HandleAddDependency(HloInstructionPtr add_dependency) override { + return DefaultAction(add_dependency); + } +- ++ Status HandleAlternatives(HloInstructionPtr alternatives) override { ++ return DefaultAction(alternatives); ++ } + // Invoked to inform the visitor that the traversal has completed, and that + // the root was "root". + Status FinishVisit(HloInstructionPtr /*root*/) override { +diff --git a/tensorflow/compiler/xla/service/dry_mode.cc b/tensorflow/compiler/xla/service/dry_mode.cc +new file mode 100644 +index 00000000000..2e713146296 +--- /dev/null ++++ b/tensorflow/compiler/xla/service/dry_mode.cc +@@ -0,0 +1,50 @@ ++#include "tensorflow/compiler/xla/service/dry_mode.h" ++ ++#include ++#include ++#include ++ ++#include "tensorflow/compiler/xla/service/hlo_instructions.h" ++ ++namespace xla { ++ ++StatusOr DryModeOn::Run(HloModule* module) { ++ for (HloComputation* computation : module->MakeNonfusionComputations()) { ++ computation->set_dry(true); ++ } ++ return false; ++} ++ ++StatusOr DryModeOff::Run(HloModule* module) { ++ bool changed = false; ++ for (HloComputation* computation : module->MakeNonfusionComputations()) { ++ computation->set_dry(false); ++ } ++ // std::cout << module->ToString() << std::endl; ++ for (auto* comp : module->MakeNonfusionComputations()) { ++ std::cout << comp->ToString() << std::endl; ++ } ++ std::random_device device; ++ std::mt19937 generator(device()); ++ for (HloComputation* computation : module->MakeNonfusionComputations()) { ++ int num_replace = 0; ++ for (HloInstruction* inst : computation->instructions()) { ++ std::uniform_int_distribution rand_selection( ++ 0, inst->operand_count() - 1); ++ if (inst->opcode() == HloOpcode::kAlternatives) { ++ // Select a random index for alternatives ++ static_cast(inst)->Select(rand_selection(generator)); ++ num_replace++; ++ } ++ } ++ if (num_replace > 0) { ++ changed = true; ++ LOG(ERROR) << num_replace << " alternatives replaced"; ++ } ++ // Remove the residues ++ computation->Prune(); ++ } ++ return changed; ++} ++ ++} // namespace xla +diff --git a/tensorflow/compiler/xla/service/dry_mode.h b/tensorflow/compiler/xla/service/dry_mode.h +new file mode 100644 +index 00000000000..dce899c69c9 +--- /dev/null ++++ b/tensorflow/compiler/xla/service/dry_mode.h +@@ -0,0 +1,40 @@ ++/* Copyright 2018 The TensorFlow Authors. All Rights Reserved. ++ ++Licensed under the Apache License, Version 2.0 (the "License"); ++you may not use this file except in compliance with the License. ++You may obtain a copy of the License at ++ ++ http://www.apache.org/licenses/LICENSE-2.0 ++ ++Unless required by applicable law or agreed to in writing, software ++distributed under the License is distributed on an "AS IS" BASIS, ++WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++See the License for the specific language governing permissions and ++limitations under the License. ++==============================================================================*/ ++ ++#ifndef TENSORFLOW_COMPILER_XLA_SERVICE_DRYRUN_H_ ++#define TENSORFLOW_COMPILER_XLA_SERVICE_DRYRUN_H_ ++ ++#include "tensorflow/compiler/xla/service/hlo_computation.h" ++#include "tensorflow/compiler/xla/service/hlo_pass_interface.h" ++ ++namespace xla { ++ ++class DryModeOn : public HloModulePass { ++ public: ++ absl::string_view name() const override { return "dry-mode-on"; } ++ explicit DryModeOn() {} ++ StatusOr Run(HloModule* module) override; ++}; ++ ++class DryModeOff : public HloModulePass { ++ public: ++ absl::string_view name() const override { return "dry-mode-off"; } ++ explicit DryModeOff() {} ++ StatusOr Run(HloModule* module) override; ++}; ++ ++} // namespace xla ++ ++#endif // TENSORFLOW_COMPILER_XLA_SERVICE_DRYRUN_H_ +diff --git a/tensorflow/compiler/xla/service/gpu/BUILD b/tensorflow/compiler/xla/service/gpu/BUILD +index 4280b3bf5cf..c4964f6d24a 100644 +--- a/tensorflow/compiler/xla/service/gpu/BUILD ++++ b/tensorflow/compiler/xla/service/gpu/BUILD +@@ -1275,6 +1275,27 @@ tf_cc_test( + ], + ) + ++cc_library( ++ name = "general_fusion", ++ srcs = ["general_fusion.cc"], ++ hdrs = ["general_fusion.h"], ++ deps = [ ++ ":gpu_fusible", ++ ":instruction_fusion", ++ ":ir_emission_utils", ++ "//tensorflow/compiler/xla:shape_util", ++ "//tensorflow/compiler/xla:util", ++ "//tensorflow/compiler/xla/service:hlo", ++ "//tensorflow/compiler/xla/service:hlo_cost_analysis", ++ "//tensorflow/compiler/xla/service:hlo_graph_dumper", ++ "//tensorflow/compiler/xla/service:hlo_pass", ++ "//tensorflow/compiler/xla/service/llvm_ir:fused_ir_emitter", ++ "//tensorflow/core:lib", ++ "@com_google_absl//absl/algorithm:container", ++ "@com_google_absl//absl/strings", ++ ], ++) ++ + cc_library( + name = "gpu_conv_padding_legalization", + srcs = ["gpu_conv_padding_legalization.cc"], +@@ -1507,6 +1528,7 @@ cc_library( + name = "gpu_compiler", + srcs = [ + "gpu_compiler.cc", ++ "gpu_compiler_ext.h", + ], + hdrs = [ + "gpu_compiler.h", +@@ -1522,6 +1544,7 @@ cc_library( + ":fusion_merger", + ":gemm_broadcast_folding_rewriter", + ":gemm_rewriter", ++ ":general_fusion", + ":gpu_constants", + ":gpu_conv_algorithm_picker", + ":gpu_conv_rewriter", +@@ -1660,6 +1683,7 @@ cc_library( + ], + "//conditions:default": [], + }), ++ visibility = ["//visibility:public"], + ) + + cc_library( +diff --git a/tensorflow/compiler/xla/service/gpu/general_fusion.cc b/tensorflow/compiler/xla/service/gpu/general_fusion.cc +new file mode 100644 +index 00000000000..0d1dba67b51 +--- /dev/null ++++ b/tensorflow/compiler/xla/service/gpu/general_fusion.cc +@@ -0,0 +1,450 @@ ++/* Copyright 2022 The TensorFlow Authors. All Rights Reserved. ++ ++Licensed under the Apache License, Version 2.0 (the "License"); ++you may not use this file except in compliance with the License. ++You may obtain a copy of the License at ++ ++ http://www.apache.org/licenses/LICENSE-2.0 ++ ++Unless required by applicable law or agreed to in writing, software ++distributed under the License is distributed on an "AS IS" BASIS, ++WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++See the License for the specific language governing permissions and ++limitations under the License. ++==============================================================================*/ ++ ++#include "tensorflow/compiler/xla/service/gpu/general_fusion.h" ++ ++#include ++#include ++ ++#include "absl/algorithm/container.h" ++#include "absl/container/flat_hash_map.h" ++#include "absl/container/flat_hash_set.h" ++#include "absl/memory/memory.h" ++#include "absl/strings/str_join.h" ++#include "tensorflow/compiler/xla/debug_options_flags.h" ++#include "tensorflow/compiler/xla/map_util.h" ++#include "tensorflow/compiler/xla/service/fusion_queue.h" ++#include "tensorflow/compiler/xla/service/gpu/gpu_fusible.h" ++#include "tensorflow/compiler/xla/service/gpu/instruction_fusion.h" ++#include "tensorflow/compiler/xla/service/gpu/ir_emission_utils.h" ++#include "tensorflow/compiler/xla/service/hlo_cost_analysis.h" ++#include "tensorflow/compiler/xla/service/hlo_dataflow_analysis.h" ++#include "tensorflow/compiler/xla/service/hlo_graph_dumper.h" ++#include "tensorflow/compiler/xla/service/hlo_instruction.h" ++#include "tensorflow/compiler/xla/service/hlo_opcode.h" ++#include "tensorflow/compiler/xla/service/hlo_reachability.h" ++#include "tensorflow/compiler/xla/service/llvm_ir/fused_ir_emitter.h" ++#include "tensorflow/compiler/xla/service/pattern_matcher.h" ++#include "tensorflow/compiler/xla/shape_util.h" ++#include "tensorflow/compiler/xla/util.h" ++#include "tensorflow/core/lib/core/errors.h" ++#include "tensorflow/core/platform/logging.h" ++ ++namespace xla { ++namespace gpu { ++ ++bool IsParameter(const HloInstruction* inst) { ++ return inst->opcode() == HloOpcode::kParameter; ++} ++ ++bool IsFusion(const HloInstruction* inst) { ++ return inst->opcode() == HloOpcode::kFusion; ++} ++ ++bool IsGTE(const HloInstruction* inst) { ++ return inst->opcode() == HloOpcode::kGetTupleElement; ++} ++ ++bool IsTuple(const HloInstruction* inst) { ++ return inst->opcode() == HloOpcode::kTuple; ++} ++ ++bool IsRoot(const HloInstruction* inst) { ++ return inst->parent()->root_instruction() == inst; ++} ++ ++void FuseTwo(HloInstruction* consumer, HloInstruction* producer) { ++ std::unordered_map replacements; ++ std::vector extra; ++ ++ // Create the replacement map ++ // replace parameter with the real external input ++ for (int i = 0; i < producer->operand_count(); ++i) { ++ HloInstruction* operand = producer->mutable_operand(i); ++ if (IsFusion(producer)) { ++ HloComputation* p_comp = producer->fused_instructions_computation(); ++ replacements[p_comp->parameter_instruction(i)] = operand; ++ } ++ } ++ ++ for (int i = 0; i < consumer->operand_count(); ++i) { ++ HloInstruction* operand = consumer->mutable_operand(i); ++ HloInstruction* key; ++ HloInstruction* value; ++ if (IsFusion(consumer)) { ++ HloComputation* c_comp = consumer->fused_instructions_computation(); ++ key = c_comp->parameter_instruction(i); ++ } else { ++ key = operand; ++ } ++ if (!IsGTE(operand)) { // not a GTE ++ if (operand == producer) { ++ if (IsFusion(producer)) { ++ value = producer->fused_expression_root(); ++ } else { ++ value = producer; ++ } ++ } else { ++ value = operand; ++ } ++ } else { // operand is a GTE ++ if (operand->operand(0) == producer) { ++ if (IsFusion(producer)) { ++ // If producer is a fused computation, connect directly without GTE ++ value = producer->fused_expression_root()->mutable_operand( ++ operand->tuple_index()); ++ } else { ++ // when this is an instruction that generates a tuple ++ value = operand; ++ // gte is useful only when the instruction provides a tuple output ++ // but is not fusion ++ extra.push_back(operand); ++ } ++ } else { ++ value = operand; ++ } ++ } ++ if (key != value) { ++ replacements[key] = value; ++ } ++ } ++ ++ std::unordered_map< ++ HloInstruction*, ++ std::unordered_map>> ++ replace_users; ++ // new fusion root ++ std::vector new_fused_root; ++ // indices of the instructions in the new_fusion_root that makes the root of ++ // the computation ++ std::vector root_indices; ++ ++ auto track_external_users = ++ [&](HloInstruction* inst, HloInstruction* to_replace, bool for_producer) { ++ std::vector users; ++ users.reserve(to_replace->user_count()); ++ if (for_producer) { ++ for (auto* u : to_replace->users()) { ++ if (u != consumer && u->dry()) { ++ users.push_back(u); ++ LOG(ERROR) << "inst: " << inst->name() << " user " << u->name(); ++ } ++ } ++ } ++ // keep only external user ++ if (for_producer && !users.empty()) { ++ // Only add to the new root instruction tuple if the shape is ++ // compatible. Since we need to ensure that the output shapes ++ // are consistent. ++ if (ShapesCompatibleForMultiOutputFusion(*inst, *consumer)) { ++ new_fused_root.push_back(inst); ++ replace_users[inst][to_replace] = users; ++ } ++ } else if (!for_producer) { ++ new_fused_root.push_back(inst); ++ std::vector users; ++ std::copy_if(to_replace->users().begin(), to_replace->users().end(), ++ std::back_inserter(users), ++ [](HloInstruction* inst) { return inst->dry(); }); ++ replace_users[inst][to_replace] = users; ++ } ++ }; ++ ++ // replacement for producer ++ auto track_uses = [&](HloInstruction* inst) { ++ bool is_consumer = (inst == consumer); ++ int num_root_inst = new_fused_root.size(); ++ if (IsFusion(inst)) { ++ HloInstruction* root = inst->fused_expression_root(); ++ if (IsTuple(root)) { ++ std::vector not_seen(root->mutable_operands().size(), true); ++ for (auto* gte : inst->users()) { ++ if (!gte->dry()) { ++ continue; ++ } ++ auto* key = root->mutable_operand(gte->tuple_index()); ++ LOG(INFO) << key->name(); ++ track_external_users(key, gte, !is_consumer); ++ not_seen.at(gte->tuple_index()) = false; ++ } ++ ++ // Add back outputs that do not get used ++ for (int i = 0; i < not_seen.size(); i++) { ++ if (not_seen.at(i)) { ++ new_fused_root.push_back(root->mutable_operand(i)); ++ } ++ } ++ ++ } else { ++ LOG(INFO) << root->name(); ++ track_external_users(root, inst, !is_consumer); ++ } ++ } else { ++ LOG(INFO) << inst->name(); ++ track_external_users(inst, inst, !is_consumer); ++ } ++ if (is_consumer) { ++ if (IsRoot(inst)) { ++ root_indices.resize(new_fused_root.size() - num_root_inst); ++ std::iota(root_indices.begin(), root_indices.end(), num_root_inst); ++ } ++ } ++ }; ++ track_uses(producer); ++ track_uses(consumer); ++ for (auto* gte : extra) { ++ track_external_users(gte, gte, true); ++ } ++ CHECK(!new_fused_root.empty()); ++ ++ std::vector post_order; ++ std::unordered_map old_to_new; ++ // put everything in topo order ++ if (IsFusion(producer)) { ++ post_order = ++ producer->fused_instructions_computation()->MakeInstructionPostOrder(); ++ } else { ++ post_order.push_back(producer); ++ } ++ post_order.insert(post_order.end(), extra.begin(), extra.end()); ++ if (IsFusion(consumer)) { ++ auto consumer_comp = ++ consumer->fused_instructions_computation()->MakeInstructionPostOrder(); ++ post_order.insert(post_order.end(), ++ std::make_move_iterator(consumer_comp.begin()), ++ std::make_move_iterator(consumer_comp.end())); ++ } else { ++ post_order.push_back(consumer); ++ } ++ ++ // now clone ++ HloComputation::Builder builder("fuse_two"); ++ int param_index = 0; ++ std::unordered_map extern_to_param; ++ std::vector kfusion_operands; ++ for (auto* inst : post_order) { ++ // don't clone parameter & tuple ++ if (IsParameter(inst) || IsTuple(inst)) { ++ continue; ++ } ++ const auto& operands = inst->operands(); ++ std::vector new_operands; ++ for (auto* operand : operands) { ++ // First find the replacement ++ if (replacements.find(operand) != replacements.end()) { ++ operand = replacements[operand]; ++ } ++ ++ if (old_to_new.find(operand) != old_to_new.end()) { ++ // Then replace with the newly cloned instructions ++ operand = old_to_new[operand]; ++ } else if (extern_to_param.find(operand) != extern_to_param.end()) { ++ // If not found, means it is external instruction, ++ // If a param is already associated with it, reuse the param ++ operand = extern_to_param[operand]; ++ } else { ++ // Otherwise create a new param for it ++ auto* param = builder.AddInstruction(HloInstruction::CreateParameter( ++ param_index, operand->shape(), ++ "param" + std::to_string(param_index))); ++ extern_to_param[operand] = param; ++ kfusion_operands.push_back(operand); ++ operand = param; ++ param_index++; ++ } ++ new_operands.push_back(operand); ++ } ++ old_to_new[inst] = builder.AddInstruction( ++ inst->CloneWithNewOperands(inst->shape(), new_operands)); ++ LOG(INFO) << "Cloning " << inst->name() << " to " ++ << old_to_new[inst]->name(); ++ } ++ ++ HloInstruction* root = nullptr; ++ std::vector tuple_operands; ++ for (auto* inst : new_fused_root) { ++ tuple_operands.push_back(old_to_new[inst]); ++ } ++ if (tuple_operands.size() > 1) { ++ root = builder.AddInstruction(HloInstruction::CreateTuple(tuple_operands)); ++ } else { ++ root = tuple_operands[0]; ++ } ++ HloComputation* comp = ++ producer->parent()->parent()->AddEmbeddedComputation(builder.Build(root)); ++ HloInstruction* fusion = ++ consumer->parent()->AddInstruction(HloInstruction::CreateFusion( ++ root->shape(), ChooseFusionKind(*producer, *consumer), ++ kfusion_operands, comp)); ++ ++ for (int i = 0; i < new_fused_root.size(); ++i) { ++ auto* inst = new_fused_root[i]; ++ for (auto& kv : replace_users[inst]) { ++ auto* to_replace = kv.first; ++ auto& users = kv.second; ++ if (new_fused_root.size() > 1) { ++ HloInstruction* gte = consumer->parent()->AddInstruction( ++ HloInstruction::CreateGetTupleElement(fusion, i)); ++ to_replace->ReplaceUsesWith(users, gte); ++ } else { ++ to_replace->ReplaceUsesWith(users, fusion); ++ } ++ } ++ } ++ ++ if (IsRoot(consumer)) { ++ HloInstruction* new_root = nullptr; ++ if (root_indices.size() == new_fused_root.size()) { ++ new_root = fusion; ++ } else { ++ std::vector operands; ++ for (int i : root_indices) { ++ HloInstruction* gte = consumer->parent()->AddInstruction( ++ HloInstruction::CreateGetTupleElement(fusion, i)); ++ operands.push_back(gte); ++ } ++ if (operands.size() == 1) { ++ new_root = operands[0]; ++ } else { ++ new_root = consumer->parent()->AddInstruction( ++ HloInstruction::CreateTuple(operands)); ++ } ++ } ++ consumer->parent()->set_root_instruction(new_root); ++ } ++} ++ ++bool GeneralFusion::HasCycle(HloInstruction* producer, ++ HloInstruction* consumer) { ++ for (const HloInstruction* operand : consumer->operands()) { ++ if (operand == producer) { ++ continue; ++ } ++ else if (operand->opcode() == HloOpcode::kGetTupleElement) { ++ if (operand->operand(0) == producer) { ++ continue; ++ } ++ } ++ // For consumer's every other operand, check if reachable by producer. ++ // If so then creates a cycle. ++ if (reachability_->IsPresent(producer) && ++ reachability_->IsPresent(operand) && ++ reachability_->IsReachable(producer, operand)) { ++ return true; ++ } ++ } ++ return false; ++} ++ ++bool GeneralFusion::ShouldFuseProducerIntoConsumer(HloInstruction* producer, ++ HloInstruction* consumer) { ++ if (!producer->IsFusible()) { ++ return false; ++ } ++ if (HasCycle(producer, consumer)) { ++ return false; ++ } ++ if (producer->opcode() == HloOpcode::kCustomCall || ++ consumer->opcode() == HloOpcode::kCustomCall) { ++ return false; ++ } ++ bool fusible = true; ++ ++ int external_user_count = 0; ++ HloInstruction* actual_user; ++ // We need to check only for users that aren't parameters in the consumer. ++ for (auto* user : producer->users()) { ++ if (IsGTE(user)) { ++ for (auto* gte_user : user->users()) { ++ if (gte_user != consumer) { ++ external_user_count += 1; ++ } ++ } ++ } ++ else { ++ if (user != consumer) { ++ external_user_count += 1; ++ } ++ } ++ } ++ ++ bool shapes_compatible = ShapesCompatibleForMultiOutputFusion(*consumer, ++ *producer); ++ // If shapes are not compatible, we don't fuse in the other consumer->user ++ // outputs as multiple outputs ++ // This is to ensure multi-output fusion has identical output shapes ++ if ((external_user_count > 0) && shapes_compatible) { ++ // MultiOutputFusion ++ fusible = IsProducerConsumerMultiOutputFusible(*producer, *consumer, ++ /*general_fusion*/ true); ++ } else { ++ FusionDecision decision = IsProducerConsumerFusible(*producer, *consumer, ++ /*general_fusion*/ true); ++ fusible = decision.CanFuse(); ++ } ++ return fusible; ++} ++ ++bool GeneralFusion::DoGeneralFusion(HloComputation* comp) { ++ reachability_.reset(); ++ reachability_ = HloReachabilityMap::Build(comp); ++ std::vector post_order = comp->MakeInstructionPostOrder(); ++ int count = 0; ++ while (!post_order.empty()) { ++ HloInstruction* inst = post_order.back(); ++ post_order.pop_back(); ++ if (IsGTE(inst) || IsTuple(inst) || !inst->IsFusible()) { ++ continue; ++ } ++ LOG(INFO) << "Considering consumer " << inst->name(); ++ HloInstructionSet uniq_operands; ++ for (const auto* const_operand : inst->unique_operands()) { ++ auto* operand = const_cast(const_operand); ++ if (IsGTE(operand)) { ++ LOG(INFO) << "Considering GTE producer " << operand->name(); ++ // If GTE, trace back one more step ++ uniq_operands.insert(operand->mutable_operand(0)); ++ } else { ++ LOG(INFO) << "Considering normal producer " << operand->name(); ++ uniq_operands.insert(operand); ++ } ++ } ++ for (auto* operand : uniq_operands) { ++ LOG(INFO) << "Considering " << operand->name() << " and " << inst->name(); ++ if (!ShouldFuseProducerIntoConsumer(/*producer=*/operand, ++ /*consumer=*/inst)) { ++ continue; ++ } ++ LOG(INFO) << "Fusing " << operand->name() << " into " << inst->name(); ++ FuseTwo(/*consumer=*/inst, /*producer=*/operand); ++ count++; ++ } ++ } ++ return count > 0; ++} ++ ++StatusOr GeneralFusion::Run(HloModule* module) { ++ bool changed = false; ++ for (auto* computation : module->MakeNonfusionComputations()) { ++ changed |= DoGeneralFusion(computation); ++ } ++ VLOG(1) << "After running GeneralFusion for module: " << module->name(); ++ XLA_VLOG_LINES(3, module->ToString()); ++ LOG(ERROR) << "Run Finish " << changed; ++ return changed; ++} ++ ++} // namespace gpu ++} // namespace xla +diff --git a/tensorflow/compiler/xla/service/gpu/general_fusion.h b/tensorflow/compiler/xla/service/gpu/general_fusion.h +new file mode 100644 +index 00000000000..d614fcac435 +--- /dev/null ++++ b/tensorflow/compiler/xla/service/gpu/general_fusion.h +@@ -0,0 +1,54 @@ ++/* Copyright 2022 The TensorFlow Authors. All Rights Reserved. ++ ++Licensed under the Apache License, Version 2.0 (the "License"); ++you may not use this file except in compliance with the License. ++You may obtain a copy of the License at ++ ++ http://www.apache.org/licenses/LICENSE-2.0 ++ ++Unless required by applicable law or agreed to in writing, software ++distributed under the License is distributed on an "AS IS" BASIS, ++WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++See the License for the specific language governing permissions and ++limitations under the License. ++==============================================================================*/ ++ ++#ifndef TENSORFLOW_COMPILER_XLA_SERVICE_GPU_GENERAL_FUSION_H_ ++#define TENSORFLOW_COMPILER_XLA_SERVICE_GPU_GENERAL_FUSION_H_ ++ ++#include "tensorflow/compiler/xla/service/hlo_module.h" ++#include "tensorflow/compiler/xla/service/hlo_pass_interface.h" ++#include "tensorflow/compiler/xla/service/hlo_reachability.h" ++ ++namespace xla { ++namespace gpu { ++ ++// An HLO pass that does general fusion. ++ ++class GeneralFusion : public HloModulePass { ++ public: ++ absl::string_view name() const override { return "general_fusion"; } ++ ++ StatusOr Run(HloModule* module) override; ++ ++ int fused_count() { return fused_count_; } ++ ++ private: ++ bool FuseSiblings(std::vector& siblings); ++ bool HasCycle(HloInstruction* producer, HloInstruction* consumer); ++ bool DoGeneralFusion(HloComputation* comp); ++ bool ShouldFuseProducerIntoConsumer(HloInstruction* producer, HloInstruction* consumer); ++ ++ // Current computation the pass is dealing with. ++ HloComputation* computation_; ++ ++ // Reachability map of current computation. ++ std::unique_ptr reachability_; ++ ++ int fused_count_; ++}; ++ ++} // namespace gpu ++} // namespace xla ++ ++#endif // TENSORFLOW_COMPILER_XLA_SERVICE_GPU_GENERAL_FUSION_H_ +diff --git a/tensorflow/compiler/xla/service/gpu/gpu_compiler.cc b/tensorflow/compiler/xla/service/gpu/gpu_compiler.cc +index 7b40c9822c1..bbbf106c66a 100644 +--- a/tensorflow/compiler/xla/service/gpu/gpu_compiler.cc ++++ b/tensorflow/compiler/xla/service/gpu/gpu_compiler.cc +@@ -86,6 +86,7 @@ limitations under the License. + #include "tensorflow/compiler/xla/service/gpu/fusion_merger.h" + #include "tensorflow/compiler/xla/service/gpu/gemm_broadcast_folding_rewriter.h" + #include "tensorflow/compiler/xla/service/gpu/gemm_rewriter.h" ++#include "tensorflow/compiler/xla/service/gpu/general_fusion.h" + #include "tensorflow/compiler/xla/service/gpu/gpu_constants.h" + #include "tensorflow/compiler/xla/service/gpu/gpu_conv_algorithm_picker.h" + #include "tensorflow/compiler/xla/service/gpu/gpu_conv_rewriter.h" +@@ -185,63 +186,6 @@ namespace xla { + namespace gpu { + namespace { + +-class GpuBfloat16Support : public BFloat16Support { +- public: +- explicit GpuBfloat16Support(bool supports_matrix_multiplication, +- se::StreamExecutor* stream_exec) +- : supports_matrix_multiplication_(supports_matrix_multiplication), +- stream_exec_(stream_exec) {} +- +- bool SupportsBF16Operand(const HloInstruction& hlo, +- int64_t operand_index) const override { +- return BFloat16Support::SupportsBF16Operand(hlo, operand_index) || +- IsSupported(hlo); +- } +- +- // Returns whether the backend supports BF16 output for the HLO instruction. +- bool SupportsBF16Output(const HloInstruction& hlo) const override { +- return BFloat16Support::SupportsBF16Output(hlo) || IsSupported(hlo); +- } +- +- private: +- bool IsSupported(const HloInstruction& hlo) const { +- switch (hlo.opcode()) { +- case HloOpcode::kAllGather: +- case HloOpcode::kAllReduce: +- case HloOpcode::kAllReduceStart: +- case HloOpcode::kAllReduceDone: +- case HloOpcode::kReduceScatter: +- case HloOpcode::kAllToAll: +- case HloOpcode::kBitcast: +- case HloOpcode::kCollectivePermute: +- return true; +- case HloOpcode::kConvolution: +- return IsConvBF16Supported(); +- default: +- return supports_matrix_multiplication_ && +- gpu::IsMatrixMultiplication(hlo); +- } +- } +- +- bool IsConvBF16Supported() const { +- if (se::dnn::DnnSupport* dnn = stream_exec_->AsDnn()) { +- se::port::StatusOr cudnn_version = +- dnn->GetVersion(); +- return cudnn_version.ok() && +- (cudnn_version->major_version() > 8 || +- (cudnn_version->major_version() == 8 && +- cudnn_version->minor_version() >= 2)) && +- stream_exec_->GetDeviceDescription() +- .cuda_compute_capability() +- .IsAtLeast(se::CudaComputeCapability::AMPERE); +- } +- return false; +- } +- +- bool supports_matrix_multiplication_; +- se::StreamExecutor* stream_exec_; +-}; +- + int64_t GetSizeOfShape(const Shape& shape, int pointer_size) { + if (shape.is_static() || shape.IsTuple()) { + return ShapeUtil::ByteSizeOf(shape, pointer_size); +@@ -291,6 +235,7 @@ GpuCompiler::GpuCompiler(se::Platform::Id platform_id, + Status GpuCompiler::OptimizeHloModule( + HloModule* hlo_module, se::StreamExecutor* stream_exec, + se::DeviceMemoryAllocator* device_allocator) { ++ + // Save proto state before optimizations if we want a snapshot. + if (DumpingEnabledForHloModule(*hlo_module)) { + hlo_proto_ = absl::make_unique(); +@@ -754,6 +699,8 @@ Status GpuCompiler::OptimizeHloPostLayoutAssignment( + StatusOr> GpuCompiler::RunHloPasses( + std::unique_ptr module, se::StreamExecutor* stream_exec, + const CompileOptions& options) { ++ throw Intercept(this, std::move(module), stream_exec, ++ options); // This is where we handover control + // We dump the post-optimization HLO in RunBackend so no need to dump it here. + XLA_SCOPED_LOGGING_TIMER("GpuCompiler::RunHloPasses"); + uint64_t start_usecs = tensorflow::Env::Default()->NowMicros(); +@@ -774,6 +721,22 @@ StatusOr> GpuCompiler::RunHloPasses( + return std::move(module); + } + ++Status GpuCompiler::RunHloPasses(HloModule* module, ++ se::StreamExecutor* stream_exec, ++ const CompileOptions& options) { ++ // We dump the post-optimization HLO in RunBackend so no need to dump it here. ++ XLA_SCOPED_LOGGING_TIMER("GpuCompiler::RunHloPasses"); ++ tensorflow::profiler::TraceMe activity( ++ [&] { return absl::StrCat("HLO Transforms:", module->name()); }, ++ tensorflow::profiler::TraceMeLevel::kInfo); ++ ++ TF_RETURN_IF_ERROR( ++ OptimizeHloModule(module, stream_exec, options.device_allocator)); ++ ++ TF_RETURN_IF_ERROR(PrepareHloModuleForIrEmitting(module)); ++ return Status::OK(); ++} ++ + static absl::optional DummyCanShareBufferFunction(const HloInstruction*, + const HloInstruction*, + const ShapeIndex&) { +@@ -1601,5 +1564,7 @@ StatusOr> CompileLmhloToExecutable( + module_name, output_shape, std::move(allocations)}); + } + ++#include "tensorflow/compiler/xla/service/gpu/gpu_compiler_ext.h" ++ + } // namespace gpu + } // namespace xla +diff --git a/tensorflow/compiler/xla/service/gpu/gpu_compiler.h b/tensorflow/compiler/xla/service/gpu/gpu_compiler.h +index 7a4709e8182..6f63c2824ea 100644 +--- a/tensorflow/compiler/xla/service/gpu/gpu_compiler.h ++++ b/tensorflow/compiler/xla/service/gpu/gpu_compiler.h +@@ -22,6 +22,11 @@ limitations under the License. + #include + + #include "mlir/IR/BuiltinOps.h" // from @llvm-project ++ ++// TODO(ohcy): See below TODO ++#include "tensorflow/compiler/xla/service/bfloat16_support.h" ++#include "tensorflow/compiler/xla/service/gpu/ir_emission_utils.h" ++ + #include "tensorflow/compiler/xla/service/executable.h" + #include "tensorflow/compiler/xla/service/gpu/gpu_device_info.h" + #include "tensorflow/compiler/xla/service/gpu/gpu_executable.h" +@@ -34,9 +39,70 @@ limitations under the License. + #include "tensorflow/core/platform/stream_executor_no_cuda.h" + #include "tensorflow/stream_executor/stream_executor_pimpl.h" + ++ + namespace xla { + namespace gpu { + ++// TODO(ohcy): Originally shifted from anonymous namespae in ++// gpu_compiler.cc. For potential refactoring when generalized pass/pipeline ++// is made more general ++class GpuBfloat16Support : public BFloat16Support { ++ public: ++ explicit GpuBfloat16Support(bool supports_matrix_multiplication, ++ se::StreamExecutor* stream_exec) ++ : supports_matrix_multiplication_(supports_matrix_multiplication), ++ stream_exec_(stream_exec) {} ++ ++ bool SupportsBF16Operand(const HloInstruction& hlo, ++ int64_t operand_index) const override { ++ return BFloat16Support::SupportsBF16Operand(hlo, operand_index) || ++ IsSupported(hlo); ++ } ++ ++ // Returns whether the backend supports BF16 output for the HLO instruction. ++ bool SupportsBF16Output(const HloInstruction& hlo) const override { ++ return BFloat16Support::SupportsBF16Output(hlo) || IsSupported(hlo); ++ } ++ ++ private: ++ bool IsSupported(const HloInstruction& hlo) const { ++ switch (hlo.opcode()) { ++ case HloOpcode::kAllGather: ++ case HloOpcode::kAllReduce: ++ case HloOpcode::kAllReduceStart: ++ case HloOpcode::kAllReduceDone: ++ case HloOpcode::kReduceScatter: ++ case HloOpcode::kAllToAll: ++ case HloOpcode::kBitcast: ++ case HloOpcode::kCollectivePermute: ++ return true; ++ case HloOpcode::kConvolution: ++ return IsConvBF16Supported(); ++ default: ++ return supports_matrix_multiplication_ && ++ gpu::IsMatrixMultiplication(hlo); ++ } ++ } ++ ++ bool IsConvBF16Supported() const { ++ if (se::dnn::DnnSupport* dnn = stream_exec_->AsDnn()) { ++ se::port::StatusOr cudnn_version = ++ dnn->GetVersion(); ++ return cudnn_version.ok() && ++ (cudnn_version->major_version() > 8 || ++ (cudnn_version->major_version() == 8 && ++ cudnn_version->minor_version() >= 2)) && ++ stream_exec_->GetDeviceDescription() ++ .cuda_compute_capability() ++ .IsAtLeast(se::CudaComputeCapability::AMPERE); ++ } ++ return false; ++ } ++ ++ bool supports_matrix_multiplication_; ++ se::StreamExecutor* stream_exec_; ++}; ++ + class GpuAotCompilationResult : public AotCompilationResult { + public: + static StatusOr> FromString( +@@ -88,6 +154,8 @@ class GpuCompiler : public LLVMCompiler { + StatusOr> RunHloPasses( + std::unique_ptr module, se::StreamExecutor* stream_exec, + const CompileOptions& options) override; ++ Status RunHloPasses(HloModule* module, se::StreamExecutor* stream_exec, ++ const CompileOptions& options); + + StatusOr> AssignBuffers( + const HloModule* hlo_module) override; +@@ -120,11 +188,30 @@ class GpuCompiler : public LLVMCompiler { + HloModule* hlo_module, se::StreamExecutor* stream_exec, + se::DeviceMemoryAllocator* device_allocator); + +- private: ++ public: ++ Status OptimizeHloModulePreFusion( ++ HloModule* hlo_module, se::StreamExecutor* stream_exec, ++ se::DeviceMemoryAllocator* device_allocator); ++ Status OptimizeHloModuleFusionRunPre( ++ HloModule* hlo_module, se::StreamExecutor* stream_exec, ++ se::DeviceMemoryAllocator* device_allocator); ++ Status OptimizeHloModuleFusionRun( ++ HloModule* hlo_module, se::StreamExecutor* stream_exec, ++ se::DeviceMemoryAllocator* device_allocator, bool may_duplicate); ++ Status OptimizeHloModuleFusionRunPost( ++ HloModule* hlo_module, se::StreamExecutor* stream_exec, ++ se::DeviceMemoryAllocator* device_allocator); ++ Status OptimizeHloModulePostFusion( ++ HloModule* hlo_module, se::StreamExecutor* stream_exec, ++ se::DeviceMemoryAllocator* device_allocator); ++ + Status OptimizeHloModule(HloModule* hlo_module, + se::StreamExecutor* stream_exec, + se::DeviceMemoryAllocator* device_allocator); + ++ Status PrepareHloModuleForIrEmitting(HloModule* hlo_module); ++ ++ private: + virtual Status OptimizeHloConvolutionCanonicalization( + HloModule* hlo_module, se::StreamExecutor* stream_exec, + se::DeviceMemoryAllocator* device_allocator) = 0; +@@ -143,8 +230,6 @@ class GpuCompiler : public LLVMCompiler { + se::StreamExecutor* stream_exec, bool relocatable, + const HloModule* debug_module) = 0; + +- Status PrepareHloModuleForIrEmitting(HloModule* hlo_module); +- + virtual StatusOr> LinkModules( + se::StreamExecutor* stream_exec, + std::vector> modules) { +diff --git a/tensorflow/compiler/xla/service/gpu/gpu_compiler_ext.h b/tensorflow/compiler/xla/service/gpu/gpu_compiler_ext.h +new file mode 100644 +index 00000000000..199166a6532 +--- /dev/null ++++ b/tensorflow/compiler/xla/service/gpu/gpu_compiler_ext.h +@@ -0,0 +1,388 @@ ++/* Copyright 2017 The TensorFlow Authors. All Rights Reserved. ++ ++Licensed under the Apache License, Version 2.0 (the "License"); ++you may not use this file except in compliance with the License. ++You may obtain a copy of the License at ++ ++ http://www.apache.org/licenses/LICENSE-2.0 ++ ++Unless required by applicable law or agreed to in writing, software ++distributed under the License is distributed on an "AS IS" BASIS, ++WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++See the License for the specific language governing permissions and ++limitations under the License. ++==============================================================================*/ ++ ++// Runs optimization passes on the given HLO module. ++Status GpuCompiler::OptimizeHloModulePreFusion( ++ HloModule* hlo_module, se::StreamExecutor* stream_exec, ++ se::DeviceMemoryAllocator* device_allocator) { ++ // Save proto state before optimizations if we want a snapshot. ++ if (DumpingEnabledForHloModule(*hlo_module)) { ++ hlo_proto_ = absl::make_unique(); ++ *hlo_proto_->mutable_hlo_module() = hlo_module->ToProto(); ++ } ++ ++ const DebugOptions& debug_options = hlo_module->config().debug_options(); ++ ++ if (hlo_module->config().use_spmd_partitioning()) { ++ HloPassPipeline spmd_pipeline("spmd-partitioner"); ++ const int64_t num_partitions = hlo_module->config().num_partitions(); ++ if (num_partitions > 1) { ++ // Run some IR cleanup passes before running the SPMD partitioning ++ // passes. ++ spmd_pipeline.AddInvariantChecker( ++ /*layout_sensitive=*/false, ++ /*allow_mixed_precision=*/false); ++ spmd_pipeline.AddPass(); ++ spmd_pipeline.AddPass(); ++ spmd_pipeline.AddPass(); ++ ++ HloPassPipeline& spmd_simplify = ++ spmd_pipeline.AddPass>("spmd-simplify"); ++ ++ AlgebraicSimplifierOptions options; ++ options.set_replace_transpose_with_bitcast(false); ++ options.set_enable_conv_operand_swap(false); ++ // "slow" minmax means we propagate nan. ++ options.set_minmax_propagate_nan( ++ !debug_options.xla_gpu_enable_fast_min_max()); ++ spmd_simplify.AddPass(options); ++ ++ spmd_simplify.AddPass(); ++ spmd_simplify.AddPass(); ++ spmd_simplify.AddPass( ++ ScatterExpander::kEliminateSimpleScatters); ++ spmd_simplify.AddPass( ++ GatherExpander::kEliminateSimpleGathers); ++ spmd_simplify.AddPass(); ++ spmd_simplify.AddPass(); ++ ++ spmd_simplify.AddPass(); ++ spmd_simplify.AddPass(); ++ spmd_simplify.AddPass(); ++ spmd_simplify.AddPass(); ++ ++ spmd_pipeline.AddPass(/*is_spmd=*/true); ++ spmd_pipeline.AddPass( ++ num_partitions, hlo_module->config().replica_count()); ++ } else { ++ // Remove redundant sharding ops when partition_count == 1. ++ spmd_pipeline.AddPass(); ++ spmd_pipeline.AddPass(); ++ } ++ TF_RETURN_IF_ERROR(spmd_pipeline.Run(hlo_module).status()); ++ } ++ ++ { ++ HloPassPipeline pipeline("optimization"); ++ pipeline.AddInvariantChecker(/*layout_sensitive=*/false, ++ /*allow_mixed_precision=*/false); ++ pipeline.AddPass(); ++ ++ OpExpanderPass::PatternExtraFilter upcaster_filter = ++ [&](const HloInstruction* instr) { ++ return !stream_exec->GetDeviceDescription() ++ .cuda_compute_capability() ++ .IsAtLeast(se::CudaComputeCapability::VOLTA) || ++ !gpu::IsMatrixMultiplication(*instr); ++ }; ++ ++ pipeline.AddPass(upcaster_filter); ++ pipeline.AddPass(upcaster_filter); ++ ++ // Expand random number generation. ++ pipeline.AddPass(); ++ pipeline.AddPass(RandomAlgorithm::RNG_PHILOX); ++ ++ // Comparison total order expander ++ pipeline.AddPass(); ++ ++ // Remove zero-sized HLO from the input so that other passes don't have to ++ // handle it. ++ pipeline.AddPass(); ++ ++ if (debug_options.xla_gpu_deterministic_ops()) { ++ // Scatter is nondeterministic, so eliminate all Scatters. ++ pipeline.AddPass(ScatterExpander::kEliminateAllScatters); ++ } else { ++ // Only Scatters unsupported on XLA:GPU are eliminated. ++ pipeline.AddPass(); ++ } ++ // TODO(phawkins): replace QR and Eigh decompositions with calls to ++ // cuSOLVER. ++ pipeline.AddPass(); ++ pipeline.AddPass(); ++ ++ pipeline.AddPass(); ++ ++ // TODO(b/64094172): make Call work on GPU instead of inlining. ++ pipeline.AddPass(); ++ ++ pipeline.AddPass(); ++ ++ pipeline.AddPass(); ++ ++ // Expand the sort op to support stable sorting if required. ++ pipeline.AddPass(); ++ ++ GpuBfloat16Support bf16(/*supports_matrix_multiplication=*/true, ++ stream_exec); ++ pipeline.AddPass(&bf16); ++ ++ pipeline.AddPass( ++ /*rewrite_training_op=*/true, ++ /*rewrite_inference_op=*/true, ++ /*rewrite_grad_op=*/true); ++ ++ pipeline.AddPass( ++ /*expansion_type=*/LogisticExpansionType::kExp); ++ pipeline.AddPass(); ++ pipeline.AddPass(); ++ auto dynamic_padder_options = DynamicPadderOptions(); ++ dynamic_padder_options.shape_check_mode = ++ DynamicDimensionInference::ShapeCheckMode::kCompileTime; ++ pipeline.AddPass(dynamic_padder_options); ++ ++ // Build simplification pipeline. The passes in here are run to a fixed ++ // point. ++ [&, &pipeline = ++ pipeline.AddPass>("simplification")] { ++ pipeline.AddInvariantCheckerDebug( ++ /*layout_sensitive=*/false, ++ /*allow_mixed_precision=*/false); ++ ++ // BatchNormExpander can create zero-sized ops, so zero-sized HLO ++ // elimination has to come after that pass. ++ pipeline.AddPass(); ++ ++ pipeline.AddPass(GatherExpander::kEliminateSimpleGathers); ++ pipeline.AddPass( ++ ScatterExpander::kEliminateSimpleScatters); ++ ++ AlgebraicSimplifierOptions options({}, ConvIsLowerable); ++ // "slow" minmax means we propagate nan. ++ options.set_minmax_propagate_nan( ++ !debug_options.xla_gpu_enable_fast_min_max()); ++ ++ // When transposes appear in a fusion node, we can easily adjust the ++ // multi-dimensional index to create the one needed for the operand. ++ // This is not as easy with bitcasts, because we don't have the ++ // information readily available which dimensions are permuted. In ++ // addition to that, if we have a transpose and a reshape next to each ++ // other, they will both be replaced by a bitcast, and we replace ++ // bitcast(bitcast) with one bitcast. This leads to having to ++ // linearize and then delinearize the index. ++ options.set_replace_transpose_with_bitcast(false); ++ const se::Platform* platform = stream_exec->platform(); ++ if (platform->Name() == "ROCM") { ++ // SwapConvOperands does not yet work on ROCM ++ options.set_enable_conv_operand_swap(false); ++ } ++ pipeline.AddPass(options); ++ pipeline.AddPass(); ++ // AlgebraicSimplifier may add contracting dimensions to a dot. ++ pipeline.AddPass(); ++ // Only merge "smallish" dots. This threshold was not set carefully, but ++ // so far we know that 1mb is too small. ++ pipeline.AddPass(/*max_size_to_merge=*/int64_t{16} << 20); ++ pipeline.AddPass(); ++ pipeline.AddPass(); ++ pipeline.AddPass(); ++ pipeline.AddPass(); ++ ++ // TODO(b/134075051): Re-enable after b/134075051 is fixed. ++ // pipeline.AddPass(); ++ ++ pipeline.AddPass(); ++ pipeline.AddPass(); ++ pipeline.AddPass(); ++ pipeline.AddPass(); ++ ++ pipeline.AddPass( ++ [](const HloInstruction& dot, ++ const TransposeFolding::OperandIndices& candidate_operands) { ++ return IsMatrixMultiplication(dot) ++ ? candidate_operands ++ : TransposeFolding::OperandIndices{}; ++ }); ++ pipeline.AddPass(/*is_layout_sensitive=*/false); ++ pipeline.AddPass(); ++ }(); ++ ++ // Run WhileLoopTripCountAnnotator at the end of the simplification ++ // pipeline, before layout assignment and fusion. This pass does some ++ // pattern-matching on while bodies/conditions, and this is where the HLO is ++ // "nicest". ++ // ++ // It's important that we don't make semantic changes (e.g. unrolling) to ++ // any `while` loops after this point, because otherwise the trip-count ++ // annotations added by this pass may not be correct after the ++ // modifications. ++ pipeline.AddPass(); ++ TF_RETURN_IF_ERROR(pipeline.Run(hlo_module).status()); ++ } ++ ++ // Optimize collectives generated by SPMD partitioning. Enable these passes ++ // otherwise as well so that all collectives can get these optimizations. ++ { ++ HloPassPipeline collectives_pipeline("collective-optimizations"); ++ collectives_pipeline.AddPass(); ++ collectives_pipeline.AddPass(); ++ collectives_pipeline.AddPass(); ++ ++ // Run algebraic simplifier to reshape(broadcast) into a broadcast when ++ // the reshape is just adding a unit dimension. This will help with the ++ // AllGatherBroadcastReorder pass. ++ AlgebraicSimplifierOptions options; ++ options.set_replace_transpose_with_bitcast(false); ++ options.set_enable_conv_operand_swap(false); ++ // "slow" minmax means we propagate nan. ++ options.set_minmax_propagate_nan( ++ !debug_options.xla_gpu_enable_fast_min_max()); ++ ++ collectives_pipeline.AddPass(options); ++ ++ collectives_pipeline.AddPass(); ++ TF_RETURN_IF_ERROR(collectives_pipeline.Run(hlo_module).status()); ++ } ++ ++ // Run target-specific HLO optimization passes for convolution ++ // canonicalization. ++ TF_RETURN_IF_ERROR(OptimizeHloConvolutionCanonicalization( ++ hlo_module, stream_exec, device_allocator)); ++ ++ { ++ // Run layout assignment in a separate pipeline from ++ // "post-layout-assignment" because we want everything after layout ++ // assignment to have a layout-sensitive invariant-checker, but ++ // HloPassPipeline also runs its invariant checker before any passes are ++ // run, meaning, the pipeline that contains layout assignment cannot contain ++ // a layout-sensitive verifier! ++ HloPassPipeline pipeline("layout assignment"); ++ // Layout assignment uses alias analysis, which requires the call graph to ++ // be flattened. ++ pipeline.AddPass(); ++ ChannelLayoutConstraints layout_constraints; ++ pipeline.AddPass( ++ hlo_module->mutable_entry_computation_layout(), stream_exec, ++ &layout_constraints); ++ TF_RETURN_IF_ERROR(pipeline.Run(hlo_module).status()); ++ } ++ ++ // Run target-specific HLO optimization passes after layout assignment. ++ TF_RETURN_IF_ERROR(OptimizeHloPostLayoutAssignment(hlo_module, stream_exec, ++ device_allocator)); ++ ++ return Status::OK(); ++} ++ ++Status GpuCompiler::OptimizeHloModuleFusionRunPre( ++ HloModule* hlo_module, se::StreamExecutor* stream_exec, ++ se::DeviceMemoryAllocator* device_allocator) { ++ { ++ HloPassPipeline fusion_pre("fusion_pre"); ++ // We try to split variadic ops with many parameters into several such ops ++ // to avoid exceeding the parameter space. ++ fusion_pre.AddPass(); ++ fusion_pre.AddInvariantCheckerDebug( ++ /*layout_sensitive=*/true, ++ /*allow_mixed_precision=*/false, ++ LayoutAssignment::InstructionCanChangeLayout); ++ TF_RETURN_IF_ERROR(fusion_pre.Run(hlo_module).status()); ++ } ++ return Status::OK(); ++} ++ ++Status GpuCompiler::OptimizeHloModuleFusionRun( ++ HloModule* hlo_module, se::StreamExecutor* stream_exec, ++ se::DeviceMemoryAllocator* device_allocator, bool may_duplicate) { ++ { ++ HloPassPipeline fusion_dry("fusion_dry"); ++ fusion_dry.AddPass(may_duplicate); ++ TF_RETURN_IF_ERROR(fusion_dry.Run(hlo_module).status()); ++ } ++ ++ return Status::OK(); ++} ++ ++Status GpuCompiler::OptimizeHloModuleFusionRunPost( ++ HloModule* hlo_module, se::StreamExecutor* stream_exec, ++ se::DeviceMemoryAllocator* device_allocator) { ++ { ++ HloPassPipeline fusion_post("fusion_post"); ++ fusion_post.AddPass(); ++ fusion_post.AddPass(); ++ fusion_post.AddPass(/*is_layout_sensitive=*/true, ++ /*only_fusion_computations=*/true); ++ fusion_post.AddPass(); ++ TF_RETURN_IF_ERROR(fusion_post.Run(hlo_module).status()); ++ } ++ return Status::OK(); ++} ++ ++Status GpuCompiler::OptimizeHloModulePostFusion( ++ HloModule* hlo_module, se::StreamExecutor* stream_exec, ++ se::DeviceMemoryAllocator* device_allocator) { ++ const DebugOptions& debug_options = hlo_module->config().debug_options(); ++ ++ { ++ HloPassFix horizontal_fusion("horizontal fusion"); ++ horizontal_fusion.AddPass(); ++ horizontal_fusion.AddPass(); ++ // FusionBitcastLift must be after InstructionFusion, as it undoes ++ // part of it. ++ // TODO(b/209005695) Renable once the bug is fixed. ++ // horizontal_fusion.AddPass(); ++ horizontal_fusion.AddPass(/*is_layout_sensitive=*/true, ++ /*only_fusion_computations=*/true); ++ horizontal_fusion.AddPass(); ++ TF_RETURN_IF_ERROR(horizontal_fusion.Run(hlo_module).status()); ++ } ++ ++ { ++ HloPassPipeline pipeline("post-fusion optimization"); ++ pipeline.AddPass( ++ /*combine_threshold_in_bytes=*/1024 * 1024 * 1024, ++ /*combine_threshold_count=*/256); ++ pipeline.AddPass( ++ debug_options.xla_gpu_all_reduce_combine_threshold_bytes(), ++ /*combine_threshold_count=*/256); ++ pipeline.AddPass( ++ /*combine_threshold_in_bytes=*/30 * 1024 * 1024, ++ /*combine_threshold_count=*/256); ++ ++ if (debug_options.xla_gpu_all_reduce_contiguous()) { ++ pipeline.AddPass(); ++ } ++ ++ int32_t blueconnect_num_devices_per_host = ++ debug_options.xla_gpu_all_reduce_blueconnect_num_devices_per_host(); ++ if (blueconnect_num_devices_per_host > 0) { ++ pipeline.AddPass(blueconnect_num_devices_per_host); ++ } ++ ++ if (debug_options.xla_gpu_enable_async_all_reduce()) { ++ AsyncCollectiveCreator::CollectiveCreatorConfig config; ++ config.convert_all_reduce = [](const HloInstruction*) { return true; }; ++ pipeline.AddPass(std::move(config)); ++ } ++ ++ pipeline.AddPass(); ++ ++ // Now we allow replacing any transposes outside of fusions with bitcasts. ++ AlgebraicSimplifierOptions options; ++ options.set_is_layout_sensitive(true); ++ options.set_enable_conv_operand_swap(false); ++ // "slow" minmax means we propagate nan. ++ options.set_minmax_propagate_nan( ++ !debug_options.xla_gpu_enable_fast_min_max()); ++ pipeline.AddPass(options); ++ pipeline.AddPass(); ++ pipeline.AddPass(); ++ ++ TF_RETURN_IF_ERROR(pipeline.Run(hlo_module).status()); ++ } ++ ++ return Status::OK(); ++} +diff --git a/tensorflow/compiler/xla/service/gpu/gpu_fusible.cc b/tensorflow/compiler/xla/service/gpu/gpu_fusible.cc +index f312cd261be..55fb1af7d92 100644 +--- a/tensorflow/compiler/xla/service/gpu/gpu_fusible.cc ++++ b/tensorflow/compiler/xla/service/gpu/gpu_fusible.cc +@@ -204,7 +204,8 @@ bool IsLoopFusible(const HloInstruction& instr) { + } + + FusionDecision IsProducerConsumerFusible(const HloInstruction& producer, +- const HloInstruction& consumer) { ++ const HloInstruction& consumer, ++ bool general_fusion) { + if (!IsLoopFusible(producer)) { + return "the producer is not loop-fusible"; + } +@@ -214,7 +215,7 @@ FusionDecision IsProducerConsumerFusible(const HloInstruction& producer, + } + + // Skip multiple output fusion. It's not yet supported. +- if (producer.IsMultiOutputFusion()) { ++ if ((!general_fusion) && producer.IsMultiOutputFusion()) { + return "the producer is not fusible as it is a multi-output fusion"; + } + +@@ -248,9 +249,10 @@ FusionDecision IsProducerConsumerFusible(const HloInstruction& producer, + } + + bool IsProducerConsumerMultiOutputFusible(const HloInstruction& producer, +- const HloInstruction& consumer) { ++ const HloInstruction& consumer, ++ bool general_fusion) { + // Skip multiple output fusion. It's not yet supported. +- if (producer.IsMultiOutputFusion()) { ++ if ((!general_fusion) && producer.IsMultiOutputFusion()) { + return false; + } + +@@ -287,7 +289,7 @@ bool IsProducerConsumerMultiOutputFusible(const HloInstruction& producer, + if (CreatesNestedLoop(producer, consumer)) { + return false; + } +- if (!ShapesCompatibleForMultiOutputFusion(producer, consumer)) { ++ if ((!general_fusion) && !ShapesCompatibleForMultiOutputFusion(producer, consumer)) { + return false; + } + if (!LayoutsAreReduceInputFusionFriendly(producer, consumer)) { +diff --git a/tensorflow/compiler/xla/service/gpu/gpu_fusible.h b/tensorflow/compiler/xla/service/gpu/gpu_fusible.h +index 28c8de06d7d..685b2614363 100644 +--- a/tensorflow/compiler/xla/service/gpu/gpu_fusible.h ++++ b/tensorflow/compiler/xla/service/gpu/gpu_fusible.h +@@ -111,13 +111,15 @@ bool ShapesCompatibleForMultiOutputFusion(const HloInstruction& instr1, + // i.e. whether the producer and consumer are loop/input fusible and + // they are not library calls. + FusionDecision IsProducerConsumerFusible(const HloInstruction& producer, +- const HloInstruction& consumer); ++ const HloInstruction& consumer, ++ bool general_fusion = false); + + // Whether the instructions are producer-consumer fusible with multiple outputs. + // That is, the root tuple of the multi-output fusion will contain the results + // of both, the producer and consumer. + bool IsProducerConsumerMultiOutputFusible(const HloInstruction& producer, +- const HloInstruction& consumer); ++ const HloInstruction& consumer, ++ bool general_fusion = false); + // Whether `instr` is a candidate for sibling fusion or as a consumer in + // a producer-consumer multi-output fusion. + bool IsFusibleAsMultiOutputFusionRoot(const HloInstruction& instr); +diff --git a/tensorflow/compiler/xla/service/gpu/ir_emitter_unnested.cc b/tensorflow/compiler/xla/service/gpu/ir_emitter_unnested.cc +index b6ebbf3d567..7897456a2d3 100644 +--- a/tensorflow/compiler/xla/service/gpu/ir_emitter_unnested.cc ++++ b/tensorflow/compiler/xla/service/gpu/ir_emitter_unnested.cc +@@ -5203,8 +5203,64 @@ std::vector> GroupDisjointReductions( + + // Place output instructions in the same set into the same group. + HloInstructionMap> groups; +- for (HloInstruction* root : roots) { +- groups[disjoint_sets[root].Get()].push_back(root); ++ ++ // Keep track of any group with at least one reduce instruction ++ // If we have any stragglers later, add them to this group ++ std::vector* reduce_group_ptr; ++ for (HloInstruction* root_instr : roots) { ++ // TODO(ohcy) Handle this more elegantly in the future when ++ // we start working on the MLIR emit sections of the codebase ++ if (HloOpcode::kReduce != root_instr->opcode() && IsBroadcastedConstantOrScalar(*root_instr)) { ++ ++ // We need to maintain the seen list so we don't add to the group twice ++ HloInstructionMap seen; ++ for (HloInstruction* output : roots) { ++ if (root_instr->unique_id() != output->unique_id()){ ++ if (reachability_map->IsReachable(root_instr, output)) { ++ HloInstruction* disjoint_set_val = disjoint_sets[output].Get(); ++ // We haven't seen this disjoint representive val yet ++ if (seen.count(disjoint_set_val) == 0) { ++ groups[disjoint_set_val].push_back(root_instr); ++ seen[disjoint_set_val] = true; ++ } ++ } ++ } ++ } ++ } ++ else { ++ groups[disjoint_sets[root_instr].Get()].push_back(root_instr); ++ if (IsReductionFromOrToContiguousDimensions(*root_instr)) { ++ reduce_group_ptr = &groups[disjoint_sets[root_instr].Get()]; ++ } ++ } ++ } ++ ++ // At this point, any groups without reduce instructions contain ++ // root instructions that are not reachable from any of the reduce outputs ++ std::vector to_be_deleted; ++ for (auto& group : groups) ++ { ++ bool found_reduce = false; ++ HloInstruction* key = group.first; ++ std::vector& instr_index_group = group.second; ++ for (HloInstruction* hlo : instr_index_group) { ++ if (IsReductionFromOrToContiguousDimensions(*hlo)) { ++ // This group has a reduce instruction, it's fine ++ found_reduce = true; ++ break; ++ } ++ } ++ if (!found_reduce) { ++ // So just throw them into any group with a reduce instruction ++ for (HloInstruction* hlo : instr_index_group) { ++ reduce_group_ptr->push_back(hlo); ++ } ++ instr_index_group.clear(); ++ to_be_deleted.push_back(key); ++ } ++ } ++ for (auto instruction : to_be_deleted) { ++ groups.erase(instruction); + } + + std::vector> ret; +diff --git a/tensorflow/compiler/xla/service/hlo_computation.cc b/tensorflow/compiler/xla/service/hlo_computation.cc +index bcfb0937468..a2b108ebcce 100644 +--- a/tensorflow/compiler/xla/service/hlo_computation.cc ++++ b/tensorflow/compiler/xla/service/hlo_computation.cc +@@ -35,9 +35,12 @@ limitations under the License. + #include "tensorflow/compiler/xla/layout_util.h" + #include "tensorflow/compiler/xla/map_util.h" + #include "tensorflow/compiler/xla/service/dfs_hlo_visitor_with_default.h" ++#include "tensorflow/compiler/xla/service/hlo_casting_utils.h" + #include "tensorflow/compiler/xla/service/hlo_instruction.h" ++#include "tensorflow/compiler/xla/service/hlo_instructions.h" + #include "tensorflow/compiler/xla/service/hlo_module.h" + #include "tensorflow/compiler/xla/service/hlo_opcode.h" ++#include "tensorflow/compiler/xla/service/hlo_reachability.h" + #include "tensorflow/compiler/xla/shape_util.h" + #include "tensorflow/compiler/xla/status_macros.h" + #include "tensorflow/compiler/xla/types.h" +@@ -126,8 +129,13 @@ HloInstruction* HloComputation::AddInstructionInternal( + } + instruction->set_parent(this); + HloInstruction* pinst = instruction.get(); +- instruction_iterators_[pinst] = +- instructions_.insert(instructions_.end(), std::move(instruction)); ++ if (dry_) { ++ dry_new_instruction_iterators_[pinst] = dry_new_instructions_.insert( ++ dry_new_instructions_.end(), std::move(instruction)); ++ } else { ++ instruction_iterators_[pinst] = ++ instructions_.insert(instructions_.end(), std::move(instruction)); ++ } + return pinst; + } + +@@ -233,6 +241,7 @@ Status HloComputation::RemoveUnusedParametersFromAnyComputation() { + + Status HloComputation::RemoveUnusedParametersImpl(bool allow_non_fusion) { + CHECK(allow_non_fusion || IsFusionComputation()); ++ CHECK(!IsEntryComputation()); + int64_t removed = 0; + for (int64_t i = 0; i < param_instructions_.size(); ++i) { + HloInstruction* param_instruction = param_instructions_[i]; +@@ -290,6 +299,15 @@ bool HloComputation::IsMarkedAsDead(const HloInstruction* inst) { + + Status HloComputation::RemoveInstructionAndUnusedOperands( + HloInstruction* instruction, std::function cleanup) { ++ if (dry_) { ++ return Status::OK(); ++ } ++ ++ // If it is still in use, don't remove ++ if (instruction->user_count() != 0) { ++ return Status::OK(); ++ } ++ + TF_RET_CHECK(root_instruction() != instruction); + + TF_RET_CHECK(instruction->IsDead()); +@@ -313,7 +331,15 @@ Status HloComputation::RemoveInstructionAndUnusedOperands( + if (cleanup) { + cleanup(item); + } +- TF_RETURN_IF_ERROR(RemoveInstruction(item)); ++ ++ // TODO(ohcy): In future we might want to patch this code so that ++ // Tensorflow updates the parameters_ vector properly when kParameters ++ // are deleted. Currently only RemoveUnusedParametersFromFusedComputation ++ // and RemoveUnusedParametersFromAnyComputation do that. ++ if (item->opcode() != xla::HloOpcode::kParameter) { ++ TF_RETURN_IF_ERROR(RemoveInstruction(item)); ++ } ++ + removed.insert(item); + } + return Status::OK(); +@@ -329,6 +355,10 @@ Status HloComputation::ForceRemoveInstruction(HloInstruction* instruction) { + + Status HloComputation::RemoveInstructionImpl(HloInstruction* instruction, + bool ignore_safety_check) { ++ if (dry_) { ++ return Status::OK(); ++ } ++ + VLOG(2) << "Removing instruction " << instruction->name() + << " from computation " << name(); + TF_RET_CHECK(ignore_safety_check || IsSafelyRemovable(instruction)) +@@ -358,6 +388,15 @@ Status HloComputation::RemoveInstructionImpl(HloInstruction* instruction, + + void HloComputation::set_root_instruction(HloInstruction* new_root_instruction, + bool accept_different_shape) { ++ if (dry_) { ++ CHECK(new_root_instruction->shape() == root_instruction_->shape()) ++ << "HloPass is changing the root instruction " ++ "shape, which conflicts with dry run " ++ << new_root_instruction->shape() << " vs " ++ << root_instruction_->shape(); ++ RecordAlternatives(root_instruction_, new_root_instruction); ++ return; ++ } + // The shape of the root (ignoring layout) is an invariant of the computation + // for non-fusion cases. + if (!IsFusionComputation() && !accept_different_shape) { +@@ -947,7 +986,8 @@ StatusOr HloComputation::ReplaceInstructionWithDifferentShape( + (old_instruction->opcode() != HloOpcode::kCustomCall || + old_instruction->custom_call_target() == + new_instruction->custom_call_target())) { +- new_instruction->SetAndSanitizeName(old_instruction->name()); ++ // Comment out this, because now all the ops will be kept in the same graph. ++ // new_instruction->SetAndSanitizeName(old_instruction->name()); + } + + TF_RETURN_IF_ERROR(RemoveInstructionAndUnusedOperands(old_instruction)); +@@ -1105,7 +1145,7 @@ std::unique_ptr HloComputation::CloneWithReplacements( + } + } + } +- } ++ } + + std::vector> instructions; + // First add the extra parameters to 'instructions'. +@@ -1171,4 +1211,461 @@ HloInstruction* HloComputation::GetInstructionWithName(absl::string_view name) { + bool HloComputation::IsEntryComputation() const { + return parent()->entry_computation() == this; + } ++ ++bool HloComputation::HasCycle(HloInstruction* inst) { ++ FunctionVisitor visitor( ++ [](HloInstruction* instruction) { return Status::OK(); }); ++ auto visit_status = inst->Accept(&visitor); ++ return !visit_status.ok(); ++} ++ ++bool HloComputation::HasCycle() { ++ return HasCycle(root_instruction()); ++}; ++ ++void HloComputation::set_dry(bool value) { ++ if (dry_ == value) { ++ return; ++ } ++ if (value == true) { ++ // turn on all the flags ++ dry_ = true; ++ for (HloInstruction* inst : instructions()) { ++ inst->set_dry(true); ++ } ++ CHECK_EQ(dry_new_instructions_.size(), 0); ++ CHECK_EQ(dry_new_instruction_iterators_.size(), 0); ++ CHECK_EQ(alternatives_.size(), 0); ++ CHECK_EQ(originals_.size(), 0); ++ } else { ++ // turn off all the flags ++ dry_ = false; ++ for (HloInstruction* inst : instructions()) { ++ inst->set_dry(false); ++ } ++ // check the number of new instructions ++ int num = dry_new_instructions_.size(); ++ if (num > 0) { ++ LOG(ERROR) << num << " instructions added in dry mode, original (" ++ << instruction_count() << ")"; ++ } ++ // append dry mode added instructions to this computation ++ for (std::unique_ptr& inst : dry_new_instructions_) { ++ HloInstruction* pinst = inst.get(); ++ pinst->set_dry(false); ++ instruction_iterators_[pinst] = ++ instructions_.insert(instructions_.end(), std::move(inst)); ++ } ++ // clear the dry mode buffer ++ dry_new_instructions_.clear(); ++ dry_new_instruction_iterators_.clear(); ++ ++ std::vector to_delete; ++ // Convert alternatives to instructions ++ // to keep everyone alive ++ for (const auto& kv : alternatives_) { ++ HloInstruction* original = kv.first; ++ for (const auto& kv2 : kv.second) { ++ HloInstruction* use = kv2.first; ++ const HloInstructionSet& alts = kv2.second; ++ std::vector all = {original}; ++ all.insert(all.end(), alts.begin(), alts.end()); ++ HloInstruction* kalt = AddInstruction( ++ HloInstruction::CreateAlternatives(original->shape(), all)); ++ if (use != nullptr) { ++ original->ReplaceUseWith(use, kalt); ++ } else { ++ CHECK_EQ(original->parent()->root_instruction(), original); ++ original->parent()->set_root_instruction(kalt); ++ } ++ if (HasCycle(kalt)) { ++ // Deconnect kalt and select Original, but defer deletion of itself ++ // and unused operands till the end, since some of its operands ++ // may be used by new alternative nodes added further down this loop ++ to_delete.push_back(kalt); ++ static_cast(kalt)->Select(0); ++ } ++ } ++ } ++ ++ for (auto kalt : to_delete) { ++ RemoveInstructionAndUnusedOperands(kalt); ++ } ++ Cleanup(); ++ alternatives_.clear(); ++ originals_.clear(); ++ } ++} ++ ++void HloComputation::RecordAlternatives( ++ HloInstruction* original, HloInstruction* alt, ++ const std::vector& uses) { ++ // E.g. in fusion, the fused node will be fused again. ++ while (originals_.contains(original)) { ++ original = originals_[original]; ++ } ++ for (auto* use : uses) { ++ alternatives_[original][use].insert(alt); ++ } ++ originals_[alt] = original; ++} ++ ++void HloComputation::RecordAlternatives(HloInstruction* original, ++ HloInstruction* alt) { ++ if (original->users().size() > 0) { ++ RecordAlternatives(original, alt, original->users()); ++ } else { ++ // If there's no user for original, it is likely that original is the root ++ // instruction ++ CHECK_EQ(original->parent()->root_instruction(), original); ++ RecordAlternatives(original, alt, {nullptr}); ++ } ++} ++ ++/** ++ * Remove all instructions (except root) that are not used, and all their deps ++ */ ++void HloComputation::Prune() { ++ int old_instruction_count = 0; ++ std::vector to_delete; ++ while (old_instruction_count != instruction_count()) { ++ old_instruction_count = instruction_count(); ++ to_delete.clear(); ++ ++ // Note, since sometimes a fusion instruction might be deleted before we ++ // get Pruning it's called computation, so it's not enough to check ++ // for IsFusionComputation ++ bool isFusionComputation = IsFusionComputation() && ++ (FusionInstruction() != nullptr); ++ if (!IsEntryComputation()) { ++ if (isFusionComputation) { ++ std::vector removed_param_indices; ++ HloInstruction* fusion_instr = FusionInstruction(); ++ for (int64_t i = 0; i < num_parameters(); ++i) { ++ HloInstruction* param = parameter_instruction(i); ++ if (param->IsDead()) { ++ removed_param_indices.push_back(i); ++ fusion_instr->DetachFrom(fusion_instr->mutable_operand(i)); ++ } ++ } ++ RemoveUnusedParametersFromFusedComputation(); ++ fusion_instr->RemoveOperandsAtAscendingIndices(removed_param_indices); ++ } ++ } ++ ++ for (HloInstruction* inst : instructions()) { ++ if (inst->IsDead()) { ++ to_delete.push_back(inst); ++ } ++ } ++ for (auto inst : to_delete) { ++ if (inst->opcode() != xla::HloOpcode::kParameter) { ++ LOG(ERROR) << "Removing side branch at " << inst->name(); ++ RemoveInstructionAndUnusedOperands(inst); ++ } ++ } ++ } ++ LOG(ERROR) << instruction_count() << " instructions remaining."; ++ Cleanup(); ++} ++ ++/** ++ * For root tuple instructions, remove duplicate operands and point the old ++ * GTE instructions at the remaining unique operands. Returns whether or not ++ * any tuple ops were deleted. ++ */ ++bool HloComputation::RemoveUnusedTupleOps(int iteration_limit) { ++ int loop_count = 0; ++ bool changed = false; ++ bool changed_this_iteration = true; ++ while (changed_this_iteration && loop_count < iteration_limit) { ++ changed_this_iteration = RemoveUnusedTupleOpsHelper(); ++ changed |= changed_this_iteration; ++ loop_count++; ++ } ++ // As a last pass, delink any unused tuple ops that are only utilized by ++ // other instructions in the computation ++ // I.e. even if the tuple operand is used by another instruction, if there ++ // is no GTE using it, delink it from the tuple root ++ changed |= RemoveUnusedTupleOpsHelper(/*delink_unused_tuple_ops*/ true); ++ return changed; ++} ++ ++bool HloComputation::RemoveUnusedTupleOpsHelper(bool delink_unused_tuple_ops) { ++ bool changed = false; ++ std::vector to_be_removed; ++ for (HloInstruction* inst : instructions()) { ++ if (inst->IsMultiOutputFusion()) { ++ ++ // Skip if this is the root instruction for the entire computation ++ if (inst == this->root_instruction()) { ++ continue; ++ } ++ ++ HloInstruction* tuple_inst = inst->fused_expression_root(); ++ HloComputation* fused_comp = inst->fused_instructions_computation(); ++ ++ absl::flat_hash_map instr_to_repr_idx; ++ std::vector op_to_be_removed; ++ ++ std::vector unused_instructions; ++ ++ int operand_count = tuple_inst->operand_count(); ++ op_to_be_removed.reserve(operand_count); ++ ++ int current_idx = 0; ++ bool cleanup_needed = false; ++ ++ std::vector old_to_new_tuple_idx(operand_count, -1); ++ ++ // Get all operands that are actually utilized by a GTE ++ std::vector is_utilized_by_gte(operand_count, false); ++ std::vector is_utilized_by_any(operand_count, false); ++ for (auto user_inst : inst->users()) { ++ auto gte = Cast(user_inst); ++ is_utilized_by_gte[gte->tuple_index()] = true; ++ is_utilized_by_any[gte->tuple_index()] = true; ++ } ++ // Some operands may not be used by a GTE, but they may be used ++ // by another instruction in the computation, so do not delete those ++ // as well. ++ for (int i = 0; i < operand_count; i++) { ++ HloInstruction* operand = tuple_inst->mutable_operand(i); ++ for (auto* user : operand->users()) { ++ if (user != tuple_inst) { ++ is_utilized_by_any[i] = true; ++ } ++ } ++ } ++ ++ current_idx = 0; ++ // Update the indices to account for any operands removed ++ operand_count = tuple_inst->operand_count(); ++ for (int i = 0; i < operand_count; i++) { ++ HloInstruction* operand = tuple_inst->mutable_operand(i); ++ // Only delete instructions that not used by any other instructions ++ if (!is_utilized_by_any[i]) { ++ cleanup_needed = true; ++ unused_instructions.push_back(operand); ++ op_to_be_removed.push_back(i); ++ } ++ else { ++ if (!is_utilized_by_gte[i] && delink_unused_tuple_ops) { ++ // If delink_unused_tuple_ops is set to true, ++ // even if an op is utilized by another instruction, delink it ++ // from the tuple if it is not utilized by a GTE ++ cleanup_needed = true; ++ op_to_be_removed.push_back(i); ++ tuple_inst->DetachFrom(operand); ++ } ++ else { ++ // Only increase the idx if it's a freshly seen and used ++ // tuple operand ++ old_to_new_tuple_idx[i] = current_idx; ++ instr_to_repr_idx[operand] = current_idx; ++ current_idx++; ++ } ++ } ++ } ++ ++ // There exists unused operands ++ if (cleanup_needed) { ++ changed = true; ++ // ------------------------------------------------------- ++ // Update the GTE to the new representative index ++ // ------------------------------------------------------- ++ int new_tuple_idx; ++ for (auto user_inst : inst->users()) { ++ auto gte = Cast(user_inst); ++ new_tuple_idx = old_to_new_tuple_idx[gte->tuple_index()]; ++ gte->set_tuple_index(new_tuple_idx); ++ } ++ ++ // ------------------------------------------------------- ++ // Remove all the unused tuple operands ++ // ------------------------------------------------------- ++ for (auto unused_inst : unused_instructions) { ++ unused_inst->clear_users(); ++ } ++ for (auto unused_inst : unused_instructions) { ++ fused_comp->RemoveInstructionAndUnusedOperands(unused_inst); ++ } ++ ++ // ------------------------------------------------------- ++ // Remove tuple instruction params that are now unused ++ // ------------------------------------------------------- ++ // When the tuple operands were removed, any of their unused ++ // operands were recursively removed as well, except for the ++ // instruction params. ++ std::vector removed_param_indices; ++ for (int64_t i = 0; i < fused_comp->num_parameters(); ++i) { ++ HloInstruction* param = fused_comp->parameter_instruction(i); ++ if (param->IsDead()) { ++ removed_param_indices.push_back(i); ++ to_be_removed.push_back(inst->mutable_operand(i)); ++ inst->DetachFrom(inst->mutable_operand(i)); ++ } ++ } ++ fused_comp->RemoveUnusedParametersFromFusedComputation(); ++ inst->RemoveOperandsAtAscendingIndices(removed_param_indices); ++ ++ // ------------------------------------------------------- ++ // Remove parent computation params that are now unused ++ // ------------------------------------------------------- ++ if (!IsEntryComputation() && IsFusionComputation()) { ++ RemoveUnusedParametersFromFusedComputation(); ++ } ++ ++ // ------------------------------------------------------- ++ // Adjust the tuple operands vector and shapes ++ // ------------------------------------------------------- ++ tuple_inst->RemoveOperandsAtAscendingIndices(op_to_be_removed); ++ ++ // Update the shape of the root tuple instruction and the fusion instr ++ // by removing the tuple shapes at the corresponding indices ++ tuple_inst->mutable_shape() ++ ->remove_tuple_shapes_at_ascending_indices(op_to_be_removed); ++ inst->mutable_shape() ++ ->remove_tuple_shapes_at_ascending_indices(op_to_be_removed); ++ ++ // ------------------------------------------------------- ++ // Handle case where only one tuple operand is left ++ // ------------------------------------------------------- ++ operand_count = tuple_inst->operand_count(); ++ // This is necessary, otherwise during horizontal-fusion, the hori ++ // fusion pass will treat this instruction as a non-tuple instruction ++ // since it only has one operand, leading to shape conflict ++ // during ReplaceInstruction ++ if (operand_count == 1) { ++ HloInstruction* sole_operand = tuple_inst->mutable_operand(0); ++ fused_comp->set_root_instruction(sole_operand); ++ CHECK_EQ(inst->users().size(), 1); ++ fused_comp->RemoveInstructionAndUnusedOperands(tuple_inst); ++ ++ HloInstruction* sole_gte = inst->users().at(0); ++ ++ // Create a new instruction with shape = that of the new root of the ++ // fused computation, which is = to the shape of its prior sole tuple ++ // operand ++ HloInstruction* new_inst = ++ AddInstruction(inst->CloneWithNewShape(sole_operand->shape())); ++ ++ // Remove the GTE instruction, since we no longer have ++ // a tuple as root ++ sole_gte->ReplaceAllUsesWith(new_inst); ++ ++ to_be_removed.push_back(inst); ++ to_be_removed.push_back(sole_gte); ++ } ++ } ++ } ++ } ++ ++ for (auto instruction : to_be_removed) { ++ auto inst_it = instruction_iterators_.find(instruction); ++ // Only delete if instruction hasn't already been deleted in a previous ++ // iteration of this loop ++ if (inst_it != instruction_iterators_.end()) { ++ RemoveInstructionAndUnusedOperands(instruction); ++ } ++ } ++ Cleanup(); ++ ++ return changed; ++} ++ ++/** ++ * For root tuple instructions, remove duplicate operands and point the old ++ * GTE instructions at the remaining unique operands ++ */ ++void HloComputation::RemoveDuplicateTupleOps() { ++ std::vector to_be_removed; ++ for (HloInstruction* inst : instructions()) { ++ if (inst->IsMultiOutputFusion()) { ++ // Skip if this is the root instruction for the entire computation ++ if (inst == this->root_instruction()) { ++ continue; ++ } ++ ++ HloInstruction* tuple_inst = inst->fused_expression_root(); ++ ++ absl::flat_hash_map representatives; ++ std::vector old_to_new_tuple_idx; ++ std::vector ops_to_be_removed; ++ int operand_count = tuple_inst->operand_count(); ++ ops_to_be_removed.reserve(operand_count); ++ old_to_new_tuple_idx.reserve(operand_count); ++ ++ int current_idx = 0; ++ int representative_idx; ++ ++ for (int i = 0; i < operand_count; i++) { ++ auto emplace_result = representatives.emplace( ++ tuple_inst->mutable_operand(i), ++ current_idx); ++ // emplace_result.second = false when we fail to emplace due to the ++ // key-value pair already existing, i.e. we've seen this tuple before ++ if (!emplace_result.second) { ++ // The representative idx of this duplicate is the idx where it ++ // first appears in the tuple ++ representative_idx = emplace_result.first->second; ++ // Save the index of the duplicate tuple to be removed later ++ ops_to_be_removed.push_back(i); ++ } ++ else { ++ representative_idx = current_idx; ++ // Only increase the idx if it's a freshly seen tuple ++ current_idx++; ++ } ++ old_to_new_tuple_idx[i] = representative_idx; ++ } ++ ++ // Update the GTE to the new representative index ++ int new_tuple_idx; ++ for (auto user_inst : inst->users()) { ++ auto gte = Cast(user_inst); ++ new_tuple_idx = old_to_new_tuple_idx[gte->tuple_index()]; ++ gte->set_tuple_index(new_tuple_idx); ++ } ++ ++ tuple_inst->RemoveOperandsAtAscendingIndices(ops_to_be_removed); ++ ++ // Update the shape of the root tuple instruction and the fusion instr ++ // by removing the tuple shapes at the corresponding indices ++ tuple_inst->mutable_shape() ++ ->remove_tuple_shapes_at_ascending_indices(ops_to_be_removed); ++ inst->mutable_shape() ++ ->remove_tuple_shapes_at_ascending_indices(ops_to_be_removed); ++ ++ // Dedup GTEs pointing to same tuple operand ++ absl::flat_hash_map ++ gte_representatives; ++ for (auto user_inst : inst->users()) { ++ auto gte = Cast(user_inst); ++ int tuple_idx = gte->tuple_index(); ++ ++ // Check if we've already seen a GTE with the same index, if so replace ++ // this duplicate with that original GTE ++ auto emplace_result = gte_representatives.emplace(tuple_idx, gte); ++ if (!emplace_result.second) { ++ HloGetTupleElementInstruction* rep_gte = emplace_result.first->second; ++ gte->ReplaceAllUsesWith(rep_gte); ++ to_be_removed.push_back(gte); ++ } ++ } ++ ++ } ++ } ++ for (auto instruction : to_be_removed) { ++ auto inst_it = instruction_iterators_.find(instruction); ++ // Only delete if instruction hasn't already been deleted in a previous ++ // iteration of this loop ++ if (inst_it != instruction_iterators_.end()) { ++ RemoveInstructionAndUnusedOperands(instruction); ++ } ++ } ++ Cleanup(); ++} ++ ++ + } // namespace xla +diff --git a/tensorflow/compiler/xla/service/hlo_computation.h b/tensorflow/compiler/xla/service/hlo_computation.h +index c1fa03e016c..d4997d28882 100644 +--- a/tensorflow/compiler/xla/service/hlo_computation.h ++++ b/tensorflow/compiler/xla/service/hlo_computation.h +@@ -584,6 +584,24 @@ class HloComputation { + // Returns true if a given instruction is marked dead in this computation. + bool IsMarkedAsDead(const HloInstruction* inst); + ++ bool dry() const { return dry_; } ++ void set_dry(bool value); ++ ++ void RecordAlternatives(HloInstruction* original, HloInstruction* alt); ++ void RecordAlternatives(HloInstruction* original, HloInstruction* alt, ++ const std::vector& uses); ++ ++ void Prune(); ++ ++ void RemoveDuplicateTupleOps(); ++ ++ bool RemoveUnusedTupleOps(int iteration_limit = 25); ++ bool RemoveUnusedTupleOpsHelper(bool delink_unused_tuple_ops = false); ++ ++ bool HasCycle(HloInstruction* inst); ++ ++ bool HasCycle(); ++ + private: + explicit HloComputation( + const std::string& name, int parameter_count, +@@ -676,6 +694,14 @@ class HloComputation { + + std::vector param_instructions_; + ++ bool dry_ = false; ++ InstructionList dry_new_instructions_; ++ absl::flat_hash_map ++ dry_new_instruction_iterators_; ++ HloInstructionMap> alternatives_; ++ ++ absl::flat_hash_map originals_; ++ + HloComputation(const HloComputation&) = delete; + HloComputation& operator=(const HloComputation&) = delete; + }; +diff --git a/tensorflow/compiler/xla/service/hlo_cost_analysis.cc b/tensorflow/compiler/xla/service/hlo_cost_analysis.cc +index 47a67de6a8f..01a16b3606d 100644 +--- a/tensorflow/compiler/xla/service/hlo_cost_analysis.cc ++++ b/tensorflow/compiler/xla/service/hlo_cost_analysis.cc +@@ -317,6 +317,11 @@ Status HloCostAnalysis::HandleDomain(const HloInstruction* domain) { + return Status::OK(); + } + ++Status HloCostAnalysis::HandleAlternatives(const HloInstruction*) { ++ return Status::OK(); ++} ++ ++ + /* static */ + int64_t HloCostAnalysis::GetDotFlops(const Shape& lhs_shape, + const Shape& result_shape, +diff --git a/tensorflow/compiler/xla/service/hlo_cost_analysis.h b/tensorflow/compiler/xla/service/hlo_cost_analysis.h +index b849fc3d8df..24df56b6692 100644 +--- a/tensorflow/compiler/xla/service/hlo_cost_analysis.h ++++ b/tensorflow/compiler/xla/service/hlo_cost_analysis.h +@@ -168,6 +168,7 @@ class HloCostAnalysis : public ConstDfsHloVisitor { + Status HandleScatter(const HloInstruction* scatter) override; + Status HandleGetDimensionSize(const HloInstruction* get_size) override; + Status HandleSetDimensionSize(const HloInstruction* set_size) override; ++ Status HandleAlternatives(const HloInstruction* alternatives) override; + Status FinishVisit(const HloInstruction* root) override; + + Status Preprocess(const HloInstruction* hlo) override; +diff --git a/tensorflow/compiler/xla/service/hlo_cse.cc b/tensorflow/compiler/xla/service/hlo_cse.cc +index 51981ddd5f2..275eca9f7c9 100644 +--- a/tensorflow/compiler/xla/service/hlo_cse.cc ++++ b/tensorflow/compiler/xla/service/hlo_cse.cc +@@ -267,6 +267,7 @@ StatusOr HloCSE::Run(HloModule* module) { + } + } + } ++ module->RemoveDuplicateTupleOps(); + return changed; + } + +diff --git a/tensorflow/compiler/xla/service/hlo_dce.cc b/tensorflow/compiler/xla/service/hlo_dce.cc +index b637ab0878e..45e70dfbe5c 100644 +--- a/tensorflow/compiler/xla/service/hlo_dce.cc ++++ b/tensorflow/compiler/xla/service/hlo_dce.cc +@@ -63,6 +63,9 @@ namespace xla { + computation->RemoveInstructionAndUnusedOperands(dead_root)); + changed = true; + } ++ changed |= computation->RemoveUnusedTupleOps(); ++ computation->Prune(); ++ + if (changed) { + VLOG(3) << "After dce:"; + XLA_VLOG_LINES(3, computation->ToString()); +diff --git a/tensorflow/compiler/xla/service/hlo_graph_dumper.cc b/tensorflow/compiler/xla/service/hlo_graph_dumper.cc +index a3015d28913..495ef335c0c 100644 +--- a/tensorflow/compiler/xla/service/hlo_graph_dumper.cc ++++ b/tensorflow/compiler/xla/service/hlo_graph_dumper.cc +@@ -1152,6 +1152,8 @@ ColorScheme HloDotDumper::GetInstructionColor(const HloInstruction* instr) { + case HloOpcode::kCustomCall: + case HloOpcode::kWhile: + return kDarkGreen; ++ case HloOpcode::kAlternatives: ++ return kDarkBlue; + } + } + +diff --git a/tensorflow/compiler/xla/service/hlo_instruction.cc b/tensorflow/compiler/xla/service/hlo_instruction.cc +index 7fbf934817e..b847b43385d 100644 +--- a/tensorflow/compiler/xla/service/hlo_instruction.cc ++++ b/tensorflow/compiler/xla/service/hlo_instruction.cc +@@ -1139,6 +1139,11 @@ HloInstruction::CreateRngBitGenerator(const Shape& shape, HloInstruction* state, + return CreateNary(shape, opcode, operands); + } + ++/* static */ std::unique_ptr HloInstruction::CreateAlternatives( ++ const Shape& shape, absl::Span operands) { ++ return absl::make_unique(shape, operands); ++} ++ + /* static */ std::unique_ptr HloInstruction::CreateMap( + const Shape& shape, absl::Span operands, + HloComputation* map_computation) { +@@ -2000,6 +2005,7 @@ std::unique_ptr HloInstruction::CloneWithNewOperands( + case HloOpcode::kSetDimensionSize: + case HloOpcode::kTriangularSolve: + case HloOpcode::kCholesky: ++ case HloOpcode::kAlternatives: + clone = CloneWithNewOperandsImpl(shape, new_operands, context); + break; + // Unary ops. +@@ -2364,6 +2370,10 @@ void HloInstruction::AppendOperand(HloInstruction* operand) { + + void HloInstruction::RemoveOperandsAtAscendingIndices( + absl::Span ascending_indices) { ++ if (dry_) { ++ return; ++ } ++ + if (ascending_indices.empty()) { + return; + } +@@ -2559,6 +2569,12 @@ bool HloInstruction::IdenticalSlowPath( + } + + void HloInstruction::RemoveUser(HloInstruction* user) { ++ // If it is touching the old graph, stop it ++ // else go ahead ++ if (dry_ && user->dry()) { ++ return; ++ } ++ + auto map_it = user_map_.find(user); + CHECK(map_it != user_map_.end()); + +@@ -2590,6 +2606,11 @@ Status HloInstruction::ReplaceUseWithDifferentShape( + VLOG(3) << "Replacing uses of " << name() << " in " << user->name() + << " with " << new_producer->name(); + ++ if (dry_) { ++ parent_->RecordAlternatives(this, new_producer); ++ return Status::OK(); ++ } ++ + RemoveUser(user); + + TF_RET_CHECK(absl::c_count(user->operands_, this) >= 0); +@@ -2623,6 +2644,11 @@ Status HloInstruction::ReplaceOperandWithDifferentShape( + return Status::OK(); + } + ++ if (dry_) { ++ parent_->RecordAlternatives(old_operand, new_operand); ++ return Status::OK(); ++ } ++ + operands_[operand_num] = new_operand; + + VLOG(3) << "Replacing operand " << operand_num << " of " << name() << " with " +@@ -2666,6 +2692,12 @@ Status HloInstruction::ReplaceAllUsesWith(HloInstruction* new_producer) { + Status HloInstruction::ReplaceAllUsesWithDifferentShape( + HloInstruction* new_producer) { + bool new_producer_is_user = false; ++ ++ if (dry_) { ++ parent_->RecordAlternatives(this, new_producer); ++ return Status::OK(); ++ } ++ + for (HloInstruction* user : users()) { + if (user == new_producer) { + // It's possible that new_producer is a user of this instruction as might +@@ -3629,6 +3661,8 @@ Status HloInstruction::Visit(DfsHloVisitorBase* visitor) { + return visitor->HandleCholesky(this); + case HloOpcode::kOptimizationBarrier: + return visitor->HandleOptimizationBarrier(this); ++ case HloOpcode::kAlternatives: ++ return visitor->HandleAlternatives(this); + + // These opcodes are not handled here. + case HloOpcode::kTrace: +diff --git a/tensorflow/compiler/xla/service/hlo_instruction.h b/tensorflow/compiler/xla/service/hlo_instruction.h +index 6c5555dda69..49bfad03303 100644 +--- a/tensorflow/compiler/xla/service/hlo_instruction.h ++++ b/tensorflow/compiler/xla/service/hlo_instruction.h +@@ -603,6 +603,9 @@ class HloInstruction { + const Shape& shape, HloOpcode opcode, + absl::Span operands); + ++ static std::unique_ptr CreateAlternatives( ++ const Shape& shape, absl::Span operands); ++ + // Creates a map instruction, where the computation (given by the handle) is + // applied element-wise to every element in operands (across the operands, + // at a given index) +@@ -1206,6 +1209,11 @@ class HloInstruction { + // Returns the number of users of this instruction. + int64_t user_count() const { return users_.size(); } + ++ // Removes all instructions from the user set ++ void clear_users() { ++ users_.clear(); ++ } ++ + // Returns the users of this instruction. + const std::vector& users() const { return users_; } + +@@ -1510,6 +1518,9 @@ class HloInstruction { + + bool IsCustomCall(absl::string_view target) const; + ++ bool dry() const { return dry_; } ++ void set_dry(bool value) { dry_ = value; } ++ + // Returns the sharding applied to this operator. + // REQUIRES: has_sharding() is true. + const HloSharding& sharding() const { +@@ -2109,6 +2120,9 @@ class HloInstruction { + void RemoveAllOperands() { operands_.clear(); } + + void RemoveOperandAt(int index) { ++ if (dry_) { ++ return; ++ } + operands_.erase(operands_.begin() + index); + } + +@@ -2323,6 +2337,7 @@ class HloInstruction { + // Intrusive flag used by HloComputation, whether this instruction has + // been marked as dead. + bool marked_as_dead_; ++ bool dry_ = false; + + HloInstruction(const HloInstruction&) = delete; + HloInstruction& operator=(const HloInstruction&) = delete; +diff --git a/tensorflow/compiler/xla/service/hlo_instructions.cc b/tensorflow/compiler/xla/service/hlo_instructions.cc +index e60dc6985f1..af9f9515148 100644 +--- a/tensorflow/compiler/xla/service/hlo_instructions.cc ++++ b/tensorflow/compiler/xla/service/hlo_instructions.cc +@@ -1833,7 +1833,12 @@ HloInstruction* HloFusionInstruction::CloneAndFuseInternal( + // fusion node. In this case, we don't need to clone + // 'instruction_to_fuse'. + CHECK(!in_operand_list); +- clone = instruction_to_fuse; ++ if (parent()->dry()) { // if dry mode, make a copy ++ clone = fused_instructions_computation()->AddInstruction( ++ instruction_to_fuse->Clone(/*suffix=*/"")); ++ } else { ++ clone = instruction_to_fuse; ++ } + } else { + clone = fused_instructions_computation()->AddInstruction( + instruction_to_fuse->Clone(/*suffix=*/"")); +@@ -1935,10 +1940,12 @@ HloInstruction* HloFusionInstruction::CloneAndFuseInternal( + } + int64_t index = tuple_elements.size(); + if (instruction_to_fuse->opcode() == HloOpcode::kTuple) { +- CHECK_EQ(clone, instruction_to_fuse); ++ if (!parent()->dry()) { // only check when it is not dry mode ++ CHECK_EQ(clone, instruction_to_fuse); ++ } + index -= clone->operand_count(); + std::vector to_be_removed; +- const auto& users = clone->users(); ++ const auto& users = instruction_to_fuse->users(); + to_be_removed.reserve(users.size()); + for (auto old_gte : users) { + CHECK_EQ(old_gte->opcode(), HloOpcode::kGetTupleElement); +@@ -2016,6 +2023,8 @@ Status HloFusionInstruction::DeduplicateFusionOperands() { + if (operands_to_remove.empty()) { + return Status::OK(); + } ++ // TODO(ohcy): Patch RemoveUnusedParameters to also handle operands, and then ++ // patch this function to account for operands removed in RemoveUnusedParams + TF_RETURN_IF_ERROR(fused_instructions_computation() + ->RemoveUnusedParametersFromFusedComputation()); + RemoveOperandsAtAscendingIndices(operands_to_remove); +@@ -3403,4 +3412,28 @@ HloRngBitGeneratorInstruction::CloneWithNewOperandsImpl( + shape, new_operands[0], algorithm()); + } + ++HloAlternatives::HloAlternatives(const Shape& shape, ++ absl::Span operands) ++ : HloInstruction(HloOpcode::kAlternatives, shape) { ++ for (auto operand : operands) { ++ AppendOperand(operand); ++ } ++} ++ ++void HloAlternatives::Select(int alternative_index) { ++ CHECK_LT(alternative_index, operand_count()); ++ HloInstruction* replace = mutable_operand(alternative_index); ++ std::vector alt_users = users(); ++ ReplaceUsesWith(alt_users, replace); ++ if (parent()->root_instruction() == this) { ++ parent()->set_root_instruction(replace); ++ } ++} ++ ++std::unique_ptr HloAlternatives::CloneWithNewOperandsImpl( ++ const Shape& shape, absl::Span new_operands, ++ HloCloneContext* /*context*/) const { ++ return absl::make_unique(shape, new_operands); ++} ++ + } // namespace xla +diff --git a/tensorflow/compiler/xla/service/hlo_instructions.h b/tensorflow/compiler/xla/service/hlo_instructions.h +index 38f2b90adb8..38fffde0e01 100644 +--- a/tensorflow/compiler/xla/service/hlo_instructions.h ++++ b/tensorflow/compiler/xla/service/hlo_instructions.h +@@ -2055,6 +2055,17 @@ class HloRngBitGeneratorInstruction : public HloInstruction { + RandomAlgorithm algorithm_; + }; + ++class HloAlternatives : public HloInstruction { ++ public: ++ HloAlternatives(const Shape& shape, ++ absl::Span operands); ++ void Select(int alternative_index); ++ ++ std::unique_ptr CloneWithNewOperandsImpl( ++ const Shape& shape, absl::Span new_operands, ++ HloCloneContext* context) const override; ++}; ++ + } // namespace xla + + #endif // TENSORFLOW_COMPILER_XLA_SERVICE_HLO_INSTRUCTIONS_H_ +diff --git a/tensorflow/compiler/xla/service/hlo_module.cc b/tensorflow/compiler/xla/service/hlo_module.cc +index ec800ff7b1e..03658189fd6 100644 +--- a/tensorflow/compiler/xla/service/hlo_module.cc ++++ b/tensorflow/compiler/xla/service/hlo_module.cc +@@ -796,6 +796,15 @@ std::vector HloModule::MakeNonfusionComputationsSorted() + return result; + } + ++std::vector HloModule::MakeFusionComputations() const { ++ std::vector result = MakeComputationPostOrder(); ++ result.erase(std::remove_if( ++ result.begin(), result.end(), ++ [](HloComputation* c) { return !c->IsFusionComputation(); }), ++ result.end()); ++ return result; ++} ++ + std::unique_ptr HloModule::Clone(const std::string& suffix) const { + return Clone(config(), suffix); + } +@@ -886,6 +895,33 @@ HloComputation* HloModule::GetComputationWithName(absl::string_view name) { + return it == computations_in_module.end() ? nullptr : *it; + } + ++uint64_t HloModule::CalledComputationHash() const { ++ return absl::HashOf(*this); ++} ++ ++void HloModule::Prune() { ++ auto computations = MakeComputationPostOrder(); ++ for (auto* computation : computations) { ++ computation->Prune(); ++ } ++ RemoveUnusedComputations(); ++} ++ ++void HloModule::SetDry(bool dry_mode) { ++ if (dry_mode != dry_mode_) { ++ for (xla::HloComputation* computation : MakeNonfusionComputations()) { ++ computation->set_dry(dry_mode); ++ } ++ dry_mode_ = dry_mode; ++ // Remove unused computations that might been orphaned during the ++ // set dry_off processes (e.g. alternatives deleted due to generating ++ // a cycle) ++ if (!dry_mode_) { ++ RemoveUnusedComputations(); ++ } ++ } ++} ++ + /* static */ std::atomic HloModule::next_unique_module_id_(0); + + } // namespace xla +diff --git a/tensorflow/compiler/xla/service/hlo_module.h b/tensorflow/compiler/xla/service/hlo_module.h +index a20f6cd383c..6ff756a5645 100644 +--- a/tensorflow/compiler/xla/service/hlo_module.h ++++ b/tensorflow/compiler/xla/service/hlo_module.h +@@ -167,6 +167,10 @@ class HloModule { + return H::combine(std::move(h), computations.size()); + } + ++ // Generates a hash value of an HLO module. Focuses on ++ // the call graphs between multiple computations. ++ uint64_t CalledComputationHash() const; ++ + // Gets the computations in this module. + // + // Returns a view of HloComputation*s, so you can iterate over this in the +@@ -210,6 +214,10 @@ class HloModule { + } + } + ++ void Prune(); ++ ++ void SetDry(bool dry_mode); ++ + // Compute and return a post order of all computations in the module. The sort + // is defined like so: if computation A has an instruction which calls + // computation B, then A will appear after B in the sort. +@@ -235,6 +243,8 @@ class HloModule { + // MakeNonfusionComputations(). + std::vector MakeNonfusionComputations() const; + ++ std::vector MakeFusionComputations() const; ++ + // Same as MakeNonfusionComputations() but sorting computations by content. + std::vector MakeNonfusionComputationsSorted() const; + +@@ -355,6 +365,20 @@ class HloModule { + + Status CheckUniqueNamesAndIdsForComputationsAndInstructions() const; + ++ // Dedup duplicate operands in Tuple instructions ++ void RemoveUnusedTupleOps() { ++ for (HloComputation* computation : computations()) { ++ computation->RemoveUnusedTupleOps(); ++ } ++ } ++ ++ // Dedup duplicate operands in Tuple instructions ++ void RemoveDuplicateTupleOps() { ++ for (HloComputation* computation : computations()) { ++ computation->RemoveDuplicateTupleOps(); ++ } ++ } ++ + // Checks if this config has a list of entry parameters' HLO shardings for + // SPMD. + bool has_spmd_parameters_shardings() const { +@@ -427,6 +451,8 @@ class HloModule { + return profile_info_list_; + } + ++ bool dry_mode() const { return dry_mode_; } ++ + void set_relative_speedup(double relative_speedup) { + relative_speedup_ = relative_speedup; + } +@@ -508,6 +534,9 @@ class HloModule { + + // The unoptimized module fingerprint. + std::string autofdo_fingerprint_; ++ ++ // Whether or not the module is currently in dry_mode ++ bool dry_mode_ = false;; + }; + + } // namespace xla +diff --git a/tensorflow/compiler/xla/service/hlo_opcode.h b/tensorflow/compiler/xla/service/hlo_opcode.h +index e58e6804e44..fb2c8777ef3 100644 +--- a/tensorflow/compiler/xla/service/hlo_opcode.h ++++ b/tensorflow/compiler/xla/service/hlo_opcode.h +@@ -59,6 +59,7 @@ namespace xla { + V(kAsyncUpdate, "async-update", 1) \ + V(kAsyncDone, "async-done", 1) \ + V(kAtan2, "atan2", 2) \ ++ V(kAlternatives, "alternatives", kHloOpcodeIsVariadic) \ + V(kBatchNormGrad, "batch-norm-grad", 5) \ + V(kBatchNormInference, "batch-norm-inference", 5) \ + V(kBatchNormTraining, "batch-norm-training", 3) \ +diff --git a/tensorflow/compiler/xla/service/hlo_parser.cc b/tensorflow/compiler/xla/service/hlo_parser.cc +index 4b93414d347..75ac81985dd 100644 +--- a/tensorflow/compiler/xla/service/hlo_parser.cc ++++ b/tensorflow/compiler/xla/service/hlo_parser.cc +@@ -87,6 +87,7 @@ bool CanInferShape(HloOpcode code) { + case HloOpcode::kAdd: + case HloOpcode::kAddDependency: + case HloOpcode::kAfterAll: ++ case HloOpcode::kAlternatives: + case HloOpcode::kAtan2: + case HloOpcode::kBatchNormGrad: + case HloOpcode::kBatchNormInference: +@@ -1339,6 +1340,23 @@ HloInstruction* HloParserImpl::CreateInstruction( // NOLINT + *shape, opcode, operands[0], operands[1], operands[2])); + } + // Other supported ops. ++ case HloOpcode::kAlternatives: { ++ if (!preset_operands && !ParseOperands(&operands, builder)) { ++ return nullptr; ++ } ++ if (!maybe_infer_shape([&] { ++ absl::InlinedVector arg_shapes; ++ arg_shapes.reserve(operands.size()); ++ for (auto* operand : operands) { ++ arg_shapes.push_back(&operand->shape()); ++ } ++ return ShapeInference::InferVariadicOpShape(opcode, arg_shapes); ++ })) { ++ return nullptr; ++ } ++ return builder->AddInstruction( ++ HloInstruction::CreateAlternatives(*shape, operands)); ++ } + case HloOpcode::kConvert: { + if ((!preset_operands && + !ParseOperands(&operands, builder, /*expected_size=*/1)) || +diff --git a/tensorflow/compiler/xla/service/hlo_pass_pipeline.cc b/tensorflow/compiler/xla/service/hlo_pass_pipeline.cc +index 6a542a67208..aaf80ebe109 100644 +--- a/tensorflow/compiler/xla/service/hlo_pass_pipeline.cc ++++ b/tensorflow/compiler/xla/service/hlo_pass_pipeline.cc +@@ -15,6 +15,7 @@ limitations under the License. + + #include "tensorflow/compiler/xla/service/hlo_pass_pipeline.h" + ++#include + #include + #include + +@@ -30,6 +31,7 @@ limitations under the License. + #include "tensorflow/compiler/xla/util.h" + #include "tensorflow/core/platform/errors.h" + #include "tensorflow/core/platform/logging.h" ++#include "tensorflow/core/util/env_var.h" + + namespace xla { + +@@ -287,4 +289,14 @@ StatusOr HloPassPipeline::RunOnModuleGroup(HloModuleGroup* module_group) { + module_group->module(0).config().debug_options()); + } + ++std::set HloPassPipeline::ExtractDrySandwichSetFromEnv() { ++ std::vector dry_passes; ++ TF_CHECK_OK(tensorflow::ReadStringsFromEnvVar( ++ /*env_var_name=*/"DRY", /*default_val=*/"", &dry_passes)); ++ return std::set(dry_passes.begin(), dry_passes.end()); ++} ++ ++std::set HloPassPipeline::dry_sandwich_set = ++ ExtractDrySandwichSetFromEnv(); ++ + } // namespace xla +diff --git a/tensorflow/compiler/xla/service/hlo_pass_pipeline.h b/tensorflow/compiler/xla/service/hlo_pass_pipeline.h +index 73b89c5d492..b2593163984 100644 +--- a/tensorflow/compiler/xla/service/hlo_pass_pipeline.h ++++ b/tensorflow/compiler/xla/service/hlo_pass_pipeline.h +@@ -18,13 +18,16 @@ limitations under the License. + + #include + #include ++#include + #include + #include + + #include "absl/memory/memory.h" + #include "absl/strings/str_cat.h" + #include "tensorflow/compiler/xla/service/compilation_stats.h" ++#include "tensorflow/compiler/xla/service/dry_mode.h" + #include "tensorflow/compiler/xla/service/hlo_module.h" ++#include "tensorflow/compiler/xla/service/hlo_pass_fix.h" + #include "tensorflow/compiler/xla/service/hlo_pass_interface.h" + #include "tensorflow/compiler/xla/statusor.h" + #include "tensorflow/compiler/xla/types.h" +@@ -33,6 +36,12 @@ namespace xla { + + class PhaseOrderPipeline; + ++template ++struct is_hlo_pass_fix : std::false_type {}; ++ ++template ++struct is_hlo_pass_fix> : std::true_type {}; ++ + // Pipeline of HLO passes. + class HloPassPipeline : public HloPassInterface { + public: +@@ -45,6 +54,36 @@ class HloPassPipeline : public HloPassInterface { + } + } + absl::string_view name() const override { return name_; } ++ static std::set dry_sandwich_set; ++ ++ // The helpers are used to detect HloPassFix, as the Fix passes will ++ // repeat internally, we can't sandwich it. ++ // TODO: find a solution for this, I think probably we need to remove the fix ++ // passes and iterate externally. ++ template ++ T& AddPassHelper(std::false_type, Args&&... args) { ++ CHECK(!run_called_) << "AddPass cannot be called after Run"; ++ auto pass = new T(std::forward(args)...); ++ std::string pass_name(pass->name()); ++ if (dry_sandwich_set.find(pass_name) != dry_sandwich_set.end()) { ++ LOG(ERROR) << "Sandwiching " << pass_name << " with dry mode on/off."; ++ passes_.push_back(std::make_unique()); ++ } ++ passes_.push_back(std::unique_ptr(pass)); ++ if (dry_sandwich_set.find(pass_name) != dry_sandwich_set.end()) { ++ passes_.push_back(std::make_unique()); ++ } ++ return *pass; ++ } ++ ++ template ++ T& AddPassHelper(std::true_type, Args&&... args) { ++ CHECK(!run_called_) << "AddPass cannot be called after Run"; ++ auto pass = new T(std::forward(args)...); ++ std::string pass_name(pass->name()); ++ passes_.push_back(std::unique_ptr(pass)); ++ return *pass; ++ } + + // Add a pass to the pipeline. It should be called with the arguments for the + // pass constructor: +@@ -54,10 +93,8 @@ class HloPassPipeline : public HloPassInterface { + // Returns a reference to the added pass. + template + T& AddPass(Args&&... args) { +- CHECK(!run_called_) << "AddPass cannot be called after Run"; +- auto pass = new T(std::forward(args)...); +- passes_.push_back(std::unique_ptr(pass)); +- return *pass; ++ return AddPassHelper(typename is_hlo_pass_fix::type(), ++ std::forward(args)...); + } + + // Add an invariant-checking pass to the pipeline. It will be run before and +@@ -89,6 +126,8 @@ class HloPassPipeline : public HloPassInterface { + // Return reference to pass specified by index. + HloPassInterface& GetPass(int index) { return *passes_[index]; } + ++ static std::set ExtractDrySandwichSetFromEnv(); ++ + private: + // Returns the set of passes which are enabled. DebugOptions can selectively + // disable passes via --xla_disable_hlo_passes flag. +diff --git a/tensorflow/compiler/xla/service/hlo_verifier.cc b/tensorflow/compiler/xla/service/hlo_verifier.cc +index b82223ca455..6c27d600a61 100644 +--- a/tensorflow/compiler/xla/service/hlo_verifier.cc ++++ b/tensorflow/compiler/xla/service/hlo_verifier.cc +@@ -1552,6 +1552,10 @@ Status ShapeVerifier::HandleSetDimensionSize(HloInstruction* set_size) { + set_size->operand(1)->shape(), set_size->dimension())); + } + ++Status ShapeVerifier::HandleAlternatives(HloInstruction* alternatives) { ++ return Status::OK(); ++} ++ + Status ShapeVerifier::CheckShape(const HloInstruction* instruction, + const Shape& inferred_shape, + bool only_compare_minor_to_major_in_layout) { +diff --git a/tensorflow/compiler/xla/service/hlo_verifier.h b/tensorflow/compiler/xla/service/hlo_verifier.h +index 998b70ec380..4513849d5de 100644 +--- a/tensorflow/compiler/xla/service/hlo_verifier.h ++++ b/tensorflow/compiler/xla/service/hlo_verifier.h +@@ -119,6 +119,7 @@ class ShapeVerifier : public DfsHloVisitor { + Status HandleGetDimensionSize(HloInstruction* get_size) override; + Status HandleSetDimensionSize(HloInstruction* set_size) override; + Status HandleAddDependency(HloInstruction* add_dependency) override; ++ Status HandleAlternatives(HloInstruction* alternatives) override; + + Status FinishVisit(HloInstruction*) override { return Status::OK(); } + +diff --git a/tensorflow/compiler/xla/service/instruction_fusion.cc b/tensorflow/compiler/xla/service/instruction_fusion.cc +index 1ae798fc4e9..33ac914a0cc 100644 +--- a/tensorflow/compiler/xla/service/instruction_fusion.cc ++++ b/tensorflow/compiler/xla/service/instruction_fusion.cc +@@ -459,11 +459,15 @@ class ReversePostOrderFusionQueue : public FusionQueue { + void OnFusingInstruction(HloInstruction* fusion, + HloInstruction* original_producer, + HloInstruction* original_consumer) override { +- // Fusing an instruction into a fusion instruction can change the operand +- // set of the fusion instruction. For simplicity just re-enqueue the +- // instruction and reconsider it for further fusion in the next iteration. +- InsertOrDie(&post_order_index_, fusion, post_order_.size()); +- post_order_.push_back(fusion); ++ // we turn dry run on for fusion, so that it won't be modified ++ if (fusion->parent()->dry()) { ++ fusion->set_dry(true); ++ } else { ++ // for dry run mode off, we re-insert into queue as usual ++ // so that it won't affect non-modified XLA passes. ++ InsertOrDie(&post_order_index_, fusion, post_order_.size()); ++ post_order_.push_back(fusion); ++ } + } + + void RemoveInstruction(HloInstruction* instruction) override { +@@ -707,6 +711,21 @@ HloInstruction* InstructionFusion::AddFusionInstruction( + HloInstruction* fusion_instruction; + auto kind = ChooseKind(producer, consumer); + if (consumer->opcode() == HloOpcode::kFusion) { ++ if (consumer->dry()) { ++ // Don't keep fusing into it, make a copy when consumer turns on ++ // dry run, we need a clone to continue adding. ++ // TODO(linmin): limit the depth of fusion to avoid combinatorial ++ // explosion ++ HloInstruction* consumer_clone = ++ consumer->parent()->AddInstruction(consumer->Clone()); ++ // Since this is in dry mode, this will trigger ++ // RecordAlternatives, which will trace down to the most original ++ // instruction that the fusion node is replacing. ++ // TODO(wangyzh): this could have problems when there're multiple outputs ++ // we need to handle this in multi_output_fusion ++ consumer->parent()->ReplaceInstruction(consumer, consumer_clone); ++ consumer = consumer_clone; ++ } + fusion_instruction = consumer; + if (kind != fusion_instruction->fusion_kind()) { + fusion_instruction->set_fusion_kind(kind); +diff --git a/tensorflow/compiler/xla/service/service.cc b/tensorflow/compiler/xla/service/service.cc +index 3ab70c0da3b..288e03e8e69 100644 +--- a/tensorflow/compiler/xla/service/service.cc ++++ b/tensorflow/compiler/xla/service/service.cc +@@ -284,6 +284,7 @@ StatusOr> Service::CreateModuleConfig( + aot_options); + } + ++// MARK: compilation call chain + StatusOr>> Service::BuildExecutables( + const std::vector& module_protos, + std::vector> module_configs, +@@ -779,6 +780,7 @@ Status Service::GetDeviceHandles(const GetDeviceHandlesRequest* arg, + return Status::OK(); + } + ++// MARK: compilation call chain + StatusOr> Service::BuildExecutable( + const HloModuleProto& module_proto, + std::unique_ptr module_config, Backend* backend, +@@ -793,6 +795,7 @@ StatusOr> Service::BuildExecutable( + CreateModuleFromProto(module_proto, *module_config, run_backend_only)); + DumpHloModuleIfEnabled(*module, kBeforeOptimizationsDumpName); + ++ // MARK: compilation call chain + if (!run_backend_only) { + TF_ASSIGN_OR_RETURN(module, backend->compiler()->RunHloPasses( + std::move(module), executor, options)); +diff --git a/tensorflow/compiler/xla/shape.h b/tensorflow/compiler/xla/shape.h +index e2c3089b445..abd42e5331f 100644 +--- a/tensorflow/compiler/xla/shape.h ++++ b/tensorflow/compiler/xla/shape.h +@@ -143,6 +143,29 @@ class Shape { + void clear_tuple_shapes() { tuple_shapes_.clear(); } + const std::vector& tuple_shapes() const { return tuple_shapes_; } + std::vector* mutable_tuple_shapes() { return &tuple_shapes_; } ++ void remove_tuple_shapes_at_ascending_indices( ++ absl::Span ascending_indices) { ++ if (ascending_indices.empty()) { ++ return; ++ } ++ int next_index = 0; ++ int removed_count = 0; ++ for (int to_remove : ascending_indices) { ++ while (next_index < to_remove) { ++ tuple_shapes_[next_index - removed_count] = tuple_shapes_[next_index]; ++ ++next_index; ++ } ++ CHECK_LT(to_remove, tuple_shapes_.size()); ++ ++removed_count; ++ ++next_index; ++ } ++ while (next_index < tuple_shapes_.size()) { ++ tuple_shapes_[next_index - removed_count] = tuple_shapes_[next_index]; ++ ++next_index; ++ } ++ CHECK_EQ(removed_count, ascending_indices.size()); ++ tuple_shapes_.resize(tuple_shapes_.size() - removed_count); ++ } + + // Methods for accessing the layout field. + bool has_layout() const { return layout_.format() != INVALID_FORMAT; } +diff --git a/tensorflow/compiler/xla/tests/BUILD b/tensorflow/compiler/xla/tests/BUILD +index 8b9738f15c0..12396a6cfea 100644 +--- a/tensorflow/compiler/xla/tests/BUILD ++++ b/tensorflow/compiler/xla/tests/BUILD +@@ -151,6 +151,7 @@ cc_library( + testonly = True, + srcs = ["hlo_test_base.cc"], + hdrs = ["hlo_test_base.h"], ++ visibility = ["//visibility:public"], + deps = [ + ":literal_test_util", + ":manifest_checking_test", +diff --git a/tensorflow/compiler/xla/tools/BUILD b/tensorflow/compiler/xla/tools/BUILD +index cc358660c72..a9a6add9175 100644 +--- a/tensorflow/compiler/xla/tools/BUILD ++++ b/tensorflow/compiler/xla/tools/BUILD +@@ -217,6 +217,7 @@ cc_library( + name = "hlo_extractor", + srcs = ["hlo_extractor.cc"], + hdrs = ["hlo_extractor.h"], ++ visibility = ["//visibility:public"], + deps = [ + "//tensorflow/compiler/xla:status", + "//tensorflow/compiler/xla/service:hlo", +@@ -230,6 +231,7 @@ cc_library( + tf_cc_binary( + name = "interactive_graphviz", + srcs = ["interactive_graphviz.cc"], ++ visibility = ["//visibility:public"], + deps = [ + ":hlo_extractor", + "//tensorflow/compiler/xla/service:hlo_graph_dumper", +@@ -262,7 +264,7 @@ cc_library( + name = "hlo_module_loader", + srcs = ["hlo_module_loader.cc"], + hdrs = ["hlo_module_loader.h"], +- visibility = ["//tensorflow/compiler/xla:friends"], ++ visibility = ["//visibility:public"], + deps = [ + "//tensorflow/compiler/xla:debug_options_flags", + "//tensorflow/compiler/xla:statusor", +diff --git a/tensorflow/core/BUILD b/tensorflow/core/BUILD +index 93bdd8402ac..255b3d8db43 100644 +--- a/tensorflow/core/BUILD ++++ b/tensorflow/core/BUILD +@@ -1299,6 +1299,7 @@ cc_library( + "@com_google_absl//absl/base:core_headers", + "//tensorflow/core/platform/default/build_config:platformlib", + ] + if_static([":lib_internal_impl"]), ++ visibility = ["//visibility:public"], + ) + + # Until we can ditch config=monolithic on windows, we have to provide an always +diff --git a/tensorflow/core/util/BUILD b/tensorflow/core/util/BUILD +index 8c267148fb7..1a1a48e9cb2 100644 +--- a/tensorflow/core/util/BUILD ++++ b/tensorflow/core/util/BUILD +@@ -596,6 +596,7 @@ cc_library( + name = "env_var", + srcs = ["env_var.cc"], + hdrs = ["env_var.h"], ++ visibility = ["//visibility:public"], + deps = [ + "//tensorflow/core/platform:errors", + "//tensorflow/core/platform:logging", +diff --git a/tensorflow/python/BUILD b/tensorflow/python/BUILD +index 3495b50db84..719d9030a3f 100644 +--- a/tensorflow/python/BUILD ++++ b/tensorflow/python/BUILD +@@ -4207,6 +4207,7 @@ alias( + alias( + name = "pybind11_lib", + actual = "//tensorflow/python/lib/core:pybind11_lib", ++ visibility = ["//visibility:public"], + ) + + alias( +diff --git a/tensorflow/workspace2.bzl b/tensorflow/workspace2.bzl +index d56d8ad9c7f..025db66156b 100644 +--- a/tensorflow/workspace2.bzl ++++ b/tensorflow/workspace2.bzl +@@ -835,6 +835,13 @@ def _tf_repositories(): + urls = tf_mirror_urls("https://github.com/nlohmann/json/archive/v3.4.0.tar.gz"), + ) + ++ tf_http_archive( ++ name = "pybind11_bazel", ++ urls = tf_mirror_urls("https://github.com/pybind/pybind11_bazel/archive/26973c0ff320cb4b39e45bc3e4297b82bc3a6c09.zip"), ++ sha256 = "a5666d950c3344a8b0d3892a88dc6b55c8e0c78764f9294e806d69213c03f19d", ++ strip_prefix = "pybind11_bazel-26973c0ff320cb4b39e45bc3e4297b82bc3a6c09", ++ ) ++ + tf_http_archive( + name = "pybind11", + urls = tf_mirror_urls("https://github.com/pybind/pybind11/archive/v2.9.0.tar.gz"), +diff --git a/tensorflow/xla_standalone/BUILD b/tensorflow/xla_standalone/BUILD +new file mode 100644 +index 00000000000..a97fe46dc7a +--- /dev/null ++++ b/tensorflow/xla_standalone/BUILD +@@ -0,0 +1,71 @@ ++load("//tensorflow:tensorflow.bzl", "tf_cc_binary") ++ ++package(default_visibility = ["//visibility:public"]) ++ ++tf_cc_binary( ++ name = "xla_compile", ++ srcs = ["xla_compile.cc"], ++ copts = [ ++ "-fexceptions", ++ ], ++ data = [ ++ "hlo_test.txt", ++ ], ++ deps = [ ++ ":hlo_graph", ++ "//tensorflow/compiler/jit:xla_gpu_jit", ++ "//tensorflow/compiler/xla:literal", ++ "//tensorflow/compiler/xla:literal_util", ++ "//tensorflow/compiler/xla:shape_util", ++ "//tensorflow/compiler/xla:status", ++ "//tensorflow/compiler/xla:statusor", ++ "//tensorflow/compiler/xla/pjrt:cpu_device", ++ "//tensorflow/compiler/xla/pjrt:gpu_device", ++ "//tensorflow/compiler/xla/pjrt:pjrt_client", ++ "//tensorflow/compiler/xla/service:hlo_pass_pipeline", ++ "//tensorflow/compiler/xla/service:hlo_proto_cc", ++ "//tensorflow/compiler/xla/tools:hlo_module_loader", ++ "@com_github_gflags_gflags//:gflags", ++ ], ++) ++ ++tf_cc_binary( ++ name = "graphviz", ++ srcs = ["graphviz.cc"], ++ copts = [ ++ "-fexceptions", ++ ], ++ deps = [ ++ "//tensorflow/compiler/xla/client:client_library", ++ "//tensorflow/compiler/xla/client:local_client", ++ "//tensorflow/compiler/xla/service:compiler", ++ "//tensorflow/compiler/xla/service:cpu_plugin", ++ "//tensorflow/compiler/xla/service:hlo_graph_dumper", ++ "//tensorflow/compiler/xla/service:hlo_proto_cc", ++ "//tensorflow/compiler/xla/service:hlo_runner", ++ "//tensorflow/compiler/xla/service:local_service", ++ "//tensorflow/compiler/xla/tools:hlo_extractor", ++ "//tensorflow/core:framework_internal", ++ "//tensorflow/core:lib", ++ "//tensorflow/core:protos_all_cc", ++ "@com_github_gflags_gflags//:gflags", ++ "@com_google_absl//absl/algorithm:container", ++ "@com_google_absl//absl/container:flat_hash_set", ++ "@com_google_absl//absl/strings", ++ ], ++) ++ ++cc_library( ++ name = "hlo_graph", ++ srcs = ["hlo_graph.cc"], ++ hdrs = ["hlo_graph.h"], ++ deps = [ ++ "//tensorflow/compiler/xla:types", ++ "//tensorflow/compiler/xla:util", ++ "//tensorflow/compiler/xla/service:hlo", ++ "//tensorflow/core:lib", ++ "//tensorflow/core:lib_internal", ++ "@com_google_absl//absl/base", ++ "@com_google_absl//absl/container:flat_hash_map", ++ ], ++) +diff --git a/tensorflow/xla_standalone/graphviz.cc b/tensorflow/xla_standalone/graphviz.cc +new file mode 100644 +index 00000000000..6ab2c1f16da +--- /dev/null ++++ b/tensorflow/xla_standalone/graphviz.cc +@@ -0,0 +1,155 @@ ++// Copyright 2022 Garena Online Private Limited. ++// ++// Licensed under the Apache License, Version 2.0 (the "License"); ++// you may not use this file except in compliance with the License. ++// You may obtain a copy of the License at ++// ++// http://www.apache.org/licenses/LICENSE-2.0 ++// ++// Unless required by applicable law or agreed to in writing, software ++// distributed under the License is distributed on an "AS IS" BASIS, ++// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++// See the License for the specific language governing permissions and ++// limitations under the License. ++// ++// Non-interactive version of xla/tools/interactive_graphviz ++#include ++#include ++#include ++ ++#include ++#include ++#include ++#include ++ ++#include "absl/algorithm/container.h" ++#include "absl/container/flat_hash_set.h" ++#include "absl/strings/match.h" ++#include "absl/strings/numbers.h" ++#include "absl/strings/str_cat.h" ++#include "absl/strings/str_join.h" ++#include "absl/strings/str_split.h" ++#include "tensorflow/compiler/xla/client/client_library.h" ++#include "tensorflow/compiler/xla/client/local_client.h" ++#include "tensorflow/compiler/xla/service/compiler.h" ++#include "tensorflow/compiler/xla/service/hlo.pb.h" ++#include "tensorflow/compiler/xla/service/hlo_runner.h" ++#include "tensorflow/compiler/xla/service/local_service.h" ++#include "tensorflow/compiler/xla/tools/hlo_extractor.h" ++#include "tensorflow/core/lib/io/path.h" ++#include "tensorflow/core/platform/init_main.h" ++#include "tensorflow/core/platform/logging.h" ++#include "tensorflow/core/platform/subprocess.h" ++#include "tensorflow/core/protobuf/error_codes.pb.h" ++#include "tensorflow/core/util/command_line_flags.h" ++ ++DEFINE_string(hlo, "-", "hlo text file"); // by default read from stdin ++DEFINE_string(html, "-", "the path to the generated html file"); ++DEFINE_string(browser, "/usr/bin/sensible-browser", ++ "default browser to view hlo graph."); ++ ++namespace xla { ++namespace tools { ++namespace { ++ ++void OpenUrl(absl::string_view url) { ++ std::cerr << url << std::endl; ++ ++ // If it is a url, try to open it up in the user's browser too. ++ if (absl::StartsWithIgnoreCase(url, "http://") || ++ absl::StartsWithIgnoreCase(url, "https://") || ++ absl::StartsWithIgnoreCase(url, "file://")) { ++ const char* browser_bin = FLAGS_browser.empty() ++ ? "/usr/bin/sensible-browser" ++ : FLAGS_browser.c_str(); ++ tensorflow::SubProcess p; ++ p.SetProgram(browser_bin, {browser_bin, std::string(url)}); ++ p.Start(); ++ } else { ++ std::cerr << "\nExpected a URL, but got strange graph result (dumped " ++ "above). If this isn't what you expected, maybe file a bug?" ++ << std::endl; ++ } ++} ++ ++void RenderAndDisplayGraph( ++ const std::function(RenderedGraphFormat)>& renderer) { ++ StatusOr url_result = renderer(RenderedGraphFormat::kUrl); ++ if (url_result.ok()) { ++ std::string url = url_result.ValueOrDie(); ++ OpenUrl(url); ++ return; ++ } ++ ++ // Ignore UNAVAILABLE errors; these are expected when there's no URL renderer ++ // plugin registered. ++ if (url_result.status().code() != tensorflow::error::UNAVAILABLE) { ++ std::cerr << "Unable to render graph as URL: " << url_result.status() ++ << std::endl; ++ std::cerr << "Trying as HTML..." << std::endl; ++ } ++ ++ auto* env = tensorflow::Env::Default(); ++ StatusOr html_result = renderer(RenderedGraphFormat::kHtml); ++ if (!html_result.ok()) { ++ std::cerr << "Failed to render graph as HTML: " << html_result.status() ++ << std::endl; ++ return; ++ } ++ ++ if (FLAGS_html == "-") { ++ std::cout << html_result.ValueOrDie() << std::endl; ++ } else { ++ std::string temp_file_path = tensorflow::io::JoinPath( ++ ".", absl::StrFormat("%s.%d.html", FLAGS_html, env->NowMicros())); ++ auto status = tensorflow::WriteStringToFile( ++ env, FLAGS_html, std::move(html_result).ValueOrDie()); ++ if (status.ok()) { ++ OpenUrl(absl::StrCat("file://", temp_file_path)); ++ return; ++ } ++ std::cerr << "Failed to write rendered HTML graph to " << temp_file_path ++ << ": " << status; ++ } ++ // We don't bother trying kDot, because kHTML should always work (or if it ++ // doesn't, we don't have any reason to believe kDot will work better). ++} ++ ++void GraphViz(HloModule* module) { ++ HloRenderOptions hlo_render_options; ++ hlo_render_options.show_backend_config = true; ++ hlo_render_options.show_fusion_subcomputations = true; ++ ++ const HloComputation* comp = module->entry_computation(); ++ RenderAndDisplayGraph([&](RenderedGraphFormat format) { ++ return xla::RenderGraph( ++ *comp, /*label=*/"", comp->parent()->config().debug_options(), format, ++ /*hlo_execution_profile=*/nullptr, hlo_render_options); ++ }); ++} ++ ++} // namespace ++} // namespace tools ++} // namespace xla ++ ++int main(int argc, char** argv) { ++ tensorflow::port::InitMain(argv[0], &argc, &argv); ++ gflags::ParseCommandLineFlags(&argc, &argv, true); ++ std::unique_ptr module; ++ if (FLAGS_hlo == "-") { ++ std::stringstream ss; ++ std::string s; ++ while (std::getline(std::cin, s)) { ++ ss << s << "\n"; ++ } ++ module = xla::HloRunner::CreateModuleFromString( ++ ss.str(), xla::GetDebugOptionsFromFlags()) ++ .ValueOrDie(); ++ } else { ++ module = xla::HloRunner::ReadModuleFromHloTextFile( ++ FLAGS_hlo, xla::GetDebugOptionsFromFlags()) ++ .ValueOrDie(); ++ } ++ xla::tools::GraphViz(module.get()); ++ return 0; ++} +diff --git a/tensorflow/xla_standalone/hlo_graph.cc b/tensorflow/xla_standalone/hlo_graph.cc +new file mode 100644 +index 00000000000..75d2134b129 +--- /dev/null ++++ b/tensorflow/xla_standalone/hlo_graph.cc +@@ -0,0 +1,360 @@ ++// Copyright 2022 Garena Online Private Limited. ++// ++// Licensed under the Apache License, Version 2.0 (the "License"); ++// you may not use this file except in compliance with the License. ++// You may obtain a copy of the License at ++// ++// http://www.apache.org/licenses/LICENSE-2.0 ++// ++// Unless required by applicable law or agreed to in writing, software ++// distributed under the License is distributed on an "AS IS" BASIS, ++// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++// See the License for the specific language governing permissions and ++// limitations under the License. ++ ++#include "tensorflow/xla_standalone/hlo_graph.h" ++ ++#include ++ ++#include "absl/base/casts.h" ++#include "tensorflow/compiler/xla/map_util.h" ++#include "tensorflow/compiler/xla/service/hlo_opcode.h" ++#include "tensorflow/compiler/xla/types.h" ++#include "tensorflow/core/lib/core/status.h" ++#include "tensorflow/core/platform/types.h" ++ ++namespace xla { ++ ++HloGraph::HloGraph(const HloModule* m) ++ : parent_hlo_module_(const_cast(m)), ++ uid_(m->unique_id()), ++ name_(m->name()) { ++ Build(m); ++} ++ ++void HloGraph::Clear() { ++ node_feats.Clear(); ++ in_edge_feats.Clear(); ++ out_edge_feats.Clear(); ++ user_list_offsets.clear(); ++ operand_list_offsets.clear(); ++ user_list_indices.clear(); ++ operand_list_indices.clear(); ++ alternative_indices_.clear(); ++ uid_to_node_ind_.clear(); ++ uid_to_inst_.clear(); ++} ++ ++bool HloGraph::Build(const HloModule* m) { ++ int gid = -1; ++ int node_ind = 0; ++ Clear(); ++ ++ std::vector inst_list; ++ ++ // Since CSR/CSC is a flatten linear structure where each item's ++ // global index needs to be decided first before values being ++ // filled up. We need to first compute the sizes/offsets, then ++ // put indices into the neighbor list array (xxx_indices). ++ for (auto c : m->MakeComputationPostOrder()) { ++ gid++; ++ for (auto inst : c->MakeInstructionPostOrder()) { ++ inst_list.push_back(inst); ++ int uid = inst->unique_id(); ++ std::string name = inst->name(); ++ ++ // Add to node_feats ++ node_feats.uids.push_back(uid); ++ node_feats.names.push_back(name); ++ node_feats.gids.push_back(gid); ++ ++ // Add to offsets ++ user_list_offsets.push_back(inst->user_count()); ++ if (inst->called_computations().empty()) { ++ operand_list_offsets.push_back(inst->operand_count()); ++ } else { ++ // if instruction calls computation(s), it should have ++ // no operand other than that computation's root instruction. ++ // current operands will all point to that computation's ++ // params. ++ operand_list_offsets.push_back(0); ++ } ++ ++ // add uid to node id hash map ++ // when we build neighbor list we will need these indices. ++ uid_to_node_ind_.insert({uid, node_ind++}); ++ uid_to_inst_.insert({uid, inst}); ++ } ++ } ++ ++ // For instruction that calls computations, we: ++ // 1) add instruction as its computation's root inst's extra user ++ // 2) connect instruction's operands to its called computation's params in ++ // order ++ // 2.1) for instruction's each operand, add one user ++ // 2.2) for each called computation's param, add one operand ++ ++ // Update user/operand count ++ for (auto inst : inst_list) { ++ int uid = inst->unique_id(); ++ auto called_comps = inst->called_computations(); ++ if (called_comps.size() > 0) { ++ // for kCall and kFusion, called_comps.size() should be 1 ++ // for kWhile and kCondition, called_comps.size() should be 2 ++ // and body_func/cond_func in kWhile and cond_true/cond_false func ++ // in kCondition share the same set of param. ++ // So it's safe to apply operand of current instruction to ++ // both computations's params. ++ ++ // add one operand count to current instruction (from called comp). ++ operand_list_offsets[uid_to_node_ind_[uid]]++; ++ for (auto cc : called_comps) { ++ int cc_uid = cc->root_instruction()->unique_id(); ++ user_list_offsets[uid_to_node_ind_[cc_uid]]++; ++ for (auto param : cc->parameter_instructions()) { ++ int param_uid = param->unique_id(); ++ // add operand count to called comp's each parameter instruction. ++ operand_list_offsets[uid_to_node_ind_[param_uid]]++; ++ } ++ } ++ } ++ } ++ ++ // running offsets are used to keep track of inserting indices ++ // when creating column indices arrays. ++ std::vector running_user_offset; ++ std::vector running_operand_offset; ++ size_t user_offset = 0; ++ size_t operand_offset = 0; ++ ++ // compute exclusive prefix sum ++ for (int i = 0; i < user_list_offsets.size(); ++i) { ++ auto inst = uid_to_inst_[node_feats.uids[i]]; ++ size_t ucount = user_list_offsets[i]; ++ size_t opcount = operand_list_offsets[i]; ++ node_feats.num_users.push_back(ucount); ++ node_feats.num_operands.push_back(opcount); ++ user_list_offsets[i] = user_offset; ++ operand_list_offsets[i] = operand_offset; ++ running_user_offset.push_back(user_offset); ++ running_operand_offset.push_back(operand_offset); ++ user_offset += ucount; ++ operand_offset += opcount; ++ } ++ user_list_offsets.push_back(user_offset); ++ operand_list_offsets.push_back(operand_offset); ++ user_list_indices.resize(user_offset); ++ operand_list_indices.resize(operand_offset); ++ ++ // prepare column indices ++ for (auto inst : inst_list) { ++ // find current node's index in offsets lists ++ // and insert node indices of its users and operands ++ // to according indices lists. ++ int uid = inst->unique_id(); ++ int node_idx = uid_to_node_ind_[uid]; ++ int empty_comp_ucount = 0; ++ ++ // Handle cases when instruction's called computation is empty. ++ auto called_comps = inst->called_computations(); ++ for (auto u : inst->users()) { ++ if (u->called_computations().empty()) { ++ user_list_indices[running_user_offset[node_idx]++] = ++ uid_to_node_ind_[u->unique_id()]; ++ } ++ } ++ if (called_comps.empty()) { ++ for (auto u : inst->operands()) { ++ operand_list_indices[running_operand_offset[node_idx]++] = ++ uid_to_node_ind_[u->unique_id()]; ++ } ++ } ++ ++ // Handle cases when instruction with called_computations: ++ auto operands = inst->operands(); ++ if (called_comps.size() > 0) { ++ for (auto cc : called_comps) { ++ auto params = cc->parameter_instructions(); ++ // 1. make sure number of operands of current instruction equals to ++ // each called_computation's parameter count. (as mentioned above they ++ // should have a one-to-one mapping) ++ CHECK_EQ(params.size(), operands.size()); ++ ++ // 2. at each index, add comp's param as user to inst's operand ++ // 3. at each index, add inst's operand as operand to comp's param ++ for (int idx = 0; idx < params.size(); ++idx) { ++ int operand_inst_idx = uid_to_node_ind_[operands[idx]->unique_id()]; ++ int param_inst_idx = uid_to_node_ind_[params[idx]->unique_id()]; ++ user_list_indices[running_user_offset[operand_inst_idx]++] = ++ param_inst_idx; ++ operand_list_indices[running_operand_offset[param_inst_idx]++] = ++ operand_inst_idx; ++ } ++ } ++ // 4. for root instruction of each computation, add curent node index ++ // to their user list indices. ++ for (auto cc : called_comps) { ++ int cc_uid = cc->root_instruction()->unique_id(); ++ int cc_root_inst_idx = uid_to_node_ind_[cc_uid]; ++ ++ // 5. for current node, add each computation's root instruction as its ++ // operand. add current instruction as computation's root instruction's ++ // user. ++ user_list_indices[running_user_offset[cc_root_inst_idx]++] = node_idx; ++ operand_list_indices[running_operand_offset[node_idx]++] = ++ cc_root_inst_idx; ++ } ++ } ++ } ++ ++ // add to edge features ++ // uids, srcs, dsts, shapes, layouts, dtypes ++ auto genuid = [](int src_uid, int dst_uid) -> int64_t { ++ int64_t suid = absl::bit_cast(src_uid); ++ int64_t duid = absl::bit_cast(dst_uid); ++ return (suid << 32) | duid; ++ }; ++ for (int i = 0; i < user_list_offsets.size() - 1; ++i) { ++ size_t user_offset = user_list_offsets[i]; ++ size_t operand_offset = operand_list_offsets[i]; ++ int cur_uid = node_feats.uids[i]; ++ auto cur_inst = uid_to_inst_[cur_uid]; ++ ++ if (cur_inst->opcode() == HloOpcode::kAlternatives) { ++ alternative_indices_.push_back(i); ++ } ++ for (int s = user_offset; s < user_list_offsets[i + 1]; ++s) { ++ int user_node_idx = user_list_indices[s]; ++ int user_uid = node_feats.uids[user_node_idx]; ++ auto user_inst = uid_to_inst_[user_uid]; ++ ++ // add to out edge features ++ int64_t euid = genuid(cur_uid, user_uid); ++ out_edge_feats.uids.push_back(euid); ++ out_edge_feats.srcs.push_back(i); ++ out_edge_feats.dsts.push_back(user_node_idx); ++ // put in shapes, layouts, and dtypes for cur_inst ++ Shape shape = cur_inst->shape(); ++ auto minor_to_major = shape.layout().minor_to_major(); ++ int dim_size = shape.dimensions_size(); ++ for (int k = 0; k < 8; ++k) { ++ if (k < dim_size) { ++ out_edge_feats.dims.push_back(shape.dimensions(k)); ++ out_edge_feats.layouts.push_back(minor_to_major[k]); ++ } else { ++ out_edge_feats.dims.push_back(-1); ++ out_edge_feats.layouts.push_back(-1); ++ } ++ } ++ out_edge_feats.dtypes.push_back(shape.element_type()); ++ } ++ for (int s = operand_offset; s < operand_list_offsets[i + 1]; ++s) { ++ int operand_node_idx = operand_list_indices[s]; ++ int operand_uid = node_feats.uids[operand_node_idx]; ++ auto operand_inst = uid_to_inst_[operand_uid]; ++ ++ // add to out edge features ++ int64_t euid = genuid(operand_uid, cur_uid); ++ in_edge_feats.uids.push_back(euid); ++ in_edge_feats.srcs.push_back(operand_node_idx); ++ in_edge_feats.dsts.push_back(i); ++ // put in shapes, layouts, and dtypes for operand_inst ++ Shape shape = operand_inst->shape(); ++ auto minor_to_major = shape.layout().minor_to_major(); ++ int dim_size = shape.dimensions_size(); ++ for (int k = 0; k < 8; ++k) { ++ if (k < dim_size) { ++ in_edge_feats.dims.push_back(shape.dimensions(k)); ++ in_edge_feats.layouts.push_back(minor_to_major[k]); ++ } else { ++ in_edge_feats.dims.push_back(-1); ++ in_edge_feats.layouts.push_back(-1); ++ } ++ } ++ in_edge_feats.dtypes.push_back(shape.element_type()); ++ } ++ } ++ ++ // final touch, add the root_index ++ int entry_root_uid = m->entry_computation()->root_instruction()->unique_id(); ++ root_index_ = uid_to_node_ind_[entry_root_uid]; ++ ++ LOG(ERROR) << "HloGraph build finished"; ++ ++ return true; ++} ++ ++void HloGraph::ShowStats() { ++ auto oedge_offsets = get_out_edge_offsets(); ++ auto iedge_offsets = get_in_edge_offsets(); ++ auto oedge_indices = get_out_edge_indices(); ++ auto iedge_indices = get_in_edge_indices(); ++ LOG(ERROR) << "module name: " << name_; ++ LOG(ERROR) << "number of nodes: " << oedge_offsets.size() - 1; ++ LOG(ERROR) << "number of in edges: " << iedge_offsets.back(); ++ LOG(ERROR) << "number of out edges: " << oedge_offsets.back(); ++ LOG(ERROR) << "================================"; ++ ++ auto print_vector = [](int64_t* vec) -> std::string { ++ std::string os; ++ os = "["; ++ for (int i = 0; i < 8; ++i) { ++ os += std::to_string(vec[i]); ++ os += ","; ++ } ++ os += "]"; ++ return os; ++ }; ++ ++ auto names = get_node_names(); ++ auto gids = get_gids(); ++ auto ucounts = get_user_counts(); ++ auto opcounts = get_operand_counts(); ++ ++ auto oedge_uids = get_out_edge_uids(); ++ auto oedge_srcs = get_out_edge_srcs(); ++ auto oedge_dsts = get_out_edge_dsts(); ++ auto oedge_dims = get_out_edge_dims(); ++ auto oedge_layouts = get_out_edge_layouts(); ++ auto oedge_dtypes = get_out_edge_dtypes(); ++ ++ auto iedge_uids = get_in_edge_uids(); ++ auto iedge_srcs = get_in_edge_srcs(); ++ auto iedge_dsts = get_in_edge_dsts(); ++ auto iedge_dims = get_in_edge_dims(); ++ auto iedge_layouts = get_in_edge_layouts(); ++ auto iedge_dtypes = get_in_edge_dtypes(); ++ ++ for (int i = 0; i < oedge_offsets.size() - 1; ++i) { ++ LOG(ERROR) << "node index: " << i; ++ LOG(ERROR) << "node name: " << names[i]; ++ LOG(ERROR) << "gid: " << gids[i]; ++ LOG(ERROR) << "user_count: " << ucounts[i]; ++ LOG(ERROR) << "operand_count: " << opcounts[i]; ++ int start_idx = oedge_offsets[i]; ++ int end_idx = oedge_offsets[i + 1]; ++ for (int ii = start_idx; ii < end_idx; ++ii) { ++ int idx = oedge_indices[ii]; ++ LOG(ERROR) << " out edge: " << idx << " " << names[idx]; ++ LOG(ERROR) << " " << oedge_uids[ii] << " | " << oedge_srcs[ii] << "->" ++ << oedge_dsts[ii]; ++ LOG(ERROR) << " dims: " << print_vector(&oedge_dims[ii * 8]); ++ LOG(ERROR) << " layouts: " << print_vector(&oedge_layouts[ii * 8]); ++ LOG(ERROR) << " dtype: " << oedge_dtypes[ii]; ++ } ++ start_idx = iedge_offsets[i]; ++ end_idx = iedge_offsets[i + 1]; ++ for (int ii = start_idx; ii < end_idx; ++ii) { ++ int idx = iedge_indices[ii]; ++ LOG(ERROR) << " in edge: " << idx << " " << names[idx]; ++ LOG(ERROR) << " " << iedge_uids[ii] << " | " << iedge_srcs[ii] << "->" ++ << iedge_dsts[ii]; ++ LOG(ERROR) << " dims: " << print_vector(&iedge_dims[ii * 8]); ++ LOG(ERROR) << " layouts: " << print_vector(&iedge_layouts[ii * 8]); ++ LOG(ERROR) << " dtype: " << iedge_dtypes[ii]; ++ } ++ LOG(ERROR) << "--------------------------------"; ++ } ++} ++ ++} // namespace xla +diff --git a/tensorflow/xla_standalone/hlo_graph.h b/tensorflow/xla_standalone/hlo_graph.h +new file mode 100644 +index 00000000000..8e491dd2720 +--- /dev/null ++++ b/tensorflow/xla_standalone/hlo_graph.h +@@ -0,0 +1,202 @@ ++// Copyright 2022 Garena Online Private Limited. ++// ++// Licensed under the Apache License, Version 2.0 (the "License"); ++// you may not use this file except in compliance with the License. ++// You may obtain a copy of the License at ++// ++// http://www.apache.org/licenses/LICENSE-2.0 ++// ++// Unless required by applicable law or agreed to in writing, software ++// distributed under the License is distributed on an "AS IS" BASIS, ++// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++// See the License for the specific language governing permissions and ++// limitations under the License. ++ ++#ifndef TENSORFLOW_XLA_STANDALONE_HLO_GRAPH_H_ ++#define TENSORFLOW_XLA_STANDALONE_HLO_GRAPH_H_ ++ ++#include ++#include ++#include ++#include ++#include ++ ++#include "absl/container/flat_hash_map.h" ++#include "absl/container/inlined_vector.h" ++#include "tensorflow/compiler/xla/service/hlo_computation.h" ++#include "tensorflow/compiler/xla/service/hlo_instruction.h" ++#include "tensorflow/compiler/xla/service/hlo_module.h" ++ ++namespace xla { ++ ++// NodeFeatures holds all tensors with #node length ++// uids: unique_id of HloInstruction ++// names: opcode in string ++// gids: sub-computation id HloInstruction belongs to ++// num_users: number of outgoing edges (users and called computations) ++// num_operands: number of incoming edges (operands) ++struct NodeFeats { ++ std::vector uids; ++ std::vector names; ++ std::vector gids; ++ std::vector num_users; ++ std::vector num_operands; ++ ++ void Clear() { ++ uids.clear(); ++ names.clear(); ++ gids.clear(); ++ num_users.clear(); ++ num_operands.clear(); ++ } ++}; ++ ++// EdgeFeatures holds all tensors with #edge length ++// uids: unique_id of both src and dst node. ++// srcs: indices of source nodes ++// dsts: indices of destination nodes ++// dims: a fixed-length (8) array to present tensor shape ++// layouts: a fixed-length (8) array to present tensor layout ++// dtypes: tensor dtype ++// enum PrimitiveType { ++// S16 = 0, ++// S32, ++// S64, ++// U8, ++// U16, ++// U32, ++// U64, ++// F16, ++// BF16, ++// F32, ++// F64, ++// C64, ++// C128 ++// }; ++struct EdgeFeats { ++ std::vector uids; ++ std::vector srcs; ++ std::vector dsts; ++ std::vector dims; ++ std::vector layouts; ++ // PrimitiveType as is defined in xla_data.proto. ++ std::vector dtypes; ++ ++ void Clear() { ++ uids.clear(); ++ srcs.clear(); ++ dsts.clear(); ++ dims.clear(); ++ layouts.clear(); ++ dtypes.clear(); ++ } ++}; ++ ++// A class for representing a HLO graph in the module ++// ++// To make things simpler, only string, f32, i32, and i64 are allowed as dtype. ++// ++class HloGraph { ++ public: ++ HloGraph() {} ++ explicit HloGraph(const HloModule* m); ++ ++ bool Build(const HloModule* m); ++ ++ void Clear(); ++ ++ void ShowStats(); ++ ++ // return CSR/CSC ++ std::vector& get_out_edge_offsets() { return user_list_offsets; } ++ std::vector& get_out_edge_indices() { return user_list_indices; } ++ std::vector& get_in_edge_offsets() { return operand_list_offsets; } ++ std::vector& get_in_edge_indices() { return operand_list_indices; } ++ ++ // return node features. ++ const std::vector& get_node_uids() { return node_feats.uids; } ++ const std::vector& get_node_names() { return node_feats.names; } ++ const std::vector& get_gids() { return node_feats.gids; } ++ const std::vector& get_user_counts() { return node_feats.num_users; } ++ const std::vector& get_operand_counts() { ++ return node_feats.num_operands; ++ } ++ ++ // return edge features. ++ const std::vector& get_in_edge_uids() { return in_edge_feats.uids; } ++ const std::vector& get_in_edge_srcs() { return in_edge_feats.srcs; } ++ const std::vector& get_in_edge_dsts() { return in_edge_feats.dsts; } ++ const std::vector& get_in_edge_dims() { return in_edge_feats.dims; } ++ const std::vector& get_in_edge_layouts() { ++ return in_edge_feats.layouts; ++ } ++ const std::vector& get_in_edge_dtypes() { ++ return in_edge_feats.dtypes; ++ } ++ ++ const std::vector& get_out_edge_uids() { ++ return out_edge_feats.uids; ++ } ++ const std::vector& get_out_edge_srcs() { return out_edge_feats.srcs; } ++ const std::vector& get_out_edge_dsts() { return out_edge_feats.dsts; } ++ const std::vector& get_out_edge_dims() { ++ return out_edge_feats.dims; ++ } ++ const std::vector& get_out_edge_layouts() { ++ return out_edge_feats.layouts; ++ } ++ const std::vector& get_out_edge_dtypes() { ++ return out_edge_feats.dtypes; ++ } ++ ++ NodeFeats& get_node_feats() { return node_feats; } ++ EdgeFeats& get_in_edge_feats() { return in_edge_feats; } ++ EdgeFeats& get_out_edge_feats() { return out_edge_feats; } ++ ++ std::vector& get_alternative_indices() { return alternative_indices_; } ++ absl::flat_hash_map& get_uid_to_inst() { ++ return uid_to_inst_; ++ } ++ ++ // TODO(wangyzh): add more utility functions ++ ++ // something I can think of now: ++ // get neighbors (up to some layers with samples) ++ // see if one edge is cross computation ++ // a lot of others we need to decide whether to do them in python ++ // or here. Since a lot of them are filters with different ++ // pre-conditions. ++ ++ private: ++ HloModule* parent_hlo_module_; ++ int uid_; ++ std::string name_; ++ // Use CSR to represent graph (and CSC inverse graph) topology ++ std::vector user_list_offsets; ++ std::vector user_list_indices; ++ std::vector operand_list_offsets; ++ std::vector operand_list_indices; ++ ++ // Ignore control deps for now ++ // utility to lookup node and its neighbor ++ absl::flat_hash_map uid_to_node_ind_; ++ absl::flat_hash_map uid_to_inst_; ++ ++ private: ++ // Indices of alternative nodes ++ std::vector alternative_indices_; ++ ++ // index of root instruction of entry computation ++ int root_index_; ++ ++ // Node features ++ NodeFeats node_feats; ++ ++ // Edge features ++ EdgeFeats in_edge_feats; ++ EdgeFeats out_edge_feats; ++}; ++ ++} // namespace xla ++ ++#endif // TENSORFLOW_XLA_STANDALONE_HLO_GRAPH_H_ +diff --git a/tensorflow/xla_standalone/hlo_test.txt b/tensorflow/xla_standalone/hlo_test.txt +new file mode 100644 +index 00000000000..ecfbc31eada +--- /dev/null ++++ b/tensorflow/xla_standalone/hlo_test.txt +@@ -0,0 +1,169 @@ ++HloModule jit_train_step.151 ++ ++%primitive_computation_add__6.23 (parameter.24: f32[], parameter.25: f32[]) -> f32[] { ++ %constant.26 = pred[] constant(false) ++ %parameter.24 = f32[] parameter(0) ++ %parameter.25 = f32[] parameter(1) ++ ROOT %add.27 = f32[] add(f32[] %parameter.24, f32[] %parameter.25), metadata={op_type="add" op_name="add" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++} ++ ++%primitive_computation_add__7.36 (parameter.37: f32[], parameter.38: f32[]) -> f32[] { ++ %constant.39 = pred[] constant(false) ++ %parameter.37 = f32[] parameter(0) ++ %parameter.38 = f32[] parameter(1) ++ ROOT %add.40 = f32[] add(f32[] %parameter.37, f32[] %parameter.38), metadata={op_type="add" op_name="add" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++} ++ ++%primitive_computation_add__8.48 (parameter.49: f32[], parameter.50: f32[]) -> f32[] { ++ %constant.51 = pred[] constant(false) ++ %parameter.49 = f32[] parameter(0) ++ %parameter.50 = f32[] parameter(1) ++ ROOT %add.52 = f32[] add(f32[] %parameter.49, f32[] %parameter.50), metadata={op_type="add" op_name="add" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++} ++ ++%primitive_computation_add__9.60 (parameter.61: f32[], parameter.62: f32[]) -> f32[] { ++ %constant.63 = pred[] constant(false) ++ %parameter.61 = f32[] parameter(0) ++ %parameter.62 = f32[] parameter(1) ++ ROOT %add.64 = f32[] add(f32[] %parameter.61, f32[] %parameter.62), metadata={op_type="add" op_name="add" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++} ++ ++%primitive_computation_add__10.75 (parameter.76: f32[], parameter.77: f32[]) -> f32[] { ++ %constant.78 = pred[] constant(false) ++ %parameter.76 = f32[] parameter(0) ++ %parameter.77 = f32[] parameter(1) ++ ROOT %add.79 = f32[] add(f32[] %parameter.76, f32[] %parameter.77), metadata={op_type="add" op_name="add" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=62} ++} ++ ++%primitive_computation_add__11.108 (parameter.109: f32[], parameter.110: f32[]) -> f32[] { ++ %constant.111 = pred[] constant(false) ++ %parameter.109 = f32[] parameter(0) ++ %parameter.110 = f32[] parameter(1) ++ ROOT %add.112 = f32[] add(f32[] %parameter.109, f32[] %parameter.110), metadata={op_type="add" op_name="add" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=184} ++} ++ ++%primitive_computation_add__12.124 (parameter.125: f32[], parameter.126: f32[]) -> f32[] { ++ %constant.127 = pred[] constant(false) ++ %parameter.125 = f32[] parameter(0) ++ %parameter.126 = f32[] parameter(1) ++ ROOT %add.128 = f32[] add(f32[] %parameter.125, f32[] %parameter.126), metadata={op_type="add" op_name="add" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=184} ++} ++ ++ENTRY %jit_train_step.151 (parameter.1: f32[128], parameter.2: f32[1,128], parameter.3: f32[1], parameter.4: f32[128,1], parameter.5: f32[200,1], parameter.6: f32[200,1]) -> (f32[128], f32[1,128], f32[1], f32[128,1]) { ++ %constant.7 = pred[] constant(false) ++ %parameter.5 = f32[200,1]{1,0} parameter(4) ++ %parameter.2 = f32[1,128]{1,0} parameter(1) ++ %dot.8 = f32[200,128]{1,0} dot(f32[200,1]{1,0} %parameter.5, f32[1,128]{1,0} %parameter.2), lhs_contracting_dims={1}, rhs_contracting_dims={0}, metadata={op_type="dot_general" op_name="jit(train_step)/dot_general[\n dimension_numbers=(((1,), (0,)), ((), ()))\n precision=None\n preferred_element_type=None\n]" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=180} ++ %parameter.1 = f32[128]{0} parameter(0) ++ %broadcast.9 = f32[200,128]{1,0} broadcast(f32[128]{0} %parameter.1), dimensions={1}, metadata={op_type="broadcast_in_dim" op_name="jit(train_step)/broadcast_in_dim[broadcast_dimensions=(1,) shape=(200, 128)]" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=184} ++ %add.10 = f32[200,128]{1,0} add(f32[200,128]{1,0} %dot.8, f32[200,128]{1,0} %broadcast.9), metadata={op_type="add" op_name="jit(train_step)/add" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=185} ++ %tanh.11 = f32[200,128]{1,0} tanh(f32[200,128]{1,0} %add.10), metadata={op_type="tanh" op_name="jit(train_step)/tanh" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=127} ++ %parameter.4 = f32[128,1]{1,0} parameter(3) ++ %dot.15 = f32[200,1]{1,0} dot(f32[200,128]{1,0} %tanh.11, f32[128,1]{1,0} %parameter.4), lhs_contracting_dims={1}, rhs_contracting_dims={0}, metadata={op_type="dot_general" op_name="jit(train_step)/dot_general[\n dimension_numbers=(((1,), (0,)), ((), ()))\n precision=None\n preferred_element_type=None\n]" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=180} ++ %parameter.3 = f32[1]{0} parameter(2) ++ %broadcast.16 = f32[200,1]{1,0} broadcast(f32[1]{0} %parameter.3), dimensions={1}, metadata={op_type="broadcast_in_dim" op_name="jit(train_step)/broadcast_in_dim[broadcast_dimensions=(1,) shape=(200, 1)]" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=184} ++ %add.17 = f32[200,1]{1,0} add(f32[200,1]{1,0} %dot.15, f32[200,1]{1,0} %broadcast.16), metadata={op_type="add" op_name="jit(train_step)/add" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=185} ++ %parameter.6 = f32[200,1]{1,0} parameter(5) ++ %subtract.69 = f32[200,1]{1,0} subtract(f32[200,1]{1,0} %add.17, f32[200,1]{1,0} %parameter.6), metadata={op_type="sub" op_name="jit(train_step)/sub" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=62} ++ %multiply.70 = f32[200,1]{1,0} multiply(f32[200,1]{1,0} %subtract.69, f32[200,1]{1,0} %subtract.69), metadata={op_type="integer_pow" op_name="jit(train_step)/integer_pow[y=2]" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=62} ++ %constant.74 = f32[] constant(0), metadata={op_type="reduce_sum" op_name="jit(train_step)/reduce_sum[axes=(0, 1)]" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=62} ++ %reduce.80 = f32[] reduce(f32[200,1]{1,0} %multiply.70, f32[] %constant.74), dimensions={0,1}, to_apply=%primitive_computation_add__10.75, metadata={op_type="reduce_sum" op_name="jit(train_step)/reduce_sum[axes=(0, 1)]" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=62} ++ %constant.81 = f32[] constant(200), metadata={op_type="div" op_name="jit(train_step)/div" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=62} ++ %divide.82 = f32[] divide(f32[] %reduce.80, f32[] %constant.81), metadata={op_type="div" op_name="jit(train_step)/div" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=62} ++ %negate.83 = f32[] negate(f32[] %divide.82), metadata={op_type="neg" op_name="jit(train_step)/neg" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=62} ++ %constant.84 = f32[] constant(0.5), metadata={op_type="div" op_name="jit(train_step)/div" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=62} ++ %divide.85 = f32[] divide(f32[] %negate.83, f32[] %constant.84), metadata={op_type="div" op_name="jit(train_step)/div" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=62} ++ %multiply.18 = f32[128]{0} multiply(f32[128]{0} %parameter.1, f32[128]{0} %parameter.1), metadata={op_type="integer_pow" op_name="jit(train_step)/integer_pow[y=2]" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %constant.22 = f32[] constant(0), metadata={op_type="reduce_sum" op_name="jit(train_step)/reduce_sum[axes=(0,)]" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %reduce.28 = f32[] reduce(f32[128]{0} %multiply.18, f32[] %constant.22), dimensions={0}, to_apply=%primitive_computation_add__6.23, metadata={op_type="reduce_sum" op_name="jit(train_step)/reduce_sum[axes=(0,)]" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %constant.29 = f32[] constant(0), metadata={op_type="add" op_name="jit(train_step)/add" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %add.30 = f32[] add(f32[] %reduce.28, f32[] %constant.29), metadata={op_type="add" op_name="jit(train_step)/add" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %multiply.31 = f32[1,128]{1,0} multiply(f32[1,128]{1,0} %parameter.2, f32[1,128]{1,0} %parameter.2), metadata={op_type="integer_pow" op_name="jit(train_step)/integer_pow[y=2]" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %constant.35 = f32[] constant(0), metadata={op_type="reduce_sum" op_name="jit(train_step)/reduce_sum[axes=(0, 1)]" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %reduce.41 = f32[] reduce(f32[1,128]{1,0} %multiply.31, f32[] %constant.35), dimensions={0,1}, to_apply=%primitive_computation_add__7.36, metadata={op_type="reduce_sum" op_name="jit(train_step)/reduce_sum[axes=(0, 1)]" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %add.42 = f32[] add(f32[] %add.30, f32[] %reduce.41), metadata={op_type="add" op_name="jit(train_step)/add" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %multiply.43 = f32[1]{0} multiply(f32[1]{0} %parameter.3, f32[1]{0} %parameter.3), metadata={op_type="integer_pow" op_name="jit(train_step)/integer_pow[y=2]" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %constant.47 = f32[] constant(0), metadata={op_type="reduce_sum" op_name="jit(train_step)/reduce_sum[axes=(0,)]" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %reduce.53 = f32[] reduce(f32[1]{0} %multiply.43, f32[] %constant.47), dimensions={0}, to_apply=%primitive_computation_add__8.48, metadata={op_type="reduce_sum" op_name="jit(train_step)/reduce_sum[axes=(0,)]" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %add.54 = f32[] add(f32[] %add.42, f32[] %reduce.53), metadata={op_type="add" op_name="jit(train_step)/add" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %multiply.55 = f32[128,1]{1,0} multiply(f32[128,1]{1,0} %parameter.4, f32[128,1]{1,0} %parameter.4), metadata={op_type="integer_pow" op_name="jit(train_step)/integer_pow[y=2]" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %constant.59 = f32[] constant(0), metadata={op_type="reduce_sum" op_name="jit(train_step)/reduce_sum[axes=(0, 1)]" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %reduce.65 = f32[] reduce(f32[128,1]{1,0} %multiply.55, f32[] %constant.59), dimensions={0,1}, to_apply=%primitive_computation_add__9.60, metadata={op_type="reduce_sum" op_name="jit(train_step)/reduce_sum[axes=(0, 1)]" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %add.66 = f32[] add(f32[] %add.54, f32[] %reduce.65), metadata={op_type="add" op_name="jit(train_step)/add" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %constant.67 = f32[] constant(-0), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %multiply.68 = f32[] multiply(f32[] %add.66, f32[] %constant.67), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %add.86 = f32[] add(f32[] %divide.85, f32[] %multiply.68), metadata={op_type="add" op_name="jit(train_step)/add" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=63} ++ %negate.87 = f32[] negate(f32[] %add.86), metadata={op_type="neg" op_name="jit(train_step)/neg" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=66} ++ %constant.88 = f32[] constant(1), metadata={op_type="neg" op_name="jit(train_step)/neg" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=66} ++ %negate.89 = f32[] negate(f32[] %constant.88), metadata={op_type="neg" op_name="jit(train_step)/neg" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=66} ++ %constant.90 = f32[] constant(-0), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %multiply.91 = f32[] multiply(f32[] %negate.89, f32[] %constant.90), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %broadcast.98 = f32[128]{0} broadcast(f32[] %multiply.91), dimensions={}, metadata={op_type="broadcast_in_dim" op_name="jit(train_step)/broadcast_in_dim[broadcast_dimensions=() shape=(128,)]" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %constant.19 = f32[] constant(2), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %broadcast.20 = f32[128]{0} broadcast(f32[] %constant.19), dimensions={}, metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %multiply.21 = f32[128]{0} multiply(f32[128]{0} %broadcast.20, f32[128]{0} %parameter.1), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %multiply.99 = f32[128]{0} multiply(f32[128]{0} %broadcast.98, f32[128]{0} %multiply.21), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %constant.100 = f32[] constant(0.5), metadata={op_type="div" op_name="jit(train_step)/div" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=62} ++ %divide.101 = f32[] divide(f32[] %negate.89, f32[] %constant.100), metadata={op_type="div" op_name="jit(train_step)/div" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=62} ++ %negate.102 = f32[] negate(f32[] %divide.101), metadata={op_type="neg" op_name="jit(train_step)/neg" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=62} ++ %constant.103 = f32[] constant(200), metadata={op_type="div" op_name="jit(train_step)/div" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=62} ++ %divide.104 = f32[] divide(f32[] %negate.102, f32[] %constant.103), metadata={op_type="div" op_name="jit(train_step)/div" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=62} ++ %broadcast.105 = f32[200,1]{1,0} broadcast(f32[] %divide.104), dimensions={}, metadata={op_type="broadcast_in_dim" op_name="jit(train_step)/broadcast_in_dim[broadcast_dimensions=() shape=(200, 1)]" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=62} ++ %constant.71 = f32[] constant(2), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=62} ++ %broadcast.72 = f32[200,1]{1,0} broadcast(f32[] %constant.71), dimensions={}, metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=62} ++ %multiply.73 = f32[200,1]{1,0} multiply(f32[200,1]{1,0} %broadcast.72, f32[200,1]{1,0} %subtract.69), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=62} ++ %multiply.106 = f32[200,1]{1,0} multiply(f32[200,1]{1,0} %broadcast.105, f32[200,1]{1,0} %multiply.73), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=62} ++ %dot.118 = f32[200,128]{1,0} dot(f32[200,1]{1,0} %multiply.106, f32[128,1]{1,0} %parameter.4), lhs_contracting_dims={1}, rhs_contracting_dims={1}, metadata={op_type="dot_general" op_name="jit(train_step)/dot_general[\n dimension_numbers=(((1,), (1,)), ((), ()))\n precision=None\n preferred_element_type=None\n]" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=180} ++ %constant.12 = f32[] constant(1), metadata={op_type="sub" op_name="jit(train_step)/sub" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=127} ++ %broadcast.13 = f32[200,128]{1,0} broadcast(f32[] %constant.12), dimensions={}, metadata={op_type="sub" op_name="jit(train_step)/sub" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=127} ++ %subtract.14 = f32[200,128]{1,0} subtract(f32[200,128]{1,0} %broadcast.13, f32[200,128]{1,0} %tanh.11), metadata={op_type="sub" op_name="jit(train_step)/sub" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=127} ++ %multiply.120 = f32[200,128]{1,0} multiply(f32[200,128]{1,0} %dot.118, f32[200,128]{1,0} %subtract.14), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=127} ++ %multiply.121 = f32[200,128]{1,0} multiply(f32[200,128]{1,0} %multiply.120, f32[200,128]{1,0} %tanh.11), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=127} ++ %add.122 = f32[200,128]{1,0} add(f32[200,128]{1,0} %multiply.120, f32[200,128]{1,0} %multiply.121), metadata={op_type="add_any" op_name="jit(train_step)/add_any" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=127} ++ %constant.123 = f32[] constant(0), metadata={op_type="reduce_sum" op_name="jit(train_step)/reduce_sum[axes=(0,)]" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=184} ++ %reduce.129 = f32[128]{0} reduce(f32[200,128]{1,0} %add.122, f32[] %constant.123), dimensions={0}, to_apply=%primitive_computation_add__12.124, metadata={op_type="reduce_sum" op_name="jit(train_step)/reduce_sum[axes=(0,)]" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=184} ++ %add.130 = f32[128]{0} add(f32[128]{0} %multiply.99, f32[128]{0} %reduce.129), metadata={op_type="add_any" op_name="jit(train_step)/add_any" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=71} ++ %constant.134 = f32[] constant(0.001), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=72} ++ %broadcast.135 = f32[128]{0} broadcast(f32[] %constant.134), dimensions={}, metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=72} ++ %multiply.136 = f32[128]{0} multiply(f32[128]{0} %add.130, f32[128]{0} %broadcast.135), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=72} ++ %subtract.137 = f32[128]{0} subtract(f32[128]{0} %parameter.1, f32[128]{0} %multiply.136), metadata={op_type="sub" op_name="jit(train_step)/sub" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=72} ++ %broadcast.96 = f32[1,128]{1,0} broadcast(f32[] %multiply.91), dimensions={}, metadata={op_type="broadcast_in_dim" op_name="jit(train_step)/broadcast_in_dim[broadcast_dimensions=() shape=(1, 128)]" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %constant.32 = f32[] constant(2), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %broadcast.33 = f32[1,128]{1,0} broadcast(f32[] %constant.32), dimensions={}, metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %multiply.34 = f32[1,128]{1,0} multiply(f32[1,128]{1,0} %broadcast.33, f32[1,128]{1,0} %parameter.2), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %multiply.97 = f32[1,128]{1,0} multiply(f32[1,128]{1,0} %broadcast.96, f32[1,128]{1,0} %multiply.34), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %dot.131 = f32[128,1]{1,0} dot(f32[200,128]{1,0} %add.122, f32[200,1]{1,0} %parameter.5), lhs_contracting_dims={0}, rhs_contracting_dims={0}, metadata={op_type="dot_general" op_name="jit(train_step)/dot_general[\n dimension_numbers=(((0,), (0,)), ((), ()))\n precision=None\n preferred_element_type=None\n]" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=180} ++ %transpose.132 = f32[1,128]{0,1} transpose(f32[128,1]{1,0} %dot.131), dimensions={1,0}, metadata={op_type="transpose" op_name="jit(train_step)/transpose[permutation=(1, 0)]" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=180} ++ %add.133 = f32[1,128]{1,0} add(f32[1,128]{1,0} %multiply.97, f32[1,128]{0,1} %transpose.132), metadata={op_type="add_any" op_name="jit(train_step)/add_any" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=71} ++ %constant.138 = f32[] constant(0.001), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=72} ++ %broadcast.139 = f32[1,128]{1,0} broadcast(f32[] %constant.138), dimensions={}, metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=72} ++ %multiply.140 = f32[1,128]{1,0} multiply(f32[1,128]{1,0} %add.133, f32[1,128]{1,0} %broadcast.139), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=72} ++ %subtract.141 = f32[1,128]{1,0} subtract(f32[1,128]{1,0} %parameter.2, f32[1,128]{1,0} %multiply.140), metadata={op_type="sub" op_name="jit(train_step)/sub" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=72} ++ %broadcast.94 = f32[1]{0} broadcast(f32[] %multiply.91), dimensions={}, metadata={op_type="broadcast_in_dim" op_name="jit(train_step)/broadcast_in_dim[broadcast_dimensions=() shape=(1,)]" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %constant.44 = f32[] constant(2), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %broadcast.45 = f32[1]{0} broadcast(f32[] %constant.44), dimensions={}, metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %multiply.46 = f32[1]{0} multiply(f32[1]{0} %broadcast.45, f32[1]{0} %parameter.3), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %multiply.95 = f32[1]{0} multiply(f32[1]{0} %broadcast.94, f32[1]{0} %multiply.46), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %constant.107 = f32[] constant(0), metadata={op_type="reduce_sum" op_name="jit(train_step)/reduce_sum[axes=(0, 1)]" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=184} ++ %reduce.113 = f32[] reduce(f32[200,1]{1,0} %multiply.106, f32[] %constant.107), dimensions={0,1}, to_apply=%primitive_computation_add__11.108, metadata={op_type="reduce_sum" op_name="jit(train_step)/reduce_sum[axes=(0, 1)]" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=184} ++ %broadcast.114 = f32[1]{0} broadcast(f32[] %reduce.113), dimensions={}, metadata={op_type="broadcast_in_dim" op_name="jit(train_step)/broadcast_in_dim[broadcast_dimensions=() shape=(1,)]" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=184} ++ %add.115 = f32[1]{0} add(f32[1]{0} %multiply.95, f32[1]{0} %broadcast.114), metadata={op_type="add_any" op_name="jit(train_step)/add_any" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=71} ++ %constant.142 = f32[] constant(0.001), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=72} ++ %broadcast.143 = f32[1]{0} broadcast(f32[] %constant.142), dimensions={}, metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=72} ++ %multiply.144 = f32[1]{0} multiply(f32[1]{0} %add.115, f32[1]{0} %broadcast.143), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=72} ++ %subtract.145 = f32[1]{0} subtract(f32[1]{0} %parameter.3, f32[1]{0} %multiply.144), metadata={op_type="sub" op_name="jit(train_step)/sub" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=72} ++ %broadcast.92 = f32[128,1]{1,0} broadcast(f32[] %multiply.91), dimensions={}, metadata={op_type="broadcast_in_dim" op_name="jit(train_step)/broadcast_in_dim[broadcast_dimensions=() shape=(128, 1)]" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %constant.56 = f32[] constant(2), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %broadcast.57 = f32[128,1]{1,0} broadcast(f32[] %constant.56), dimensions={}, metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %multiply.58 = f32[128,1]{1,0} multiply(f32[128,1]{1,0} %broadcast.57, f32[128,1]{1,0} %parameter.4), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %multiply.93 = f32[128,1]{1,0} multiply(f32[128,1]{1,0} %broadcast.92, f32[128,1]{1,0} %multiply.58), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=60} ++ %dot.116 = f32[1,128]{1,0} dot(f32[200,1]{1,0} %multiply.106, f32[200,128]{1,0} %tanh.11), lhs_contracting_dims={0}, rhs_contracting_dims={0}, metadata={op_type="dot_general" op_name="jit(train_step)/dot_general[\n dimension_numbers=(((0,), (0,)), ((), ()))\n precision=None\n preferred_element_type=None\n]" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=180} ++ %transpose.117 = f32[128,1]{0,1} transpose(f32[1,128]{1,0} %dot.116), dimensions={1,0}, metadata={op_type="transpose" op_name="jit(train_step)/transpose[permutation=(1, 0)]" source_file="/mnt/home/linmin/g/lib/python3.8/site-packages/haiku/_src/basic.py" source_line=180} ++ %add.119 = f32[128,1]{1,0} add(f32[128,1]{1,0} %multiply.93, f32[128,1]{0,1} %transpose.117), metadata={op_type="add_any" op_name="jit(train_step)/add_any" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=71} ++ %constant.146 = f32[] constant(0.001), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=72} ++ %broadcast.147 = f32[128,1]{1,0} broadcast(f32[] %constant.146), dimensions={}, metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=72} ++ %multiply.148 = f32[128,1]{1,0} multiply(f32[128,1]{1,0} %add.119, f32[128,1]{1,0} %broadcast.147), metadata={op_type="mul" op_name="jit(train_step)/mul" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=72} ++ %subtract.149 = f32[128,1]{1,0} subtract(f32[128,1]{1,0} %parameter.4, f32[128,1]{1,0} %multiply.148), metadata={op_type="sub" op_name="jit(train_step)/sub" source_file="examples/deep/nn_regression/mlp_regression.py" source_line=72} ++ ROOT %tuple.150 = (f32[128]{0}, f32[1,128]{1,0}, f32[1]{0}, f32[128,1]{1,0}) tuple(f32[128]{0} %subtract.137, f32[1,128]{1,0} %subtract.141, f32[1]{0} %subtract.145, f32[128,1]{1,0} %subtract.149) ++} ++ +diff --git a/tensorflow/xla_standalone/xla_compile.cc b/tensorflow/xla_standalone/xla_compile.cc +new file mode 100644 +index 00000000000..2e5d52a28aa +--- /dev/null ++++ b/tensorflow/xla_standalone/xla_compile.cc +@@ -0,0 +1,117 @@ ++// Copyright 2022 Garena Online Private Limited. ++// ++// Licensed under the Apache License, Version 2.0 (the "License"); ++// you may not use this file except in compliance with the License. ++// You may obtain a copy of the License at ++// ++// http://www.apache.org/licenses/LICENSE-2.0 ++// ++// Unless required by applicable law or agreed to in writing, software ++// distributed under the License is distributed on an "AS IS" BASIS, ++// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++// See the License for the specific language governing permissions and ++// limitations under the License. ++// ++// An example for reading a HloModule from a HloProto file and execute the ++// module on PJRT CPU client. ++ ++#include ++ ++#include ++#include ++#include ++#include ++#include ++ ++#include "tensorflow/compiler/xla/literal.h" ++#include "tensorflow/compiler/xla/literal_util.h" ++#include "tensorflow/compiler/xla/pjrt/cpu_device.h" ++#include "tensorflow/compiler/xla/pjrt/gpu_device.h" ++#include "tensorflow/compiler/xla/pjrt/pjrt_client.h" ++#include "tensorflow/compiler/xla/service/cpu/cpu_compiler.h" ++#include "tensorflow/compiler/xla/service/gpu/gpu_compiler.h" ++#include "tensorflow/compiler/xla/service/hlo_pass_pipeline.h" ++#include "tensorflow/compiler/xla/status.h" ++#include "tensorflow/compiler/xla/statusor.h" ++#include "tensorflow/compiler/xla/tools/hlo_module_loader.h" ++#include "tensorflow/core/platform/init_main.h" ++#include "tensorflow/core/platform/logging.h" ++#include "tensorflow/xla_standalone/hlo_graph.h" ++ ++DEFINE_string(hlo, "-", "hlo text file"); // by default read from stdin ++DEFINE_string(dry, "", "which pass to dry run"); ++DEFINE_string(platform, "gpu", "gpu or cpu, defaults to gpu"); ++ ++int main(int argc, char** argv) { ++ tensorflow::port::InitMain("", &argc, &argv); ++ gflags::ParseCommandLineFlags(&argc, &argv, true); ++ ++ setenv("DRY", FLAGS_dry.c_str(), 1); ++ xla::HloPassPipeline::dry_sandwich_set = ++ xla::HloPassPipeline::ExtractDrySandwichSetFromEnv(); ++ ++ xla::Intercept cpu_intercept; ++ xla::Intercept gpu_intercept; ++ ++ std::function config_modifier_hook = ++ [](xla::HloModuleConfig* config) { config->set_seed(42); }; ++ ++ // Load HloModule from file. ++ std::unique_ptr hlo_module; ++ if (FLAGS_hlo == "-") { ++ std::stringstream ss; ++ std::string s; ++ while (std::getline(std::cin, s)) { ++ ss << s << "\n"; ++ } ++ hlo_module = LoadModuleFromData(ss.str(), "txt", ++ xla::hlo_module_loader_details::Config(), ++ config_modifier_hook) ++ .ValueOrDie(); ++ } else { ++ hlo_module = ++ LoadModuleFromFile(FLAGS_hlo, xla::hlo_module_loader_details::Config(), ++ "txt", config_modifier_hook) ++ .ValueOrDie(); ++ } ++ const xla::HloModuleProto hlo_module_proto = hlo_module->ToProto(); ++ ++ // Run it using JAX C++ Runtime (PJRT). ++ // Get a CPU client. ++ ++ std::unique_ptr client; ++ if (FLAGS_platform == "gpu") { ++ client = xla::GetGpuClient(/*asynchronous=*/true, xla::GpuAllocatorConfig(), ++ nullptr, 0) ++ .ValueOrDie(); ++ } else if (FLAGS_platform == "cpu") { ++ client = xla::GetCpuClient(/*asynchronous=*/true).ValueOrDie(); ++ } else { ++ LOG(FATAL) << "Unknown platform " << FLAGS_platform; ++ } ++ ++ // Compile XlaComputation to PjRtExecutable. ++ xla::XlaComputation xla_computation(hlo_module_proto); ++ xla::CompileOptions compile_options; ++ ++ try { ++ std::unique_ptr executable = ++ client->Compile(xla_computation, compile_options).ValueOrDie(); ++ } catch (xla::Intercept& e) { ++ cpu_intercept = std::move(e); ++ } catch (xla::Intercept& e) { ++ gpu_intercept = std::move(e); ++ gpu_intercept.compiler->RunHloPasses(gpu_intercept.module.get(), ++ gpu_intercept.stream_exec, ++ gpu_intercept.options); ++ xla::HloGraph graph(gpu_intercept.module.get()); ++ graph.ShowStats(); ++ } ++ ++ // intercept.compiler->RunHloPasses(intercept.module.get(), ++ // intercept.stream_exec, intercept.options); ++ ++ /// There's a very long chain here ++ /// pjrtclient -> local_client -> local_service -> service -> BuildExecutable ++ /// -> backend->compiler->RunHloPasses ++} +diff --git a/third_party/absl/hloenv_make_hash_deterministic.patch b/third_party/absl/hloenv_make_hash_deterministic.patch +new file mode 100644 +index 00000000000..4c773ed5108 +--- /dev/null ++++ b/third_party/absl/hloenv_make_hash_deterministic.patch +@@ -0,0 +1,20 @@ ++diff --git a/absl/hash/internal/hash.h b/absl/hash/internal/hash.h ++index 45dfdd46..3e90c0f5 100644 ++--- a/absl/hash/internal/hash.h +++++ b/absl/hash/internal/hash.h ++@@ -1133,14 +1133,7 @@ class ABSL_DLL MixingHashState : public HashStateBase { ++ // On other platforms this is still going to be non-deterministic but most ++ // probably per-build and not per-process. ++ ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Seed() { ++-#if (!defined(__clang__) || __clang_major__ > 11) && \ ++- !defined(__apple_build_version__) ++- return static_cast(reinterpret_cast(&kSeed)); ++-#else ++- // Workaround the absence of ++- // https://github.com/llvm/llvm-project/commit/bc15bf66dcca76cc06fe71fca35b74dc4d521021. ++- return static_cast(reinterpret_cast(kSeed)); ++-#endif +++ return 42; ++ } ++ static const void* const kSeed; ++ +diff --git a/third_party/absl/workspace.bzl b/third_party/absl/workspace.bzl +index 39ba0e6ed6e..75b1f507937 100644 +--- a/third_party/absl/workspace.bzl ++++ b/third_party/absl/workspace.bzl +@@ -1,14 +1,17 @@ + """Provides the repository macro to import absl.""" + + load("//third_party:repo.bzl", "tf_http_archive", "tf_mirror_urls") ++load("@bazel_tools//tools/build_defs/repo:git.bzl", "new_git_repository") + + def repo(): + """Imports absl.""" + + # Attention: tools parse and update these lines. + # LINT.IfChange +- ABSL_COMMIT = "215105818dfde3174fe799600bb0f3cae233d0bf" +- ABSL_SHA256 = "237e2e6aec7571ae90d961d02de19f56861a7417acbbc15713b8926e39d461ed" ++ # ABSL_COMMIT = "215105818dfde3174fe799600bb0f3cae233d0bf" ++ # ABSL_SHA256 = "237e2e6aec7571ae90d961d02de19f56861a7417acbbc15713b8926e39d461ed" ++ ABSL_SHA256 = "520f61963f0807412d1d61f5f0dd706576b69413ee69959aa8f8715c49a78a00" ++ ABSL_COMMIT = "731689ffc2ad7bb95cc86b5b6160dbe7858f27a0" + # LINT.ThenChange(//tensorflow/lite/tools/cmake/modules/abseil-cpp.cmake) + + SYS_DIRS = [ +@@ -42,8 +45,7 @@ def repo(): + build_file = "//third_party/absl:com_google_absl.BUILD", + system_build_file = "//third_party/absl:system.BUILD", + system_link_files = SYS_LINKS, +- # TODO(mihaimaruseac): Remove the patch when https://github.com/abseil/abseil-cpp/issues/326 is resolved +- patch_file = ["//third_party/absl:com_google_absl_fix_mac_and_nvcc_build.patch"], ++ patch_file = ["//third_party/absl:hloenv_make_hash_deterministic.patch"], + strip_prefix = "abseil-cpp-{commit}".format(commit = ABSL_COMMIT), + urls = tf_mirror_urls("https://github.com/abseil/abseil-cpp/archive/{commit}.tar.gz".format(commit = ABSL_COMMIT)), + )