i := strings.IndexFunc(v, func(r rune) bool {
		return r < '0' || r > '9'
	})
	year, _ := strconv.Atoi(v[:i])
	return year
}

type gowasmFeatures struct {
	SatConv bool
	SignExt bool
}

func (f gowasmFeatures) String() string {
	var flags []string
	if f.SatConv {
		flags = append(flags, "satconv")
	}
	if f.SignExt {
		flags = append(flags, "signext")
	}

go list -f '{{context.ToolTags}}'
stdout 'riscv64.rva20u64'

env GOARCH=386
env GO386=sse2
go list -f '{{context.ToolTags}}'
stdout '386.sse2'

env GOARCH=wasm
env GOWASM=satconv
go list -f '{{context.ToolTags}}'
stdout 'wasm.satconv'

-- go.mod --
module m

-- p.go --

	  feature build tags.
	- For GOARCH=riscv64,
	  GORISCV64=rva20u64 and rva22u64 correspond to the riscv64.rva20u64
	  and riscv64.rva22u64 build tags.
	- For GOARCH=wasm, GOWASM=satconv and signext
	  correspond to the wasm.satconv and wasm.signext feature build tags.

For GOARCH=amd64, arm, ppc64, ppc64le, and riscv64, a particular feature level
sets the feature build tags for all previous levels as well.

//   - For GOARCH=riscv64,
//     GORISCV64=rva20u64 and rva22u64 correspond to the riscv64.rva20u64
//     and riscv64.rva22u64 build tags.
//   - For GOARCH=wasm, GOWASM=satconv and signext
//     correspond to the wasm.satconv and wasm.signext feature build tags.
//
// For GOARCH=amd64, arm, ppc64, ppc64le, and riscv64, a particular feature level
// sets the feature build tags for all previous levels as well.

// license that can be found in the LICENSE file.

// This file implements rat-to-string conversion functions.

package big

import (
	"errors"
	"fmt"
	"io"
	"strconv"
	"strings"
)

func ratTok(ch rune) bool {
	return strings.ContainsRune("+-/0123456789.eE", ch)
}

var ratZero Rat
var _ fmt.Scanner = &ratZero // *Rat must implement fmt.Scanner

cui fliter <******@****.***> 1697288956 +0800

		if verb == 'v' && f.Flag('+') {
			mode = fmtDebug
		}
		fmt.Fprint(f, sconv(s, verb, mode))

	default:
		fmt.Fprintf(f, "%%!%c(*types.Sym=%p)", verb, s)
	}
}

func (s *Sym) String() string {
	return sconv(s, 0, fmtGo)
}

// See #16897 for details about performance implications
// before changing the implementation of sconv.
func sconv(s *Sym, verb rune, mode fmtMode) string {
	if verb == 'L' {
		panic("linksymfmt")

						},
						Fallback: crypto.GetFallback().GetValue(),
					},
				},
			}
		case *mesh.PrivateKeyProvider_Qat:
			qatConf := pkpConf.GetQat()
			msg := protoconv.MessageToAny(&qat.QatPrivateKeyMethodConfig{
				PollDelay: durationpb.New(time.Duration(qatConf.GetPollDelay().Nanos)),
				PrivateKey: &core.DataSource{
					Specifier: &core.DataSource_InlineBytes{
						InlineBytes: s.PrivateKey,
					},

	"NONE",
	"REG",
	"FREG",
	"FCSRREG",
	"FCCREG",
	"ZCON",
	"SCON",
	"UCON",
	"ADD0CON",
	"AND0CON",
	"ADDCON",
	"ANDCON",
	"LCON",
	"DCON",
	"SACON",
	"SECON",
	"LACON",
	"LECON",
	"DACON",
	"STCON",
	"SBRA",
	"LBRA",
	"SAUTO",
	"LAUTO",
	"SEXT",
	"LEXT",
	"ZOREG",
	"SOREG",
	"LOREG",
	"GOK",
	"ADDR",
	"TLS_LE",
	"TLS_IE",
	"GOTADDR",
	"TEXTSIZE",

						},
						Fallback: crypto.GetFallback().GetValue(),
					},
				},
			},
		})
	case *mesh.PrivateKeyProvider_Qat:
		qatConf := pkpConf.GetQat()
		msg := protoconv.MessageToAny(&qat.QatPrivateKeyMethodConfig{
			PollDelay: durationpb.New(time.Duration(qatConf.GetPollDelay().Nanos)),
			PrivateKey: &core.DataSource{
				Specifier: &core.DataSource_InlineBytes{
					InlineBytes: certInfo.Key,
				},
			},