if (!matchPattern(q.getOperand(), m_Constant(&attr))) {
              continue;
            }
            auto cst = rewriter.create<arith::ConstantOp>(
                quantized_op->getLoc(), attr);
            quantizing_op->setOperand(i, cst.getResult());
          }
        }

        for (int i = 0, e = quantized_op->getNumResults(); i < e; ++i) {
          if (!quantizing_op->getResult(i)

			select {
			case <-triggerCancelCh:
			default:
				t.Errorf("Failed to write terminal message: %v", err)
			}
		}
		bufrw.Flush()
	}))
	defer cst.Close()

	backendURL, _ := url.Parse(cst.URL)
	rproxy := NewSingleHostReverseProxy(backendURL)
	rproxy.ErrorLog = log.New(io.Discard, "", 0) // quiet for tests
	rproxy.ModifyResponse = func(res *http.Response) error {

  LogicalResult matchAndRewrite(AssertOp op,
                                PatternRewriter& rewriter) const override {
    ElementsAttr cst;
    if (matchPattern(op.getCondition(), m_Constant(&cst))) {
      if (cst.getValues<bool>()[0]) {
        rewriter.eraseOp(op);
        return success();
      }
    }
    return failure();
  }
};
}  // namespace

}
// CHECK-LABEL: transpose
// CHECK-SAME: %[[ARG0:.+]]: tensor<2x3x4x!quant.uniform<i8:f32, 2.000000e+00:-1>>
// CHECK-NOT: stablehlo.transpose
// CHECK: %[[CST:.+]] = arith.constant dense<[2, 1, 0]> : tensor<3xi32>
// CHECK: %[[TRANSPOSE:.+]] = "tfl.transpose"(%[[ARG0]], %[[CST]]) : (tensor<2x3x4x!quant.uniform<i8:f32, 2.000000e+00:-1>>, tensor<3xi32>) -> tensor<4x3x2x!quant.uniform<i8:f32, 2.000000e+00:-1>>
// CHECK: return %[[TRANSPOSE]]

bool SameTypeOrDefaultCompare(mhlo::ComparisonTypeAttr comparison_type_attr,
                              ElementsAttr cst) {
  if (!comparison_type_attr) return true;
  auto comparison_type_attr_value = comparison_type_attr.getValue();
  if (comparison_type_attr_value == mhlo::ComparisonType::FLOAT &&
      IsDenseSplatFloatAttr(cst)) {
    return true;
  }
  if ((comparison_type_attr_value == mhlo::ComparisonType::SIGNED ||

  // considered dynamic so use -1 here if k is not a constant value.
  int const_k = -1;
  ElementsAttr cst;
  if (matchPattern(k, m_Constant(&cst)))
    // These casts should all be valid due to how Tensor constants are stored.
    // TODO(jpienaar): This should use a helper function.
    const_k = cst.getValues<IntegerAttr>()[0].getValue().getSExtValue();

  auto val_type = input.getType().cast<TensorType>();

      "tf.MakeIterator"(%arg0, %0) : (tensor<!tf_type.variant>, tensor<!tf_type.resource>) -> ()
      %cst = "tf.Const"() {value = dense<true> : tensor<i1>} : () -> tensor<i1>
      %1:2 = "tf.WhileRegion"(%cst, %arg1) ({
      ^bb0(%arg2: tensor<i1>, %arg3: tensor<i64>):
        "tf.Yield"(%arg2) : (tensor<i1>) -> ()
      }, {
      ^bb0(%arg2: tensor<i1>, %arg3: tensor<i64>):

    %cst = "tf.Const"() {value = dense<512> : tensor<i32>} : () -> tensor<i32>
    %2:4 = "tf_device.launch"() ({
      %4 = "tf.Cast"(%arg0) {Truncate = false} : (tensor<512xi64>) -> tensor<512xi32>
      %5 = "tf.TPUCopyWithDynamicShape"(%4,  %cst) {operandSegmentSizes = array<i32: 1, 1>} : (tensor<512xi32>, tensor<i32>) -> tensor<512xi32>

public void DefaultConsumer(); public void consumeLine(String); } org/codehaus/plexus/util/cli/EnhancedStringTokeni.class package org.codehaus.plexus.util.cli; public final synchronized class EnhancedStringTokeni { private java.util.StringTokenizer cst; String cdelim; final boolean cdelimSingleChar; final char cdelimChar; boolean creturnDelims; String lastToken; boolean delimLast; public void EnhancedStringTokeni(String); public void EnhancedStringTokeni(String, String); public void EnhancedStringTokeni(String,...

    auto cst =
        rewriter.create<mhlo::ConstantOp>(op.getLoc(), zero_attr).getResult();
    auto split_updates = rewriter.create<TF::SplitOp>(
        op.getLoc(), split_updates_type, cst, updates);

    SmallVector<Value, 6> input_indices;
    input_indices.resize(input_type.getRank(), cst);

    for (auto pair :