var Typ = [...]*Basic{
	Invalid: {Invalid, 0, "invalid type"},

	Bool:          {Bool, IsBoolean, "bool"},
	Int:           {Int, IsInteger, "int"},
	Int8:          {Int8, IsInteger, "int8"},
	Int16:         {Int16, IsInteger, "int16"},
	Int32:         {Int32, IsInteger, "int32"},
	Int64:         {Int64, IsInteger, "int64"},
	Uint:          {Uint, IsInteger | IsUnsigned, "uint"},

// alias basic type named "byte" (and analogous for "rune").
var Typ = []*Basic{
	Invalid: {Invalid, 0, "invalid type"},

	Bool:          {Bool, IsBoolean, "bool"},
	Int:           {Int, IsInteger, "int"},
	Int8:          {Int8, IsInteger, "int8"},
	Int16:         {Int16, IsInteger, "int16"},
	Int32:         {Int32, IsInteger, "int32"},
	Int64:         {Int64, IsInteger, "int64"},
	Uint:          {Uint, IsInteger | IsUnsigned, "uint"},

# CHECK:     version: 1
# CHECK:     builtin_code: RESHAPE
# CHECK:   } ],
# CHECK:   subgraphs: [ {
# CHECK:     tensors: [ {
# CHECK:       shape: [ 1, 1, 1, 256 ],
# CHECK:       type: INT8,
# CHECK:       buffer: 1,
# CHECK:       name: "input",
# CHECK:       quantization: {
# CHECK:         scale: [ 0.216328 ],
# CHECK:         zero_point: [ 27 ]
# CHECK:       }
# CHECK:     }, {

// license that can be found in the LICENSE file.

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

  auto rhs_type = mlir::cast<RankedTensorType>(input_rhs.getType());

  // Skip int8 x int8 => int32.
  if (lhs_type.getElementType().isInteger(8) &&
      rhs_type.getElementType().isInteger(8)) {
    return rewriter.notifyMatchFailure(op,
                                       "skip unrolling for int8 BatchMatMulV3");
  }

  auto element_type = lhs_type.getElementType();

          /*used_tensors=*/used_tensors, /*quantized=*/true);
      // If the tensor is a weight, it should have type INT8.
      // If the tensor is a bias, it should have type FLOAT32.
      // If the tensor is an input or output it should have type FLOAT32.
      // The input to dequantize should be INT8, and all other tensors should be
      // FLOAT32.
      if (i == dequant_input_idx) {

	auxS390XCCMaskInt8   // aux is a s390x 4-bit condition code mask, auxInt is an int8 immediate
	auxS390XCCMaskUint8  // aux is a s390x 4-bit condition code mask, auxInt is a uint8 immediate
)

// A SymEffect describes the effect that an SSA Value has on the variable
// identified by the symbol in its Aux field.
type SymEffect int8

const (
	SymRead SymEffect = 1 << iota
	SymWrite
	SymAddr

# CHECK:     version: 1
# CHECK:     builtin_code: RESHAPE
# CHECK:   } ],
# CHECK:   subgraphs: [ {
# CHECK:     tensors: [ {
# CHECK:       shape: [ 1, 1, 1, 256 ],
# CHECK:       type: INT8,
# CHECK:       buffer: 1,
# CHECK:       name: "input",
# CHECK:       quantization: {
# CHECK:         scale: [ 0.216328 ],
# CHECK:         zero_point: [ 27 ]
# CHECK:       }
# CHECK:     }, {

				schema.err = fmt.Errorf("failed to parse %s as default value for bool, got error: %v", field.DefaultValue, err)
			}
		}
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		field.DataType = Int
		if field.HasDefaultValue && !skipParseDefaultValue {
			if field.DefaultValueInterface, err = strconv.ParseInt(field.DefaultValue, 0, 64); err != nil {

		printindented(*(*string)(eface.data))
		print(`")`)
	case abi.Bool:
		print(typestring, "(", *(*bool)(eface.data), ")")
	case abi.Int:
		print(typestring, "(", *(*int)(eface.data), ")")
	case abi.Int8:
		print(typestring, "(", *(*int8)(eface.data), ")")
	case abi.Int16:
		print(typestring, "(", *(*int16)(eface.data), ")")
	case abi.Int32:
		print(typestring, "(", *(*int32)(eface.data), ")")
	case abi.Int64: