" ", "%20",
	"`", "%60",
	"[", "%5B",
	"]", "%5D",
	"^", "%5E",
	"{", "%7B",
	"}", "%7D",
	"\x00", "%00",
	"\x01", "%01",
	"\x02", "%02",
	"\x03", "%03",
	"\x04", "%04",
	"\x05", "%05",
	"\x06", "%06",
	"\x07", "%07",
	"\x08", "%08",
	//	"\x09", "%09",
	//	"\x0A", "%0A",
	"\x0B", "%0B",
	"\x0C", "%0C",
	//	"\x0D", "%0D",
	"\x0E", "%0E",
	"\x0F", "%0F",
	"\x10", "%10",

00000130  21 13 87 ab e5 b8 e5 86  01 74 25 b7 39 fc 86 e2  |!........t%.9...|
00000140  2f de 0b 1f 8c db b2 98  b3 47 c1 4e dd db 36 d3  |/........G.N..6.|
00000150  28 de cf 4c 4d 54 8e a3  e5 d3 38 19 1f 4b 05 7f  |(..LMT....8..K..|
00000160  9a e1 59 4c a3 4e 42 b6  71 0d 9c 96 e4 d8 29 73  |..YL.NB.q.....)s|
00000170  4e e6 f5 87 56 04 99 c2  56 15 6c 8b 04 7c e5 83  |N...V...V.l..|..|

//go:noinline
func testInt64Slice_ssa(s string, i, j int64) string {
	return s[i:j]
}

func testInt64Index(t *testing.T) {
	tests := []struct {
		i int64
		j int64
		b byte
		s string
	}{
		{0, 5, 'B', "Below"},
		{5, 10, 'E', "Exact"},
		{10, 15, 'A', "Above"},
	}

	str := "BelowExactAbove"
	for i, test := range tests {
		if got := testInt64Index_ssa(str, test.i); got != test.b {

namespace mlir {
namespace TFL {
namespace tac {
namespace {
// CPU
constexpr float kCPUArithmeticUnitCost = 1.0;

// This basically assumes pure load/store. This is just fake data.
constexpr float kCPUCopyUnitCost = 0.5;

// Default values.
constexpr float kCPUDefaultFixedValuedCost = 10000.0;

// Quantized inference cost efficiency.
// For CPU, quantized inference is ~3x faster than the float alternative, this

000001b0  7e 7c bf e7 46 7d 13 27  0d 38 75 f0 15 e1 64 93  |~|..F}.'.8u...d.|
000001c0  1e 26 bc a8 5d 95 60 a2  e5 42 7f 2f 08 a1 e8 d3  |.&..].`..B./....|
000001d0  79 e8 5e 1f 02 45 cc 05  ca 63 7b f2 d9 ad af ab  |y.^..E...c{.....|
000001e0  5a 94 f0 16 e7 60 14 c2  3d 05 3f 8d bb 33 c1 ca  |Z....`..=.?..3..|
000001f0  79 28 04 c7 20 07 c8 13  89 7a 11 a2 54 6d b8 d5  |y(.. ....z..Tm..|

 *  in Debug Versions
 *
 *  18/Jun/2002   Memory Debug Functions. (AK)
 *
 *  17-Jul-2004   New interface for global function names. (JDS)
 *
 *  05-Sep-2004   Added internal test interface. (JDS)
 */

/** @file
 *  Memory management functions (user interface).
 *  Two versions of memory allocation/deallocation are available.

  %3 = "tfl.pseudo_const"() {value = dense<[[0.3]]> : tensor<1x1xf32>} : () -> tensor<1x1xf32>
  %4 = "tfl.pseudo_const"() {value = dense<[[0.4]]> : tensor<1x1xf32>} : () -> tensor<1x1xf32>
  %5 = "tfl.pseudo_const"() {value = dense<[[0.5]]> : tensor<1x1xf32>} : () -> tensor<1x1xf32>
  %6 = "tfl.pseudo_const"() {value = dense<[[0.6]]> : tensor<1x1xf32>} : () -> tensor<1x1xf32>
  %7 = "tfl.pseudo_const"() {value = dense<[[0.7]]> : tensor<1x1xf32>} : () -> tensor<1x1xf32>

func.func @fallback_resource(%ch0: !tfrt.chain) -> !tfrt.chain {

  %ra = tfrt_fallback_async.const_dense_tensor dense<0.0> : tensor<f32> {_tfrt_cost = 1 : i64}
  %rb = tfrt_fallback_async.const_dense_tensor dense<0.5> : tensor<f32> {_tfrt_cost = 1 : i64}

  // CHECK: tfrt_fallback_async.set_resource {{%.*}}, {{%.*}} {device = "cpu", index = 0 : i64}
  // CHECK: tfrt_fallback_async.set_resource {{%.*}}, {{%.*}} {device = "cpu", index = 1 : i64}

000000b0  e5 db e8 90 49 90 89 8a  c3 7f 33 a0 c7 91 2a 3f  |....I.....3...*?|
000000c0  c5 1f 0c 00 58 9f 5e d7  01 35 24 92 a7 66 db 0e  |....X.^..5$..f..|
000000d0  fd d3 6c ff 58 61 56 39  b3 9b 05 d2 a1 9f ab f1  |..l.XaV9........|
000000e0  29 ce b0 c6 37 c5 56 8d  0b 2a bd 0c 04 a3 c8 4e  |)...7.V..*.....N|
000000f0  61 08 44 4b b7 f1 12 60  a9 f6 e7 02 14 e7 d4 1a  |a.DK...`........|

						cosines[((2*x+1)*u)%32] *
						cosines[((2*y+1)*v)%32]
				}
			}
			dst[8*v+u] = sum / 8
		}
	}
	// Convert from float64 to int32.
	for i := range dst {
		b[i] = int32(dst[i] + 0.5)
	}
}

// slowIDCT performs the 8*8 2-dimensional inverse discrete cosine transform:
//
//	dst[x,y] = (1/8) * Σ_u Σ_v alpha(u) * alpha(v) * src[u,v] *
//		cos((π/2) * (2*x + 1) * u / 8) *