},
	{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

func gt_neg1_int8(x int8) bool   { return x > -1 }
func ge_neg1_int8(x int8) bool   { return x >= -1 }
func eq_neg1_int8(x int8) bool   { return x == -1 }
func ne_neg1_int8(x int8) bool   { return x != -1 }
func lt_0_int8(x int8) bool      { return x < 0 }
func le_0_int8(x int8) bool      { return x <= 0 }
func gt_0_int8(x int8) bool      { return x > 0 }

		{name: "SHRQconst", argLength: 1, reg: gp11, asm: "SHRQ", aux: "Int8", resultInArg0: true, clobberFlags: true},
		{name: "SHRLconst", argLength: 1, reg: gp11, asm: "SHRL", aux: "Int8", resultInArg0: true, clobberFlags: true},
		{name: "SHRWconst", argLength: 1, reg: gp11, asm: "SHRW", aux: "Int8", resultInArg0: true, clobberFlags: true},
		{name: "SHRBconst", argLength: 1, reg: gp11, asm: "SHRB", aux: "Int8", resultInArg0: true, clobberFlags: true},

  && symIsRO(scon)
  => (MakeResult (Eq8 (Load <typ.Int8> sptr mem) (Const8 <typ.Int8> [int8(read8(scon,0))])) mem)

(StaticLECall {callAux} (Addr {scon} (SB)) sptr (Const64 [1]) mem)
  && isSameCall(callAux, "runtime.memequal")
  && symIsRO(scon)
  => (MakeResult (Eq8 (Load <typ.Int8> sptr mem) (Const8 <typ.Int8> [int8(read8(scon,0))])) mem)

// It panics if v's Kind is not [Int], [Int8], [Int16], [Int32], or [Int64], or if [Value.CanSet] returns false.
func (v Value) SetInt(x int64) {
	v.mustBeAssignable()
	switch k := v.kind(); k {
	default:
		panic(&ValueError{"reflect.Value.SetInt", v.kind()})
	case Int:
		*(*int)(v.ptr) = int(x)
	case Int8:
		*(*int8)(v.ptr) = int8(x)
	case Int16:
		*(*int16)(v.ptr) = int16(x)

  }];
}

def DecomposeReduceDatasetPass : Pass<"tf-decompose-reduce-dataset", "mlir::func::FuncOp"> {
  let summary = "Decomposes ReduceDataset op into dataset operations.";

  let description = [{
    Decomposes ReduceDataset op into a while loop that iterates the dataset and calls
    into the reduction function.  This decomposition is only done if the
    ReduceDataset op is marked for compilation with the _xla_compile_device_type

108-7/9, 109. By the latter Theorem the Refraction out of one Medium into another is gathered as often as you have the Refractions out of them both into any third Medium. As if the Sine of Incidence of any Ray out of Glass into Air be to its Sine of Refraction, as 20 to 31, and the Sine of Incidence of the same Ray out of Air into Water, be to its Sine of Refraction as 4 to 3; the Sine of Incidence of that Ray out of Glass into Water will be to its Sine of Refraction as 20 to 31 and 4 to 3 jointly,...

an organization that produces free electronic books, mostly of
works old enough that they have passed into the public domain.


                            CHAPTER I

                      Down the Rabbit-Hole


  Alice was beginning to get very tired of sitting by her sister
on the bank, and of having nothing to do:  once or twice she had
peeped into the book her sister was reading, but it had no

	// match: (MOVBreg x:(ANDI [c] y))
	// cond: c >= 0 && int64(int8(c)) == c
	// result: x
	for {
		x := v_0
		if x.Op != OpRISCV64ANDI {
			break
		}
		c := auxIntToInt64(x.AuxInt)
		if !(c >= 0 && int64(int8(c)) == c) {
			break
		}
		v.copyOf(x)
		return true
	}
	// match: (MOVBreg (MOVDconst [c]))
	// result: (MOVDconst [int64(int8(c))])
	for {
		if v_0.Op != OpRISCV64MOVDconst {

      "properties": {
        "items": {