Type        [64]int8
	Blocksize   uint32
	Min_keysize uint32
	Max_keysize uint32
}

type CryptoReportBlkCipher struct {
	Type        [64]int8
	Geniv       [64]int8
	Blocksize   uint32
	Min_keysize uint32
	Max_keysize uint32
	Ivsize      uint32
}

type CryptoReportAEAD struct {
	Type        [64]int8
	Geniv       [64]int8
	Blocksize   uint32
	Maxauthsize uint32

	Type        [64]int8
	Blocksize   uint32
	Min_keysize uint32
	Max_keysize uint32
}

type CryptoReportBlkCipher struct {
	Type        [64]int8
	Geniv       [64]int8
	Blocksize   uint32
	Min_keysize uint32
	Max_keysize uint32
	Ivsize      uint32
}

type CryptoReportAEAD struct {
	Type        [64]int8
	Geniv       [64]int8
	Blocksize   uint32
	Maxauthsize uint32

// RUN: tf-opt %s -tfl-modify-io-nodes="test-io-types=float32,float32" | FileCheck %s
// RUN: tf-opt %s -tfl-modify-io-nodes="test-io-types=int8,int8" | FileCheck --check-prefix=INT8 %s
// RUN: tf-opt %s -tfl-modify-io-nodes="test-io-types=uint8,uint8" | FileCheck --check-prefix=UINT8 %s

func.func @modified(%arg0: tensor<1x224x224x3xf32>) -> tensor<1x401408xf32> attributes {tf.entry_function = {control_outputs = "", inputs = "input", outputs = "output"}} {

      if (current_type == input_type) {  // int8 == int8
        arg_type = quantize_output.getType();
        new_arg = block.addArgument(arg_type, loc);
        quantize_output.replaceAllUsesWith(new_arg);
      } else if (input_type.isUnsignedInteger(
                     current_type.getIntOrFloatBitWidth())) {  // int8 != uint8
        arg_type = quant::ConvertSignedQuantizedToUnsigned(

		for i := 0; i < l; i++ {
			e.value(v.Index(i))
		}

	case reflect.Bool:
		e.bool(v.Bool())

	case reflect.Int8:
		e.int8(int8(v.Int()))
	case reflect.Int16:
		e.int16(int16(v.Int()))
	case reflect.Int32:
		e.int32(int32(v.Int()))
	case reflect.Int64:
		e.int64(v.Int())

	case reflect.Uint8:
		e.uint8(uint8(v.Uint()))
	case reflect.Uint16:
		e.uint16(uint16(v.Uint()))

	g := int16(v >> 48)
	// ppc64x:".*MOVH"
	g += int16(v >> 30)
	// ppc64x:-".*MOVH"
	g += int16(f >> 16)
	// ppc64x:-".*MOVB"
	h := int8(v >> 56)
	// ppc64x:".*MOVB"
	h += int8(v >> 28)
	// ppc64x:-".*MOVB"
	h += int8(f >> 24)
	// ppc64x:".*MOVB"
	h += int8(f >> 16)
	return int64(h), uint64(g)
}

func checkShiftAndMask32(v []uint32) {
	i := 0

		}

		if window < width/2 {
			carry = 0
			naf[pos] = int8(window)
		} else {
			carry = 1
			naf[pos] = int8(window) - int8(width)
		}

		pos += w
	}
	return naf
}

func (s *Scalar) signedRadix16() [64]int8 {
	b := s.Bytes()
	if b[31] > 127 {
		panic("scalar has high bit set illegally")
	}

	var digits [64]int8

	// Compute unsigned radix-16 digits:

			})
			v.Call([]Value{rf})
		}
	}
	switch v.Kind() {
	case Int:
		return rangeNum[int](v.Int())
	case Int8:
		return rangeNum[int8](v.Int())
	case Int16:
		return rangeNum[int16](v.Int())
	case Int32:
		return rangeNum[int32](v.Int())
	case Int64:
		return rangeNum[int64](v.Int())
	case Uint:
		return rangeNum[uint](v.Uint())
	case Uint8:
		return rangeNum[uint8](v.Uint())

	},
	{struct {
		x struct {
			a int8
			b int8
			c int8
			d int32
		}
	}{},
		"struct { a int8; b int8; c int8; d int32 }",
	},
	{struct {
		x struct {
			a int8
			b int8
			c int8
			d int8
			e int32
		}
	}{},
		"struct { a int8; b int8; c int8; d int8; e int32 }",
	},
	{struct {
		x struct {
			a int8
			b int8
			c int8

		}},
		{"[4]int", ValueOf([4]int{1, 2, 3, 4}), func(t *testing.T, s iter.Seq2[Value, Value]) {
			i := int64(0)
			for v1, v2 := range s {
				if v1.Int() != i {
					t.Fatalf("got %d, want %d", v1.Int(), i)
				}
				i++
				if v2.Int() != i {
					t.Fatalf("got %d, want %d", v2.Int(), i)
				}
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},