Merge remote-tracking branch 'origin/develop' into rewrite-fast-gelu

.github/workflows/ci.yaml

@@ -53,6 +53,7 @@ jobs:
         CXX=/opt/rocm/llvm/bin/clang++ CC=/opt/rocm/llvm/bin/clang cmake \
           -DMIGRAPHX_ENABLE_GPU=On \
           -DMIGRAPHX_ENABLE_CPU=On \
+          -DMIGRAPHX_ENABLE_FPGA=On \
           -DROCM_ENABLE_GH_ANNOTATIONS=On \
           -DCLANG_TIDY_DEPEND_ON_TARGET=Off \
           -DCLANG_TIDY_CACHE=/data/tidy-cache \

.github/workflows/performance.yaml

 name: MIGraphX Performance Tests
 
 on:
-  push:
-    branches: [develop]
-
   pull_request:
     branches: [develop]
+    types: [opened, synchronize, closed]
   schedule:
     - cron: "0 5 * * 1-6"
 

src/CMakeLists.txt

@@ -91,7 +91,6 @@ add_library(migraphx
     shape.cpp
     simplify_algebra.cpp
     simplify_reshapes.cpp
-    target_assignments.cpp
     tmp_dir.cpp
     value.cpp
     verify_args.cpp

src/driver/alexnet.cpp

@@ -25,13 +25,10 @@
 #include <migraphx/make_op.hpp>
 #include <migraphx/program.hpp>
 #include <migraphx/generate.hpp>
-#include <migraphx/json.hpp>
 #include "models.hpp"
-
 namespace migraphx {
 namespace driver {
 inline namespace MIGRAPHX_INLINE_NS {
-
 migraphx::program alexnet(unsigned batch) // NOLINT(readability-function-size)
 {
     migraphx::program p;
@@ -42,179 +39,153 @@ migraphx::program alexnet(unsigned batch) // NOLINT(readability-function-size)
         migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1}}, 1)));
     auto x_main_module_2       = mmain->add_literal(migraphx::abs(
         migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1}}, 2)));
-    auto x_input_1             = mmain->add_parameter(
-        "input.1", migraphx::shape{migraphx::shape::float_type, {batch, 3, 224, 224}});
+    auto x_0                   = mmain->add_parameter(
+        "0", migraphx::shape{migraphx::shape::float_type, {batch, 3, 224, 224}});
     auto x_main_module_4 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {4096, 4096}}, 3));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1000}}, 3));
     auto x_main_module_5 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {4096}}, 4));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1000, 4096}}, 4));
     auto x_main_module_6 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {4096, 9216}}, 5));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {4096}}, 5));
     auto x_main_module_7 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {4096}}, 6));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {4096, 4096}}, 6));
     auto x_main_module_8 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1000, 4096}}, 7));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {4096}}, 7));
     auto x_main_module_9 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1000}}, 8));
-    auto x_main_module_10 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {256, 384, 3, 3}}, 9));
-    auto x_main_module_11 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 10));
-    auto x_main_module_12 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {384, 192, 3, 3}}, 11));
-    auto x_main_module_13 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {384}}, 12));
-    auto x_main_module_14 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {192, 64, 5, 5}}, 13));
-    auto x_main_module_15 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {192}}, 14));
-    auto x_main_module_16 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 15));
-    auto x_main_module_17 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 16));
-    auto x_main_module_18 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {64, 3, 11, 11}}, 17));
-    auto x_main_module_19 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 18));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {4096, 9216}}, 8));
+    auto x_main_module_10 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 9));
+    auto x_main_module_11 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 10));
+    auto x_main_module_12 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 11));
+    auto x_main_module_13 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {256, 384, 3, 3}}, 12));
+    auto x_main_module_14 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {384}}, 13));
+    auto x_main_module_15 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {384, 192, 3, 3}}, 14));
+    auto x_main_module_16 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {192}}, 15));
+    auto x_main_module_17 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {192, 64, 5, 5}}, 16));
+    auto x_main_module_18 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 17));
+    auto x_main_module_19 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {64, 3, 11, 11}}, 18));
     auto x_main_module_20 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[2,2,2,2],padding_mode:0,stride:[4,4]}")),
-        x_input_1,
-        x_main_module_18);
-    auto x_main_module_21 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,64,55,55]}")),
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[2,2,2,2],padding_mode:0,stride:[4,"
+                               "4],use_dynamic_same_auto_pad:0}"),
+        x_0,
         x_main_module_19);
+    auto x_main_module_21 = mmain->add_instruction(
+        migraphx::make_json_op("broadcast", "{axis:1,out_lens:[1,64,55,55]}"), x_main_module_18);
     auto x_main_module_22 =
         mmain->add_instruction(migraphx::make_op("add"), x_main_module_20, x_main_module_21);
     auto x_main_module_23 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_22);
     auto x_main_module_24 = mmain->add_instruction(
-        migraphx::make_op(
+        migraphx::make_json_op(
             "pooling",
-            migraphx::from_json_string(
-                "{ceil_mode:0,lengths:[3,3],lp_order:2,mode:1,padding:[0,0,0,0],stride:[2,2]}")),
+            "{ceil_mode:0,lengths:[3,3],lp_order:2,mode:1,padding:[0,0,0,0],stride:[2,2]}"),
         x_main_module_23);
     auto x_main_module_25 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[2,2,2,2],padding_mode:0,stride:[1,1]}")),
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[2,2,2,2],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
         x_main_module_24,
-        x_main_module_14);
+        x_main_module_17);
     auto x_main_module_26 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,192,27,27]}")),
-        x_main_module_15);
+        migraphx::make_json_op("broadcast", "{axis:1,out_lens:[1,192,27,27]}"), x_main_module_16);
     auto x_main_module_27 =
         mmain->add_instruction(migraphx::make_op("add"), x_main_module_25, x_main_module_26);
     auto x_main_module_28 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_27);
     auto x_main_module_29 = mmain->add_instruction(
-        migraphx::make_op(
+        migraphx::make_json_op(
             "pooling",
-            migraphx::from_json_string(
-                "{ceil_mode:0,lengths:[3,3],lp_order:2,mode:1,padding:[0,0,0,0],stride:[2,2]}")),
+            "{ceil_mode:0,lengths:[3,3],lp_order:2,mode:1,padding:[0,0,0,0],stride:[2,2]}"),
         x_main_module_28);
     auto x_main_module_30 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
         x_main_module_29,
-        x_main_module_12);
+        x_main_module_15);
     auto x_main_module_31 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,384,13,13]}")),
-        x_main_module_13);
+        migraphx::make_json_op("broadcast", "{axis:1,out_lens:[1,384,13,13]}"), x_main_module_14);
     auto x_main_module_32 =
         mmain->add_instruction(migraphx::make_op("add"), x_main_module_30, x_main_module_31);
     auto x_main_module_33 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_32);
     auto x_main_module_34 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
         x_main_module_33,
-        x_main_module_10);
+        x_main_module_13);
     auto x_main_module_35 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,256,13,13]}")),
-        x_main_module_11);
+        migraphx::make_json_op("broadcast", "{axis:1,out_lens:[1,256,13,13]}"), x_main_module_12);
     auto x_main_module_36 =
         mmain->add_instruction(migraphx::make_op("add"), x_main_module_34, x_main_module_35);
     auto x_main_module_37 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_36);
     auto x_main_module_38 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
         x_main_module_37,
-        x_main_module_16);
+        x_main_module_11);
     auto x_main_module_39 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,256,13,13]}")),
-        x_main_module_17);
+        migraphx::make_json_op("broadcast", "{axis:1,out_lens:[1,256,13,13]}"), x_main_module_10);
     auto x_main_module_40 =
         mmain->add_instruction(migraphx::make_op("add"), x_main_module_38, x_main_module_39);
     auto x_main_module_41 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_40);
     auto x_main_module_42 = mmain->add_instruction(
-        migraphx::make_op(
+        migraphx::make_json_op(
             "pooling",
-            migraphx::from_json_string(
-                "{ceil_mode:0,lengths:[3,3],lp_order:2,mode:1,padding:[0,0,0,0],stride:[2,2]}")),
+            "{ceil_mode:0,lengths:[3,3],lp_order:2,mode:1,padding:[0,0,0,0],stride:[2,2]}"),
         x_main_module_41);
-    auto x_main_module_43 = mmain->add_instruction(
-        migraphx::make_op("reshape", migraphx::from_json_string("{dims:[1,9216]}")),
-        x_main_module_42);
-    auto x_main_module_44 = mmain->add_instruction(
-        migraphx::make_op("transpose", migraphx::from_json_string("{permutation:[1,0]}")),
-        x_main_module_6);
-    auto x_main_module_45 =
-        mmain->add_instruction(migraphx::make_op("dot"), x_main_module_43, x_main_module_44);
-    auto x_main_module_46 = mmain->add_instruction(
-        migraphx::make_op("multibroadcast", migraphx::from_json_string("{out_lens:[1,4096]}")),
-        x_main_module_7);
+    auto x_main_module_43 =
+        mmain->add_instruction(migraphx::make_json_op("flatten", "{axis:1}"), x_main_module_42);
+    auto x_main_module_44 = mmain->add_instruction(migraphx::make_op("identity"), x_main_module_43);
+    auto x_main_module_45 = mmain->add_instruction(
+        migraphx::make_json_op("transpose", "{permutation:[1,0]}"), x_main_module_9);
+    auto x_main_module_46 =
+        mmain->add_instruction(migraphx::make_op("dot"), x_main_module_44, x_main_module_45);
     auto x_main_module_47 = mmain->add_instruction(
-        migraphx::make_op("multibroadcast", migraphx::from_json_string("{out_lens:[1,4096]}")),
-        x_main_module_2);
-    auto x_main_module_48 =
-        mmain->add_instruction(migraphx::make_op("mul"), x_main_module_46, x_main_module_47);
+        migraphx::make_json_op("multibroadcast", "{out_lens:[1,4096]}"), x_main_module_8);
+    auto x_main_module_48 = mmain->add_instruction(
+        migraphx::make_json_op("multibroadcast", "{out_lens:[1,4096]}"), x_main_module_2);
     auto x_main_module_49 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_45, x_main_module_48);
-    auto x_main_module_50 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_49);
-    auto x_main_module_51 = mmain->add_instruction(
-        migraphx::make_op("transpose", migraphx::from_json_string("{permutation:[1,0]}")),
-        x_main_module_4);
-    auto x_main_module_52 =
-        mmain->add_instruction(migraphx::make_op("dot"), x_main_module_50, x_main_module_51);
+        mmain->add_instruction(migraphx::make_op("mul"), x_main_module_47, x_main_module_48);
+    auto x_main_module_50 =
+        mmain->add_instruction(migraphx::make_op("add"), x_main_module_46, x_main_module_49);
+    auto x_main_module_51 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_50);
+    auto x_main_module_52 = mmain->add_instruction(migraphx::make_op("identity"), x_main_module_51);
     auto x_main_module_53 = mmain->add_instruction(
-        migraphx::make_op("multibroadcast", migraphx::from_json_string("{out_lens:[1,4096]}")),
-        x_main_module_5);
-    auto x_main_module_54 = mmain->add_instruction(
-        migraphx::make_op("multibroadcast", migraphx::from_json_string("{out_lens:[1,4096]}")),
-        x_main_module_1);
-    auto x_main_module_55 =
-        mmain->add_instruction(migraphx::make_op("mul"), x_main_module_53, x_main_module_54);
-    auto x_main_module_56 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_52, x_main_module_55);
-    auto x_main_module_57 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_56);
-    auto x_main_module_58 = mmain->add_instruction(
-        migraphx::make_op("transpose", migraphx::from_json_string("{permutation:[1,0]}")),
-        x_main_module_8);
-    auto x_main_module_59 =
-        mmain->add_instruction(migraphx::make_op("dot"), x_main_module_57, x_main_module_58);
+        migraphx::make_json_op("transpose", "{permutation:[1,0]}"), x_main_module_7);
+    auto x_main_module_54 =
+        mmain->add_instruction(migraphx::make_op("dot"), x_main_module_52, x_main_module_53);
+    auto x_main_module_55 = mmain->add_instruction(
+        migraphx::make_json_op("multibroadcast", "{out_lens:[1,4096]}"), x_main_module_6);
+    auto x_main_module_56 = mmain->add_instruction(
+        migraphx::make_json_op("multibroadcast", "{out_lens:[1,4096]}"), x_main_module_1);
+    auto x_main_module_57 =
+        mmain->add_instruction(migraphx::make_op("mul"), x_main_module_55, x_main_module_56);
+    auto x_main_module_58 =
+        mmain->add_instruction(migraphx::make_op("add"), x_main_module_54, x_main_module_57);
+    auto x_main_module_59 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_58);
     auto x_main_module_60 = mmain->add_instruction(
-        migraphx::make_op("multibroadcast", migraphx::from_json_string("{out_lens:[1,1000]}")),
-        x_main_module_9);
-    auto x_main_module_61 = mmain->add_instruction(
-        migraphx::make_op("multibroadcast", migraphx::from_json_string("{out_lens:[1,1000]}")),
-        x_main_module_0);
-    auto x_main_module_62 =
-        mmain->add_instruction(migraphx::make_op("mul"), x_main_module_60, x_main_module_61);
-    auto x_main_module_63 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_59, x_main_module_62);
-    mmain->add_return({x_main_module_63});
+        migraphx::make_json_op("transpose", "{permutation:[1,0]}"), x_main_module_5);
+    auto x_main_module_61 =
+        mmain->add_instruction(migraphx::make_op("dot"), x_main_module_59, x_main_module_60);
+    auto x_main_module_62 = mmain->add_instruction(
+        migraphx::make_json_op("multibroadcast", "{out_lens:[1,1000]}"), x_main_module_4);
+    auto x_main_module_63 = mmain->add_instruction(
+        migraphx::make_json_op("multibroadcast", "{out_lens:[1,1000]}"), x_main_module_0);
+    auto x_main_module_64 =
+        mmain->add_instruction(migraphx::make_op("mul"), x_main_module_62, x_main_module_63);
+    auto x_main_module_65 =
+        mmain->add_instruction(migraphx::make_op("add"), x_main_module_61, x_main_module_64);
+    mmain->add_return({x_main_module_65});
 
     return p;
 }

src/driver/resnet50.cpp

@@ -25,1033 +25,1453 @@
 #include <migraphx/make_op.hpp>
 #include <migraphx/program.hpp>
 #include <migraphx/generate.hpp>
-#include <migraphx/json.hpp>
 #include "models.hpp"
-
 namespace migraphx {
 namespace driver {
 inline namespace MIGRAPHX_INLINE_NS {
-
 migraphx::program resnet50(unsigned batch) // NOLINT(readability-function-size)
 {
     migraphx::program p;
     migraphx::module_ref mmain = p.get_main_module();
     auto x_main_module_0       = mmain->add_literal(migraphx::abs(
         migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1}}, 0)));
-    auto x_input_1             = mmain->add_parameter(
-        "input.1", migraphx::shape{migraphx::shape::float_type, {batch, 3, 224, 224}});
+    auto x_0                   = mmain->add_parameter(
+        "0", migraphx::shape{migraphx::shape::float_type, {batch, 3, 224, 224}});
     auto x_main_module_2 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1000, 2048}}, 1));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1000}}, 1));
     auto x_main_module_3 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1000}}, 2));
-    auto x_main_module_4 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 3));
-    auto x_main_module_5 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {2048, 512, 1, 1}}, 4));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1000, 2048}}, 2));
+    auto x_main_module_4 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 3)));
+    auto x_main_module_5 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 4));
     auto x_main_module_6 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 5));
-    auto x_main_module_7 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {512, 512, 3, 3}}, 6));
-    auto x_main_module_8 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 7));
-    auto x_main_module_9  = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {512, 2048, 1, 1}}, 8));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 5));
+    auto x_main_module_7  = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 6)));
+    auto x_main_module_8  = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {2048, 512, 1, 1}}, 7));
+    auto x_main_module_9  = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 8)));
     auto x_main_module_10 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 9));
-    auto x_main_module_11 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {2048, 512, 1, 1}}, 10));
-    auto x_main_module_12 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 11));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 9));
+    auto x_main_module_11 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 10));
+    auto x_main_module_12 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 11)));
     auto x_main_module_13 = mmain->add_literal(migraphx::generate_literal(
         migraphx::shape{migraphx::shape::float_type, {512, 512, 3, 3}}, 12));
-    auto x_main_module_14 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 13));
-    auto x_main_module_15 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {512, 2048, 1, 1}}, 14));
+    auto x_main_module_14 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 13)));
+    auto x_main_module_15 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 14));
     auto x_main_module_16 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 15));
-    auto x_main_module_17 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {2048, 1024, 1, 1}}, 16));
-    auto x_main_module_18 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 17));
-    auto x_main_module_19 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {2048, 512, 1, 1}}, 18));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 15));
+    auto x_main_module_17 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 16)));
+    auto x_main_module_18 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {512, 2048, 1, 1}}, 17));
+    auto x_main_module_19 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 18)));
     auto x_main_module_20 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 19));
-    auto x_main_module_21 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {512, 512, 3, 3}}, 20));
-    auto x_main_module_22 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 21));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 19));
+    auto x_main_module_21 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 20));
+    auto x_main_module_22 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 21)));
     auto x_main_module_23 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {512, 1024, 1, 1}}, 22));
-    auto x_main_module_24 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 23));
-    auto x_main_module_25 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 24));
+        migraphx::shape{migraphx::shape::float_type, {2048, 512, 1, 1}}, 22));
+    auto x_main_module_24 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 23)));
+    auto x_main_module_25 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 24));
     auto x_main_module_26 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 25));
-    auto x_main_module_27 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 26));
-    auto x_main_module_28 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 27));
-    auto x_main_module_29 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 28));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 25));
+    auto x_main_module_27 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 26)));
+    auto x_main_module_28 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {512, 512, 3, 3}}, 27));
+    auto x_main_module_29 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 28)));
     auto x_main_module_30 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 29));
-    auto x_main_module_31 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 30));
-    auto x_main_module_32 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 31));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 29));
+    auto x_main_module_31 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 30));
+    auto x_main_module_32 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 31)));
     auto x_main_module_33 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 32));
-    auto x_main_module_34 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 33));
-    auto x_main_module_35 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 34));
+        migraphx::shape{migraphx::shape::float_type, {512, 2048, 1, 1}}, 32));
+    auto x_main_module_34 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 33)));
+    auto x_main_module_35 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 34));
     auto x_main_module_36 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 35));
-    auto x_main_module_37 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 36));
-    auto x_main_module_38 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 37));
-    auto x_main_module_39 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 38));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 35));
+    auto x_main_module_37 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 36)));
+    auto x_main_module_38 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {2048, 1024, 1, 1}}, 37));
+    auto x_main_module_39 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 38)));
     auto x_main_module_40 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 39));
-    auto x_main_module_41 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 40));
-    auto x_main_module_42 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 41));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 39));
+    auto x_main_module_41 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 40));
+    auto x_main_module_42 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {2048}}, 41)));
     auto x_main_module_43 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 42));
-    auto x_main_module_44 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 43));
-    auto x_main_module_45 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 44));
+        migraphx::shape{migraphx::shape::float_type, {2048, 512, 1, 1}}, 42));
+    auto x_main_module_44 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 43)));
+    auto x_main_module_45 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 44));
     auto x_main_module_46 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 45));
-    auto x_main_module_47 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 46));
-    auto x_main_module_48 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 47));
-    auto x_main_module_49 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 48));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 45));
+    auto x_main_module_47 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 46)));
+    auto x_main_module_48 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {512, 512, 3, 3}}, 47));
+    auto x_main_module_49 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 48)));
     auto x_main_module_50 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 49));
-    auto x_main_module_51 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 50));
-    auto x_main_module_52 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 51));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 49));
+    auto x_main_module_51 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 50));
+    auto x_main_module_52 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 51)));
     auto x_main_module_53 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 52));
-    auto x_main_module_54 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 53));
-    auto x_main_module_55 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {1024, 512, 1, 1}}, 54));
+        migraphx::shape{migraphx::shape::float_type, {512, 1024, 1, 1}}, 52));
+    auto x_main_module_54 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 53)));
+    auto x_main_module_55 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 54));
     auto x_main_module_56 = mmain->add_literal(
         migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 55));
-    auto x_main_module_57 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 56));
-    auto x_main_module_58 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 57));
-    auto x_main_module_59 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 58));
+    auto x_main_module_57 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 56));
+    auto x_main_module_58 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 57));
+    auto x_main_module_59 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 58)));
     auto x_main_module_60 = mmain->add_literal(
         migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 59));
-    auto x_main_module_61 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {256, 512, 1, 1}}, 60));
-    auto x_main_module_62 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 61));
+    auto x_main_module_61 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 60));
+    auto x_main_module_62 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 61)));
     auto x_main_module_63 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {512, 128, 1, 1}}, 62));
-    auto x_main_module_64 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 63));
-    auto x_main_module_65 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {128, 128, 3, 3}}, 64));
+        migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 62));
+    auto x_main_module_64 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 63)));
+    auto x_main_module_65 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 64));
     auto x_main_module_66 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 65));
-    auto x_main_module_67 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {128, 512, 1, 1}}, 66));
-    auto x_main_module_68 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 67));
-    auto x_main_module_69 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {512, 128, 1, 1}}, 68));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 65));
+    auto x_main_module_67 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 66)));
+    auto x_main_module_68 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 67));
+    auto x_main_module_69 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 68)));
     auto x_main_module_70 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 69));
-    auto x_main_module_71 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {128, 128, 3, 3}}, 70));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 69));
+    auto x_main_module_71 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 70));
     auto x_main_module_72 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 71));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 71));
     auto x_main_module_73 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {128, 512, 1, 1}}, 72));
-    auto x_main_module_74 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 73));
-    auto x_main_module_75 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {512, 128, 1, 1}}, 74));
+        migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 72));
+    auto x_main_module_74 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 73)));
+    auto x_main_module_75 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 74));
     auto x_main_module_76 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 75));
-    auto x_main_module_77 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {128, 128, 3, 3}}, 76));
-    auto x_main_module_78 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 77));
-    auto x_main_module_79 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {128, 512, 1, 1}}, 78));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 75));
+    auto x_main_module_77 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 76)));
+    auto x_main_module_78 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 77));
+    auto x_main_module_79 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 78)));
     auto x_main_module_80 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 79));
-    auto x_main_module_81 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {512, 256, 1, 1}}, 80));
-    auto x_main_module_82 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 81));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 79));
+    auto x_main_module_81 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 80));
+    auto x_main_module_82 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 81)));
     auto x_main_module_83 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {512, 128, 1, 1}}, 82));
-    auto x_main_module_84 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 83));
-    auto x_main_module_85 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {128, 128, 3, 3}}, 84));
+        migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 82));
+    auto x_main_module_84 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 83)));
+    auto x_main_module_85 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 84));
     auto x_main_module_86 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 85));
-    auto x_main_module_87 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {128, 256, 1, 1}}, 86));
-    auto x_main_module_88 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 87));
-    auto x_main_module_89 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {256, 64, 1, 1}}, 88));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 85));
+    auto x_main_module_87 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 86));
+    auto x_main_module_88 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 87));
+    auto x_main_module_89 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 88)));
     auto x_main_module_90 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 89));
-    auto x_main_module_91 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {64, 64, 3, 3}}, 90));
-    auto x_main_module_92 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 91));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 89));
+    auto x_main_module_91 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 90));
+    auto x_main_module_92 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 91)));
     auto x_main_module_93 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {64, 256, 1, 1}}, 92));
-    auto x_main_module_94 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 93));
-    auto x_main_module_95 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {256, 64, 1, 1}}, 94));
+        migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 92));
+    auto x_main_module_94 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 93)));
+    auto x_main_module_95 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 94));
     auto x_main_module_96 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 95));
-    auto x_main_module_97 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {64, 64, 3, 3}}, 96));
-    auto x_main_module_98 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 97));
-    auto x_main_module_99  = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {64, 256, 1, 1}}, 98));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 95));
+    auto x_main_module_97  = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 96)));
+    auto x_main_module_98  = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 97));
+    auto x_main_module_99  = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 98)));
     auto x_main_module_100 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 99));
-    auto x_main_module_101 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {256, 64, 1, 1}}, 100));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 99));
+    auto x_main_module_101 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 100));
     auto x_main_module_102 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 101));
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 101));
     auto x_main_module_103 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {256, 64, 1, 1}}, 102));
-    auto x_main_module_104 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 103));
-    auto x_main_module_105 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {64, 64, 3, 3}}, 104));
+        migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 102));
+    auto x_main_module_104 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 103)));
+    auto x_main_module_105 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 104));
     auto x_main_module_106 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 105));
-    auto x_main_module_107 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {64, 64, 1, 1}}, 106));
-    auto x_main_module_108 = mmain->add_literal(
-        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 107));
-    auto x_main_module_109 = mmain->add_literal(migraphx::generate_literal(
-        migraphx::shape{migraphx::shape::float_type, {64, 3, 7, 7}}, 108));
-    auto x_main_module_110 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[3,3,3,3],padding_mode:0,stride:[2,2]}")),
-        x_input_1,
-        x_main_module_109);
-    auto x_main_module_111 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,64,112,112]}")),
-        x_main_module_108);
-    auto x_main_module_112 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_110, x_main_module_111);
-    auto x_main_module_113 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_112);
-    auto x_main_module_114 = mmain->add_instruction(
-        migraphx::make_op(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 105));
+    auto x_main_module_107 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 106)));
+    auto x_main_module_108 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 107));
+    auto x_main_module_109 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 108)));
+    auto x_main_module_110 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 109));
+    auto x_main_module_111 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 110));
+    auto x_main_module_112 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 111)));
+    auto x_main_module_113 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 112));
+    auto x_main_module_114 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 113)));
+    auto x_main_module_115 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 114));
+    auto x_main_module_116 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 115));
+    auto x_main_module_117 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 116));
+    auto x_main_module_118 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 117));
+    auto x_main_module_119 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 118)));
+    auto x_main_module_120 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 119));
+    auto x_main_module_121 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 120));
+    auto x_main_module_122 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 121)));
+    auto x_main_module_123 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 122));
+    auto x_main_module_124 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 123)));
+    auto x_main_module_125 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 124));
+    auto x_main_module_126 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 125));
+    auto x_main_module_127 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 126)));
+    auto x_main_module_128 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {256, 1024, 1, 1}}, 127));
+    auto x_main_module_129 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 128)));
+    auto x_main_module_130 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 129));
+    auto x_main_module_131 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 130));
+    auto x_main_module_132 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 131));
+    auto x_main_module_133 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {1024, 512, 1, 1}}, 132));
+    auto x_main_module_134 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 133)));
+    auto x_main_module_135 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 134));
+    auto x_main_module_136 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 135));
+    auto x_main_module_137 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {1024}}, 136));
+    auto x_main_module_138 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {1024, 256, 1, 1}}, 137));
+    auto x_main_module_139 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 138)));
+    auto x_main_module_140 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 139));
+    auto x_main_module_141 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 140));
+    auto x_main_module_142 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 141)));
+    auto x_main_module_143 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {256, 256, 3, 3}}, 142));
+    auto x_main_module_144 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 143)));
+    auto x_main_module_145 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 144));
+    auto x_main_module_146 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 145));
+    auto x_main_module_147 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 146)));
+    auto x_main_module_148 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {256, 512, 1, 1}}, 147));
+    auto x_main_module_149 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 148)));
+    auto x_main_module_150 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 149));
+    auto x_main_module_151 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 150));
+    auto x_main_module_152 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 151));
+    auto x_main_module_153 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {512, 128, 1, 1}}, 152));
+    auto x_main_module_154 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 153)));
+    auto x_main_module_155 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 154));
+    auto x_main_module_156 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 155));
+    auto x_main_module_157 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 156)));
+    auto x_main_module_158 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {128, 128, 3, 3}}, 157));
+    auto x_main_module_159 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 158)));
+    auto x_main_module_160 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 159));
+    auto x_main_module_161 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 160));
+    auto x_main_module_162 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 161)));
+    auto x_main_module_163 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {128, 512, 1, 1}}, 162));
+    auto x_main_module_164 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 163)));
+    auto x_main_module_165 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 164));
+    auto x_main_module_166 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 165));
+    auto x_main_module_167 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 166));
+    auto x_main_module_168 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {512, 128, 1, 1}}, 167));
+    auto x_main_module_169 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 168)));
+    auto x_main_module_170 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 169));
+    auto x_main_module_171 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 170));
+    auto x_main_module_172 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 171)));
+    auto x_main_module_173 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {128, 128, 3, 3}}, 172));
+    auto x_main_module_174 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 173)));
+    auto x_main_module_175 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 174));
+    auto x_main_module_176 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 175));
+    auto x_main_module_177 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 176)));
+    auto x_main_module_178 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {128, 512, 1, 1}}, 177));
+    auto x_main_module_179 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 178)));
+    auto x_main_module_180 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 179));
+    auto x_main_module_181 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 180));
+    auto x_main_module_182 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 181));
+    auto x_main_module_183 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {512, 128, 1, 1}}, 182));
+    auto x_main_module_184 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 183)));
+    auto x_main_module_185 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 184));
+    auto x_main_module_186 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 185));
+    auto x_main_module_187 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 186)));
+    auto x_main_module_188 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {128, 128, 3, 3}}, 187));
+    auto x_main_module_189 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 188)));
+    auto x_main_module_190 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 189));
+    auto x_main_module_191 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 190));
+    auto x_main_module_192 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 191)));
+    auto x_main_module_193 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {128, 512, 1, 1}}, 192));
+    auto x_main_module_194 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 193)));
+    auto x_main_module_195 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 194));
+    auto x_main_module_196 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 195));
+    auto x_main_module_197 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 196));
+    auto x_main_module_198 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {512, 256, 1, 1}}, 197));
+    auto x_main_module_199 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 198)));
+    auto x_main_module_200 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 199));
+    auto x_main_module_201 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 200));
+    auto x_main_module_202 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {512}}, 201));
+    auto x_main_module_203 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {512, 128, 1, 1}}, 202));
+    auto x_main_module_204 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 203)));
+    auto x_main_module_205 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 204));
+    auto x_main_module_206 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 205));
+    auto x_main_module_207 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 206)));
+    auto x_main_module_208 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {128, 128, 3, 3}}, 207));
+    auto x_main_module_209 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 208)));
+    auto x_main_module_210 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 209));
+    auto x_main_module_211 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 210));
+    auto x_main_module_212 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {128}}, 211)));
+    auto x_main_module_213 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {128, 256, 1, 1}}, 212));
+    auto x_main_module_214 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 213)));
+    auto x_main_module_215 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 214));
+    auto x_main_module_216 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 215));
+    auto x_main_module_217 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 216));
+    auto x_main_module_218 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {256, 64, 1, 1}}, 217));
+    auto x_main_module_219 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 218)));
+    auto x_main_module_220 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 219));
+    auto x_main_module_221 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 220));
+    auto x_main_module_222 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 221)));
+    auto x_main_module_223 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {64, 64, 3, 3}}, 222));
+    auto x_main_module_224 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 223)));
+    auto x_main_module_225 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 224));
+    auto x_main_module_226 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 225));
+    auto x_main_module_227 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 226)));
+    auto x_main_module_228 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {64, 256, 1, 1}}, 227));
+    auto x_main_module_229 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 228)));
+    auto x_main_module_230 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 229));
+    auto x_main_module_231 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 230));
+    auto x_main_module_232 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 231));
+    auto x_main_module_233 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {256, 64, 1, 1}}, 232));
+    auto x_main_module_234 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 233)));
+    auto x_main_module_235 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 234));
+    auto x_main_module_236 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 235));
+    auto x_main_module_237 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 236)));
+    auto x_main_module_238 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {64, 64, 3, 3}}, 237));
+    auto x_main_module_239 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 238)));
+    auto x_main_module_240 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 239));
+    auto x_main_module_241 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 240));
+    auto x_main_module_242 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 241)));
+    auto x_main_module_243 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {64, 256, 1, 1}}, 242));
+    auto x_main_module_244 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 243)));
+    auto x_main_module_245 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 244));
+    auto x_main_module_246 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 245));
+    auto x_main_module_247 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 246));
+    auto x_main_module_248 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {256, 64, 1, 1}}, 247));
+    auto x_main_module_249 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 248)));
+    auto x_main_module_250 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 249));
+    auto x_main_module_251 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 250));
+    auto x_main_module_252 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {256}}, 251));
+    auto x_main_module_253 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {256, 64, 1, 1}}, 252));
+    auto x_main_module_254 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 253)));
+    auto x_main_module_255 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 254));
+    auto x_main_module_256 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 255));
+    auto x_main_module_257 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 256)));
+    auto x_main_module_258 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {64, 64, 3, 3}}, 257));
+    auto x_main_module_259 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 258)));
+    auto x_main_module_260 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 259));
+    auto x_main_module_261 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 260));
+    auto x_main_module_262 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 261)));
+    auto x_main_module_263 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {64, 64, 1, 1}}, 262));
+    auto x_main_module_264 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 263)));
+    auto x_main_module_265 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 264));
+    auto x_main_module_266 = mmain->add_literal(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 265));
+    auto x_main_module_267 = mmain->add_literal(migraphx::abs(
+        migraphx::generate_literal(migraphx::shape{migraphx::shape::float_type, {64}}, 266)));
+    auto x_main_module_268 = mmain->add_literal(migraphx::generate_literal(
+        migraphx::shape{migraphx::shape::float_type, {64, 3, 7, 7}}, 267));
+    auto x_main_module_269 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[3,3,3,3],padding_mode:0,stride:[2,"
+                               "2],use_dynamic_same_auto_pad:0}"),
+        x_0,
+        x_main_module_268);
+    auto x_main_module_270 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_269,
+        x_main_module_267,
+        x_main_module_266,
+        x_main_module_265,
+        x_main_module_264);
+    auto x_main_module_271 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_270);
+    auto x_main_module_272 = mmain->add_instruction(
+        migraphx::make_json_op(
             "pooling",
-            migraphx::from_json_string(
-                "{ceil_mode:0,lengths:[3,3],lp_order:2,mode:1,padding:[1,1,1,1],stride:[2,2]}")),
+            "{ceil_mode:0,lengths:[3,3],lp_order:2,mode:1,padding:[1,1,1,1],stride:[2,2]}"),
+        x_main_module_271);
+    auto x_main_module_273 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_272,
+        x_main_module_263);
+    auto x_main_module_274 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_273,
+        x_main_module_262,
+        x_main_module_261,
+        x_main_module_260,
+        x_main_module_259);
+    auto x_main_module_275 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_274);
+    auto x_main_module_276 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_275,
+        x_main_module_258);
+    auto x_main_module_277 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_276,
+        x_main_module_257,
+        x_main_module_256,
+        x_main_module_255,
+        x_main_module_254);
+    auto x_main_module_278 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_277);
+    auto x_main_module_279 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_278,
+        x_main_module_253);
+    auto x_main_module_280 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_279,
+        x_main_module_252,
+        x_main_module_251,
+        x_main_module_250,
+        x_main_module_249);
+    auto x_main_module_281 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_272,
+        x_main_module_248);
+    auto x_main_module_282 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_281,
+        x_main_module_247,
+        x_main_module_246,
+        x_main_module_245,
+        x_main_module_244);
+    auto x_main_module_283 =
+        mmain->add_instruction(migraphx::make_op("add"), x_main_module_280, x_main_module_282);
+    auto x_main_module_284 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_283);
+    auto x_main_module_285 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_284,
+        x_main_module_243);
+    auto x_main_module_286 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_285,
+        x_main_module_242,
+        x_main_module_241,
+        x_main_module_240,
+        x_main_module_239);
+    auto x_main_module_287 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_286);
+    auto x_main_module_288 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_287,
+        x_main_module_238);
+    auto x_main_module_289 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_288,
+        x_main_module_237,
+        x_main_module_236,
+        x_main_module_235,
+        x_main_module_234);
+    auto x_main_module_290 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_289);
+    auto x_main_module_291 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_290,
+        x_main_module_233);
+    auto x_main_module_292 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_291,
+        x_main_module_232,
+        x_main_module_231,
+        x_main_module_230,
+        x_main_module_229);
+    auto x_main_module_293 =
+        mmain->add_instruction(migraphx::make_op("add"), x_main_module_292, x_main_module_284);
+    auto x_main_module_294 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_293);
+    auto x_main_module_295 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_294,
+        x_main_module_228);
+    auto x_main_module_296 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_295,
+        x_main_module_227,
+        x_main_module_226,
+        x_main_module_225,
+        x_main_module_224);
+    auto x_main_module_297 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_296);
+    auto x_main_module_298 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_297,
+        x_main_module_223);
+    auto x_main_module_299 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_298,
+        x_main_module_222,
+        x_main_module_221,
+        x_main_module_220,
+        x_main_module_219);
+    auto x_main_module_300 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_299);
+    auto x_main_module_301 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_300,
+        x_main_module_218);
+    auto x_main_module_302 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_301,
+        x_main_module_217,
+        x_main_module_216,
+        x_main_module_215,
+        x_main_module_214);
+    auto x_main_module_303 =
+        mmain->add_instruction(migraphx::make_op("add"), x_main_module_302, x_main_module_294);
+    auto x_main_module_304 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_303);
+    auto x_main_module_305 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_304,
+        x_main_module_213);
+    auto x_main_module_306 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_305,
+        x_main_module_212,
+        x_main_module_211,
+        x_main_module_210,
+        x_main_module_209);
+    auto x_main_module_307 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_306);
+    auto x_main_module_308 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[2,"
+                               "2],use_dynamic_same_auto_pad:0}"),
+        x_main_module_307,
+        x_main_module_208);
+    auto x_main_module_309 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_308,
+        x_main_module_207,
+        x_main_module_206,
+        x_main_module_205,
+        x_main_module_204);
+    auto x_main_module_310 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_309);
+    auto x_main_module_311 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_310,
+        x_main_module_203);
+    auto x_main_module_312 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_311,
+        x_main_module_202,
+        x_main_module_201,
+        x_main_module_200,
+        x_main_module_199);
+    auto x_main_module_313 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[2,"
+                               "2],use_dynamic_same_auto_pad:0}"),
+        x_main_module_304,
+        x_main_module_198);
+    auto x_main_module_314 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_313,
+        x_main_module_197,
+        x_main_module_196,
+        x_main_module_195,
+        x_main_module_194);
+    auto x_main_module_315 =
+        mmain->add_instruction(migraphx::make_op("add"), x_main_module_312, x_main_module_314);
+    auto x_main_module_316 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_315);
+    auto x_main_module_317 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_316,
+        x_main_module_193);
+    auto x_main_module_318 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_317,
+        x_main_module_192,
+        x_main_module_191,
+        x_main_module_190,
+        x_main_module_189);
+    auto x_main_module_319 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_318);
+    auto x_main_module_320 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_319,
+        x_main_module_188);
+    auto x_main_module_321 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_320,
+        x_main_module_187,
+        x_main_module_186,
+        x_main_module_185,
+        x_main_module_184);
+    auto x_main_module_322 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_321);
+    auto x_main_module_323 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_322,
+        x_main_module_183);
+    auto x_main_module_324 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_323,
+        x_main_module_182,
+        x_main_module_181,
+        x_main_module_180,
+        x_main_module_179);
+    auto x_main_module_325 =
+        mmain->add_instruction(migraphx::make_op("add"), x_main_module_324, x_main_module_316);
+    auto x_main_module_326 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_325);
+    auto x_main_module_327 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_326,
+        x_main_module_178);
+    auto x_main_module_328 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_327,
+        x_main_module_177,
+        x_main_module_176,
+        x_main_module_175,
+        x_main_module_174);
+    auto x_main_module_329 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_328);
+    auto x_main_module_330 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_329,
+        x_main_module_173);
+    auto x_main_module_331 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_330,
+        x_main_module_172,
+        x_main_module_171,
+        x_main_module_170,
+        x_main_module_169);
+    auto x_main_module_332 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_331);
+    auto x_main_module_333 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_332,
+        x_main_module_168);
+    auto x_main_module_334 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_333,
+        x_main_module_167,
+        x_main_module_166,
+        x_main_module_165,
+        x_main_module_164);
+    auto x_main_module_335 =
+        mmain->add_instruction(migraphx::make_op("add"), x_main_module_334, x_main_module_326);
+    auto x_main_module_336 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_335);
+    auto x_main_module_337 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_336,
+        x_main_module_163);
+    auto x_main_module_338 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_337,
+        x_main_module_162,
+        x_main_module_161,
+        x_main_module_160,
+        x_main_module_159);
+    auto x_main_module_339 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_338);
+    auto x_main_module_340 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_339,
+        x_main_module_158);
+    auto x_main_module_341 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_340,
+        x_main_module_157,
+        x_main_module_156,
+        x_main_module_155,
+        x_main_module_154);
+    auto x_main_module_342 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_341);
+    auto x_main_module_343 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_342,
+        x_main_module_153);
+    auto x_main_module_344 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_343,
+        x_main_module_152,
+        x_main_module_151,
+        x_main_module_150,
+        x_main_module_149);
+    auto x_main_module_345 =
+        mmain->add_instruction(migraphx::make_op("add"), x_main_module_344, x_main_module_336);
+    auto x_main_module_346 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_345);
+    auto x_main_module_347 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_346,
+        x_main_module_148);
+    auto x_main_module_348 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_347,
+        x_main_module_147,
+        x_main_module_146,
+        x_main_module_145,
+        x_main_module_144);
+    auto x_main_module_349 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_348);
+    auto x_main_module_350 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[2,"
+                               "2],use_dynamic_same_auto_pad:0}"),
+        x_main_module_349,
+        x_main_module_143);
+    auto x_main_module_351 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_350,
+        x_main_module_142,
+        x_main_module_141,
+        x_main_module_140,
+        x_main_module_139);
+    auto x_main_module_352 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_351);
+    auto x_main_module_353 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_352,
+        x_main_module_138);
+    auto x_main_module_354 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_353,
+        x_main_module_137,
+        x_main_module_136,
+        x_main_module_135,
+        x_main_module_134);
+    auto x_main_module_355 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[2,"
+                               "2],use_dynamic_same_auto_pad:0}"),
+        x_main_module_346,
+        x_main_module_133);
+    auto x_main_module_356 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_355,
+        x_main_module_132,
+        x_main_module_131,
+        x_main_module_130,
+        x_main_module_129);
+    auto x_main_module_357 =
+        mmain->add_instruction(migraphx::make_op("add"), x_main_module_354, x_main_module_356);
+    auto x_main_module_358 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_357);
+    auto x_main_module_359 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_358,
+        x_main_module_128);
+    auto x_main_module_360 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_359,
+        x_main_module_127,
+        x_main_module_126,
+        x_main_module_125,
+        x_main_module_124);
+    auto x_main_module_361 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_360);
+    auto x_main_module_362 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_361,
+        x_main_module_123);
+    auto x_main_module_363 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_362,
+        x_main_module_122,
+        x_main_module_121,
+        x_main_module_120,
+        x_main_module_119);
+    auto x_main_module_364 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_363);
+    auto x_main_module_365 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_364,
+        x_main_module_118);
+    auto x_main_module_366 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_365,
+        x_main_module_117,
+        x_main_module_116,
+        x_main_module_115,
+        x_main_module_114);
+    auto x_main_module_367 =
+        mmain->add_instruction(migraphx::make_op("add"), x_main_module_366, x_main_module_358);
+    auto x_main_module_368 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_367);
+    auto x_main_module_369 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_368,
         x_main_module_113);
-    auto x_main_module_115 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_114,
-        x_main_module_107);
-    auto x_main_module_116 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,64,56,56]}")),
-        x_main_module_106);
-    auto x_main_module_117 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_115, x_main_module_116);
-    auto x_main_module_118 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_117);
-    auto x_main_module_119 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
-        x_main_module_118,
-        x_main_module_105);
-    auto x_main_module_120 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,64,56,56]}")),
+    auto x_main_module_370 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_369,
+        x_main_module_112,
+        x_main_module_111,
+        x_main_module_110,
+        x_main_module_109);
+    auto x_main_module_371 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_370);
+    auto x_main_module_372 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_371,
+        x_main_module_108);
+    auto x_main_module_373 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_372,
+        x_main_module_107,
+        x_main_module_106,
+        x_main_module_105,
         x_main_module_104);
-    auto x_main_module_121 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_119, x_main_module_120);
-    auto x_main_module_122 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_121);
-    auto x_main_module_123 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_122,
+    auto x_main_module_374 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_373);
+    auto x_main_module_375 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_374,
         x_main_module_103);
-    auto x_main_module_124 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,256,56,56]}")),
-        x_main_module_102);
-    auto x_main_module_125 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_123, x_main_module_124);
-    auto x_main_module_126 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_114,
-        x_main_module_101);
-    auto x_main_module_127 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,256,56,56]}")),
-        x_main_module_100);
-    auto x_main_module_128 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_126, x_main_module_127);
-    auto x_main_module_129 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_125, x_main_module_128);
-    auto x_main_module_130 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_129);
-    auto x_main_module_131 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_130,
+    auto x_main_module_376 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_375,
+        x_main_module_102,
+        x_main_module_101,
+        x_main_module_100,
         x_main_module_99);
-    auto x_main_module_132 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,64,56,56]}")),
+    auto x_main_module_377 =
+        mmain->add_instruction(migraphx::make_op("add"), x_main_module_376, x_main_module_368);
+    auto x_main_module_378 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_377);
+    auto x_main_module_379 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_378,
         x_main_module_98);
-    auto x_main_module_133 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_131, x_main_module_132);
-    auto x_main_module_134 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_133);
-    auto x_main_module_135 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
-        x_main_module_134,
-        x_main_module_97);
-    auto x_main_module_136 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,64,56,56]}")),
-        x_main_module_96);
-    auto x_main_module_137 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_135, x_main_module_136);
-    auto x_main_module_138 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_137);
-    auto x_main_module_139 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_138,
-        x_main_module_95);
-    auto x_main_module_140 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,256,56,56]}")),
+    auto x_main_module_380 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_379,
+        x_main_module_97,
+        x_main_module_96,
+        x_main_module_95,
         x_main_module_94);
-    auto x_main_module_141 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_139, x_main_module_140);
-    auto x_main_module_142 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_141, x_main_module_130);
-    auto x_main_module_143 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_142);
-    auto x_main_module_144 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_143,
+    auto x_main_module_381 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_380);
+    auto x_main_module_382 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_381,
         x_main_module_93);
