var (
	eight8  uint8 = 8
	eight8I T8    = 8
	yes     bool  = true

	zero16     uint16 = 0
	zero16I    T16    = 0
	one16      uint16 = 1
	thousand16 uint16 = 1000

	zero32     uint32 = 0
	zero32I    T32    = 0
	one32      uint32 = 1
	thousand32 uint32 = 1000

	zero64     uint64 = 0
	zero64I    T64    = 0
	one64      uint64 = 1
	thousand64 uint64 = 1000

	zerostr  string = ""

	MOV	ZERO, 16(X10)
	MOV	ZERO, 24(X10)
	MOV	ZERO, 32(X10)
	MOV	ZERO, 40(X10)
	MOV	ZERO, 48(X10)
	MOV	ZERO, 56(X10)
	ADD	$64, X10
	SUB	$64, X11
	BGE	X11, X9, loop64
	BEQZ	X11, done

check32:
	MOV	$32, X9
	BLT	X11, X9, check16
zero32:
	MOV	ZERO, 0(X10)
	MOV	ZERO, 8(X10)
	MOV	ZERO, 16(X10)
	MOV	ZERO, 24(X10)
	ADD	$32, X10
	SUB	$32, X11
	BEQZ	X11, done

check16:
	MOV	$16, X9
	BLT	X11, X9, check8

	zero8u1_ssa(&a)
	want := Z8u1{false, [8]byte{0, 0, 0, 0, 0, 0, 0, 0}}
	if a != want {
		t.Errorf("zero8u2 got=%v, want %v\n", a, want)
	}
	b := Z8u2{15, [8]byte{255, 255, 255, 255, 255, 255, 255, 255}}
	zero8u2_ssa(&b)
	wantb := Z8u2{15, [8]byte{0, 0, 0, 0, 0, 0, 0, 0}}
	if b != wantb {
		t.Errorf("zero8u2 got=%v, want %v\n", b, wantb)
	}
}

type Z16u1 struct {
	b   bool
	val [16]byte
}

	gg func(a, b float32) float32,
	zero, one, inf, nan float64, result uint) {
	fail64bool(s, f, zero, zero, result>>16&1 == 1)
	fail64bool(s, f, zero, one, result>>12&1 == 1)
	fail64bool(s, f, zero, inf, result>>8&1 == 1)
	fail64bool(s, f, zero, nan, result>>4&1 == 1)
	fail64bool(s, f, nan, nan, result&1 == 1)

	fail64(s, g, zero, zero, ev64[result>>16&1])
	fail64(s, g, zero, one, ev64[result>>12&1])

// CHECK-DAG:  [[ZERO_1:%cst.*]] = arith.constant dense<0> : tensor<i32>


// CHECK:  [[PARTIAL_START_POS:%.*]] = "tf.Fill"([[VECTOR_RANK]], [[ZERO_1]]) : (tensor<1xi32>, tensor<i32>) -> tensor<?xi32>
// CHECK:  [[ZERO_2:%cst.*]] = arith.constant dense<0> : tensor<i32>
// CHECK:  [[EXPANDED_START_INDEX:%.*]] = "tf.ExpandDims"([[ZERO]], [[ZERO_2]]) : (tensor<i32>, tensor<i32>) -> tensor<1xi32>

// struct types.

// ------------- //
//    Zeroing    //
// ------------- //

type Z1 struct {
	a, b, c int
}

func Zero1(t *Z1) { // Issue #18370
	// amd64:`MOVUPS\tX[0-9]+, \(.*\)`,`MOVQ\t\$0, 16\(.*\)`
	*t = Z1{}
}

type Z2 struct {
	a, b, c *int
}

func Zero2(t *Z2) {
	// amd64:`MOVUPS\tX[0-9]+, \(.*\)`,`MOVQ\t\$0, 16\(.*\)`
	// amd64:`.*runtime[.]gcWriteBarrier.*\(SB\)`
	*t = Z2{}
}

		fmt.Fprintln(w, "\tADDQ\t$16, SI")
		fmt.Fprintln(w, "\tMOVUPS\tX0, (DI)")
		fmt.Fprintln(w, "\tADDQ\t$16, DI")
		fmt.Fprintln(w)
	}
	fmt.Fprintln(w, "\tRET")
}

func zero386(w io.Writer) {
	// AX: zero
	// DI: ptr to memory to be zeroed
	// DI is updated as a side effect.
	fmt.Fprintln(w, "TEXT runtime·duffzero(SB), NOSPLIT, $0-0")
	for i := 0; i < 128; i++ {
		fmt.Fprintln(w, "\tSTOSL")
	}

	MOVD   $16, R8
	MOVD   $32, R16
	MOVD   $48, R17

zero64:
	STXVD2X VS32, (R3+R0)   // store 16 bytes
	STXVD2X VS32, (R3+R8)
	STXVD2X VS32, (R3+R16)
	STXVD2X VS32, (R3+R17)
	ADD     $64, R3
	ADD     $-64, R4
	BDNZ    zero64          // dec ctr, br zero64 if ctr not 0
	SRDCC   $3, R4, R6	// remaining doublewords
	BEQ     nozerolarge

lt64gt8:
	CMP	R4, $32
	BLT	lt32gt8

				// will no longer necessarily be zero).
				for i := min; i < max; i += ptrSize {
					bit := i / ptrSize
					z.mask &^= 1 << uint(bit)
				}
				if z.mask == 0 {
					// No more known zeros - don't bother keeping.
					continue
				}
				// Save updated known zero contents for new store.
				if zeroes[v.ID] != z {
					zeroes[v.ID] = z
					changed = true
				}
			}
		}

  - name: gateway
    namespace: istio-system
  hostnames: ["first.domain.example"]
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /get
    backendRefs:
      - name: httpbin-zero
        port: 8080
        weight: 0
  - matches:
    - path:
        type: PathPrefix
        value: /weighted-100
    backendRefs:
    - filters:
      - requestHeaderModifier:
          add: