"LT":                               '\U0000003C',
		"Ntilde":                           '\U000000D1',
		"Oacute":                           '\U000000D3',
		"Ocirc":                            '\U000000D4',
		"Ograve":                           '\U000000D2',
		"Oslash":                           '\U000000D8',
		"Otilde":                           '\U000000D5',
		"Ouml":                             '\U000000D6',

	"⁡":                   "\u2061",
	"Å":                           "\u00c5",
	"𝒜":                            "\U0001d49c",
	"≔":                          "\u2254",
	"Ã":                          "\u00c3",
	"Ä":                            "\u00c4",
	"∖":                       "\u2216",
	"⫧":                            "\u2ae7",
	"⌆":                          "\u2306",

    func.return %1, %3 : tensor<*xi32>, tensor<*xi1>
  }
}

// -----

// Tests inputs are correctly split and fed into TPU computation for tiled input
// sharding.

// The following OpSharding is used for TPU computation inputs in below test:
// Proto debug string:
//  input 0
//   type: OTHER
//   tile_assignment_dimensions: 1

  // CHECK:  return
}

func.func @tile(tensor<2x3xf32>, tensor<2xi32>) -> tensor<2x6xf32> {
^bb0(%arg0: tensor<2x3xf32>, %arg1: tensor<2xi32>):
  %cst = "tf.Const"() { value = dense<[1, 2]> : tensor<2xi32> } : () -> tensor<2xi32>
  %0 = "tf.Tile"(%arg0, %cst) : (tensor<2x3xf32>, tensor<2xi32>) -> tensor<2x6xf32>
  func.return %0 : tensor<2x6xf32>

  // CHECK-LABEL: tile

  %cst = arith.constant dense <[2, 3, 4]> : tensor<3xi32>
  %0 = "tf.Tile"(%arg0, %cst) : (tensor<2x3x?xf32>, tensor<3xi32>) -> tensor<4x9x?xf32>
  func.return
}

// -----

func.func @testTileMultipleNotRank1(%arg0: tensor<2x3xf32>, %arg1: tensor<1x1xi32>) {
  // expected-error @+1 {{expected multiples to be rank 1, got rank = 2}}
  %0 = "tf.Tile"(%arg0, %arg1) : (tensor<2x3xf32>, tensor<1x1xi32>) -> tensor<2x3xf32>

        /*scale=*/1.0 / (1<<(bit_width-1)), /*zero_point=*/0);
  }
  }];
}

def TFL_TileOp: TFL_Op<"tile", [
    Pure,
    SameOperandsAndResultsScale,
    QuantizableResult,
    PredOpTrait<"input and output must have same element type",
      TFL_TCresVTEtIsSameAsOp<0, 0>>]> {
  let summary = "Tile operator.";
  let description = [{
    Constructs a tensor by tiling a given tensor.

  func.return %0#0 : tensor<? x f32>
}

// -----

// CHECK-LABEL: testTileF32
func.func @testTileF32(%arg0: tensor<4 x 1 x f32>, %arg1: tensor<4 x i32>) -> tensor<? x f32> {
  // CHECK: "tfl.tile"(%arg0, %arg1)
  %0 = "tfl.tile"(%arg0, %arg1): (tensor<4 x 1 x f32>, tensor<4 x i32>) -> tensor<? x f32>
  func.return %0 : tensor<? x f32>
}

// -----

func.func @testEluI32(%arg0: tensor<? x i32>) -> tensor<? x i32> {

	EM_MICROBLAZE    Machine = 189 /* Xilinx MicroBlaze 32-bit RISC soft processor core */
	EM_CUDA          Machine = 190 /* NVIDIA CUDA architecture */
	EM_TILEGX        Machine = 191 /* Tilera TILE-Gx multicore architecture family */
	EM_CLOUDSHIELD   Machine = 192 /* CloudShield architecture family */
	EM_COREA_1ST     Machine = 193 /* KIPO-KAIST Core-A 1st generation processor family */

}

// CHECK-LABEL: testTileMultiplesAllOnes
func.func @testTileMultiplesAllOnes(%arg0: tensor<2x3xf32>) -> tensor<2x3xf32> {
  %cst = arith.constant dense <[1, 1]> : tensor<2xi32>
  // CHECK: return %arg0
  %0 = "tf.Tile"(%arg0, %cst) : (tensor<2x3xf32>, tensor<2xi32>) -> tensor<2x3xf32>
  func.return %0: tensor<2x3xf32>
}

// CHECK-LABEL: func @testStaticAndIdenticalTypeForEqualOp

              [later editions continued as follows
    When the sands are all dry, he is gay as a lark,
    And will talk in contemptuous tones of the Shark,
    But, when the tide rises and sharks are around,
    His voice has a timid and tremulous sound.]

  `That's different from what I used to say when I was a child,'
said the Gryphon.