-    auto x_main_module_145 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,64,56,56]}")),
-        x_main_module_92);
-    auto x_main_module_146 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_144, x_main_module_145);
-    auto x_main_module_147 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_146);
-    auto x_main_module_148 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
-        x_main_module_147,
-        x_main_module_91);
-    auto x_main_module_149 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,64,56,56]}")),
-        x_main_module_90);
-    auto x_main_module_150 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_148, x_main_module_149);
-    auto x_main_module_151 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_150);
-    auto x_main_module_152 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_151,
+    auto x_main_module_383 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_382,
+        x_main_module_92,
+        x_main_module_91,
+        x_main_module_90,
         x_main_module_89);
-    auto x_main_module_153 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,256,56,56]}")),
+    auto x_main_module_384 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_383);
+    auto x_main_module_385 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_384,
         x_main_module_88);
-    auto x_main_module_154 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_152, x_main_module_153);
-    auto x_main_module_155 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_154, x_main_module_143);
-    auto x_main_module_156 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_155);
-    auto x_main_module_157 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_156,
-        x_main_module_87);
-    auto x_main_module_158 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,128,56,56]}")),
-        x_main_module_86);
-    auto x_main_module_159 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_157, x_main_module_158);
-    auto x_main_module_160 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_159);
-    auto x_main_module_161 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[2,2]}")),
-        x_main_module_160,
-        x_main_module_85);
-    auto x_main_module_162 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,128,28,28]}")),
+    auto x_main_module_386 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_385,
+        x_main_module_87,
+        x_main_module_86,
+        x_main_module_85,
         x_main_module_84);
-    auto x_main_module_163 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_161, x_main_module_162);
-    auto x_main_module_164 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_163);
-    auto x_main_module_165 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_164,
+    auto x_main_module_387 =
+        mmain->add_instruction(migraphx::make_op("add"), x_main_module_386, x_main_module_378);
+    auto x_main_module_388 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_387);
+    auto x_main_module_389 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_388,
         x_main_module_83);
-    auto x_main_module_166 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,512,28,28]}")),
-        x_main_module_82);
-    auto x_main_module_167 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_165, x_main_module_166);
-    auto x_main_module_168 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[2,2]}")),
-        x_main_module_156,
-        x_main_module_81);
-    auto x_main_module_169 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,512,28,28]}")),
-        x_main_module_80);
-    auto x_main_module_170 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_168, x_main_module_169);
-    auto x_main_module_171 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_167, x_main_module_170);
-    auto x_main_module_172 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_171);
-    auto x_main_module_173 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_172,
+    auto x_main_module_390 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_389,
+        x_main_module_82,
+        x_main_module_81,
+        x_main_module_80,
         x_main_module_79);
-    auto x_main_module_174 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,128,28,28]}")),
+    auto x_main_module_391 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_390);
+    auto x_main_module_392 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_391,
         x_main_module_78);
-    auto x_main_module_175 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_173, x_main_module_174);
-    auto x_main_module_176 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_175);
-    auto x_main_module_177 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
-        x_main_module_176,
-        x_main_module_77);
-    auto x_main_module_178 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,128,28,28]}")),
-        x_main_module_76);
-    auto x_main_module_179 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_177, x_main_module_178);
-    auto x_main_module_180 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_179);
-    auto x_main_module_181 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_180,
-        x_main_module_75);
-    auto x_main_module_182 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,512,28,28]}")),
+    auto x_main_module_393 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_392,
+        x_main_module_77,
+        x_main_module_76,
+        x_main_module_75,
         x_main_module_74);
-    auto x_main_module_183 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_181, x_main_module_182);
-    auto x_main_module_184 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_183, x_main_module_172);
-    auto x_main_module_185 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_184);
-    auto x_main_module_186 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_185,
+    auto x_main_module_394 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_393);
+    auto x_main_module_395 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_394,
         x_main_module_73);
-    auto x_main_module_187 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,128,28,28]}")),
-        x_main_module_72);
-    auto x_main_module_188 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_186, x_main_module_187);
-    auto x_main_module_189 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_188);
-    auto x_main_module_190 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
-        x_main_module_189,
-        x_main_module_71);
-    auto x_main_module_191 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,128,28,28]}")),
-        x_main_module_70);
-    auto x_main_module_192 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_190, x_main_module_191);
-    auto x_main_module_193 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_192);
-    auto x_main_module_194 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_193,
+    auto x_main_module_396 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_395,
+        x_main_module_72,
+        x_main_module_71,
+        x_main_module_70,
         x_main_module_69);
-    auto x_main_module_195 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,512,28,28]}")),
+    auto x_main_module_397 =
+        mmain->add_instruction(migraphx::make_op("add"), x_main_module_396, x_main_module_388);
+    auto x_main_module_398 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_397);
+    auto x_main_module_399 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_398,
         x_main_module_68);
-    auto x_main_module_196 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_194, x_main_module_195);
-    auto x_main_module_197 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_196, x_main_module_185);
-    auto x_main_module_198 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_197);
-    auto x_main_module_199 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_198,
-        x_main_module_67);
-    auto x_main_module_200 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,128,28,28]}")),
-        x_main_module_66);
-    auto x_main_module_201 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_199, x_main_module_200);
-    auto x_main_module_202 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_201);
-    auto x_main_module_203 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
-        x_main_module_202,
-        x_main_module_65);
-    auto x_main_module_204 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,128,28,28]}")),
+    auto x_main_module_400 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_399,
+        x_main_module_67,
+        x_main_module_66,
+        x_main_module_65,
         x_main_module_64);
-    auto x_main_module_205 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_203, x_main_module_204);
-    auto x_main_module_206 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_205);
-    auto x_main_module_207 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_206,
+    auto x_main_module_401 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_400);
+    auto x_main_module_402 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_401,
         x_main_module_63);
-    auto x_main_module_208 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,512,28,28]}")),
-        x_main_module_62);
-    auto x_main_module_209 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_207, x_main_module_208);
-    auto x_main_module_210 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_209, x_main_module_198);
-    auto x_main_module_211 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_210);
-    auto x_main_module_212 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_211,
-        x_main_module_61);
-    auto x_main_module_213 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,256,28,28]}")),
-        x_main_module_60);
-    auto x_main_module_214 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_212, x_main_module_213);
-    auto x_main_module_215 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_214);
-    auto x_main_module_216 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[2,2]}")),
-        x_main_module_215,
+    auto x_main_module_403 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_402,
+        x_main_module_62,
+        x_main_module_61,
+        x_main_module_60,
         x_main_module_59);
-    auto x_main_module_217 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
+    auto x_main_module_404 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_403);
+    auto x_main_module_405 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_404,
         x_main_module_58);
-    auto x_main_module_218 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_216, x_main_module_217);
-    auto x_main_module_219 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_218);
-    auto x_main_module_220 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_219,
-        x_main_module_57);
-    auto x_main_module_221 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,1024,14,14]}")),
-        x_main_module_56);
-    auto x_main_module_222 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_220, x_main_module_221);
-    auto x_main_module_223 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[2,2]}")),
-        x_main_module_211,
-        x_main_module_55);
-    auto x_main_module_224 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,1024,14,14]}")),
+    auto x_main_module_406 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_405,
+        x_main_module_57,
+        x_main_module_56,
+        x_main_module_55,
         x_main_module_54);
-    auto x_main_module_225 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_223, x_main_module_224);
-    auto x_main_module_226 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_222, x_main_module_225);
-    auto x_main_module_227 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_226);
-    auto x_main_module_228 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_227,
+    auto x_main_module_407 =
+        mmain->add_instruction(migraphx::make_op("add"), x_main_module_406, x_main_module_398);
+    auto x_main_module_408 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_407);
+    auto x_main_module_409 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_408,
         x_main_module_53);
-    auto x_main_module_229 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
-        x_main_module_52);
-    auto x_main_module_230 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_228, x_main_module_229);
-    auto x_main_module_231 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_230);
-    auto x_main_module_232 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
-        x_main_module_231,
-        x_main_module_51);
-    auto x_main_module_233 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
-        x_main_module_50);
-    auto x_main_module_234 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_232, x_main_module_233);
-    auto x_main_module_235 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_234);
-    auto x_main_module_236 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_235,
+    auto x_main_module_410 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_409,
+        x_main_module_52,
+        x_main_module_51,
+        x_main_module_50,
         x_main_module_49);
-    auto x_main_module_237 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,1024,14,14]}")),
+    auto x_main_module_411 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_410);
+    auto x_main_module_412 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[2,"
+                               "2],use_dynamic_same_auto_pad:0}"),
+        x_main_module_411,
         x_main_module_48);
-    auto x_main_module_238 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_236, x_main_module_237);
-    auto x_main_module_239 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_238, x_main_module_227);
-    auto x_main_module_240 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_239);
-    auto x_main_module_241 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_240,
-        x_main_module_47);
-    auto x_main_module_242 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
-        x_main_module_46);
-    auto x_main_module_243 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_241, x_main_module_242);
-    auto x_main_module_244 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_243);
-    auto x_main_module_245 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
-        x_main_module_244,
-        x_main_module_45);
-    auto x_main_module_246 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
+    auto x_main_module_413 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_412,
+        x_main_module_47,
+        x_main_module_46,
+        x_main_module_45,
         x_main_module_44);
-    auto x_main_module_247 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_245, x_main_module_246);
-    auto x_main_module_248 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_247);
-    auto x_main_module_249 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_248,
+    auto x_main_module_414 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_413);
+    auto x_main_module_415 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_414,
         x_main_module_43);
-    auto x_main_module_250 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,1024,14,14]}")),
-        x_main_module_42);
-    auto x_main_module_251 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_249, x_main_module_250);
-    auto x_main_module_252 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_251, x_main_module_240);
-    auto x_main_module_253 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_252);
-    auto x_main_module_254 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_253,
-        x_main_module_41);
-    auto x_main_module_255 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
-        x_main_module_40);
-    auto x_main_module_256 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_254, x_main_module_255);
-    auto x_main_module_257 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_256);
-    auto x_main_module_258 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
-        x_main_module_257,
+    auto x_main_module_416 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_415,
+        x_main_module_42,
+        x_main_module_41,
+        x_main_module_40,
         x_main_module_39);
-    auto x_main_module_259 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
+    auto x_main_module_417 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[2,"
+                               "2],use_dynamic_same_auto_pad:0}"),
+        x_main_module_408,
         x_main_module_38);
-    auto x_main_module_260 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_258, x_main_module_259);
-    auto x_main_module_261 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_260);
-    auto x_main_module_262 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_261,
-        x_main_module_37);
-    auto x_main_module_263 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,1024,14,14]}")),
-        x_main_module_36);
-    auto x_main_module_264 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_262, x_main_module_263);
-    auto x_main_module_265 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_264, x_main_module_253);
-    auto x_main_module_266 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_265);
-    auto x_main_module_267 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_266,
-        x_main_module_35);
-    auto x_main_module_268 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
+    auto x_main_module_418 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_417,
+        x_main_module_37,
+        x_main_module_36,
+        x_main_module_35,
         x_main_module_34);
-    auto x_main_module_269 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_267, x_main_module_268);
-    auto x_main_module_270 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_269);
-    auto x_main_module_271 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
-        x_main_module_270,
+    auto x_main_module_419 =
+        mmain->add_instruction(migraphx::make_op("add"), x_main_module_416, x_main_module_418);
+    auto x_main_module_420 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_419);
+    auto x_main_module_421 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_420,
         x_main_module_33);
-    auto x_main_module_272 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
-        x_main_module_32);
-    auto x_main_module_273 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_271, x_main_module_272);
-    auto x_main_module_274 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_273);
-    auto x_main_module_275 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_274,
-        x_main_module_31);
-    auto x_main_module_276 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,1024,14,14]}")),
-        x_main_module_30);
-    auto x_main_module_277 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_275, x_main_module_276);
-    auto x_main_module_278 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_277, x_main_module_266);
-    auto x_main_module_279 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_278);
-    auto x_main_module_280 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_279,
+    auto x_main_module_422 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_421,
+        x_main_module_32,
+        x_main_module_31,
+        x_main_module_30,
         x_main_module_29);
-    auto x_main_module_281 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
+    auto x_main_module_423 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_422);
+    auto x_main_module_424 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_423,
         x_main_module_28);
-    auto x_main_module_282 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_280, x_main_module_281);
-    auto x_main_module_283 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_282);
-    auto x_main_module_284 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
-        x_main_module_283,
-        x_main_module_27);
-    auto x_main_module_285 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,256,14,14]}")),
-        x_main_module_26);
-    auto x_main_module_286 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_284, x_main_module_285);
-    auto x_main_module_287 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_286);
-    auto x_main_module_288 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_287,
-        x_main_module_25);
-    auto x_main_module_289 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,1024,14,14]}")),
+    auto x_main_module_425 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_424,
+        x_main_module_27,
+        x_main_module_26,
+        x_main_module_25,
         x_main_module_24);
-    auto x_main_module_290 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_288, x_main_module_289);
-    auto x_main_module_291 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_290, x_main_module_279);
-    auto x_main_module_292 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_291);
-    auto x_main_module_293 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_292,
+    auto x_main_module_426 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_425);
+    auto x_main_module_427 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_426,
         x_main_module_23);
-    auto x_main_module_294 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,512,14,14]}")),
-        x_main_module_22);
-    auto x_main_module_295 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_293, x_main_module_294);
-    auto x_main_module_296 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_295);
-    auto x_main_module_297 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[2,2]}")),
-        x_main_module_296,
-        x_main_module_21);
-    auto x_main_module_298 = mmain->add_instruction(
-        migraphx::make_op("broadcast", migraphx::from_json_string("{axis:1,out_lens:[1,512,7,7]}")),
-        x_main_module_20);
-    auto x_main_module_299 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_297, x_main_module_298);
-    auto x_main_module_300 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_299);
-    auto x_main_module_301 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_300,
+    auto x_main_module_428 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_427,
+        x_main_module_22,
+        x_main_module_21,
+        x_main_module_20,
         x_main_module_19);
-    auto x_main_module_302 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,2048,7,7]}")),
+    auto x_main_module_429 =
+        mmain->add_instruction(migraphx::make_op("add"), x_main_module_428, x_main_module_420);
+    auto x_main_module_430 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_429);
+    auto x_main_module_431 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_430,
         x_main_module_18);
-    auto x_main_module_303 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_301, x_main_module_302);
-    auto x_main_module_304 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[2,2]}")),
-        x_main_module_292,
-        x_main_module_17);
-    auto x_main_module_305 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,2048,7,7]}")),
-        x_main_module_16);
-    auto x_main_module_306 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_304, x_main_module_305);
-    auto x_main_module_307 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_303, x_main_module_306);
-    auto x_main_module_308 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_307);
-    auto x_main_module_309 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_308,
-        x_main_module_15);
-    auto x_main_module_310 = mmain->add_instruction(
-        migraphx::make_op("broadcast", migraphx::from_json_string("{axis:1,out_lens:[1,512,7,7]}")),
+    auto x_main_module_432 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_431,
+        x_main_module_17,
+        x_main_module_16,
+        x_main_module_15,
         x_main_module_14);
-    auto x_main_module_311 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_309, x_main_module_310);
-    auto x_main_module_312 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_311);
-    auto x_main_module_313 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
-        x_main_module_312,
+    auto x_main_module_433 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_432);
+    auto x_main_module_434 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_433,
         x_main_module_13);
-    auto x_main_module_314 = mmain->add_instruction(
-        migraphx::make_op("broadcast", migraphx::from_json_string("{axis:1,out_lens:[1,512,7,7]}")),
-        x_main_module_12);
-    auto x_main_module_315 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_313, x_main_module_314);
-    auto x_main_module_316 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_315);
-    auto x_main_module_317 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_316,
-        x_main_module_11);
-    auto x_main_module_318 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,2048,7,7]}")),
-        x_main_module_10);
-    auto x_main_module_319 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_317, x_main_module_318);
-    auto x_main_module_320 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_319, x_main_module_308);
-    auto x_main_module_321 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_320);
-    auto x_main_module_322 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_321,
+    auto x_main_module_435 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_434,
+        x_main_module_12,
+        x_main_module_11,
+        x_main_module_10,
         x_main_module_9);
-    auto x_main_module_323 = mmain->add_instruction(
-        migraphx::make_op("broadcast", migraphx::from_json_string("{axis:1,out_lens:[1,512,7,7]}")),
+    auto x_main_module_436 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_435);
+    auto x_main_module_437 = mmain->add_instruction(
+        migraphx::make_json_op("convolution",
+                               "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,"
+                               "1],use_dynamic_same_auto_pad:0}"),
+        x_main_module_436,
         x_main_module_8);
-    auto x_main_module_324 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_322, x_main_module_323);
-    auto x_main_module_325 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_324);
-    auto x_main_module_326 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[1,1,1,1],padding_mode:0,stride:[1,1]}")),
-        x_main_module_325,
-        x_main_module_7);
-    auto x_main_module_327 = mmain->add_instruction(
-        migraphx::make_op("broadcast", migraphx::from_json_string("{axis:1,out_lens:[1,512,7,7]}")),
-        x_main_module_6);
-    auto x_main_module_328 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_326, x_main_module_327);
-    auto x_main_module_329 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_328);
-    auto x_main_module_330 = mmain->add_instruction(
-        migraphx::make_op(
-            "convolution",
-            migraphx::from_json_string(
-                "{dilation:[1,1],group:1,padding:[0,0,0,0],padding_mode:0,stride:[1,1]}")),
-        x_main_module_329,
-        x_main_module_5);
-    auto x_main_module_331 = mmain->add_instruction(
-        migraphx::make_op("broadcast",
-                          migraphx::from_json_string("{axis:1,out_lens:[1,2048,7,7]}")),
+    auto x_main_module_438 = mmain->add_instruction(
+        migraphx::make_json_op(
+            "batch_norm_inference",
+            "{bn_mode:1,epsilon:9.999999747378752e-06,momentum:0.8999999761581421}"),
+        x_main_module_437,
+        x_main_module_7,
+        x_main_module_6,
+        x_main_module_5,
         x_main_module_4);
-    auto x_main_module_332 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_330, x_main_module_331);
-    auto x_main_module_333 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_332, x_main_module_321);
-    auto x_main_module_334 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_333);
-    auto x_main_module_335 = mmain->add_instruction(
-        migraphx::make_op(
+    auto x_main_module_439 =
+        mmain->add_instruction(migraphx::make_op("add"), x_main_module_438, x_main_module_430);
+    auto x_main_module_440 = mmain->add_instruction(migraphx::make_op("relu"), x_main_module_439);
+    auto x_main_module_441 = mmain->add_instruction(
+        migraphx::make_json_op(
             "pooling",
-            migraphx::from_json_string(
-                "{ceil_mode:0,lengths:[7,7],lp_order:2,mode:0,padding:[0,0,0,0],stride:[1,1]}")),
-        x_main_module_334);
-    auto x_main_module_336 = mmain->add_instruction(
-        migraphx::make_op("reshape", migraphx::from_json_string("{dims:[1,-1]}")),
-        x_main_module_335);
-    auto x_main_module_337 = mmain->add_instruction(
-        migraphx::make_op("transpose", migraphx::from_json_string("{permutation:[1,0]}")),
-        x_main_module_2);
-    auto x_main_module_338 =
-        mmain->add_instruction(migraphx::make_op("dot"), x_main_module_336, x_main_module_337);
-    auto x_main_module_339 = mmain->add_instruction(
-        migraphx::make_op("multibroadcast", migraphx::from_json_string("{out_lens:[1,1000]}")),
-        x_main_module_3);
-    auto x_main_module_340 = mmain->add_instruction(
-        migraphx::make_op("multibroadcast", migraphx::from_json_string("{out_lens:[1,1000]}")),
-        x_main_module_0);
-    auto x_main_module_341 =
-        mmain->add_instruction(migraphx::make_op("mul"), x_main_module_339, x_main_module_340);
-    auto x_main_module_342 =
-        mmain->add_instruction(migraphx::make_op("add"), x_main_module_338, x_main_module_341);
-    mmain->add_return({x_main_module_342});
+            "{ceil_mode:0,lengths:[7,7],lp_order:2,mode:0,padding:[0,0,0,0],stride:[1,1]}"),
+        x_main_module_440);
+    auto x_main_module_442 =
+        mmain->add_instruction(migraphx::make_json_op("flatten", "{axis:1}"), x_main_module_441);
+    auto x_main_module_443 = mmain->add_instruction(
+        migraphx::make_json_op("transpose", "{permutation:[1,0]}"), x_main_module_3);
+    auto x_main_module_444 =
+        mmain->add_instruction(migraphx::make_op("dot"), x_main_module_442, x_main_module_443);
+    auto x_main_module_445 = mmain->add_instruction(
+        migraphx::make_json_op("multibroadcast", "{out_lens:[1,1000]}"), x_main_module_2);
+    auto x_main_module_446 = mmain->add_instruction(
+        migraphx::make_json_op("multibroadcast", "{out_lens:[1,1000]}"), x_main_module_0);
+    auto x_main_module_447 =
+        mmain->add_instruction(migraphx::make_op("mul"), x_main_module_445, x_main_module_446);
+    auto x_main_module_448 =
+        mmain->add_instruction(migraphx::make_op("add"), x_main_module_444, x_main_module_447);
+    mmain->add_return({x_main_module_448});
 
     return p;
 }

src/include/migraphx/make_op.hpp

@@ -27,6 +27,8 @@
 #include <migraphx/config.hpp>
 #include <migraphx/operation.hpp>
 #include <migraphx/value.hpp>
+#include <migraphx/json.hpp>
+#include <migraphx/convert_to_json.hpp>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
@@ -46,6 +48,8 @@ operation make_op(const std::string& name, const Value& v)
     return make_op_from_value(name, v);
 }
 
+operation make_json_op(const std::string& name, const std::string& s);
+
 } // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 

src/target_assignments.cpp → src/include/migraphx/supported_segments.hpp

@@ -21,16 +21,24 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
+#ifndef MIGRAPHX_GUARD_MIGRAPHX_SUPPORTED_SEGMENTS_HPP
+#define MIGRAPHX_GUARD_MIGRAPHX_SUPPORTED_SEGMENTS_HPP
 
-#include <migraphx/target_assignments.hpp>
+#include <unordered_set>
+
+#include <migraphx/instruction_ref.hpp>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
 
-void target_assignments::add_assignment(instruction_ref ins, const std::string& target)
+struct supported_segment
 {
-    assignments.emplace(ins, target);
-}
+    std::unordered_set<instruction_ref> instructions;
+    float metric;
+};
+
+using supported_segments = std::vector<supported_segment>;
 
 } // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
+#endif // MIGRAPHX_GUARD_MIGRAPHX_SUPPORTED_SEGMENTS_HPP

src/include/migraphx/target.hpp

@@ -37,8 +37,10 @@
 #include <migraphx/compile_options.hpp>
 #include <migraphx/argument.hpp>
 #include <migraphx/rank.hpp>
+#include <migraphx/module_ref.hpp>
 #include <migraphx/support_metric.hpp>
 #include <migraphx/instruction_ref.hpp>
+#include <migraphx/supported_segments.hpp>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
@@ -64,12 +66,12 @@ struct target
      */
     context get_context() const;
     /**
-     * @brief Check how well an instruction is supported on a target with the given metric
-     * @param ins Instruction to check if it's supported
-     * @param metric Used to define how the return value should be interpreted
-     * @return The value based on the chosen metric. Negative numbers mean unsupported
+     * @brief Get the ranges of instructions that are supported on a target
+     * @param module Module to check for supported instructions
+     * @param metric Used to define how the quality of the support should be measured
+     * @return the supported segments of the graph
      */
