// CHECK:         %[[DIV:.*]] = f32[] divide(f32[] %[[ARG0]],
// CHECK:         %[[ADD:.*]] = f32[] add(f32[] %[[DIV]], f32[]
// CHECK:         %[[CLAMP:.*]] = f32[] clamp(f32[] %[[MIN:.*]], f32[] %[[ADD]],
// CHECK:         %[[ROUND:.*]] = f32[] round-nearest-even(f32[] %[[CLAMP]])
// CHECK:         %[[CONVERT_0:.*]] = u8[] convert(f32[] %[[ROUND]])
// CHECK:         %[[CONVERT_1:.*]] = s32[] convert(u8[] %[[CONVERT_0]])

		r.nFront++
	}
	// Check if a copy was modified by slicing past the end
	// and seeing if the Attr there is non-zero.
	if cap(r.back) > len(r.back) {
		end := r.back[:len(r.back)+1][len(r.back)]
		if !end.isEmpty() {
			// Don't panic; copy and muddle through.
			r.back = slices.Clip(r.back)
			r.back = append(r.back, String("!BUG", "AddAttrs unsafely called on copy of Record made without using Record.Clone"))
		}
	}

		Len:  n,
		Cap:  cap(b) * int(scale),
	}
	return *(*[]*Block)(unsafe.Pointer(&s))
}
func (c *Cache) freeBlockSlice(s []*Block) {
	var base *Value
	var derived *Block
	scale := unsafe.Sizeof(base) / unsafe.Sizeof(derived)
	b := unsafeheader.Slice{
		Data: unsafe.Pointer(&s[0]),
		Len:  int((uintptr(len(s)) + scale - 1) / scale),
		Cap:  int((uintptr(cap(s)) + scale - 1) / scale),
	}

	raw := *(*[3]uintptr)(unsafe.Pointer(&x))
	base, len, cap := raw[0] - arrayBase, raw[1], raw[2]
	if xbase < 0 {
		notOK()
		println(desc, "=", base, len, cap, "want panic")
		return
	}
	if cap != 0 && base != uintptr(xbase) || base >= 10 || len != uintptr(xlen) || cap != uintptr(xcap) {
		notOK()
		if cap == 0 {
			println(desc, "=", base, len, cap, "want", "0-9", xlen, xcap)
		} else {

def RemoveRedundantCastOps : Pat<
  (TF_CastOp:$root_cast
    (TF_CastOp:$i8_cast
      (TF_ClipByValueOp:$clip $input, $min_value, $max_value),
      ConstBoolAttrFalse:$truncate2),
    ConstBoolAttrFalse:$truncate1),
  (TF_CastOp $clip, ConstBoolAttrFalse),
  [(TensorOf<[I8]> $i8_cast),
   (TensorOf<[I32]> $clip),
   (IsIntSplatValueEqual<"int32_t", "-128"> $min_value),
   (IsIntSplatValueEqual<"int32_t", "127"> $max_value)]>;

	}
	if len(c) != 3 || cap(c) != 10 {
		println("chan len/cap ", len(c), cap(c), " want 3 10")
		panic("fail")
	}

	c = make(T)
	if len(c) != 0 || cap(c) != 0 {
		println("chan len/cap ", len(c), cap(c), " want 0 0")
		panic("fail")
	}

	n := -1
	shouldPanic("makechan: size out of range", func() { _ = make(T, n) })
	shouldPanic("makechan: size out of range", func() { _ = make(T, int64(n)) })
	if ptrSize == 8 {

            }
        }
    }

    /**
     * Clamp the value to an int, or return {@link Diagnostic#NOPOS} if the value is too large.
     * <p>
     * This is used to ensure that we don't report invalid locations.
     *
     * @param value the value to clamp
     * @return either the clamped value, or {@link Diagnostic#NOPOS}
     */

// Test arrays and slices.

package main

func setpd(a []int) {
	//	print("setpd a=", a, " len=", len(a), " cap=", cap(a), "\n");
	for i := 0; i < len(a); i++ {
		a[i] = i
	}
}

func sumpd(a []int) int {
	//	print("sumpd a=", a, " len=", len(a), " cap=", cap(a), "\n");
	t := 0
	for i := 0; i < len(a); i++ {
		t += a[i]
	}
	//	print("sumpd t=", t, "\n");
	return t
}

	for _, cla := range cla {
		if cla == nil {
			continue
		}
		got[cla.ClusterName] = append(got[cla.ClusterName], ExtractEndpoints(cla)...)
	}
	return got
}

// ExtractHealthEndpoints returns all health and unhealth endpoints
func ExtractHealthEndpoints(cla *endpoint.ClusterLoadAssignment) ([]string, []string) {
	if cla == nil {
		return nil, nil
	}
	healthy := []string{}
	unhealthy := []string{}

	sink = make([]byte, 0, 1.0)
	sink = make([]byte, 0, float32(1.0)) // ERROR "non-integer.*cap|must be integer"
	sink = make([]byte, 0, float64(1.0)) // ERROR "non-integer.*cap|must be integer"

	sink = make([]byte, 1+0i)
	sink = make([]byte, complex64(1+0i))  // ERROR "non-integer.*len|must be integer"
	sink = make([]byte, complex128(1+0i)) // ERROR "non-integer.*len|must be integer"

	sink = make([]byte, 0, 1+0i)