LogicalResult matchAndRewrite(ConstOp const_op,
                                PatternRewriter& rewriter) const override {
    if (arith::ConstantOp::isBuildableWith(const_op.getValue(),
                                           const_op.getType())) {
      rewriter.replaceOpWithNewOp<arith::ConstantOp>(const_op,
                                                     const_op.getValue());
      return success();

        return failure();

      OpBuilder builder(op);
      auto const_op = builder.create<TF::ConstOp>(
          op->getLoc(), DenseIntElementsAttr::get(
                            RankedTensorType::get({}, builder.getI64Type()),
                            {device_ordinal}));
      op->replaceAllUsesWith(const_op);
      op->erase();
      return WalkResult::advance();
    }

  name: "bn_conv1_1/FusedBatchNorm"
  op: "FusedBatchNorm"
  input: "conv1_1/Conv2D"
  input: "bn_conv1_1/ReadVariableOp"
  input: "bn_conv1_1/ReadVariableOp_1"
  input: "bn5a_branch1_1/Const_1"
  input: "bn5a_branch1_1/Const_1"
  device: "/job:localhost/replica:0/task:0/device:GPU:0"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "data_format"

#include "tensorflow/compiler/jit/clone_constants_for_better_clustering.h"

#include "tensorflow/cc/framework/ops.h"
#include "tensorflow/cc/ops/array_ops.h"
#include "tensorflow/cc/ops/const_op.h"
#include "tensorflow/cc/ops/math_ops.h"
#include "tensorflow/compiler/jit/node_matchers.h"
#include "tensorflow/core/lib/core/status_test_util.h"
#include "tensorflow/core/platform/test.h"

namespace tensorflow {
namespace fuzzing {

)namespace";

  const string fuzz_header = strings::StrCat(
      R"include(// This file is MACHINE GENERATED! Do not edit.

#include "tensorflow/cc/ops/const_op.h"
#include "tensorflow/cc/ops/standard_ops.h"
#include "tensorflow/security/fuzzing/cc/fuzz_session.h"
#include "third_party/mediapipe/framework/port/parse_text_proto.h"
)include",
      fuzz_namespace_begin);

          squeeze_op, "result for current op has more than 1 use");
    }
    // Make sure that the axis in `expand_op` is constant.
    if (auto const_op =
            llvm::dyn_cast<TF::ConstOp>(expand_op.getDim().getDefiningOp())) {
      expand_axis = (*mlir::cast<DenseElementsAttr>(const_op.getValue())
                          .getValues<APInt>()
                          .begin())
                        .getSExtValue();

import org.gradle.kotlin.dsl.support.bytecode.CHECKCAST
import org.gradle.kotlin.dsl.support.bytecode.DUP
import org.gradle.kotlin.dsl.support.bytecode.GETSTATIC
import org.gradle.kotlin.dsl.support.bytecode.ICONST_0
import org.gradle.kotlin.dsl.support.bytecode.INVOKEINTERFACE
import org.gradle.kotlin.dsl.support.bytecode.INVOKESPECIAL
import org.gradle.kotlin.dsl.support.bytecode.INVOKESTATIC

  name: "bn_conv1_1/FusedBatchNormV2"
  op: "FusedBatchNormV2"
  input: "conv1_1/Conv2D"
  input: "bn_conv1_1/ReadVariableOp"
  input: "bn_conv1_1/ReadVariableOp_1"
  input: "bn5a_branch1_1/Const_1"
  input: "bn5a_branch1_1/Const_1"
  device: "/job:localhost/replica:0/task:0/device:GPU:0"
  attr {
    key: "T"
    value {
      type: DT_HALF
    }
  }
  attr {
    key: "U"

  // CHECK-NEXT: %[[CAST_ZERO:.*]] = "tf.Cast"(%[[ZERO_SCALAR]]) : (tensor<i32>) -> tensor<f32>
  // CHECK-NEXT: %[[CONST10:.*]] = "tf.Const"() <{value = dense<10> : tensor<1xi32>}> : () -> tensor<1xi32>
  // CHECK-NEXT: %[[BROADCAST:.*]] = "tf.BroadcastTo"(%[[CAST_ZERO]], %[[CONST10]]) : (tensor<f32>, tensor<1xi32>) -> tensor<10xf32>
  // CHECK-NEXT: %[[ZERO:.*]] = "tf.Const"() <{value = dense<0> : tensor<1xi32>}> : () -> tensor<1xi32>

	// Must match runtime/mwbbuf.go:wbMaxEntriesPerCall.
	// It must also match the number of instances of runtime.gcWriteBarrier{X}.
	const maxEntries = 8

	var sb, sp, wbaddr, const0 *Value
	var cgoCheckPtrWrite, cgoCheckMemmove *obj.LSym
	var wbZero, wbMove *obj.LSym
	var stores, after []*Value
	var sset, sset2 *sparseSet
	var storeNumber []int32