-    float is_supported(T&, instruction_ref ins, support_metric m) const;
+    supported_segments target_is_supported(T&, const_module_ref mod, support_metric metric) const;
     /**
      * @brief copy an argument to the current target.
      *
@@ -115,9 +117,9 @@ argument copy_from_target(T&, const argument& arg)
 }
 
 template <class T>
-float target_is_supported(T&, instruction_ref, support_metric)
+supported_segments target_find_supported(T&, const_module_ref, support_metric)
 {
-    return 0;
+    return {};
 }
 
 #ifdef TYPE_ERASED_DECLARATION
@@ -132,7 +134,7 @@ struct target
     //
     context get_context() const;
     // (optional)
-    float is_supported(instruction_ref ins, support_metric m) const;
+    supported_segments find_supported(const_module_ref mod, support_metric m) const;
     // (optional)
     argument copy_to(const argument& input) const;
     // (optional)
@@ -224,10 +226,10 @@ struct target
         return (*this).private_detail_te_get_handle().get_context();
     }
 
-    float is_supported(instruction_ref ins, support_metric m) const
+    supported_segments find_supported(const_module_ref mod, support_metric m) const
     {
         assert((*this).private_detail_te_handle_mem_var);
-        return (*this).private_detail_te_get_handle().is_supported(ins, m);
+        return (*this).private_detail_te_get_handle().find_supported(mod, m);
     }
 
     argument copy_to(const argument& input) const
@@ -265,29 +267,29 @@ struct target
         virtual std::vector<pass> get_passes(context& ctx,
                                              const compile_options& options) const              = 0;
         virtual context get_context() const                                                     = 0;
-        virtual float is_supported(instruction_ref ins, support_metric m) const    = 0;
+        virtual supported_segments find_supported(const_module_ref mod, support_metric m) const = 0;
         virtual argument copy_to(const argument& input) const                                   = 0;
         virtual argument copy_from(const argument& input) const                                 = 0;
         virtual argument allocate(const shape& s) const                                         = 0;
     };
 
     template <class T>
-    static auto private_detail_te_default_is_supported(char,
+    static auto private_detail_te_default_find_supported(char,
                                                          T&& private_detail_te_self,
-                                                       instruction_ref ins,
+                                                         const_module_ref mod,
                                                          support_metric m)
-        -> decltype(private_detail_te_self.is_supported(ins, m))
+        -> decltype(private_detail_te_self.find_supported(mod, m))
     {
-        return private_detail_te_self.is_supported(ins, m);
+        return private_detail_te_self.find_supported(mod, m);
     }
 
     template <class T>
-    static float private_detail_te_default_is_supported(float,
+    static supported_segments private_detail_te_default_find_supported(float,
                                                                        T&& private_detail_te_self,
-                                                        instruction_ref ins,
+                                                                       const_module_ref mod,
                                                                        support_metric m)
     {
-        return target_is_supported(private_detail_te_self, ins, m);
+        return target_find_supported(private_detail_te_self, mod, m);
     }
 
     template <class T>
@@ -372,10 +374,11 @@ struct target
 
         context get_context() const override { return private_detail_te_value.get_context(); }
 
-        float is_supported(instruction_ref ins, support_metric m) const override
+        supported_segments find_supported(const_module_ref mod, support_metric m) const override
         {
 
-            return private_detail_te_default_is_supported(char(0), private_detail_te_value, ins, m);
+            return private_detail_te_default_find_supported(
+                char(0), private_detail_te_value, mod, m);
         }
 
         argument copy_to(const argument& input) const override

src/include/migraphx/target_assignments.hpp

@@ -33,10 +33,20 @@ inline namespace MIGRAPHX_INLINE_NS {
 
 struct target_assignments
 {
-    void add_assignment(instruction_ref ins, const std::string& target);
+    using iterator   = std::unordered_map<instruction_ref, std::string>::const_iterator;
+    using value_type = std::pair<instruction_ref, std::string>;
 
-    auto begin() const { return assignments.cbegin(); }
-    auto end() const { return assignments.cend(); }
+    auto size() const { return assignments.size(); }
+    auto& at(instruction_ref ins) const { return assignments.at(ins); }
+
+    auto insert(iterator it, const std::pair<instruction_ref, std::string>& assignment)
+    {
+        return assignments.insert(it, assignment);
+    }
+    auto find(instruction_ref ins) const { return assignments.find(ins); }
+
+    auto begin() const { return assignments.begin(); }
+    auto end() const { return assignments.end(); }
 
     private:
     std::unordered_map<instruction_ref, std::string> assignments;

src/make_op.cpp

@@ -64,5 +64,10 @@ operation make_op_from_value(const std::string& name, const value& v)
     });
 }
 
+operation make_json_op(const std::string& name, const std::string& s)
+{
+    return make_op(name, from_json_string(convert_to_json(s)));
+}
+
 } // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx

src/module.cpp

@@ -788,12 +788,15 @@ static std::string cpp_var_name(const std::string& name)
 
 static void print_make_op(std::ostream& os, const operation& op)
 {
-    os << "migraphx::make_op(" << enclose_name(op.name());
     auto v = op.to_value();
     if(not v.empty())
     {
-        os << ", "
-           << "migraphx::from_json_string(" << enclose_name(to_json_string(v)) << ")";
+        os << "migraphx::make_json_op(" << enclose_name(op.name());
+        os << ", " << enclose_name(to_json_string(v));
+    }
+    else
+    {
+        os << "migraphx::make_op(" << enclose_name(op.name());
     }
     os << ")";
 }

src/program.cpp

@@ -37,6 +37,7 @@
 #include <migraphx/output_iterator.hpp>
 #include <migraphx/make_op.hpp>
 #include <migraphx/marker.hpp>
+#include <migraphx/supported_segments.hpp>
 #include <iostream>
 #include <sstream>
 #include <algorithm>
@@ -167,13 +168,37 @@ target_assignments program::get_target_assignments(const std::vector<target>& ta
     target_assignments p;
 
     const auto* mod = get_main_module();
-    for(auto it : iterator_for(*mod))
+    std::vector<std::pair<target, supported_segments>> target_subgraphs;
+    target_subgraphs.reserve(targets.size());
+    std::transform(targets.begin(),
+                   targets.end(),
+                   std::back_inserter(target_subgraphs),
+                   [&](const auto& t) { return std::make_pair(t, t.find_supported(mod, m)); });
+
+    for(const auto ins : iterator_for(*mod))
     {
-        auto t = std::max_element(
-            targets.begin(), targets.end(), [it, m](const target& lhs, const target& rhs) {
-                return lhs.is_supported(it, m) < rhs.is_supported(it, m);
-            });
-        p.add_assignment(it, t->name());
+        if(contains(p, ins))
+        {
+            continue;
+        }
+
+        for(const auto& [target, subgraph] : target_subgraphs)
+        {
+            // can't pass a structured binding into lambda in C++17 so create a variable for it
+            const auto& t = target;
+            for(const auto& segment : subgraph)
+            {
+                const auto& instructions = segment.instructions;
+                if(not contains(instructions, ins))
+                {
+                    continue;
+                }
+                std::transform(instructions.begin(),
+                               instructions.end(),
+                               std::inserter(p, p.end()),
+                               [&](auto instr) { return std::make_pair(instr, t.name()); });
+            }
+        }
     }
     return p;
 }

src/py/migraphx_py.cpp

@@ -40,6 +40,7 @@
 #include <migraphx/register_target.hpp>
 #include <migraphx/json.hpp>
 #include <migraphx/make_op.hpp>
+#include <migraphx/op/common.hpp>
 
 #ifdef HAVE_GPU
 #include <migraphx/gpu/hip.hpp>
@@ -82,7 +83,7 @@ void visit_py(T x, F f)
     {
         f(x.template cast<bool>());
     }
-    else if(py::isinstance<py::int_>(x))
+    else if(py::isinstance<py::int_>(x) || py::hasattr(x, "__index__"))
     {
         f(x.template cast<int>());
     }
@@ -324,6 +325,7 @@ MIGRAPHX_PYBIND11_MODULE(migraphx, m)
         .def("get_parameter_names", &migraphx::program::get_parameter_names)
         .def("get_parameter_shapes", &migraphx::program::get_parameter_shapes)
         .def("get_output_shapes", &migraphx::program::get_output_shapes)
+        .def("is_compiled", &migraphx::program::is_compiled)
         .def(
             "compile",
             [](migraphx::program& p, const migraphx::target& t, bool offload_copy, bool fast_math) {
@@ -358,8 +360,8 @@ MIGRAPHX_PYBIND11_MODULE(migraphx, m)
         .def("__ne__", std::not_equal_to<migraphx::program>{})
         .def("__repr__", [](const migraphx::program& p) { return migraphx::to_string(p); });
 
-    py::class_<migraphx::operation>(m, "op")
-        .def(py::init([](const std::string& name, py::kwargs kwargs) {
+    py::class_<migraphx::operation> op(m, "op");
+    op.def(py::init([](const std::string& name, py::kwargs kwargs) {
           migraphx::value v = migraphx::value::object{};
           if(kwargs)
           {
@@ -367,9 +369,26 @@ MIGRAPHX_PYBIND11_MODULE(migraphx, m)
           }
           return migraphx::make_op(name, v);
       }))
-
         .def("name", &migraphx::operation::name);
 
+    py::enum_<migraphx::op::pooling_mode>(op, "pooling_mode")
+        .value("average", migraphx::op::pooling_mode::average)
+        .value("max", migraphx::op::pooling_mode::max)
+        .value("lpnorm", migraphx::op::pooling_mode::lpnorm);
+
+    py::enum_<migraphx::op::rnn_direction>(op, "rnn_direction")
+        .value("forward", migraphx::op::rnn_direction::forward)
+        .value("reverse", migraphx::op::rnn_direction::reverse)
+        .value("bidirectional", migraphx::op::rnn_direction::bidirectional);
+
+    m.def(
+        "argument_from_pointer",
+        [](const migraphx::shape shape, const int64_t address) {
+            return migraphx::argument(shape, reinterpret_cast<void*>(address));
+        },
+        py::arg("shape"),
+        py::arg("address"));
+
     m.def(
         "parse_tf",
         [](const std::string& filename,

src/simplify_reshapes.cpp

@@ -151,8 +151,11 @@ struct find_transpose
 {
     auto matcher() const
     {
-        return match::name("transpose")(match::none_of(
-            match::skip_output(match::name("contiguous"))(match::name("transpose"))));
+        auto output_not_transpose =
+            match::none_of(match::skip_output(match::name("contiguous"))(match::name("transpose")));
+        auto input_has_transpose =
+            match::args(match::skip(match::name("contiguous"))(match::name("transpose")));
+        return match::name("transpose")(output_not_transpose, input_has_transpose);
     }
 
     void apply(module& m, const match::matcher_result& mr) const
@@ -664,9 +667,94 @@ struct find_slice_transpose
     }
 };
 
+struct find_transpose_slice
+{
+    auto matcher() const
+    {
+        return match::name("transpose")(match::all_of[match::outputs()](match::name("slice")));
+    }
+
+    static std::vector<int64_t> slice_distance(const op::slice& op)
+    {
+        assert(op.starts.size() == op.ends.size());
+        std::vector<int64_t> result(op.starts.size());
+        std::transform(
+            op.ends.begin(), op.ends.end(), op.starts.begin(), result.begin(), std::minus<>{});
+        return result;
+    }
+
+    void apply(module& m, const match::matcher_result& r) const
+    {
+        auto ins    = r.result;
+        auto slices = ins->outputs();
+        if(slices.empty())
+            return;
+        auto slice     = any_cast<op::slice>(slices.front()->get_operator());
+        auto sdistance = slice_distance(slice);
+        // Check all distances and axes are the same
+        if(std::any_of(slices.begin(), slices.end(), [&](auto sins) {
+               auto s = any_cast<op::slice>(sins->get_operator());
+               return s.axes != slice.axes or slice_distance(s) != sdistance;
+           }))
+            return;
+        // Check distances are divisible by lens of corresponding axes
+        auto mod_by_distance = [&](const auto& v, auto f) {
+            return std::inner_product(v.begin(),
+                                      v.end(),
+                                      sdistance.begin(),
+                                      0,
+                                      std::plus<>{},
+                                      [&](auto x, auto d) -> uint64_t {
+                                          if(d == 0)
+                                              return 1;
+                                          return f(x) % d;
+                                      });
+        };
+        if(mod_by_distance(slice.axes, [&](auto x) { return ins->get_shape().lens()[x]; }) != 0 or
+           mod_by_distance(slice.starts, id{}) != 0 or mod_by_distance(slice.ends, id{}) != 0)
+            return;
+        // TODO: Handle multiple axes
+        if(sdistance.size() != 1)
+            return;
+        auto axis = slice.axes.front();
+        // Skip if axis would be packed
+        if(std::all_of(ins->get_shape().lens().begin(),
+                       ins->get_shape().lens().begin() + axis,
+                       [](auto x) { return x == 1; }))
+            return;
+        // Compute axis before transpose to use for unsqueeze
+        auto perm    = ins->get_operator().to_value()["permutation"].to_vector<int64_t>();
+        auto preaxis = std::find(perm.begin(), perm.end(), axis) - perm.begin();
+        // Make unsqeeze
+        auto unsqueeze = m.insert_instruction(
+            ins, make_op("unsqueeze", {{"axes", {preaxis}}, {"steps", sdistance}}), ins->inputs());
+        // Make transpose
+        std::transform(perm.begin(), perm.end(), perm.begin(), [&](auto i) {
+            if(i > preaxis)
+                return i + 1;
+            return i;
+        });
+        perm.insert(perm.begin(), preaxis + 1);
+        auto transpose =
+            m.insert_instruction(ins, make_op("transpose", {{"permutation", perm}}), unsqueeze);
+        // Slice and squeeze
+        for(auto s : slices)
+        {
+            auto op        = any_cast<op::slice>(s->get_operator());
+            op.axes        = {0};
+            op.starts      = {op.starts.front() / sdistance.front()};
+            op.ends        = {op.ends.front() / sdistance.front()};
+            auto slice_ins = m.insert_instruction(ins, op, transpose);
+            auto squeeze =
+                m.insert_instruction(ins, make_op("squeeze", {{"axes", {0}}}), slice_ins);
+            m.replace_instruction(s, squeeze);
+        }
+    }
+};
+
 void simplify_reshapes::apply(module& m) const
 {
-    for(int i = 0; i < 2; i++)
+    for(int i = 0; i < 4; i++)
     {
         match::find_matches(m,
                             find_where_op{},
@@ -679,6 +767,7 @@ void simplify_reshapes::apply(module& m) const
                             find_nested_convert{},
                             find_nested_slice{},
                             find_nested_concat{},
+                            find_transpose_slice{},
                             find_slice_transpose{},
                             find_transpose_contiguous_reshaper_unary{});
         dead_code_elimination{}.apply(m);

src/targets/fpga/include/migraphx/fpga/target.hpp

@@ -30,6 +30,7 @@
 #include <migraphx/compile_options.hpp>
 #include <migraphx/fpga/context.hpp>
 #include <migraphx/config.hpp>
+#include <migraphx/supported_segments.hpp>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
@@ -41,7 +42,7 @@ struct target
     std::string name() const;
     std::vector<pass> get_passes(migraphx::context& ctx, const compile_options&) const;
     migraphx::context get_context() const { return context{}; }
-    float is_supported(instruction_ref ins, support_metric m);
+    supported_segments find_supported(const_module_ref mod, support_metric m) const;
 
     argument copy_to(const argument& arg) const { return arg; }
     argument copy_from(const argument& arg) const { return arg; }

src/targets/fpga/target.cpp

@@ -34,6 +34,7 @@
 #include <migraphx/dead_code_elimination.hpp>
 #include <migraphx/generate.hpp>
 #include <migraphx/normalize_ops.hpp>
+#include <migraphx/iterator_for.hpp>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
@@ -62,12 +63,17 @@ std::vector<pass> target::get_passes(migraphx::context& gctx, const compile_opti
 
 argument target::allocate(const shape& s) const { return fill_argument(s, 0); }
 
-float is_supported(instruction_ref ins, support_metric m)
+supported_segments target::find_supported(const_module_ref mod, support_metric m) const
 {
-    // for now, not using the ins and metric to return a value
-    (void)ins;
     (void)m;
-    return 1.0;
+
+    supported_segment instrs;
+    for(const auto ins : iterator_for(*mod))
+    {
+        instrs.instructions.insert(ins);
+    }
+    instrs.metric = 1; // arbitrary value
+    return {instrs};
 }
 
 MIGRAPHX_REGISTER_TARGET(target);

src/targets/gpu/compile_gen.cpp

@@ -25,6 +25,13 @@
 #include <migraphx/shape.hpp>
 #include <migraphx/permutation.hpp>
 #include <migraphx/stringutils.hpp>
+#include <migraphx/module.hpp>
+#include <migraphx/dead_code_elimination.hpp>
+#include <migraphx/eliminate_common_subexpression.hpp>
+#include <migraphx/cpp_generator.hpp>
+#include <migraphx/pass_manager.hpp>
+#include <migraphx/instruction.hpp>
+#include <migraphx/ranges.hpp>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
@@ -75,25 +82,25 @@ std::string vectorize::str() const
 preload preload::broadcasts(std::size_t axis, const std::vector<shape>& inputs)
 {
     const std::size_t max_lds_bytes = 4096;
-    std::vector<bool> result;
-    std::transform(inputs.begin(),
-                   inputs.end(),
-                   std::back_inserter(result),
-                   [&](const shape& input) { return input.strides()[axis] == 0; });
-    auto bytes = std::inner_product(inputs.begin(),
-                                    inputs.end(),
-                                    result.begin(),
-                                    std::size_t{0},
-                                    std::plus<>{},
-                                    [](const shape& s, bool b) -> std::size_t {
-                                        if(b)
-                                            return s.bytes();
-                                        return 0;
+    std::vector<bool> result(inputs.size());
+    std::vector<std::size_t> preloaded;
+    auto idxs = range(inputs.size());
+    std::copy_if(idxs.begin(), idxs.end(), std::back_inserter(preloaded), [&](auto i) {
+        return inputs[i].strides()[axis] == 0;
     });
-    if(bytes < max_lds_bytes)
-        return {result};
-    // TODO: Try to partially preload items
-    std::fill(result.begin(), result.end(), false);
+    std::sort(preloaded.begin(), preloaded.end(), by(std::less<>{}, [&](auto i) {
+                  return inputs[i].bytes();
+              }));
+
+    std::size_t bytes = 0;
+    for(auto i : preloaded)
+    {
+        auto input = inputs[i];
+        bytes += input.bytes();
+        if(bytes > max_lds_bytes)
+            break;
+        result[i] = true;
+    }
     return {result};
 }
 
@@ -125,6 +132,45 @@ std::string make_transformer_args(std::vector<std::string> transformers)
     return join_strings(std::move(transformers), ", ");
 }
 
+std::string generate_pointwise(const module& pm, const std::string& name)
+{
+    module m = pm;
+    run_passes(m, {eliminate_common_subexpression{}, dead_code_elimination{}});
+    cpp_generator g;
+    g.fmap([](const std::string& fname) { return "migraphx::" + fname; });
+    g.add_point_op("where", "${function:where}(${0}, ${1}, ${2})");
+    g.add_point_op("prelu", "${function:where}(${0} < 0, ${0} * ${1}, ${0})");
+    g.add_point_op("sign", "${function:where}(${0} > 0, 1, ${function:where}(${0} < 0, -1, 0))");
+    g.add_point_op("equal", "migraphx::abs(${0} == ${1})");
+    g.add_point_op("less", "migraphx::abs(${0} < ${1})");
+    g.add_point_op("greater", "migraphx::abs(${0} > ${1})");
+    g.add_point_op("not", "migraphx::abs(not ${0})");
+    // Add explict conversions
+    g.fresult(
+        [](const shape& s) { return "migraphx::convert<" + shape::cpp_type(s.type()) + ">"; });
+    g.create_function(
+        g.generate_module(m).set_attributes({"__device__"}).set_generic_types(m).set_name(name));
+    return g.str();
+}
+
+static std::vector<std::string> get_op_names(const module& m)
+{
+    std::vector<std::string> result;
+    for(auto& ins : m)
+    {
+        if(starts_with(ins.name(), "@"))
+            continue;
+        result.push_back(ins.name());
+    }
+    return result;
+}
+
+std::string generate_name_from_ops(const module& m)
+{
+    auto op_names = get_op_names(m);
+    return join_strings(op_names, "_");
+}
+
 } // namespace gen
 } // namespace gpu
 } // namespace MIGRAPHX_INLINE_NS

src/targets/gpu/fuse_ops.cpp

@@ -827,13 +827,14 @@ void apply_conv_bias(context& ctx, module& m, const match::matcher_result& r)
     m.replace_instruction(ins, cb, input_ins, weights_ins, old_ws_ins, bias_ins, alloc_ins);
 }
 
-inline auto precompile_name(std::string s) // NOLINT
+template <class... Strings>
+inline auto precompile_name(Strings... names) // NOLINT
 {
     return match::make_basic_pred_matcher([=](instruction_ref ins) {
         if(ins->name() != "gpu::precompile_op")
             return false;
         auto op = from_value<operation>(ins->get_operator().to_value().at("op"));
-        return (op.name() == s);
+        return (contains({names...}, op.name()));
     });
 }
 
@@ -1041,6 +1042,31 @@ struct find_contiguous_pointwise
     }
 };
 
+struct find_layernorm_pointwise
+{
+    auto matcher() const
+    {
+        return precompile_name("pointwise")(match::arg(0)(
+            precompile_name("gpu::prelayernorm", "gpu::preadd_layernorm").bind("layernorm")));
+    }
+
+    void apply(module& m, const match::matcher_result& r) const
+    {
+        auto ins       = r.result;
+        auto layernorm = r.instructions["layernorm"];
+        auto* pm       = ins->module_inputs().front();
+
+        if(not layernorm->module_inputs().empty())
+            return;
+
+        auto inputs = layernorm->inputs();
+        inputs.pop_back();
+        inputs.insert(inputs.end(), ins->inputs().begin() + 1, ins->inputs().end());
+
+        m.replace_instruction(ins, layernorm->get_operator(), inputs, {pm});
+    }
+};
+
 void fuse_ops::apply(module& m) const
 {
     match::find_matches(m, find_contiguous_pointwise{}, find_gelu{}, find_gelu_new{fast_math});
@@ -1063,6 +1089,7 @@ void fuse_ops::apply(module& m) const
     match::find_matches(m,
                         find_triadd_layernorm{},
                         find_gemm_add{},
+                        find_layernorm_pointwise{},
                         find_gemm_pointwise{},
                         find_commutative_broadcast{});
     match::find_matches(m, find_contiguous{});

src/targets/gpu/include/migraphx/gpu/compile_gen.hpp

@@ -25,6 +25,7 @@
 #define MIGRAPHX_GUARD_GPU_COMPILE_GEN_HPP
 
 #include <migraphx/config.hpp>
+#include <migraphx/module_ref.hpp>
 #include <string>
 #include <unordered_map>
 #include <vector>
@@ -62,6 +63,10 @@ std::string make_transformer_args(Ts... xs)
     return make_transformer_args({xs.str()...});
 }
 
+std::string generate_pointwise(const module& pm, const std::string& name);
+
+std::string generate_name_from_ops(const module& m);
+
 } // namespace gen
 } // namespace gpu
 } // namespace MIGRAPHX_INLINE_NS