auto orig_const_output = Const(scope, val);
  if (!scope.ok()) return Output();

  typedef typename Input::Initializer::RealType<T>::type DstT;

  if (val.tensor.dtype() == DataTypeToEnum<DstT>::v()) {
    return orig_const_output;
  }
  if (val.tensor.NumElements() == 0) {
    Tensor t(DataTypeToEnum<DstT>::v(), val.tensor.shape());
    return Const(scope, Input::Initializer(t));
  }

           "Const",
           {},
           {{"value", test::AsScalar<int32>(2)}, {"dtype", DT_INT64}}},
          {{"scale"},
           "Cast",
           {"two"},
           {{"SrcT", DT_INT64}, {"DstT", DT_FLOAT}}},
          {{"y"}, "Mul", {"x", "scale"}, {{"T", DT_FLOAT}}},
      });

  tensorflow::set_tf2_execution(true);
  FunctionDefLibrary flib;
  *flib.add_function() = fd;

  if (node_def->op() == "Cast" && attr->contains("SrcT") &&
      attr->contains("DstT") &&
      attr->at("SrcT").type() == attr->at("DstT").type() &&
      attr->contains("Truncate") && !attr->at("Truncate").b()) {
    node_def->set_op("Identity");
    attr->insert({{"T", attr->at("SrcT")}});
    attr->erase("SrcT");
    attr->erase("DstT");
    attr->erase("Truncate");
  }
}

}  // namespace

    }
  }
}
node {
  name: "fc1000_1/BiasAdd/Cast"
  op: "Cast"
  input: "fc1000_1/BiasAdd/ReadVariableOp"
  device: "/job:localhost/replica:0/task:0/device:GPU:0"
  attr {
    key: "DstT"
    value {
      type: DT_HALF
    }
  }
  attr {
    key: "SrcT"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "Truncate"
    value {

      // Attr def
      {"T: {float, double, int32, int64}"},
      // Nodes
      {
          {{"two"}, "Const", {}, {{"value", kTwo}, {"dtype", DT_INT64}}},
          {{"scale"}, "Cast", {"two"}, {{"SrcT", DT_INT64}, {"DstT", "$T"}}},
          {{"y"}, "Mul", {"x", "scale"}, {{"T", "$T"}}},
      });
}

class MlirGraphOptimizationPassTest : public Test {
 public:
  void Init(Status pass_run_result,

  y = math_ops.Sub(y, z)
  qmin, qmax = _tfr_quant_act_range('RELU', 1.0, 0)
  (qmin, qmax)  # pylint: disable=pointless-statement
  d = _tfr_quant_rescale(y, s, 0)
  e = math_ops.Cast(x=d, DstT=dtypes.int16)
  f = math_ops.Cast(x=e, DstT=dtypes.int8)
  return f


@composite.Composite('TestIdentityNOp')
def _tfr_quant_test_n(x):
  y = _tfr_quant_raw_data(x)
  return y


class TFRGenTestBase(test.TestCase):

  }
}
node {
  name: "loss_1/activation_49_loss/Cast"
  op: "Cast"
  input: "loss_1/activation_49_loss/Reshape"
  device: "/job:localhost/replica:0/task:0/device:GPU:0"
  attr {
    key: "DstT"
    value {
      type: DT_INT64
    }
  }
  attr {
    key: "SrcT"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "Truncate"
    value {

  let summary = "Cast x of type SrcT to y of DstT.";

  let arguments = (ins
    TF_Tensor:$x,

    DefaultValuedOptionalAttr<BoolAttr, "false">:$Truncate
  );

  let results = (outs
    TF_Tensor:$y
  );

  TF_DerivedOperandTypeAttr SrcT = TF_DerivedOperandTypeAttr<0>;
  TF_DerivedResultTypeAttr DstT = TF_DerivedResultTypeAttr<0>;

  let hasFolder = 1;
}