elemType.isInteger(64))
    return true;

  // Complex<F<32>> is allowed.
  if (mlir::isa<ComplexType>(elemType) &&
      mlir::cast<ComplexType>(elemType).getElementType().isF32())
    return true;

  // QUINT8 and UI8 are allowed.
  if (mlir::isa<TF::Quint8Type>(elemType) ||
      (elemType.isInteger(8) && mlir::cast<IntegerType>(elemType).isUnsigned()))
    return true;

  return false;
}

systems in general.

Operations in this dialect usually operate on tensor and scalar types defined in
the standard dialect. The extra defined types are specific to TensorFlow: `QINT`
types like !tf_type.qint8 (etc), `QUINT` types like !tf_type.quint8, all of the
`REF` types like !tf_type.uint8ref, as well as !tf_type.string,
!tf_type.resource, and !tf_type.variant which correspond to the tensorflow types
of the same name.

### Example:

  func.return %0...

//===----------------------------------------------------------------------===//
// TFLite dialect quint8 type - uses the TF quint8 type as implementation
//===----------------------------------------------------------------------===//
def TFL_Quint8 : Type<CPred<"$_self.isa<mlir::TF::Quint8Type>()">,
                    "TFLite quint8 type">,
              BuildableType<"getType<mlir::TF::Quint8Type>()">;

    %check = "tf.Equal"(%arg1, %one) : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "tf.Yield"(%check) : (tensor<i1>) -> ()
    }, {
  ^bb0(%barg0: tensor<2x?x!tf_type.qint8>, %barg1: tensor<?x2x!tf_type.qint8>):
    %id = "tf.Identity"(%barg0) : (tensor<2x?x!tf_type.qint8>) -> tensor<2x?x!tf_type.qint8>

}

// -----

func.func @illegal_cast(%arg0: tensor<1x!tf_type.qint8>) -> tensor<1xi8> {
  // expected-error@+1 {{'tf.Cast' op is illegal as it is a UQ op or contains uq/qint types}}
  %0 = "tf.Cast"(%arg0) {Truncate = false} : (tensor<1x!tf_type.qint8>) -> tensor<1xi8>
  func.return %0: tensor<1xi8>
}

// -----

package main

type MyBool bool
type MyComplex128 complex128
type MyComplex64 complex64
type MyFloat32 float32
type MyFloat64 float64
type MyInt int
type MyInt8 int8
type MyInt16 int16
type MyInt32 int32
type MyInt64 int64
type MyString string
type MyUint uint
type MyUint8 uint8
type MyUint16 uint16
type MyUint32 uint32
type MyUint64 uint64
type MyUintptr uintptr

func panicCustomComplex64() {

value of the input by 255/6 and cast to quint8.

If the output type was qint8 ([-128, 127]), the operation will additionally
subtract each value by 128 prior to casting, so that the range of values aligns
with the range of qint8.

If the mode is 'MIN_FIRST', then this approach is used:

```
num_discrete_values = 1 << (# of bits in T)

A. Unique TensorFlower <******@****.***> 1605121757 -0800

mi
ti
ci
vi
lo
la
li
le
gli
ne
il
un
uno
una
ma
ed
se
perché
anche
come
dov
dove
che
chi
cui
non
più
quale
quanto
quanti
quanta
quante
quello
quelli
quella
quelle
questo
questi
questa
queste
si
tutto
tutti
a
c
e
i
l
o
ho
hai
ha
abbiamo
avete
hanno