switch u.Kind() {
				case types.Byte, types.Rune, types.UntypedRune:
					continue
				}
				V0 = vt
				break
			}
		}

		if V0 == nil {
			// No source types are non-byte or rune integer types.
			return
		}

		convertibleToRune := true // if true, we can suggest a fix
		for _, t := range vtypes {
			if !types.ConvertibleTo(t, types.Typ[types.Rune]) {
				convertibleToRune = false
				break

					" isn't testing.", s)
			}
			if c > unicode.MaxASCII {
				t.Skipf("skipping %#q: contains a non-ASCII character %q", s, c)
			}
			if !unicode.IsGraphic(rune(c)) && !unicode.IsSpace(rune(c)) {
				t.Skipf("skipping %#q: contains non-graphic character %q", s, c)
			}
			if runtime.GOOS == "windows" && c == '\r' || c == '\n' {

	}
	for u8 = range 256 /* ERROR "cannot use 256 (untyped int constant) as uint8 value in range clause (overflows)" */ {
	}
}

func issue64471() {
	for i := range 'a' {
		var _ *rune = &i // ensure i has type rune
	}
}

func issue66561() {
	for range 10.0 /* ERROR "cannot range over 10.0 (untyped float constant 10)" */ {
	}
	for range 1e3 /* ERROR "cannot range over 1e3 (untyped float constant 1000)" */ {

	}
	// The open bracket must be preceeded by a link-adjacent rune (or by nothing).
	if t := plainText(i - 1); t != "" {
		r, _ := utf8.DecodeLastRuneInString(t)
		if !isLinkAdjacentRune(r) {
			return ""
		}
	}
	// The element after the next must be a ']'.
	if plainText(i+2) != "]" {
		return ""
	}
	// The ']' must be followed by a link-adjacent rune (or by nothing).
	if t := plainText(i + 3); t != "" {

	failed := false
	for len(chunk) > 0 {
		if !failed && len(s) == 0 {
			failed = true
		}
		switch chunk[0] {
		case '[':
			// character class
			var r rune
			if !failed {
				var n int
				r, n = utf8.DecodeRuneInString(s)
				s = s[n:]
			}
			chunk = chunk[1:]
			// possibly negated
			negated := false
			if len(chunk) > 0 && chunk[0] == '^' {

				// {RFC 2231 section 7}
				// attribute-char := <any (US-ASCII) CHAR except SPACE, CTLs, "*", "'", "%", or tspecials>
				if ch <= ' ' || ch >= 0x7F ||
					ch == '*' || ch == '\'' || ch == '%' ||
					isTSpecial(rune(ch)) {

					b.WriteString(value[offset:index])
					offset = index + 1

					b.WriteByte('%')
					b.WriteByte(upperhex[ch>>4])
					b.WriteByte(upperhex[ch&0x0F])
				}
			}

	"P-521",
	"P-384",
	"X25519",
	"X25519Kyber768Draft00",
)

func IsValidCipherSuite(cs string) bool {
	if cs == "" || cs == "ALL" {
		return true
	}
	if !unicode.IsNumber(rune(cs[0])) && !unicode.IsLetter(rune(cs[0])) {
		// Not all of these are correct, but this is needed to support advanced cases like - and + operators
		// without needing to parse the full expression
		return true
	}

			return true
		case isInteger(x.typ) && isString(t):
			codepoint := unicode.ReplacementChar
			if i, ok := constant.Uint64Val(x.val); ok && i <= unicode.MaxRune {
				codepoint = rune(i)
			}
			if val != nil {
				*val = constant.MakeString(string(codepoint))
			}
			return true
		}
		return false
	}

	var ok bool
	var cause string
	switch {
	case constArg && isConstType(T):

			return true
		case isInteger(x.typ) && isString(t):
			codepoint := unicode.ReplacementChar
			if i, ok := constant.Uint64Val(x.val); ok && i <= unicode.MaxRune {
				codepoint = rune(i)
			}
			if val != nil {
				*val = constant.MakeString(string(codepoint))
			}
			return true
		}
		return false
	}

	var ok bool
	var cause string
	switch {
	case constArg && isConstType(T):

	'q':  true,
	'r':  true,
	's':  true,
	't':  true,
	'u':  true,
	'v':  true,
	'w':  true,
	'x':  true,
	'y':  true,
	'z':  true,
	'|':  true,
	'~':  true,
}

func IsTokenRune(r rune) bool {
	return r < utf8.RuneSelf && isTokenTable[byte(r)]
}

// HeaderValuesContainsToken reports whether any string in values
// contains the provided token, ASCII case-insensitively.