}))
	t.Run("ParseComplex", checkNoAllocs(func() {
		Sink.Complex128, Sink.Error = ParseComplex(string(bytes.Number), 128)
	}))
	t.Run("CanBackquote", checkNoAllocs(func() {
		Sink.Bool = CanBackquote(string(bytes.String))
	}))
	t.Run("AppendQuote", checkNoAllocs(func() {
		Sink.Bytes = AppendQuote(bytes.Buffer[:0], string(bytes.String))
	}))

	if s, err := strconv.Atoi(v); err == nil {
		fmt.Printf("%T, %v", s, s)
	}

	// Output:
	// int, 10
}

func ExampleCanBackquote() {
	fmt.Println(strconv.CanBackquote("Fran & Freddie's Diner ☺"))
	fmt.Println(strconv.CanBackquote("`can't backquote this`"))

	// Output:
	// true
	// false
}

func ExampleFormatBool() {
	v := true
	s := strconv.FormatBool(v)
	fmt.Printf("%T, %v\n", s, s)

func AppendQuoteRuneToGraphic(dst []byte, r rune) []byte {
	return appendQuotedRuneWith(dst, r, '\'', false, true)
}

// CanBackquote reports whether the string s can be represented
// unchanged as a single-line backquoted string without control
// characters other than tab.
func CanBackquote(s string) bool {
	for len(s) > 0 {
		r, wid := utf8.DecodeRuneInString(s)
		s = s[wid:]
		if wid > 1 {
			if r == '\ufeff' {

// If f.sharp is set a raw (backquoted) string may be returned instead
// if the string does not contain any control characters other than tab.
func (f *fmt) fmtQ(s string) {
	s = f.truncateString(s)
	if f.sharp && strconv.CanBackquote(s) {
		f.padString("`" + s + "`")
		return
	}
	buf := f.intbuf[:0]
	if f.plus {
		f.pad(strconv.AppendQuoteToASCII(buf, s))
	} else {
		f.pad(strconv.AppendQuote(buf, s))
	}
}

	'#'	alternate format: add leading 0b for binary (%#b), 0 for octal (%#o),
		0x or 0X for hex (%#x or %#X); suppress 0x for %p (%#p);
		for %q, print a raw (backquoted) string if [strconv.CanBackquote]
		returns true;
		always print a decimal point for %e, %E, %f, %F, %g and %G;
		do not remove trailing zeros for %g and %G;
		write e.g. U+0078 'x' if the character is printable for %U (%#U)

	regexp, err := CompilePOSIX(str)
	if err != nil {
		panic(`regexp: CompilePOSIX(` + quote(str) + `): ` + err.Error())
	}
	return regexp
}

func quote(s string) string {
	if strconv.CanBackquote(s) {
		return "`" + s + "`"
	}
	return strconv.Quote(s)
}

// NumSubexp returns the number of parenthesized subexpressions in this [Regexp].
func (re *Regexp) NumSubexp() int {
	return re.numSubexp

		{"AppendQuoteRuneToASCII", Func, 0},
		{"AppendQuoteRuneToGraphic", Func, 6},
		{"AppendQuoteToASCII", Func, 0},
		{"AppendQuoteToGraphic", Func, 6},
		{"AppendUint", Func, 0},
		{"Atoi", Func, 0},
		{"CanBackquote", Func, 0},
		{"ErrRange", Var, 0},
		{"ErrSyntax", Var, 0},
		{"FormatBool", Func, 0},
		{"FormatComplex", Func, 15},
		{"FormatFloat", Func, 0},
		{"FormatInt", Func, 0},
		{"FormatUint", Func, 0},