auto from_type = from->GetTypeId();
    auto to_type = GetTypeId();
    if (from_type == to_type) return 0.0f;

    // TODO(renjieliu): Implement a better version for different hardware cases.
    return buffer_size * kCrossHardwareTransferPerByteCost / 8.0 +
           kCrossHardwareTransferFixedCost;
  }

  mlir::RewritePatternSet GetTransformations(
      MLIRContext* context) const override {

  transient volatile int busy;

  /** Package-private default constructor */
  Striped64() {}

  /** CASes the base field. */
  final boolean casBase(long cmp, long val) {
    return UNSAFE.compareAndSwapLong(this, baseOffset, cmp, val);
  }

  /** CASes the busy field from 0 to 1 to acquire lock. */
  final boolean casBusy() {
    return UNSAFE.compareAndSwapInt(this, busyOffset, 0, 1);
  }

  transient volatile int busy;

  /** Package-private default constructor */
  Striped64() {}

  /** CASes the base field. */
  final boolean casBase(long cmp, long val) {
    return UNSAFE.compareAndSwapLong(this, baseOffset, cmp, val);
  }

  /** CASes the busy field from 0 to 1 to acquire lock. */
  final boolean casBusy() {
    return UNSAFE.compareAndSwapInt(this, busyOffset, 0, 1);
  }

bool IsLastDimEqualToNumElements(Type type1, Type type2) {
  return (mlir::cast<ShapedType>(type1).getRank() >= 1 &&
          mlir::cast<ShapedType>(type1).getDimSize(
              mlir::cast<ShapedType>(type1).getRank() - 1) ==
              mlir::cast<ShapedType>(type2).getNumElements());
}

bool CanFuseConvOrDepthwiseConvShapes(const ArrayRef<int64_t> filter_shape,

  %accum_zp = "tf.Const"() { value = dense<0> : tensor<i32> } : () -> tensor<i32>
  %quant_input = "tf.Cast"(%input) {} : (tensor<1x9x9x9xi8>) ->
    tensor<1x9x9x9x!tf_type.qint8>
  %quant_filter = "tf.Cast"(%filter) {} : (tensor<3x3x9x10xi8>) ->
    tensor<3x3x9x10x!tf_type.qint8>
  %0 = "tf.UniformQuantizedConvolution"(
    %quant_input, %quant_filter, %input_scale, %input_zp,

     * Checks if a type has a type variable which may require resolving.
     */
    public static boolean hasTypeVariable(Type type) {
        // do some checks up-front, so we avoid creating the queue in most cases
        // Cases we want to handle:
        // - List<String>
        // - Class<?>
        // - List<Class<?>>
        // - Integer[]
        // - ? extends BaseType
        // - Class<?>[]

#include "tensorflow/compiler/mlir/lite/ir/tfl_ops.h"

namespace mlir {
namespace TFL {
namespace tac {
namespace {

// These are just fake costs.
constexpr float kDequantCost = 2.0;
constexpr float kQuantCost = 2.0;
constexpr float kRequantCost = 2.0;

// TODO(renjieliu): Ideally this should consider different kinds of SOCs as
// well.

	"package_bb"
	"package_ccc"	// comment
	"package_dddd"	// comment
)

// print import paths as double-quoted strings
// (we would like more test cases but the go/parser
// already excludes most incorrect paths, and we don't
// bother setting up test-ASTs manually)
import (
	"fmt"
	"math"
)

// at least one empty line between declarations of different kind
import _ "io"

var _ int

// An error is returned if it's not possible to cast the object to
// metav1.Object type.
func newCachingObject(object runtime.Object) (*cachingObject, error) {
	if obj, ok := object.(metaRuntimeInterface); ok {
		result := &cachingObject{
			object:     obj,
			deepCopied: false,
		}
		result.serializations.Store(make(serializationsCache))
		return result, nil
	}
	return nil, fmt.Errorf("can't cast object to metav1.Object: %#v", object)
}

  "$0.isa<DenseElementsAttr>() && "
  "$0.cast<DenseElementsAttr>().getNumElements() == 1 && "
  "(($0.cast<DenseElementsAttr>().getValues<APFloat>()[0].isLargest() && "
  "$0.cast<DenseElementsAttr>().getValues<APFloat>()[0].isNegative()) || "
  "$0.cast<DenseElementsAttr>().getValues<APFloat>()[0].isNegInfinity())">>;

def L2NormValidReduceIndex : Constraint<CPred<
  "L2NormalizeReduceAxis($0, $1.cast<DenseElementsAttr>())">>;