diff --git a/go.mod b/go.mod
index 6023dca994..c99fefc9a3 100644
--- a/go.mod
+++ b/go.mod
@@ -22,9 +22,8 @@ require (
 	github.com/jedisct1/go-sieve-cache v0.1.9
 	github.com/jedisct1/xsecretbox v0.0.0-20241212092125-3afc4917ac41
 	github.com/k-sone/critbitgo v1.4.0
-	github.com/kardianos/service v1.2.4
+	github.com/kardianos/service v1.3.0
 	github.com/lifenjoiner/dhcpdns v0.0.7
-	github.com/miekg/dns v1.1.72
 	github.com/powerman/check v1.9.1
 	github.com/quic-go/quic-go v0.60.0
 	golang.org/x/crypto v0.53.0
@@ -45,10 +44,7 @@ require (
 	github.com/quic-go/qpack v0.6.0 // indirect
 	github.com/smartystreets/goconvey v1.8.1 // indirect
 	go.uber.org/mock v0.6.0 // indirect
-	golang.org/x/mod v0.37.0 // indirect
-	golang.org/x/sync v0.21.0 // indirect
 	golang.org/x/text v0.38.0 // indirect
-	golang.org/x/tools v0.46.0 // indirect
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20260618152121-87f3d3e198d3 // indirect
 	google.golang.org/grpc v1.81.1 // indirect
 	google.golang.org/protobuf v1.36.11 // indirect
diff --git a/go.sum b/go.sum
index f71fbb346a..54c292a91e 100644
--- a/go.sum
+++ b/go.sum
@@ -54,12 +54,10 @@ github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/k-sone/critbitgo v1.4.0 h1:l71cTyBGeh6X5ATh6Fibgw3+rtNT80BA0uNNWgkPrbE=
 github.com/k-sone/critbitgo v1.4.0/go.mod h1:7E6pyoyADnFxlUBEKcnfS49b7SUAQGMK+OAp/UQvo0s=
-github.com/kardianos/service v1.2.4 h1:XNlGtZOYNx2u91urOdg/Kfmc+gfmuIo1Dd3rEi2OgBk=
-github.com/kardianos/service v1.2.4/go.mod h1:E4V9ufUuY82F7Ztlu1eN9VXWIQxg8NoLQlmFe0MtrXc=
+github.com/kardianos/service v1.3.0 h1:/LGy+xPP2TM+GLTiCZ2di7cy0Jd/qrawlTUfqKYFdTI=
+github.com/kardianos/service v1.3.0/go.mod h1:E4V9ufUuY82F7Ztlu1eN9VXWIQxg8NoLQlmFe0MtrXc=
 github.com/lifenjoiner/dhcpdns v0.0.7 h1:VJM2aFWHU9V7M5v4UYYNaHhIHZkbdvSI6WGGpq6/TNQ=
 github.com/lifenjoiner/dhcpdns v0.0.7/go.mod h1:BixeaGeafYzDIuDCYIUbSOdi4m+TScpzI9cZGYgzgSk=
-github.com/miekg/dns v1.1.72 h1:vhmr+TF2A3tuoGNkLDFK9zi36F2LS+hKTRW0Uf8kbzI=
-github.com/miekg/dns v1.1.72/go.mod h1:+EuEPhdHOsfk6Wk5TT2CzssZdqkmFhf8r+aVyDEToIs=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
@@ -84,18 +82,12 @@ go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y=
 go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU=
 golang.org/x/crypto v0.53.0 h1:QZ4Muo8THX6CizN2vPPd5fBGHyogrdK9fG4wLPFUsto=
 golang.org/x/crypto v0.53.0/go.mod h1:DNLU434OwVakk9PzuwV8w62mAJpRJL3vsgcfp4Qnsio=
-golang.org/x/mod v0.37.0 h1:vF1DjpVEshcIqoEaauuHebaLk1O1forxjxBaVn884JQ=
-golang.org/x/mod v0.37.0/go.mod h1:m8S8VeM9r4dzDwjrKO0a1sZP3YjeMamRRlD+fmR2Q/0=
 golang.org/x/net v0.56.0 h1:Rw8j/hFzGvJUZwNBXnAtf5sVDVt+65SK2C7IxCxZt5o=
 golang.org/x/net v0.56.0/go.mod h1:D3Ku6r+V6JROoZK144D2XfMHFcMq/0zSfLelVTCFKec=
-golang.org/x/sync v0.21.0 h1:HLII4xRRTtCRkxYp4HNFF0Js/Og6q2i++KXbg0gHCwM=
-golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
 golang.org/x/sys v0.46.0 h1:noSf2Fq6F8DBgS+LysIkx7rIExoNHJsxOAtPp4rthXw=
 golang.org/x/sys v0.46.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
 golang.org/x/text v0.38.0 h1:sXmwo9DwP3OK9EZ7PqAdaooSGozfl/3a6/xJcbzPRhE=
 golang.org/x/text v0.38.0/go.mod h1:YXZt3QhHUKYT53r2lLKFIVi6Ao1jdzrTR/KQ09qyxF4=
-golang.org/x/tools v0.46.0 h1:7jTurBkPZu4moS/Uy4OQT1M+QBlsj3wejyZwsT8Z7rk=
-golang.org/x/tools v0.46.0/go.mod h1:FrD85F8l+NWL+9XWBSyVSHO6Ne4jutsfIFba7AWQ5Ys=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20260618152121-87f3d3e198d3 h1:phvBWCAQMGN1945mp5fjCXP6jEF0+a0+4TjokS4sxNY=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20260618152121-87f3d3e198d3/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8=
 google.golang.org/grpc v1.81.1 h1:VnnIIZ88UzOOKLukQi+ImGz8O1Wdp8nAGGnvOfEIWQQ=
diff --git a/vendor/github.com/kardianos/service/service.go b/vendor/github.com/kardianos/service/service.go
index 130fc22d48..adef097e15 100644
--- a/vendor/github.com/kardianos/service/service.go
+++ b/vendor/github.com/kardianos/service/service.go
@@ -231,6 +231,53 @@ func New(i Interface, c *Config) (Service, error) {
 //   - OnFailureDelayDuration  string ( "1s" )       - Delay before restarting the service, time.Duration string.
 //
 //   - OnFailureResetPeriod    int ( 10 )            - Reset period for errors, seconds.
+//
+// # Custom service-file templates
+//
+// The LaunchdConfig, SystemdScript, UpstartScript, SysvScript, RCSScript, and
+// OpenRCScript options each supply a template used to render the service file
+// in place of the built-in one. Set one by placing the template string in
+// Config.Option under the matching key:
+//
+//	c := &service.Config{
+//		Name: "myservice",
+//		Option: service.KeyValue{
+//			"SystemdScript": myScript, // template string, syntax below
+//		},
+//	}
+//
+// SysvScript is also the key read by the procd, AIX, FreeBSD, and Solaris
+// backends; the key set available to a custom script is whatever the active
+// init system passes (see below).
+//
+// Templates are rendered by a small built-in engine (not text/template). The
+// supported actions are:
+//
+//   - {{Key}}                       substitute a value.
+//   - {{Key | fn | fn}}             substitute, piped through function(s).
+//   - {{if Key}}…{{end}}            include the body when Key is non-empty.
+//   - {{if Key}}…{{else}}…{{end}}   with an else branch.
+//   - {{range Key}}…{{.}}…{{end}}   repeat the body once per item of a list
+//     value, with {{.}} bound to the current item.
+//   - {{- …}} and {{… -}}          trim whitespace before or after the action.
+//
+// Every value is a string or a list of strings; a list is also truthy in
+// {{if}} when non-empty. There is no dotted field access and no arithmetic or
+// boolean functions — any such logic is resolved before rendering. The exact
+// keys and pipeline functions available for a given platform are precisely
+// those used by that platform's default template, so read the corresponding
+// source constant to see them: launchdConfig (darwin), systemdScript,
+// upstartScript, sysvScript, rcsScript, openRCScript, procdScript, svcConfig
+// (AIX), rcScript (FreeBSD), and manifest (Solaris).
+//
+// Compatibility: earlier versions parsed these options with the standard
+// library text/template. Custom scripts written for that engine — using dotted
+// fields such as {{.Name}}, the and/or/not/eq/gt functions, or method calls —
+// must be rewritten in the syntax above; they will otherwise fail to render
+// with an "unknown template key" error. text/template was removed because it
+// reaches reflect.Value.MethodByName, which forces the linker into a
+// conservative mode that defeats dead-code elimination and substantially
+// inflates binaries importing this package.
 type KeyValue map[string]interface{}
 
 // bool returns the value of the given name, assuming the value is a boolean.
diff --git a/vendor/github.com/kardianos/service/service_aix.go b/vendor/github.com/kardianos/service/service_aix.go
index de7a907272..eda2aa4b1d 100644
--- a/vendor/github.com/kardianos/service/service_aix.go
+++ b/vendor/github.com/kardianos/service/service_aix.go
@@ -18,7 +18,6 @@ import (
 	"strconv"
 	"strings"
 	"syscall"
-	"text/template"
 	"time"
 )
 
@@ -96,21 +95,13 @@ func (s *aixService) Platform() string {
 	return version
 }
 
-func (s *aixService) template() *template.Template {
-	functions := template.FuncMap{
-		"bool": func(v bool) string {
-			if v {
-				return "true"
-			}
-			return "false"
-		},
-	}
+var svcConfigTemplate = mustParse(svcConfig)
 
-	customConfig := s.Option.string(optionSysvScript, "")
-	if customConfig != "" {
-		return template.Must(template.New("").Funcs(functions).Parse(customConfig))
+func (s *aixService) template() (*tmpl, error) {
+	if custom := s.Option.string(optionSysvScript, ""); custom != "" {
+		return parseTemplate(custom)
 	}
-	return template.Must(template.New("").Funcs(functions).Parse(svcConfig))
+	return svcConfigTemplate, nil
 }
 
 func (s *aixService) configPath() (string, error) {
@@ -147,15 +138,20 @@ func (s *aixService) Install() error {
 	}
 	defer f.Close()
 
-	to := struct {
-		*Config
-		Path string
-	}{
-		Config: s.Config,
-		Path:   path,
+	data := map[string]any{
+		"Name": s.Config.Name,
+		"Path": path,
 	}
 
-	if err = s.template().Execute(f, &to); err != nil {
+	t, err := s.template()
+	if err != nil {
+		return err
+	}
+	out, err := t.render(data, nil)
+	if err != nil {
+		return err
+	}
+	if _, err = f.WriteString(out); err != nil {
 		return err
 	}
 
@@ -271,13 +267,13 @@ func (s *aixService) SystemLogger(errs chan<- error) (Logger, error) {
 	return newSysLogger(s.Name, errs)
 }
 
-var svcConfig = `#!/bin/ksh
+const svcConfig = `#!/bin/ksh
 case "$1" in
 start)
-        startsrc -s {{.Name}}
+        startsrc -s {{Name}}
         ;;
 stop)
-        stopsrc -s {{.Name}}
+        stopsrc -s {{Name}}
         ;;
 *)
         echo "Usage: $0 {start|stop}"
diff --git a/vendor/github.com/kardianos/service/service_darwin.go b/vendor/github.com/kardianos/service/service_darwin.go
index 727ef2cb31..4d8fd9fb05 100644
--- a/vendor/github.com/kardianos/service/service_darwin.go
+++ b/vendor/github.com/kardianos/service/service_darwin.go
@@ -14,7 +14,6 @@ import (
 	"regexp"
 	"strings"
 	"syscall"
-	"text/template"
 	"time"
 )
 
@@ -134,22 +133,38 @@ func (s *darwinLaunchdService) getLogPath(logDir, logType string) string {
 	return fmt.Sprintf("%s/%s.%s.log", logDir, s.Name, logType)
 }
 
-func (s *darwinLaunchdService) template() *template.Template {
-	functions := template.FuncMap{
-		"bool": func(v bool) string {
-			if v {
-				return "true"
-			}
-			return "false"
-		},
-	}
+// plistEscaper matches text/template's html escaper, which the launchd plist
+// was previously rendered with.
+var plistEscaper = strings.NewReplacer(
+	`&`, "&amp;",
+	`'`, "&#39;",
+	`<`, "&lt;",
+	`>`, "&gt;",
+	`"`, "&#34;",
+)
+
+// launchdFuncs is the pipeline function map for the launchd plist: html escapes
+// a value for XML.
+var launchdFuncs = map[string]tmplFunc{
+	"html": func(s string) (string, error) { return plistEscaper.Replace(s), nil },
+}
 
-	customConfig := s.Option.string(optionLaunchdConfig, "")
+var launchdTemplate = mustParse(launchdConfig)
+
+func (s *darwinLaunchdService) template() (*tmpl, error) {
+	if custom := s.Option.string(optionLaunchdConfig, ""); custom != "" {
+		return parseTemplate(custom)
+	}
+	return launchdTemplate, nil
+}
 
-	if customConfig != "" {
-		return template.Must(template.New("").Funcs(functions).Parse(customConfig))
+// launchdBool renders a Go bool as the "true"/"false" element name used in the
+// plist (previously the text/template "bool" function).
+func launchdBool(v bool) string {
+	if v {
+		return "true"
 	}
-	return template.Must(template.New("").Funcs(functions).Parse(launchdConfig))
+	return "false"
 }
 
 func (s *darwinLaunchdService) Install() error {
@@ -182,25 +197,37 @@ func (s *darwinLaunchdService) Install() error {
 	}
 
 	stdOutPath, stdErrPath, _ := s.getLogPaths()
-	var to = &struct {
-		*Config
-		Path string
-
-		KeepAlive, RunAtLoad bool
-		SessionCreate        bool
-		StandardOutPath      string
-		StandardErrorPath    string
-	}{
-		Config:            s.Config,
-		Path:              path,
-		KeepAlive:         s.Option.bool(optionKeepAlive, optionKeepAliveDefault),
-		RunAtLoad:         s.Option.bool(optionRunAtLoad, optionRunAtLoadDefault),
-		SessionCreate:     s.Option.bool(optionSessionCreate, optionSessionCreateDefault),
-		StandardOutPath:   stdOutPath,
-		StandardErrorPath: stdErrPath,
+
+	c := s.Config
+	data := map[string]any{
+		"Name":              c.Name,
+		"Path":              path,
+		"Arguments":         c.Arguments,
+		"ChRoot":            c.ChRoot,
+		"UserName":          c.UserName,
+		"WorkingDirectory":  c.WorkingDirectory,
+		"KeepAlive":         launchdBool(s.Option.bool(optionKeepAlive, optionKeepAliveDefault)),
+		"RunAtLoad":         launchdBool(s.Option.bool(optionRunAtLoad, optionRunAtLoadDefault)),
+		"SessionCreate":     launchdBool(s.Option.bool(optionSessionCreate, optionSessionCreateDefault)),
+		"StandardOutPath":   stdOutPath,
+		"StandardErrorPath": stdErrPath,
+		// Each entry is the two escaped plist lines for one variable.
+		"EnvVars": envVars(c.EnvVars, func(k, v string) string {
+			return "\t\t<key>" + plistEscaper.Replace(k) + "</key>\n" +
+				"\t\t<string>" + plistEscaper.Replace(v) + "</string>"
+		}),
 	}
 
-	return s.template().Execute(f, to)
+	t, err := s.template()
+	if err != nil {
+		return err
+	}
+	out, err := t.render(data, launchdFuncs)
+	if err != nil {
+		return err
+	}
+	_, err = f.WriteString(out)
+	return err
 }
 
 func (s *darwinLaunchdService) Uninstall() error {
@@ -290,58 +317,39 @@ func (s *darwinLaunchdService) SystemLogger(errs chan<- error) (Logger, error) {
 	return newSysLogger(s.Name, errs)
 }
 
-var launchdConfig = `<?xml version="1.0" encoding="UTF-8"?>
+const launchdConfig = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
 	<key>Disabled</key>
 	<false/>
-	{{- if .EnvVars}}
-	<key>EnvironmentVariables</key>
+	{{if EnvVars}}<key>EnvironmentVariables</key>
 	<dict>
-		{{- range $k, $v := .EnvVars}}
-		<key>{{html $k}}</key>
-		<string>{{html $v}}</string>
-		{{- end}}
-	</dict>
-	{{- end}}
-	<key>KeepAlive</key>
-	<{{bool .KeepAlive}}/>
+{{range EnvVars}}{{.}}
+{{end}}	</dict>
+	{{end}}<key>KeepAlive</key>
+	<{{KeepAlive}}/>
 	<key>Label</key>
-	<string>{{html .Name}}</string>
+	<string>{{Name | html}}</string>
 	<key>ProgramArguments</key>
 	<array>
-		<string>{{html .Path}}</string>
-		{{- if .Config.Arguments}}
-		{{- range .Config.Arguments}}
-		<string>{{html .}}</string>
-		{{- end}}
-	{{- end}}
-	</array>
-	{{- if .ChRoot}}
-	<key>RootDirectory</key>
-	<string>{{html .ChRoot}}</string>
-	{{- end}}
-	<key>RunAtLoad</key>
-	<{{bool .RunAtLoad}}/>
+		<string>{{Path | html}}</string>
+{{range Arguments}}		<string>{{. | html}}</string>
+{{end}}	</array>
+	{{if ChRoot}}<key>RootDirectory</key>
+	<string>{{ChRoot | html}}</string>
+	{{end}}<key>RunAtLoad</key>
+	<{{RunAtLoad}}/>
 	<key>SessionCreate</key>
-	<{{bool .SessionCreate}}/>
-	{{- if .StandardErrorPath}}
-	<key>StandardErrorPath</key>
-	<string>{{html .StandardErrorPath}}</string>
-	{{- end}}
-	{{- if .StandardOutPath}}
-	<key>StandardOutPath</key>
-	<string>{{html .StandardOutPath}}</string>
-	{{- end}}
-	{{- if .UserName}}
-	<key>UserName</key>
-	<string>{{html .UserName}}</string>
-	{{- end}}
-	{{- if .WorkingDirectory}}
-	<key>WorkingDirectory</key>
-	<string>{{html .WorkingDirectory}}</string>
-	{{- end}}
-</dict>
+	<{{SessionCreate}}/>
+	{{if StandardErrorPath}}<key>StandardErrorPath</key>
+	<string>{{StandardErrorPath | html}}</string>
+	{{end}}{{if StandardOutPath}}<key>StandardOutPath</key>
+	<string>{{StandardOutPath | html}}</string>
+	{{end}}{{if UserName}}<key>UserName</key>
+	<string>{{UserName | html}}</string>
+	{{end}}{{if WorkingDirectory}}<key>WorkingDirectory</key>
+	<string>{{WorkingDirectory | html}}</string>
+	{{end}}</dict>
 </plist>
 `
diff --git a/vendor/github.com/kardianos/service/service_freebsd.go b/vendor/github.com/kardianos/service/service_freebsd.go
index 752f5feb85..4570773039 100644
--- a/vendor/github.com/kardianos/service/service_freebsd.go
+++ b/vendor/github.com/kardianos/service/service_freebsd.go
@@ -10,7 +10,6 @@ import (
 	"os/signal"
 	"path/filepath"
 	"syscall"
-	"text/template"
 )
 
 const version = "freebsd"
@@ -70,23 +69,13 @@ func (s *freebsdService) Platform() string {
 	return version
 }
 
-func (s *freebsdService) template() *template.Template {
-	functions := template.FuncMap{
-		"bool": func(v bool) string {
-			if v {
-				return "true"
-			}
-			return "false"
-		},
-	}
-
-	customConfig := s.Option.string(optionSysvScript, "")
+var rcTemplate = mustParse(rcScript)
 
-	if customConfig != "" {
-		return template.Must(template.New("").Funcs(functions).Parse(customConfig))
-	} else {
-		return template.Must(template.New("").Funcs(functions).Parse(rcScript))
+func (s *freebsdService) template() (*tmpl, error) {
+	if custom := s.Option.string(optionSysvScript, ""); custom != "" {
+		return parseTemplate(custom)
 	}
+	return rcTemplate, nil
 }
 
 func (s *freebsdService) configPath() (cp string, err error) {
@@ -120,18 +109,25 @@ func (s *freebsdService) Install() error {
 	}
 	defer f.Close()
 
-	var to = &struct {
-		*Config
-		Path string
-	}{
-		s.Config,
-		path,
+	c := s.Config
+	data := map[string]any{
+		"Name":             c.Name,
+		"Path":             path,
+		"Arguments":        c.Arguments,
+		"WorkingDirectory": c.WorkingDirectory,
 	}
 
-	err = s.template().Execute(f, to)
+	t, err := s.template()
 	if err != nil {
 		return err
 	}
+	out, err := t.render(data, nil)
+	if err != nil {
+		return err
+	}
+	if _, err = f.WriteString(out); err != nil {
+		return err
+	}
 
 	if err = os.Chmod(confPath, 0755); err != nil {
 		return err
@@ -207,20 +203,20 @@ func (s *freebsdService) SystemLogger(errs chan<- error) (Logger, error) {
 	return newSysLogger(s.Name, errs)
 }
 
-var rcScript = `#!/bin/sh
+const rcScript = `#!/bin/sh
 
-# PROVIDE: {{.Name}}
+# PROVIDE: {{Name}}
 # REQUIRE: SERVERS
 # KEYWORD: shutdown
 
 . /etc/rc.subr
 
-name="{{.Name}}"
-{{.Name}}_env="IS_DAEMON=1"
+name="{{Name}}"
+{{Name}}_env="IS_DAEMON=1"
 pidfile="/var/run/${name}.pid"
 command="/usr/sbin/daemon"
-daemon_args="-P ${pidfile} -r -t \"${name}: daemon\"{{if .WorkingDirectory}} -c {{.WorkingDirectory}}{{end}}"
-command_args="${daemon_args} {{.Path}}{{range .Arguments}} {{.}}{{end}}"
+daemon_args="-P ${pidfile} -r -t \"${name}: daemon\"{{if WorkingDirectory}} -c {{WorkingDirectory}}{{end}}"
+command_args="${daemon_args} {{Path}}{{range Arguments}} {{.}}{{end}}"
 
 run_rc_command "$1"
 `
diff --git a/vendor/github.com/kardianos/service/service_linux.go b/vendor/github.com/kardianos/service/service_linux.go
index edd5a0abd3..ea32181768 100644
--- a/vendor/github.com/kardianos/service/service_linux.go
+++ b/vendor/github.com/kardianos/service/service_linux.go
@@ -209,11 +209,19 @@ func isInContainerCGroup(cgroupPath string) (bool, error) {
 	return false, nil
 }
 
-var tf = map[string]interface{}{
-	"cmd": func(s string) string {
-		return `"` + strings.Replace(s, `"`, `\"`, -1) + `"`
-	},
-	"cmdEscape": func(s string) string {
-		return strings.Replace(s, " ", `\x20`, -1)
-	},
+// cmdQuote and cmdEscape are the plain string transforms used when building
+// service files. They are also exposed to custom user templates through tfs.
+func cmdQuote(s string) string {
+	return `"` + strings.ReplaceAll(s, `"`, `\"`) + `"`
+}
+
+func cmdEscape(s string) string {
+	return strings.ReplaceAll(s, " ", `\x20`)
+}
+
+// tfs is the string-only function map for the mini template engine, exposing
+// the cmd/cmdEscape pipeline functions to the built-in and custom templates.
+var tfs = map[string]tmplFunc{
+	"cmd":       func(s string) (string, error) { return cmdQuote(s), nil },
+	"cmdEscape": func(s string) (string, error) { return cmdEscape(s), nil },
 }
diff --git a/vendor/github.com/kardianos/service/service_openrc_linux.go b/vendor/github.com/kardianos/service/service_openrc_linux.go
index c678e3aef6..1f12a085dd 100644
--- a/vendor/github.com/kardianos/service/service_openrc_linux.go
+++ b/vendor/github.com/kardianos/service/service_openrc_linux.go
@@ -9,7 +9,6 @@ import (
 	"os/signal"
 	"regexp"
 	"syscall"
-	"text/template"
 	"time"
 )
 
@@ -55,13 +54,13 @@ func (s *openrc) Platform() string {
 	return s.platform
 }
 
-func (s *openrc) template() *template.Template {
-	customScript := s.Option.string(optionOpenRCScript, "")
+var openRCTemplate = mustParse(openRCScript)
 
-	if customScript != "" {
-		return template.Must(template.New("").Funcs(tf).Parse(customScript))
+func (s *openrc) template() (*tmpl, error) {
+	if custom := s.Option.string(optionOpenRCScript, ""); custom != "" {
+		return parseTemplate(custom)
 	}
-	return template.Must(template.New("").Funcs(tf).Parse(openRCScript))
+	return openRCTemplate, nil
 }
 
 func newOpenRCService(i Interface, platform string, c *Config) (Service, error) {
@@ -110,20 +109,36 @@ func (s *openrc) Install() error {
 		return err
 	}
 
-	var to = &struct {
-		*Config
-		Path         string
-		LogDirectory string
-	}{
-		s.Config,
-		path,
-		s.Option.string(optionLogDirectory, defaultLogDirectory),
+	c := s.Config
+
+	// depend() lists each dependency on its own tab-indented line; bake the
+	// tab in here so the template is a plain {{range}}.
+	deps := make([]string, len(c.Dependencies))
+	for i, d := range c.Dependencies {
+		deps[i] = "\t" + d
+	}
+
+	data := map[string]any{
+		"DisplayName":  c.DisplayName,
+		"Description":  c.Description,
+		"Path":         path,
+		"Arguments":    c.Arguments,
+		"Dependencies": deps,
+		"LogDirectory": s.Option.string(optionLogDirectory, defaultLogDirectory),
+		"EnvVars":      envVars(c.EnvVars, func(k, v string) string { return "export " + k + "=" + v }),
 	}
 
-	err = s.template().Execute(f, to)
+	t, err := s.template()
+	if err != nil {
+		return err
+	}
+	out, err := t.render(data, tfs)
 	if err != nil {
 		return err
 	}
+	if _, err = f.WriteString(out); err != nil {
+		return err
+	}
 	// run rc-update
 	return s.runAction("add")
 }
@@ -221,23 +236,16 @@ func (s *openrc) run(action string, args ...string) error {
 
 const openRCScript = `#!/sbin/openrc-run
 supervisor=supervise-daemon
-name="{{.DisplayName}}"
-description="{{.Description}}"
-command={{.Path|cmdEscape}}
-{{- if .Arguments }}
-command_args="{{range .Arguments}}{{.}} {{end}}"
-{{- end }}
-name=$(basename $(readlink -f $command))
-supervise_daemon_args="--stdout {{.LogDirectory}}/${name}.log --stderr {{.LogDirectory}}/${name}.err"
-
-{{range $k, $v := .EnvVars -}}
-export {{$k}}={{$v}}
-{{end -}}
-
-{{- if .Dependencies }}
-depend() {
-{{- range $i, $dep := .Dependencies}} 
-{{"\t"}}{{$dep}}{{end}}
-}
-{{- end}}
-`
+name="{{DisplayName}}"
+description="{{Description}}"
+command={{Path | cmdEscape}}
+{{if Arguments}}command_args="{{range Arguments}}{{.}} {{end}}"
+{{end}}name=$(basename $(readlink -f $command))
+supervise_daemon_args="--stdout {{LogDirectory}}/${name}.log --stderr {{LogDirectory}}/${name}.err"
+
+{{range EnvVars}}{{.}}
+{{end}}
+{{if Dependencies}}depend() {
+{{range Dependencies}}{{.}}
+{{end}}}
+{{end}}`
diff --git a/vendor/github.com/kardianos/service/service_procd_linux.go b/vendor/github.com/kardianos/service/service_procd_linux.go
index 3213784cd1..9de40c8d64 100644
--- a/vendor/github.com/kardianos/service/service_procd_linux.go
+++ b/vendor/github.com/kardianos/service/service_procd_linux.go
@@ -9,7 +9,6 @@ import (
 	"os"
 	"os/exec"
 	"strings"
-	"text/template"
 	"time"
 )
 
@@ -39,13 +38,13 @@ func newProcdService(i Interface, platform string, c *Config) (Service, error) {
 	return p, nil
 }
 
-func (p *procd) template() *template.Template {
-	customScript := p.Option.string(optionSysvScript, "")
+var procdTemplate = mustParse(procdScript)
 
-	if customScript != "" {
-		return template.Must(template.New("").Funcs(tf).Parse(customScript))
+func (p *procd) template() (*tmpl, error) {
+	if custom := p.Option.string(optionSysvScript, ""); custom != "" {
+		return parseTemplate(custom)
 	}
-	return template.Must(template.New("").Funcs(tf).Parse(procdScript))
+	return procdTemplate, nil
 }
 
 func (p *procd) Install() error {
@@ -69,20 +68,24 @@ func (p *procd) Install() error {
 		return err
 	}
 
-	var to = &struct {
-		*Config
-		Path         string
-		LogDirectory string
-	}{
-		p.Config,
-		path,
-		p.Option.string(optionLogDirectory, defaultLogDirectory),
+	c := p.Config
+	data := map[string]any{
+		"Path":      path,
+		"Name":      c.Name,
+		"Arguments": c.Arguments,
 	}
 
-	err = p.template().Execute(f, to)
+	t, err := p.template()
 	if err != nil {
 		return err
 	}
+	out, err := t.render(data, tfs)
+	if err != nil {
+		return err
+	}
+	if _, err = f.WriteString(out); err != nil {
+		return err
+	}
 
 	if err = os.Chmod(confPath, 0755); err != nil {
 		return err
@@ -151,8 +154,8 @@ USE_PROCD=1
 START=21
 # Before network stops
 STOP=89
-cmd="{{.Path}}{{range .Arguments}} {{.|cmd}}{{end}}"
-name="{{.Name}}"
+cmd="{{Path}}{{range Arguments}} {{. | cmd}}{{end}}"
+name="{{Name}}"
 pid_file="/var/run/${name}.pid"
 
 start_service() {
diff --git a/vendor/github.com/kardianos/service/service_rcs_linux.go b/vendor/github.com/kardianos/service/service_rcs_linux.go
index 0fca97dcdd..cabf5b1d22 100644
--- a/vendor/github.com/kardianos/service/service_rcs_linux.go
+++ b/vendor/github.com/kardianos/service/service_rcs_linux.go
@@ -14,7 +14,6 @@ import (
 	"regexp"
 	"strings"
 	"syscall"
-	"text/template"
 	"time"
 )
 
@@ -85,13 +84,13 @@ func (s *rcs) configPath() (cp string, err error) {
 	return
 }
 
-func (s *rcs) template() *template.Template {
-	customScript := s.Option.string(optionRCSScript, "")
+var rcsTemplate = mustParse(rcsScript)
 
-	if customScript != "" {
-		return template.Must(template.New("").Funcs(tf).Parse(customScript))
+func (s *rcs) template() (*tmpl, error) {
+	if custom := s.Option.string(optionRCSScript, ""); custom != "" {
+		return parseTemplate(custom)
 	}
-	return template.Must(template.New("").Funcs(tf).Parse(rcsScript))
+	return rcsTemplate, nil
 }
 
 func (s *rcs) Install() error {
@@ -115,20 +114,28 @@ func (s *rcs) Install() error {
 		return err
 	}
 
-	var to = &struct {
-		*Config
-		Path         string
-		LogDirectory string
-	}{
-		s.Config,
-		path,
-		s.Option.string(optionLogDirectory, defaultLogDirectory),
+	c := s.Config
+	data := map[string]any{
+		"Description":      c.Description,
+		"DisplayName":      c.DisplayName,
+		"Name":             c.Name,
+		"Path":             path,
+		"Arguments":        c.Arguments,
+		"WorkingDirectory": c.WorkingDirectory,
+		"LogDirectory":     s.Option.string(optionLogDirectory, defaultLogDirectory),
 	}
 
-	err = s.template().Execute(f, to)
+	t, err := s.template()
 	if err != nil {
 		return err
 	}
+	out, err := t.render(data, tfs)
+	if err != nil {
+		return err
+	}
+	if _, err = f.WriteString(out); err != nil {
+		return err
+	}
 
 	if err = os.Chmod(confPath, 0755); err != nil {
 		return err
@@ -216,25 +223,25 @@ func (s *rcs) Restart() error {
 const rcsScript = `#!/bin/sh
 # For RedHat and cousins:
 # chkconfig: - 99 01
-# description: {{.Description}}
-# processname: {{.Path}}
+# description: {{Description}}
+# processname: {{Path}}
 
 ### BEGIN INIT INFO
-# Provides:          {{.Path}}
+# Provides:          {{Path}}
 # Required-Start:
 # Required-Stop:
 # Default-Start:     2 3 4 5
 # Default-Stop:      0 1 6
-# Short-Description: {{.DisplayName}}
-# Description:       {{.Description}}
+# Short-Description: {{DisplayName}}
+# Description:       {{Description}}
 ### END INIT INFO
 
-cmd="{{.Path}}{{range .Arguments}} {{.|cmd}}{{end}}"
+cmd="{{Path}}{{range Arguments}} {{. | cmd}}{{end}}"
 
-name={{.Name}}
+name={{Name}}
 pid_file="/var/run/$name.pid"
-stdout_log="{{.LogDirectory}}/$name.log"
-stderr_log="{{.LogDirectory}}/$name.err"
+stdout_log="{{LogDirectory}}/$name.log"
+stderr_log="{{LogDirectory}}/$name.err"
 
 [ -e /etc/sysconfig/$name ] && . /etc/sysconfig/$name
 
@@ -252,7 +259,7 @@ case "$1" in
             echo "Already started"
         else
             echo "Starting $name"
-            {{if .WorkingDirectory}}cd '{{.WorkingDirectory}}'{{end}}
+            {{if WorkingDirectory}}cd '{{WorkingDirectory}}'{{end}}
             $cmd >> "$stdout_log" 2>> "$stderr_log" &
             echo $! > "$pid_file"
             if ! is_running; then
diff --git a/vendor/github.com/kardianos/service/service_solaris.go b/vendor/github.com/kardianos/service/service_solaris.go
index 55e0074062..96ac4513f9 100644
--- a/vendor/github.com/kardianos/service/service_solaris.go
+++ b/vendor/github.com/kardianos/service/service_solaris.go
@@ -12,7 +12,6 @@ import (
 	"os/signal"
 	"regexp"
 	"syscall"
-	"text/template"
 	"time"
 )
 
@@ -79,23 +78,13 @@ func (s *solarisService) Platform() string {
 	return version
 }
 
-func (s *solarisService) template() *template.Template {
-	functions := template.FuncMap{
-		"bool": func(v bool) string {
-			if v {
-				return "true"
-			}
-			return "false"
-		},
-	}
-
-	customConfig := s.Option.string(optionSysvScript, "")
+var manifestTemplate = mustParse(manifest)
 
-	if customConfig != "" {
-		return template.Must(template.New("").Funcs(functions).Parse(customConfig))
-	} else {
-		return template.Must(template.New("").Funcs(functions).Parse(manifest))
+func (s *solarisService) template() (*tmpl, error) {
+	if custom := s.Option.string(optionSysvScript, ""); custom != "" {
+		return parseTemplate(custom)
 	}
+	return manifestTemplate, nil
 }
 
 func (s *solarisService) configPath() (string, error) {
@@ -132,19 +121,22 @@ func (s *solarisService) Install() error {
 	if err := xml.EscapeText(escaped, []byte(s.DisplayName)); err == nil {
 		Display = escaped.String()
 	}
-	var to = &struct {
-		*Config
-		Prefix  string
-		Display string
-		Path    string
-	}{
-		s.Config,
-		s.Prefix,
-		Display,
-		path,
+	data := map[string]any{
+		"Name":    s.Config.Name,
+		"Prefix":  s.Prefix,
+		"Display": Display,
+		"Path":    path,
 	}
 
-	err = s.template().Execute(f, to)
+	t, err := s.template()
+	if err != nil {
+		return err
+	}
+	out, err := t.render(data, nil)
+	if err != nil {
+		return err
+	}
+	_, err = f.WriteString(out)
 	if err != nil {
 		return err
 	}
@@ -241,12 +233,12 @@ func (s *solarisService) SystemLogger(errs chan<- error) (Logger, error) {
 	return newSysLogger(s.Name, errs)
 }
 
-var manifest = `<?xml version="1.0"?>
+const manifest = `<?xml version="1.0"?>
 <!DOCTYPE service_bundle SYSTEM "/usr/share/lib/xml/dtd/service_bundle.dtd.1">
 
-<service_bundle type='manifest' name='golang-{{.Name}}'>
+<service_bundle type='manifest' name='golang-{{Name}}'>
 <service
-	name='{{.Prefix}}/{{.Name}}'
+	name='{{Prefix}}/{{Name}}'
 	type='service'
 	version='1'>
 	
@@ -278,13 +270,13 @@ var manifest = `<?xml version="1.0"?>
 	<exec_method
 		type='method'
 		name='start'
-		exec='bash -c {{.Path}} &amp;'
+		exec='bash -c {{Path}} &amp;'
 		timeout_seconds='10' />
 
 	<exec_method
 		type='method'
 		name='stop'
-		exec='pkill -TERM -f {{.Path}}'
+		exec='pkill -TERM -f {{Path}}'
 		timeout_seconds='60' />
 
 	<!--
@@ -298,7 +290,7 @@ var manifest = `<?xml version="1.0"?>
 	<template>
                 <common_name>
                         <loctext xml:lang='C'>
-                                {{.Display}}
+                                {{Display}}
                         </loctext>
                 </common_name>
         </template>
diff --git a/vendor/github.com/kardianos/service/service_systemd_linux.go b/vendor/github.com/kardianos/service/service_systemd_linux.go
index 6c21f29f17..a32d14ed8f 100644
--- a/vendor/github.com/kardianos/service/service_systemd_linux.go
+++ b/vendor/github.com/kardianos/service/service_systemd_linux.go
@@ -16,7 +16,6 @@ import (
 	"strconv"
 	"strings"
 	"syscall"
-	"text/template"
 )
 
 func isSystemd() bool {
@@ -130,13 +129,15 @@ func (s *systemd) hasOutputFileSupport() bool {
 	return defaultValue
 }
 
-func (s *systemd) template() *template.Template {
-	customScript := s.Option.string(optionSystemdScript, "")
+// systemdTemplate is the built-in template, parsed once at init and reused for
+// every install. A custom SystemdScript is parsed per install instead.
+var systemdTemplate = mustParse(systemdScript)
 
-	if customScript != "" {
-		return template.Must(template.New("").Funcs(tf).Parse(customScript))
+func (s *systemd) template() (*tmpl, error) {
+	if custom := s.Option.string(optionSystemdScript, ""); custom != "" {
+		return parseTemplate(custom)
 	}
-	return template.Must(template.New("").Funcs(tf).Parse(systemdScript))
+	return systemdTemplate, nil
 }
 
 func (s *systemd) isUserService() bool {
@@ -164,34 +165,52 @@ func (s *systemd) Install() error {
 		return err
 	}
 
-	var to = &struct {
-		*Config
-		Path                 string
-		HasOutputFileSupport bool
-		ReloadSignal         string
-		PIDFile              string
-		LimitNOFILE          int
-		Restart              string
-		SuccessExitStatus    string
-		LogOutput            bool
-		LogDirectory         string
-	}{
-		s.Config,
-		path,
-		s.hasOutputFileSupport(),
-		s.Option.string(optionReloadSignal, ""),
-		s.Option.string(optionPIDFile, ""),
-		s.Option.int(optionLimitNOFILE, optionLimitNOFILEDefault),
-		s.Option.string(optionRestart, "always"),
-		s.Option.string(optionSuccessExitStatus, ""),
-		s.Option.bool(optionLogOutput, optionLogOutputDefault),
-		s.Option.string(optionLogDirectory, defaultLogDirectory),
-	}
-
-	err = s.template().Execute(f, to)
+	c := s.Config
+
+	// Conditions that the mini engine cannot express (and/gt on non-string
+	// values) are collapsed here to a present-or-empty string, so the template
+	// only needs {{if Key}} truthiness. Everything else is passed through as a
+	// string or a []string for {{range}}.
+	outputFileSupport := ""
+	if s.Option.bool(optionLogOutput, optionLogOutputDefault) && s.hasOutputFileSupport() {
+		outputFileSupport = "yes"
+	}
+
+	limitNOFILE := ""
+	if n := s.Option.int(optionLimitNOFILE, optionLimitNOFILEDefault); n > -1 {
+		limitNOFILE = strconv.Itoa(n)
+	}
+
+	data := map[string]any{
+		"Description":       c.Description,
+		"Path":              path,
+		"Name":              c.Name,
+		"Dependencies":      c.Dependencies,
+		"Arguments":         c.Arguments,
+		"ChRoot":            c.ChRoot,
+		"WorkingDirectory":  c.WorkingDirectory,
+		"UserName":          c.UserName,
+		"ReloadSignal":      s.Option.string(optionReloadSignal, ""),
+		"PIDFile":           s.Option.string(optionPIDFile, ""),
+		"LogDirectory":      s.Option.string(optionLogDirectory, defaultLogDirectory),
+		"OutputFileSupport": outputFileSupport,
+		"LimitNOFILE":       limitNOFILE,
+		"Restart":           s.Option.string(optionRestart, "always"),
+		"SuccessExitStatus": s.Option.string(optionSuccessExitStatus, ""),
+		"EnvVars":           envVars(c.EnvVars, func(k, v string) string { return "Environment=" + k + "=" + v }),
+	}
+
+	t, err := s.template()
 	if err != nil {
 		return err
 	}
+	out, err := t.render(data, tfs)
+	if err != nil {
+		return err
+	}
+	if _, err = f.WriteString(out); err != nil {
+		return err
+	}
 
 	err = s.runAction("enable")
 	if err != nil {
@@ -301,35 +320,33 @@ func (s *systemd) runAction(action string) error {
 	return s.run(action, s.unitName())
 }
 
+// systemdScript is expanded by the mini template engine (renderTemplate).
+// {{if}}/{{range}} operate on plain string / []string values built in Install;
+// compound conditions such as "and .LogOutput .HasOutputFileSupport" or
+// "gt .LimitNOFILE -1" are precomputed there into a present-or-empty string.
 const systemdScript = `[Unit]
-Description={{.Description}}
-ConditionFileIsExecutable={{.Path|cmdEscape}}
-{{range $i, $dep := .Dependencies}} 
-{{$dep}} {{end}}
-
+Description={{Description}}
+ConditionFileIsExecutable={{Path | cmdEscape}}
+{{range Dependencies}}{{.}}
+{{end}}
 [Service]
 StartLimitInterval=5
 StartLimitBurst=10
-ExecStart={{.Path|cmdEscape}}{{range .Arguments}} {{.|cmd}}{{end}}
-{{if .ChRoot}}RootDirectory={{.ChRoot|cmd}}{{end}}
-{{if .WorkingDirectory}}WorkingDirectory={{.WorkingDirectory|cmdEscape}}{{end}}
-{{if .UserName}}User={{.UserName}}{{end}}
-{{if .ReloadSignal}}ExecReload=/bin/kill -{{.ReloadSignal}} "$MAINPID"{{end}}
-{{if .PIDFile}}PIDFile={{.PIDFile|cmd}}{{end}}
-{{if and .LogOutput .HasOutputFileSupport -}}
-StandardOutput=file:{{.LogDirectory}}/{{.Name}}.out
-StandardError=file:{{.LogDirectory}}/{{.Name}}.err
-{{- end}}
-{{if gt .LimitNOFILE -1 }}LimitNOFILE={{.LimitNOFILE}}{{end}}
-{{if .Restart}}Restart={{.Restart}}{{end}}
-{{if .SuccessExitStatus}}SuccessExitStatus={{.SuccessExitStatus}}{{end}}
-RestartSec=120
-EnvironmentFile=-/etc/sysconfig/{{.Name}}
-
-{{range $k, $v := .EnvVars -}}
-Environment={{$k}}={{$v}}
-{{end -}}
-
-[Install]
+ExecStart={{Path | cmdEscape}}{{range Arguments}} {{. | cmd}}{{end}}
+{{if ChRoot}}RootDirectory={{ChRoot | cmd}}
+{{end}}{{if WorkingDirectory}}WorkingDirectory={{WorkingDirectory | cmdEscape}}
+{{end}}{{if UserName}}User={{UserName}}
+{{end}}{{if ReloadSignal}}ExecReload=/bin/kill -{{ReloadSignal}} "$MAINPID"
+{{end}}{{if PIDFile}}PIDFile={{PIDFile | cmd}}
+{{end}}{{if OutputFileSupport}}StandardOutput=file:{{LogDirectory}}/{{Name}}.out
+StandardError=file:{{LogDirectory}}/{{Name}}.err
+{{end}}{{if LimitNOFILE}}LimitNOFILE={{LimitNOFILE}}
+{{end}}{{if Restart}}Restart={{Restart}}
+{{end}}{{if SuccessExitStatus}}SuccessExitStatus={{SuccessExitStatus}}
+{{end}}RestartSec=120
+EnvironmentFile=-/etc/sysconfig/{{Name}}
+
+{{range EnvVars}}{{.}}
+{{end}}[Install]
 WantedBy=multi-user.target
 `
diff --git a/vendor/github.com/kardianos/service/service_sysv_linux.go b/vendor/github.com/kardianos/service/service_sysv_linux.go
index 5a98a51476..2586f6741d 100644
--- a/vendor/github.com/kardianos/service/service_sysv_linux.go
+++ b/vendor/github.com/kardianos/service/service_sysv_linux.go
@@ -11,7 +11,6 @@ import (
 	"os/signal"
 	"strings"
 	"syscall"
-	"text/template"
 	"time"
 )
 
@@ -53,13 +52,13 @@ func (s *sysv) configPath() (cp string, err error) {
 	return
 }
 
-func (s *sysv) template() *template.Template {
-	customScript := s.Option.string(optionSysvScript, "")
+var sysvTemplate = mustParse(sysvScript)
 
-	if customScript != "" {
-		return template.Must(template.New("").Funcs(tf).Parse(customScript))
+func (s *sysv) template() (*tmpl, error) {
+	if custom := s.Option.string(optionSysvScript, ""); custom != "" {
+		return parseTemplate(custom)
 	}
-	return template.Must(template.New("").Funcs(tf).Parse(sysvScript))
+	return sysvTemplate, nil
 }
 
 func (s *sysv) Install() error {
@@ -83,20 +82,28 @@ func (s *sysv) Install() error {
 		return err
 	}
 
-	var to = &struct {
-		*Config
-		Path         string
-		LogDirectory string
-	}{
-		s.Config,
-		path,
-		s.Option.string(optionLogDirectory, defaultLogDirectory),
+	c := s.Config
+	data := map[string]any{
+		"Description":      c.Description,
+		"DisplayName":      c.DisplayName,
+		"Path":             path,
+		"Arguments":        c.Arguments,
+		"WorkingDirectory": c.WorkingDirectory,
+		"LogDirectory":     s.Option.string(optionLogDirectory, defaultLogDirectory),
+		"EnvVars":          envVars(c.EnvVars, func(k, v string) string { return "export " + k + "=" + v }),
 	}
 
-	err = s.template().Execute(f, to)
+	t, err := s.template()
 	if err != nil {
 		return err
 	}
+	out, err := t.render(data, tfs)
+	if err != nil {
+		return err
+	}
+	if _, err = f.WriteString(out); err != nil {
+		return err
+	}
 
 	if err = os.Chmod(confPath, 0755); err != nil {
 		return err
@@ -187,30 +194,28 @@ func (s *sysv) Restart() error {
 const sysvScript = `#!/bin/sh
 # For RedHat and cousins:
 # chkconfig: - 99 01
-# description: {{.Description}}
-# processname: {{.Path}}
+# description: {{Description}}
+# processname: {{Path}}
 
 ### BEGIN INIT INFO
-# Provides:          {{.Path}}
+# Provides:          {{Path}}
 # Required-Start:
 # Required-Stop:
 # Default-Start:     2 3 4 5
 # Default-Stop:      0 1 6
-# Short-Description: {{.DisplayName}}
-# Description:       {{.Description}}
+# Short-Description: {{DisplayName}}
+# Description:       {{Description}}
 ### END INIT INFO
 
-cmd="{{.Path}}{{range .Arguments}} {{.|cmd}}{{end}}"
+cmd="{{Path}}{{range Arguments}} {{. | cmd}}{{end}}"
 
 name=$(basename $(readlink -f $0))
 pid_file="/var/run/$name.pid"
-stdout_log="{{.LogDirectory}}/$name.log"
-stderr_log="{{.LogDirectory}}/$name.err"
-
-{{range $k, $v := .EnvVars -}}
-export {{$k}}={{$v}}
-{{end -}}
+stdout_log="{{LogDirectory}}/$name.log"
+stderr_log="{{LogDirectory}}/$name.err"
 
+{{range EnvVars}}{{.}}
+{{end}}
 [ -e /etc/sysconfig/$name ] && . /etc/sysconfig/$name
 
 get_pid() {
@@ -227,7 +232,7 @@ case "$1" in
             echo "Already started"
         else
             echo "Starting $name"
-            {{if .WorkingDirectory}}cd '{{.WorkingDirectory}}'{{end}}
+            {{if WorkingDirectory}}cd '{{WorkingDirectory}}'{{end}}
             $cmd >> "$stdout_log" 2>> "$stderr_log" &
             echo $! > "$pid_file"
             if ! is_running; then
diff --git a/vendor/github.com/kardianos/service/service_upstart_linux.go b/vendor/github.com/kardianos/service/service_upstart_linux.go
index 42b947cb7e..8045502c7b 100644
--- a/vendor/github.com/kardianos/service/service_upstart_linux.go
+++ b/vendor/github.com/kardianos/service/service_upstart_linux.go
@@ -12,7 +12,6 @@ import (
 	"regexp"
 	"strings"
 	"syscall"
-	"text/template"
 )
 
 func isUpstart() bool {
@@ -115,14 +114,13 @@ func (s *upstart) getUpstartVersion() []int {
 	return parseVersion(matches[1])
 }
 
-func (s *upstart) template() *template.Template {
-	customScript := s.Option.string(optionUpstartScript, "")
+var upstartTemplate = mustParse(upstartScript)
 
-	if customScript != "" {
-		return template.Must(template.New("").Funcs(tf).Parse(customScript))
-	} else {
-		return template.Must(template.New("").Funcs(tf).Parse(upstartScript))
+func (s *upstart) template() (*tmpl, error) {
+	if custom := s.Option.string(optionUpstartScript, ""); custom != "" {
+		return parseTemplate(custom)
 	}
+	return upstartTemplate, nil
 }
 
 func (s *upstart) Install() error {
@@ -146,23 +144,53 @@ func (s *upstart) Install() error {
 		return err
 	}
 
-	var to = &struct {
-		*Config
-		Path            string
-		HasKillStanza   bool
-		HasSetUIDStanza bool
-		LogOutput       bool
-		LogDirectory    string
-	}{
-		s.Config,
-		path,
-		s.hasKillStanza(),
-		s.hasSetUIDStanza(),
-		s.Option.bool(optionLogOutput, optionLogOutputDefault),
-		s.Option.string(optionLogDirectory, defaultLogDirectory),
+	c := s.Config
+
+	// Compound conditions the engine cannot express (and/not on UserName +
+	// HasSetUIDStanza) are collapsed here into ready-made strings.
+	setUID := ""
+	sudoPrefix := ""
+	if c.UserName != "" {
+		if s.hasSetUIDStanza() {
+			setUID = "setuid " + c.UserName
+		} else {
+			sudoPrefix = "sudo -E -u " + c.UserName + " "
+		}
+	}
+	killStanza := ""
+	if s.hasKillStanza() {
+		killStanza = "yes"
+	}
+	logOutput := ""
+	if s.Option.bool(optionLogOutput, optionLogOutputDefault) {
+		logOutput = "yes"
 	}
 
-	return s.template().Execute(f, to)
+	data := map[string]any{
+		"Description":      c.Description,
+		"DisplayName":      c.DisplayName,
+		"Name":             c.Name,
+		"Path":             path,
+		"Arguments":        c.Arguments,
+		"ChRoot":           c.ChRoot,
+		"WorkingDirectory": c.WorkingDirectory,
+		"LogDirectory":     s.Option.string(optionLogDirectory, defaultLogDirectory),
+		"KillStanza":       killStanza,
+		"LogOutput":        logOutput,
+		"SetUID":           setUID,
+		"SudoPrefix":       sudoPrefix,
+	}
+
+	t, err := s.template()
+	if err != nil {
+		return err
+	}
+	out, err := t.render(data, tfs)
+	if err != nil {
+		return err
+	}
+	_, err = f.WriteString(out)
+	return err
 }
 
 func (s *upstart) Uninstall() error {
@@ -231,17 +259,17 @@ func (s *upstart) Restart() error {
 
 // The upstart script should stop with an INT or the Go runtime will terminate
 // the program before the Stop handler can run.
-const upstartScript = `# {{.Description}}
+const upstartScript = `# {{Description}}
 
-{{if .DisplayName}}description    "{{.DisplayName}}"{{end}}
+{{if DisplayName}}description    "{{DisplayName}}"{{end}}
 
-{{if .HasKillStanza}}kill signal INT{{end}}
-{{if .ChRoot}}chroot {{.ChRoot}}{{end}}
-{{if .WorkingDirectory}}chdir {{.WorkingDirectory}}{{end}}
+{{if KillStanza}}kill signal INT{{end}}
+{{if ChRoot}}chroot {{ChRoot}}{{end}}
+{{if WorkingDirectory}}chdir {{WorkingDirectory}}{{end}}
 start on filesystem or runlevel [2345]
 stop on runlevel [!2345]
 
-{{if and .UserName .HasSetUIDStanza}}setuid {{.UserName}}{{end}}
+{{SetUID}}
 
 respawn
 respawn limit 10 5
@@ -250,22 +278,22 @@ umask 022
 console none
 
 pre-start script
-    test -x {{.Path}} || { stop; exit 0; }
+    test -x {{Path}} || { stop; exit 0; }
 end script
 
 # Start
 script
-	{{if .LogOutput}}
-	stdout_log="{{.LogDirectory}}/{{.Name}}.out"
-	stderr_log="{{.LogDirectory}}/{{.Name}}.err"
+	{{if LogOutput}}
+	stdout_log="{{LogDirectory}}/{{Name}}.out"
+	stderr_log="{{LogDirectory}}/{{Name}}.err"
 	{{end}}
-	
-	if [ -f "/etc/sysconfig/{{.Name}}" ]; then
+
+	if [ -f "/etc/sysconfig/{{Name}}" ]; then
 		set -a
-		source /etc/sysconfig/{{.Name}}
+		source /etc/sysconfig/{{Name}}
 		set +a
 	fi
 
-	exec {{if and .UserName (not .HasSetUIDStanza)}}sudo -E -u {{.UserName}} {{end}}{{.Path}}{{range .Arguments}} {{.|cmd}}{{end}}{{if .LogOutput}} >> $stdout_log 2>> $stderr_log{{end}}
+	exec {{SudoPrefix}}{{Path}}{{range Arguments}} {{. | cmd}}{{end}}{{if LogOutput}} >> $stdout_log 2>> $stderr_log{{end}}
 end script
 `
diff --git a/vendor/github.com/kardianos/service/template.go b/vendor/github.com/kardianos/service/template.go
new file mode 100644
index 0000000000..befbf1da41
--- /dev/null
+++ b/vendor/github.com/kardianos/service/template.go
@@ -0,0 +1,301 @@
+// Copyright 2015 Daniel Theophanes.
+// Use of this source code is governed by a zlib-style
+// license that can be found in the LICENSE file.
+
+package service
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+)
+
+// This is a deliberately small template engine used to render service files.
+// A template is parsed once into a tree of nodes and then executed by walking
+// that tree, so rendering scans nothing. A value is either a string or a
+// []string; a []string is iterable with {{range Key}}…{{end}} and is truthy
+// when non-empty.
+//
+// It exists to avoid text/template. text/template reaches
+// reflect.Value.MethodByName, which forces the Go linker into conservative
+// mode: it must then keep every exported method of every concrete type that
+// implements any interface used in the binary, defeating dead-code elimination
+// and inflating binaries that merely import this package (issue #418).
+
+// tmplFunc is the only function shape the engine supports: string in, string
+// out. Because every value is a string, functions are called directly and the
+// engine never needs reflection.
+type tmplFunc func(string) (string, error)
+
+type nodeKind uint8
+
+const (
+	nodeText  nodeKind = iota // literal text
+	nodeValue                 // {{ Key }}, {{ Key | fn | fn }}, or {{ . }}
+	nodeIf                    // {{ if Key }} body {{ else }} alt {{ end }}
+	nodeRange                 // {{ range Key }} body {{ end }}
+)
+
+// node is a single template operation. text holds literal text for nodeText or
+// the lookup key for the other kinds; body/alt hold nested nodes for the block
+// forms.
+type node struct {
+	kind  nodeKind
+	text  string
+	funcs []string // pipeline of function names (nodeValue only)
+	body  []node   // nodeIf / nodeRange body
+	alt   []node   // nodeIf else-branch
+}
+
+// tmpl is a parsed template. Parsing scans the source once; a tmpl can then be
+// rendered any number of times, so the constant service-file templates are
+// parsed a single time at package init and rendered per install.
+type tmpl struct {
+	nodes []node
+}
+
+// parseTemplate parses text into a reusable tmpl.
+func parseTemplate(text string) (*tmpl, error) {
+	nodes, _, _, _, err := parseNodes(text, false)
+	if err != nil {
+		return nil, err
+	}
+	return &tmpl{nodes: nodes}, nil
+}
+
+// mustParse is parseTemplate for the built-in templates, which are constants
+// and cannot fail at runtime. It panics on a malformed template, surfacing the
+// mistake at init time.
+func mustParse(text string) *tmpl {
+	t, err := parseTemplate(text)
+	if err != nil {
+		panic(err)
+	}
+	return t
+}
+
+// render executes the template against data and funcs. Each value in data is a
+// string or a []string; funcs supplies the string transforms usable in a
+// {{ Key | fn }} pipeline. render does not mutate the tmpl and is safe to call
+// repeatedly.
+func (t *tmpl) render(data map[string]any, funcs map[string]tmplFunc) (string, error) {
+	var b strings.Builder
+	if err := execNodes(&b, t.nodes, data, nil, funcs); err != nil {
+		return "", err
+	}
+	return b.String(), nil
+}
+
+// renderTemplate is a one-shot convenience that parses text and renders it
+// once. Prefer parseTemplate + (*tmpl).render when the same template is used
+// more than once.
+func renderTemplate(text string, data map[string]any, funcs map[string]tmplFunc) (string, error) {
+	t, err := parseTemplate(text)
+	if err != nil {
+		return "", err
+	}
+	return t.render(data, funcs)
+}
+
+// parseNodes parses src into nodes, stopping when it reaches one of the given
+// terminator keywords (used to bound if/range bodies). trimLeading requests
+// that leading whitespace of the first literal be trimmed (a {{... -}} carried
+// in from the caller). It returns the parsed nodes, the terminator that
+// stopped it ("" at end of input), the unparsed remainder of src, and whether
+// that terminator asked to trim the whitespace that follows it. This is the
+// only code that scans the template.
+func parseNodes(src string, trimLeading bool, terminators ...string) (nodes []node, term, rest string, trimNext bool, err error) {
+	for {
+		open := strings.Index(src, "{{")
+
+		lit := src
+		var action string
+		var haveAction, trimBefore, trimAfter bool
+		if open >= 0 {
+			close := strings.Index(src[open:], "}}")
+			if close < 0 {
+				return nil, "", "", false, fmt.Errorf(`service: unclosed "{{" in template`)
+			}
+			lit = src[:open]
+			action = src[open+2 : open+close]
+			src = src[open+close+2:]
+			haveAction = true
+
+			if strings.HasPrefix(action, "-") {
+				trimBefore, action = true, action[1:]
+			}
+			if strings.HasSuffix(action, "-") {
+				trimAfter, action = true, action[:len(action)-1]
+			}
+			action = strings.TrimSpace(action)
+		} else {
+			src = ""
+		}
+
+		if trimLeading {
+			lit = strings.TrimLeft(lit, " \t\r\n")
+		}
+		if trimBefore {
+			lit = strings.TrimRight(lit, " \t\r\n")
+		}
+		if lit != "" {
+			nodes = append(nodes, node{kind: nodeText, text: lit})
+		}
+		trimLeading = trimAfter
+
+		if !haveAction {
+			return nodes, "", "", false, nil
+		}
+
+		// Dispatch on the first word, delimited by a space or a pipe.
+		kw := action
+		if i := strings.IndexAny(action, " \t|"); i >= 0 {
+			kw = action[:i]
+		}
+		switch kw {
+		case "end", "else":
+			for _, t := range terminators {
+				if kw == t {
+					return nodes, kw, src, trimAfter, nil
+				}
+			}
+			return nil, "", "", false, fmt.Errorf("service: unexpected %q in template", kw)
+		case "if", "range":
+			key := strings.TrimSpace(action[len(kw):])
+			if key == "" {
+				return nil, "", "", false, fmt.Errorf("service: %q requires a key", kw)
+			}
+			n := node{kind: nodeIf, text: key}
+			var stop string
+			var tn bool
+			if kw == "range" {
+				n.kind = nodeRange
+				n.body, stop, src, tn, err = parseNodes(src, trimAfter, "end")
+			} else {
+				n.body, stop, src, tn, err = parseNodes(src, trimAfter, "else", "end")
+			}
+			if err != nil {
+				return nil, "", "", false, err
+			}
+			if stop == "else" {
+				if n.alt, _, src, tn, err = parseNodes(src, tn, "end"); err != nil {
+					return nil, "", "", false, err
+				}
+			}
+			trimLeading = tn
+			nodes = append(nodes, n)
+		default:
+			parts := strings.Split(action, "|")
+			n := node{kind: nodeValue, text: strings.TrimSpace(parts[0])}
+			for _, p := range parts[1:] {
+				n.funcs = append(n.funcs, strings.TrimSpace(p))
+			}
+			nodes = append(nodes, n)
+		}
+	}
+}
+
+// execNodes walks nodes, writing output to b. dot is the current element while
+// inside a range and is referenced as {{ . }}.
+func execNodes(b *strings.Builder, nodes []node, data map[string]any, dot any, funcs map[string]tmplFunc) error {
+	for i := range nodes {
+		n := &nodes[i]
+		switch n.kind {
+		case nodeText:
+			b.WriteString(n.text)
+		case nodeValue:
+			v, err := lookup(data, dot, n.text)
+			if err != nil {
+				return err
+			}
+			s, ok := v.(string)
+			if !ok {
+				return fmt.Errorf("service: template key %q is not a string", n.text)
+			}
+			for _, name := range n.funcs {
+				fn, ok := funcs[name]
+				if !ok {
+					return fmt.Errorf("service: unknown template function %q", name)
+				}
+				if s, err = fn(s); err != nil {
+					return err
+				}
+			}
+			b.WriteString(s)
+		case nodeIf:
+			v, err := lookup(data, dot, n.text)
+			if err != nil {
+				return err
+			}
+			if truthy(v) {
+				err = execNodes(b, n.body, data, dot, funcs)
+			} else {
+				err = execNodes(b, n.alt, data, dot, funcs)
+			}
+			if err != nil {
+				return err
+			}
+		case nodeRange:
+			v, err := lookup(data, dot, n.text)
+			if err != nil {
+				return err
+			}
+			items, ok := v.([]string)
+			if !ok {
+				return fmt.Errorf("service: template key %q is not a list", n.text)
+			}
+			for _, item := range items {
+				if err := execNodes(b, n.body, data, item, funcs); err != nil {
+					return err
+				}
+			}
+		}
+	}
+	return nil
+}
+
+// lookup resolves a key to its value. The special key "." is the current range
+// element.
+func lookup(data map[string]any, dot any, key string) (any, error) {
+	if key == "." {
+		return dot, nil
+	}
+	v, ok := data[key]
+	if !ok {
+		return nil, fmt.Errorf("service: unknown template key %q", key)
+	}
+	return v, nil
+}
+
+// envVars renders vars as a []string, one entry per key formatted by f, sorted
+// by key so the output is deterministic (text/template also ranged maps in
+// sorted key order). The result is meant to be iterated with {{range}}. It
+// returns nil when vars is empty. Each platform supplies its own f because the
+// per-entry syntax differs (Environment=, export, plist key/string, …).
+func envVars(vars map[string]string, f func(key, value string) string) []string {
+	if len(vars) == 0 {
+		return nil
+	}
+	keys := make([]string, 0, len(vars))
+	for k := range vars {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	out := make([]string, 0, len(keys))
+	for _, k := range keys {
+		out = append(out, f(k, vars[k]))
+	}
+	return out
+}
+
+// truthy reports whether v selects the {{if}} body: a non-empty string or a
+// non-empty list.
+func truthy(v any) bool {
+	switch t := v.(type) {
+	case string:
+		return t != ""
+	case []string:
+		return len(t) > 0
+	}
+	return false
+}
diff --git a/vendor/github.com/miekg/dns/.codecov.yml b/vendor/github.com/miekg/dns/.codecov.yml
deleted file mode 100644
index f91e5c1fe5..0000000000
--- a/vendor/github.com/miekg/dns/.codecov.yml
+++ /dev/null
@@ -1,8 +0,0 @@
-coverage:
-  status:
-    project:
-      default:
-        target: 40%
-        threshold: null
-    patch: false
-    changes: false
diff --git a/vendor/github.com/miekg/dns/.gitignore b/vendor/github.com/miekg/dns/.gitignore
deleted file mode 100644
index 776cd950c2..0000000000
--- a/vendor/github.com/miekg/dns/.gitignore
+++ /dev/null
@@ -1,4 +0,0 @@
-*.6
-tags
-test.out
-a.out
diff --git a/vendor/github.com/miekg/dns/AUTHORS b/vendor/github.com/miekg/dns/AUTHORS
deleted file mode 100644
index 1965683525..0000000000
--- a/vendor/github.com/miekg/dns/AUTHORS
+++ /dev/null
@@ -1 +0,0 @@
-Miek Gieben <miek@miek.nl>
diff --git a/vendor/github.com/miekg/dns/CODEOWNERS b/vendor/github.com/miekg/dns/CODEOWNERS
deleted file mode 100644
index e0917031bc..0000000000
--- a/vendor/github.com/miekg/dns/CODEOWNERS
+++ /dev/null
@@ -1 +0,0 @@
-* @miekg @tmthrgd
diff --git a/vendor/github.com/miekg/dns/CONTRIBUTORS b/vendor/github.com/miekg/dns/CONTRIBUTORS
deleted file mode 100644
index 5903779d81..0000000000
--- a/vendor/github.com/miekg/dns/CONTRIBUTORS
+++ /dev/null
@@ -1,10 +0,0 @@
-Alex A. Skinner
-Andrew Tunnell-Jones
-Ask Bjørn Hansen
-Dave Cheney
-Dusty Wilson
-Marek Majkowski
-Peter van Dijk
-Omri Bahumi
-Alex Sergeyev
-James Hartig
diff --git a/vendor/github.com/miekg/dns/COPYRIGHT b/vendor/github.com/miekg/dns/COPYRIGHT
deleted file mode 100644
index 35702b10e8..0000000000
--- a/vendor/github.com/miekg/dns/COPYRIGHT
+++ /dev/null
@@ -1,9 +0,0 @@
-Copyright 2009 The Go Authors. All rights reserved. Use of this source code
-is governed by a BSD-style license that can be found in the LICENSE file.
-Extensions of the original work are copyright (c) 2011 Miek Gieben
-
-Copyright 2011 Miek Gieben. All rights reserved. Use of this source code is
-governed by a BSD-style license that can be found in the LICENSE file.
-
-Copyright 2014 CloudFlare. All rights reserved. Use of this source code is
-governed by a BSD-style license that can be found in the LICENSE file.
diff --git a/vendor/github.com/miekg/dns/LICENSE b/vendor/github.com/miekg/dns/LICENSE
deleted file mode 100644
index 852ab9ced4..0000000000
--- a/vendor/github.com/miekg/dns/LICENSE
+++ /dev/null
@@ -1,29 +0,0 @@
-BSD 3-Clause License
-
-Copyright (c) 2009, The Go Authors. Extensions copyright (c) 2011, Miek Gieben. 
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its
-   contributors may be used to endorse or promote products derived from
-   this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/miekg/dns/Makefile.fuzz b/vendor/github.com/miekg/dns/Makefile.fuzz
deleted file mode 100644
index dc158c4ace..0000000000
--- a/vendor/github.com/miekg/dns/Makefile.fuzz
+++ /dev/null
@@ -1,33 +0,0 @@
-# Makefile for fuzzing
-#
-# Use go-fuzz and needs the tools installed.
-# See https://blog.cloudflare.com/dns-parser-meet-go-fuzzer/
-#
-# Installing go-fuzz:
-# $ make -f Makefile.fuzz get
-# Installs:
-# * github.com/dvyukov/go-fuzz/go-fuzz
-# * get github.com/dvyukov/go-fuzz/go-fuzz-build
-
-all: build
-
-.PHONY: build
-build:
-	go-fuzz-build -tags fuzz github.com/miekg/dns
-
-.PHONY: build-newrr
-build-newrr:
-	go-fuzz-build -func FuzzNewRR -tags fuzz github.com/miekg/dns
-
-.PHONY: fuzz
-fuzz:
-	go-fuzz -bin=dns-fuzz.zip -workdir=fuzz
-
-.PHONY: get
-get:
-	go get github.com/dvyukov/go-fuzz/go-fuzz
-	go get github.com/dvyukov/go-fuzz/go-fuzz-build
-
-.PHONY: clean
-clean:
-	rm *-fuzz.zip
diff --git a/vendor/github.com/miekg/dns/Makefile.release b/vendor/github.com/miekg/dns/Makefile.release
deleted file mode 100644
index a0ce9b712d..0000000000
--- a/vendor/github.com/miekg/dns/Makefile.release
+++ /dev/null
@@ -1,52 +0,0 @@
-# Makefile for releasing.
-#
-# The release is controlled from version.go. The version found there is
-# used to tag the git repo, we're not building any artifacts so there is nothing
-# to upload to github.
-#
-# * Up the version in version.go
-# * Run: make -f Makefile.release release
-#   * will *commit* your change with 'Release $VERSION'
-#   * push to github
-#
-
-define GO
-//+build ignore
-
-package main
-
-import (
-	"fmt"
-
-	"github.com/miekg/dns"
-)
-
-func main() {
-	fmt.Println(dns.Version.String())
-}
-endef
-
-$(file > version_release.go,$(GO))
-VERSION:=$(shell go run version_release.go)
-TAG="v$(VERSION)"
-
-all:
-	@echo Use the \'release\' target to start a release $(VERSION)
-	rm -f version_release.go
-
-.PHONY: release
-release: commit push
-	@echo Released $(VERSION)
-	rm -f version_release.go
-
-.PHONY: commit
-commit:
-	@echo Committing release $(VERSION)
-	git commit -am"Release $(VERSION)"
-	git tag $(TAG)
-
-.PHONY: push
-push:
-	@echo Pushing release $(VERSION) to master
-	git push --tags
-	git push
diff --git a/vendor/github.com/miekg/dns/README.md b/vendor/github.com/miekg/dns/README.md
deleted file mode 100644
index 8dc2472360..0000000000
--- a/vendor/github.com/miekg/dns/README.md
+++ /dev/null
@@ -1,219 +0,0 @@
-[![Build Status](https://travis-ci.org/miekg/dns.svg?branch=master)](https://travis-ci.org/miekg/dns)
-[![Code Coverage](https://img.shields.io/codecov/c/github/miekg/dns/master.svg)](https://codecov.io/github/miekg/dns?branch=master)
-[![Go Report Card](https://goreportcard.com/badge/github.com/miekg/dns)](https://goreportcard.com/report/miekg/dns)
-[![](https://godoc.org/github.com/miekg/dns?status.svg)](https://godoc.org/github.com/miekg/dns)
-
-DNS version 2 is now available at <https://codeberg.org/miekg/dns>, check it out if you want to
-help shape the next 15 years of the Go DNS package.
-
-The version here will see no new features and less and less development, and my time (if any) will be fully
-devoted towards v2.
-
-**December 2025**: v2 should be (already) a good replacement, the coming months would be a good time to
-migrate, see [this file describing the
-differences](https://codeberg.org/miekg/dns/src/branch/main/README-diff-with-v1.md), to help you get started.
-
-# Alternative (more granular) approach to a DNS library
-
-> Less is more.
-
-Complete and usable DNS library. All Resource Records are supported, including the DNSSEC types.
-It follows a lean and mean philosophy. If there is stuff you should know as a DNS programmer there
-isn't a convenience function for it. Server side and client side programming is supported, i.e. you
-can build servers and resolvers with it.
-
-We try to keep the "master" branch as sane as possible and at the bleeding edge of standards,
-avoiding breaking changes wherever reasonable. We support the last two versions of Go.
-
-# Goals
-
-- KISS;
-- Fast;
-- Small API. If it's easy to code in Go, don't make a function for it.
-
-# Users
-
-A not-so-up-to-date-list-that-may-be-actually-current:
-
-- https://github.com/coredns/coredns
-- https://github.com/abh/geodns
-- https://github.com/baidu/bfe
-- http://www.statdns.com/
-- http://www.dnsinspect.com/
-- https://github.com/chuangbo/jianbing-dictionary-dns
-- http://www.dns-lg.com/
-- https://github.com/fcambus/rrda
-- https://github.com/kenshinx/godns
-- https://github.com/skynetservices/skydns
-- https://github.com/hashicorp/consul
-- https://github.com/DevelopersPL/godnsagent
-- https://github.com/duedil-ltd/discodns
-- https://github.com/StalkR/dns-reverse-proxy
-- https://github.com/tianon/rawdns
-- https://mesosphere.github.io/mesos-dns/
-- https://github.com/fcambus/statzone
-- https://github.com/benschw/dns-clb-go
-- https://github.com/corny/dnscheck for <http://public-dns.info/>
-- https://github.com/miekg/unbound
-- https://github.com/miekg/exdns
-- https://dnslookup.org
-- https://github.com/looterz/grimd
-- https://github.com/phamhongviet/serf-dns
-- https://github.com/mehrdadrad/mylg
-- https://github.com/bamarni/dockness
-- https://github.com/fffaraz/microdns
-- https://github.com/ipdcode/hades <https://jd.com>
-- https://github.com/StackExchange/dnscontrol/
-- https://www.dnsperf.com/
-- https://dnssectest.net/
-- https://github.com/oif/apex
-- https://github.com/jedisct1/dnscrypt-proxy (migrated to v2)
-- https://github.com/jedisct1/rpdns
-- https://github.com/xor-gate/sshfp
-- https://github.com/rs/dnstrace
-- https://blitiri.com.ar/p/dnss ([github mirror](https://github.com/albertito/dnss))
-- https://render.com
-- https://github.com/peterzen/goresolver
-- https://github.com/folbricht/routedns
-- https://domainr.com/
-- https://zonedb.org/
-- https://router7.org/
-- https://github.com/fortio/dnsping
-- https://github.com/Luzilla/dnsbl_exporter
-- https://github.com/bodgit/tsig
-- https://github.com/v2fly/v2ray-core (test only)
-- https://kuma.io/
-- https://www.misaka.io/services/dns
-- https://ping.sx/dig
-- https://fleetdeck.io/
-- https://github.com/markdingo/autoreverse
-- https://github.com/slackhq/nebula
-- https://addr.tools/
-- https://dnscheck.tools/
-- https://github.com/egbakou/domainverifier
-- https://github.com/semihalev/sdns
-- https://github.com/wintbiit/NineDNS
-- https://linuxcontainers.org/incus/
-- https://ifconfig.es
-- https://github.com/zmap/zdns
-- https://framagit.org/bortzmeyer/check-soa
-- https://github.com/jkerdreux-imt/owns
-
-Send pull request if you want to be listed here.
-
-# Features
-
-- UDP/TCP queries, IPv4 and IPv6
-- RFC 1035 zone file parsing ($INCLUDE, $ORIGIN, $TTL and $GENERATE (for all record types) are supported
-- Fast
-- Server side programming (mimicking the net/http package)
-- Client side programming
-- DNSSEC: signing, validating and key generation for DSA, RSA, ECDSA and Ed25519
-- EDNS0, NSID, Cookies
-- AXFR/IXFR
-- TSIG, SIG(0)
-- DNS over TLS (DoT): encrypted connection between client and server over TCP
-- DNS name compression
-
-Have fun!
-
-Miek Gieben - 2010-2012 - <miek@miek.nl>
-DNS Authors 2012-
-
-# Building
-
-This library uses Go modules and uses semantic versioning. Building is done with the `go` tool, so
-the following should work:
-
-    go get github.com/miekg/dns
-    go build github.com/miekg/dns
-
-## Examples
-
-A short "how to use the API" is at the beginning of doc.go (this also will show when you call `godoc
-github.com/miekg/dns`).
-
-Example programs can be found in the `github.com/miekg/exdns` repository.
-
-## Supported RFCs
-
-_all of them_
-
-- 103{4,5} - DNS standard
-- 1183 - ISDN, X25 and other deprecated records
-- 1348 - NSAP record (removed the record)
-- 1982 - Serial Arithmetic
-- 1876 - LOC record
-- 1995 - IXFR
-- 1996 - DNS notify
-- 2136 - DNS Update (dynamic updates)
-- 2181 - RRset definition - there is no RRset type though, just []RR
-- 2537 - RSAMD5 DNS keys
-- 2065 - DNSSEC (updated in later RFCs)
-- 2671 - EDNS record
-- 2782 - SRV record
-- 2845 - TSIG record
-- 2915 - NAPTR record
-- 2929 - DNS IANA Considerations
-- 3110 - RSASHA1 DNS keys
-- 3123 - APL record
-- 3225 - DO bit (DNSSEC OK)
-- 340{1,2,3} - NAPTR record
-- 3445 - Limiting the scope of (DNS)KEY
-- 3596 - AAAA record
-- 3597 - Unknown RRs
-- 4025 - A Method for Storing IPsec Keying Material in DNS
-- 403{3,4,5} - DNSSEC + validation functions
-- 4255 - SSHFP record
-- 4343 - Case insensitivity
-- 4408 - SPF record
-- 4509 - SHA256 Hash in DS
-- 4592 - Wildcards in the DNS
-- 4635 - HMAC SHA TSIG
-- 4701 - DHCID
-- 4892 - id.server
-- 5001 - NSID
-- 5155 - NSEC3 record
-- 5205 - HIP record
-- 5702 - SHA2 in the DNS
-- 5936 - AXFR
-- 5966 - TCP implementation recommendations
-- 6605 - ECDSA
-- 6725 - IANA Registry Update
-- 6742 - ILNP DNS
-- 6840 - Clarifications and Implementation Notes for DNS Security
-- 6844 - CAA record
-- 6891 - EDNS0 update
-- 6895 - DNS IANA considerations
-- 6944 - DNSSEC DNSKEY Algorithm Status
-- 6975 - Algorithm Understanding in DNSSEC
-- 7043 - EUI48/EUI64 records
-- 7314 - DNS (EDNS) EXPIRE Option
-- 7477 - CSYNC RR
-- 7828 - edns-tcp-keepalive EDNS0 Option
-- 7553 - URI record
-- 7858 - DNS over TLS: Initiation and Performance Considerations
-- 7871 - EDNS0 Client Subnet
-- 7873 - Domain Name System (DNS) Cookies
-- 8080 - EdDSA for DNSSEC
-- 8490 - DNS Stateful Operations
-- 8499 - DNS Terminology
-- 8659 - DNS Certification Authority Authorization (CAA) Resource Record
-- 8777 - DNS Reverse IP Automatic Multicast Tunneling (AMT) Discovery
-- 8914 - Extended DNS Errors
-- 8976 - Message Digest for DNS Zones (ZONEMD RR)
-- 9460 - Service Binding and Parameter Specification via the DNS
-- 9461 - Service Binding Mapping for DNS Servers
-- 9462 - Discovery of Designated Resolvers
-- 9460 - SVCB and HTTPS Records
-- 9567 - DNS Error Reporting
-- 9606 - DNS Resolver Information
-- 9660 - DNS Zone Version (ZONEVERSION) Option
-- Draft - Compact Denial of Existence in DNSSEC
-
-## Loosely Based Upon
-
-- ldns - <https://nlnetlabs.nl/projects/ldns/about/>
-- NSD - <https://nlnetlabs.nl/projects/nsd/about/>
-- Net::DNS - <http://www.net-dns.org/>
-- GRONG - <https://github.com/bortzmeyer/grong>
diff --git a/vendor/github.com/miekg/dns/acceptfunc.go b/vendor/github.com/miekg/dns/acceptfunc.go
deleted file mode 100644
index 1a59a854ec..0000000000
--- a/vendor/github.com/miekg/dns/acceptfunc.go
+++ /dev/null
@@ -1,59 +0,0 @@
-package dns
-
-// MsgAcceptFunc is used early in the server code to accept or reject a message with RcodeFormatError.
-// It returns a MsgAcceptAction to indicate what should happen with the message.
-type MsgAcceptFunc func(dh Header) MsgAcceptAction
-
-// DefaultMsgAcceptFunc checks the request and will reject if:
-//
-// * isn't a request (don't respond in that case)
-//
-// * opcode isn't OpcodeQuery or OpcodeNotify
-//
-// * does not have exactly 1 question in the question section
-//
-// * has more than 1 RR in the Answer section
-//
-// * has more than 0 RRs in the Authority section
-//
-// * has more than 2 RRs in the Additional section
-var DefaultMsgAcceptFunc MsgAcceptFunc = defaultMsgAcceptFunc
-
-// MsgAcceptAction represents the action to be taken.
-type MsgAcceptAction int
-
-// Allowed returned values from a MsgAcceptFunc.
-const (
-	MsgAccept               MsgAcceptAction = iota // Accept the message
-	MsgReject                                      // Reject the message with a RcodeFormatError
-	MsgIgnore                                      // Ignore the error and send nothing back.
-	MsgRejectNotImplemented                        // Reject the message with a RcodeNotImplemented
-)
-
-func defaultMsgAcceptFunc(dh Header) MsgAcceptAction {
-	if isResponse := dh.Bits&_QR != 0; isResponse {
-		return MsgIgnore
-	}
-
-	// Don't allow dynamic updates, because then the sections can contain a whole bunch of RRs.
-	opcode := int(dh.Bits>>11) & 0xF
-	if opcode != OpcodeQuery && opcode != OpcodeNotify {
-		return MsgRejectNotImplemented
-	}
-
-	if dh.Qdcount != 1 {
-		return MsgReject
-	}
-	// NOTIFY requests can have a SOA in the ANSWER section. See RFC 1996 Section 3.7 and 3.11.
-	if dh.Ancount > 1 {
-		return MsgReject
-	}
-	// IXFR request could have one SOA RR in the NS section. See RFC 1995, section 3.
-	if dh.Nscount > 1 {
-		return MsgReject
-	}
-	if dh.Arcount > 2 {
-		return MsgReject
-	}
-	return MsgAccept
-}
diff --git a/vendor/github.com/miekg/dns/client.go b/vendor/github.com/miekg/dns/client.go
deleted file mode 100644
index a0f96187b4..0000000000
--- a/vendor/github.com/miekg/dns/client.go
+++ /dev/null
@@ -1,469 +0,0 @@
-package dns
-
-// A client implementation.
-
-import (
-	"context"
-	"crypto/tls"
-	"encoding/binary"
-	"io"
-	"net"
-	"strings"
-	"time"
-)
-
-const (
-	dnsTimeout     time.Duration = 2 * time.Second
-	tcpIdleTimeout time.Duration = 8 * time.Second
-)
-
-func isPacketConn(c net.Conn) bool {
-	if _, ok := c.(net.PacketConn); !ok {
-		return false
-	}
-
-	if ua, ok := c.LocalAddr().(*net.UnixAddr); ok {
-		return ua.Net == "unixgram" || ua.Net == "unixpacket"
-	}
-
-	return true
-}
-
-// A Conn represents a connection to a DNS server.
-type Conn struct {
-	net.Conn                         // a net.Conn holding the connection
-	UDPSize        uint16            // minimum receive buffer for UDP messages
-	TsigSecret     map[string]string // secret(s) for Tsig map[<zonename>]<base64 secret>, zonename must be in canonical form (lowercase, fqdn, see RFC 4034 Section 6.2)
-	TsigProvider   TsigProvider      // An implementation of the TsigProvider interface. If defined it replaces TsigSecret and is used for all TSIG operations.
-	tsigRequestMAC string
-}
-
-func (co *Conn) tsigProvider() TsigProvider {
-	if co.TsigProvider != nil {
-		return co.TsigProvider
-	}
-	// tsigSecretProvider will return ErrSecret if co.TsigSecret is nil.
-	return tsigSecretProvider(co.TsigSecret)
-}
-
-// A Client defines parameters for a DNS client.
-type Client struct {
-	Net       string      // if "tcp" or "tcp-tls" (DNS over TLS) a TCP query will be initiated, otherwise an UDP one (default is "" for UDP)
-	UDPSize   uint16      // minimum receive buffer for UDP messages
-	TLSConfig *tls.Config // TLS connection configuration
-	Dialer    *net.Dialer // a net.Dialer used to set local address, timeouts and more
-	// Timeout is a cumulative timeout for dial, write and read, defaults to 0 (disabled) - overrides DialTimeout, ReadTimeout,
-	// WriteTimeout when non-zero. Can be overridden with net.Dialer.Timeout (see Client.ExchangeWithDialer and
-	// Client.Dialer) or context.Context.Deadline (see ExchangeContext)
-	Timeout      time.Duration
-	DialTimeout  time.Duration     // net.DialTimeout, defaults to 2 seconds, or net.Dialer.Timeout if expiring earlier - overridden by Timeout when that value is non-zero
-	ReadTimeout  time.Duration     // net.Conn.SetReadDeadline value for connections, defaults to 2 seconds - overridden by Timeout when that value is non-zero
-	WriteTimeout time.Duration     // net.Conn.SetWriteDeadline value for connections, defaults to 2 seconds - overridden by Timeout when that value is non-zero
-	TsigSecret   map[string]string // secret(s) for Tsig map[<zonename>]<base64 secret>, zonename must be in canonical form (lowercase, fqdn, see RFC 4034 Section 6.2)
-	TsigProvider TsigProvider      // An implementation of the TsigProvider interface. If defined it replaces TsigSecret and is used for all TSIG operations.
-
-	// SingleInflight previously serialised multiple concurrent queries for the
-	// same Qname, Qtype and Qclass to ensure only one would be in flight at a
-	// time.
-	//
-	// Deprecated: This is a no-op. Callers should implement their own in flight
-	// query caching if needed. See github.com/miekg/dns/issues/1449.
-	SingleInflight bool
-}
-
-// Exchange performs a synchronous UDP query. It sends the message m to the address
-// contained in a and waits for a reply. Exchange does not retry a failed query, nor
-// will it fall back to TCP in case of truncation.
-// See client.Exchange for more information on setting larger buffer sizes.
-func Exchange(m *Msg, a string) (r *Msg, err error) {
-	client := Client{Net: "udp"}
-	r, _, err = client.Exchange(m, a)
-	return r, err
-}
-
-func (c *Client) dialTimeout() time.Duration {
-	if c.Timeout != 0 {
-		return c.Timeout
-	}
-	if c.DialTimeout != 0 {
-		return c.DialTimeout
-	}
-	return dnsTimeout
-}
-
-func (c *Client) readTimeout() time.Duration {
-	if c.Timeout != 0 {
-		return c.Timeout
-	}
-	if c.ReadTimeout != 0 {
-		return c.ReadTimeout
-	}
-	return dnsTimeout
-}
-
-func (c *Client) writeTimeout() time.Duration {
-	if c.Timeout != 0 {
-		return c.Timeout
-	}
-	if c.WriteTimeout != 0 {
-		return c.WriteTimeout
-	}
-	return dnsTimeout
-}
-
-// Dial connects to the address on the named network.
-func (c *Client) Dial(address string) (conn *Conn, err error) {
-	return c.DialContext(context.Background(), address)
-}
-
-// DialContext connects to the address on the named network, with a context.Context.
-func (c *Client) DialContext(ctx context.Context, address string) (conn *Conn, err error) {
-	// create a new dialer with the appropriate timeout
-	var d net.Dialer
-	if c.Dialer == nil {
-		d = net.Dialer{Timeout: c.getTimeoutForRequest(c.dialTimeout())}
-	} else {
-		d = *c.Dialer
-	}
-
-	network := c.Net
-	if network == "" {
-		network = "udp"
-	}
-
-	useTLS := strings.HasPrefix(network, "tcp") && strings.HasSuffix(network, "-tls")
-
-	conn = new(Conn)
-	if useTLS {
-		network = strings.TrimSuffix(network, "-tls")
-
-		tlsDialer := tls.Dialer{
-			NetDialer: &d,
-			Config:    c.TLSConfig,
-		}
-		conn.Conn, err = tlsDialer.DialContext(ctx, network, address)
-	} else {
-		conn.Conn, err = d.DialContext(ctx, network, address)
-	}
-	if err != nil {
-		return nil, err
-	}
-	conn.UDPSize = c.UDPSize
-	return conn, nil
-}
-
-// Exchange performs a synchronous query. It sends the message m to the address
-// contained in a and waits for a reply. Basic use pattern with a *dns.Client:
-//
-//	c := new(dns.Client)
-//	in, rtt, err := c.Exchange(message, "127.0.0.1:53")
-//
-// Exchange does not retry a failed query, nor will it fall back to TCP in
-// case of truncation.
-// It is up to the caller to create a message that allows for larger responses to be
-// returned. Specifically this means adding an EDNS0 OPT RR that will advertise a larger
-// buffer, see SetEdns0. Messages without an OPT RR will fallback to the historic limit
-// of 512 bytes
-// To specify a local address or a timeout, the caller has to set the `Client.Dialer`
-// attribute appropriately
-func (c *Client) Exchange(m *Msg, address string) (r *Msg, rtt time.Duration, err error) {
-	co, err := c.Dial(address)
-
-	if err != nil {
-		return nil, 0, err
-	}
-	defer co.Close()
-	return c.ExchangeWithConn(m, co)
-}
-
-// ExchangeWithConn has the same behavior as Exchange, just with a predetermined connection
-// that will be used instead of creating a new one.
-// Usage pattern with a *dns.Client:
-//
-//	c := new(dns.Client)
-//	// connection management logic goes here
-//
-//	conn := c.Dial(address)
-//	in, rtt, err := c.ExchangeWithConn(message, conn)
-//
-// This allows users of the library to implement their own connection management,
-// as opposed to Exchange, which will always use new connections and incur the added overhead
-// that entails when using "tcp" and especially "tcp-tls" clients.
-func (c *Client) ExchangeWithConn(m *Msg, conn *Conn) (r *Msg, rtt time.Duration, err error) {
-	return c.ExchangeWithConnContext(context.Background(), m, conn)
-}
-
-// ExchangeWithConnContext has the same behaviour as ExchangeWithConn and
-// additionally obeys deadlines from the passed Context.
-func (c *Client) ExchangeWithConnContext(ctx context.Context, m *Msg, co *Conn) (r *Msg, rtt time.Duration, err error) {
-	opt := m.IsEdns0()
-	// If EDNS0 is used use that for size.
-	if opt != nil && opt.UDPSize() >= MinMsgSize {
-		co.UDPSize = opt.UDPSize()
-	}
-	// Otherwise use the client's configured UDP size.
-	if opt == nil && c.UDPSize >= MinMsgSize {
-		co.UDPSize = c.UDPSize
-	}
-
-	// write with the appropriate write timeout
-	t := time.Now()
-	writeDeadline := t.Add(c.getTimeoutForRequest(c.writeTimeout()))
-	readDeadline := t.Add(c.getTimeoutForRequest(c.readTimeout()))
-	if deadline, ok := ctx.Deadline(); ok {
-		if deadline.Before(writeDeadline) {
-			writeDeadline = deadline
-		}
-		if deadline.Before(readDeadline) {
-			readDeadline = deadline
-		}
-	}
-	co.SetWriteDeadline(writeDeadline)
-	co.SetReadDeadline(readDeadline)
-
-	co.TsigSecret, co.TsigProvider = c.TsigSecret, c.TsigProvider
-
-	if err = co.WriteMsg(m); err != nil {
-		return nil, 0, err
-	}
-
-	if isPacketConn(co.Conn) {
-		for {
-			r, err = co.ReadMsg()
-			// Ignore replies with mismatched IDs because they might be
-			// responses to earlier queries that timed out.
-			if err != nil || r.Id == m.Id {
-				break
-			}
-		}
-	} else {
-		r, err = co.ReadMsg()
-		if err == nil && r.Id != m.Id {
-			err = ErrId
-		}
-	}
-	rtt = time.Since(t)
-	return r, rtt, err
-}
-
-// ReadMsg reads a message from the connection co.
-// If the received message contains a TSIG record the transaction signature
-// is verified. This method always tries to return the message, however if an
-// error is returned there are no guarantees that the returned message is a
-// valid representation of the packet read.
-func (co *Conn) ReadMsg() (*Msg, error) {
-	p, err := co.ReadMsgHeader(nil)
-	if err != nil {
-		return nil, err
-	}
-
-	m := new(Msg)
-	if err := m.Unpack(p); err != nil {
-		// If an error was returned, we still want to allow the user to use
-		// the message, but naively they can just check err if they don't want
-		// to use an erroneous message
-		return m, err
-	}
-	if t := m.IsTsig(); t != nil {
-		// Need to work on the original message p, as that was used to calculate the tsig.
-		err = TsigVerifyWithProvider(p, co.tsigProvider(), co.tsigRequestMAC, false)
-	}
-	return m, err
-}
-
-// ReadMsgHeader reads a DNS message, parses and populates hdr (when hdr is not nil).
-// Returns message as a byte slice to be parsed with Msg.Unpack later on.
-// Note that error handling on the message body is not possible as only the header is parsed.
-func (co *Conn) ReadMsgHeader(hdr *Header) ([]byte, error) {
-	var (
-		p   []byte
-		n   int
-		err error
-	)
-
-	if isPacketConn(co.Conn) {
-		if co.UDPSize > MinMsgSize {
-			p = make([]byte, co.UDPSize)
-		} else {
-			p = make([]byte, MinMsgSize)
-		}
-		n, err = co.Read(p)
-	} else {
-		var length uint16
-		if err := binary.Read(co.Conn, binary.BigEndian, &length); err != nil {
-			return nil, err
-		}
-
-		p = make([]byte, length)
-		n, err = io.ReadFull(co.Conn, p)
-	}
-
-	if err != nil {
-		return nil, err
-	} else if n < headerSize {
-		return nil, ErrShortRead
-	}
-
-	p = p[:n]
-	if hdr != nil {
-		dh, _, err := unpackMsgHdr(p, 0)
-		if err != nil {
-			return nil, err
-		}
-		*hdr = dh
-	}
-	return p, err
-}
-
-// Read implements the net.Conn read method.
-func (co *Conn) Read(p []byte) (n int, err error) {
-	if co.Conn == nil {
-		return 0, ErrConnEmpty
-	}
-
-	if isPacketConn(co.Conn) {
-		// UDP connection
-		return co.Conn.Read(p)
-	}
-
-	var length uint16
-	if err := binary.Read(co.Conn, binary.BigEndian, &length); err != nil {
-		return 0, err
-	}
-	if int(length) > len(p) {
-		return 0, io.ErrShortBuffer
-	}
-
-	return io.ReadFull(co.Conn, p[:length])
-}
-
-// WriteMsg sends a message through the connection co.
-// If the message m contains a TSIG record the transaction
-// signature is calculated.
-func (co *Conn) WriteMsg(m *Msg) (err error) {
-	var out []byte
-	if t := m.IsTsig(); t != nil {
-		// Set tsigRequestMAC for the next read, although only used in zone transfers.
-		out, co.tsigRequestMAC, err = TsigGenerateWithProvider(m, co.tsigProvider(), co.tsigRequestMAC, false)
-	} else {
-		out, err = m.Pack()
-	}
-	if err != nil {
-		return err
-	}
-	_, err = co.Write(out)
-	return err
-}
-
-// Write implements the net.Conn Write method.
-func (co *Conn) Write(p []byte) (int, error) {
-	if len(p) > MaxMsgSize {
-		return 0, &Error{err: "message too large"}
-	}
-
-	if isPacketConn(co.Conn) {
-		return co.Conn.Write(p)
-	}
-
-	msg := make([]byte, 2+len(p))
-	binary.BigEndian.PutUint16(msg, uint16(len(p)))
-	copy(msg[2:], p)
-	return co.Conn.Write(msg)
-}
-
-// Return the appropriate timeout for a specific request
-func (c *Client) getTimeoutForRequest(timeout time.Duration) time.Duration {
-	var requestTimeout time.Duration
-	if c.Timeout != 0 {
-		requestTimeout = c.Timeout
-	} else {
-		requestTimeout = timeout
-	}
-	// net.Dialer.Timeout has priority if smaller than the timeouts computed so
-	// far
-	if c.Dialer != nil && c.Dialer.Timeout != 0 {
-		if c.Dialer.Timeout < requestTimeout {
-			requestTimeout = c.Dialer.Timeout
-		}
-	}
-	return requestTimeout
-}
-
-// Dial connects to the address on the named network.
-func Dial(network, address string) (conn *Conn, err error) {
-	conn = new(Conn)
-	conn.Conn, err = net.Dial(network, address)
-	if err != nil {
-		return nil, err
-	}
-	return conn, nil
-}
-
-// ExchangeContext performs a synchronous UDP query, like Exchange. It
-// additionally obeys deadlines from the passed Context.
-func ExchangeContext(ctx context.Context, m *Msg, a string) (r *Msg, err error) {
-	client := Client{Net: "udp"}
-	r, _, err = client.ExchangeContext(ctx, m, a)
-	// ignoring rtt to leave the original ExchangeContext API unchanged, but
-	// this function will go away
-	return r, err
-}
-
-// ExchangeConn performs a synchronous query. It sends the message m via the connection
-// c and waits for a reply. The connection c is not closed by ExchangeConn.
-// Deprecated: This function is going away, but can easily be mimicked:
-//
-//	co := &dns.Conn{Conn: c} // c is your net.Conn
-//	co.WriteMsg(m)
-//	in, _  := co.ReadMsg()
-//	co.Close()
-func ExchangeConn(c net.Conn, m *Msg) (r *Msg, err error) {
-	println("dns: ExchangeConn: this function is deprecated")
-	co := new(Conn)
-	co.Conn = c
-	if err = co.WriteMsg(m); err != nil {
-		return nil, err
-	}
-	r, err = co.ReadMsg()
-	if err == nil && r.Id != m.Id {
-		err = ErrId
-	}
-	return r, err
-}
-
-// DialTimeout acts like Dial but takes a timeout.
-func DialTimeout(network, address string, timeout time.Duration) (conn *Conn, err error) {
-	client := Client{Net: network, Dialer: &net.Dialer{Timeout: timeout}}
-	return client.Dial(address)
-}
-
-// DialWithTLS connects to the address on the named network with TLS.
-func DialWithTLS(network, address string, tlsConfig *tls.Config) (conn *Conn, err error) {
-	if !strings.HasSuffix(network, "-tls") {
-		network += "-tls"
-	}
-	client := Client{Net: network, TLSConfig: tlsConfig}
-	return client.Dial(address)
-}
-
-// DialTimeoutWithTLS acts like DialWithTLS but takes a timeout.
-func DialTimeoutWithTLS(network, address string, tlsConfig *tls.Config, timeout time.Duration) (conn *Conn, err error) {
-	if !strings.HasSuffix(network, "-tls") {
-		network += "-tls"
-	}
-	client := Client{Net: network, Dialer: &net.Dialer{Timeout: timeout}, TLSConfig: tlsConfig}
-	return client.Dial(address)
-}
-
-// ExchangeContext acts like Exchange, but honors the deadline on the provided
-// context, if present. If there is both a context deadline and a configured
-// timeout on the client, the earliest of the two takes effect.
-func (c *Client) ExchangeContext(ctx context.Context, m *Msg, a string) (r *Msg, rtt time.Duration, err error) {
-	conn, err := c.DialContext(ctx, a)
-	if err != nil {
-		return nil, 0, err
-	}
-	defer conn.Close()
-
-	return c.ExchangeWithConnContext(ctx, m, conn)
-}
diff --git a/vendor/github.com/miekg/dns/clientconfig.go b/vendor/github.com/miekg/dns/clientconfig.go
deleted file mode 100644
index d00ac62fb6..0000000000
--- a/vendor/github.com/miekg/dns/clientconfig.go
+++ /dev/null
@@ -1,135 +0,0 @@
-package dns
-
-import (
-	"bufio"
-	"io"
-	"os"
-	"strconv"
-	"strings"
-)
-
-// ClientConfig wraps the contents of the /etc/resolv.conf file.
-type ClientConfig struct {
-	Servers  []string // servers to use
-	Search   []string // suffixes to append to local name
-	Port     string   // what port to use
-	Ndots    int      // number of dots in name to trigger absolute lookup
-	Timeout  int      // seconds before giving up on packet
-	Attempts int      // lost packets before giving up on server, not used in the package dns
-}
-
-// ClientConfigFromFile parses a resolv.conf(5) like file and returns
-// a *ClientConfig.
-func ClientConfigFromFile(resolvconf string) (*ClientConfig, error) {
-	file, err := os.Open(resolvconf)
-	if err != nil {
-		return nil, err
-	}
-	defer file.Close()
-	return ClientConfigFromReader(file)
-}
-
-// ClientConfigFromReader works like ClientConfigFromFile but takes an io.Reader as argument
-func ClientConfigFromReader(resolvconf io.Reader) (*ClientConfig, error) {
-	c := new(ClientConfig)
-	scanner := bufio.NewScanner(resolvconf)
-	c.Servers = make([]string, 0)
-	c.Search = make([]string, 0)
-	c.Port = "53"
-	c.Ndots = 1
-	c.Timeout = 5
-	c.Attempts = 2
-
-	for scanner.Scan() {
-		if err := scanner.Err(); err != nil {
-			return nil, err
-		}
-		line := scanner.Text()
-		f := strings.Fields(line)
-		if len(f) < 1 {
-			continue
-		}
-		switch f[0] {
-		case "nameserver": // add one name server
-			if len(f) > 1 {
-				// One more check: make sure server name is
-				// just an IP address.  Otherwise we need DNS
-				// to look it up.
-				name := f[1]
-				c.Servers = append(c.Servers, name)
-			}
-
-		case "domain": // set search path to just this domain
-			if len(f) > 1 {
-				c.Search = make([]string, 1)
-				c.Search[0] = f[1]
-			} else {
-				c.Search = make([]string, 0)
-			}
-
-		case "search": // set search path to given servers
-			c.Search = cloneSlice(f[1:])
-
-		case "options": // magic options
-			for _, s := range f[1:] {
-				switch {
-				case len(s) >= 6 && s[:6] == "ndots:":
-					n, _ := strconv.Atoi(s[6:])
-					if n < 0 {
-						n = 0
-					} else if n > 15 {
-						n = 15
-					}
-					c.Ndots = n
-				case len(s) >= 8 && s[:8] == "timeout:":
-					n, _ := strconv.Atoi(s[8:])
-					if n < 1 {
-						n = 1
-					}
-					c.Timeout = n
-				case len(s) >= 9 && s[:9] == "attempts:":
-					n, _ := strconv.Atoi(s[9:])
-					if n < 1 {
-						n = 1
-					}
-					c.Attempts = n
-				case s == "rotate":
-					/* not imp */
-				}
-			}
-		}
-	}
-	return c, nil
-}
-
-// NameList returns all of the names that should be queried based on the
-// config. It is based off of go's net/dns name building, but it does not
-// check the length of the resulting names.
-func (c *ClientConfig) NameList(name string) []string {
-	// if this domain is already fully qualified, no append needed.
-	if IsFqdn(name) {
-		return []string{name}
-	}
-
-	// Check to see if the name has more labels than Ndots. Do this before making
-	// the domain fully qualified.
-	hasNdots := CountLabel(name) > c.Ndots
-	// Make the domain fully qualified.
-	name = Fqdn(name)
-
-	// Make a list of names based off search.
-	names := []string{}
-
-	// If name has enough dots, try that first.
-	if hasNdots {
-		names = append(names, name)
-	}
-	for _, s := range c.Search {
-		names = append(names, Fqdn(name+s))
-	}
-	// If we didn't have enough dots, try after suffixes.
-	if !hasNdots {
-		names = append(names, name)
-	}
-	return names
-}
diff --git a/vendor/github.com/miekg/dns/dane.go b/vendor/github.com/miekg/dns/dane.go
deleted file mode 100644
index 8c4a14ef19..0000000000
--- a/vendor/github.com/miekg/dns/dane.go
+++ /dev/null
@@ -1,43 +0,0 @@
-package dns
-
-import (
-	"crypto/sha256"
-	"crypto/sha512"
-	"crypto/x509"
-	"encoding/hex"
-	"errors"
-)
-
-// CertificateToDANE converts a certificate to a hex string as used in the TLSA or SMIMEA records.
-func CertificateToDANE(selector, matchingType uint8, cert *x509.Certificate) (string, error) {
-	switch matchingType {
-	case 0:
-		switch selector {
-		case 0:
-			return hex.EncodeToString(cert.Raw), nil
-		case 1:
-			return hex.EncodeToString(cert.RawSubjectPublicKeyInfo), nil
-		}
-	case 1:
-		h := sha256.New()
-		switch selector {
-		case 0:
-			h.Write(cert.Raw)
-			return hex.EncodeToString(h.Sum(nil)), nil
-		case 1:
-			h.Write(cert.RawSubjectPublicKeyInfo)
-			return hex.EncodeToString(h.Sum(nil)), nil
-		}
-	case 2:
-		h := sha512.New()
-		switch selector {
-		case 0:
-			h.Write(cert.Raw)
-			return hex.EncodeToString(h.Sum(nil)), nil
-		case 1:
-			h.Write(cert.RawSubjectPublicKeyInfo)
-			return hex.EncodeToString(h.Sum(nil)), nil
-		}
-	}
-	return "", errors.New("dns: bad MatchingType or Selector")
-}
diff --git a/vendor/github.com/miekg/dns/defaults.go b/vendor/github.com/miekg/dns/defaults.go
deleted file mode 100644
index 68e766c689..0000000000
--- a/vendor/github.com/miekg/dns/defaults.go
+++ /dev/null
@@ -1,396 +0,0 @@
-package dns
-
-import (
-	"errors"
-	"net"
-	"strconv"
-	"strings"
-)
-
-const hexDigit = "0123456789abcdef"
-
-// Everything is assumed in ClassINET.
-
-// SetReply creates a reply message from a request message.
-func (dns *Msg) SetReply(request *Msg) *Msg {
-	dns.Id = request.Id
-	dns.Response = true
-	dns.Opcode = request.Opcode
-	if dns.Opcode == OpcodeQuery {
-		dns.RecursionDesired = request.RecursionDesired // Copy rd bit
-		dns.CheckingDisabled = request.CheckingDisabled // Copy cd bit
-	}
-	dns.Rcode = RcodeSuccess
-	if len(request.Question) > 0 {
-		dns.Question = []Question{request.Question[0]}
-	}
-	return dns
-}
-
-// SetQuestion creates a question message, it sets the Question
-// section, generates an Id and sets the RecursionDesired (RD)
-// bit to true.
-func (dns *Msg) SetQuestion(z string, t uint16) *Msg {
-	dns.Id = Id()
-	dns.RecursionDesired = true
-	dns.Question = make([]Question, 1)
-	dns.Question[0] = Question{z, t, ClassINET}
-	return dns
-}
-
-// SetNotify creates a notify message, it sets the Question
-// section, generates an Id and sets the Authoritative (AA)
-// bit to true.
-func (dns *Msg) SetNotify(z string) *Msg {
-	dns.Opcode = OpcodeNotify
-	dns.Authoritative = true
-	dns.Id = Id()
-	dns.Question = make([]Question, 1)
-	dns.Question[0] = Question{z, TypeSOA, ClassINET}
-	return dns
-}
-
-// SetRcode creates an error message suitable for the request.
-func (dns *Msg) SetRcode(request *Msg, rcode int) *Msg {
-	dns.SetReply(request)
-	dns.Rcode = rcode
-	return dns
-}
-
-// SetRcodeFormatError creates a message with FormError set.
-func (dns *Msg) SetRcodeFormatError(request *Msg) *Msg {
-	dns.Rcode = RcodeFormatError
-	dns.Opcode = OpcodeQuery
-	dns.Response = true
-	dns.Authoritative = false
-	dns.Id = request.Id
-	return dns
-}
-
-// SetUpdate makes the message a dynamic update message. It
-// sets the ZONE section to: z, TypeSOA, ClassINET.
-func (dns *Msg) SetUpdate(z string) *Msg {
-	dns.Id = Id()
-	dns.Response = false
-	dns.Opcode = OpcodeUpdate
-	dns.Compress = false // BIND9 cannot handle compression
-	dns.Question = make([]Question, 1)
-	dns.Question[0] = Question{z, TypeSOA, ClassINET}
-	return dns
-}
-
-// SetIxfr creates message for requesting an IXFR.
-func (dns *Msg) SetIxfr(z string, serial uint32, ns, mbox string) *Msg {
-	dns.Id = Id()
-	dns.Question = make([]Question, 1)
-	dns.Ns = make([]RR, 1)
-	s := new(SOA)
-	s.Hdr = RR_Header{z, TypeSOA, ClassINET, defaultTtl, 0}
-	s.Serial = serial
-	s.Ns = ns
-	s.Mbox = mbox
-	dns.Question[0] = Question{z, TypeIXFR, ClassINET}
-	dns.Ns[0] = s
-	return dns
-}
-
-// SetAxfr creates message for requesting an AXFR.
-func (dns *Msg) SetAxfr(z string) *Msg {
-	dns.Id = Id()
-	dns.Question = make([]Question, 1)
-	dns.Question[0] = Question{z, TypeAXFR, ClassINET}
-	return dns
-}
-
-// SetTsig appends a TSIG RR to the message.
-// This is only a skeleton TSIG RR that is added as the last RR in the
-// additional section. The TSIG is calculated when the message is being send.
-func (dns *Msg) SetTsig(z, algo string, fudge uint16, timesigned int64) *Msg {
-	t := new(TSIG)
-	t.Hdr = RR_Header{z, TypeTSIG, ClassANY, 0, 0}
-	t.Algorithm = algo
-	t.Fudge = fudge
-	t.TimeSigned = uint64(timesigned)
-	t.OrigId = dns.Id
-	dns.Extra = append(dns.Extra, t)
-	return dns
-}
-
-// SetEdns0 appends a EDNS0 OPT RR to the message.
-// TSIG should always the last RR in a message.
-func (dns *Msg) SetEdns0(udpsize uint16, do bool) *Msg {
-	e := new(OPT)
-	e.Hdr.Name = "."
-	e.Hdr.Rrtype = TypeOPT
-	e.SetUDPSize(udpsize)
-	if do {
-		e.SetDo()
-	}
-	dns.Extra = append(dns.Extra, e)
-	return dns
-}
-
-// IsTsig checks if the message has a TSIG record as the last record
-// in the additional section. It returns the TSIG record found or nil.
-func (dns *Msg) IsTsig() *TSIG {
-	if len(dns.Extra) > 0 {
-		if dns.Extra[len(dns.Extra)-1].Header().Rrtype == TypeTSIG {
-			return dns.Extra[len(dns.Extra)-1].(*TSIG)
-		}
-	}
-	return nil
-}
-
-// IsEdns0 checks if the message has a EDNS0 (OPT) record, any EDNS0
-// record in the additional section will do. It returns the OPT record
-// found or nil.
-func (dns *Msg) IsEdns0() *OPT {
-	// RFC 6891, Section 6.1.1 allows the OPT record to appear
-	// anywhere in the additional record section, but it's usually at
-	// the end so start there.
-	for i := len(dns.Extra) - 1; i >= 0; i-- {
-		if dns.Extra[i].Header().Rrtype == TypeOPT {
-			return dns.Extra[i].(*OPT)
-		}
-	}
-	return nil
-}
-
-// popEdns0 is like IsEdns0, but it removes the record from the message.
-func (dns *Msg) popEdns0() *OPT {
-	// RFC 6891, Section 6.1.1 allows the OPT record to appear
-	// anywhere in the additional record section, but it's usually at
-	// the end so start there.
-	for i := len(dns.Extra) - 1; i >= 0; i-- {
-		if dns.Extra[i].Header().Rrtype == TypeOPT {
-			opt := dns.Extra[i].(*OPT)
-			dns.Extra = append(dns.Extra[:i], dns.Extra[i+1:]...)
-			return opt
-		}
-	}
-	return nil
-}
-
-// IsDomainName checks if s is a valid domain name, it returns the number of
-// labels and true, when a domain name is valid.  Note that non fully qualified
-// domain name is considered valid, in this case the last label is counted in
-// the number of labels.  When false is returned the number of labels is not
-// defined.  Also note that this function is extremely liberal; almost any
-// string is a valid domain name as the DNS is 8 bit protocol. It checks if each
-// label fits in 63 characters and that the entire name will fit into the 255
-// octet wire format limit.
-func IsDomainName(s string) (labels int, ok bool) {
-	// XXX: The logic in this function was copied from packDomainName and
-	// should be kept in sync with that function.
-
-	const lenmsg = 256
-
-	if len(s) == 0 { // Ok, for instance when dealing with update RR without any rdata.
-		return 0, false
-	}
-
-	s = Fqdn(s)
-
-	// Each dot ends a segment of the name. Except for escaped dots (\.), which
-	// are normal dots.
-
-	var (
-		off    int
-		begin  int
-		wasDot bool
-		escape bool
-	)
-	for i := 0; i < len(s); i++ {
-		switch s[i] {
-		case '\\':
-			escape = !escape
-			if off+1 > lenmsg {
-				return labels, false
-			}
-
-			// check for \DDD
-			if isDDD(s[i+1:]) {
-				i += 3
-				begin += 3
-			} else {
-				i++
-				begin++
-			}
-
-			wasDot = false
-		case '.':
-			escape = false
-			if i == 0 && len(s) > 1 {
-				// leading dots are not legal except for the root zone
-				return labels, false
-			}
-
-			if wasDot {
-				// two dots back to back is not legal
-				return labels, false
-			}
-			wasDot = true
-
-			labelLen := i - begin
-			if labelLen >= 1<<6 { // top two bits of length must be clear
-				return labels, false
-			}
-
-			// off can already (we're in a loop) be bigger than lenmsg
-			// this happens when a name isn't fully qualified
-			off += 1 + labelLen
-			if off > lenmsg {
-				return labels, false
-			}
-
-			labels++
-			begin = i + 1
-		default:
-			escape = false
-			wasDot = false
-		}
-	}
-	if escape {
-		return labels, false
-	}
-	return labels, true
-}
-
-// IsSubDomain checks if child is indeed a child of the parent. If child and parent
-// are the same domain true is returned as well.
-func IsSubDomain(parent, child string) bool {
-	// Entire child is contained in parent
-	return CompareDomainName(parent, child) == CountLabel(parent)
-}
-
-// IsMsg sanity checks buf and returns an error if it isn't a valid DNS packet.
-// The checking is performed on the binary payload.
-func IsMsg(buf []byte) error {
-	// Header
-	if len(buf) < headerSize {
-		return errors.New("dns: bad message header")
-	}
-	// Header: Opcode
-	// TODO(miek): more checks here, e.g. check all header bits.
-	return nil
-}
-
-// IsFqdn checks if a domain name is fully qualified.
-func IsFqdn(s string) bool {
-	// Check for (and remove) a trailing dot, returning if there isn't one.
-	if s == "" || s[len(s)-1] != '.' {
-		return false
-	}
-	s = s[:len(s)-1]
-
-	// If we don't have an escape sequence before the final dot, we know it's
-	// fully qualified and can return here.
-	if s == "" || s[len(s)-1] != '\\' {
-		return true
-	}
-
-	// Otherwise we have to check if the dot is escaped or not by checking if
-	// there are an odd or even number of escape sequences before the dot.
-	i := strings.LastIndexFunc(s, func(r rune) bool {
-		return r != '\\'
-	})
-	return (len(s)-i)%2 != 0
-}
-
-// IsRRset reports whether a set of RRs is a valid RRset as defined by RFC 2181.
-// This means the RRs need to have the same type, name, and class.
-func IsRRset(rrset []RR) bool {
-	if len(rrset) == 0 {
-		return false
-	}
-
-	baseH := rrset[0].Header()
-	for _, rr := range rrset[1:] {
-		curH := rr.Header()
-		if curH.Rrtype != baseH.Rrtype || curH.Class != baseH.Class || curH.Name != baseH.Name {
-			// Mismatch between the records, so this is not a valid rrset for
-			// signing/verifying
-			return false
-		}
-	}
-
-	return true
-}
-
-// Fqdn return the fully qualified domain name from s.
-// If s is already fully qualified, it behaves as the identity function.
-func Fqdn(s string) string {
-	if IsFqdn(s) {
-		return s
-	}
-	return s + "."
-}
-
-// CanonicalName returns the domain name in canonical form. A name in canonical
-// form is lowercase and fully qualified. Only US-ASCII letters are affected. See
-// Section 6.2 in RFC 4034.
-func CanonicalName(s string) string {
-	return strings.Map(func(r rune) rune {
-		if r >= 'A' && r <= 'Z' {
-			r += 'a' - 'A'
-		}
-		return r
-	}, Fqdn(s))
-}
-
-// Copied from the official Go code.
-
-// ReverseAddr returns the in-addr.arpa. or ip6.arpa. hostname of the IP
-// address suitable for reverse DNS (PTR) record lookups or an error if it fails
-// to parse the IP address.
-func ReverseAddr(addr string) (arpa string, err error) {
-	ip := net.ParseIP(addr)
-	if ip == nil {
-		return "", &Error{err: "unrecognized address: " + addr}
-	}
-	if v4 := ip.To4(); v4 != nil {
-		buf := make([]byte, 0, net.IPv4len*4+len("in-addr.arpa."))
-		// Add it, in reverse, to the buffer
-		for i := len(v4) - 1; i >= 0; i-- {
-			buf = strconv.AppendInt(buf, int64(v4[i]), 10)
-			buf = append(buf, '.')
-		}
-		// Append "in-addr.arpa." and return (buf already has the final .)
-		buf = append(buf, "in-addr.arpa."...)
-		return string(buf), nil
-	}
-	// Must be IPv6
-	buf := make([]byte, 0, net.IPv6len*4+len("ip6.arpa."))
-	// Add it, in reverse, to the buffer
-	for i := len(ip) - 1; i >= 0; i-- {
-		v := ip[i]
-		buf = append(buf, hexDigit[v&0xF], '.', hexDigit[v>>4], '.')
-	}
-	// Append "ip6.arpa." and return (buf already has the final .)
-	buf = append(buf, "ip6.arpa."...)
-	return string(buf), nil
-}
-
-// String returns the string representation for the type t.
-func (t Type) String() string {
-	if t1, ok := TypeToString[uint16(t)]; ok {
-		return t1
-	}
-	return "TYPE" + strconv.Itoa(int(t))
-}
-
-// String returns the string representation for the class c.
-func (c Class) String() string {
-	if s, ok := ClassToString[uint16(c)]; ok {
-		// Only emit mnemonics when they are unambiguous, specially ANY is in both.
-		if _, ok := StringToType[s]; !ok {
-			return s
-		}
-	}
-	return "CLASS" + strconv.Itoa(int(c))
-}
-
-// String returns the string representation for the name n.
-func (n Name) String() string {
-	return sprintName(string(n))
-}
diff --git a/vendor/github.com/miekg/dns/dns.go b/vendor/github.com/miekg/dns/dns.go
deleted file mode 100644
index a88484b062..0000000000
--- a/vendor/github.com/miekg/dns/dns.go
+++ /dev/null
@@ -1,158 +0,0 @@
-package dns
-
-import (
-	"encoding/hex"
-	"strconv"
-)
-
-const (
-	year68     = 1 << 31 // For RFC1982 (Serial Arithmetic) calculations in 32 bits.
-	defaultTtl = 3600    // Default internal TTL.
-
-	// DefaultMsgSize is the standard default for messages larger than 512 bytes.
-	DefaultMsgSize = 4096
-	// MinMsgSize is the minimal size of a DNS packet.
-	MinMsgSize = 512
-	// MaxMsgSize is the largest possible DNS packet.
-	MaxMsgSize = 65535
-)
-
-// Error represents a DNS error.
-type Error struct{ err string }
-
-func (e *Error) Error() string {
-	if e == nil {
-		return "dns: <nil>"
-	}
-	return "dns: " + e.err
-}
-
-// An RR represents a resource record.
-type RR interface {
-	// Header returns the header of an resource record. The header contains
-	// everything up to the rdata.
-	Header() *RR_Header
-	// String returns the text representation of the resource record.
-	String() string
-
-	// copy returns a copy of the RR
-	copy() RR
-
-	// len returns the length (in octets) of the compressed or uncompressed RR in wire format.
-	//
-	// If compression is nil, the uncompressed size will be returned, otherwise the compressed
-	// size will be returned and domain names will be added to the map for future compression.
-	len(off int, compression map[string]struct{}) int
-
-	// pack packs the records RDATA into wire format. The header will
-	// already have been packed into msg.
-	pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error)
-
-	// unpack unpacks an RR from wire format.
-	//
-	// This will only be called on a new and empty RR type with only the header populated. It
-	// will only be called if the record's RDATA is non-empty.
-	unpack(msg []byte, off int) (off1 int, err error)
-
-	// parse parses an RR from zone file format.
-	//
-	// This will only be called on a new and empty RR type with only the header populated.
-	parse(c *zlexer, origin string) *ParseError
-
-	// isDuplicate returns whether the two RRs are duplicates.
-	isDuplicate(r2 RR) bool
-}
-
-// RR_Header is the header all DNS resource records share.
-type RR_Header struct {
-	Name     string `dns:"cdomain-name"`
-	Rrtype   uint16
-	Class    uint16
-	Ttl      uint32
-	Rdlength uint16 // Length of data after header.
-}
-
-// Header returns itself. This is here to make RR_Header implements the RR interface.
-func (h *RR_Header) Header() *RR_Header { return h }
-
-// Just to implement the RR interface.
-func (h *RR_Header) copy() RR { return nil }
-
-func (h *RR_Header) String() string {
-	var s string
-
-	if h.Rrtype == TypeOPT {
-		s = ";"
-		// and maybe other things
-	}
-
-	s += sprintName(h.Name) + "\t"
-	s += strconv.FormatInt(int64(h.Ttl), 10) + "\t"
-	s += Class(h.Class).String() + "\t"
-	s += Type(h.Rrtype).String() + "\t"
-	return s
-}
-
-func (h *RR_Header) len(off int, compression map[string]struct{}) int {
-	l := domainNameLen(h.Name, off, compression, true)
-	l += 10 // rrtype(2) + class(2) + ttl(4) + rdlength(2)
-	return l
-}
-
-func (h *RR_Header) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	// RR_Header has no RDATA to pack.
-	return off, nil
-}
-
-func (h *RR_Header) unpack(msg []byte, off int) (int, error) {
-	panic("dns: internal error: unpack should never be called on RR_Header")
-}
-
-func (h *RR_Header) parse(c *zlexer, origin string) *ParseError {
-	panic("dns: internal error: parse should never be called on RR_Header")
-}
-
-// ToRFC3597 converts a known RR to the unknown RR representation from RFC 3597.
-func (rr *RFC3597) ToRFC3597(r RR) error {
-	buf := make([]byte, Len(r))
-	headerEnd, off, err := packRR(r, buf, 0, compressionMap{}, false)
-	if err != nil {
-		return err
-	}
-	buf = buf[:off]
-
-	*rr = RFC3597{Hdr: *r.Header()}
-	rr.Hdr.Rdlength = uint16(off - headerEnd)
-
-	if noRdata(rr.Hdr) {
-		return nil
-	}
-
-	_, err = rr.unpack(buf, headerEnd)
-	return err
-}
-
-// fromRFC3597 converts an unknown RR representation from RFC 3597 to the known RR type.
-func (rr *RFC3597) fromRFC3597(r RR) error {
-	hdr := r.Header()
-	*hdr = rr.Hdr
-
-	// Can't overflow uint16 as the length of Rdata is validated in (*RFC3597).parse.
-	// We can only get here when rr was constructed with that method.
-	hdr.Rdlength = uint16(hex.DecodedLen(len(rr.Rdata)))
-
-	if noRdata(*hdr) {
-		// Dynamic update.
-		return nil
-	}
-
-	// rr.pack requires an extra allocation and a copy so we just decode Rdata
-	// manually, it's simpler anyway.
-	msg, err := hex.DecodeString(rr.Rdata)
-	if err != nil {
-		return err
-	}
-
-	_, err = r.unpack(msg, 0)
-	return err
-}
diff --git a/vendor/github.com/miekg/dns/dnssec.go b/vendor/github.com/miekg/dns/dnssec.go
deleted file mode 100644
index ffdafcebda..0000000000
--- a/vendor/github.com/miekg/dns/dnssec.go
+++ /dev/null
@@ -1,761 +0,0 @@
-package dns
-
-import (
-	"bytes"
-	"crypto"
-	"crypto/ecdsa"
-	"crypto/ed25519"
-	"crypto/elliptic"
-	"crypto/rand"
-	"crypto/rsa"
-	_ "crypto/sha1"   // need its init function
-	_ "crypto/sha256" // need its init function
-	_ "crypto/sha512" // need its init function
-	"encoding/asn1"
-	"encoding/binary"
-	"encoding/hex"
-	"math/big"
-	"sort"
-	"strings"
-	"time"
-)
-
-// DNSSEC encryption algorithm codes.
-const (
-	_ uint8 = iota
-	RSAMD5
-	DH
-	DSA
-	_ // Skip 4, RFC 6725, section 2.1
-	RSASHA1
-	DSANSEC3SHA1
-	RSASHA1NSEC3SHA1
-	RSASHA256
-	_ // Skip 9, RFC 6725, section 2.1
-	RSASHA512
-	_ // Skip 11, RFC 6725, section 2.1
-	ECCGOST
-	ECDSAP256SHA256
-	ECDSAP384SHA384
-	ED25519
-	ED448
-	INDIRECT   uint8 = 252
-	PRIVATEDNS uint8 = 253 // Private (experimental keys)
-	PRIVATEOID uint8 = 254
-)
-
-// AlgorithmToString is a map of algorithm IDs to algorithm names.
-var AlgorithmToString = map[uint8]string{
-	RSAMD5:           "RSAMD5",
-	DH:               "DH",
-	DSA:              "DSA",
-	RSASHA1:          "RSASHA1",
-	DSANSEC3SHA1:     "DSA-NSEC3-SHA1",
-	RSASHA1NSEC3SHA1: "RSASHA1-NSEC3-SHA1",
-	RSASHA256:        "RSASHA256",
-	RSASHA512:        "RSASHA512",
-	ECCGOST:          "ECC-GOST",
-	ECDSAP256SHA256:  "ECDSAP256SHA256",
-	ECDSAP384SHA384:  "ECDSAP384SHA384",
-	ED25519:          "ED25519",
-	ED448:            "ED448",
-	INDIRECT:         "INDIRECT",
-	PRIVATEDNS:       "PRIVATEDNS",
-	PRIVATEOID:       "PRIVATEOID",
-}
-
-// AlgorithmToHash is a map of algorithm crypto hash IDs to crypto.Hash's.
-// For newer algorithm that do their own hashing (i.e. ED25519) the returned value
-// is 0, implying no (external) hashing should occur. The non-exported identityHash is then
-// used.
-var AlgorithmToHash = map[uint8]crypto.Hash{
-	RSAMD5:           crypto.MD5, // Deprecated in RFC 6725
-	DSA:              crypto.SHA1,
-	RSASHA1:          crypto.SHA1,
-	RSASHA1NSEC3SHA1: crypto.SHA1,
-	RSASHA256:        crypto.SHA256,
-	ECDSAP256SHA256:  crypto.SHA256,
-	ECDSAP384SHA384:  crypto.SHA384,
-	RSASHA512:        crypto.SHA512,
-	ED25519:          0,
-}
-
-// DNSSEC hashing algorithm codes.
-const (
-	_      uint8 = iota
-	SHA1         // RFC 4034
-	SHA256       // RFC 4509
-	GOST94       // RFC 5933
-	SHA384       // Experimental
-	SHA512       // Experimental
-)
-
-// HashToString is a map of hash IDs to names.
-var HashToString = map[uint8]string{
-	SHA1:   "SHA1",
-	SHA256: "SHA256",
-	GOST94: "GOST94",
-	SHA384: "SHA384",
-	SHA512: "SHA512",
-}
-
-// DNSKEY flag values.
-const (
-	SEP    = 1
-	REVOKE = 1 << 7
-	ZONE   = 1 << 8
-)
-
-// The RRSIG needs to be converted to wireformat with some of the rdata (the signature) missing.
-type rrsigWireFmt struct {
-	TypeCovered uint16
-	Algorithm   uint8
-	Labels      uint8
-	OrigTtl     uint32
-	Expiration  uint32
-	Inception   uint32
-	KeyTag      uint16
-	SignerName  string `dns:"domain-name"`
-	/* No Signature */
-}
-
-// Used for converting DNSKEY's rdata to wirefmt.
-type dnskeyWireFmt struct {
-	Flags     uint16
-	Protocol  uint8
-	Algorithm uint8
-	PublicKey string `dns:"base64"`
-	/* Nothing is left out */
-}
-
-// KeyTag calculates the keytag (or key-id) of the DNSKEY.
-func (k *DNSKEY) KeyTag() uint16 {
-	if k == nil {
-		return 0
-	}
-	var keytag int
-	switch k.Algorithm {
-	case RSAMD5:
-		// This algorithm has been deprecated, but keep this key-tag calculation.
-		// Look at the bottom two bytes of the modules, which the last item in the pubkey.
-		// See https://www.rfc-editor.org/errata/eid193 .
-		modulus, _ := fromBase64([]byte(k.PublicKey))
-		if len(modulus) > 1 {
-			x := binary.BigEndian.Uint16(modulus[len(modulus)-3:])
-			keytag = int(x)
-		}
-	default:
-		keywire := new(dnskeyWireFmt)
-		keywire.Flags = k.Flags
-		keywire.Protocol = k.Protocol
-		keywire.Algorithm = k.Algorithm
-		keywire.PublicKey = k.PublicKey
-		wire := make([]byte, DefaultMsgSize)
-		n, err := packKeyWire(keywire, wire)
-		if err != nil {
-			return 0
-		}
-		wire = wire[:n]
-		for i, v := range wire {
-			if i&1 != 0 {
-				keytag += int(v) // must be larger than uint32
-			} else {
-				keytag += int(v) << 8
-			}
-		}
-		keytag += keytag >> 16 & 0xFFFF
-		keytag &= 0xFFFF
-	}
-	return uint16(keytag)
-}
-
-// ToDS converts a DNSKEY record to a DS record.
-func (k *DNSKEY) ToDS(h uint8) *DS {
-	if k == nil {
-		return nil
-	}
-	ds := new(DS)
-	ds.Hdr.Name = k.Hdr.Name
-	ds.Hdr.Class = k.Hdr.Class
-	ds.Hdr.Rrtype = TypeDS
-	ds.Hdr.Ttl = k.Hdr.Ttl
-	ds.Algorithm = k.Algorithm
-	ds.DigestType = h
-	ds.KeyTag = k.KeyTag()
-
-	keywire := new(dnskeyWireFmt)
-	keywire.Flags = k.Flags
-	keywire.Protocol = k.Protocol
-	keywire.Algorithm = k.Algorithm
-	keywire.PublicKey = k.PublicKey
-	wire := make([]byte, DefaultMsgSize)
-	n, err := packKeyWire(keywire, wire)
-	if err != nil {
-		return nil
-	}
-	wire = wire[:n]
-
-	owner := make([]byte, 255)
-	off, err1 := PackDomainName(CanonicalName(k.Hdr.Name), owner, 0, nil, false)
-	if err1 != nil {
-		return nil
-	}
-	owner = owner[:off]
-	// RFC4034:
-	// digest = digest_algorithm( DNSKEY owner name | DNSKEY RDATA);
-	// "|" denotes concatenation
-	// DNSKEY RDATA = Flags | Protocol | Algorithm | Public Key.
-
-	var hash crypto.Hash
-	switch h {
-	case SHA1:
-		hash = crypto.SHA1
-	case SHA256:
-		hash = crypto.SHA256
-	case SHA384:
-		hash = crypto.SHA384
-	case SHA512:
-		hash = crypto.SHA512
-	default:
-		return nil
-	}
-
-	s := hash.New()
-	s.Write(owner)
-	s.Write(wire)
-	ds.Digest = hex.EncodeToString(s.Sum(nil))
-	return ds
-}
-
-// ToCDNSKEY converts a DNSKEY record to a CDNSKEY record.
-func (k *DNSKEY) ToCDNSKEY() *CDNSKEY {
-	c := &CDNSKEY{DNSKEY: *k}
-	c.Hdr = k.Hdr
-	c.Hdr.Rrtype = TypeCDNSKEY
-	return c
-}
-
-// ToCDS converts a DS record to a CDS record.
-func (d *DS) ToCDS() *CDS {
-	c := &CDS{DS: *d}
-	c.Hdr = d.Hdr
-	c.Hdr.Rrtype = TypeCDS
-	return c
-}
-
-// Sign signs an RRSet. The signature needs to be filled in with the values:
-// Inception, Expiration, KeyTag, SignerName and Algorithm.  The rest is copied
-// from the RRset. Sign returns a non-nill error when the signing went OK.
-// There is no check if RRSet is a proper (RFC 2181) RRSet.  If OrigTTL is non
-// zero, it is used as-is, otherwise the TTL of the RRset is used as the
-// OrigTTL.
-func (rr *RRSIG) Sign(k crypto.Signer, rrset []RR) error {
-	h0 := rrset[0].Header()
-	rr.Hdr.Rrtype = TypeRRSIG
-	rr.Hdr.Name = h0.Name
-	rr.Hdr.Class = h0.Class
-	if rr.OrigTtl == 0 { // If set don't override
-		rr.OrigTtl = h0.Ttl
-	}
-	rr.TypeCovered = h0.Rrtype
-	rr.Labels = uint8(CountLabel(h0.Name))
-
-	if strings.HasPrefix(h0.Name, "*") {
-		rr.Labels-- // wildcard, remove from label count
-	}
-
-	return rr.signAsIs(k, rrset)
-}
-
-func (rr *RRSIG) signAsIs(k crypto.Signer, rrset []RR) error {
-	if k == nil {
-		return ErrPrivKey
-	}
-	// s.Inception and s.Expiration may be 0 (rollover etc.), the rest must be set
-	if rr.KeyTag == 0 || len(rr.SignerName) == 0 || rr.Algorithm == 0 {
-		return ErrKey
-	}
-
-	sigwire := new(rrsigWireFmt)
-	sigwire.TypeCovered = rr.TypeCovered
-	sigwire.Algorithm = rr.Algorithm
-	sigwire.Labels = rr.Labels
-	sigwire.OrigTtl = rr.OrigTtl
-	sigwire.Expiration = rr.Expiration
-	sigwire.Inception = rr.Inception
-	sigwire.KeyTag = rr.KeyTag
-	// For signing, lowercase this name
-	sigwire.SignerName = CanonicalName(rr.SignerName)
-
-	// Create the desired binary blob
-	signdata := make([]byte, DefaultMsgSize)
-	n, err := packSigWire(sigwire, signdata)
-	if err != nil {
-		return err
-	}
-	signdata = signdata[:n]
-	wire, err := rawSignatureData(rrset, rr)
-	if err != nil {
-		return err
-	}
-
-	h, cryptohash, err := hashFromAlgorithm(rr.Algorithm)
-	if err != nil {
-		return err
-	}
-
-	switch rr.Algorithm {
-	case RSAMD5, DSA, DSANSEC3SHA1:
-		// See RFC 6944.
-		return ErrAlg
-	default:
-		h.Write(signdata)
-		h.Write(wire)
-
-		signature, err := sign(k, h.Sum(nil), cryptohash, rr.Algorithm)
-		if err != nil {
-			return err
-		}
-
-		rr.Signature = toBase64(signature)
-		return nil
-	}
-}
-
-func sign(k crypto.Signer, hashed []byte, hash crypto.Hash, alg uint8) ([]byte, error) {
-	signature, err := k.Sign(rand.Reader, hashed, hash)
-	if err != nil {
-		return nil, err
-	}
-
-	switch alg {
-	case RSASHA1, RSASHA1NSEC3SHA1, RSASHA256, RSASHA512, ED25519:
-		return signature, nil
-	case ECDSAP256SHA256, ECDSAP384SHA384:
-		ecdsaSignature := &struct {
-			R, S *big.Int
-		}{}
-		if _, err := asn1.Unmarshal(signature, ecdsaSignature); err != nil {
-			return nil, err
-		}
-
-		var intlen int
-		switch alg {
-		case ECDSAP256SHA256:
-			intlen = 32
-		case ECDSAP384SHA384:
-			intlen = 48
-		}
-
-		signature := intToBytes(ecdsaSignature.R, intlen)
-		signature = append(signature, intToBytes(ecdsaSignature.S, intlen)...)
-		return signature, nil
-	default:
-		return nil, ErrAlg
-	}
-}
-
-// Verify validates an RRSet with the signature and key. This is only the
-// cryptographic test, the signature validity period must be checked separately.
-// This function copies the rdata of some RRs (to lowercase domain names) for the validation to work.
-// It also checks that the Zone Key bit (RFC 4034 2.1.1) is set on the DNSKEY
-// and that the Protocol field is set to 3 (RFC 4034 2.1.2).
-func (rr *RRSIG) Verify(k *DNSKEY, rrset []RR) error {
-	// First the easy checks
-	if !IsRRset(rrset) {
-		return ErrRRset
-	}
-	if rr.KeyTag != k.KeyTag() {
-		return ErrKey
-	}
-	if rr.Hdr.Class != k.Hdr.Class {
-		return ErrKey
-	}
-	if rr.Algorithm != k.Algorithm {
-		return ErrKey
-	}
-
-	signerName := CanonicalName(rr.SignerName)
-	if !equal(signerName, k.Hdr.Name) {
-		return ErrKey
-	}
-
-	if k.Protocol != 3 {
-		return ErrKey
-	}
-	// RFC 4034 2.1.1 If bit 7 has value 0, then the DNSKEY record holds some
-	// other type of DNS public key and MUST NOT be used to verify RRSIGs that
-	// cover RRsets.
-	if k.Flags&ZONE == 0 {
-		return ErrKey
-	}
-
-	// IsRRset checked that we have at least one RR and that the RRs in
-	// the set have consistent type, class, and name. Also check that type,
-	// class and name matches the RRSIG record.
-	// Also checks RFC 4035 5.3.1 the number of labels in the RRset owner
-	// name MUST be greater than or equal to the value in the RRSIG RR's Labels field.
-	// RFC 4035 5.3.1 Signer's Name MUST be the name of the zone that [contains the RRset].
-	// Since we don't have SOA info, checking suffix may be the best we can do...?
-	if h0 := rrset[0].Header(); h0.Class != rr.Hdr.Class ||
-		h0.Rrtype != rr.TypeCovered ||
-		uint8(CountLabel(h0.Name)) < rr.Labels ||
-		!equal(h0.Name, rr.Hdr.Name) ||
-		!strings.HasSuffix(CanonicalName(h0.Name), signerName) {
-
-		return ErrRRset
-	}
-
-	// RFC 4035 5.3.2.  Reconstructing the Signed Data
-	// Copy the sig, except the rrsig data
-	sigwire := new(rrsigWireFmt)
-	sigwire.TypeCovered = rr.TypeCovered
-	sigwire.Algorithm = rr.Algorithm
-	sigwire.Labels = rr.Labels
-	sigwire.OrigTtl = rr.OrigTtl
-	sigwire.Expiration = rr.Expiration
-	sigwire.Inception = rr.Inception
-	sigwire.KeyTag = rr.KeyTag
-	sigwire.SignerName = signerName
-	// Create the desired binary blob
-	signeddata := make([]byte, DefaultMsgSize)
-	n, err := packSigWire(sigwire, signeddata)
-	if err != nil {
-		return err
-	}
-	signeddata = signeddata[:n]
-	wire, err := rawSignatureData(rrset, rr)
-	if err != nil {
-		return err
-	}
-
-	sigbuf := rr.sigBuf() // Get the binary signature data
-	// TODO(miek)
-	// remove the domain name and assume its ours?
-	// if rr.Algorithm == PRIVATEDNS { // PRIVATEOID
-	// }
-
-	h, cryptohash, err := hashFromAlgorithm(rr.Algorithm)
-	if err != nil {
-		return err
-	}
-
-	switch rr.Algorithm {
-	case RSASHA1, RSASHA1NSEC3SHA1, RSASHA256, RSASHA512:
-		// TODO(mg): this can be done quicker, ie. cache the pubkey data somewhere??
-		pubkey := k.publicKeyRSA() // Get the key
-		if pubkey == nil {
-			return ErrKey
-		}
-
-		h.Write(signeddata)
-		h.Write(wire)
-		return rsa.VerifyPKCS1v15(pubkey, cryptohash, h.Sum(nil), sigbuf)
-
-	case ECDSAP256SHA256, ECDSAP384SHA384:
-		pubkey := k.publicKeyECDSA()
-		if pubkey == nil {
-			return ErrKey
-		}
-
-		// Split sigbuf into the r and s coordinates
-		r := new(big.Int).SetBytes(sigbuf[:len(sigbuf)/2])
-		s := new(big.Int).SetBytes(sigbuf[len(sigbuf)/2:])
-
-		h.Write(signeddata)
-		h.Write(wire)
-		if ecdsa.Verify(pubkey, h.Sum(nil), r, s) {
-			return nil
-		}
-		return ErrSig
-
-	case ED25519:
-		pubkey := k.publicKeyED25519()
-		if pubkey == nil {
-			return ErrKey
-		}
-
-		if ed25519.Verify(pubkey, append(signeddata, wire...), sigbuf) {
-			return nil
-		}
-		return ErrSig
-
-	default:
-		return ErrAlg
-	}
-}
-
-// ValidityPeriod uses RFC1982 serial arithmetic to calculate
-// if a signature period is valid. If t is the zero time, the
-// current time is taken other t is. Returns true if the signature
-// is valid at the given time, otherwise returns false.
-func (rr *RRSIG) ValidityPeriod(t time.Time) bool {
-	var utc int64
-	if t.IsZero() {
-		utc = time.Now().UTC().Unix()
-	} else {
-		utc = t.UTC().Unix()
-	}
-	modi := (int64(rr.Inception) - utc) / year68
-	mode := (int64(rr.Expiration) - utc) / year68
-	ti := int64(rr.Inception) + modi*year68
-	te := int64(rr.Expiration) + mode*year68
-	return ti <= utc && utc <= te
-}
-
-// Return the signatures base64 encoding sigdata as a byte slice.
-func (rr *RRSIG) sigBuf() []byte {
-	sigbuf, err := fromBase64([]byte(rr.Signature))
-	if err != nil {
-		return nil
-	}
-	return sigbuf
-}
-
-// publicKeyRSA returns the RSA public key from a DNSKEY record.
-func (k *DNSKEY) publicKeyRSA() *rsa.PublicKey {
-	keybuf, err := fromBase64([]byte(k.PublicKey))
-	if err != nil {
-		return nil
-	}
-
-	if len(keybuf) < 1+1+64 {
-		// Exponent must be at least 1 byte and modulus at least 64
-		return nil
-	}
-
-	// RFC 2537/3110, section 2. RSA Public KEY Resource Records
-	// Length is in the 0th byte, unless its zero, then it
-	// it in bytes 1 and 2 and its a 16 bit number
-	explen := uint16(keybuf[0])
-	keyoff := 1
-	if explen == 0 {
-		explen = uint16(keybuf[1])<<8 | uint16(keybuf[2])
-		keyoff = 3
-	}
-
-	if explen > 4 || explen == 0 || keybuf[keyoff] == 0 {
-		// Exponent larger than supported by the crypto package,
-		// empty, or contains prohibited leading zero.
-		return nil
-	}
-
-	modoff := keyoff + int(explen)
-	modlen := len(keybuf) - modoff
-	if modlen < 64 || modlen > 512 || keybuf[modoff] == 0 {
-		// Modulus is too small, large, or contains prohibited leading zero.
-		return nil
-	}
-
-	pubkey := new(rsa.PublicKey)
-
-	var expo uint64
-	// The exponent of length explen is between keyoff and modoff.
-	for _, v := range keybuf[keyoff:modoff] {
-		expo <<= 8
-		expo |= uint64(v)
-	}
-	if expo > 1<<31-1 {
-		// Larger exponent than supported by the crypto package.
-		return nil
-	}
-
-	pubkey.E = int(expo)
-	pubkey.N = new(big.Int).SetBytes(keybuf[modoff:])
-	return pubkey
-}
-
-// publicKeyECDSA returns the Curve public key from the DNSKEY record.
-func (k *DNSKEY) publicKeyECDSA() *ecdsa.PublicKey {
-	keybuf, err := fromBase64([]byte(k.PublicKey))
-	if err != nil {
-		return nil
-	}
-	pubkey := new(ecdsa.PublicKey)
-	switch k.Algorithm {
-	case ECDSAP256SHA256:
-		pubkey.Curve = elliptic.P256()
-		if len(keybuf) != 64 {
-			// wrongly encoded key
-			return nil
-		}
-	case ECDSAP384SHA384:
-		pubkey.Curve = elliptic.P384()
-		if len(keybuf) != 96 {
-			// Wrongly encoded key
-			return nil
-		}
-	}
-	pubkey.X = new(big.Int).SetBytes(keybuf[:len(keybuf)/2])
-	pubkey.Y = new(big.Int).SetBytes(keybuf[len(keybuf)/2:])
-	return pubkey
-}
-
-func (k *DNSKEY) publicKeyED25519() ed25519.PublicKey {
-	keybuf, err := fromBase64([]byte(k.PublicKey))
-	if err != nil {
-		return nil
-	}
-	if len(keybuf) != ed25519.PublicKeySize {
-		return nil
-	}
-	return keybuf
-}
-
-type wireSlice [][]byte
-
-func (p wireSlice) Len() int      { return len(p) }
-func (p wireSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
-func (p wireSlice) Less(i, j int) bool {
-	_, ioff, _ := UnpackDomainName(p[i], 0)
-	_, joff, _ := UnpackDomainName(p[j], 0)
-	return bytes.Compare(p[i][ioff+10:], p[j][joff+10:]) < 0
-}
-
-// Return the raw signature data.
-func rawSignatureData(rrset []RR, s *RRSIG) (buf []byte, err error) {
-	wires := make(wireSlice, len(rrset))
-	for i, r := range rrset {
-		r1 := r.copy()
-		h := r1.Header()
-		h.Ttl = s.OrigTtl
-		labels := SplitDomainName(h.Name)
-		// 6.2. Canonical RR Form. (4) - wildcards
-		if len(labels) > int(s.Labels) {
-			// Wildcard
-			h.Name = "*." + strings.Join(labels[len(labels)-int(s.Labels):], ".") + "."
-		}
-		// RFC 4034: 6.2.  Canonical RR Form. (2) - domain name to lowercase
-		h.Name = CanonicalName(h.Name)
-		// 6.2. Canonical RR Form. (3) - domain rdata to lowercase.
-		//   NS, MD, MF, CNAME, SOA, MB, MG, MR, PTR,
-		//   HINFO, MINFO, MX, RP, AFSDB, RT, SIG, PX, NXT, NAPTR, KX,
-		//   SRV, DNAME, A6
-		//
-		// RFC 6840 - Clarifications and Implementation Notes for DNS Security (DNSSEC):
-		//	Section 6.2 of [RFC4034] also erroneously lists HINFO as a record
-		//	that needs conversion to lowercase, and twice at that.  Since HINFO
-		//	records contain no domain names, they are not subject to case
-		//	conversion.
-		switch x := r1.(type) {
-		case *NS:
-			x.Ns = CanonicalName(x.Ns)
-		case *MD:
-			x.Md = CanonicalName(x.Md)
-		case *MF:
-			x.Mf = CanonicalName(x.Mf)
-		case *CNAME:
-			x.Target = CanonicalName(x.Target)
-		case *SOA:
-			x.Ns = CanonicalName(x.Ns)
-			x.Mbox = CanonicalName(x.Mbox)
-		case *MB:
-			x.Mb = CanonicalName(x.Mb)
-		case *MG:
-			x.Mg = CanonicalName(x.Mg)
-		case *MR:
-			x.Mr = CanonicalName(x.Mr)
-		case *PTR:
-			x.Ptr = CanonicalName(x.Ptr)
-		case *MINFO:
-			x.Rmail = CanonicalName(x.Rmail)
-			x.Email = CanonicalName(x.Email)
-		case *MX:
-			x.Mx = CanonicalName(x.Mx)
-		case *RP:
-			x.Mbox = CanonicalName(x.Mbox)
-			x.Txt = CanonicalName(x.Txt)
-		case *AFSDB:
-			x.Hostname = CanonicalName(x.Hostname)
-		case *RT:
-			x.Host = CanonicalName(x.Host)
-		case *SIG:
-			x.SignerName = CanonicalName(x.SignerName)
-		case *PX:
-			x.Map822 = CanonicalName(x.Map822)
-			x.Mapx400 = CanonicalName(x.Mapx400)
-		case *NAPTR:
-			x.Replacement = CanonicalName(x.Replacement)
-		case *KX:
-			x.Exchanger = CanonicalName(x.Exchanger)
-		case *SRV:
-			x.Target = CanonicalName(x.Target)
-		case *DNAME:
-			x.Target = CanonicalName(x.Target)
-		}
-		// 6.2. Canonical RR Form. (5) - origTTL
-		wire := make([]byte, Len(r1)+1) // +1 to be safe(r)
-		off, err1 := PackRR(r1, wire, 0, nil, false)
-		if err1 != nil {
-			return nil, err1
-		}
-		wire = wire[:off]
-		wires[i] = wire
-	}
-	sort.Sort(wires)
-	for i, wire := range wires {
-		if i > 0 && bytes.Equal(wire, wires[i-1]) {
-			continue
-		}
-		buf = append(buf, wire...)
-	}
-	return buf, nil
-}
-
-func packSigWire(sw *rrsigWireFmt, msg []byte) (int, error) {
-	// copied from zmsg.go RRSIG packing
-	off, err := packUint16(sw.TypeCovered, msg, 0)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(sw.Algorithm, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(sw.Labels, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint32(sw.OrigTtl, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint32(sw.Expiration, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint32(sw.Inception, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(sw.KeyTag, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = PackDomainName(sw.SignerName, msg, off, nil, false)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func packKeyWire(dw *dnskeyWireFmt, msg []byte) (int, error) {
-	// copied from zmsg.go DNSKEY packing
-	off, err := packUint16(dw.Flags, msg, 0)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(dw.Protocol, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(dw.Algorithm, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringBase64(dw.PublicKey, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
diff --git a/vendor/github.com/miekg/dns/dnssec_keygen.go b/vendor/github.com/miekg/dns/dnssec_keygen.go
deleted file mode 100644
index b8124b5618..0000000000
--- a/vendor/github.com/miekg/dns/dnssec_keygen.go
+++ /dev/null
@@ -1,139 +0,0 @@
-package dns
-
-import (
-	"crypto"
-	"crypto/ecdsa"
-	"crypto/ed25519"
-	"crypto/elliptic"
-	"crypto/rand"
-	"crypto/rsa"
-	"math/big"
-)
-
-// Generate generates a DNSKEY of the given bit size.
-// The public part is put inside the DNSKEY record.
-// The Algorithm in the key must be set as this will define
-// what kind of DNSKEY will be generated.
-// The ECDSA algorithms imply a fixed keysize, in that case
-// bits should be set to the size of the algorithm.
-func (k *DNSKEY) Generate(bits int) (crypto.PrivateKey, error) {
-	switch k.Algorithm {
-	case RSASHA1, RSASHA256, RSASHA1NSEC3SHA1:
-		if bits < 512 || bits > 4096 {
-			return nil, ErrKeySize
-		}
-	case RSASHA512:
-		if bits < 1024 || bits > 4096 {
-			return nil, ErrKeySize
-		}
-	case ECDSAP256SHA256:
-		if bits != 256 {
-			return nil, ErrKeySize
-		}
-	case ECDSAP384SHA384:
-		if bits != 384 {
-			return nil, ErrKeySize
-		}
-	case ED25519:
-		if bits != 256 {
-			return nil, ErrKeySize
-		}
-	default:
-		return nil, ErrAlg
-	}
-
-	switch k.Algorithm {
-	case RSASHA1, RSASHA256, RSASHA512, RSASHA1NSEC3SHA1:
-		priv, err := rsa.GenerateKey(rand.Reader, bits)
-		if err != nil {
-			return nil, err
-		}
-		k.setPublicKeyRSA(priv.PublicKey.E, priv.PublicKey.N)
-		return priv, nil
-	case ECDSAP256SHA256, ECDSAP384SHA384:
-		var c elliptic.Curve
-		switch k.Algorithm {
-		case ECDSAP256SHA256:
-			c = elliptic.P256()
-		case ECDSAP384SHA384:
-			c = elliptic.P384()
-		}
-		priv, err := ecdsa.GenerateKey(c, rand.Reader)
-		if err != nil {
-			return nil, err
-		}
-		k.setPublicKeyECDSA(priv.PublicKey.X, priv.PublicKey.Y)
-		return priv, nil
-	case ED25519:
-		pub, priv, err := ed25519.GenerateKey(rand.Reader)
-		if err != nil {
-			return nil, err
-		}
-		k.setPublicKeyED25519(pub)
-		return priv, nil
-	default:
-		return nil, ErrAlg
-	}
-}
-
-// Set the public key (the value E and N)
-func (k *DNSKEY) setPublicKeyRSA(_E int, _N *big.Int) bool {
-	if _E == 0 || _N == nil {
-		return false
-	}
-	buf := exponentToBuf(_E)
-	buf = append(buf, _N.Bytes()...)
-	k.PublicKey = toBase64(buf)
-	return true
-}
-
-// Set the public key for Elliptic Curves
-func (k *DNSKEY) setPublicKeyECDSA(_X, _Y *big.Int) bool {
-	if _X == nil || _Y == nil {
-		return false
-	}
-	var intlen int
-	switch k.Algorithm {
-	case ECDSAP256SHA256:
-		intlen = 32
-	case ECDSAP384SHA384:
-		intlen = 48
-	}
-	k.PublicKey = toBase64(curveToBuf(_X, _Y, intlen))
-	return true
-}
-
-// Set the public key for Ed25519
-func (k *DNSKEY) setPublicKeyED25519(_K ed25519.PublicKey) bool {
-	if _K == nil {
-		return false
-	}
-	k.PublicKey = toBase64(_K)
-	return true
-}
-
-// Set the public key (the values E and N) for RSA
-// RFC 3110: Section 2. RSA Public KEY Resource Records
-func exponentToBuf(_E int) []byte {
-	var buf []byte
-	i := big.NewInt(int64(_E)).Bytes()
-	if len(i) < 256 {
-		buf = make([]byte, 1, 1+len(i))
-		buf[0] = uint8(len(i))
-	} else {
-		buf = make([]byte, 3, 3+len(i))
-		buf[0] = 0
-		buf[1] = uint8(len(i) >> 8)
-		buf[2] = uint8(len(i))
-	}
-	buf = append(buf, i...)
-	return buf
-}
-
-// Set the public key for X and Y for Curve. The two
-// values are just concatenated.
-func curveToBuf(_X, _Y *big.Int, intlen int) []byte {
-	buf := intToBytes(_X, intlen)
-	buf = append(buf, intToBytes(_Y, intlen)...)
-	return buf
-}
diff --git a/vendor/github.com/miekg/dns/dnssec_keyscan.go b/vendor/github.com/miekg/dns/dnssec_keyscan.go
deleted file mode 100644
index 9c9972db6e..0000000000
--- a/vendor/github.com/miekg/dns/dnssec_keyscan.go
+++ /dev/null
@@ -1,310 +0,0 @@
-package dns
-
-import (
-	"bufio"
-	"crypto"
-	"crypto/ecdsa"
-	"crypto/ed25519"
-	"crypto/rsa"
-	"io"
-	"math/big"
-	"strconv"
-	"strings"
-)
-
-// NewPrivateKey returns a PrivateKey by parsing the string s.
-// s should be in the same form of the BIND private key files.
-func (k *DNSKEY) NewPrivateKey(s string) (crypto.PrivateKey, error) {
-	if s == "" || s[len(s)-1] != '\n' { // We need a closing newline
-		return k.ReadPrivateKey(strings.NewReader(s+"\n"), "")
-	}
-	return k.ReadPrivateKey(strings.NewReader(s), "")
-}
-
-// ReadPrivateKey reads a private key from the io.Reader q. The string file is
-// only used in error reporting.
-// The public key must be known, because some cryptographic algorithms embed
-// the public inside the privatekey.
-func (k *DNSKEY) ReadPrivateKey(q io.Reader, file string) (crypto.PrivateKey, error) {
-	m, err := parseKey(q, file)
-	if m == nil {
-		return nil, err
-	}
-	if _, ok := m["private-key-format"]; !ok {
-		return nil, ErrPrivKey
-	}
-	if m["private-key-format"] != "v1.2" && m["private-key-format"] != "v1.3" {
-		return nil, ErrPrivKey
-	}
-	// TODO(mg): check if the pubkey matches the private key
-	algoStr, _, _ := strings.Cut(m["algorithm"], " ")
-	algo, err := strconv.ParseUint(algoStr, 10, 8)
-	if err != nil {
-		return nil, ErrPrivKey
-	}
-	switch uint8(algo) {
-	case RSASHA1, RSASHA1NSEC3SHA1, RSASHA256, RSASHA512:
-		priv, err := readPrivateKeyRSA(m)
-		if err != nil {
-			return nil, err
-		}
-		pub := k.publicKeyRSA()
-		if pub == nil {
-			return nil, ErrKey
-		}
-		priv.PublicKey = *pub
-		return priv, nil
-	case ECDSAP256SHA256, ECDSAP384SHA384:
-		priv, err := readPrivateKeyECDSA(m)
-		if err != nil {
-			return nil, err
-		}
-		pub := k.publicKeyECDSA()
-		if pub == nil {
-			return nil, ErrKey
-		}
-		priv.PublicKey = *pub
-		return priv, nil
-	case ED25519:
-		return readPrivateKeyED25519(m)
-	default:
-		return nil, ErrAlg
-	}
-}
-
-// Read a private key (file) string and create a public key. Return the private key.
-func readPrivateKeyRSA(m map[string]string) (*rsa.PrivateKey, error) {
-	p := new(rsa.PrivateKey)
-	p.Primes = []*big.Int{nil, nil}
-	for k, v := range m {
-		switch k {
-		case "modulus", "publicexponent", "privateexponent", "prime1", "prime2":
-			v1, err := fromBase64([]byte(v))
-			if err != nil {
-				return nil, err
-			}
-			switch k {
-			case "modulus":
-				p.PublicKey.N = new(big.Int).SetBytes(v1)
-			case "publicexponent":
-				i := new(big.Int).SetBytes(v1)
-				p.PublicKey.E = int(i.Int64()) // int64 should be large enough
-			case "privateexponent":
-				p.D = new(big.Int).SetBytes(v1)
-			case "prime1":
-				p.Primes[0] = new(big.Int).SetBytes(v1)
-			case "prime2":
-				p.Primes[1] = new(big.Int).SetBytes(v1)
-			}
-		case "exponent1", "exponent2", "coefficient":
-			// not used in Go (yet)
-		case "created", "publish", "activate":
-			// not used in Go (yet)
-		}
-	}
-	return p, nil
-}
-
-func readPrivateKeyECDSA(m map[string]string) (*ecdsa.PrivateKey, error) {
-	p := new(ecdsa.PrivateKey)
-	p.D = new(big.Int)
-	// TODO: validate that the required flags are present
-	for k, v := range m {
-		switch k {
-		case "privatekey":
-			v1, err := fromBase64([]byte(v))
-			if err != nil {
-				return nil, err
-			}
-			p.D.SetBytes(v1)
-		case "created", "publish", "activate":
-			/* not used in Go (yet) */
-		}
-	}
-	return p, nil
-}
-
-func readPrivateKeyED25519(m map[string]string) (ed25519.PrivateKey, error) {
-	var p ed25519.PrivateKey
-	// TODO: validate that the required flags are present
-	for k, v := range m {
-		switch k {
-		case "privatekey":
-			p1, err := fromBase64([]byte(v))
-			if err != nil {
-				return nil, err
-			}
-			if len(p1) != ed25519.SeedSize {
-				return nil, ErrPrivKey
-			}
-			p = ed25519.NewKeyFromSeed(p1)
-		case "created", "publish", "activate":
-			/* not used in Go (yet) */
-		}
-	}
-	return p, nil
-}
-
-// parseKey reads a private key from r. It returns a map[string]string,
-// with the key-value pairs, or an error when the file is not correct.
-func parseKey(r io.Reader, file string) (map[string]string, error) {
-	m := make(map[string]string)
-	var k string
-
-	c := newKLexer(r)
-
-	for l, ok := c.Next(); ok; l, ok = c.Next() {
-		// It should alternate
-		switch l.value {
-		case zKey:
-			k = l.token
-		case zValue:
-			if k == "" {
-				return nil, &ParseError{file: file, err: "no private key seen", lex: l}
-			}
-
-			m[strings.ToLower(k)] = l.token
-			k = ""
-		}
-	}
-
-	// Surface any read errors from r.
-	if err := c.Err(); err != nil {
-		return nil, &ParseError{file: file, err: err.Error()}
-	}
-
-	return m, nil
-}
-
-type klexer struct {
-	br io.ByteReader
-
-	readErr error
-
-	line   int
-	column int
-
-	key bool
-
-	eol bool // end-of-line
-}
-
-func newKLexer(r io.Reader) *klexer {
-	br, ok := r.(io.ByteReader)
-	if !ok {
-		br = bufio.NewReaderSize(r, 1024)
-	}
-
-	return &klexer{
-		br: br,
-
-		line: 1,
-
-		key: true,
-	}
-}
-
-func (kl *klexer) Err() error {
-	if kl.readErr == io.EOF {
-		return nil
-	}
-
-	return kl.readErr
-}
-
-// readByte returns the next byte from the input
-func (kl *klexer) readByte() (byte, bool) {
-	if kl.readErr != nil {
-		return 0, false
-	}
-
-	c, err := kl.br.ReadByte()
-	if err != nil {
-		kl.readErr = err
-		return 0, false
-	}
-
-	// delay the newline handling until the next token is delivered,
-	// fixes off-by-one errors when reporting a parse error.
-	if kl.eol {
-		kl.line++
-		kl.column = 0
-		kl.eol = false
-	}
-
-	if c == '\n' {
-		kl.eol = true
-	} else {
-		kl.column++
-	}
-
-	return c, true
-}
-
-func (kl *klexer) Next() (lex, bool) {
-	var (
-		l lex
-
-		str strings.Builder
-
-		commt bool
-	)
-
-	for x, ok := kl.readByte(); ok; x, ok = kl.readByte() {
-		l.line, l.column = kl.line, kl.column
-
-		switch x {
-		case ':':
-			if commt || !kl.key {
-				break
-			}
-
-			kl.key = false
-
-			// Next token is a space, eat it
-			kl.readByte()
-
-			l.value = zKey
-			l.token = str.String()
-			return l, true
-		case ';':
-			commt = true
-		case '\n':
-			if commt {
-				// Reset a comment
-				commt = false
-			}
-
-			if kl.key && str.Len() == 0 {
-				// ignore empty lines
-				break
-			}
-
-			kl.key = true
-
-			l.value = zValue
-			l.token = str.String()
-			return l, true
-		default:
-			if commt {
-				break
-			}
-
-			str.WriteByte(x)
-		}
-	}
-
-	if kl.readErr != nil && kl.readErr != io.EOF {
-		// Don't return any tokens after a read error occurs.
-		return lex{value: zEOF}, false
-	}
-
-	if str.Len() > 0 {
-		// Send remainder
-		l.value = zValue
-		l.token = str.String()
-		return l, true
-	}
-
-	return lex{value: zEOF}, false
-}
diff --git a/vendor/github.com/miekg/dns/dnssec_privkey.go b/vendor/github.com/miekg/dns/dnssec_privkey.go
deleted file mode 100644
index f160772964..0000000000
--- a/vendor/github.com/miekg/dns/dnssec_privkey.go
+++ /dev/null
@@ -1,77 +0,0 @@
-package dns
-
-import (
-	"crypto"
-	"crypto/ecdsa"
-	"crypto/ed25519"
-	"crypto/rsa"
-	"math/big"
-	"strconv"
-)
-
-const format = "Private-key-format: v1.3\n"
-
-var bigIntOne = big.NewInt(1)
-
-// PrivateKeyString converts a PrivateKey to a string. This string has the same
-// format as the private-key-file of BIND9 (Private-key-format: v1.3).
-// It needs some info from the key (the algorithm), so its a method of the DNSKEY.
-// It supports *rsa.PrivateKey, *ecdsa.PrivateKey and ed25519.PrivateKey.
-func (r *DNSKEY) PrivateKeyString(p crypto.PrivateKey) string {
-	algorithm := strconv.Itoa(int(r.Algorithm))
-	algorithm += " (" + AlgorithmToString[r.Algorithm] + ")"
-
-	switch p := p.(type) {
-	case *rsa.PrivateKey:
-		modulus := toBase64(p.PublicKey.N.Bytes())
-		e := big.NewInt(int64(p.PublicKey.E))
-		publicExponent := toBase64(e.Bytes())
-		privateExponent := toBase64(p.D.Bytes())
-		prime1 := toBase64(p.Primes[0].Bytes())
-		prime2 := toBase64(p.Primes[1].Bytes())
-		// Calculate Exponent1/2 and Coefficient as per: http://en.wikipedia.org/wiki/RSA#Using_the_Chinese_remainder_algorithm
-		// and from: http://code.google.com/p/go/issues/detail?id=987
-		p1 := new(big.Int).Sub(p.Primes[0], bigIntOne)
-		q1 := new(big.Int).Sub(p.Primes[1], bigIntOne)
-		exp1 := new(big.Int).Mod(p.D, p1)
-		exp2 := new(big.Int).Mod(p.D, q1)
-		coeff := new(big.Int).ModInverse(p.Primes[1], p.Primes[0])
-
-		exponent1 := toBase64(exp1.Bytes())
-		exponent2 := toBase64(exp2.Bytes())
-		coefficient := toBase64(coeff.Bytes())
-
-		return format +
-			"Algorithm: " + algorithm + "\n" +
-			"Modulus: " + modulus + "\n" +
-			"PublicExponent: " + publicExponent + "\n" +
-			"PrivateExponent: " + privateExponent + "\n" +
-			"Prime1: " + prime1 + "\n" +
-			"Prime2: " + prime2 + "\n" +
-			"Exponent1: " + exponent1 + "\n" +
-			"Exponent2: " + exponent2 + "\n" +
-			"Coefficient: " + coefficient + "\n"
-
-	case *ecdsa.PrivateKey:
-		var intlen int
-		switch r.Algorithm {
-		case ECDSAP256SHA256:
-			intlen = 32
-		case ECDSAP384SHA384:
-			intlen = 48
-		}
-		private := toBase64(intToBytes(p.D, intlen))
-		return format +
-			"Algorithm: " + algorithm + "\n" +
-			"PrivateKey: " + private + "\n"
-
-	case ed25519.PrivateKey:
-		private := toBase64(p.Seed())
-		return format +
-			"Algorithm: " + algorithm + "\n" +
-			"PrivateKey: " + private + "\n"
-
-	default:
-		return ""
-	}
-}
diff --git a/vendor/github.com/miekg/dns/doc.go b/vendor/github.com/miekg/dns/doc.go
deleted file mode 100644
index 586ab6917e..0000000000
--- a/vendor/github.com/miekg/dns/doc.go
+++ /dev/null
@@ -1,292 +0,0 @@
-/*
-Package dns implements a full featured interface to the Domain Name System.
-Both server- and client-side programming is supported. The package allows
-complete control over what is sent out to the DNS. The API follows the
-less-is-more principle, by presenting a small, clean interface.
-
-It supports (asynchronous) querying/replying, incoming/outgoing zone transfers,
-TSIG, EDNS0, dynamic updates, notifies and DNSSEC validation/signing.
-
-Note that domain names MUST be fully qualified before sending them, unqualified
-names in a message will result in a packing failure.
-
-Resource records are native types. They are not stored in wire format. Basic
-usage pattern for creating a new resource record:
-
-	r := new(dns.MX)
-	r.Hdr = dns.RR_Header{Name: "miek.nl.", Rrtype: dns.TypeMX, Class: dns.ClassINET, Ttl: 3600}
-	r.Preference = 10
-	r.Mx = "mx.miek.nl."
-
-Or directly from a string:
-
-	mx, err := dns.NewRR("miek.nl. 3600 IN MX 10 mx.miek.nl.")
-
-Or when the default origin (.) and TTL (3600) and class (IN) suit you:
-
-	mx, err := dns.NewRR("miek.nl MX 10 mx.miek.nl")
-
-Or even:
-
-	mx, err := dns.NewRR("$ORIGIN nl.\nmiek 1H IN MX 10 mx.miek")
-
-In the DNS messages are exchanged, these messages contain resource records
-(sets). Use pattern for creating a message:
-
-	m := new(dns.Msg)
-	m.SetQuestion("miek.nl.", dns.TypeMX)
-
-Or when not certain if the domain name is fully qualified:
-
-	m.SetQuestion(dns.Fqdn("miek.nl"), dns.TypeMX)
-
-The message m is now a message with the question section set to ask the MX
-records for the miek.nl. zone.
-
-The following is slightly more verbose, but more flexible:
-
-	m1 := new(dns.Msg)
-	m1.Id = dns.Id()
-	m1.RecursionDesired = true
-	m1.Question = make([]dns.Question, 1)
-	m1.Question[0] = dns.Question{"miek.nl.", dns.TypeMX, dns.ClassINET}
-
-After creating a message it can be sent. Basic use pattern for synchronous
-querying the DNS at a server configured on 127.0.0.1 and port 53:
-
-	c := new(dns.Client)
-	in, rtt, err := c.Exchange(m1, "127.0.0.1:53")
-
-Suppressing multiple outstanding queries (with the same question, type and
-class) is as easy as setting:
-
-	c.SingleInflight = true
-
-More advanced options are available using a net.Dialer and the corresponding API.
-For example it is possible to set a timeout, or to specify a source IP address
-and port to use for the connection:
-
-	c := new(dns.Client)
-	laddr := net.UDPAddr{
-		IP: net.ParseIP("[::1]"),
-		Port: 12345,
-		Zone: "",
-	}
-	c.Dialer = &net.Dialer{
-		Timeout: 200 * time.Millisecond,
-		LocalAddr: &laddr,
-	}
-	in, rtt, err := c.Exchange(m1, "8.8.8.8:53")
-
-If these "advanced" features are not needed, a simple UDP query can be sent,
-with:
-
-	in, err := dns.Exchange(m1, "127.0.0.1:53")
-
-When this functions returns you will get DNS message. A DNS message consists
-out of four sections.
-The question section: in.Question, the answer section: in.Answer,
-the authority section: in.Ns and the additional section: in.Extra.
-
-Each of these sections (except the Question section) contain a []RR. Basic
-use pattern for accessing the rdata of a TXT RR as the first RR in
-the Answer section:
-
-	if t, ok := in.Answer[0].(*dns.TXT); ok {
-		// do something with t.Txt
-	}
-
-# Domain Name and TXT Character String Representations
-
-Both domain names and TXT character strings are converted to presentation form
-both when unpacked and when converted to strings.
-
-For TXT character strings, tabs, carriage returns and line feeds will be
-converted to \t, \r and \n respectively. Back slashes and quotations marks will
-be escaped. Bytes below 32 and above 127 will be converted to \DDD form.
-
-For domain names, in addition to the above rules brackets, periods, spaces,
-semicolons and the at symbol are escaped.
-
-# DNSSEC
-
-DNSSEC (DNS Security Extension) adds a layer of security to the DNS. It uses
-public key cryptography to sign resource records. The public keys are stored in
-DNSKEY records and the signatures in RRSIG records.
-
-Requesting DNSSEC information for a zone is done by adding the DO (DNSSEC OK)
-bit to a request.
-
-	m := new(dns.Msg)
-	m.SetEdns0(4096, true)
-
-Signature generation, signature verification and key generation are all supported.
-
-# DYNAMIC UPDATES
-
-Dynamic updates reuses the DNS message format, but renames three of the
-sections. Question is Zone, Answer is Prerequisite, Authority is Update, only
-the Additional is not renamed. See RFC 2136 for the gory details.
-
-You can set a rather complex set of rules for the existence of absence of
-certain resource records or names in a zone to specify if resource records
-should be added or removed. The table from RFC 2136 supplemented with the Go
-DNS function shows which functions exist to specify the prerequisites.
-
-	3.2.4 - Table Of Metavalues Used In Prerequisite Section
-
-	 CLASS    TYPE     RDATA    Meaning                    Function
-	 --------------------------------------------------------------
-	 ANY      ANY      empty    Name is in use             dns.NameUsed
-	 ANY      rrset    empty    RRset exists (value indep) dns.RRsetUsed
-	 NONE     ANY      empty    Name is not in use         dns.NameNotUsed
-	 NONE     rrset    empty    RRset does not exist       dns.RRsetNotUsed
-	 zone     rrset    rr       RRset exists (value dep)   dns.Used
-
-The prerequisite section can also be left empty. If you have decided on the
-prerequisites you can tell what RRs should be added or deleted. The next table
-shows the options you have and what functions to call.
-
-	3.4.2.6 - Table Of Metavalues Used In Update Section
-
-	 CLASS    TYPE     RDATA    Meaning                     Function
-	 ---------------------------------------------------------------
-	 ANY      ANY      empty    Delete all RRsets from name dns.RemoveName
-	 ANY      rrset    empty    Delete an RRset             dns.RemoveRRset
-	 NONE     rrset    rr       Delete an RR from RRset     dns.Remove
-	 zone     rrset    rr       Add to an RRset             dns.Insert
-
-# TRANSACTION SIGNATURE
-
-An TSIG or transaction signature adds a HMAC TSIG record to each message sent.
-The supported algorithms include: HmacSHA1, HmacSHA256 and HmacSHA512.
-
-Basic use pattern when querying with a TSIG name "axfr." (note that these key names
-must be fully qualified - as they are domain names) and the base64 secret
-"so6ZGir4GPAqINNh9U5c3A==":
-
-If an incoming message contains a TSIG record it MUST be the last record in
-the additional section (RFC2845 3.2).  This means that you should make the
-call to SetTsig last, right before executing the query.  If you make any
-changes to the RRset after calling SetTsig() the signature will be incorrect.
-
-	c := new(dns.Client)
-	c.TsigSecret = map[string]string{"axfr.": "so6ZGir4GPAqINNh9U5c3A=="}
-	m := new(dns.Msg)
-	m.SetQuestion("miek.nl.", dns.TypeMX)
-	m.SetTsig("axfr.", dns.HmacSHA256, 300, time.Now().Unix())
-	...
-	// When sending the TSIG RR is calculated and filled in before sending
-
-When requesting an zone transfer (almost all TSIG usage is when requesting zone
-transfers), with TSIG, this is the basic use pattern. In this example we
-request an AXFR for miek.nl. with TSIG key named "axfr." and secret
-"so6ZGir4GPAqINNh9U5c3A==" and using the server 176.58.119.54:
-
-	t := new(dns.Transfer)
-	m := new(dns.Msg)
-	t.TsigSecret = map[string]string{"axfr.": "so6ZGir4GPAqINNh9U5c3A=="}
-	m.SetAxfr("miek.nl.")
-	m.SetTsig("axfr.", dns.HmacSHA256, 300, time.Now().Unix())
-	c, err := t.In(m, "176.58.119.54:53")
-	for r := range c { ... }
-
-You can now read the records from the transfer as they come in. Each envelope
-is checked with TSIG. If something is not correct an error is returned.
-
-A custom TSIG implementation can be used. This requires additional code to
-perform any session establishment and signature generation/verification. The
-client must be configured with an implementation of the TsigProvider interface:
-
-	type Provider struct{}
-
-	func (*Provider) Generate(msg []byte, tsig *dns.TSIG) ([]byte, error) {
-		// Use tsig.Hdr.Name and tsig.Algorithm in your code to
-		// generate the MAC using msg as the payload.
-	}
-
-	func (*Provider) Verify(msg []byte, tsig *dns.TSIG) error {
-		// Use tsig.Hdr.Name and tsig.Algorithm in your code to verify
-		// that msg matches the value in tsig.MAC.
-	}
-
-	c := new(dns.Client)
-	c.TsigProvider = new(Provider)
-	m := new(dns.Msg)
-	m.SetQuestion("miek.nl.", dns.TypeMX)
-	m.SetTsig(keyname, dns.HmacSHA256, 300, time.Now().Unix())
-	...
-	// TSIG RR is calculated by calling your Generate method
-
-Basic use pattern validating and replying to a message that has TSIG set.
-
-	server := &dns.Server{Addr: ":53", Net: "udp"}
-	server.TsigSecret = map[string]string{"axfr.": "so6ZGir4GPAqINNh9U5c3A=="}
-	go server.ListenAndServe()
-	dns.HandleFunc(".", handleRequest)
-
-	func handleRequest(w dns.ResponseWriter, r *dns.Msg) {
-		m := new(dns.Msg)
-		m.SetReply(r)
-		if r.IsTsig() != nil {
-			if w.TsigStatus() == nil {
-				// *Msg r has an TSIG record and it was validated
-				m.SetTsig("axfr.", dns.HmacSHA256, 300, time.Now().Unix())
-			} else {
-				// *Msg r has an TSIG records and it was not validated
-			}
-		}
-		w.WriteMsg(m)
-	}
-
-# PRIVATE RRS
-
-RFC 6895 sets aside a range of type codes for private use. This range is 65,280
-- 65,534 (0xFF00 - 0xFFFE). When experimenting with new Resource Records these
-can be used, before requesting an official type code from IANA.
-
-See https://miek.nl/2014/september/21/idn-and-private-rr-in-go-dns/ for more
-information.
-
-# EDNS0
-
-EDNS0 is an extension mechanism for the DNS defined in RFC 2671 and updated by
-RFC 6891. It defines a new RR type, the OPT RR, which is then completely
-abused.
-
-Basic use pattern for creating an (empty) OPT RR:
-
-	o := new(dns.OPT)
-	o.Hdr.Name = "." // MUST be the root zone, per definition.
-	o.Hdr.Rrtype = dns.TypeOPT
-
-The rdata of an OPT RR consists out of a slice of EDNS0 (RFC 6891) interfaces.
-Currently only a few have been standardized: EDNS0_NSID (RFC 5001) and
-EDNS0_SUBNET (RFC 7871). Note that these options may be combined in an OPT RR.
-Basic use pattern for a server to check if (and which) options are set:
-
-	// o is a dns.OPT
-	for _, s := range o.Option {
-		switch e := s.(type) {
-		case *dns.EDNS0_NSID:
-			// do stuff with e.Nsid
-		case *dns.EDNS0_SUBNET:
-			// access e.Family, e.Address, etc.
-		}
-	}
-
-SIG(0)
-
-From RFC 2931:
-
-	SIG(0) provides protection for DNS transactions and requests ....
-	... protection for glue records, DNS requests, protection for message headers
-	on requests and responses, and protection of the overall integrity of a response.
-
-It works like TSIG, except that SIG(0) uses public key cryptography, instead of
-the shared secret approach in TSIG. Supported algorithms: ECDSAP256SHA256,
-ECDSAP384SHA384, RSASHA1, RSASHA256 and RSASHA512.
-
-Signing subsequent messages in multi-message sessions is not implemented.
-*/
-package dns
diff --git a/vendor/github.com/miekg/dns/duplicate.go b/vendor/github.com/miekg/dns/duplicate.go
deleted file mode 100644
index d21ae1cac1..0000000000
--- a/vendor/github.com/miekg/dns/duplicate.go
+++ /dev/null
@@ -1,37 +0,0 @@
-package dns
-
-//go:generate go run duplicate_generate.go
-
-// IsDuplicate checks of r1 and r2 are duplicates of each other, excluding the TTL.
-// So this means the header data is equal *and* the RDATA is the same. Returns true
-// if so, otherwise false. It's a protocol violation to have identical RRs in a message.
-func IsDuplicate(r1, r2 RR) bool {
-	// Check whether the record header is identical.
-	if !r1.Header().isDuplicate(r2.Header()) {
-		return false
-	}
-
-	// Check whether the RDATA is identical.
-	return r1.isDuplicate(r2)
-}
-
-func (r1 *RR_Header) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*RR_Header)
-	if !ok {
-		return false
-	}
-	if r1.Class != r2.Class {
-		return false
-	}
-	if r1.Rrtype != r2.Rrtype {
-		return false
-	}
-	if !isDuplicateName(r1.Name, r2.Name) {
-		return false
-	}
-	// ignore TTL
-	return true
-}
-
-// isDuplicateName checks if the domain names s1 and s2 are equal.
-func isDuplicateName(s1, s2 string) bool { return equal(s1, s2) }
diff --git a/vendor/github.com/miekg/dns/edns.go b/vendor/github.com/miekg/dns/edns.go
deleted file mode 100644
index 89318b7500..0000000000
--- a/vendor/github.com/miekg/dns/edns.go
+++ /dev/null
@@ -1,970 +0,0 @@
-package dns
-
-import (
-	"encoding/binary"
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"net"
-	"strconv"
-)
-
-// EDNS0 Option codes.
-const (
-	EDNS0LLQ          = 0x1     // long lived queries: http://tools.ietf.org/html/draft-sekar-dns-llq-01
-	EDNS0UL           = 0x2     // update lease draft: http://files.dns-sd.org/draft-sekar-dns-ul.txt
-	EDNS0NSID         = 0x3     // nsid (See RFC 5001)
-	EDNS0ESU          = 0x4     // ENUM Source-URI draft: https://datatracker.ietf.org/doc/html/draft-kaplan-enum-source-uri-00
-	EDNS0DAU          = 0x5     // DNSSEC Algorithm Understood
-	EDNS0DHU          = 0x6     // DS Hash Understood
-	EDNS0N3U          = 0x7     // NSEC3 Hash Understood
-	EDNS0SUBNET       = 0x8     // client-subnet (See RFC 7871)
-	EDNS0EXPIRE       = 0x9     // EDNS0 expire
-	EDNS0COOKIE       = 0xa     // EDNS0 Cookie
-	EDNS0TCPKEEPALIVE = 0xb     // EDNS0 tcp keep alive (See RFC 7828)
-	EDNS0PADDING      = 0xc     // EDNS0 padding (See RFC 7830)
-	EDNS0EDE          = 0xf     // EDNS0 extended DNS errors (See RFC 8914)
-	EDNS0REPORTING    = 0x12    // EDNS0 reporting (See RFC 9567)
-	EDNS0ZONEVERSION  = 0x13    // EDNS0 Zone Version (See RFC 9660)
-	EDNS0LOCALSTART   = 0xFDE9  // Beginning of range reserved for local/experimental use (See RFC 6891)
-	EDNS0LOCALEND     = 0xFFFE  // End of range reserved for local/experimental use (See RFC 6891)
-	_DO               = 1 << 15 // DNSSEC OK
-	_CO               = 1 << 14 // Compact Answers OK
-)
-
-// makeDataOpt is used to unpack the EDNS0 option(s) from a message.
-func makeDataOpt(code uint16) EDNS0 {
-	// All the EDNS0.* constants above need to be in this switch.
-	switch code {
-	case EDNS0LLQ:
-		return new(EDNS0_LLQ)
-	case EDNS0UL:
-		return new(EDNS0_UL)
-	case EDNS0NSID:
-		return new(EDNS0_NSID)
-	case EDNS0DAU:
-		return new(EDNS0_DAU)
-	case EDNS0DHU:
-		return new(EDNS0_DHU)
-	case EDNS0N3U:
-		return new(EDNS0_N3U)
-	case EDNS0SUBNET:
-		return new(EDNS0_SUBNET)
-	case EDNS0EXPIRE:
-		return new(EDNS0_EXPIRE)
-	case EDNS0COOKIE:
-		return new(EDNS0_COOKIE)
-	case EDNS0TCPKEEPALIVE:
-		return new(EDNS0_TCP_KEEPALIVE)
-	case EDNS0PADDING:
-		return new(EDNS0_PADDING)
-	case EDNS0EDE:
-		return new(EDNS0_EDE)
-	case EDNS0ESU:
-		return new(EDNS0_ESU)
-	case EDNS0REPORTING:
-		return new(EDNS0_REPORTING)
-	case EDNS0ZONEVERSION:
-		return new(EDNS0_ZONEVERSION)
-	default:
-		e := new(EDNS0_LOCAL)
-		e.Code = code
-		return e
-	}
-}
-
-// OPT is the EDNS0 RR appended to messages to convey extra (meta) information. See RFC 6891.
-type OPT struct {
-	Hdr    RR_Header
-	Option []EDNS0 `dns:"opt"`
-}
-
-func (rr *OPT) String() string {
-	s := "\n;; OPT PSEUDOSECTION:\n; EDNS: version " + strconv.Itoa(int(rr.Version())) + "; "
-	s += "flags:"
-	if rr.Do() {
-		s += " do"
-	}
-	if rr.Co() {
-		s += " co"
-	}
-	s += "; "
-	if z := rr.Z(); z != 0 {
-		s += fmt.Sprintf("MBZ: 0x%04x, ", z)
-	}
-	s += "udp: " + strconv.Itoa(int(rr.UDPSize()))
-
-	for _, o := range rr.Option {
-		switch o.(type) {
-		case *EDNS0_NSID:
-			s += "\n; NSID: " + o.String()
-			h, e := o.pack()
-			var r string
-			if e == nil {
-				for _, c := range h {
-					r += "(" + string(c) + ")"
-				}
-				s += "  " + r
-			}
-		case *EDNS0_SUBNET:
-			s += "\n; SUBNET: " + o.String()
-		case *EDNS0_COOKIE:
-			s += "\n; COOKIE: " + o.String()
-		case *EDNS0_EXPIRE:
-			s += "\n; EXPIRE: " + o.String()
-		case *EDNS0_TCP_KEEPALIVE:
-			s += "\n; KEEPALIVE: " + o.String()
-		case *EDNS0_UL:
-			s += "\n; UPDATE LEASE: " + o.String()
-		case *EDNS0_LLQ:
-			s += "\n; LONG LIVED QUERIES: " + o.String()
-		case *EDNS0_DAU:
-			s += "\n; DNSSEC ALGORITHM UNDERSTOOD: " + o.String()
-		case *EDNS0_DHU:
-			s += "\n; DS HASH UNDERSTOOD: " + o.String()
-		case *EDNS0_N3U:
-			s += "\n; NSEC3 HASH UNDERSTOOD: " + o.String()
-		case *EDNS0_LOCAL:
-			s += "\n; LOCAL OPT: " + o.String()
-		case *EDNS0_PADDING:
-			s += "\n; PADDING: " + o.String()
-		case *EDNS0_EDE:
-			s += "\n; EDE: " + o.String()
-		case *EDNS0_ESU:
-			s += "\n; ESU: " + o.String()
-		case *EDNS0_REPORTING:
-			s += "\n; REPORT-CHANNEL: " + o.String()
-		case *EDNS0_ZONEVERSION:
-			s += "\n; ZONEVERSION: " + o.String()
-		}
-	}
-	return s
-}
-
-func (rr *OPT) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	for _, o := range rr.Option {
-		l += 4 // Account for 2-byte option code and 2-byte option length.
-		lo, _ := o.pack()
-		l += len(lo)
-	}
-	return l
-}
-
-func (*OPT) parse(c *zlexer, origin string) *ParseError {
-	return &ParseError{err: "OPT records do not have a presentation format"}
-}
-
-func (rr *OPT) isDuplicate(r2 RR) bool { return false }
-
-// Version returns the EDNS version used. Only zero is defined.
-func (rr *OPT) Version() uint8 {
-	return uint8(rr.Hdr.Ttl & 0x00FF0000 >> 16)
-}
-
-// SetVersion sets the version of EDNS. This is usually zero.
-func (rr *OPT) SetVersion(v uint8) {
-	rr.Hdr.Ttl = rr.Hdr.Ttl&0xFF00FFFF | uint32(v)<<16
-}
-
-// ExtendedRcode returns the EDNS extended RCODE field (the upper 8 bits of the TTL).
-func (rr *OPT) ExtendedRcode() int {
-	return int(rr.Hdr.Ttl&0xFF000000>>24) << 4
-}
-
-// SetExtendedRcode sets the EDNS extended RCODE field.
-//
-// If the RCODE is not an extended RCODE, will reset the extended RCODE field to 0.
-func (rr *OPT) SetExtendedRcode(v uint16) {
-	rr.Hdr.Ttl = rr.Hdr.Ttl&0x00FFFFFF | uint32(v>>4)<<24
-}
-
-// UDPSize returns the UDP buffer size.
-func (rr *OPT) UDPSize() uint16 {
-	return rr.Hdr.Class
-}
-
-// SetUDPSize sets the UDP buffer size.
-func (rr *OPT) SetUDPSize(size uint16) {
-	rr.Hdr.Class = size
-}
-
-// Do returns the value of the DO (DNSSEC OK) bit.
-func (rr *OPT) Do() bool {
-	return rr.Hdr.Ttl&_DO == _DO
-}
-
-// SetDo sets the DO (DNSSEC OK) bit.
-// If we pass an argument, set the DO bit to that value.
-// It is possible to pass 2 or more arguments, but they will be ignored.
-func (rr *OPT) SetDo(do ...bool) {
-	if len(do) == 1 {
-		if do[0] {
-			rr.Hdr.Ttl |= _DO
-		} else {
-			rr.Hdr.Ttl &^= _DO
-		}
-	} else {
-		rr.Hdr.Ttl |= _DO
-	}
-}
-
-// Co returns the value of the CO (Compact Answers OK) bit.
-func (rr *OPT) Co() bool {
-	return rr.Hdr.Ttl&_CO == _CO
-}
-
-// SetCo sets the CO (Compact Answers OK) bit.
-// If we pass an argument, set the CO bit to that value.
-// It is possible to pass 2 or more arguments, but they will be ignored.
-func (rr *OPT) SetCo(co ...bool) {
-	if len(co) == 1 {
-		if co[0] {
-			rr.Hdr.Ttl |= _CO
-		} else {
-			rr.Hdr.Ttl &^= _CO
-		}
-	} else {
-		rr.Hdr.Ttl |= _CO
-	}
-}
-
-// Z returns the Z part of the OPT RR as a uint16 with only the 14 least significant bits used.
-func (rr *OPT) Z() uint16 {
-	return uint16(rr.Hdr.Ttl & 0x3FFF)
-}
-
-// SetZ sets the Z part of the OPT RR, note only the 14 least significant bits of z are used.
-func (rr *OPT) SetZ(z uint16) {
-	rr.Hdr.Ttl = rr.Hdr.Ttl&^0x3FFF | uint32(z&0x3FFF)
-}
-
-// EDNS0 defines an EDNS0 Option. An OPT RR can have multiple options appended to it.
-type EDNS0 interface {
-	// Option returns the option code for the option.
-	Option() uint16
-	// pack returns the bytes of the option data.
-	pack() ([]byte, error)
-	// unpack sets the data as found in the buffer. Is also sets
-	// the length of the slice as the length of the option data.
-	unpack([]byte) error
-	// String returns the string representation of the option.
-	String() string
-	// copy returns a deep-copy of the option.
-	copy() EDNS0
-}
-
-// EDNS0_NSID option is used to retrieve a nameserver
-// identifier. When sending a request Nsid must be set to the empty string
-// The identifier is an opaque string encoded as hex.
-// Basic use pattern for creating an nsid option:
-//
-//	o := new(dns.OPT)
-//	o.Hdr.Name = "."
-//	o.Hdr.Rrtype = dns.TypeOPT
-//	e := new(dns.EDNS0_NSID)
-//	e.Code = dns.EDNS0NSID
-//	e.Nsid = "AA"
-//	o.Option = append(o.Option, e)
-type EDNS0_NSID struct {
-	Code uint16 // always EDNS0NSID
-	Nsid string // string needs to be hex encoded
-}
-
-func (e *EDNS0_NSID) pack() ([]byte, error) {
-	h, err := hex.DecodeString(e.Nsid)
-	if err != nil {
-		return nil, err
-	}
-	return h, nil
-}
-
-// Option implements the EDNS0 interface.
-func (e *EDNS0_NSID) Option() uint16        { return EDNS0NSID } // Option returns the option code.
-func (e *EDNS0_NSID) unpack(b []byte) error { e.Nsid = hex.EncodeToString(b); return nil }
-func (e *EDNS0_NSID) String() string        { return e.Nsid }
-func (e *EDNS0_NSID) copy() EDNS0           { return &EDNS0_NSID{e.Code, e.Nsid} }
-
-// EDNS0_SUBNET is the subnet option that is used to give the remote nameserver
-// an idea of where the client lives. See RFC 7871. It can then give back a different
-// answer depending on the location or network topology.
-// Basic use pattern for creating an subnet option:
-//
-//	o := new(dns.OPT)
-//	o.Hdr.Name = "."
-//	o.Hdr.Rrtype = dns.TypeOPT
-//	e := new(dns.EDNS0_SUBNET)
-//	e.Code = dns.EDNS0SUBNET // by default this is filled in through unpacking OPT packets (unpackDataOpt)
-//	e.Family = 1	// 1 for IPv4 source address, 2 for IPv6
-//	e.SourceNetmask = 32	// 32 for IPV4, 128 for IPv6
-//	e.SourceScope = 0
-//	e.Address = net.ParseIP("127.0.0.1").To4()	// for IPv4
-//	// e.Address = net.ParseIP("2001:7b8:32a::2")	// for IPV6
-//	o.Option = append(o.Option, e)
-//
-// This code will parse all the available bits when unpacking (up to optlen).
-// When packing it will apply SourceNetmask. If you need more advanced logic,
-// patches welcome and good luck.
-type EDNS0_SUBNET struct {
-	Code          uint16 // always EDNS0SUBNET
-	Family        uint16 // 1 for IP, 2 for IP6
-	SourceNetmask uint8
-	SourceScope   uint8
-	Address       net.IP
-}
-
-// Option implements the EDNS0 interface.
-func (e *EDNS0_SUBNET) Option() uint16 { return EDNS0SUBNET }
-
-func (e *EDNS0_SUBNET) pack() ([]byte, error) {
-	switch e.Family {
-	case 0:
-		// "dig" sets AddressFamily to 0 if SourceNetmask is also 0
-		// We might don't need to complain either
-		if e.SourceNetmask != 0 {
-			return nil, errors.New("bad address family")
-		}
-		b := make([]byte, 4)
-		b[3] = e.SourceScope
-		return b, nil
-	case 1:
-		if e.SourceNetmask > net.IPv4len*8 {
-			return nil, errors.New("bad netmask")
-		}
-		ip4 := e.Address.To4()
-		if len(ip4) != net.IPv4len {
-			return nil, errors.New("bad address")
-		}
-		needLength := (e.SourceNetmask + 8 - 1) / 8 // division rounding up
-		b := make([]byte, 4+needLength)
-		binary.BigEndian.PutUint16(b[0:], e.Family)
-		b[2] = e.SourceNetmask
-		b[3] = e.SourceScope
-		if needLength > 0 {
-			ip := ip4.Mask(net.CIDRMask(int(e.SourceNetmask), net.IPv4len*8))
-			copy(b[4:], ip[:needLength])
-		}
-		return b, nil
-	case 2:
-		if e.SourceNetmask > net.IPv6len*8 {
-			return nil, errors.New("bad netmask")
-		}
-		if len(e.Address) != net.IPv6len {
-			return nil, errors.New("bad address")
-		}
-		needLength := (e.SourceNetmask + 8 - 1) / 8 // division rounding up
-		b := make([]byte, 4+needLength)
-		binary.BigEndian.PutUint16(b[0:], e.Family)
-		b[2] = e.SourceNetmask
-		b[3] = e.SourceScope
-		if needLength > 0 {
-			ip := e.Address.Mask(net.CIDRMask(int(e.SourceNetmask), net.IPv6len*8))
-			copy(b[4:], ip[:needLength])
-		}
-		return b, nil
-	default:
-		return nil, errors.New("bad address family")
-	}
-}
-
-func (e *EDNS0_SUBNET) unpack(b []byte) error {
-	if len(b) < 4 {
-		return ErrBuf
-	}
-	e.Family = binary.BigEndian.Uint16(b)
-	e.SourceNetmask = b[2]
-	e.SourceScope = b[3]
-	switch e.Family {
-	case 0:
-		// "dig" sets AddressFamily to 0 if SourceNetmask is also 0
-		// It's okay to accept such a packet
-		if e.SourceNetmask != 0 {
-			return errors.New("bad address family")
-		}
-		e.Address = net.IPv4(0, 0, 0, 0)
-	case 1:
-		if e.SourceNetmask > net.IPv4len*8 || e.SourceScope > net.IPv4len*8 {
-			return errors.New("bad netmask")
-		}
-		addr := make(net.IP, net.IPv4len)
-		copy(addr, b[4:])
-		e.Address = addr.To16()
-	case 2:
-		if e.SourceNetmask > net.IPv6len*8 || e.SourceScope > net.IPv6len*8 {
-			return errors.New("bad netmask")
-		}
-		addr := make(net.IP, net.IPv6len)
-		copy(addr, b[4:])
-		e.Address = addr
-	default:
-		return errors.New("bad address family")
-	}
-	return nil
-}
-
-func (e *EDNS0_SUBNET) String() (s string) {
-	if e.Address == nil {
-		s = "<nil>"
-	} else if e.Address.To4() != nil {
-		s = e.Address.String()
-	} else {
-		s = "[" + e.Address.String() + "]"
-	}
-	s += "/" + strconv.Itoa(int(e.SourceNetmask)) + "/" + strconv.Itoa(int(e.SourceScope))
-	return
-}
-
-func (e *EDNS0_SUBNET) copy() EDNS0 {
-	return &EDNS0_SUBNET{
-		e.Code,
-		e.Family,
-		e.SourceNetmask,
-		e.SourceScope,
-		e.Address,
-	}
-}
-
-// The EDNS0_COOKIE option is used to add a DNS Cookie to a message.
-//
-//	o := new(dns.OPT)
-//	o.Hdr.Name = "."
-//	o.Hdr.Rrtype = dns.TypeOPT
-//	e := new(dns.EDNS0_COOKIE)
-//	e.Code = dns.EDNS0COOKIE
-//	e.Cookie = "24a5ac.."
-//	o.Option = append(o.Option, e)
-//
-// The Cookie field consists out of a client cookie (RFC 7873 Section 4), that is
-// always 8 bytes. It may then optionally be followed by the server cookie. The server
-// cookie is of variable length, 8 to a maximum of 32 bytes. In other words:
-//
-//	cCookie := o.Cookie[:16]
-//	sCookie := o.Cookie[16:]
-//
-// There is no guarantee that the Cookie string has a specific length.
-type EDNS0_COOKIE struct {
-	Code   uint16 // always EDNS0COOKIE
-	Cookie string // hex encoded cookie data
-}
-
-func (e *EDNS0_COOKIE) pack() ([]byte, error) {
-	h, err := hex.DecodeString(e.Cookie)
-	if err != nil {
-		return nil, err
-	}
-	return h, nil
-}
-
-// Option implements the EDNS0 interface.
-func (e *EDNS0_COOKIE) Option() uint16        { return EDNS0COOKIE }
-func (e *EDNS0_COOKIE) unpack(b []byte) error { e.Cookie = hex.EncodeToString(b); return nil }
-func (e *EDNS0_COOKIE) String() string        { return e.Cookie }
-func (e *EDNS0_COOKIE) copy() EDNS0           { return &EDNS0_COOKIE{e.Code, e.Cookie} }
-
-// The EDNS0_UL (Update Lease) (draft RFC) option is used to tell the server to set
-// an expiration on an update RR. This is helpful for clients that cannot clean
-// up after themselves. This is a draft RFC and more information can be found at
-// https://tools.ietf.org/html/draft-sekar-dns-ul-02
-//
-//	o := new(dns.OPT)
-//	o.Hdr.Name = "."
-//	o.Hdr.Rrtype = dns.TypeOPT
-//	e := new(dns.EDNS0_UL)
-//	e.Code = dns.EDNS0UL
-//	e.Lease = 120 // in seconds
-//	o.Option = append(o.Option, e)
-type EDNS0_UL struct {
-	Code     uint16 // always EDNS0UL
-	Lease    uint32
-	KeyLease uint32
-}
-
-// Option implements the EDNS0 interface.
-func (e *EDNS0_UL) Option() uint16 { return EDNS0UL }
-func (e *EDNS0_UL) String() string { return fmt.Sprintf("%d %d", e.Lease, e.KeyLease) }
-func (e *EDNS0_UL) copy() EDNS0    { return &EDNS0_UL{e.Code, e.Lease, e.KeyLease} }
-
-// Copied: http://golang.org/src/pkg/net/dnsmsg.go
-func (e *EDNS0_UL) pack() ([]byte, error) {
-	var b []byte
-	if e.KeyLease == 0 {
-		b = make([]byte, 4)
-	} else {
-		b = make([]byte, 8)
-		binary.BigEndian.PutUint32(b[4:], e.KeyLease)
-	}
-	binary.BigEndian.PutUint32(b, e.Lease)
-	return b, nil
-}
-
-func (e *EDNS0_UL) unpack(b []byte) error {
-	switch len(b) {
-	case 4:
-		e.KeyLease = 0
-	case 8:
-		e.KeyLease = binary.BigEndian.Uint32(b[4:])
-	default:
-		return ErrBuf
-	}
-	e.Lease = binary.BigEndian.Uint32(b)
-	return nil
-}
-
-// EDNS0_LLQ stands for Long Lived Queries: http://tools.ietf.org/html/draft-sekar-dns-llq-01
-// Implemented for completeness, as the EDNS0 type code is assigned.
-type EDNS0_LLQ struct {
-	Code      uint16 // always EDNS0LLQ
-	Version   uint16
-	Opcode    uint16
-	Error     uint16
-	Id        uint64
-	LeaseLife uint32
-}
-
-// Option implements the EDNS0 interface.
-func (e *EDNS0_LLQ) Option() uint16 { return EDNS0LLQ }
-
-func (e *EDNS0_LLQ) pack() ([]byte, error) {
-	b := make([]byte, 18)
-	binary.BigEndian.PutUint16(b[0:], e.Version)
-	binary.BigEndian.PutUint16(b[2:], e.Opcode)
-	binary.BigEndian.PutUint16(b[4:], e.Error)
-	binary.BigEndian.PutUint64(b[6:], e.Id)
-	binary.BigEndian.PutUint32(b[14:], e.LeaseLife)
-	return b, nil
-}
-
-func (e *EDNS0_LLQ) unpack(b []byte) error {
-	if len(b) < 18 {
-		return ErrBuf
-	}
-	e.Version = binary.BigEndian.Uint16(b[0:])
-	e.Opcode = binary.BigEndian.Uint16(b[2:])
-	e.Error = binary.BigEndian.Uint16(b[4:])
-	e.Id = binary.BigEndian.Uint64(b[6:])
-	e.LeaseLife = binary.BigEndian.Uint32(b[14:])
-	return nil
-}
-
-func (e *EDNS0_LLQ) String() string {
-	s := strconv.FormatUint(uint64(e.Version), 10) + " " + strconv.FormatUint(uint64(e.Opcode), 10) +
-		" " + strconv.FormatUint(uint64(e.Error), 10) + " " + strconv.FormatUint(e.Id, 10) +
-		" " + strconv.FormatUint(uint64(e.LeaseLife), 10)
-	return s
-}
-
-func (e *EDNS0_LLQ) copy() EDNS0 {
-	return &EDNS0_LLQ{e.Code, e.Version, e.Opcode, e.Error, e.Id, e.LeaseLife}
-}
-
-// EDNS0_DAU implements the EDNS0 "DNSSEC Algorithm Understood" option. See RFC 6975.
-type EDNS0_DAU struct {
-	Code    uint16 // always EDNS0DAU
-	AlgCode []uint8
-}
-
-// Option implements the EDNS0 interface.
-func (e *EDNS0_DAU) Option() uint16        { return EDNS0DAU }
-func (e *EDNS0_DAU) pack() ([]byte, error) { return cloneSlice(e.AlgCode), nil }
-func (e *EDNS0_DAU) unpack(b []byte) error { e.AlgCode = cloneSlice(b); return nil }
-
-func (e *EDNS0_DAU) String() string {
-	s := ""
-	for _, alg := range e.AlgCode {
-		if a, ok := AlgorithmToString[alg]; ok {
-			s += " " + a
-		} else {
-			s += " " + strconv.Itoa(int(alg))
-		}
-	}
-	return s
-}
-func (e *EDNS0_DAU) copy() EDNS0 { return &EDNS0_DAU{e.Code, e.AlgCode} }
-
-// EDNS0_DHU implements the EDNS0 "DS Hash Understood" option. See RFC 6975.
-type EDNS0_DHU struct {
-	Code    uint16 // always EDNS0DHU
-	AlgCode []uint8
-}
-
-// Option implements the EDNS0 interface.
-func (e *EDNS0_DHU) Option() uint16        { return EDNS0DHU }
-func (e *EDNS0_DHU) pack() ([]byte, error) { return cloneSlice(e.AlgCode), nil }
-func (e *EDNS0_DHU) unpack(b []byte) error { e.AlgCode = cloneSlice(b); return nil }
-
-func (e *EDNS0_DHU) String() string {
-	s := ""
-	for _, alg := range e.AlgCode {
-		if a, ok := HashToString[alg]; ok {
-			s += " " + a
-		} else {
-			s += " " + strconv.Itoa(int(alg))
-		}
-	}
-	return s
-}
-func (e *EDNS0_DHU) copy() EDNS0 { return &EDNS0_DHU{e.Code, e.AlgCode} }
-
-// EDNS0_N3U implements the EDNS0 "NSEC3 Hash Understood" option. See RFC 6975.
-type EDNS0_N3U struct {
-	Code    uint16 // always EDNS0N3U
-	AlgCode []uint8
-}
-
-// Option implements the EDNS0 interface.
-func (e *EDNS0_N3U) Option() uint16        { return EDNS0N3U }
-func (e *EDNS0_N3U) pack() ([]byte, error) { return cloneSlice(e.AlgCode), nil }
-func (e *EDNS0_N3U) unpack(b []byte) error { e.AlgCode = cloneSlice(b); return nil }
-
-func (e *EDNS0_N3U) String() string {
-	// Re-use the hash map
-	s := ""
-	for _, alg := range e.AlgCode {
-		if a, ok := HashToString[alg]; ok {
-			s += " " + a
-		} else {
-			s += " " + strconv.Itoa(int(alg))
-		}
-	}
-	return s
-}
-func (e *EDNS0_N3U) copy() EDNS0 { return &EDNS0_N3U{e.Code, e.AlgCode} }
-
-// EDNS0_EXPIRE implements the EDNS0 option as described in RFC 7314.
-type EDNS0_EXPIRE struct {
-	Code   uint16 // always EDNS0EXPIRE
-	Expire uint32
-	Empty  bool // Empty is used to signal an empty Expire option in a backwards compatible way, it's not used on the wire.
-}
-
-// Option implements the EDNS0 interface.
-func (e *EDNS0_EXPIRE) Option() uint16 { return EDNS0EXPIRE }
-func (e *EDNS0_EXPIRE) copy() EDNS0    { return &EDNS0_EXPIRE{e.Code, e.Expire, e.Empty} }
-
-func (e *EDNS0_EXPIRE) pack() ([]byte, error) {
-	if e.Empty {
-		return []byte{}, nil
-	}
-	b := make([]byte, 4)
-	binary.BigEndian.PutUint32(b, e.Expire)
-	return b, nil
-}
-
-func (e *EDNS0_EXPIRE) unpack(b []byte) error {
-	if len(b) == 0 {
-		// zero-length EXPIRE query, see RFC 7314 Section 2
-		e.Empty = true
-		return nil
-	}
-	if len(b) < 4 {
-		return ErrBuf
-	}
-	e.Expire = binary.BigEndian.Uint32(b)
-	e.Empty = false
-	return nil
-}
-
-func (e *EDNS0_EXPIRE) String() (s string) {
-	if e.Empty {
-		return ""
-	}
-	return strconv.FormatUint(uint64(e.Expire), 10)
-}
-
-// The EDNS0_LOCAL option is used for local/experimental purposes. The option
-// code is recommended to be within the range [EDNS0LOCALSTART, EDNS0LOCALEND]
-// (RFC6891), although any unassigned code can actually be used.  The content of
-// the option is made available in Data, unaltered.
-// Basic use pattern for creating a local option:
-//
-//	o := new(dns.OPT)
-//	o.Hdr.Name = "."
-//	o.Hdr.Rrtype = dns.TypeOPT
-//	e := new(dns.EDNS0_LOCAL)
-//	e.Code = dns.EDNS0LOCALSTART
-//	e.Data = []byte{72, 82, 74}
-//	o.Option = append(o.Option, e)
-type EDNS0_LOCAL struct {
-	Code uint16
-	Data []byte
-}
-
-// Option implements the EDNS0 interface.
-func (e *EDNS0_LOCAL) Option() uint16 { return e.Code }
-
-func (e *EDNS0_LOCAL) String() string {
-	return strconv.FormatInt(int64(e.Code), 10) + ":0x" + hex.EncodeToString(e.Data)
-}
-
-func (e *EDNS0_LOCAL) copy() EDNS0 {
-	return &EDNS0_LOCAL{e.Code, cloneSlice(e.Data)}
-}
-
-func (e *EDNS0_LOCAL) pack() ([]byte, error) {
-	return cloneSlice(e.Data), nil
-}
-
-func (e *EDNS0_LOCAL) unpack(b []byte) error {
-	e.Data = cloneSlice(b)
-	return nil
-}
-
-// EDNS0_TCP_KEEPALIVE is an EDNS0 option that instructs the server to keep
-// the TCP connection alive. See RFC 7828.
-type EDNS0_TCP_KEEPALIVE struct {
-	Code uint16 // always EDNSTCPKEEPALIVE
-
-	// Timeout is an idle timeout value for the TCP connection, specified in
-	// units of 100 milliseconds, encoded in network byte order. If set to 0,
-	// pack will return a nil slice.
-	Timeout uint16
-
-	// Length is the option's length.
-	// Deprecated: this field is deprecated and is always equal to 0.
-	Length uint16
-}
-
-// Option implements the EDNS0 interface.
-func (e *EDNS0_TCP_KEEPALIVE) Option() uint16 { return EDNS0TCPKEEPALIVE }
-
-func (e *EDNS0_TCP_KEEPALIVE) pack() ([]byte, error) {
-	if e.Timeout > 0 {
-		b := make([]byte, 2)
-		binary.BigEndian.PutUint16(b, e.Timeout)
-		return b, nil
-	}
-	return nil, nil
-}
-
-func (e *EDNS0_TCP_KEEPALIVE) unpack(b []byte) error {
-	switch len(b) {
-	case 0:
-	case 2:
-		e.Timeout = binary.BigEndian.Uint16(b)
-	default:
-		return fmt.Errorf("length mismatch, want 0/2 but got %d", len(b))
-	}
-	return nil
-}
-
-func (e *EDNS0_TCP_KEEPALIVE) String() string {
-	s := "use tcp keep-alive"
-	if e.Timeout == 0 {
-		s += ", timeout omitted"
-	} else {
-		s += fmt.Sprintf(", timeout %dms", e.Timeout*100)
-	}
-	return s
-}
-
-func (e *EDNS0_TCP_KEEPALIVE) copy() EDNS0 { return &EDNS0_TCP_KEEPALIVE{e.Code, e.Timeout, e.Length} }
-
-// EDNS0_PADDING option is used to add padding to a request/response. The default
-// value of padding SHOULD be 0x0 but other values MAY be used, for instance if
-// compression is applied before encryption which may break signatures.
-type EDNS0_PADDING struct {
-	Padding []byte
-}
-
-// Option implements the EDNS0 interface.
-func (e *EDNS0_PADDING) Option() uint16        { return EDNS0PADDING }
-func (e *EDNS0_PADDING) pack() ([]byte, error) { return cloneSlice(e.Padding), nil }
-func (e *EDNS0_PADDING) unpack(b []byte) error { e.Padding = cloneSlice(b); return nil }
-func (e *EDNS0_PADDING) String() string        { return fmt.Sprintf("%0X", e.Padding) }
-func (e *EDNS0_PADDING) copy() EDNS0           { return &EDNS0_PADDING{cloneSlice(e.Padding)} }
-
-// Extended DNS Error Codes (RFC 8914).
-const (
-	ExtendedErrorCodeOther uint16 = iota
-	ExtendedErrorCodeUnsupportedDNSKEYAlgorithm
-	ExtendedErrorCodeUnsupportedDSDigestType
-	ExtendedErrorCodeStaleAnswer
-	ExtendedErrorCodeForgedAnswer
-	ExtendedErrorCodeDNSSECIndeterminate
-	ExtendedErrorCodeDNSBogus
-	ExtendedErrorCodeSignatureExpired
-	ExtendedErrorCodeSignatureNotYetValid
-	ExtendedErrorCodeDNSKEYMissing
-	ExtendedErrorCodeRRSIGsMissing
-	ExtendedErrorCodeNoZoneKeyBitSet
-	ExtendedErrorCodeNSECMissing
-	ExtendedErrorCodeCachedError
-	ExtendedErrorCodeNotReady
-	ExtendedErrorCodeBlocked
-	ExtendedErrorCodeCensored
-	ExtendedErrorCodeFiltered
-	ExtendedErrorCodeProhibited
-	ExtendedErrorCodeStaleNXDOMAINAnswer
-	ExtendedErrorCodeNotAuthoritative
-	ExtendedErrorCodeNotSupported
-	ExtendedErrorCodeNoReachableAuthority
-	ExtendedErrorCodeNetworkError
-	ExtendedErrorCodeInvalidData
-	ExtendedErrorCodeSignatureExpiredBeforeValid
-	ExtendedErrorCodeTooEarly
-	ExtendedErrorCodeUnsupportedNSEC3IterValue
-	ExtendedErrorCodeUnableToConformToPolicy
-	ExtendedErrorCodeSynthesized
-	ExtendedErrorCodeInvalidQueryType
-)
-
-// ExtendedErrorCodeToString maps extended error info codes to a human readable
-// description.
-var ExtendedErrorCodeToString = map[uint16]string{
-	ExtendedErrorCodeOther:                       "Other",
-	ExtendedErrorCodeUnsupportedDNSKEYAlgorithm:  "Unsupported DNSKEY Algorithm",
-	ExtendedErrorCodeUnsupportedDSDigestType:     "Unsupported DS Digest Type",
-	ExtendedErrorCodeStaleAnswer:                 "Stale Answer",
-	ExtendedErrorCodeForgedAnswer:                "Forged Answer",
-	ExtendedErrorCodeDNSSECIndeterminate:         "DNSSEC Indeterminate",
-	ExtendedErrorCodeDNSBogus:                    "DNSSEC Bogus",
-	ExtendedErrorCodeSignatureExpired:            "Signature Expired",
-	ExtendedErrorCodeSignatureNotYetValid:        "Signature Not Yet Valid",
-	ExtendedErrorCodeDNSKEYMissing:               "DNSKEY Missing",
-	ExtendedErrorCodeRRSIGsMissing:               "RRSIGs Missing",
-	ExtendedErrorCodeNoZoneKeyBitSet:             "No Zone Key Bit Set",
-	ExtendedErrorCodeNSECMissing:                 "NSEC Missing",
-	ExtendedErrorCodeCachedError:                 "Cached Error",
-	ExtendedErrorCodeNotReady:                    "Not Ready",
-	ExtendedErrorCodeBlocked:                     "Blocked",
-	ExtendedErrorCodeCensored:                    "Censored",
-	ExtendedErrorCodeFiltered:                    "Filtered",
-	ExtendedErrorCodeProhibited:                  "Prohibited",
-	ExtendedErrorCodeStaleNXDOMAINAnswer:         "Stale NXDOMAIN Answer",
-	ExtendedErrorCodeNotAuthoritative:            "Not Authoritative",
-	ExtendedErrorCodeNotSupported:                "Not Supported",
-	ExtendedErrorCodeNoReachableAuthority:        "No Reachable Authority",
-	ExtendedErrorCodeNetworkError:                "Network Error",
-	ExtendedErrorCodeInvalidData:                 "Invalid Data",
-	ExtendedErrorCodeSignatureExpiredBeforeValid: "Signature Expired Before Valid",
-	ExtendedErrorCodeTooEarly:                    "Too Early",
-	ExtendedErrorCodeUnsupportedNSEC3IterValue:   "Unsupported NSEC3 Iterations Value",
-	ExtendedErrorCodeUnableToConformToPolicy:     "Unable To Conform To Policy",
-	ExtendedErrorCodeSynthesized:                 "Synthesized",
-	ExtendedErrorCodeInvalidQueryType:            "Invalid Query Type",
-}
-
-// StringToExtendedErrorCode is a map from human readable descriptions to
-// extended error info codes.
-var StringToExtendedErrorCode = reverseInt16(ExtendedErrorCodeToString)
-
-// EDNS0_EDE option is used to return additional information about the cause of
-// DNS errors.
-type EDNS0_EDE struct {
-	InfoCode  uint16
-	ExtraText string
-}
-
-// Option implements the EDNS0 interface.
-func (e *EDNS0_EDE) Option() uint16 { return EDNS0EDE }
-func (e *EDNS0_EDE) copy() EDNS0    { return &EDNS0_EDE{e.InfoCode, e.ExtraText} }
-
-func (e *EDNS0_EDE) String() string {
-	info := strconv.FormatUint(uint64(e.InfoCode), 10)
-	if s, ok := ExtendedErrorCodeToString[e.InfoCode]; ok {
-		info += fmt.Sprintf(" (%s)", s)
-	}
-	return fmt.Sprintf("%s: (%s)", info, e.ExtraText)
-}
-
-func (e *EDNS0_EDE) pack() ([]byte, error) {
-	b := make([]byte, 2+len(e.ExtraText))
-	binary.BigEndian.PutUint16(b[0:], e.InfoCode)
-	copy(b[2:], e.ExtraText)
-	return b, nil
-}
-
-func (e *EDNS0_EDE) unpack(b []byte) error {
-	if len(b) < 2 {
-		return ErrBuf
-	}
-	e.InfoCode = binary.BigEndian.Uint16(b[0:])
-	e.ExtraText = string(b[2:])
-	return nil
-}
-
-// The EDNS0_ESU option for ENUM Source-URI Extension.
-type EDNS0_ESU struct {
-	Code uint16 // always EDNS0ESU
-	Uri  string
-}
-
-func (e *EDNS0_ESU) Option() uint16        { return EDNS0ESU }
-func (e *EDNS0_ESU) String() string        { return e.Uri }
-func (e *EDNS0_ESU) copy() EDNS0           { return &EDNS0_ESU{e.Code, e.Uri} }
-func (e *EDNS0_ESU) pack() ([]byte, error) { return []byte(e.Uri), nil }
-func (e *EDNS0_ESU) unpack(b []byte) error {
-	e.Uri = string(b)
-	return nil
-}
-
-// EDNS0_REPORTING implements the EDNS0 Reporting Channel option (RFC 9567).
-type EDNS0_REPORTING struct {
-	Code        uint16 // always EDNS0REPORTING
-	AgentDomain string
-}
-
-func (e *EDNS0_REPORTING) Option() uint16 { return EDNS0REPORTING }
-func (e *EDNS0_REPORTING) String() string { return e.AgentDomain }
-func (e *EDNS0_REPORTING) copy() EDNS0    { return &EDNS0_REPORTING{e.Code, e.AgentDomain} }
-func (e *EDNS0_REPORTING) pack() ([]byte, error) {
-	b := make([]byte, 255)
-	off1, err := PackDomainName(Fqdn(e.AgentDomain), b, 0, nil, false)
-	if err != nil {
-		return nil, fmt.Errorf("bad agent domain: %w", err)
-	}
-	return b[:off1], nil
-}
-func (e *EDNS0_REPORTING) unpack(b []byte) error {
-	domain, _, err := UnpackDomainName(b, 0)
-	if err != nil {
-		return fmt.Errorf("bad agent domain: %w", err)
-	}
-	e.AgentDomain = domain
-	return nil
-}
-
-// EDNS0_ZONEVERSION implements the EDNS0 Zone Version option (RFC 9660).
-type EDNS0_ZONEVERSION struct {
-	// always EDNS0ZONEVERSION (19)
-	Code uint16
-	// An unsigned 1-octet Label Count indicating
-	// the number of labels for the name of the zone that VERSION value refers to.
-	LabelCount uint8
-	// An unsigned 1-octet type number distinguishing the format and meaning of version.
-	// 0 SOA-SERIAL, 1-245 Unassigned, 246-255 Reserved for private use, see RFC 9660.
-	Type uint8
-	// An opaque octet string conveying the zone version data (VERSION).
-	Version string
-}
-
-func (e *EDNS0_ZONEVERSION) Option() uint16 { return EDNS0ZONEVERSION }
-func (e *EDNS0_ZONEVERSION) String() string { return e.Version }
-func (e *EDNS0_ZONEVERSION) copy() EDNS0 {
-	return &EDNS0_ZONEVERSION{e.Code, e.LabelCount, e.Type, e.Version}
-}
-func (e *EDNS0_ZONEVERSION) pack() ([]byte, error) {
-	b := []byte{
-		// first octet label count
-		e.LabelCount,
-		// second octet is type
-		e.Type,
-	}
-	if len(e.Version) > 0 {
-		b = append(b, []byte(e.Version)...)
-	}
-	return b, nil
-}
-func (e *EDNS0_ZONEVERSION) unpack(b []byte) error {
-	if len(b) < 2 {
-		return ErrBuf
-	}
-	e.LabelCount = b[0]
-	e.Type = b[1]
-	if len(b) > 2 {
-		e.Version = string(b[2:])
-	} else {
-		e.Version = ""
-	}
-	return nil
-}
diff --git a/vendor/github.com/miekg/dns/format.go b/vendor/github.com/miekg/dns/format.go
deleted file mode 100644
index 0ec79f2fc1..0000000000
--- a/vendor/github.com/miekg/dns/format.go
+++ /dev/null
@@ -1,93 +0,0 @@
-package dns
-
-import (
-	"net"
-	"reflect"
-	"strconv"
-)
-
-// NumField returns the number of rdata fields r has.
-func NumField(r RR) int {
-	return reflect.ValueOf(r).Elem().NumField() - 1 // Remove RR_Header
-}
-
-// Field returns the rdata field i as a string. Fields are indexed starting from 1.
-// RR types that holds slice data, for instance the NSEC type bitmap will return a single
-// string where the types are concatenated using a space.
-// Accessing non existing fields will cause a panic.
-func Field(r RR, i int) string {
-	if i == 0 {
-		return ""
-	}
-	d := reflect.ValueOf(r).Elem().Field(i)
-	switch d.Kind() {
-	case reflect.String:
-		return d.String()
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		return strconv.FormatInt(d.Int(), 10)
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return strconv.FormatUint(d.Uint(), 10)
-	case reflect.Slice:
-		switch reflect.ValueOf(r).Elem().Type().Field(i).Tag {
-		case `dns:"a"`:
-			// TODO(miek): Hmm store this as 16 bytes
-			if d.Len() < net.IPv4len {
-				return ""
-			}
-			if d.Len() < net.IPv6len {
-				return net.IPv4(byte(d.Index(0).Uint()),
-					byte(d.Index(1).Uint()),
-					byte(d.Index(2).Uint()),
-					byte(d.Index(3).Uint())).String()
-			}
-			return net.IPv4(byte(d.Index(12).Uint()),
-				byte(d.Index(13).Uint()),
-				byte(d.Index(14).Uint()),
-				byte(d.Index(15).Uint())).String()
-		case `dns:"aaaa"`:
-			if d.Len() < net.IPv6len {
-				return ""
-			}
-			return net.IP{
-				byte(d.Index(0).Uint()),
-				byte(d.Index(1).Uint()),
-				byte(d.Index(2).Uint()),
-				byte(d.Index(3).Uint()),
-				byte(d.Index(4).Uint()),
-				byte(d.Index(5).Uint()),
-				byte(d.Index(6).Uint()),
-				byte(d.Index(7).Uint()),
-				byte(d.Index(8).Uint()),
-				byte(d.Index(9).Uint()),
-				byte(d.Index(10).Uint()),
-				byte(d.Index(11).Uint()),
-				byte(d.Index(12).Uint()),
-				byte(d.Index(13).Uint()),
-				byte(d.Index(14).Uint()),
-				byte(d.Index(15).Uint()),
-			}.String()
-		case `dns:"nsec"`:
-			if d.Len() == 0 {
-				return ""
-			}
-			s := Type(d.Index(0).Uint()).String()
-			for i := 1; i < d.Len(); i++ {
-				s += " " + Type(d.Index(i).Uint()).String()
-			}
-			return s
-		default:
-			// if it does not have a tag its a string slice
-			fallthrough
-		case `dns:"txt"`:
-			if d.Len() == 0 {
-				return ""
-			}
-			s := d.Index(0).String()
-			for i := 1; i < d.Len(); i++ {
-				s += " " + d.Index(i).String()
-			}
-			return s
-		}
-	}
-	return ""
-}
diff --git a/vendor/github.com/miekg/dns/fuzz.go b/vendor/github.com/miekg/dns/fuzz.go
deleted file mode 100644
index 505ae43086..0000000000
--- a/vendor/github.com/miekg/dns/fuzz.go
+++ /dev/null
@@ -1,33 +0,0 @@
-//go:build fuzz
-// +build fuzz
-
-package dns
-
-import "strings"
-
-func Fuzz(data []byte) int {
-	msg := new(Msg)
-
-	if err := msg.Unpack(data); err != nil {
-		return 0
-	}
-	if _, err := msg.Pack(); err != nil {
-		return 0
-	}
-
-	return 1
-}
-
-func FuzzNewRR(data []byte) int {
-	str := string(data)
-	// Do not fuzz lines that include the $INCLUDE keyword and hint the fuzzer
-	// at avoiding them.
-	// See GH#1025 for context.
-	if strings.Contains(strings.ToUpper(str), "$INCLUDE") {
-		return -1
-	}
-	if _, err := NewRR(str); err != nil {
-		return 0
-	}
-	return 1
-}
diff --git a/vendor/github.com/miekg/dns/generate.go b/vendor/github.com/miekg/dns/generate.go
deleted file mode 100644
index a81d2bc51f..0000000000
--- a/vendor/github.com/miekg/dns/generate.go
+++ /dev/null
@@ -1,248 +0,0 @@
-package dns
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"strconv"
-	"strings"
-)
-
-// Parse the $GENERATE statement as used in BIND9 zones.
-// See http://www.zytrax.com/books/dns/ch8/generate.html for instance.
-// We are called after '$GENERATE '. After which we expect:
-// * the range (12-24/2)
-// * lhs (ownername)
-// * [[ttl][class]]
-// * type
-// * rhs (rdata)
-// But we are lazy here, only the range is parsed *all* occurrences
-// of $ after that are interpreted.
-func (zp *ZoneParser) generate(l lex) (RR, bool) {
-	token := l.token
-	step := int64(1)
-	if i := strings.IndexByte(token, '/'); i >= 0 {
-		if i+1 == len(token) {
-			return zp.setParseError("bad step in $GENERATE range", l)
-		}
-
-		s, err := strconv.ParseInt(token[i+1:], 10, 64)
-		if err != nil || s <= 0 {
-			return zp.setParseError("bad step in $GENERATE range", l)
-		}
-
-		step = s
-		token = token[:i]
-	}
-
-	startStr, endStr, ok := strings.Cut(token, "-")
-	if !ok {
-		return zp.setParseError("bad start-stop in $GENERATE range", l)
-	}
-
-	start, err := strconv.ParseInt(startStr, 10, 64)
-	if err != nil {
-		return zp.setParseError("bad start in $GENERATE range", l)
-	}
-
-	end, err := strconv.ParseInt(endStr, 10, 64)
-	if err != nil {
-		return zp.setParseError("bad stop in $GENERATE range", l)
-	}
-	if end < 0 || start < 0 || end < start || (end-start)/step > 65535 {
-		return zp.setParseError("bad range in $GENERATE range", l)
-	}
-
-	// _BLANK
-	l, ok = zp.c.Next()
-	if !ok || l.value != zBlank {
-		return zp.setParseError("garbage after $GENERATE range", l)
-	}
-
-	// Create a complete new string, which we then parse again.
-	var s string
-	for l, ok := zp.c.Next(); ok; l, ok = zp.c.Next() {
-		if l.err {
-			return zp.setParseError("bad data in $GENERATE directive", l)
-		}
-		if l.value == zNewline {
-			break
-		}
-
-		s += l.token
-	}
-
-	r := &generateReader{
-		s: s,
-
-		cur:   start,
-		start: start,
-		end:   end,
-		step:  step,
-
-		file: zp.file,
-		lex:  &l,
-	}
-	zp.sub = NewZoneParser(r, zp.origin, zp.file)
-	zp.sub.includeDepth, zp.sub.includeAllowed = zp.includeDepth, zp.includeAllowed
-	zp.sub.generateDisallowed = true
-	zp.sub.SetDefaultTTL(defaultTtl)
-	return zp.subNext()
-}
-
-type generateReader struct {
-	s  string
-	si int
-
-	cur   int64
-	start int64
-	end   int64
-	step  int64
-
-	mod bytes.Buffer
-
-	escape bool
-
-	eof bool
-
-	file string
-	lex  *lex
-}
-
-func (r *generateReader) parseError(msg string, end int) *ParseError {
-	r.eof = true // Make errors sticky.
-
-	l := *r.lex
-	l.token = r.s[r.si-1 : end]
-	l.column += r.si // l.column starts one zBLANK before r.s
-
-	return &ParseError{file: r.file, err: msg, lex: l}
-}
-
-func (r *generateReader) Read(p []byte) (int, error) {
-	// NewZLexer, through NewZoneParser, should use ReadByte and
-	// not end up here.
-
-	panic("not implemented")
-}
-
-func (r *generateReader) ReadByte() (byte, error) {
-	if r.eof {
-		return 0, io.EOF
-	}
-	if r.mod.Len() > 0 {
-		return r.mod.ReadByte()
-	}
-
-	if r.si >= len(r.s) {
-		r.si = 0
-		r.cur += r.step
-
-		r.eof = r.cur > r.end || r.cur < 0
-		return '\n', nil
-	}
-
-	si := r.si
-	r.si++
-
-	switch r.s[si] {
-	case '\\':
-		if r.escape {
-			r.escape = false
-			return '\\', nil
-		}
-
-		r.escape = true
-		return r.ReadByte()
-	case '$':
-		if r.escape {
-			r.escape = false
-			return '$', nil
-		}
-
-		mod := "%d"
-
-		if si >= len(r.s)-1 {
-			// End of the string
-			fmt.Fprintf(&r.mod, mod, r.cur)
-			return r.mod.ReadByte()
-		}
-
-		if r.s[si+1] == '$' {
-			r.si++
-			return '$', nil
-		}
-
-		var offset int64
-
-		// Search for { and }
-		if r.s[si+1] == '{' {
-			// Modifier block
-			sep := strings.Index(r.s[si+2:], "}")
-			if sep < 0 {
-				return 0, r.parseError("bad modifier in $GENERATE", len(r.s))
-			}
-
-			var errMsg string
-			mod, offset, errMsg = modToPrintf(r.s[si+2 : si+2+sep])
-			if errMsg != "" {
-				return 0, r.parseError(errMsg, si+3+sep)
-			}
-			if r.start+offset < 0 || r.end+offset > 1<<31-1 {
-				return 0, r.parseError("bad offset in $GENERATE", si+3+sep)
-			}
-
-			r.si += 2 + sep // Jump to it
-		}
-
-		fmt.Fprintf(&r.mod, mod, r.cur+offset)
-		return r.mod.ReadByte()
-	default:
-		if r.escape { // Pretty useless here
-			r.escape = false
-			return r.ReadByte()
-		}
-
-		return r.s[si], nil
-	}
-}
-
-// Convert a $GENERATE modifier 0,0,d to something Printf can deal with.
-func modToPrintf(s string) (string, int64, string) {
-	// Modifier is { offset [ ,width [ ,base ] ] } - provide default
-	// values for optional width and type, if necessary.
-	offStr, s, ok0 := strings.Cut(s, ",")
-	widthStr, s, ok1 := strings.Cut(s, ",")
-	base, _, ok2 := strings.Cut(s, ",")
-	if !ok0 {
-		widthStr = "0"
-	}
-	if !ok1 {
-		base = "d"
-	}
-	if ok2 {
-		return "", 0, "bad modifier in $GENERATE"
-	}
-
-	switch base {
-	case "o", "d", "x", "X":
-	default:
-		return "", 0, "bad base in $GENERATE"
-	}
-
-	offset, err := strconv.ParseInt(offStr, 10, 64)
-	if err != nil {
-		return "", 0, "bad offset in $GENERATE"
-	}
-
-	width, err := strconv.ParseUint(widthStr, 10, 8)
-	if err != nil {
-		return "", 0, "bad width in $GENERATE"
-	}
-
-	if width == 0 {
-		return "%" + base, offset, ""
-	}
-
-	return "%0" + widthStr + base, offset, ""
-}
diff --git a/vendor/github.com/miekg/dns/hash.go b/vendor/github.com/miekg/dns/hash.go
deleted file mode 100644
index 7d4183e027..0000000000
--- a/vendor/github.com/miekg/dns/hash.go
+++ /dev/null
@@ -1,31 +0,0 @@
-package dns
-
-import (
-	"bytes"
-	"crypto"
-	"hash"
-)
-
-// identityHash will not hash, it only buffers the data written into it and returns it as-is.
-type identityHash struct {
-	b *bytes.Buffer
-}
-
-// Implement the hash.Hash interface.
-
-func (i identityHash) Write(b []byte) (int, error) { return i.b.Write(b) }
-func (i identityHash) Size() int                   { return i.b.Len() }
-func (i identityHash) BlockSize() int              { return 1024 }
-func (i identityHash) Reset()                      { i.b.Reset() }
-func (i identityHash) Sum(b []byte) []byte         { return append(b, i.b.Bytes()...) }
-
-func hashFromAlgorithm(alg uint8) (hash.Hash, crypto.Hash, error) {
-	hashnumber, ok := AlgorithmToHash[alg]
-	if !ok {
-		return nil, 0, ErrAlg
-	}
-	if hashnumber == 0 {
-		return identityHash{b: &bytes.Buffer{}}, hashnumber, nil
-	}
-	return hashnumber.New(), hashnumber, nil
-}
diff --git a/vendor/github.com/miekg/dns/labels.go b/vendor/github.com/miekg/dns/labels.go
deleted file mode 100644
index cd498d2e9e..0000000000
--- a/vendor/github.com/miekg/dns/labels.go
+++ /dev/null
@@ -1,212 +0,0 @@
-package dns
-
-// Holds a bunch of helper functions for dealing with labels.
-
-// SplitDomainName splits a name string into it's labels.
-// www.miek.nl. returns []string{"www", "miek", "nl"}
-// .www.miek.nl. returns []string{"", "www", "miek", "nl"},
-// The root label (.) returns nil. Note that using
-// strings.Split(s) will work in most cases, but does not handle
-// escaped dots (\.) for instance.
-// s must be a syntactically valid domain name, see IsDomainName.
-func SplitDomainName(s string) (labels []string) {
-	if s == "" {
-		return nil
-	}
-	fqdnEnd := 0 // offset of the final '.' or the length of the name
-	idx := Split(s)
-	begin := 0
-	if IsFqdn(s) {
-		fqdnEnd = len(s) - 1
-	} else {
-		fqdnEnd = len(s)
-	}
-
-	switch len(idx) {
-	case 0:
-		return nil
-	case 1:
-		// no-op
-	default:
-		for _, end := range idx[1:] {
-			labels = append(labels, s[begin:end-1])
-			begin = end
-		}
-	}
-
-	return append(labels, s[begin:fqdnEnd])
-}
-
-// CompareDomainName compares the names s1 and s2 and
-// returns how many labels they have in common starting from the *right*.
-// The comparison stops at the first inequality. The names are downcased
-// before the comparison.
-//
-// www.miek.nl. and miek.nl. have two labels in common: miek and nl
-// www.miek.nl. and www.bla.nl. have one label in common: nl
-//
-// s1 and s2 must be syntactically valid domain names.
-func CompareDomainName(s1, s2 string) (n int) {
-	// the first check: root label
-	if s1 == "." || s2 == "." {
-		return 0
-	}
-
-	l1 := Split(s1)
-	l2 := Split(s2)
-
-	j1 := len(l1) - 1 // end
-	i1 := len(l1) - 2 // start
-	j2 := len(l2) - 1
-	i2 := len(l2) - 2
-	// the second check can be done here: last/only label
-	// before we fall through into the for-loop below
-	if equal(s1[l1[j1]:], s2[l2[j2]:]) {
-		n++
-	} else {
-		return
-	}
-	for {
-		if i1 < 0 || i2 < 0 {
-			break
-		}
-		if equal(s1[l1[i1]:l1[j1]], s2[l2[i2]:l2[j2]]) {
-			n++
-		} else {
-			break
-		}
-		j1--
-		i1--
-		j2--
-		i2--
-	}
-	return
-}
-
-// CountLabel counts the number of labels in the string s.
-// s must be a syntactically valid domain name.
-func CountLabel(s string) (labels int) {
-	if s == "." {
-		return
-	}
-	off := 0
-	end := false
-	for {
-		off, end = NextLabel(s, off)
-		labels++
-		if end {
-			return
-		}
-	}
-}
-
-// Split splits a name s into its label indexes.
-// www.miek.nl. returns []int{0, 4, 9}, www.miek.nl also returns []int{0, 4, 9}.
-// The root name (.) returns nil. Also see SplitDomainName.
-// s must be a syntactically valid domain name.
-func Split(s string) []int {
-	if s == "." {
-		return nil
-	}
-	idx := make([]int, 1, 3)
-	off := 0
-	end := false
-
-	for {
-		off, end = NextLabel(s, off)
-		if end {
-			return idx
-		}
-		idx = append(idx, off)
-	}
-}
-
-// NextLabel returns the index of the start of the next label in the
-// string s starting at offset. A negative offset will cause a panic.
-// The bool end is true when the end of the string has been reached.
-// Also see PrevLabel.
-func NextLabel(s string, offset int) (i int, end bool) {
-	if s == "" {
-		return 0, true
-	}
-	for i = offset; i < len(s)-1; i++ {
-		if s[i] != '.' {
-			continue
-		}
-		j := i - 1
-		for j >= 0 && s[j] == '\\' {
-			j--
-		}
-
-		if (j-i)%2 == 0 {
-			continue
-		}
-
-		return i + 1, false
-	}
-	return i + 1, true
-}
-
-// PrevLabel returns the index of the label when starting from the right and
-// jumping n labels to the left.
-// The bool start is true when the start of the string has been overshot.
-// Also see NextLabel.
-func PrevLabel(s string, n int) (i int, start bool) {
-	if s == "" {
-		return 0, true
-	}
-	if n == 0 {
-		return len(s), false
-	}
-
-	l := len(s) - 1
-	if s[l] == '.' {
-		l--
-	}
-
-	for ; l >= 0 && n > 0; l-- {
-		if s[l] != '.' {
-			continue
-		}
-		j := l - 1
-		for j >= 0 && s[j] == '\\' {
-			j--
-		}
-
-		if (j-l)%2 == 0 {
-			continue
-		}
-
-		n--
-		if n == 0 {
-			return l + 1, false
-		}
-	}
-
-	return 0, n > 1
-}
-
-// equal compares a and b while ignoring case. It returns true when equal otherwise false.
-func equal(a, b string) bool {
-	// might be lifted into API function.
-	la := len(a)
-	lb := len(b)
-	if la != lb {
-		return false
-	}
-
-	for i := la - 1; i >= 0; i-- {
-		ai := a[i]
-		bi := b[i]
-		if ai >= 'A' && ai <= 'Z' {
-			ai |= 'a' - 'A'
-		}
-		if bi >= 'A' && bi <= 'Z' {
-			bi |= 'a' - 'A'
-		}
-		if ai != bi {
-			return false
-		}
-	}
-	return true
-}
diff --git a/vendor/github.com/miekg/dns/listen_no_socket_options.go b/vendor/github.com/miekg/dns/listen_no_socket_options.go
deleted file mode 100644
index 9e4010bdcc..0000000000
--- a/vendor/github.com/miekg/dns/listen_no_socket_options.go
+++ /dev/null
@@ -1,40 +0,0 @@
-//go:build !aix && !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd
-// +build !aix,!darwin,!dragonfly,!freebsd,!linux,!netbsd,!openbsd
-
-package dns
-
-import (
-	"fmt"
-	"net"
-)
-
-const (
-	supportsReusePort = false
-	supportsReuseAddr = false
-)
-
-func listenTCP(network, addr string, reuseport, reuseaddr bool) (net.Listener, error) {
-	if reuseport || reuseaddr {
-		// TODO(tmthrgd): return an error?
-	}
-
-	return net.Listen(network, addr)
-}
-
-func listenUDP(network, addr string, reuseport, reuseaddr bool) (net.PacketConn, error) {
-	if reuseport || reuseaddr {
-		// TODO(tmthrgd): return an error?
-	}
-
-	return net.ListenPacket(network, addr)
-}
-
-// this is just for test compatibility
-func checkReuseport(fd uintptr) (bool, error) {
-	return false, fmt.Errorf("not supported")
-}
-
-// this is just for test compatibility
-func checkReuseaddr(fd uintptr) (bool, error) {
-	return false, fmt.Errorf("not supported")
-}
diff --git a/vendor/github.com/miekg/dns/listen_socket_options.go b/vendor/github.com/miekg/dns/listen_socket_options.go
deleted file mode 100644
index 35dfc9498a..0000000000
--- a/vendor/github.com/miekg/dns/listen_socket_options.go
+++ /dev/null
@@ -1,97 +0,0 @@
-//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd
-// +build aix darwin dragonfly freebsd linux netbsd openbsd
-
-package dns
-
-import (
-	"context"
-	"net"
-	"syscall"
-
-	"golang.org/x/sys/unix"
-)
-
-const supportsReusePort = true
-
-func reuseportControl(network, address string, c syscall.RawConn) error {
-	var opErr error
-	err := c.Control(func(fd uintptr) {
-		opErr = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEPORT, 1)
-	})
-	if err != nil {
-		return err
-	}
-
-	return opErr
-}
-
-const supportsReuseAddr = true
-
-func reuseaddrControl(network, address string, c syscall.RawConn) error {
-	var opErr error
-	err := c.Control(func(fd uintptr) {
-		opErr = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEADDR, 1)
-	})
-	if err != nil {
-		return err
-	}
-
-	return opErr
-}
-
-func reuseaddrandportControl(network, address string, c syscall.RawConn) error {
-	err := reuseaddrControl(network, address, c)
-	if err != nil {
-		return err
-	}
-
-	return reuseportControl(network, address, c)
-}
-
-// this is just for test compatibility
-func checkReuseport(fd uintptr) (bool, error) {
-	v, err := unix.GetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEPORT)
-	if err != nil {
-		return false, err
-	}
-
-	return v == 1, nil
-}
-
-// this is just for test compatibility
-func checkReuseaddr(fd uintptr) (bool, error) {
-	v, err := unix.GetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEADDR)
-	if err != nil {
-		return false, err
-	}
-
-	return v == 1, nil
-}
-
-func listenTCP(network, addr string, reuseport, reuseaddr bool) (net.Listener, error) {
-	var lc net.ListenConfig
-	switch {
-	case reuseaddr && reuseport:
-		lc.Control = reuseaddrandportControl
-	case reuseport:
-		lc.Control = reuseportControl
-	case reuseaddr:
-		lc.Control = reuseaddrControl
-	}
-
-	return lc.Listen(context.Background(), network, addr)
-}
-
-func listenUDP(network, addr string, reuseport, reuseaddr bool) (net.PacketConn, error) {
-	var lc net.ListenConfig
-	switch {
-	case reuseaddr && reuseport:
-		lc.Control = reuseaddrandportControl
-	case reuseport:
-		lc.Control = reuseportControl
-	case reuseaddr:
-		lc.Control = reuseaddrControl
-	}
-
-	return lc.ListenPacket(context.Background(), network, addr)
-}
diff --git a/vendor/github.com/miekg/dns/msg.go b/vendor/github.com/miekg/dns/msg.go
deleted file mode 100644
index 382a808387..0000000000
--- a/vendor/github.com/miekg/dns/msg.go
+++ /dev/null
@@ -1,1225 +0,0 @@
-// DNS packet assembly, see RFC 1035. Converting from - Unpack() -
-// and to - Pack() - wire format.
-// All the packers and unpackers take a (msg []byte, off int)
-// and return (off1 int, ok bool).  If they return ok==false, they
-// also return off1==len(msg), so that the next unpacker will
-// also fail.  This lets us avoid checks of ok until the end of a
-// packing sequence.
-
-package dns
-
-//go:generate go run msg_generate.go
-
-import (
-	"crypto/rand"
-	"encoding/binary"
-	"fmt"
-	"math/big"
-	"strconv"
-	"strings"
-)
-
-const (
-	maxCompressionOffset    = 2 << 13 // We have 14 bits for the compression pointer
-	maxDomainNameWireOctets = 255     // See RFC 1035 section 2.3.4
-
-	// This is the maximum number of compression pointers that should occur in a
-	// semantically valid message. Each label in a domain name must be at least one
-	// octet and is separated by a period. The root label won't be represented by a
-	// compression pointer to a compression pointer, hence the -2 to exclude the
-	// smallest valid root label.
-	//
-	// It is possible to construct a valid message that has more compression pointers
-	// than this, and still doesn't loop, by pointing to a previous pointer. This is
-	// not something a well written implementation should ever do, so we leave them
-	// to trip the maximum compression pointer check.
-	maxCompressionPointers = (maxDomainNameWireOctets+1)/2 - 2
-
-	// This is the maximum length of a domain name in presentation format. The
-	// maximum wire length of a domain name is 255 octets (see above), with the
-	// maximum label length being 63. The wire format requires one extra byte over
-	// the presentation format, reducing the number of octets by 1. Each label in
-	// the name will be separated by a single period, with each octet in the label
-	// expanding to at most 4 bytes (\DDD). If all other labels are of the maximum
-	// length, then the final label can only be 61 octets long to not exceed the
-	// maximum allowed wire length.
-	maxDomainNamePresentationLength = 61*4 + 1 + 63*4 + 1 + 63*4 + 1 + 63*4 + 1
-)
-
-// Errors defined in this package.
-var (
-	ErrAlg           error = &Error{err: "bad algorithm"}                  // ErrAlg indicates an error with the (DNSSEC) algorithm.
-	ErrAuth          error = &Error{err: "bad authentication"}             // ErrAuth indicates an error in the TSIG authentication.
-	ErrBuf           error = &Error{err: "buffer size too small"}          // ErrBuf indicates that the buffer used is too small for the message.
-	ErrConnEmpty     error = &Error{err: "conn has no connection"}         // ErrConnEmpty indicates a connection is being used before it is initialized.
-	ErrExtendedRcode error = &Error{err: "bad extended rcode"}             // ErrExtendedRcode ...
-	ErrFqdn          error = &Error{err: "domain must be fully qualified"} // ErrFqdn indicates that a domain name does not have a closing dot.
-	ErrId            error = &Error{err: "id mismatch"}                    // ErrId indicates there is a mismatch with the message's ID.
-	ErrKeyAlg        error = &Error{err: "bad key algorithm"}              // ErrKeyAlg indicates that the algorithm in the key is not valid.
-	ErrKey           error = &Error{err: "bad key"}
-	ErrKeySize       error = &Error{err: "bad key size"}
-	ErrLongDomain    error = &Error{err: fmt.Sprintf("domain name exceeded %d wire-format octets", maxDomainNameWireOctets)}
-	ErrNoSig         error = &Error{err: "no signature found"}
-	ErrPrivKey       error = &Error{err: "bad private key"}
-	ErrRcode         error = &Error{err: "bad rcode"}
-	ErrRdata         error = &Error{err: "bad rdata"}
-	ErrRRset         error = &Error{err: "bad rrset"}
-	ErrSecret        error = &Error{err: "no secrets defined"}
-	ErrShortRead     error = &Error{err: "short read"}
-	ErrSig           error = &Error{err: "bad signature"} // ErrSig indicates that a signature can not be cryptographically validated.
-	ErrSoa           error = &Error{err: "no SOA"}        // ErrSOA indicates that no SOA RR was seen when doing zone transfers.
-	ErrTime          error = &Error{err: "bad time"}      // ErrTime indicates a timing error in TSIG authentication.
-)
-
-// Id by default returns a 16-bit random number to be used as a message id. The
-// number is drawn from a cryptographically secure random number generator.
-// This being a variable the function can be reassigned to a custom function.
-// For instance, to make it return a static value for testing:
-//
-//	dns.Id = func() uint16 { return 3 }
-var Id = id
-
-// id returns a 16 bits random number to be used as a
-// message id. The random provided should be good enough.
-func id() uint16 {
-	var output uint16
-	err := binary.Read(rand.Reader, binary.BigEndian, &output)
-	if err != nil {
-		panic("dns: reading random id failed: " + err.Error())
-	}
-	return output
-}
-
-// MsgHdr is a a manually-unpacked version of (id, bits).
-type MsgHdr struct {
-	Id                 uint16
-	Response           bool
-	Opcode             int
-	Authoritative      bool
-	Truncated          bool
-	RecursionDesired   bool
-	RecursionAvailable bool
-	Zero               bool
-	AuthenticatedData  bool
-	CheckingDisabled   bool
-	Rcode              int
-}
-
-// Msg contains the layout of a DNS message.
-type Msg struct {
-	MsgHdr
-	Compress bool       `json:"-"` // If true, the message will be compressed when converted to wire format.
-	Question []Question // Holds the RR(s) of the question section.
-	Answer   []RR       // Holds the RR(s) of the answer section.
-	Ns       []RR       // Holds the RR(s) of the authority section.
-	Extra    []RR       // Holds the RR(s) of the additional section.
-}
-
-// ClassToString is a maps Classes to strings for each CLASS wire type.
-var ClassToString = map[uint16]string{
-	ClassINET:   "IN",
-	ClassCSNET:  "CS",
-	ClassCHAOS:  "CH",
-	ClassHESIOD: "HS",
-	ClassNONE:   "NONE",
-	ClassANY:    "ANY",
-}
-
-// OpcodeToString maps Opcodes to strings.
-var OpcodeToString = map[int]string{
-	OpcodeQuery:  "QUERY",
-	OpcodeIQuery: "IQUERY",
-	OpcodeStatus: "STATUS",
-	OpcodeNotify: "NOTIFY",
-	OpcodeUpdate: "UPDATE",
-}
-
-// RcodeToString maps Rcodes to strings.
-var RcodeToString = map[int]string{
-	RcodeSuccess:                    "NOERROR",
-	RcodeFormatError:                "FORMERR",
-	RcodeServerFailure:              "SERVFAIL",
-	RcodeNameError:                  "NXDOMAIN",
-	RcodeNotImplemented:             "NOTIMP",
-	RcodeRefused:                    "REFUSED",
-	RcodeYXDomain:                   "YXDOMAIN", // See RFC 2136
-	RcodeYXRrset:                    "YXRRSET",
-	RcodeNXRrset:                    "NXRRSET",
-	RcodeNotAuth:                    "NOTAUTH",
-	RcodeNotZone:                    "NOTZONE",
-	RcodeStatefulTypeNotImplemented: "DSOTYPENI",
-	RcodeBadSig:                     "BADSIG", // Also known as RcodeBadVers, see RFC 6891
-	//	RcodeBadVers:        "BADVERS",
-	RcodeBadKey:    "BADKEY",
-	RcodeBadTime:   "BADTIME",
-	RcodeBadMode:   "BADMODE",
-	RcodeBadName:   "BADNAME",
-	RcodeBadAlg:    "BADALG",
-	RcodeBadTrunc:  "BADTRUNC",
-	RcodeBadCookie: "BADCOOKIE",
-}
-
-// compressionMap is used to allow a more efficient compression map
-// to be used for internal packDomainName calls without changing the
-// signature or functionality of public API.
-//
-// In particular, map[string]uint16 uses 25% less per-entry memory
-// than does map[string]int.
-type compressionMap struct {
-	ext map[string]int    // external callers
-	int map[string]uint16 // internal callers
-}
-
-func (m compressionMap) valid() bool {
-	return m.int != nil || m.ext != nil
-}
-
-func (m compressionMap) insert(s string, pos int) {
-	if m.ext != nil {
-		m.ext[s] = pos
-	} else {
-		m.int[s] = uint16(pos)
-	}
-}
-
-func (m compressionMap) find(s string) (int, bool) {
-	if m.ext != nil {
-		pos, ok := m.ext[s]
-		return pos, ok
-	}
-
-	pos, ok := m.int[s]
-	return int(pos), ok
-}
-
-// Domain names are a sequence of counted strings
-// split at the dots. They end with a zero-length string.
-
-// PackDomainName packs a domain name s into msg[off:].
-// If compression is wanted compress must be true and the compression
-// map needs to hold a mapping between domain names and offsets
-// pointing into msg.
-func PackDomainName(s string, msg []byte, off int, compression map[string]int, compress bool) (off1 int, err error) {
-	return packDomainName(s, msg, off, compressionMap{ext: compression}, compress)
-}
-
-func packDomainName(s string, msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	// XXX: A logical copy of this function exists in IsDomainName and
-	// should be kept in sync with this function.
-
-	ls := len(s)
-	if ls == 0 { // Ok, for instance when dealing with update RR without any rdata.
-		return off, nil
-	}
-
-	// If not fully qualified, error out.
-	if !IsFqdn(s) {
-		return len(msg), ErrFqdn
-	}
-
-	// Each dot ends a segment of the name.
-	// We trade each dot byte for a length byte.
-	// Except for escaped dots (\.), which are normal dots.
-	// There is also a trailing zero.
-
-	// Compression
-	pointer := -1
-
-	// Emit sequence of counted strings, chopping at dots.
-	var (
-		begin     int
-		compBegin int
-		compOff   int
-		bs        []byte
-		wasDot    bool
-	)
-loop:
-	for i := 0; i < ls; i++ {
-		var c byte
-		if bs == nil {
-			c = s[i]
-		} else {
-			c = bs[i]
-		}
-
-		switch c {
-		case '\\':
-			if off+1 > len(msg) {
-				return len(msg), ErrBuf
-			}
-
-			if bs == nil {
-				bs = []byte(s)
-			}
-
-			// check for \DDD
-			if isDDD(bs[i+1:]) {
-				bs[i] = dddToByte(bs[i+1:])
-				copy(bs[i+1:ls-3], bs[i+4:])
-				ls -= 3
-				compOff += 3
-			} else {
-				copy(bs[i:ls-1], bs[i+1:])
-				ls--
-				compOff++
-			}
-
-			wasDot = false
-		case '.':
-			if i == 0 && len(s) > 1 {
-				// leading dots are not legal except for the root zone
-				return len(msg), ErrRdata
-			}
-
-			if wasDot {
-				// two dots back to back is not legal
-				return len(msg), ErrRdata
-			}
-			wasDot = true
-
-			labelLen := i - begin
-			if labelLen >= 1<<6 { // top two bits of length must be clear
-				return len(msg), ErrRdata
-			}
-
-			// off can already (we're in a loop) be bigger than len(msg)
-			// this happens when a name isn't fully qualified
-			if off+1+labelLen > len(msg) {
-				return len(msg), ErrBuf
-			}
-
-			// Don't try to compress '.'
-			// We should only compress when compress is true, but we should also still pick
-			// up names that can be used for *future* compression(s).
-			if compression.valid() && !isRootLabel(s, bs, begin, ls) {
-				if p, ok := compression.find(s[compBegin:]); ok {
-					// The first hit is the longest matching dname
-					// keep the pointer offset we get back and store
-					// the offset of the current name, because that's
-					// where we need to insert the pointer later
-
-					// If compress is true, we're allowed to compress this dname
-					if compress {
-						pointer = p // Where to point to
-						break loop
-					}
-				} else if off < maxCompressionOffset {
-					// Only offsets smaller than maxCompressionOffset can be used.
-					compression.insert(s[compBegin:], off)
-				}
-			}
-
-			// The following is covered by the length check above.
-			msg[off] = byte(labelLen)
-
-			if bs == nil {
-				copy(msg[off+1:], s[begin:i])
-			} else {
-				copy(msg[off+1:], bs[begin:i])
-			}
-			off += 1 + labelLen
-
-			begin = i + 1
-			compBegin = begin + compOff
-		default:
-			wasDot = false
-		}
-	}
-
-	// Root label is special
-	if isRootLabel(s, bs, 0, ls) {
-		return off, nil
-	}
-
-	// If we did compression and we find something add the pointer here
-	if pointer != -1 {
-		// We have two bytes (14 bits) to put the pointer in
-		binary.BigEndian.PutUint16(msg[off:], uint16(pointer^0xC000))
-		return off + 2, nil
-	}
-
-	// Trailing root label
-	if off < len(msg) {
-		msg[off] = 0
-		return off + 1, nil
-	}
-
-	return off, ErrBuf
-}
-
-// isRootLabel returns whether s or bs, from off to end, is the root
-// label ".".
-//
-// If bs is nil, s will be checked, otherwise bs will be checked.
-func isRootLabel(s string, bs []byte, off, end int) bool {
-	if bs == nil {
-		return s[off:end] == "."
-	}
-
-	return end-off == 1 && bs[off] == '.'
-}
-
-// Unpack a domain name.
-// In addition to the simple sequences of counted strings above,
-// domain names are allowed to refer to strings elsewhere in the
-// packet, to avoid repeating common suffixes when returning
-// many entries in a single domain.  The pointers are marked
-// by a length byte with the top two bits set.  Ignoring those
-// two bits, that byte and the next give a 14 bit offset from msg[0]
-// where we should pick up the trail.
-// Note that if we jump elsewhere in the packet,
-// we return off1 == the offset after the first pointer we found,
-// which is where the next record will start.
-// In theory, the pointers are only allowed to jump backward.
-// We let them jump anywhere and stop jumping after a while.
-
-// UnpackDomainName unpacks a domain name into a string. It returns
-// the name, the new offset into msg and any error that occurred.
-//
-// When an error is encountered, the unpacked name will be discarded
-// and len(msg) will be returned as the offset.
-func UnpackDomainName(msg []byte, off int) (string, int, error) {
-	s := make([]byte, 0, maxDomainNamePresentationLength)
-	off1 := 0
-	lenmsg := len(msg)
-	budget := maxDomainNameWireOctets
-	ptr := 0 // number of pointers followed
-Loop:
-	for {
-		if off >= lenmsg {
-			return "", lenmsg, ErrBuf
-		}
-		c := int(msg[off])
-		off++
-		switch c & 0xC0 {
-		case 0x00:
-			if c == 0x00 {
-				// end of name
-				break Loop
-			}
-			// literal string
-			if off+c > lenmsg {
-				return "", lenmsg, ErrBuf
-			}
-			budget -= c + 1 // +1 for the label separator
-			if budget <= 0 {
-				return "", lenmsg, ErrLongDomain
-			}
-			for _, b := range msg[off : off+c] {
-				if isDomainNameLabelSpecial(b) {
-					s = append(s, '\\', b)
-				} else if b < ' ' || b > '~' {
-					s = append(s, escapeByte(b)...)
-				} else {
-					s = append(s, b)
-				}
-			}
-			s = append(s, '.')
-			off += c
-		case 0xC0:
-			// pointer to somewhere else in msg.
-			// remember location after first ptr,
-			// since that's how many bytes we consumed.
-			// also, don't follow too many pointers --
-			// maybe there's a loop.
-			if off >= lenmsg {
-				return "", lenmsg, ErrBuf
-			}
-			c1 := msg[off]
-			off++
-			if ptr == 0 {
-				off1 = off
-			}
-			if ptr++; ptr > maxCompressionPointers {
-				return "", lenmsg, &Error{err: "too many compression pointers"}
-			}
-			// pointer should guarantee that it advances and points forwards at least
-			// but the condition on previous three lines guarantees that it's
-			// at least loop-free
-			off = (c^0xC0)<<8 | int(c1)
-		default:
-			// 0x80 and 0x40 are reserved
-			return "", lenmsg, ErrRdata
-		}
-	}
-	if ptr == 0 {
-		off1 = off
-	}
-	if len(s) == 0 {
-		return ".", off1, nil
-	}
-	return string(s), off1, nil
-}
-
-func packTxt(txt []string, msg []byte, offset int) (int, error) {
-	if len(txt) == 0 {
-		if offset >= len(msg) {
-			return offset, ErrBuf
-		}
-		msg[offset] = 0
-		return offset, nil
-	}
-	var err error
-	for _, s := range txt {
-		offset, err = packTxtString(s, msg, offset)
-		if err != nil {
-			return offset, err
-		}
-	}
-	return offset, nil
-}
-
-func packTxtString(s string, msg []byte, offset int) (int, error) {
-	lenByteOffset := offset
-	if offset >= len(msg) || len(s) > 256*4+1 /* If all \DDD */ {
-		return offset, ErrBuf
-	}
-	offset++
-	for i := 0; i < len(s); i++ {
-		if len(msg) <= offset {
-			return offset, ErrBuf
-		}
-		if s[i] == '\\' {
-			i++
-			if i == len(s) {
-				break
-			}
-			// check for \DDD
-			if isDDD(s[i:]) {
-				msg[offset] = dddToByte(s[i:])
-				i += 2
-			} else {
-				msg[offset] = s[i]
-			}
-		} else {
-			msg[offset] = s[i]
-		}
-		offset++
-	}
-	l := offset - lenByteOffset - 1
-	if l > 255 {
-		return offset, &Error{err: "string exceeded 255 bytes in txt"}
-	}
-	msg[lenByteOffset] = byte(l)
-	return offset, nil
-}
-
-func packOctetString(s string, msg []byte, offset int) (int, error) {
-	if offset >= len(msg) || len(s) > 256*4+1 {
-		return offset, ErrBuf
-	}
-	for i := 0; i < len(s); i++ {
-		if len(msg) <= offset {
-			return offset, ErrBuf
-		}
-		if s[i] == '\\' {
-			i++
-			if i == len(s) {
-				break
-			}
-			// check for \DDD
-			if isDDD(s[i:]) {
-				msg[offset] = dddToByte(s[i:])
-				i += 2
-			} else {
-				msg[offset] = s[i]
-			}
-		} else {
-			msg[offset] = s[i]
-		}
-		offset++
-	}
-	return offset, nil
-}
-
-func unpackTxt(msg []byte, off0 int) (ss []string, off int, err error) {
-	off = off0
-	var s string
-	for off < len(msg) && err == nil {
-		s, off, err = unpackString(msg, off)
-		if err == nil {
-			ss = append(ss, s)
-		}
-	}
-	return
-}
-
-// Helpers for dealing with escaped bytes
-func isDigit(b byte) bool { return b >= '0' && b <= '9' }
-
-func isDDD[T ~[]byte | ~string](s T) bool {
-	return len(s) >= 3 && isDigit(s[0]) && isDigit(s[1]) && isDigit(s[2])
-}
-
-func dddToByte[T ~[]byte | ~string](s T) byte {
-	_ = s[2] // bounds check hint to compiler; see golang.org/issue/14808
-	return byte((s[0]-'0')*100 + (s[1]-'0')*10 + (s[2] - '0'))
-}
-
-// Helper function for packing and unpacking
-func intToBytes(i *big.Int, length int) []byte {
-	buf := i.Bytes()
-	if len(buf) < length {
-		b := make([]byte, length)
-		copy(b[length-len(buf):], buf)
-		return b
-	}
-	return buf
-}
-
-// PackRR packs a resource record rr into msg[off:].
-// See PackDomainName for documentation about the compression.
-func PackRR(rr RR, msg []byte, off int, compression map[string]int, compress bool) (off1 int, err error) {
-	headerEnd, off1, err := packRR(rr, msg, off, compressionMap{ext: compression}, compress)
-	if err == nil {
-		// packRR no longer sets the Rdlength field on the rr, but
-		// callers might be expecting it so we set it here.
-		rr.Header().Rdlength = uint16(off1 - headerEnd)
-	}
-	return off1, err
-}
-
-func packRR(rr RR, msg []byte, off int, compression compressionMap, compress bool) (headerEnd int, off1 int, err error) {
-	if rr == nil {
-		return len(msg), len(msg), &Error{err: "nil rr"}
-	}
-
-	headerEnd, err = rr.Header().packHeader(msg, off, compression, compress)
-	if err != nil {
-		return headerEnd, len(msg), err
-	}
-
-	off1, err = rr.pack(msg, headerEnd, compression, compress)
-	if err != nil {
-		return headerEnd, len(msg), err
-	}
-
-	rdlength := off1 - headerEnd
-	if int(uint16(rdlength)) != rdlength { // overflow
-		return headerEnd, len(msg), ErrRdata
-	}
-
-	// The RDLENGTH field is the last field in the header and we set it here.
-	binary.BigEndian.PutUint16(msg[headerEnd-2:], uint16(rdlength))
-	return headerEnd, off1, nil
-}
-
-// UnpackRR unpacks msg[off:] into an RR.
-func UnpackRR(msg []byte, off int) (rr RR, off1 int, err error) {
-	h, off, msg, err := unpackHeader(msg, off)
-	if err != nil {
-		return nil, len(msg), err
-	}
-
-	return UnpackRRWithHeader(h, msg, off)
-}
-
-// UnpackRRWithHeader unpacks the record type specific payload given an existing
-// RR_Header.
-func UnpackRRWithHeader(h RR_Header, msg []byte, off int) (rr RR, off1 int, err error) {
-	if newFn, ok := TypeToRR[h.Rrtype]; ok {
-		rr = newFn()
-		*rr.Header() = h
-	} else {
-		rr = &RFC3597{Hdr: h}
-	}
-
-	if off < 0 || off > len(msg) {
-		return &h, off, &Error{err: "bad off"}
-	}
-
-	end := off + int(h.Rdlength)
-	if end < off || end > len(msg) {
-		return &h, end, &Error{err: "bad rdlength"}
-	}
-
-	if noRdata(h) {
-		return rr, off, nil
-	}
-
-	off, err = rr.unpack(msg, off)
-	if err != nil {
-		return nil, end, err
-	}
-	if off != end {
-		return &h, end, &Error{err: "bad rdlength"}
-	}
-
-	return rr, off, nil
-}
-
-// unpackRRslice unpacks msg[off:] into an []RR.
-// If we cannot unpack the whole array, then it will return nil
-func unpackRRslice(l int, msg []byte, off int) (dst1 []RR, off1 int, err error) {
-	var r RR
-	// Don't pre-allocate, l may be under attacker control
-	var dst []RR
-	for i := 0; i < l; i++ {
-		off1 := off
-		r, off, err = UnpackRR(msg, off)
-		if err != nil {
-			off = len(msg)
-			break
-		}
-		// If offset does not increase anymore, l is a lie
-		if off1 == off {
-			break
-		}
-		dst = append(dst, r)
-	}
-	if err != nil && off == len(msg) {
-		dst = nil
-	}
-	return dst, off, err
-}
-
-// Convert a MsgHdr to a string, with dig-like headers:
-//
-// ;; opcode: QUERY, status: NOERROR, id: 48404
-//
-// ;; flags: qr aa rd ra;
-func (h *MsgHdr) String() string {
-	if h == nil {
-		return "<nil> MsgHdr"
-	}
-
-	s := ";; opcode: " + OpcodeToString[h.Opcode]
-	s += ", status: " + RcodeToString[h.Rcode]
-	s += ", id: " + strconv.Itoa(int(h.Id)) + "\n"
-
-	s += ";; flags:"
-	if h.Response {
-		s += " qr"
-	}
-	if h.Authoritative {
-		s += " aa"
-	}
-	if h.Truncated {
-		s += " tc"
-	}
-	if h.RecursionDesired {
-		s += " rd"
-	}
-	if h.RecursionAvailable {
-		s += " ra"
-	}
-	if h.Zero { // Hmm
-		s += " z"
-	}
-	if h.AuthenticatedData {
-		s += " ad"
-	}
-	if h.CheckingDisabled {
-		s += " cd"
-	}
-
-	s += ";"
-	return s
-}
-
-// Pack packs a Msg: it is converted to wire format.
-// If the dns.Compress is true the message will be in compressed wire format.
-func (dns *Msg) Pack() (msg []byte, err error) {
-	return dns.PackBuffer(nil)
-}
-
-// PackBuffer packs a Msg, using the given buffer buf. If buf is too small a new buffer is allocated.
-func (dns *Msg) PackBuffer(buf []byte) (msg []byte, err error) {
-	// If this message can't be compressed, avoid filling the
-	// compression map and creating garbage.
-	if dns.Compress && dns.isCompressible() {
-		compression := make(map[string]uint16) // Compression pointer mappings.
-		return dns.packBufferWithCompressionMap(buf, compressionMap{int: compression}, true)
-	}
-
-	return dns.packBufferWithCompressionMap(buf, compressionMap{}, false)
-}
-
-// packBufferWithCompressionMap packs a Msg, using the given buffer buf.
-func (dns *Msg) packBufferWithCompressionMap(buf []byte, compression compressionMap, compress bool) (msg []byte, err error) {
-	if dns.Rcode < 0 || dns.Rcode > 0xFFF {
-		return nil, ErrRcode
-	}
-
-	// Set extended rcode unconditionally if we have an opt, this will allow
-	// resetting the extended rcode bits if they need to.
-	if opt := dns.IsEdns0(); opt != nil {
-		opt.SetExtendedRcode(uint16(dns.Rcode))
-	} else if dns.Rcode > 0xF {
-		// If Rcode is an extended one and opt is nil, error out.
-		return nil, ErrExtendedRcode
-	}
-
-	// Convert convenient Msg into wire-like Header.
-	var dh Header
-	dh.Id = dns.Id
-	dh.Bits = uint16(dns.Opcode)<<11 | uint16(dns.Rcode&0xF)
-	if dns.Response {
-		dh.Bits |= _QR
-	}
-	if dns.Authoritative {
-		dh.Bits |= _AA
-	}
-	if dns.Truncated {
-		dh.Bits |= _TC
-	}
-	if dns.RecursionDesired {
-		dh.Bits |= _RD
-	}
-	if dns.RecursionAvailable {
-		dh.Bits |= _RA
-	}
-	if dns.Zero {
-		dh.Bits |= _Z
-	}
-	if dns.AuthenticatedData {
-		dh.Bits |= _AD
-	}
-	if dns.CheckingDisabled {
-		dh.Bits |= _CD
-	}
-
-	dh.Qdcount = uint16(len(dns.Question))
-	dh.Ancount = uint16(len(dns.Answer))
-	dh.Nscount = uint16(len(dns.Ns))
-	dh.Arcount = uint16(len(dns.Extra))
-
-	// We need the uncompressed length here, because we first pack it and then compress it.
-	msg = buf
-	uncompressedLen := msgLenWithCompressionMap(dns, nil)
-	if packLen := uncompressedLen + 1; len(msg) < packLen {
-		msg = make([]byte, packLen)
-	}
-
-	// Pack it in: header and then the pieces.
-	off := 0
-	off, err = dh.pack(msg, off, compression, compress)
-	if err != nil {
-		return nil, err
-	}
-	for _, r := range dns.Question {
-		off, err = r.pack(msg, off, compression, compress)
-		if err != nil {
-			return nil, err
-		}
-	}
-	for _, r := range dns.Answer {
-		_, off, err = packRR(r, msg, off, compression, compress)
-		if err != nil {
-			return nil, err
-		}
-	}
-	for _, r := range dns.Ns {
-		_, off, err = packRR(r, msg, off, compression, compress)
-		if err != nil {
-			return nil, err
-		}
-	}
-	for _, r := range dns.Extra {
-		_, off, err = packRR(r, msg, off, compression, compress)
-		if err != nil {
-			return nil, err
-		}
-	}
-	return msg[:off], nil
-}
-
-func (dns *Msg) unpack(dh Header, msg []byte, off int) (err error) {
-	// If we are at the end of the message we should return *just* the
-	// header. This can still be useful to the caller. 9.9.9.9 sends these
-	// when responding with REFUSED for instance.
-	if off == len(msg) {
-		// reset sections before returning
-		dns.Question, dns.Answer, dns.Ns, dns.Extra = nil, nil, nil, nil
-		return nil
-	}
-
-	// Qdcount, Ancount, Nscount, Arcount can't be trusted, as they are
-	// attacker controlled. This means we can't use them to pre-allocate
-	// slices.
-	dns.Question = nil
-	for i := 0; i < int(dh.Qdcount); i++ {
-		off1 := off
-		var q Question
-		q, off, err = unpackQuestion(msg, off)
-		if err != nil {
-			return err
-		}
-		if off1 == off { // Offset does not increase anymore, dh.Qdcount is a lie!
-			dh.Qdcount = uint16(i)
-			break
-		}
-		dns.Question = append(dns.Question, q)
-	}
-
-	dns.Answer, off, err = unpackRRslice(int(dh.Ancount), msg, off)
-	// The header counts might have been wrong so we need to update it
-	dh.Ancount = uint16(len(dns.Answer))
-	if err == nil {
-		dns.Ns, off, err = unpackRRslice(int(dh.Nscount), msg, off)
-	}
-	// The header counts might have been wrong so we need to update it
-	dh.Nscount = uint16(len(dns.Ns))
-	if err == nil {
-		dns.Extra, _, err = unpackRRslice(int(dh.Arcount), msg, off)
-	}
-	// The header counts might have been wrong so we need to update it
-	dh.Arcount = uint16(len(dns.Extra))
-
-	// Set extended Rcode
-	if opt := dns.IsEdns0(); opt != nil {
-		dns.Rcode |= opt.ExtendedRcode()
-	}
-
-	// TODO(miek) make this an error?
-	// use PackOpt to let people tell how detailed the error reporting should be?
-	// if off != len(msg) {
-	//	// println("dns: extra bytes in dns packet", off, "<", len(msg))
-	// }
-	return err
-}
-
-// Unpack unpacks a binary message to a Msg structure.
-func (dns *Msg) Unpack(msg []byte) (err error) {
-	dh, off, err := unpackMsgHdr(msg, 0)
-	if err != nil {
-		return err
-	}
-
-	dns.setHdr(dh)
-	return dns.unpack(dh, msg, off)
-}
-
-// Convert a complete message to a string with dig-like output.
-func (dns *Msg) String() string {
-	if dns == nil {
-		return "<nil> MsgHdr"
-	}
-	s := dns.MsgHdr.String() + " "
-	if dns.MsgHdr.Opcode == OpcodeUpdate {
-		s += "ZONE: " + strconv.Itoa(len(dns.Question)) + ", "
-		s += "PREREQ: " + strconv.Itoa(len(dns.Answer)) + ", "
-		s += "UPDATE: " + strconv.Itoa(len(dns.Ns)) + ", "
-		s += "ADDITIONAL: " + strconv.Itoa(len(dns.Extra)) + "\n"
-	} else {
-		s += "QUERY: " + strconv.Itoa(len(dns.Question)) + ", "
-		s += "ANSWER: " + strconv.Itoa(len(dns.Answer)) + ", "
-		s += "AUTHORITY: " + strconv.Itoa(len(dns.Ns)) + ", "
-		s += "ADDITIONAL: " + strconv.Itoa(len(dns.Extra)) + "\n"
-	}
-	opt := dns.IsEdns0()
-	if opt != nil {
-		// OPT PSEUDOSECTION
-		s += opt.String() + "\n"
-	}
-	if len(dns.Question) > 0 {
-		if dns.MsgHdr.Opcode == OpcodeUpdate {
-			s += "\n;; ZONE SECTION:\n"
-		} else {
-			s += "\n;; QUESTION SECTION:\n"
-		}
-		for _, r := range dns.Question {
-			s += r.String() + "\n"
-		}
-	}
-	if len(dns.Answer) > 0 {
-		if dns.MsgHdr.Opcode == OpcodeUpdate {
-			s += "\n;; PREREQUISITE SECTION:\n"
-		} else {
-			s += "\n;; ANSWER SECTION:\n"
-		}
-		for _, r := range dns.Answer {
-			if r != nil {
-				s += r.String() + "\n"
-			}
-		}
-	}
-	if len(dns.Ns) > 0 {
-		if dns.MsgHdr.Opcode == OpcodeUpdate {
-			s += "\n;; UPDATE SECTION:\n"
-		} else {
-			s += "\n;; AUTHORITY SECTION:\n"
-		}
-		for _, r := range dns.Ns {
-			if r != nil {
-				s += r.String() + "\n"
-			}
-		}
-	}
-	if len(dns.Extra) > 0 && (opt == nil || len(dns.Extra) > 1) {
-		s += "\n;; ADDITIONAL SECTION:\n"
-		for _, r := range dns.Extra {
-			if r != nil && r.Header().Rrtype != TypeOPT {
-				s += r.String() + "\n"
-			}
-		}
-	}
-	return s
-}
-
-// isCompressible returns whether the msg may be compressible.
-func (dns *Msg) isCompressible() bool {
-	// If we only have one question, there is nothing we can ever compress.
-	return len(dns.Question) > 1 || len(dns.Answer) > 0 ||
-		len(dns.Ns) > 0 || len(dns.Extra) > 0
-}
-
-// Len returns the message length when in (un)compressed wire format.
-// If dns.Compress is true compression it is taken into account. Len()
-// is provided to be a faster way to get the size of the resulting packet,
-// than packing it, measuring the size and discarding the buffer.
-func (dns *Msg) Len() int {
-	// If this message can't be compressed, avoid filling the
-	// compression map and creating garbage.
-	if dns.Compress && dns.isCompressible() {
-		compression := make(map[string]struct{})
-		return msgLenWithCompressionMap(dns, compression)
-	}
-
-	return msgLenWithCompressionMap(dns, nil)
-}
-
-func msgLenWithCompressionMap(dns *Msg, compression map[string]struct{}) int {
-	l := headerSize
-
-	for _, r := range dns.Question {
-		l += r.len(l, compression)
-	}
-	for _, r := range dns.Answer {
-		if r != nil {
-			l += r.len(l, compression)
-		}
-	}
-	for _, r := range dns.Ns {
-		if r != nil {
-			l += r.len(l, compression)
-		}
-	}
-	for _, r := range dns.Extra {
-		if r != nil {
-			l += r.len(l, compression)
-		}
-	}
-
-	return l
-}
-
-func domainNameLen(s string, off int, compression map[string]struct{}, compress bool) int {
-	if s == "" || s == "." {
-		return 1
-	}
-
-	escaped := strings.Contains(s, "\\")
-
-	if compression != nil && (compress || off < maxCompressionOffset) {
-		// compressionLenSearch will insert the entry into the compression
-		// map if it doesn't contain it.
-		if l, ok := compressionLenSearch(compression, s, off); ok && compress {
-			if escaped {
-				return escapedNameLen(s[:l]) + 2
-			}
-
-			return l + 2
-		}
-	}
-
-	if escaped {
-		return escapedNameLen(s) + 1
-	}
-
-	return len(s) + 1
-}
-
-func escapedNameLen(s string) int {
-	nameLen := len(s)
-	for i := 0; i < len(s); i++ {
-		if s[i] != '\\' {
-			continue
-		}
-
-		if isDDD(s[i+1:]) {
-			nameLen -= 3
-			i += 3
-		} else {
-			nameLen--
-			i++
-		}
-	}
-
-	return nameLen
-}
-
-func compressionLenSearch(c map[string]struct{}, s string, msgOff int) (int, bool) {
-	for off, end := 0, false; !end; off, end = NextLabel(s, off) {
-		if _, ok := c[s[off:]]; ok {
-			return off, true
-		}
-
-		if msgOff+off < maxCompressionOffset {
-			c[s[off:]] = struct{}{}
-		}
-	}
-
-	return 0, false
-}
-
-// Copy returns a new RR which is a deep-copy of r.
-func Copy(r RR) RR { return r.copy() }
-
-// Len returns the length (in octets) of the uncompressed RR in wire format.
-func Len(r RR) int { return r.len(0, nil) }
-
-// Copy returns a new *Msg which is a deep-copy of dns.
-func (dns *Msg) Copy() *Msg { return dns.CopyTo(new(Msg)) }
-
-// CopyTo copies the contents to the provided message using a deep-copy and returns the copy.
-func (dns *Msg) CopyTo(r1 *Msg) *Msg {
-	r1.MsgHdr = dns.MsgHdr
-	r1.Compress = dns.Compress
-
-	if len(dns.Question) > 0 {
-		// TODO(miek): Question is an immutable value, ok to do a shallow-copy
-		r1.Question = cloneSlice(dns.Question)
-	}
-
-	rrArr := make([]RR, len(dns.Answer)+len(dns.Ns)+len(dns.Extra))
-	r1.Answer, rrArr = rrArr[:0:len(dns.Answer)], rrArr[len(dns.Answer):]
-	r1.Ns, rrArr = rrArr[:0:len(dns.Ns)], rrArr[len(dns.Ns):]
-	r1.Extra = rrArr[:0:len(dns.Extra)]
-
-	for _, r := range dns.Answer {
-		r1.Answer = append(r1.Answer, r.copy())
-	}
-
-	for _, r := range dns.Ns {
-		r1.Ns = append(r1.Ns, r.copy())
-	}
-
-	for _, r := range dns.Extra {
-		r1.Extra = append(r1.Extra, r.copy())
-	}
-
-	return r1
-}
-
-func (q *Question) pack(msg []byte, off int, compression compressionMap, compress bool) (int, error) {
-	off, err := packDomainName(q.Name, msg, off, compression, compress)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(q.Qtype, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(q.Qclass, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func unpackQuestion(msg []byte, off int) (Question, int, error) {
-	var (
-		q   Question
-		err error
-	)
-	q.Name, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return q, off, fmt.Errorf("bad question name: %w", err)
-	}
-	if off == len(msg) {
-		return q, off, nil
-	}
-	q.Qtype, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return q, off, fmt.Errorf("bad question qtype: %w", err)
-	}
-	if off == len(msg) {
-		return q, off, nil
-	}
-	q.Qclass, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return q, off, fmt.Errorf("bad question qclass: %w", err)
-	}
-
-	if off == len(msg) {
-		return q, off, nil
-	}
-
-	return q, off, nil
-}
-
-func (dh *Header) pack(msg []byte, off int, compression compressionMap, compress bool) (int, error) {
-	off, err := packUint16(dh.Id, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(dh.Bits, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(dh.Qdcount, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(dh.Ancount, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(dh.Nscount, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(dh.Arcount, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func unpackMsgHdr(msg []byte, off int) (Header, int, error) {
-	var (
-		dh  Header
-		err error
-	)
-	dh.Id, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return dh, off, fmt.Errorf("bad header id: %w", err)
-	}
-	dh.Bits, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return dh, off, fmt.Errorf("bad header bits: %w", err)
-	}
-	dh.Qdcount, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return dh, off, fmt.Errorf("bad header question count: %w", err)
-	}
-	dh.Ancount, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return dh, off, fmt.Errorf("bad header answer count: %w", err)
-	}
-	dh.Nscount, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return dh, off, fmt.Errorf("bad header ns count: %w", err)
-	}
-	dh.Arcount, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return dh, off, fmt.Errorf("bad header extra count: %w", err)
-	}
-	return dh, off, nil
-}
-
-// setHdr set the header in the dns using the binary data in dh.
-func (dns *Msg) setHdr(dh Header) {
-	dns.Id = dh.Id
-	dns.Response = dh.Bits&_QR != 0
-	dns.Opcode = int(dh.Bits>>11) & 0xF
-	dns.Authoritative = dh.Bits&_AA != 0
-	dns.Truncated = dh.Bits&_TC != 0
-	dns.RecursionDesired = dh.Bits&_RD != 0
-	dns.RecursionAvailable = dh.Bits&_RA != 0
-	dns.Zero = dh.Bits&_Z != 0 // _Z covers the zero bit, which should be zero; not sure why we set it to the opposite.
-	dns.AuthenticatedData = dh.Bits&_AD != 0
-	dns.CheckingDisabled = dh.Bits&_CD != 0
-	dns.Rcode = int(dh.Bits & 0xF)
-}
diff --git a/vendor/github.com/miekg/dns/msg_helpers.go b/vendor/github.com/miekg/dns/msg_helpers.go
deleted file mode 100644
index acec21f7de..0000000000
--- a/vendor/github.com/miekg/dns/msg_helpers.go
+++ /dev/null
@@ -1,834 +0,0 @@
-package dns
-
-import (
-	"encoding/base32"
-	"encoding/base64"
-	"encoding/binary"
-	"encoding/hex"
-	"net"
-	"sort"
-	"strings"
-)
-
-// helper functions called from the generated zmsg.go
-
-// These function are named after the tag to help pack/unpack, if there is no tag it is the name
-// of the type they pack/unpack (string, int, etc). We prefix all with unpackData or packData, so packDataA or
-// packDataDomainName.
-
-func unpackDataA(msg []byte, off int) (net.IP, int, error) {
-	if off+net.IPv4len > len(msg) {
-		return nil, len(msg), &Error{err: "overflow unpacking a"}
-	}
-	return cloneSlice(msg[off : off+net.IPv4len]), off + net.IPv4len, nil
-}
-
-func packDataA(a net.IP, msg []byte, off int) (int, error) {
-	switch len(a) {
-	case net.IPv4len, net.IPv6len:
-		// It must be a slice of 4, even if it is 16, we encode only the first 4
-		if off+net.IPv4len > len(msg) {
-			return len(msg), &Error{err: "overflow packing a"}
-		}
-
-		copy(msg[off:], a.To4())
-		off += net.IPv4len
-	case 0:
-		// Allowed, for dynamic updates.
-	default:
-		return len(msg), &Error{err: "overflow packing a"}
-	}
-	return off, nil
-}
-
-func unpackDataAAAA(msg []byte, off int) (net.IP, int, error) {
-	if off+net.IPv6len > len(msg) {
-		return nil, len(msg), &Error{err: "overflow unpacking aaaa"}
-	}
-	return cloneSlice(msg[off : off+net.IPv6len]), off + net.IPv6len, nil
-}
-
-func packDataAAAA(aaaa net.IP, msg []byte, off int) (int, error) {
-	switch len(aaaa) {
-	case net.IPv6len:
-		if off+net.IPv6len > len(msg) {
-			return len(msg), &Error{err: "overflow packing aaaa"}
-		}
-
-		copy(msg[off:], aaaa)
-		off += net.IPv6len
-	case 0:
-		// Allowed, dynamic updates.
-	default:
-		return len(msg), &Error{err: "overflow packing aaaa"}
-	}
-	return off, nil
-}
-
-// unpackHeader unpacks an RR header, returning the offset to the end of the header and a
-// re-sliced msg according to the expected length of the RR.
-func unpackHeader(msg []byte, off int) (rr RR_Header, off1 int, truncmsg []byte, err error) {
-	hdr := RR_Header{}
-	if off == len(msg) {
-		return hdr, off, msg, nil
-	}
-
-	hdr.Name, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return hdr, len(msg), msg, err
-	}
-	hdr.Rrtype, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return hdr, len(msg), msg, err
-	}
-	hdr.Class, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return hdr, len(msg), msg, err
-	}
-	hdr.Ttl, off, err = unpackUint32(msg, off)
-	if err != nil {
-		return hdr, len(msg), msg, err
-	}
-	hdr.Rdlength, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return hdr, len(msg), msg, err
-	}
-	msg, err = truncateMsgFromRdlength(msg, off, hdr.Rdlength)
-	return hdr, off, msg, err
-}
-
-// packHeader packs an RR header, returning the offset to the end of the header.
-// See PackDomainName for documentation about the compression.
-func (hdr RR_Header) packHeader(msg []byte, off int, compression compressionMap, compress bool) (int, error) {
-	if off == len(msg) {
-		return off, nil
-	}
-
-	off, err := packDomainName(hdr.Name, msg, off, compression, compress)
-	if err != nil {
-		return len(msg), err
-	}
-	off, err = packUint16(hdr.Rrtype, msg, off)
-	if err != nil {
-		return len(msg), err
-	}
-	off, err = packUint16(hdr.Class, msg, off)
-	if err != nil {
-		return len(msg), err
-	}
-	off, err = packUint32(hdr.Ttl, msg, off)
-	if err != nil {
-		return len(msg), err
-	}
-	off, err = packUint16(0, msg, off) // The RDLENGTH field will be set later in packRR.
-	if err != nil {
-		return len(msg), err
-	}
-	return off, nil
-}
-
-// helper helper functions.
-
-// truncateMsgFromRdLength truncates msg to match the expected length of the RR.
-// Returns an error if msg is smaller than the expected size.
-func truncateMsgFromRdlength(msg []byte, off int, rdlength uint16) (truncmsg []byte, err error) {
-	lenrd := off + int(rdlength)
-	if lenrd > len(msg) {
-		return msg, &Error{err: "overflowing header size"}
-	}
-	return msg[:lenrd], nil
-}
-
-var base32HexNoPadEncoding = base32.HexEncoding.WithPadding(base32.NoPadding)
-
-func fromBase32(s []byte) (buf []byte, err error) {
-	for i, b := range s {
-		if b >= 'a' && b <= 'z' {
-			s[i] = b - 32
-		}
-	}
-	buflen := base32HexNoPadEncoding.DecodedLen(len(s))
-	buf = make([]byte, buflen)
-	n, err := base32HexNoPadEncoding.Decode(buf, s)
-	buf = buf[:n]
-	return
-}
-
-func toBase32(b []byte) string {
-	return base32HexNoPadEncoding.EncodeToString(b)
-}
-
-func fromBase64(s []byte) (buf []byte, err error) {
-	buflen := base64.StdEncoding.DecodedLen(len(s))
-	buf = make([]byte, buflen)
-	n, err := base64.StdEncoding.Decode(buf, s)
-	buf = buf[:n]
-	return
-}
-
-func toBase64(b []byte) string { return base64.StdEncoding.EncodeToString(b) }
-
-// dynamicUpdate returns true if the Rdlength is zero.
-func noRdata(h RR_Header) bool { return h.Rdlength == 0 }
-
-func unpackUint8(msg []byte, off int) (i uint8, off1 int, err error) {
-	if off+1 > len(msg) {
-		return 0, len(msg), &Error{err: "overflow unpacking uint8"}
-	}
-	return msg[off], off + 1, nil
-}
-
-func packUint8(i uint8, msg []byte, off int) (off1 int, err error) {
-	if off+1 > len(msg) {
-		return len(msg), &Error{err: "overflow packing uint8"}
-	}
-	msg[off] = i
-	return off + 1, nil
-}
-
-func unpackUint16(msg []byte, off int) (i uint16, off1 int, err error) {
-	if off+2 > len(msg) {
-		return 0, len(msg), &Error{err: "overflow unpacking uint16"}
-	}
-	return binary.BigEndian.Uint16(msg[off:]), off + 2, nil
-}
-
-func packUint16(i uint16, msg []byte, off int) (off1 int, err error) {
-	if off+2 > len(msg) {
-		return len(msg), &Error{err: "overflow packing uint16"}
-	}
-	binary.BigEndian.PutUint16(msg[off:], i)
-	return off + 2, nil
-}
-
-func unpackUint32(msg []byte, off int) (i uint32, off1 int, err error) {
-	if off+4 > len(msg) {
-		return 0, len(msg), &Error{err: "overflow unpacking uint32"}
-	}
-	return binary.BigEndian.Uint32(msg[off:]), off + 4, nil
-}
-
-func packUint32(i uint32, msg []byte, off int) (off1 int, err error) {
-	if off+4 > len(msg) {
-		return len(msg), &Error{err: "overflow packing uint32"}
-	}
-	binary.BigEndian.PutUint32(msg[off:], i)
-	return off + 4, nil
-}
-
-func unpackUint48(msg []byte, off int) (i uint64, off1 int, err error) {
-	if off+6 > len(msg) {
-		return 0, len(msg), &Error{err: "overflow unpacking uint64 as uint48"}
-	}
-	// Used in TSIG where the last 48 bits are occupied, so for now, assume a uint48 (6 bytes)
-	i = uint64(msg[off])<<40 | uint64(msg[off+1])<<32 | uint64(msg[off+2])<<24 | uint64(msg[off+3])<<16 |
-		uint64(msg[off+4])<<8 | uint64(msg[off+5])
-	off += 6
-	return i, off, nil
-}
-
-func packUint48(i uint64, msg []byte, off int) (off1 int, err error) {
-	if off+6 > len(msg) {
-		return len(msg), &Error{err: "overflow packing uint64 as uint48"}
-	}
-	msg[off] = byte(i >> 40)
-	msg[off+1] = byte(i >> 32)
-	msg[off+2] = byte(i >> 24)
-	msg[off+3] = byte(i >> 16)
-	msg[off+4] = byte(i >> 8)
-	msg[off+5] = byte(i)
-	off += 6
-	return off, nil
-}
-
-func unpackUint64(msg []byte, off int) (i uint64, off1 int, err error) {
-	if off+8 > len(msg) {
-		return 0, len(msg), &Error{err: "overflow unpacking uint64"}
-	}
-	return binary.BigEndian.Uint64(msg[off:]), off + 8, nil
-}
-
-func packUint64(i uint64, msg []byte, off int) (off1 int, err error) {
-	if off+8 > len(msg) {
-		return len(msg), &Error{err: "overflow packing uint64"}
-	}
-	binary.BigEndian.PutUint64(msg[off:], i)
-	off += 8
-	return off, nil
-}
-
-func unpackString(msg []byte, off int) (string, int, error) {
-	if off+1 > len(msg) {
-		return "", off, &Error{err: "overflow unpacking txt"}
-	}
-	l := int(msg[off])
-	off++
-	if off+l > len(msg) {
-		return "", off, &Error{err: "overflow unpacking txt"}
-	}
-	var s strings.Builder
-	consumed := 0
-	for i, b := range msg[off : off+l] {
-		switch {
-		case b == '"' || b == '\\':
-			if consumed == 0 {
-				s.Grow(l * 2)
-			}
-			s.Write(msg[off+consumed : off+i])
-			s.WriteByte('\\')
-			s.WriteByte(b)
-			consumed = i + 1
-		case b < ' ' || b > '~': // unprintable
-			if consumed == 0 {
-				s.Grow(l * 2)
-			}
-			s.Write(msg[off+consumed : off+i])
-			s.WriteString(escapeByte(b))
-			consumed = i + 1
-		}
-	}
-	if consumed == 0 { // no escaping needed
-		return string(msg[off : off+l]), off + l, nil
-	}
-	s.Write(msg[off+consumed : off+l])
-	return s.String(), off + l, nil
-}
-
-func packString(s string, msg []byte, off int) (int, error) {
-	off, err := packTxtString(s, msg, off)
-	if err != nil {
-		return len(msg), err
-	}
-	return off, nil
-}
-
-func unpackStringBase32(msg []byte, off, end int) (string, int, error) {
-	if end > len(msg) {
-		return "", len(msg), &Error{err: "overflow unpacking base32"}
-	}
-	s := toBase32(msg[off:end])
-	return s, end, nil
-}
-
-func packStringBase32(s string, msg []byte, off int) (int, error) {
-	b32, err := fromBase32([]byte(s))
-	if err != nil {
-		return len(msg), err
-	}
-	if off+len(b32) > len(msg) {
-		return len(msg), &Error{err: "overflow packing base32"}
-	}
-	copy(msg[off:off+len(b32)], b32)
-	off += len(b32)
-	return off, nil
-}
-
-func unpackStringBase64(msg []byte, off, end int) (string, int, error) {
-	// Rest of the RR is base64 encoded value, so we don't need an explicit length
-	// to be set. Thus far all RR's that have base64 encoded fields have those as their
-	// last one. What we do need is the end of the RR!
-	if end > len(msg) {
-		return "", len(msg), &Error{err: "overflow unpacking base64"}
-	}
-	s := toBase64(msg[off:end])
-	return s, end, nil
-}
-
-func packStringBase64(s string, msg []byte, off int) (int, error) {
-	b64, err := fromBase64([]byte(s))
-	if err != nil {
-		return len(msg), err
-	}
-	if off+len(b64) > len(msg) {
-		return len(msg), &Error{err: "overflow packing base64"}
-	}
-	copy(msg[off:off+len(b64)], b64)
-	off += len(b64)
-	return off, nil
-}
-
-func unpackStringHex(msg []byte, off, end int) (string, int, error) {
-	// Rest of the RR is hex encoded value, so we don't need an explicit length
-	// to be set. NSEC and TSIG have hex fields with a length field.
-	// What we do need is the end of the RR!
-	if end > len(msg) {
-		return "", len(msg), &Error{err: "overflow unpacking hex"}
-	}
-
-	s := hex.EncodeToString(msg[off:end])
-	return s, end, nil
-}
-
-func packStringHex(s string, msg []byte, off int) (int, error) {
-	h, err := hex.DecodeString(s)
-	if err != nil {
-		return len(msg), err
-	}
-	if off+len(h) > len(msg) {
-		return len(msg), &Error{err: "overflow packing hex"}
-	}
-	copy(msg[off:off+len(h)], h)
-	off += len(h)
-	return off, nil
-}
-
-func unpackStringAny(msg []byte, off, end int) (string, int, error) {
-	if end > len(msg) {
-		return "", len(msg), &Error{err: "overflow unpacking anything"}
-	}
-	return string(msg[off:end]), end, nil
-}
-
-func packStringAny(s string, msg []byte, off int) (int, error) {
-	if off+len(s) > len(msg) {
-		return len(msg), &Error{err: "overflow packing anything"}
-	}
-	copy(msg[off:off+len(s)], s)
-	off += len(s)
-	return off, nil
-}
-
-func unpackStringTxt(msg []byte, off int) ([]string, int, error) {
-	txt, off, err := unpackTxt(msg, off)
-	if err != nil {
-		return nil, len(msg), err
-	}
-	return txt, off, nil
-}
-
-func packStringTxt(s []string, msg []byte, off int) (int, error) {
-	off, err := packTxt(s, msg, off)
-	if err != nil {
-		return len(msg), err
-	}
-	return off, nil
-}
-
-func unpackDataOpt(msg []byte, off int) ([]EDNS0, int, error) {
-	var edns []EDNS0
-	for off < len(msg) {
-		if off+4 > len(msg) {
-			return nil, len(msg), &Error{err: "overflow unpacking opt"}
-		}
-		code := binary.BigEndian.Uint16(msg[off:])
-		off += 2
-		optlen := binary.BigEndian.Uint16(msg[off:])
-		off += 2
-		if off+int(optlen) > len(msg) {
-			return nil, len(msg), &Error{err: "overflow unpacking opt"}
-		}
-		opt := makeDataOpt(code)
-		if err := opt.unpack(msg[off : off+int(optlen)]); err != nil {
-			return nil, len(msg), err
-		}
-		edns = append(edns, opt)
-		off += int(optlen)
-	}
-	return edns, off, nil
-}
-
-func packDataOpt(options []EDNS0, msg []byte, off int) (int, error) {
-	for _, el := range options {
-		b, err := el.pack()
-		if err != nil || off+4 > len(msg) {
-			return len(msg), &Error{err: "overflow packing opt"}
-		}
-		binary.BigEndian.PutUint16(msg[off:], el.Option())      // Option code
-		binary.BigEndian.PutUint16(msg[off+2:], uint16(len(b))) // Length
-		off += 4
-		if off+len(b) > len(msg) {
-			return len(msg), &Error{err: "overflow packing opt"}
-		}
-		// Actual data
-		copy(msg[off:off+len(b)], b)
-		off += len(b)
-	}
-	return off, nil
-}
-
-func unpackStringOctet(msg []byte, off int) (string, int, error) {
-	s := string(msg[off:])
-	return s, len(msg), nil
-}
-
-func packStringOctet(s string, msg []byte, off int) (int, error) {
-	off, err := packOctetString(s, msg, off)
-	if err != nil {
-		return len(msg), err
-	}
-	return off, nil
-}
-
-func unpackDataNsec(msg []byte, off int) ([]uint16, int, error) {
-	var nsec []uint16
-	length, window, lastwindow := 0, 0, -1
-	for off < len(msg) {
-		if off+2 > len(msg) {
-			return nsec, len(msg), &Error{err: "overflow unpacking NSEC(3)"}
-		}
-		window = int(msg[off])
-		length = int(msg[off+1])
-		off += 2
-		if window <= lastwindow {
-			// RFC 4034: Blocks are present in the NSEC RR RDATA in
-			// increasing numerical order.
-			return nsec, len(msg), &Error{err: "out of order NSEC(3) block in type bitmap"}
-		}
-		if length == 0 {
-			// RFC 4034: Blocks with no types present MUST NOT be included.
-			return nsec, len(msg), &Error{err: "empty NSEC(3) block in type bitmap"}
-		}
-		if length > 32 {
-			return nsec, len(msg), &Error{err: "NSEC(3) block too long in type bitmap"}
-		}
-		if off+length > len(msg) {
-			return nsec, len(msg), &Error{err: "overflowing NSEC(3) block in type bitmap"}
-		}
-
-		// Walk the bytes in the window and extract the type bits
-		for j, b := range msg[off : off+length] {
-			// Check the bits one by one, and set the type
-			if b&0x80 == 0x80 {
-				nsec = append(nsec, uint16(window*256+j*8+0))
-			}
-			if b&0x40 == 0x40 {
-				nsec = append(nsec, uint16(window*256+j*8+1))
-			}
-			if b&0x20 == 0x20 {
-				nsec = append(nsec, uint16(window*256+j*8+2))
-			}
-			if b&0x10 == 0x10 {
-				nsec = append(nsec, uint16(window*256+j*8+3))
-			}
-			if b&0x8 == 0x8 {
-				nsec = append(nsec, uint16(window*256+j*8+4))
-			}
-			if b&0x4 == 0x4 {
-				nsec = append(nsec, uint16(window*256+j*8+5))
-			}
-			if b&0x2 == 0x2 {
-				nsec = append(nsec, uint16(window*256+j*8+6))
-			}
-			if b&0x1 == 0x1 {
-				nsec = append(nsec, uint16(window*256+j*8+7))
-			}
-		}
-		off += length
-		lastwindow = window
-	}
-	return nsec, off, nil
-}
-
-// typeBitMapLen is a helper function which computes the "maximum" length of
-// a the NSEC Type BitMap field.
-func typeBitMapLen(bitmap []uint16) int {
-	var l int
-	var lastwindow, lastlength uint16
-	for _, t := range bitmap {
-		window := t / 256
-		length := (t-window*256)/8 + 1
-		if window > lastwindow && lastlength != 0 { // New window, jump to the new offset
-			l += int(lastlength) + 2
-			lastlength = 0
-		}
-		if window < lastwindow || length < lastlength {
-			// packDataNsec would return Error{err: "nsec bits out of order"} here, but
-			// when computing the length, we want do be liberal.
-			continue
-		}
-		lastwindow, lastlength = window, length
-	}
-	l += int(lastlength) + 2
-	return l
-}
-
-func packDataNsec(bitmap []uint16, msg []byte, off int) (int, error) {
-	if len(bitmap) == 0 {
-		return off, nil
-	}
-	if off > len(msg) {
-		return off, &Error{err: "overflow packing nsec"}
-	}
-	toZero := msg[off:]
-	if maxLen := typeBitMapLen(bitmap); maxLen < len(toZero) {
-		toZero = toZero[:maxLen]
-	}
-	for i := range toZero {
-		toZero[i] = 0
-	}
-	var lastwindow, lastlength uint16
-	for _, t := range bitmap {
-		window := t / 256
-		length := (t-window*256)/8 + 1
-		if window > lastwindow && lastlength != 0 { // New window, jump to the new offset
-			off += int(lastlength) + 2
-			lastlength = 0
-		}
-		if window < lastwindow || length < lastlength {
-			return len(msg), &Error{err: "nsec bits out of order"}
-		}
-		if off+2+int(length) > len(msg) {
-			return len(msg), &Error{err: "overflow packing nsec"}
-		}
-		// Setting the window #
-		msg[off] = byte(window)
-		// Setting the octets length
-		msg[off+1] = byte(length)
-		// Setting the bit value for the type in the right octet
-		msg[off+1+int(length)] |= byte(1 << (7 - t%8))
-		lastwindow, lastlength = window, length
-	}
-	off += int(lastlength) + 2
-	return off, nil
-}
-
-func unpackDataSVCB(msg []byte, off int) ([]SVCBKeyValue, int, error) {
-	var xs []SVCBKeyValue
-	var code uint16
-	var length uint16
-	var err error
-	for off < len(msg) {
-		code, off, err = unpackUint16(msg, off)
-		if err != nil {
-			return nil, len(msg), &Error{err: "overflow unpacking SVCB"}
-		}
-		length, off, err = unpackUint16(msg, off)
-		if err != nil || off+int(length) > len(msg) {
-			return nil, len(msg), &Error{err: "overflow unpacking SVCB"}
-		}
-		e := makeSVCBKeyValue(SVCBKey(code))
-		if e == nil {
-			return nil, len(msg), &Error{err: "bad SVCB key"}
-		}
-		if err := e.unpack(msg[off : off+int(length)]); err != nil {
-			return nil, len(msg), err
-		}
-		if len(xs) > 0 && e.Key() <= xs[len(xs)-1].Key() {
-			return nil, len(msg), &Error{err: "SVCB keys not in strictly increasing order"}
-		}
-		xs = append(xs, e)
-		off += int(length)
-	}
-	return xs, off, nil
-}
-
-func packDataSVCB(pairs []SVCBKeyValue, msg []byte, off int) (int, error) {
-	pairs = cloneSlice(pairs)
-	sort.Slice(pairs, func(i, j int) bool {
-		return pairs[i].Key() < pairs[j].Key()
-	})
-	prev := svcb_RESERVED
-	for _, el := range pairs {
-		if el.Key() == prev {
-			return len(msg), &Error{err: "repeated SVCB keys are not allowed"}
-		}
-		prev = el.Key()
-		packed, err := el.pack()
-		if err != nil {
-			return len(msg), err
-		}
-		off, err = packUint16(uint16(el.Key()), msg, off)
-		if err != nil {
-			return len(msg), &Error{err: "overflow packing SVCB"}
-		}
-		off, err = packUint16(uint16(len(packed)), msg, off)
-		if err != nil || off+len(packed) > len(msg) {
-			return len(msg), &Error{err: "overflow packing SVCB"}
-		}
-		copy(msg[off:off+len(packed)], packed)
-		off += len(packed)
-	}
-	return off, nil
-}
-
-func unpackDataDomainNames(msg []byte, off, end int) ([]string, int, error) {
-	var (
-		servers []string
-		s       string
-		err     error
-	)
-	if end > len(msg) {
-		return nil, len(msg), &Error{err: "overflow unpacking domain names"}
-	}
-	for off < end {
-		s, off, err = UnpackDomainName(msg, off)
-		if err != nil {
-			return servers, len(msg), err
-		}
-		servers = append(servers, s)
-	}
-	return servers, off, nil
-}
-
-func packDataDomainNames(names []string, msg []byte, off int, compression compressionMap, compress bool) (int, error) {
-	var err error
-	for _, name := range names {
-		off, err = packDomainName(name, msg, off, compression, compress)
-		if err != nil {
-			return len(msg), err
-		}
-	}
-	return off, nil
-}
-
-func packDataApl(data []APLPrefix, msg []byte, off int) (int, error) {
-	var err error
-	for i := range data {
-		off, err = packDataAplPrefix(&data[i], msg, off)
-		if err != nil {
-			return len(msg), err
-		}
-	}
-	return off, nil
-}
-
-func packDataAplPrefix(p *APLPrefix, msg []byte, off int) (int, error) {
-	if len(p.Network.IP) != len(p.Network.Mask) {
-		return len(msg), &Error{err: "address and mask lengths don't match"}
-	}
-
-	var err error
-	prefix, _ := p.Network.Mask.Size()
-	addr := p.Network.IP.Mask(p.Network.Mask)[:(prefix+7)/8]
-
-	switch len(p.Network.IP) {
-	case net.IPv4len:
-		off, err = packUint16(1, msg, off)
-	case net.IPv6len:
-		off, err = packUint16(2, msg, off)
-	default:
-		err = &Error{err: "unrecognized address family"}
-	}
-	if err != nil {
-		return len(msg), err
-	}
-
-	off, err = packUint8(uint8(prefix), msg, off)
-	if err != nil {
-		return len(msg), err
-	}
-
-	var n uint8
-	if p.Negation {
-		n = 0x80
-	}
-
-	// trim trailing zero bytes as specified in RFC3123 Sections 4.1 and 4.2.
-	i := len(addr) - 1
-	for ; i >= 0 && addr[i] == 0; i-- {
-	}
-	addr = addr[:i+1]
-
-	adflen := uint8(len(addr)) & 0x7f
-	off, err = packUint8(n|adflen, msg, off)
-	if err != nil {
-		return len(msg), err
-	}
-
-	if off+len(addr) > len(msg) {
-		return len(msg), &Error{err: "overflow packing APL prefix"}
-	}
-	off += copy(msg[off:], addr)
-
-	return off, nil
-}
-
-func unpackDataApl(msg []byte, off int) ([]APLPrefix, int, error) {
-	var result []APLPrefix
-	for off < len(msg) {
-		prefix, end, err := unpackDataAplPrefix(msg, off)
-		if err != nil {
-			return nil, len(msg), err
-		}
-		off = end
-		result = append(result, prefix)
-	}
-	return result, off, nil
-}
-
-func unpackDataAplPrefix(msg []byte, off int) (APLPrefix, int, error) {
-	family, off, err := unpackUint16(msg, off)
-	if err != nil {
-		return APLPrefix{}, len(msg), &Error{err: "overflow unpacking APL prefix"}
-	}
-	prefix, off, err := unpackUint8(msg, off)
-	if err != nil {
-		return APLPrefix{}, len(msg), &Error{err: "overflow unpacking APL prefix"}
-	}
-	nlen, off, err := unpackUint8(msg, off)
-	if err != nil {
-		return APLPrefix{}, len(msg), &Error{err: "overflow unpacking APL prefix"}
-	}
-
-	var ip []byte
-	switch family {
-	case 1:
-		ip = make([]byte, net.IPv4len)
-	case 2:
-		ip = make([]byte, net.IPv6len)
-	default:
-		return APLPrefix{}, len(msg), &Error{err: "unrecognized APL address family"}
-	}
-	if int(prefix) > 8*len(ip) {
-		return APLPrefix{}, len(msg), &Error{err: "APL prefix too long"}
-	}
-	afdlen := int(nlen & 0x7f)
-	if afdlen > len(ip) {
-		return APLPrefix{}, len(msg), &Error{err: "APL length too long"}
-	}
-	if off+afdlen > len(msg) {
-		return APLPrefix{}, len(msg), &Error{err: "overflow unpacking APL address"}
-	}
-
-	// Address MUST NOT contain trailing zero bytes per RFC3123 Sections 4.1 and 4.2.
-	off += copy(ip, msg[off:off+afdlen])
-	if afdlen > 0 {
-		last := ip[afdlen-1]
-		if last == 0 {
-			return APLPrefix{}, len(msg), &Error{err: "extra APL address bits"}
-		}
-	}
-	ipnet := net.IPNet{
-		IP:   ip,
-		Mask: net.CIDRMask(int(prefix), 8*len(ip)),
-	}
-
-	return APLPrefix{
-		Negation: (nlen & 0x80) != 0,
-		Network:  ipnet,
-	}, off, nil
-}
-
-func unpackIPSECGateway(msg []byte, off int, gatewayType uint8) (net.IP, string, int, error) {
-	var retAddr net.IP
-	var retString string
-	var err error
-
-	switch gatewayType {
-	case IPSECGatewayNone: // do nothing
-	case IPSECGatewayIPv4:
-		retAddr, off, err = unpackDataA(msg, off)
-	case IPSECGatewayIPv6:
-		retAddr, off, err = unpackDataAAAA(msg, off)
-	case IPSECGatewayHost:
-		retString, off, err = UnpackDomainName(msg, off)
-	}
-
-	return retAddr, retString, off, err
-}
-
-func packIPSECGateway(gatewayAddr net.IP, gatewayString string, msg []byte, off int, gatewayType uint8, compression compressionMap, compress bool) (int, error) {
-	var err error
-
-	switch gatewayType {
-	case IPSECGatewayNone: // do nothing
-	case IPSECGatewayIPv4:
-		off, err = packDataA(gatewayAddr, msg, off)
-	case IPSECGatewayIPv6:
-		off, err = packDataAAAA(gatewayAddr, msg, off)
-	case IPSECGatewayHost:
-		off, err = packDomainName(gatewayString, msg, off, compression, compress)
-	}
-
-	return off, err
-}
diff --git a/vendor/github.com/miekg/dns/msg_truncate.go b/vendor/github.com/miekg/dns/msg_truncate.go
deleted file mode 100644
index 2ddc9a7da8..0000000000
--- a/vendor/github.com/miekg/dns/msg_truncate.go
+++ /dev/null
@@ -1,117 +0,0 @@
-package dns
-
-// Truncate ensures the reply message will fit into the requested buffer
-// size by removing records that exceed the requested size.
-//
-// It will first check if the reply fits without compression and then with
-// compression. If it won't fit with compression, Truncate then walks the
-// record adding as many records as possible without exceeding the
-// requested buffer size.
-//
-// If the message fits within the requested size without compression,
-// Truncate will set the message's Compress attribute to false. It is
-// the caller's responsibility to set it back to true if they wish to
-// compress the payload regardless of size.
-//
-// The TC bit will be set if any records were excluded from the message.
-// If the TC bit is already set on the message it will be retained.
-// TC indicates that the client should retry over TCP.
-//
-// According to RFC 2181, the TC bit should only be set if not all of the
-// "required" RRs can be included in the response. Unfortunately, we have
-// no way of knowing which RRs are required so we set the TC bit if any RR
-// had to be omitted from the response.
-//
-// The appropriate buffer size can be retrieved from the requests OPT
-// record, if present, and is transport specific otherwise. dns.MinMsgSize
-// should be used for UDP requests without an OPT record, and
-// dns.MaxMsgSize for TCP requests without an OPT record.
-func (dns *Msg) Truncate(size int) {
-	if dns.IsTsig() != nil {
-		// To simplify this implementation, we don't perform
-		// truncation on responses with a TSIG record.
-		return
-	}
-
-	// RFC 6891 mandates that the payload size in an OPT record
-	// less than 512 (MinMsgSize) bytes must be treated as equal to 512 bytes.
-	//
-	// For ease of use, we impose that restriction here.
-	if size < MinMsgSize {
-		size = MinMsgSize
-	}
-
-	l := msgLenWithCompressionMap(dns, nil) // uncompressed length
-	if l <= size {
-		// Don't waste effort compressing this message.
-		dns.Compress = false
-		return
-	}
-
-	dns.Compress = true
-
-	edns0 := dns.popEdns0()
-	if edns0 != nil {
-		// Account for the OPT record that gets added at the end,
-		// by subtracting that length from our budget.
-		//
-		// The EDNS(0) OPT record must have the root domain and
-		// it's length is thus unaffected by compression.
-		size -= Len(edns0)
-	}
-
-	compression := make(map[string]struct{})
-
-	l = headerSize
-	for _, r := range dns.Question {
-		l += r.len(l, compression)
-	}
-
-	var numAnswer int
-	if l < size {
-		l, numAnswer = truncateLoop(dns.Answer, size, l, compression)
-	}
-
-	var numNS int
-	if l < size {
-		l, numNS = truncateLoop(dns.Ns, size, l, compression)
-	}
-
-	var numExtra int
-	if l < size {
-		_, numExtra = truncateLoop(dns.Extra, size, l, compression)
-	}
-
-	// See the function documentation for when we set this.
-	dns.Truncated = dns.Truncated || len(dns.Answer) > numAnswer ||
-		len(dns.Ns) > numNS || len(dns.Extra) > numExtra
-
-	dns.Answer = dns.Answer[:numAnswer]
-	dns.Ns = dns.Ns[:numNS]
-	dns.Extra = dns.Extra[:numExtra]
-
-	if edns0 != nil {
-		// Add the OPT record back onto the additional section.
-		dns.Extra = append(dns.Extra, edns0)
-	}
-}
-
-func truncateLoop(rrs []RR, size, l int, compression map[string]struct{}) (int, int) {
-	for i, r := range rrs {
-		if r == nil {
-			continue
-		}
-
-		l += r.len(l, compression)
-		if l > size {
-			// Return size, rather than l prior to this record,
-			// to prevent any further records being added.
-			return size, i
-		}
-		if l == size {
-			return l, i + 1
-		}
-	}
-
-	return l, len(rrs)
-}
diff --git a/vendor/github.com/miekg/dns/nsecx.go b/vendor/github.com/miekg/dns/nsecx.go
deleted file mode 100644
index f8826817b3..0000000000
--- a/vendor/github.com/miekg/dns/nsecx.go
+++ /dev/null
@@ -1,95 +0,0 @@
-package dns
-
-import (
-	"crypto/sha1"
-	"encoding/hex"
-	"strings"
-)
-
-// HashName hashes a string (label) according to RFC 5155. It returns the hashed string in uppercase.
-func HashName(label string, ha uint8, iter uint16, salt string) string {
-	if ha != SHA1 {
-		return ""
-	}
-
-	wireSalt := make([]byte, hex.DecodedLen(len(salt)))
-	n, err := packStringHex(salt, wireSalt, 0)
-	if err != nil {
-		return ""
-	}
-	wireSalt = wireSalt[:n]
-
-	name := make([]byte, 255)
-	off, err := PackDomainName(strings.ToLower(label), name, 0, nil, false)
-	if err != nil {
-		return ""
-	}
-	name = name[:off]
-
-	s := sha1.New()
-	// k = 0
-	s.Write(name)
-	s.Write(wireSalt)
-	nsec3 := s.Sum(nil)
-
-	// k > 0
-	for k := uint16(0); k < iter; k++ {
-		s.Reset()
-		s.Write(nsec3)
-		s.Write(wireSalt)
-		nsec3 = s.Sum(nsec3[:0])
-	}
-
-	return toBase32(nsec3)
-}
-
-// Cover returns true if a name is covered by the NSEC3 record.
-func (rr *NSEC3) Cover(name string) bool {
-	nameHash := HashName(name, rr.Hash, rr.Iterations, rr.Salt)
-	owner := strings.ToUpper(rr.Hdr.Name)
-	labelIndices := Split(owner)
-	if len(labelIndices) < 2 {
-		return false
-	}
-	ownerHash := owner[:labelIndices[1]-1]
-	ownerZone := owner[labelIndices[1]:]
-	if !IsSubDomain(ownerZone, strings.ToUpper(name)) { // name is outside owner zone
-		return false
-	}
-
-	nextHash := rr.NextDomain
-
-	// if empty interval found, try cover wildcard hashes so nameHash shouldn't match with ownerHash
-	if ownerHash == nextHash && nameHash != ownerHash { // empty interval
-		return true
-	}
-	if ownerHash > nextHash { // end of zone
-		if nameHash > ownerHash { // covered since there is nothing after ownerHash
-			return true
-		}
-		return nameHash < nextHash // if nameHash is before beginning of zone it is covered
-	}
-	if nameHash < ownerHash { // nameHash is before ownerHash, not covered
-		return false
-	}
-	return nameHash < nextHash // if nameHash is before nextHash is it covered (between ownerHash and nextHash)
-}
-
-// Match returns true if a name matches the NSEC3 record
-func (rr *NSEC3) Match(name string) bool {
-	nameHash := HashName(name, rr.Hash, rr.Iterations, rr.Salt)
-	owner := strings.ToUpper(rr.Hdr.Name)
-	labelIndices := Split(owner)
-	if len(labelIndices) < 2 {
-		return false
-	}
-	ownerHash := owner[:labelIndices[1]-1]
-	ownerZone := owner[labelIndices[1]:]
-	if !IsSubDomain(ownerZone, strings.ToUpper(name)) { // name is outside owner zone
-		return false
-	}
-	if ownerHash == nameHash {
-		return true
-	}
-	return false
-}
diff --git a/vendor/github.com/miekg/dns/privaterr.go b/vendor/github.com/miekg/dns/privaterr.go
deleted file mode 100644
index 350ea5a47a..0000000000
--- a/vendor/github.com/miekg/dns/privaterr.go
+++ /dev/null
@@ -1,113 +0,0 @@
-package dns
-
-import "strings"
-
-// PrivateRdata is an interface used for implementing "Private Use" RR types, see
-// RFC 6895. This allows one to experiment with new RR types, without requesting an
-// official type code. Also see dns.PrivateHandle and dns.PrivateHandleRemove.
-type PrivateRdata interface {
-	// String returns the text presentation of the Rdata of the Private RR.
-	String() string
-	// Parse parses the Rdata of the private RR.
-	Parse([]string) error
-	// Pack is used when packing a private RR into a buffer.
-	Pack([]byte) (int, error)
-	// Unpack is used when unpacking a private RR from a buffer.
-	Unpack([]byte) (int, error)
-	// Copy copies the Rdata into the PrivateRdata argument.
-	Copy(PrivateRdata) error
-	// Len returns the length in octets of the Rdata.
-	Len() int
-}
-
-// PrivateRR represents an RR that uses a PrivateRdata user-defined type.
-// It mocks normal RRs and implements dns.RR interface.
-type PrivateRR struct {
-	Hdr  RR_Header
-	Data PrivateRdata
-
-	generator func() PrivateRdata // for copy
-}
-
-// Header return the RR header of r.
-func (r *PrivateRR) Header() *RR_Header { return &r.Hdr }
-
-func (r *PrivateRR) String() string { return r.Hdr.String() + r.Data.String() }
-
-// Private len and copy parts to satisfy RR interface.
-func (r *PrivateRR) len(off int, compression map[string]struct{}) int {
-	l := r.Hdr.len(off, compression)
-	l += r.Data.Len()
-	return l
-}
-
-func (r *PrivateRR) copy() RR {
-	// make new RR like this:
-	rr := &PrivateRR{r.Hdr, r.generator(), r.generator}
-
-	if err := r.Data.Copy(rr.Data); err != nil {
-		panic("dns: got value that could not be used to copy Private rdata: " + err.Error())
-	}
-
-	return rr
-}
-
-func (r *PrivateRR) pack(msg []byte, off int, compression compressionMap, compress bool) (int, error) {
-	n, err := r.Data.Pack(msg[off:])
-	if err != nil {
-		return len(msg), err
-	}
-	off += n
-	return off, nil
-}
-
-func (r *PrivateRR) unpack(msg []byte, off int) (int, error) {
-	off1, err := r.Data.Unpack(msg[off:])
-	off += off1
-	return off, err
-}
-
-func (r *PrivateRR) parse(c *zlexer, origin string) *ParseError {
-	var l lex
-	text := make([]string, 0, 2) // could be 0..N elements, median is probably 1
-Fetch:
-	for {
-		// TODO(miek): we could also be returning _QUOTE, this might or might not
-		// be an issue (basically parsing TXT becomes hard)
-		switch l, _ = c.Next(); l.value {
-		case zNewline, zEOF:
-			break Fetch
-		case zString:
-			text = append(text, l.token)
-		}
-	}
-
-	err := r.Data.Parse(text)
-	if err != nil {
-		return &ParseError{wrappedErr: err, lex: l}
-	}
-
-	return nil
-}
-
-func (r *PrivateRR) isDuplicate(r2 RR) bool { return false }
-
-// PrivateHandle registers a private resource record type. It requires
-// string and numeric representation of private RR type and generator function as argument.
-func PrivateHandle(rtypestr string, rtype uint16, generator func() PrivateRdata) {
-	rtypestr = strings.ToUpper(rtypestr)
-
-	TypeToRR[rtype] = func() RR { return &PrivateRR{RR_Header{}, generator(), generator} }
-	TypeToString[rtype] = rtypestr
-	StringToType[rtypestr] = rtype
-}
-
-// PrivateHandleRemove removes definitions required to support private RR type.
-func PrivateHandleRemove(rtype uint16) {
-	rtypestr, ok := TypeToString[rtype]
-	if ok {
-		delete(TypeToRR, rtype)
-		delete(TypeToString, rtype)
-		delete(StringToType, rtypestr)
-	}
-}
diff --git a/vendor/github.com/miekg/dns/reverse.go b/vendor/github.com/miekg/dns/reverse.go
deleted file mode 100644
index 6f5b3ea70d..0000000000
--- a/vendor/github.com/miekg/dns/reverse.go
+++ /dev/null
@@ -1,55 +0,0 @@
-package dns
-
-// StringToType is the reverse of TypeToString, needed for string parsing.
-var StringToType = reverseInt16(TypeToString)
-
-// StringToClass is the reverse of ClassToString, needed for string parsing.
-var StringToClass = reverseInt16(ClassToString)
-
-// StringToOpcode is a map of opcodes to strings.
-var StringToOpcode = reverseInt(OpcodeToString)
-
-// StringToRcode is a map of rcodes to strings.
-var StringToRcode = reverseInt(RcodeToString)
-
-func init() {
-	// Preserve previous NOTIMP typo, see github.com/miekg/dns/issues/733.
-	StringToRcode["NOTIMPL"] = RcodeNotImplemented
-}
-
-// StringToAlgorithm is the reverse of AlgorithmToString.
-var StringToAlgorithm = reverseInt8(AlgorithmToString)
-
-// StringToHash is a map of names to hash IDs.
-var StringToHash = reverseInt8(HashToString)
-
-// StringToCertType is the reverse of CertTypeToString.
-var StringToCertType = reverseInt16(CertTypeToString)
-
-// StringToStatefulType is the reverse of StatefulTypeToString.
-var StringToStatefulType = reverseInt16(StatefulTypeToString)
-
-// Reverse a map
-func reverseInt8(m map[uint8]string) map[string]uint8 {
-	n := make(map[string]uint8, len(m))
-	for u, s := range m {
-		n[s] = u
-	}
-	return n
-}
-
-func reverseInt16(m map[uint16]string) map[string]uint16 {
-	n := make(map[string]uint16, len(m))
-	for u, s := range m {
-		n[s] = u
-	}
-	return n
-}
-
-func reverseInt(m map[int]string) map[string]int {
-	n := make(map[string]int, len(m))
-	for u, s := range m {
-		n[s] = u
-	}
-	return n
-}
diff --git a/vendor/github.com/miekg/dns/sanitize.go b/vendor/github.com/miekg/dns/sanitize.go
deleted file mode 100644
index a638e862e3..0000000000
--- a/vendor/github.com/miekg/dns/sanitize.go
+++ /dev/null
@@ -1,86 +0,0 @@
-package dns
-
-// Dedup removes identical RRs from rrs. It preserves the original ordering.
-// The lowest TTL of any duplicates is used in the remaining one. Dedup modifies
-// rrs.
-// m is used to store the RRs temporary. If it is nil a new map will be allocated.
-func Dedup(rrs []RR, m map[string]RR) []RR {
-
-	if m == nil {
-		m = make(map[string]RR)
-	}
-	// Save the keys, so we don't have to call normalizedString twice.
-	keys := make([]*string, 0, len(rrs))
-
-	for _, r := range rrs {
-		key := normalizedString(r)
-		keys = append(keys, &key)
-		if mr, ok := m[key]; ok {
-			// Shortest TTL wins.
-			rh, mrh := r.Header(), mr.Header()
-			if mrh.Ttl > rh.Ttl {
-				mrh.Ttl = rh.Ttl
-			}
-			continue
-		}
-
-		m[key] = r
-	}
-	// If the length of the result map equals the amount of RRs we got,
-	// it means they were all different. We can then just return the original rrset.
-	if len(m) == len(rrs) {
-		return rrs
-	}
-
-	j := 0
-	for i, r := range rrs {
-		// If keys[i] lives in the map, we should copy and remove it.
-		if _, ok := m[*keys[i]]; ok {
-			delete(m, *keys[i])
-			rrs[j] = r
-			j++
-		}
-
-		if len(m) == 0 {
-			break
-		}
-	}
-
-	return rrs[:j]
-}
-
-// normalizedString returns a normalized string from r. The TTL
-// is removed and the domain name is lowercased. We go from this:
-// DomainName<TAB>TTL<TAB>CLASS<TAB>TYPE<TAB>RDATA to:
-// lowercasename<TAB>CLASS<TAB>TYPE...
-func normalizedString(r RR) string {
-	// A string Go DNS makes has: domainname<TAB>TTL<TAB>...
-	b := []byte(r.String())
-
-	// find the first non-escaped tab, then another, so we capture where the TTL lives.
-	esc := false
-	ttlStart, ttlEnd := 0, 0
-	for i := 0; i < len(b) && ttlEnd == 0; i++ {
-		switch {
-		case b[i] == '\\':
-			esc = !esc
-		case b[i] == '\t' && !esc:
-			if ttlStart == 0 {
-				ttlStart = i
-				continue
-			}
-			if ttlEnd == 0 {
-				ttlEnd = i
-			}
-		case b[i] >= 'A' && b[i] <= 'Z' && !esc:
-			b[i] += 32
-		default:
-			esc = false
-		}
-	}
-
-	// remove TTL.
-	copy(b[ttlStart:], b[ttlEnd:])
-	cut := ttlEnd - ttlStart
-	return string(b[:len(b)-cut])
-}
diff --git a/vendor/github.com/miekg/dns/scan.go b/vendor/github.com/miekg/dns/scan.go
deleted file mode 100644
index f7c6525dd0..0000000000
--- a/vendor/github.com/miekg/dns/scan.go
+++ /dev/null
@@ -1,1418 +0,0 @@
-package dns
-
-import (
-	"bufio"
-	"fmt"
-	"io"
-	"io/fs"
-	"math"
-	"os"
-	"path"
-	"path/filepath"
-	"strconv"
-	"strings"
-)
-
-const maxTok = 512 // Token buffer start size, and growth size amount.
-
-// The maximum depth of $INCLUDE directives supported by the
-// ZoneParser API.
-const maxIncludeDepth = 7
-
-// Tokenize a RFC 1035 zone file. The tokenizer will normalize it:
-// * Add ownernames if they are left blank;
-// * Suppress sequences of spaces;
-// * Make each RR fit on one line (_NEWLINE is send as last)
-// * Handle comments: ;
-// * Handle braces - anywhere.
-const (
-	// Zonefile
-	zEOF = iota
-	zString
-	zBlank
-	zQuote
-	zNewline
-	zRrtpe
-	zOwner
-	zClass
-	zDirOrigin   // $ORIGIN
-	zDirTTL      // $TTL
-	zDirInclude  // $INCLUDE
-	zDirGenerate // $GENERATE
-
-	// Privatekey file
-	zValue
-	zKey
-
-	zExpectOwnerDir      // Ownername
-	zExpectOwnerBl       // Whitespace after the ownername
-	zExpectAny           // Expect rrtype, ttl or class
-	zExpectAnyNoClass    // Expect rrtype or ttl
-	zExpectAnyNoClassBl  // The whitespace after _EXPECT_ANY_NOCLASS
-	zExpectAnyNoTTL      // Expect rrtype or class
-	zExpectAnyNoTTLBl    // Whitespace after _EXPECT_ANY_NOTTL
-	zExpectRrtype        // Expect rrtype
-	zExpectRrtypeBl      // Whitespace BEFORE rrtype
-	zExpectRdata         // The first element of the rdata
-	zExpectDirTTLBl      // Space after directive $TTL
-	zExpectDirTTL        // Directive $TTL
-	zExpectDirOriginBl   // Space after directive $ORIGIN
-	zExpectDirOrigin     // Directive $ORIGIN
-	zExpectDirIncludeBl  // Space after directive $INCLUDE
-	zExpectDirInclude    // Directive $INCLUDE
-	zExpectDirGenerate   // Directive $GENERATE
-	zExpectDirGenerateBl // Space after directive $GENERATE
-)
-
-// ParseError is a parsing error. It contains the parse error and the location in the io.Reader
-// where the error occurred.
-type ParseError struct {
-	file       string
-	err        string
-	wrappedErr error
-	lex        lex
-}
-
-func (e *ParseError) Error() (s string) {
-	if e.file != "" {
-		s = e.file + ": "
-	}
-	if e.err == "" && e.wrappedErr != nil {
-		e.err = e.wrappedErr.Error()
-	}
-	s += "dns: " + e.err + ": " + strconv.QuoteToASCII(e.lex.token) + " at line: " +
-		strconv.Itoa(e.lex.line) + ":" + strconv.Itoa(e.lex.column)
-	return
-}
-
-func (e *ParseError) Unwrap() error { return e.wrappedErr }
-
-type lex struct {
-	token  string // text of the token
-	err    bool   // when true, token text has lexer error
-	value  uint8  // value: zString, _BLANK, etc.
-	torc   uint16 // type or class as parsed in the lexer, we only need to look this up in the grammar
-	line   int    // line in the file
-	column int    // column in the file
-}
-
-// ttlState describes the state necessary to fill in an omitted RR TTL
-type ttlState struct {
-	ttl           uint32 // ttl is the current default TTL
-	isByDirective bool   // isByDirective indicates whether ttl was set by a $TTL directive
-}
-
-// NewRR reads a string s and returns the first RR.
-// If s contains no records, NewRR will return nil with no error.
-//
-// The class defaults to IN, TTL defaults to 3600, and
-// origin for resolving relative domain names defaults to the DNS root (.).
-// Full zone file syntax is supported, including directives like $TTL and $ORIGIN.
-// All fields of the returned RR are set from the read data, except RR.Header().Rdlength which is set to 0.
-// Is you need a partial resource record with no rdata - for instance - for dynamic updates, see the [ANY]
-// documentation.
-func NewRR(s string) (RR, error) {
-	if len(s) > 0 && s[len(s)-1] != '\n' { // We need a closing newline
-		return ReadRR(strings.NewReader(s+"\n"), "")
-	}
-	return ReadRR(strings.NewReader(s), "")
-}
-
-// ReadRR reads the RR contained in r.
-//
-// The string file is used in error reporting and to resolve relative
-// $INCLUDE directives.
-//
-// See NewRR for more documentation.
-func ReadRR(r io.Reader, file string) (RR, error) {
-	zp := NewZoneParser(r, ".", file)
-	zp.SetDefaultTTL(defaultTtl)
-	zp.SetIncludeAllowed(true)
-	rr, _ := zp.Next()
-	return rr, zp.Err()
-}
-
-// ZoneParser is a parser for an RFC 1035 style zonefile.
-//
-// Each parsed RR in the zone is returned sequentially from Next. An
-// optional comment can be retrieved with Comment.
-//
-// The directives $INCLUDE, $ORIGIN, $TTL and $GENERATE are all
-// supported. Although $INCLUDE is disabled by default.
-// Note that $GENERATE's range support up to a maximum of 65535 steps.
-//
-// Basic usage pattern when reading from a string (z) containing the
-// zone data:
-//
-//	zp := NewZoneParser(strings.NewReader(z), "", "")
-//
-//	for rr, ok := zp.Next(); ok; rr, ok = zp.Next() {
-//		// Do something with rr
-//	}
-//
-//	if err := zp.Err(); err != nil {
-//		// log.Println(err)
-//	}
-//
-// Comments specified after an RR (and on the same line!) are
-// returned too:
-//
-//	foo. IN A 10.0.0.1 ; this is a comment
-//
-// The text "; this is comment" is returned from Comment. Comments inside
-// the RR are returned concatenated along with the RR. Comments on a line
-// by themselves are discarded.
-//
-// Callers should not assume all returned data in an Resource Record is
-// syntactically correct, e.g. illegal base64 in RRSIGs will be returned as-is.
-type ZoneParser struct {
-	c *zlexer
-
-	parseErr *ParseError
-
-	origin string
-	file   string
-
-	defttl *ttlState
-
-	h RR_Header
-
-	// sub is used to parse $INCLUDE files and $GENERATE directives.
-	// Next, by calling subNext, forwards the resulting RRs from this
-	// sub parser to the calling code.
-	sub  *ZoneParser
-	r    io.Reader
-	fsys fs.FS
-
-	includeDepth uint8
-
-	includeAllowed     bool
-	generateDisallowed bool
-}
-
-// NewZoneParser returns an RFC 1035 style zonefile parser that reads
-// from r.
-//
-// The string file is used in error reporting and to resolve relative
-// $INCLUDE directives. The string origin is used as the initial
-// origin, as if the file would start with an $ORIGIN directive.
-func NewZoneParser(r io.Reader, origin, file string) *ZoneParser {
-	var pe *ParseError
-	if origin != "" {
-		origin = Fqdn(origin)
-		if _, ok := IsDomainName(origin); !ok {
-			pe = &ParseError{file: file, err: "bad initial origin name"}
-		}
-	}
-
-	return &ZoneParser{
-		c: newZLexer(r),
-
-		parseErr: pe,
-
-		origin: origin,
-		file:   file,
-	}
-}
-
-// SetDefaultTTL sets the parsers default TTL to ttl.
-func (zp *ZoneParser) SetDefaultTTL(ttl uint32) {
-	zp.defttl = &ttlState{ttl, false}
-}
-
-// SetIncludeAllowed controls whether $INCLUDE directives are
-// allowed. $INCLUDE directives are not supported by default.
-//
-// The $INCLUDE directive will open and read from a user controlled
-// file on the system. Even if the file is not a valid zonefile, the
-// contents of the file may be revealed in error messages, such as:
-//
-//	/etc/passwd: dns: not a TTL: "root:x:0:0:root:/root:/bin/bash" at line: 1:31
-//	/etc/shadow: dns: not a TTL: "root:$6$<redacted>::0:99999:7:::" at line: 1:125
-func (zp *ZoneParser) SetIncludeAllowed(v bool) {
-	zp.includeAllowed = v
-}
-
-// SetIncludeFS provides an [fs.FS] to use when looking for the target of
-// $INCLUDE directives.  ($INCLUDE must still be enabled separately by calling
-// [ZoneParser.SetIncludeAllowed].)  If fsys is nil, [os.Open] will be used.
-//
-// When fsys is an on-disk FS, the ability of $INCLUDE to reach files from
-// outside its root directory depends upon the FS implementation.  For
-// instance, [os.DirFS] will refuse to open paths like "../../etc/passwd",
-// however it will still follow links which may point anywhere on the system.
-//
-// FS paths are slash-separated on all systems, even Windows.  $INCLUDE paths
-// containing other characters such as backslash and colon may be accepted as
-// valid, but those characters will never be interpreted by an FS
-// implementation as path element separators.  See [fs.ValidPath] for more
-// details.
-func (zp *ZoneParser) SetIncludeFS(fsys fs.FS) {
-	zp.fsys = fsys
-}
-
-// Err returns the first non-EOF error that was encountered by the
-// ZoneParser.
-func (zp *ZoneParser) Err() error {
-	if zp.parseErr != nil {
-		return zp.parseErr
-	}
-
-	if zp.sub != nil {
-		if err := zp.sub.Err(); err != nil {
-			return err
-		}
-	}
-
-	return zp.c.Err()
-}
-
-func (zp *ZoneParser) setParseError(err string, l lex) (RR, bool) {
-	zp.parseErr = &ParseError{file: zp.file, err: err, lex: l}
-	return nil, false
-}
-
-// Comment returns an optional text comment that occurred alongside
-// the RR.
-func (zp *ZoneParser) Comment() string {
-	if zp.parseErr != nil {
-		return ""
-	}
-
-	if zp.sub != nil {
-		return zp.sub.Comment()
-	}
-
-	return zp.c.Comment()
-}
-
-func (zp *ZoneParser) subNext() (RR, bool) {
-	if rr, ok := zp.sub.Next(); ok {
-		return rr, true
-	}
-
-	if zp.sub.r != nil {
-		if c, ok := zp.sub.r.(io.Closer); ok {
-			c.Close()
-		}
-		zp.sub.r = nil
-	}
-
-	if zp.sub.Err() != nil {
-		// We have errors to surface.
-		return nil, false
-	}
-
-	zp.sub = nil
-	return zp.Next()
-}
-
-// Next advances the parser to the next RR in the zonefile and
-// returns the (RR, true). It will return (nil, false) when the
-// parsing stops, either by reaching the end of the input or an
-// error. After Next returns (nil, false), the Err method will return
-// any error that occurred during parsing.
-func (zp *ZoneParser) Next() (RR, bool) {
-	if zp.parseErr != nil {
-		return nil, false
-	}
-	if zp.sub != nil {
-		return zp.subNext()
-	}
-
-	// 6 possible beginnings of a line (_ is a space):
-	//
-	//   0. zRRTYPE                              -> all omitted until the rrtype
-	//   1. zOwner _ zRrtype                     -> class/ttl omitted
-	//   2. zOwner _ zString _ zRrtype           -> class omitted
-	//   3. zOwner _ zString _ zClass  _ zRrtype -> ttl/class
-	//   4. zOwner _ zClass  _ zRrtype           -> ttl omitted
-	//   5. zOwner _ zClass  _ zString _ zRrtype -> class/ttl (reversed)
-	//
-	// After detecting these, we know the zRrtype so we can jump to functions
-	// handling the rdata for each of these types.
-
-	st := zExpectOwnerDir // initial state
-	h := &zp.h
-
-	for l, ok := zp.c.Next(); ok; l, ok = zp.c.Next() {
-		// zlexer spotted an error already
-		if l.err {
-			return zp.setParseError(l.token, l)
-		}
-
-		switch st {
-		case zExpectOwnerDir:
-			// We can also expect a directive, like $TTL or $ORIGIN
-			if zp.defttl != nil {
-				h.Ttl = zp.defttl.ttl
-			}
-
-			h.Class = ClassINET
-
-			switch l.value {
-			case zNewline:
-				st = zExpectOwnerDir
-			case zOwner:
-				name, ok := toAbsoluteName(l.token, zp.origin)
-				if !ok {
-					return zp.setParseError("bad owner name", l)
-				}
-
-				h.Name = name
-
-				st = zExpectOwnerBl
-			case zDirTTL:
-				st = zExpectDirTTLBl
-			case zDirOrigin:
-				st = zExpectDirOriginBl
-			case zDirInclude:
-				st = zExpectDirIncludeBl
-			case zDirGenerate:
-				st = zExpectDirGenerateBl
-			case zRrtpe:
-				h.Rrtype = l.torc
-
-				st = zExpectRdata
-			case zClass:
-				h.Class = l.torc
-
-				st = zExpectAnyNoClassBl
-			case zBlank:
-				// Discard, can happen when there is nothing on the
-				// line except the RR type
-			case zString:
-				ttl, ok := stringToTTL(l.token)
-				if !ok {
-					return zp.setParseError("not a TTL", l)
-				}
-
-				h.Ttl = ttl
-
-				if zp.defttl == nil || !zp.defttl.isByDirective {
-					zp.defttl = &ttlState{ttl, false}
-				}
-
-				st = zExpectAnyNoTTLBl
-			default:
-				return zp.setParseError("syntax error at beginning", l)
-			}
-		case zExpectDirIncludeBl:
-			if l.value != zBlank {
-				return zp.setParseError("no blank after $INCLUDE-directive", l)
-			}
-
-			st = zExpectDirInclude
-		case zExpectDirInclude:
-			if l.value != zString {
-				return zp.setParseError("expecting $INCLUDE value, not this...", l)
-			}
-
-			neworigin := zp.origin // There may be optionally a new origin set after the filename, if not use current one
-			switch l, _ := zp.c.Next(); l.value {
-			case zBlank:
-				l, _ := zp.c.Next()
-				if l.value == zString {
-					name, ok := toAbsoluteName(l.token, zp.origin)
-					if !ok {
-						return zp.setParseError("bad origin name", l)
-					}
-
-					neworigin = name
-				}
-			case zNewline, zEOF:
-				// Ok
-			default:
-				return zp.setParseError("garbage after $INCLUDE", l)
-			}
-
-			if !zp.includeAllowed {
-				return zp.setParseError("$INCLUDE directive not allowed", l)
-			}
-			if zp.includeDepth >= maxIncludeDepth {
-				return zp.setParseError("too deeply nested $INCLUDE", l)
-			}
-
-			// Start with the new file
-			includePath := l.token
-			var r1 io.Reader
-			var e1 error
-			if zp.fsys != nil {
-				// fs.FS always uses / as separator, even on Windows, so use
-				// path instead of filepath here:
-				if !path.IsAbs(includePath) {
-					includePath = path.Join(path.Dir(zp.file), includePath)
-				}
-
-				// os.DirFS, and probably others, expect all paths to be
-				// relative, so clean the path and remove leading / if
-				// present:
-				includePath = strings.TrimLeft(path.Clean(includePath), "/")
-
-				r1, e1 = zp.fsys.Open(includePath)
-			} else {
-				if !filepath.IsAbs(includePath) {
-					includePath = filepath.Join(filepath.Dir(zp.file), includePath)
-				}
-				r1, e1 = os.Open(includePath)
-			}
-			if e1 != nil {
-				var as string
-				if includePath != l.token {
-					as = fmt.Sprintf(" as `%s'", includePath)
-				}
-				zp.parseErr = &ParseError{
-					file:       zp.file,
-					wrappedErr: fmt.Errorf("failed to open `%s'%s: %w", l.token, as, e1),
-					lex:        l,
-				}
-				return nil, false
-			}
-
-			zp.sub = NewZoneParser(r1, neworigin, includePath)
-			zp.sub.defttl, zp.sub.includeDepth, zp.sub.r = zp.defttl, zp.includeDepth+1, r1
-			zp.sub.SetIncludeAllowed(true)
-			zp.sub.SetIncludeFS(zp.fsys)
-			return zp.subNext()
-		case zExpectDirTTLBl:
-			if l.value != zBlank {
-				return zp.setParseError("no blank after $TTL-directive", l)
-			}
-
-			st = zExpectDirTTL
-		case zExpectDirTTL:
-			if l.value != zString {
-				return zp.setParseError("expecting $TTL value, not this...", l)
-			}
-
-			if err := slurpRemainder(zp.c); err != nil {
-				return zp.setParseError(err.err, err.lex)
-			}
-
-			ttl, ok := stringToTTL(l.token)
-			if !ok {
-				return zp.setParseError("expecting $TTL value, not this...", l)
-			}
-
-			zp.defttl = &ttlState{ttl, true}
-
-			st = zExpectOwnerDir
-		case zExpectDirOriginBl:
-			if l.value != zBlank {
-				return zp.setParseError("no blank after $ORIGIN-directive", l)
-			}
-
-			st = zExpectDirOrigin
-		case zExpectDirOrigin:
-			if l.value != zString {
-				return zp.setParseError("expecting $ORIGIN value, not this...", l)
-			}
-
-			if err := slurpRemainder(zp.c); err != nil {
-				return zp.setParseError(err.err, err.lex)
-			}
-
-			name, ok := toAbsoluteName(l.token, zp.origin)
-			if !ok {
-				return zp.setParseError("bad origin name", l)
-			}
-
-			zp.origin = name
-
-			st = zExpectOwnerDir
-		case zExpectDirGenerateBl:
-			if l.value != zBlank {
-				return zp.setParseError("no blank after $GENERATE-directive", l)
-			}
-
-			st = zExpectDirGenerate
-		case zExpectDirGenerate:
-			if zp.generateDisallowed {
-				return zp.setParseError("nested $GENERATE directive not allowed", l)
-			}
-			if l.value != zString {
-				return zp.setParseError("expecting $GENERATE value, not this...", l)
-			}
-
-			return zp.generate(l)
-		case zExpectOwnerBl:
-			if l.value != zBlank {
-				return zp.setParseError("no blank after owner", l)
-			}
-
-			st = zExpectAny
-		case zExpectAny:
-			switch l.value {
-			case zRrtpe:
-				if zp.defttl == nil {
-					return zp.setParseError("missing TTL with no previous value", l)
-				}
-
-				h.Rrtype = l.torc
-
-				st = zExpectRdata
-			case zClass:
-				h.Class = l.torc
-
-				st = zExpectAnyNoClassBl
-			case zString:
-				ttl, ok := stringToTTL(l.token)
-				if !ok {
-					return zp.setParseError("not a TTL", l)
-				}
-
-				h.Ttl = ttl
-
-				if zp.defttl == nil || !zp.defttl.isByDirective {
-					zp.defttl = &ttlState{ttl, false}
-				}
-
-				st = zExpectAnyNoTTLBl
-			default:
-				return zp.setParseError("expecting RR type, TTL or class, not this...", l)
-			}
-		case zExpectAnyNoClassBl:
-			if l.value != zBlank {
-				return zp.setParseError("no blank before class", l)
-			}
-
-			st = zExpectAnyNoClass
-		case zExpectAnyNoTTLBl:
-			if l.value != zBlank {
-				return zp.setParseError("no blank before TTL", l)
-			}
-
-			st = zExpectAnyNoTTL
-		case zExpectAnyNoTTL:
-			switch l.value {
-			case zClass:
-				h.Class = l.torc
-
-				st = zExpectRrtypeBl
-			case zRrtpe:
-				h.Rrtype = l.torc
-
-				st = zExpectRdata
-			default:
-				return zp.setParseError("expecting RR type or class, not this...", l)
-			}
-		case zExpectAnyNoClass:
-			switch l.value {
-			case zString:
-				ttl, ok := stringToTTL(l.token)
-				if !ok {
-					return zp.setParseError("not a TTL", l)
-				}
-
-				h.Ttl = ttl
-
-				if zp.defttl == nil || !zp.defttl.isByDirective {
-					zp.defttl = &ttlState{ttl, false}
-				}
-
-				st = zExpectRrtypeBl
-			case zRrtpe:
-				h.Rrtype = l.torc
-
-				st = zExpectRdata
-			default:
-				return zp.setParseError("expecting RR type or TTL, not this...", l)
-			}
-		case zExpectRrtypeBl:
-			if l.value != zBlank {
-				return zp.setParseError("no blank before RR type", l)
-			}
-
-			st = zExpectRrtype
-		case zExpectRrtype:
-			if l.value != zRrtpe {
-				return zp.setParseError("unknown RR type", l)
-			}
-
-			h.Rrtype = l.torc
-
-			st = zExpectRdata
-		case zExpectRdata:
-			var (
-				rr             RR
-				parseAsRFC3597 bool
-			)
-			if newFn, ok := TypeToRR[h.Rrtype]; ok {
-				rr = newFn()
-				*rr.Header() = *h
-
-				// We may be parsing a known RR type using the RFC3597 format.
-				// If so, we handle that here in a generic way.
-				//
-				// This is also true for PrivateRR types which will have the
-				// RFC3597 parsing done for them and the Unpack method called
-				// to populate the RR instead of simply deferring to Parse.
-				if zp.c.Peek().token == "\\#" {
-					parseAsRFC3597 = true
-				}
-			} else {
-				rr = &RFC3597{Hdr: *h}
-			}
-
-			_, isPrivate := rr.(*PrivateRR)
-			if !isPrivate && zp.c.Peek().token == "" {
-				// This is a dynamic update rr.
-
-				if err := slurpRemainder(zp.c); err != nil {
-					return zp.setParseError(err.err, err.lex)
-				}
-
-				return rr, true
-			} else if l.value == zNewline {
-				return zp.setParseError("unexpected newline", l)
-			}
-
-			parseAsRR := rr
-			if parseAsRFC3597 {
-				parseAsRR = &RFC3597{Hdr: *h}
-			}
-
-			if err := parseAsRR.parse(zp.c, zp.origin); err != nil {
-				// err is a concrete *ParseError without the file field set.
-				// The setParseError call below will construct a new
-				// *ParseError with file set to zp.file.
-
-				// err.lex may be nil in which case we substitute our current
-				// lex token.
-				if err.lex == (lex{}) {
-					return zp.setParseError(err.err, l)
-				}
-
-				return zp.setParseError(err.err, err.lex)
-			}
-
-			if parseAsRFC3597 {
-				err := parseAsRR.(*RFC3597).fromRFC3597(rr)
-				if err != nil {
-					return zp.setParseError(err.Error(), l)
-				}
-			}
-
-			return rr, true
-		}
-	}
-
-	// If we get here, we and the h.Rrtype is still zero, we haven't parsed anything, this
-	// is not an error, because an empty zone file is still a zone file.
-	return nil, false
-}
-
-type zlexer struct {
-	br io.ByteReader
-
-	readErr error
-
-	line   int
-	column int
-
-	comBuf  string
-	comment string
-
-	l       lex
-	cachedL *lex
-
-	brace  int
-	quote  bool
-	space  bool
-	commt  bool
-	rrtype bool
-	owner  bool
-
-	nextL bool
-
-	eol bool // end-of-line
-}
-
-func newZLexer(r io.Reader) *zlexer {
-	br, ok := r.(io.ByteReader)
-	if !ok {
-		br = bufio.NewReaderSize(r, 1024)
-	}
-
-	return &zlexer{
-		br: br,
-
-		line: 1,
-
-		owner: true,
-	}
-}
-
-func (zl *zlexer) Err() error {
-	if zl.readErr == io.EOF {
-		return nil
-	}
-
-	return zl.readErr
-}
-
-// readByte returns the next byte from the input
-func (zl *zlexer) readByte() (byte, bool) {
-	if zl.readErr != nil {
-		return 0, false
-	}
-
-	c, err := zl.br.ReadByte()
-	if err != nil {
-		zl.readErr = err
-		return 0, false
-	}
-
-	// delay the newline handling until the next token is delivered,
-	// fixes off-by-one errors when reporting a parse error.
-	if zl.eol {
-		zl.line++
-		zl.column = 0
-		zl.eol = false
-	}
-
-	if c == '\n' {
-		zl.eol = true
-	} else {
-		zl.column++
-	}
-
-	return c, true
-}
-
-func (zl *zlexer) Peek() lex {
-	if zl.nextL {
-		return zl.l
-	}
-
-	l, ok := zl.Next()
-	if !ok {
-		return l
-	}
-
-	if zl.nextL {
-		// Cache l. Next returns zl.cachedL then zl.l.
-		zl.cachedL = &l
-	} else {
-		// In this case l == zl.l, so we just tell Next to return zl.l.
-		zl.nextL = true
-	}
-
-	return l
-}
-
-func (zl *zlexer) Next() (lex, bool) {
-	l := &zl.l
-	switch {
-	case zl.cachedL != nil:
-		l, zl.cachedL = zl.cachedL, nil
-		return *l, true
-	case zl.nextL:
-		zl.nextL = false
-		return *l, true
-	case l.err:
-		// Parsing errors should be sticky.
-		return lex{value: zEOF}, false
-	}
-
-	var (
-		str = make([]byte, maxTok) // Hold string text
-		com = make([]byte, maxTok) // Hold comment text
-
-		stri int // Offset in str (0 means empty)
-		comi int // Offset in com (0 means empty)
-
-		escape bool
-	)
-
-	if zl.comBuf != "" {
-		comi = copy(com[:], zl.comBuf)
-		zl.comBuf = ""
-	}
-
-	zl.comment = ""
-
-	for x, ok := zl.readByte(); ok; x, ok = zl.readByte() {
-		l.line, l.column = zl.line, zl.column
-
-		if stri >= len(str) {
-			// if buffer length is insufficient, increase it.
-			str = append(str[:], make([]byte, maxTok)...)
-		}
-		if comi >= len(com) {
-			// if buffer length is insufficient, increase it.
-			com = append(com[:], make([]byte, maxTok)...)
-		}
-
-		switch x {
-		case ' ', '\t':
-			if escape || zl.quote {
-				// Inside quotes or escaped this is legal.
-				str[stri] = x
-				stri++
-
-				escape = false
-				break
-			}
-
-			if zl.commt {
-				com[comi] = x
-				comi++
-				break
-			}
-
-			var retL lex
-			if stri == 0 {
-				// Space directly in the beginning, handled in the grammar
-			} else if zl.owner {
-				// If we have a string and it's the first, make it an owner
-				l.value = zOwner
-				l.token = string(str[:stri])
-
-				// escape $... start with a \ not a $, so this will work
-				switch strings.ToUpper(l.token) {
-				case "$TTL":
-					l.value = zDirTTL
-				case "$ORIGIN":
-					l.value = zDirOrigin
-				case "$INCLUDE":
-					l.value = zDirInclude
-				case "$GENERATE":
-					l.value = zDirGenerate
-				}
-
-				retL = *l
-			} else {
-				l.value = zString
-				l.token = string(str[:stri])
-
-				if !zl.rrtype {
-					tokenUpper := strings.ToUpper(l.token)
-					if t, ok := StringToType[tokenUpper]; ok {
-						l.value = zRrtpe
-						l.torc = t
-
-						zl.rrtype = true
-					} else if strings.HasPrefix(tokenUpper, "TYPE") {
-						t, ok := typeToInt(l.token)
-						if !ok {
-							l.token = "unknown RR type"
-							l.err = true
-							return *l, true
-						}
-
-						l.value = zRrtpe
-						l.torc = t
-
-						zl.rrtype = true
-					}
-
-					if t, ok := StringToClass[tokenUpper]; ok {
-						l.value = zClass
-						l.torc = t
-					} else if strings.HasPrefix(tokenUpper, "CLASS") {
-						t, ok := classToInt(l.token)
-						if !ok {
-							l.token = "unknown class"
-							l.err = true
-							return *l, true
-						}
-
-						l.value = zClass
-						l.torc = t
-					}
-				}
-
-				retL = *l
-			}
-
-			zl.owner = false
-
-			if !zl.space {
-				zl.space = true
-
-				l.value = zBlank
-				l.token = " "
-
-				if retL == (lex{}) {
-					return *l, true
-				}
-
-				zl.nextL = true
-			}
-
-			if retL != (lex{}) {
-				return retL, true
-			}
-		case ';':
-			if escape || zl.quote {
-				// Inside quotes or escaped this is legal.
-				str[stri] = x
-				stri++
-
-				escape = false
-				break
-			}
-
-			zl.commt = true
-			zl.comBuf = ""
-
-			if comi > 1 {
-				// A newline was previously seen inside a comment that
-				// was inside braces and we delayed adding it until now.
-				com[comi] = ' ' // convert newline to space
-				comi++
-				if comi >= len(com) {
-					l.token = "comment length insufficient for parsing"
-					l.err = true
-					return *l, true
-				}
-			}
-
-			com[comi] = ';'
-			comi++
-
-			if stri > 0 {
-				zl.comBuf = string(com[:comi])
-
-				l.value = zString
-				l.token = string(str[:stri])
-				return *l, true
-			}
-		case '\r':
-			escape = false
-
-			if zl.quote {
-				str[stri] = x
-				stri++
-			}
-
-			// discard if outside of quotes
-		case '\n':
-			escape = false
-
-			// Escaped newline
-			if zl.quote {
-				str[stri] = x
-				stri++
-				break
-			}
-
-			if zl.commt {
-				// Reset a comment
-				zl.commt = false
-				zl.rrtype = false
-
-				// If not in a brace this ends the comment AND the RR
-				if zl.brace == 0 {
-					zl.owner = true
-
-					l.value = zNewline
-					l.token = "\n"
-					zl.comment = string(com[:comi])
-					return *l, true
-				}
-
-				zl.comBuf = string(com[:comi])
-				break
-			}
-
-			if zl.brace == 0 {
-				// If there is previous text, we should output it here
-				var retL lex
-				if stri != 0 {
-					l.value = zString
-					l.token = string(str[:stri])
-
-					if !zl.rrtype {
-						tokenUpper := strings.ToUpper(l.token)
-						if t, ok := StringToType[tokenUpper]; ok {
-							zl.rrtype = true
-
-							l.value = zRrtpe
-							l.torc = t
-						}
-					}
-
-					retL = *l
-				}
-
-				l.value = zNewline
-				l.token = "\n"
-
-				zl.comment = zl.comBuf
-				zl.comBuf = ""
-				zl.rrtype = false
-				zl.owner = true
-
-				if retL != (lex{}) {
-					zl.nextL = true
-					return retL, true
-				}
-
-				return *l, true
-			}
-		case '\\':
-			// comments do not get escaped chars, everything is copied
-			if zl.commt {
-				com[comi] = x
-				comi++
-				break
-			}
-
-			// something already escaped must be in string
-			if escape {
-				str[stri] = x
-				stri++
-
-				escape = false
-				break
-			}
-
-			// something escaped outside of string gets added to string
-			str[stri] = x
-			stri++
-
-			escape = true
-		case '"':
-			if zl.commt {
-				com[comi] = x
-				comi++
-				break
-			}
-
-			if escape {
-				str[stri] = x
-				stri++
-
-				escape = false
-				break
-			}
-
-			zl.space = false
-
-			// send previous gathered text and the quote
-			var retL lex
-			if stri != 0 {
-				l.value = zString
-				l.token = string(str[:stri])
-
-				retL = *l
-			}
-
-			// send quote itself as separate token
-			l.value = zQuote
-			l.token = "\""
-
-			zl.quote = !zl.quote
-
-			if retL != (lex{}) {
-				zl.nextL = true
-				return retL, true
-			}
-
-			return *l, true
-		case '(', ')':
-			if zl.commt {
-				com[comi] = x
-				comi++
-				break
-			}
-
-			if escape || zl.quote {
-				// Inside quotes or escaped this is legal.
-				str[stri] = x
-				stri++
-
-				escape = false
-				break
-			}
-
-			switch x {
-			case ')':
-				zl.brace--
-
-				if zl.brace < 0 {
-					l.token = "extra closing brace"
-					l.err = true
-					return *l, true
-				}
-			case '(':
-				zl.brace++
-			}
-		default:
-			escape = false
-
-			if zl.commt {
-				com[comi] = x
-				comi++
-				break
-			}
-
-			str[stri] = x
-			stri++
-
-			zl.space = false
-		}
-	}
-
-	if zl.readErr != nil && zl.readErr != io.EOF {
-		// Don't return any tokens after a read error occurs.
-		return lex{value: zEOF}, false
-	}
-
-	var retL lex
-	if stri > 0 {
-		// Send remainder of str
-		l.value = zString
-		l.token = string(str[:stri])
-		retL = *l
-
-		if comi <= 0 {
-			return retL, true
-		}
-	}
-
-	if comi > 0 {
-		// Send remainder of com
-		l.value = zNewline
-		l.token = "\n"
-		zl.comment = string(com[:comi])
-
-		if retL != (lex{}) {
-			zl.nextL = true
-			return retL, true
-		}
-
-		return *l, true
-	}
-
-	if zl.brace != 0 {
-		l.token = "unbalanced brace"
-		l.err = true
-		return *l, true
-	}
-
-	return lex{value: zEOF}, false
-}
-
-func (zl *zlexer) Comment() string {
-	if zl.l.err {
-		return ""
-	}
-
-	return zl.comment
-}
-
-// Extract the class number from CLASSxx
-func classToInt(token string) (uint16, bool) {
-	offset := 5
-	if len(token) < offset+1 {
-		return 0, false
-	}
-	class, err := strconv.ParseUint(token[offset:], 10, 16)
-	if err != nil {
-		return 0, false
-	}
-	return uint16(class), true
-}
-
-// Extract the rr number from TYPExxx
-func typeToInt(token string) (uint16, bool) {
-	offset := 4
-	if len(token) < offset+1 {
-		return 0, false
-	}
-	typ, err := strconv.ParseUint(token[offset:], 10, 16)
-	if err != nil {
-		return 0, false
-	}
-	return uint16(typ), true
-}
-
-// stringToTTL parses things like 2w, 2m, etc, and returns the time in seconds.
-func stringToTTL(token string) (uint32, bool) {
-	var s, i uint
-	for _, c := range token {
-		switch c {
-		case 's', 'S':
-			s += i
-			i = 0
-		case 'm', 'M':
-			s += i * 60
-			i = 0
-		case 'h', 'H':
-			s += i * 60 * 60
-			i = 0
-		case 'd', 'D':
-			s += i * 60 * 60 * 24
-			i = 0
-		case 'w', 'W':
-			s += i * 60 * 60 * 24 * 7
-			i = 0
-		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
-			i *= 10
-			i += uint(c) - '0'
-		default:
-			return 0, false
-		}
-	}
-	if s+i > math.MaxUint32 {
-		return 0, false
-	}
-	return uint32(s + i), true
-}
-
-// Parse LOC records' <digits>[.<digits>][mM] into a
-// mantissa exponent format. Token should contain the entire
-// string (i.e. no spaces allowed)
-func stringToCm(token string) (e, m uint8, ok bool) {
-	if token[len(token)-1] == 'M' || token[len(token)-1] == 'm' {
-		token = token[0 : len(token)-1]
-	}
-
-	var (
-		meters, cmeters, val int
-		err                  error
-	)
-	mStr, cmStr, hasCM := strings.Cut(token, ".")
-	if hasCM {
-		// There's no point in having more than 2 digits in this part, and would rather make the implementation complicated ('123' should be treated as '12').
-		// So we simply reject it.
-		// We also make sure the first character is a digit to reject '+-' signs.
-		cmeters, err = strconv.Atoi(cmStr)
-		if err != nil || len(cmStr) > 2 || cmStr[0] < '0' || cmStr[0] > '9' {
-			return
-		}
-		if len(cmStr) == 1 {
-			// 'nn.1' must be treated as 'nn-meters and 10cm, not 1cm.
-			cmeters *= 10
-		}
-	}
-	// This slightly ugly condition will allow omitting the 'meter' part, like .01 (meaning 0.01m = 1cm).
-	if !hasCM || mStr != "" {
-		meters, err = strconv.Atoi(mStr)
-		// RFC1876 states the max value is 90000000.00.  The latter two conditions enforce it.
-		if err != nil || mStr[0] < '0' || mStr[0] > '9' || meters > 90000000 || (meters == 90000000 && cmeters != 0) {
-			return
-		}
-	}
-
-	if meters > 0 {
-		e = 2
-		val = meters
-	} else {
-		e = 0
-		val = cmeters
-	}
-	for val >= 10 {
-		e++
-		val /= 10
-	}
-	return e, uint8(val), true
-}
-
-func toAbsoluteName(name, origin string) (absolute string, ok bool) {
-	// check for an explicit origin reference
-	if name == "@" {
-		// require a nonempty origin
-		if origin == "" {
-			return "", false
-		}
-		return origin, true
-	}
-
-	// this can happen when we have a comment after a RR that has a domain, '...   MX 20 ; this is wrong'.
-	// technically a newline can be in a domain name, but this is clearly an error and the newline only shows
-	// because of the scanning and the comment.
-	if name == "\n" {
-		return "", false
-	}
-
-	// require a valid domain name
-	_, ok = IsDomainName(name)
-	if !ok || name == "" {
-		return "", false
-	}
-
-	// check if name is already absolute
-	if IsFqdn(name) {
-		return name, true
-	}
-
-	// require a nonempty origin
-	if origin == "" {
-		return "", false
-	}
-	return appendOrigin(name, origin), true
-}
-
-func appendOrigin(name, origin string) string {
-	if origin == "." {
-		return name + origin
-	}
-	return name + "." + origin
-}
-
-// LOC record helper function
-func locCheckNorth(token string, latitude uint32) (uint32, bool) {
-	if latitude > 90*1000*60*60 {
-		return latitude, false
-	}
-	switch token {
-	case "n", "N":
-		return LOC_EQUATOR + latitude, true
-	case "s", "S":
-		return LOC_EQUATOR - latitude, true
-	}
-	return latitude, false
-}
-
-// LOC record helper function
-func locCheckEast(token string, longitude uint32) (uint32, bool) {
-	if longitude > 180*1000*60*60 {
-		return longitude, false
-	}
-	switch token {
-	case "e", "E":
-		return LOC_EQUATOR + longitude, true
-	case "w", "W":
-		return LOC_EQUATOR - longitude, true
-	}
-	return longitude, false
-}
-
-// "Eat" the rest of the "line"
-func slurpRemainder(c *zlexer) *ParseError {
-	l, _ := c.Next()
-	switch l.value {
-	case zBlank:
-		l, _ = c.Next()
-		if l.value != zNewline && l.value != zEOF {
-			return &ParseError{err: "garbage after rdata", lex: l}
-		}
-	case zNewline:
-	case zEOF:
-	default:
-		return &ParseError{err: "garbage after rdata", lex: l}
-	}
-	return nil
-}
-
-// Parse a 64 bit-like ipv6 address: "0014:4fff:ff20:ee64"
-// Used for NID and L64 record.
-func stringToNodeID(l lex) (uint64, *ParseError) {
-	if len(l.token) < 19 {
-		return 0, &ParseError{file: l.token, err: "bad NID/L64 NodeID/Locator64", lex: l}
-	}
-	// There must be three colons at fixes positions, if not its a parse error
-	if l.token[4] != ':' && l.token[9] != ':' && l.token[14] != ':' {
-		return 0, &ParseError{file: l.token, err: "bad NID/L64 NodeID/Locator64", lex: l}
-	}
-	s := l.token[0:4] + l.token[5:9] + l.token[10:14] + l.token[15:19]
-	u, err := strconv.ParseUint(s, 16, 64)
-	if err != nil {
-		return 0, &ParseError{file: l.token, err: "bad NID/L64 NodeID/Locator64", lex: l}
-	}
-	return u, nil
-}
diff --git a/vendor/github.com/miekg/dns/scan_rr.go b/vendor/github.com/miekg/dns/scan_rr.go
deleted file mode 100644
index ac885f66fe..0000000000
--- a/vendor/github.com/miekg/dns/scan_rr.go
+++ /dev/null
@@ -1,1967 +0,0 @@
-package dns
-
-import (
-	"encoding/base64"
-	"errors"
-	"fmt"
-	"net"
-	"strconv"
-	"strings"
-)
-
-// A remainder of the rdata with embedded spaces, return the parsed string (sans the spaces)
-// or an error
-func endingToString(c *zlexer, errstr string) (string, *ParseError) {
-	var s strings.Builder
-	l, _ := c.Next() // zString
-	for l.value != zNewline && l.value != zEOF {
-		if l.err {
-			return s.String(), &ParseError{err: errstr, lex: l}
-		}
-		switch l.value {
-		case zString:
-			s.WriteString(l.token)
-		case zBlank: // Ok
-		default:
-			return "", &ParseError{err: errstr, lex: l}
-		}
-		l, _ = c.Next()
-	}
-
-	return s.String(), nil
-}
-
-// A remainder of the rdata with embedded spaces, split on unquoted whitespace
-// and return the parsed string slice or an error
-func endingToTxtSlice(c *zlexer, errstr string) ([]string, *ParseError) {
-	// Get the remaining data until we see a zNewline
-	l, _ := c.Next()
-	if l.err {
-		return nil, &ParseError{err: errstr, lex: l}
-	}
-
-	// Build the slice
-	s := make([]string, 0)
-	quote := false
-	empty := false
-	for l.value != zNewline && l.value != zEOF {
-		if l.err {
-			return nil, &ParseError{err: errstr, lex: l}
-		}
-		switch l.value {
-		case zString:
-			empty = false
-			// split up tokens that are larger than 255 into 255-chunks
-			sx := []string{}
-			p := 0
-			for {
-				i, ok := escapedStringOffset(l.token[p:], 255)
-				if !ok {
-					return nil, &ParseError{err: errstr, lex: l}
-				}
-				if i != -1 && p+i != len(l.token) {
-					sx = append(sx, l.token[p:p+i])
-				} else {
-					sx = append(sx, l.token[p:])
-					break
-
-				}
-				p += i
-			}
-			s = append(s, sx...)
-		case zBlank:
-			if quote {
-				// zBlank can only be seen in between txt parts.
-				return nil, &ParseError{err: errstr, lex: l}
-			}
-		case zQuote:
-			if empty && quote {
-				s = append(s, "")
-			}
-			quote = !quote
-			empty = true
-		default:
-			return nil, &ParseError{err: errstr, lex: l}
-		}
-		l, _ = c.Next()
-	}
-
-	if quote {
-		return nil, &ParseError{err: errstr, lex: l}
-	}
-
-	return s, nil
-}
-
-func (rr *A) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	rr.A = net.ParseIP(l.token)
-	// IPv4 addresses cannot include ":".
-	// We do this rather than use net.IP's To4() because
-	// To4() treats IPv4-mapped IPv6 addresses as being
-	// IPv4.
-	isIPv4 := !strings.Contains(l.token, ":")
-	if rr.A == nil || !isIPv4 || l.err {
-		return &ParseError{err: "bad A A", lex: l}
-	}
-	return slurpRemainder(c)
-}
-
-func (rr *AAAA) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	rr.AAAA = net.ParseIP(l.token)
-	// IPv6 addresses must include ":", and IPv4
-	// addresses cannot include ":".
-	isIPv6 := strings.Contains(l.token, ":")
-	if rr.AAAA == nil || !isIPv6 || l.err {
-		return &ParseError{err: "bad AAAA AAAA", lex: l}
-	}
-	return slurpRemainder(c)
-}
-
-func (rr *NS) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	name, nameOk := toAbsoluteName(l.token, o)
-	if l.err || !nameOk {
-		return &ParseError{err: "bad NS Ns", lex: l}
-	}
-	rr.Ns = name
-	return slurpRemainder(c)
-}
-
-func (rr *PTR) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	name, nameOk := toAbsoluteName(l.token, o)
-	if l.err || !nameOk {
-		return &ParseError{err: "bad PTR Ptr", lex: l}
-	}
-	rr.Ptr = name
-	return slurpRemainder(c)
-}
-
-func (rr *NSAPPTR) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	name, nameOk := toAbsoluteName(l.token, o)
-	if l.err || !nameOk {
-		return &ParseError{err: "bad NSAP-PTR Ptr", lex: l}
-	}
-	rr.Ptr = name
-	return slurpRemainder(c)
-}
-
-func (rr *RP) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	mbox, mboxOk := toAbsoluteName(l.token, o)
-	if l.err || !mboxOk {
-		return &ParseError{err: "bad RP Mbox", lex: l}
-	}
-	rr.Mbox = mbox
-
-	c.Next() // zBlank
-	l, _ = c.Next()
-	rr.Txt = l.token
-
-	txt, txtOk := toAbsoluteName(l.token, o)
-	if l.err || !txtOk {
-		return &ParseError{err: "bad RP Txt", lex: l}
-	}
-	rr.Txt = txt
-
-	return slurpRemainder(c)
-}
-
-func (rr *MR) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	name, nameOk := toAbsoluteName(l.token, o)
-	if l.err || !nameOk {
-		return &ParseError{err: "bad MR Mr", lex: l}
-	}
-	rr.Mr = name
-	return slurpRemainder(c)
-}
-
-func (rr *MB) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	name, nameOk := toAbsoluteName(l.token, o)
-	if l.err || !nameOk {
-		return &ParseError{err: "bad MB Mb", lex: l}
-	}
-	rr.Mb = name
-	return slurpRemainder(c)
-}
-
-func (rr *MG) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	name, nameOk := toAbsoluteName(l.token, o)
-	if l.err || !nameOk {
-		return &ParseError{err: "bad MG Mg", lex: l}
-	}
-	rr.Mg = name
-	return slurpRemainder(c)
-}
-
-func (rr *HINFO) parse(c *zlexer, o string) *ParseError {
-	chunks, e := endingToTxtSlice(c, "bad HINFO Fields")
-	if e != nil {
-		return e
-	}
-
-	if ln := len(chunks); ln == 0 {
-		return nil
-	} else if ln == 1 {
-		// Can we split it?
-		if out := strings.Fields(chunks[0]); len(out) > 1 {
-			chunks = out
-		} else {
-			chunks = append(chunks, "")
-		}
-	}
-
-	rr.Cpu = chunks[0]
-	rr.Os = strings.Join(chunks[1:], " ")
-	return nil
-}
-
-// according to RFC 1183 the parsing is identical to HINFO, so just use that code.
-func (rr *ISDN) parse(c *zlexer, o string) *ParseError {
-	chunks, e := endingToTxtSlice(c, "bad ISDN Fields")
-	if e != nil {
-		return e
-	}
-
-	if ln := len(chunks); ln == 0 {
-		return nil
-	} else if ln == 1 {
-		// Can we split it?
-		if out := strings.Fields(chunks[0]); len(out) > 1 {
-			chunks = out
-		} else {
-			chunks = append(chunks, "")
-		}
-	}
-
-	rr.Address = chunks[0]
-	rr.SubAddress = strings.Join(chunks[1:], " ")
-
-	return nil
-}
-
-func (rr *MINFO) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	rmail, rmailOk := toAbsoluteName(l.token, o)
-	if l.err || !rmailOk {
-		return &ParseError{err: "bad MINFO Rmail", lex: l}
-	}
-	rr.Rmail = rmail
-
-	c.Next() // zBlank
-	l, _ = c.Next()
-	rr.Email = l.token
-
-	email, emailOk := toAbsoluteName(l.token, o)
-	if l.err || !emailOk {
-		return &ParseError{err: "bad MINFO Email", lex: l}
-	}
-	rr.Email = email
-
-	return slurpRemainder(c)
-}
-
-func (rr *MF) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	name, nameOk := toAbsoluteName(l.token, o)
-	if l.err || !nameOk {
-		return &ParseError{err: "bad MF Mf", lex: l}
-	}
-	rr.Mf = name
-	return slurpRemainder(c)
-}
-
-func (rr *MD) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	name, nameOk := toAbsoluteName(l.token, o)
-	if l.err || !nameOk {
-		return &ParseError{err: "bad MD Md", lex: l}
-	}
-	rr.Md = name
-	return slurpRemainder(c)
-}
-
-func (rr *MX) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 16)
-	if e != nil || l.err {
-		return &ParseError{err: "bad MX Pref", lex: l}
-	}
-	rr.Preference = uint16(i)
-
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	rr.Mx = l.token
-
-	name, nameOk := toAbsoluteName(l.token, o)
-	if l.err || !nameOk {
-		return &ParseError{err: "bad MX Mx", lex: l}
-	}
-	rr.Mx = name
-
-	return slurpRemainder(c)
-}
-
-func (rr *RT) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 16)
-	if e != nil {
-		return &ParseError{err: "bad RT Preference", lex: l}
-	}
-	rr.Preference = uint16(i)
-
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	rr.Host = l.token
-
-	name, nameOk := toAbsoluteName(l.token, o)
-	if l.err || !nameOk {
-		return &ParseError{err: "bad RT Host", lex: l}
-	}
-	rr.Host = name
-
-	return slurpRemainder(c)
-}
-
-func (rr *AFSDB) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 16)
-	if e != nil || l.err {
-		return &ParseError{err: "bad AFSDB Subtype", lex: l}
-	}
-	rr.Subtype = uint16(i)
-
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	rr.Hostname = l.token
-
-	name, nameOk := toAbsoluteName(l.token, o)
-	if l.err || !nameOk {
-		return &ParseError{err: "bad AFSDB Hostname", lex: l}
-	}
-	rr.Hostname = name
-	return slurpRemainder(c)
-}
-
-func (rr *X25) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	if l.err {
-		return &ParseError{err: "bad X25 PSDNAddress", lex: l}
-	}
-	rr.PSDNAddress = l.token
-	return slurpRemainder(c)
-}
-
-func (rr *KX) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 16)
-	if e != nil || l.err {
-		return &ParseError{err: "bad KX Pref", lex: l}
-	}
-	rr.Preference = uint16(i)
-
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	rr.Exchanger = l.token
-
-	name, nameOk := toAbsoluteName(l.token, o)
-	if l.err || !nameOk {
-		return &ParseError{err: "bad KX Exchanger", lex: l}
-	}
-	rr.Exchanger = name
-	return slurpRemainder(c)
-}
-
-func (rr *CNAME) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	name, nameOk := toAbsoluteName(l.token, o)
-	if l.err || !nameOk {
-		return &ParseError{err: "bad CNAME Target", lex: l}
-	}
-	rr.Target = name
-	return slurpRemainder(c)
-}
-
-func (rr *DNAME) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	name, nameOk := toAbsoluteName(l.token, o)
-	if l.err || !nameOk {
-		return &ParseError{err: "bad DNAME Target", lex: l}
-	}
-	rr.Target = name
-	return slurpRemainder(c)
-}
-
-func (rr *SOA) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	ns, nsOk := toAbsoluteName(l.token, o)
-	if l.err || !nsOk {
-		return &ParseError{err: "bad SOA Ns", lex: l}
-	}
-	rr.Ns = ns
-
-	c.Next() // zBlank
-	l, _ = c.Next()
-	rr.Mbox = l.token
-
-	mbox, mboxOk := toAbsoluteName(l.token, o)
-	if l.err || !mboxOk {
-		return &ParseError{err: "bad SOA Mbox", lex: l}
-	}
-	rr.Mbox = mbox
-
-	c.Next() // zBlank
-
-	var (
-		v  uint32
-		ok bool
-	)
-	for i := 0; i < 5; i++ {
-		l, _ = c.Next()
-		if l.err {
-			return &ParseError{err: "bad SOA zone parameter", lex: l}
-		}
-		if j, err := strconv.ParseUint(l.token, 10, 32); err != nil {
-			if i == 0 {
-				// Serial must be a number
-				return &ParseError{err: "bad SOA zone parameter", lex: l}
-			}
-			// We allow other fields to be unitful duration strings
-			if v, ok = stringToTTL(l.token); !ok {
-				return &ParseError{err: "bad SOA zone parameter", lex: l}
-
-			}
-		} else {
-			v = uint32(j)
-		}
-		switch i {
-		case 0:
-			rr.Serial = v
-			c.Next() // zBlank
-		case 1:
-			rr.Refresh = v
-			c.Next() // zBlank
-		case 2:
-			rr.Retry = v
-			c.Next() // zBlank
-		case 3:
-			rr.Expire = v
-			c.Next() // zBlank
-		case 4:
-			rr.Minttl = v
-		}
-	}
-	return slurpRemainder(c)
-}
-
-func (rr *SRV) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 16)
-	if e != nil || l.err {
-		return &ParseError{err: "bad SRV Priority", lex: l}
-	}
-	rr.Priority = uint16(i)
-
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	i, e1 := strconv.ParseUint(l.token, 10, 16)
-	if e1 != nil || l.err {
-		return &ParseError{err: "bad SRV Weight", lex: l}
-	}
-	rr.Weight = uint16(i)
-
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	i, e2 := strconv.ParseUint(l.token, 10, 16)
-	if e2 != nil || l.err {
-		return &ParseError{err: "bad SRV Port", lex: l}
-	}
-	rr.Port = uint16(i)
-
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	rr.Target = l.token
-
-	name, nameOk := toAbsoluteName(l.token, o)
-	if l.err || !nameOk {
-		return &ParseError{err: "bad SRV Target", lex: l}
-	}
-	rr.Target = name
-	return slurpRemainder(c)
-}
-
-func (rr *NAPTR) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 16)
-	if e != nil || l.err {
-		return &ParseError{err: "bad NAPTR Order", lex: l}
-	}
-	rr.Order = uint16(i)
-
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	i, e1 := strconv.ParseUint(l.token, 10, 16)
-	if e1 != nil || l.err {
-		return &ParseError{err: "bad NAPTR Preference", lex: l}
-	}
-	rr.Preference = uint16(i)
-
-	// Flags
-	c.Next()        // zBlank
-	l, _ = c.Next() // _QUOTE
-	if l.value != zQuote {
-		return &ParseError{err: "bad NAPTR Flags", lex: l}
-	}
-	l, _ = c.Next() // Either String or Quote
-	if l.value == zString {
-		rr.Flags = l.token
-		l, _ = c.Next() // _QUOTE
-		if l.value != zQuote {
-			return &ParseError{err: "bad NAPTR Flags", lex: l}
-		}
-	} else if l.value == zQuote {
-		rr.Flags = ""
-	} else {
-		return &ParseError{err: "bad NAPTR Flags", lex: l}
-	}
-
-	// Service
-	c.Next()        // zBlank
-	l, _ = c.Next() // _QUOTE
-	if l.value != zQuote {
-		return &ParseError{err: "bad NAPTR Service", lex: l}
-	}
-	l, _ = c.Next() // Either String or Quote
-	if l.value == zString {
-		rr.Service = l.token
-		l, _ = c.Next() // _QUOTE
-		if l.value != zQuote {
-			return &ParseError{err: "bad NAPTR Service", lex: l}
-		}
-	} else if l.value == zQuote {
-		rr.Service = ""
-	} else {
-		return &ParseError{err: "bad NAPTR Service", lex: l}
-	}
-
-	// Regexp
-	c.Next()        // zBlank
-	l, _ = c.Next() // _QUOTE
-	if l.value != zQuote {
-		return &ParseError{err: "bad NAPTR Regexp", lex: l}
-	}
-	l, _ = c.Next() // Either String or Quote
-	if l.value == zString {
-		rr.Regexp = l.token
-		l, _ = c.Next() // _QUOTE
-		if l.value != zQuote {
-			return &ParseError{err: "bad NAPTR Regexp", lex: l}
-		}
-	} else if l.value == zQuote {
-		rr.Regexp = ""
-	} else {
-		return &ParseError{err: "bad NAPTR Regexp", lex: l}
-	}
-
-	// After quote no space??
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	rr.Replacement = l.token
-
-	name, nameOk := toAbsoluteName(l.token, o)
-	if l.err || !nameOk {
-		return &ParseError{err: "bad NAPTR Replacement", lex: l}
-	}
-	rr.Replacement = name
-	return slurpRemainder(c)
-}
-
-func (rr *TALINK) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	previousName, previousNameOk := toAbsoluteName(l.token, o)
-	if l.err || !previousNameOk {
-		return &ParseError{err: "bad TALINK PreviousName", lex: l}
-	}
-	rr.PreviousName = previousName
-
-	c.Next() // zBlank
-	l, _ = c.Next()
-	rr.NextName = l.token
-
-	nextName, nextNameOk := toAbsoluteName(l.token, o)
-	if l.err || !nextNameOk {
-		return &ParseError{err: "bad TALINK NextName", lex: l}
-	}
-	rr.NextName = nextName
-
-	return slurpRemainder(c)
-}
-
-func (rr *LOC) parse(c *zlexer, o string) *ParseError {
-	// Non zero defaults for LOC record, see RFC 1876, Section 3.
-	rr.Size = 0x12     // 1e2 cm (1m)
-	rr.HorizPre = 0x16 // 1e6 cm (10000m)
-	rr.VertPre = 0x13  // 1e3 cm (10m)
-	ok := false
-
-	// North
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 32)
-	if e != nil || l.err || i > 90 {
-		return &ParseError{err: "bad LOC Latitude", lex: l}
-	}
-	rr.Latitude = 1000 * 60 * 60 * uint32(i)
-
-	c.Next() // zBlank
-	// Either number, 'N' or 'S'
-	l, _ = c.Next()
-	if rr.Latitude, ok = locCheckNorth(l.token, rr.Latitude); ok {
-		goto East
-	}
-	if i, err := strconv.ParseUint(l.token, 10, 32); err != nil || l.err || i > 59 {
-		return &ParseError{err: "bad LOC Latitude minutes", lex: l}
-	} else {
-		rr.Latitude += 1000 * 60 * uint32(i)
-	}
-
-	c.Next() // zBlank
-	l, _ = c.Next()
-	if i, err := strconv.ParseFloat(l.token, 64); err != nil || l.err || i < 0 || i >= 60 {
-		return &ParseError{err: "bad LOC Latitude seconds", lex: l}
-	} else {
-		rr.Latitude += uint32(1000 * i)
-	}
-	c.Next() // zBlank
-	// Either number, 'N' or 'S'
-	l, _ = c.Next()
-	if rr.Latitude, ok = locCheckNorth(l.token, rr.Latitude); ok {
-		goto East
-	}
-	// If still alive, flag an error
-	return &ParseError{err: "bad LOC Latitude North/South", lex: l}
-
-East:
-	// East
-	c.Next() // zBlank
-	l, _ = c.Next()
-	if i, err := strconv.ParseUint(l.token, 10, 32); err != nil || l.err || i > 180 {
-		return &ParseError{err: "bad LOC Longitude", lex: l}
-	} else {
-		rr.Longitude = 1000 * 60 * 60 * uint32(i)
-	}
-	c.Next() // zBlank
-	// Either number, 'E' or 'W'
-	l, _ = c.Next()
-	if rr.Longitude, ok = locCheckEast(l.token, rr.Longitude); ok {
-		goto Altitude
-	}
-	if i, err := strconv.ParseUint(l.token, 10, 32); err != nil || l.err || i > 59 {
-		return &ParseError{err: "bad LOC Longitude minutes", lex: l}
-	} else {
-		rr.Longitude += 1000 * 60 * uint32(i)
-	}
-	c.Next() // zBlank
-	l, _ = c.Next()
-	if i, err := strconv.ParseFloat(l.token, 64); err != nil || l.err || i < 0 || i >= 60 {
-		return &ParseError{err: "bad LOC Longitude seconds", lex: l}
-	} else {
-		rr.Longitude += uint32(1000 * i)
-	}
-	c.Next() // zBlank
-	// Either number, 'E' or 'W'
-	l, _ = c.Next()
-	if rr.Longitude, ok = locCheckEast(l.token, rr.Longitude); ok {
-		goto Altitude
-	}
-	// If still alive, flag an error
-	return &ParseError{err: "bad LOC Longitude East/West", lex: l}
-
-Altitude:
-	c.Next() // zBlank
-	l, _ = c.Next()
-	if l.token == "" || l.err {
-		return &ParseError{err: "bad LOC Altitude", lex: l}
-	}
-	if l.token[len(l.token)-1] == 'M' || l.token[len(l.token)-1] == 'm' {
-		l.token = l.token[0 : len(l.token)-1]
-	}
-	if i, err := strconv.ParseFloat(l.token, 64); err != nil {
-		return &ParseError{err: "bad LOC Altitude", lex: l}
-	} else {
-		rr.Altitude = uint32(i*100.0 + 10000000.0 + 0.5)
-	}
-
-	// And now optionally the other values
-	l, _ = c.Next()
-	count := 0
-	for l.value != zNewline && l.value != zEOF {
-		switch l.value {
-		case zString:
-			switch count {
-			case 0: // Size
-				exp, m, ok := stringToCm(l.token)
-				if !ok {
-					return &ParseError{err: "bad LOC Size", lex: l}
-				}
-				rr.Size = exp&0x0f | m<<4&0xf0
-			case 1: // HorizPre
-				exp, m, ok := stringToCm(l.token)
-				if !ok {
-					return &ParseError{err: "bad LOC HorizPre", lex: l}
-				}
-				rr.HorizPre = exp&0x0f | m<<4&0xf0
-			case 2: // VertPre
-				exp, m, ok := stringToCm(l.token)
-				if !ok {
-					return &ParseError{err: "bad LOC VertPre", lex: l}
-				}
-				rr.VertPre = exp&0x0f | m<<4&0xf0
-			}
-			count++
-		case zBlank:
-			// Ok
-		default:
-			return &ParseError{err: "bad LOC Size, HorizPre or VertPre", lex: l}
-		}
-		l, _ = c.Next()
-	}
-	return nil
-}
-
-func (rr *HIP) parse(c *zlexer, o string) *ParseError {
-	// HitLength is not represented
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 8)
-	if e != nil || l.err {
-		return &ParseError{err: "bad HIP PublicKeyAlgorithm", lex: l}
-	}
-	rr.PublicKeyAlgorithm = uint8(i)
-
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	if l.token == "" || l.err {
-		return &ParseError{err: "bad HIP Hit", lex: l}
-	}
-	rr.Hit = l.token // This can not contain spaces, see RFC 5205 Section 6.
-	rr.HitLength = uint8(len(rr.Hit)) / 2
-
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	if l.token == "" || l.err {
-		return &ParseError{err: "bad HIP PublicKey", lex: l}
-	}
-	rr.PublicKey = l.token // This cannot contain spaces
-	decodedPK, decodedPKerr := base64.StdEncoding.DecodeString(rr.PublicKey)
-	if decodedPKerr != nil {
-		return &ParseError{err: "bad HIP PublicKey", lex: l}
-	}
-	rr.PublicKeyLength = uint16(len(decodedPK))
-
-	// RendezvousServers (if any)
-	l, _ = c.Next()
-	var xs []string
-	for l.value != zNewline && l.value != zEOF {
-		switch l.value {
-		case zString:
-			name, nameOk := toAbsoluteName(l.token, o)
-			if l.err || !nameOk {
-				return &ParseError{err: "bad HIP RendezvousServers", lex: l}
-			}
-			xs = append(xs, name)
-		case zBlank:
-			// Ok
-		default:
-			return &ParseError{err: "bad HIP RendezvousServers", lex: l}
-		}
-		l, _ = c.Next()
-	}
-
-	rr.RendezvousServers = xs
-	return nil
-}
-
-func (rr *CERT) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	if v, ok := StringToCertType[l.token]; ok {
-		rr.Type = v
-	} else if i, err := strconv.ParseUint(l.token, 10, 16); err != nil {
-		return &ParseError{err: "bad CERT Type", lex: l}
-	} else {
-		rr.Type = uint16(i)
-	}
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	i, e := strconv.ParseUint(l.token, 10, 16)
-	if e != nil || l.err {
-		return &ParseError{err: "bad CERT KeyTag", lex: l}
-	}
-	rr.KeyTag = uint16(i)
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	if v, ok := StringToAlgorithm[l.token]; ok {
-		rr.Algorithm = v
-	} else if i, err := strconv.ParseUint(l.token, 10, 8); err != nil {
-		return &ParseError{err: "bad CERT Algorithm", lex: l}
-	} else {
-		rr.Algorithm = uint8(i)
-	}
-	s, e1 := endingToString(c, "bad CERT Certificate")
-	if e1 != nil {
-		return e1
-	}
-	rr.Certificate = s
-	return nil
-}
-
-func (rr *OPENPGPKEY) parse(c *zlexer, o string) *ParseError {
-	s, e := endingToString(c, "bad OPENPGPKEY PublicKey")
-	if e != nil {
-		return e
-	}
-	rr.PublicKey = s
-	return nil
-}
-
-func (rr *CSYNC) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	j, e := strconv.ParseUint(l.token, 10, 32)
-	if e != nil {
-		// Serial must be a number
-		return &ParseError{err: "bad CSYNC serial", lex: l}
-	}
-	rr.Serial = uint32(j)
-
-	c.Next() // zBlank
-
-	l, _ = c.Next()
-	j, e1 := strconv.ParseUint(l.token, 10, 16)
-	if e1 != nil {
-		// Serial must be a number
-		return &ParseError{err: "bad CSYNC flags", lex: l}
-	}
-	rr.Flags = uint16(j)
-
-	rr.TypeBitMap = make([]uint16, 0)
-	var (
-		k  uint16
-		ok bool
-	)
-	l, _ = c.Next()
-	for l.value != zNewline && l.value != zEOF {
-		switch l.value {
-		case zBlank:
-			// Ok
-		case zString:
-			tokenUpper := strings.ToUpper(l.token)
-			if k, ok = StringToType[tokenUpper]; !ok {
-				if k, ok = typeToInt(l.token); !ok {
-					return &ParseError{err: "bad CSYNC TypeBitMap", lex: l}
-				}
-			}
-			rr.TypeBitMap = append(rr.TypeBitMap, k)
-		default:
-			return &ParseError{err: "bad CSYNC TypeBitMap", lex: l}
-		}
-		l, _ = c.Next()
-	}
-	return nil
-}
-
-func (rr *ZONEMD) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 32)
-	if e != nil || l.err {
-		return &ParseError{err: "bad ZONEMD Serial", lex: l}
-	}
-	rr.Serial = uint32(i)
-
-	c.Next() // zBlank
-	l, _ = c.Next()
-	i, e1 := strconv.ParseUint(l.token, 10, 8)
-	if e1 != nil || l.err {
-		return &ParseError{err: "bad ZONEMD Scheme", lex: l}
-	}
-	rr.Scheme = uint8(i)
-
-	c.Next() // zBlank
-	l, _ = c.Next()
-	i, err := strconv.ParseUint(l.token, 10, 8)
-	if err != nil || l.err {
-		return &ParseError{err: "bad ZONEMD Hash Algorithm", lex: l}
-	}
-	rr.Hash = uint8(i)
-
-	s, e2 := endingToString(c, "bad ZONEMD Digest")
-	if e2 != nil {
-		return e2
-	}
-	rr.Digest = s
-	return nil
-}
-
-func (rr *SIG) parse(c *zlexer, o string) *ParseError { return rr.RRSIG.parse(c, o) }
-
-func (rr *RRSIG) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	tokenUpper := strings.ToUpper(l.token)
-	if t, ok := StringToType[tokenUpper]; !ok {
-		if strings.HasPrefix(tokenUpper, "TYPE") {
-			t, ok = typeToInt(l.token)
-			if !ok {
-				return &ParseError{err: "bad RRSIG Typecovered", lex: l}
-			}
-			rr.TypeCovered = t
-		} else {
-			return &ParseError{err: "bad RRSIG Typecovered", lex: l}
-		}
-	} else {
-		rr.TypeCovered = t
-	}
-
-	c.Next() // zBlank
-	l, _ = c.Next()
-	if l.err {
-		return &ParseError{err: "bad RRSIG Algorithm", lex: l}
-	}
-	i, e := strconv.ParseUint(l.token, 10, 8)
-	rr.Algorithm = uint8(i) // if 0 we'll check the mnemonic in the if
-	if e != nil {
-		v, ok := StringToAlgorithm[l.token]
-		if !ok {
-			return &ParseError{err: "bad RRSIG Algorithm", lex: l}
-		}
-		rr.Algorithm = v
-	}
-
-	c.Next() // zBlank
-	l, _ = c.Next()
-	i, e1 := strconv.ParseUint(l.token, 10, 8)
-	if e1 != nil || l.err {
-		return &ParseError{err: "bad RRSIG Labels", lex: l}
-	}
-	rr.Labels = uint8(i)
-
-	c.Next() // zBlank
-	l, _ = c.Next()
-	i, e2 := strconv.ParseUint(l.token, 10, 32)
-	if e2 != nil || l.err {
-		return &ParseError{err: "bad RRSIG OrigTtl", lex: l}
-	}
-	rr.OrigTtl = uint32(i)
-
-	c.Next() // zBlank
-	l, _ = c.Next()
-	if i, err := StringToTime(l.token); err != nil {
-		// Try to see if all numeric and use it as epoch
-		if i, err := strconv.ParseUint(l.token, 10, 32); err == nil {
-			rr.Expiration = uint32(i)
-		} else {
-			return &ParseError{err: "bad RRSIG Expiration", lex: l}
-		}
-	} else {
-		rr.Expiration = i
-	}
-
-	c.Next() // zBlank
-	l, _ = c.Next()
-	if i, err := StringToTime(l.token); err != nil {
-		if i, err := strconv.ParseUint(l.token, 10, 32); err == nil {
-			rr.Inception = uint32(i)
-		} else {
-			return &ParseError{err: "bad RRSIG Inception", lex: l}
-		}
-	} else {
-		rr.Inception = i
-	}
-
-	c.Next() // zBlank
-	l, _ = c.Next()
-	i, e3 := strconv.ParseUint(l.token, 10, 16)
-	if e3 != nil || l.err {
-		return &ParseError{err: "bad RRSIG KeyTag", lex: l}
-	}
-	rr.KeyTag = uint16(i)
-
-	c.Next() // zBlank
-	l, _ = c.Next()
-	rr.SignerName = l.token
-	name, nameOk := toAbsoluteName(l.token, o)
-	if l.err || !nameOk {
-		return &ParseError{err: "bad RRSIG SignerName", lex: l}
-	}
-	rr.SignerName = name
-
-	s, e4 := endingToString(c, "bad RRSIG Signature")
-	if e4 != nil {
-		return e4
-	}
-	rr.Signature = s
-
-	return nil
-}
-
-func (rr *NXT) parse(c *zlexer, o string) *ParseError { return rr.NSEC.parse(c, o) }
-
-func (rr *NSEC) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	name, nameOk := toAbsoluteName(l.token, o)
-	if l.err || !nameOk {
-		return &ParseError{err: "bad NSEC NextDomain", lex: l}
-	}
-	rr.NextDomain = name
-
-	rr.TypeBitMap = make([]uint16, 0)
-	var (
-		k  uint16
-		ok bool
-	)
-	l, _ = c.Next()
-	for l.value != zNewline && l.value != zEOF {
-		switch l.value {
-		case zBlank:
-			// Ok
-		case zString:
-			tokenUpper := strings.ToUpper(l.token)
-			if k, ok = StringToType[tokenUpper]; !ok {
-				if k, ok = typeToInt(l.token); !ok {
-					return &ParseError{err: "bad NSEC TypeBitMap", lex: l}
-				}
-			}
-			rr.TypeBitMap = append(rr.TypeBitMap, k)
-		default:
-			return &ParseError{err: "bad NSEC TypeBitMap", lex: l}
-		}
-		l, _ = c.Next()
-	}
-	return nil
-}
-
-func (rr *NSEC3) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 8)
-	if e != nil || l.err {
-		return &ParseError{err: "bad NSEC3 Hash", lex: l}
-	}
-	rr.Hash = uint8(i)
-	c.Next() // zBlank
-	l, _ = c.Next()
-	i, e1 := strconv.ParseUint(l.token, 10, 8)
-	if e1 != nil || l.err {
-		return &ParseError{err: "bad NSEC3 Flags", lex: l}
-	}
-	rr.Flags = uint8(i)
-	c.Next() // zBlank
-	l, _ = c.Next()
-	i, e2 := strconv.ParseUint(l.token, 10, 16)
-	if e2 != nil || l.err {
-		return &ParseError{err: "bad NSEC3 Iterations", lex: l}
-	}
-	rr.Iterations = uint16(i)
-	c.Next()
-	l, _ = c.Next()
-	if l.token == "" || l.err {
-		return &ParseError{err: "bad NSEC3 Salt", lex: l}
-	}
-	if l.token != "-" {
-		rr.SaltLength = uint8(len(l.token)) / 2
-		rr.Salt = l.token
-	}
-
-	c.Next()
-	l, _ = c.Next()
-	if l.token == "" || l.err {
-		return &ParseError{err: "bad NSEC3 NextDomain", lex: l}
-	}
-	rr.HashLength = 20 // Fix for NSEC3 (sha1 160 bits)
-	rr.NextDomain = l.token
-
-	rr.TypeBitMap = make([]uint16, 0)
-	var (
-		k  uint16
-		ok bool
-	)
-	l, _ = c.Next()
-	for l.value != zNewline && l.value != zEOF {
-		switch l.value {
-		case zBlank:
-			// Ok
-		case zString:
-			tokenUpper := strings.ToUpper(l.token)
-			if k, ok = StringToType[tokenUpper]; !ok {
-				if k, ok = typeToInt(l.token); !ok {
-					return &ParseError{err: "bad NSEC3 TypeBitMap", lex: l}
-				}
-			}
-			rr.TypeBitMap = append(rr.TypeBitMap, k)
-		default:
-			return &ParseError{err: "bad NSEC3 TypeBitMap", lex: l}
-		}
-		l, _ = c.Next()
-	}
-	return nil
-}
-
-func (rr *NSEC3PARAM) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 8)
-	if e != nil || l.err {
-		return &ParseError{err: "bad NSEC3PARAM Hash", lex: l}
-	}
-	rr.Hash = uint8(i)
-	c.Next() // zBlank
-	l, _ = c.Next()
-	i, e1 := strconv.ParseUint(l.token, 10, 8)
-	if e1 != nil || l.err {
-		return &ParseError{err: "bad NSEC3PARAM Flags", lex: l}
-	}
-	rr.Flags = uint8(i)
-	c.Next() // zBlank
-	l, _ = c.Next()
-	i, e2 := strconv.ParseUint(l.token, 10, 16)
-	if e2 != nil || l.err {
-		return &ParseError{err: "bad NSEC3PARAM Iterations", lex: l}
-	}
-	rr.Iterations = uint16(i)
-	c.Next()
-	l, _ = c.Next()
-	if l.token != "-" {
-		rr.SaltLength = uint8(len(l.token) / 2)
-		rr.Salt = l.token
-	}
-	return slurpRemainder(c)
-}
-
-func (rr *EUI48) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	if len(l.token) != 17 || l.err {
-		return &ParseError{err: "bad EUI48 Address", lex: l}
-	}
-	addr := make([]byte, 12)
-	dash := 0
-	for i := 0; i < 10; i += 2 {
-		addr[i] = l.token[i+dash]
-		addr[i+1] = l.token[i+1+dash]
-		dash++
-		if l.token[i+1+dash] != '-' {
-			return &ParseError{err: "bad EUI48 Address", lex: l}
-		}
-	}
-	addr[10] = l.token[15]
-	addr[11] = l.token[16]
-
-	i, e := strconv.ParseUint(string(addr), 16, 48)
-	if e != nil {
-		return &ParseError{err: "bad EUI48 Address", lex: l}
-	}
-	rr.Address = i
-	return slurpRemainder(c)
-}
-
-func (rr *EUI64) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	if len(l.token) != 23 || l.err {
-		return &ParseError{err: "bad EUI64 Address", lex: l}
-	}
-	addr := make([]byte, 16)
-	dash := 0
-	for i := 0; i < 14; i += 2 {
-		addr[i] = l.token[i+dash]
-		addr[i+1] = l.token[i+1+dash]
-		dash++
-		if l.token[i+1+dash] != '-' {
-			return &ParseError{err: "bad EUI64 Address", lex: l}
-		}
-	}
-	addr[14] = l.token[21]
-	addr[15] = l.token[22]
-
-	i, e := strconv.ParseUint(string(addr), 16, 64)
-	if e != nil {
-		return &ParseError{err: "bad EUI68 Address", lex: l}
-	}
-	rr.Address = i
-	return slurpRemainder(c)
-}
-
-func (rr *SSHFP) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 8)
-	if e != nil || l.err {
-		return &ParseError{err: "bad SSHFP Algorithm", lex: l}
-	}
-	rr.Algorithm = uint8(i)
-	c.Next() // zBlank
-	l, _ = c.Next()
-	i, e1 := strconv.ParseUint(l.token, 10, 8)
-	if e1 != nil || l.err {
-		return &ParseError{err: "bad SSHFP Type", lex: l}
-	}
-	rr.Type = uint8(i)
-	c.Next() // zBlank
-	s, e2 := endingToString(c, "bad SSHFP Fingerprint")
-	if e2 != nil {
-		return e2
-	}
-	rr.FingerPrint = s
-	return nil
-}
-
-func (rr *DNSKEY) parseDNSKEY(c *zlexer, o, typ string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 16)
-	if e != nil || l.err {
-		return &ParseError{err: "bad " + typ + " Flags", lex: l}
-	}
-	rr.Flags = uint16(i)
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	i, e1 := strconv.ParseUint(l.token, 10, 8)
-	if e1 != nil || l.err {
-		return &ParseError{err: "bad " + typ + " Protocol", lex: l}
-	}
-	rr.Protocol = uint8(i)
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	i, e2 := strconv.ParseUint(l.token, 10, 8)
-	if e2 != nil || l.err {
-		return &ParseError{err: "bad " + typ + " Algorithm", lex: l}
-	}
-	rr.Algorithm = uint8(i)
-	s, e3 := endingToString(c, "bad "+typ+" PublicKey")
-	if e3 != nil {
-		return e3
-	}
-	rr.PublicKey = s
-	return nil
-}
-
-func (rr *DNSKEY) parse(c *zlexer, o string) *ParseError  { return rr.parseDNSKEY(c, o, "DNSKEY") }
-func (rr *KEY) parse(c *zlexer, o string) *ParseError     { return rr.parseDNSKEY(c, o, "KEY") }
-func (rr *CDNSKEY) parse(c *zlexer, o string) *ParseError { return rr.parseDNSKEY(c, o, "CDNSKEY") }
-func (rr *DS) parse(c *zlexer, o string) *ParseError      { return rr.parseDS(c, o, "DS") }
-func (rr *DLV) parse(c *zlexer, o string) *ParseError     { return rr.parseDS(c, o, "DLV") }
-func (rr *CDS) parse(c *zlexer, o string) *ParseError     { return rr.parseDS(c, o, "CDS") }
-
-func (rr *IPSECKEY) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	num, err := strconv.ParseUint(l.token, 10, 8)
-	if err != nil || l.err {
-		return &ParseError{err: "bad IPSECKEY value", lex: l}
-	}
-	rr.Precedence = uint8(num)
-	c.Next() // zBlank
-
-	l, _ = c.Next()
-	num, err = strconv.ParseUint(l.token, 10, 8)
-	if err != nil || l.err {
-		return &ParseError{err: "bad IPSECKEY value", lex: l}
-	}
-	rr.GatewayType = uint8(num)
-	c.Next() // zBlank
-
-	l, _ = c.Next()
-	num, err = strconv.ParseUint(l.token, 10, 8)
-	if err != nil || l.err {
-		return &ParseError{err: "bad IPSECKEY value", lex: l}
-	}
-	rr.Algorithm = uint8(num)
-	c.Next() // zBlank
-
-	l, _ = c.Next()
-	if l.err {
-		return &ParseError{err: "bad IPSECKEY gateway", lex: l}
-	}
-
-	rr.GatewayAddr, rr.GatewayHost, err = parseAddrHostUnion(l.token, o, rr.GatewayType)
-	if err != nil {
-		return &ParseError{wrappedErr: fmt.Errorf("IPSECKEY %w", err), lex: l}
-	}
-
-	c.Next() // zBlank
-
-	s, pErr := endingToString(c, "bad IPSECKEY PublicKey")
-	if pErr != nil {
-		return pErr
-	}
-	rr.PublicKey = s
-	return slurpRemainder(c)
-}
-
-func (rr *AMTRELAY) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	num, err := strconv.ParseUint(l.token, 10, 8)
-	if err != nil || l.err {
-		return &ParseError{err: "bad AMTRELAY value", lex: l}
-	}
-	rr.Precedence = uint8(num)
-	c.Next() // zBlank
-
-	l, _ = c.Next()
-	if l.err || !(l.token == "0" || l.token == "1") {
-		return &ParseError{err: "bad discovery value", lex: l}
-	}
-	if l.token == "1" {
-		rr.GatewayType = 0x80
-	}
-
-	c.Next() // zBlank
-
-	l, _ = c.Next()
-	num, err = strconv.ParseUint(l.token, 10, 8)
-	if err != nil || l.err {
-		return &ParseError{err: "bad AMTRELAY value", lex: l}
-	}
-	rr.GatewayType |= uint8(num)
-	c.Next() // zBlank
-
-	l, _ = c.Next()
-	if l.err {
-		return &ParseError{err: "bad AMTRELAY gateway", lex: l}
-	}
-
-	rr.GatewayAddr, rr.GatewayHost, err = parseAddrHostUnion(l.token, o, rr.GatewayType&0x7f)
-	if err != nil {
-		return &ParseError{wrappedErr: fmt.Errorf("AMTRELAY %w", err), lex: l}
-	}
-
-	return slurpRemainder(c)
-}
-
-// same constants and parsing between IPSECKEY and AMTRELAY
-func parseAddrHostUnion(token, o string, gatewayType uint8) (addr net.IP, host string, err error) {
-	switch gatewayType {
-	case IPSECGatewayNone:
-		if token != "." {
-			return addr, host, errors.New("gateway type none with gateway set")
-		}
-	case IPSECGatewayIPv4, IPSECGatewayIPv6:
-		addr = net.ParseIP(token)
-		if addr == nil {
-			return addr, host, errors.New("gateway IP invalid")
-		}
-		if (addr.To4() == nil) == (gatewayType == IPSECGatewayIPv4) {
-			return addr, host, errors.New("gateway IP family mismatch")
-		}
-	case IPSECGatewayHost:
-		var ok bool
-		host, ok = toAbsoluteName(token, o)
-		if !ok {
-			return addr, host, errors.New("invalid gateway host")
-		}
-	}
-
-	return addr, host, nil
-}
-
-func (rr *RKEY) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 16)
-	if e != nil || l.err {
-		return &ParseError{err: "bad RKEY Flags", lex: l}
-	}
-	rr.Flags = uint16(i)
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	i, e1 := strconv.ParseUint(l.token, 10, 8)
-	if e1 != nil || l.err {
-		return &ParseError{err: "bad RKEY Protocol", lex: l}
-	}
-	rr.Protocol = uint8(i)
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	i, e2 := strconv.ParseUint(l.token, 10, 8)
-	if e2 != nil || l.err {
-		return &ParseError{err: "bad RKEY Algorithm", lex: l}
-	}
-	rr.Algorithm = uint8(i)
-	s, e3 := endingToString(c, "bad RKEY PublicKey")
-	if e3 != nil {
-		return e3
-	}
-	rr.PublicKey = s
-	return nil
-}
-
-func (rr *EID) parse(c *zlexer, o string) *ParseError {
-	s, e := endingToString(c, "bad EID Endpoint")
-	if e != nil {
-		return e
-	}
-	rr.Endpoint = s
-	return nil
-}
-
-func (rr *NIMLOC) parse(c *zlexer, o string) *ParseError {
-	s, e := endingToString(c, "bad NIMLOC Locator")
-	if e != nil {
-		return e
-	}
-	rr.Locator = s
-	return nil
-}
-
-func (rr *GPOS) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	_, e := strconv.ParseFloat(l.token, 64)
-	if e != nil || l.err {
-		return &ParseError{err: "bad GPOS Longitude", lex: l}
-	}
-	rr.Longitude = l.token
-	c.Next() // zBlank
-	l, _ = c.Next()
-	_, e1 := strconv.ParseFloat(l.token, 64)
-	if e1 != nil || l.err {
-		return &ParseError{err: "bad GPOS Latitude", lex: l}
-	}
-	rr.Latitude = l.token
-	c.Next() // zBlank
-	l, _ = c.Next()
-	_, e2 := strconv.ParseFloat(l.token, 64)
-	if e2 != nil || l.err {
-		return &ParseError{err: "bad GPOS Altitude", lex: l}
-	}
-	rr.Altitude = l.token
-	return slurpRemainder(c)
-}
-
-func (rr *DS) parseDS(c *zlexer, o, typ string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 16)
-	if e != nil || l.err {
-		return &ParseError{err: "bad " + typ + " KeyTag", lex: l}
-	}
-	rr.KeyTag = uint16(i)
-	c.Next() // zBlank
-	l, _ = c.Next()
-	if i, err := strconv.ParseUint(l.token, 10, 8); err != nil {
-		tokenUpper := strings.ToUpper(l.token)
-		i, ok := StringToAlgorithm[tokenUpper]
-		if !ok || l.err {
-			return &ParseError{err: "bad " + typ + " Algorithm", lex: l}
-		}
-		rr.Algorithm = i
-	} else {
-		rr.Algorithm = uint8(i)
-	}
-	c.Next() // zBlank
-	l, _ = c.Next()
-	i, e1 := strconv.ParseUint(l.token, 10, 8)
-	if e1 != nil || l.err {
-		return &ParseError{err: "bad " + typ + " DigestType", lex: l}
-	}
-	rr.DigestType = uint8(i)
-	s, e2 := endingToString(c, "bad "+typ+" Digest")
-	if e2 != nil {
-		return e2
-	}
-	rr.Digest = s
-	return nil
-}
-
-func (rr *TA) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 16)
-	if e != nil || l.err {
-		return &ParseError{err: "bad TA KeyTag", lex: l}
-	}
-	rr.KeyTag = uint16(i)
-	c.Next() // zBlank
-	l, _ = c.Next()
-	if i, err := strconv.ParseUint(l.token, 10, 8); err != nil {
-		tokenUpper := strings.ToUpper(l.token)
-		i, ok := StringToAlgorithm[tokenUpper]
-		if !ok || l.err {
-			return &ParseError{err: "bad TA Algorithm", lex: l}
-		}
-		rr.Algorithm = i
-	} else {
-		rr.Algorithm = uint8(i)
-	}
-	c.Next() // zBlank
-	l, _ = c.Next()
-	i, e1 := strconv.ParseUint(l.token, 10, 8)
-	if e1 != nil || l.err {
-		return &ParseError{err: "bad TA DigestType", lex: l}
-	}
-	rr.DigestType = uint8(i)
-	s, e2 := endingToString(c, "bad TA Digest")
-	if e2 != nil {
-		return e2
-	}
-	rr.Digest = s
-	return nil
-}
-
-func (rr *TLSA) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 8)
-	if e != nil || l.err {
-		return &ParseError{err: "bad TLSA Usage", lex: l}
-	}
-	rr.Usage = uint8(i)
-	c.Next() // zBlank
-	l, _ = c.Next()
-	i, e1 := strconv.ParseUint(l.token, 10, 8)
-	if e1 != nil || l.err {
-		return &ParseError{err: "bad TLSA Selector", lex: l}
-	}
-	rr.Selector = uint8(i)
-	c.Next() // zBlank
-	l, _ = c.Next()
-	i, e2 := strconv.ParseUint(l.token, 10, 8)
-	if e2 != nil || l.err {
-		return &ParseError{err: "bad TLSA MatchingType", lex: l}
-	}
-	rr.MatchingType = uint8(i)
-	// So this needs be e2 (i.e. different than e), because...??t
-	s, e3 := endingToString(c, "bad TLSA Certificate")
-	if e3 != nil {
-		return e3
-	}
-	rr.Certificate = s
-	return nil
-}
-
-func (rr *SMIMEA) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 8)
-	if e != nil || l.err {
-		return &ParseError{err: "bad SMIMEA Usage", lex: l}
-	}
-	rr.Usage = uint8(i)
-	c.Next() // zBlank
-	l, _ = c.Next()
-	i, e1 := strconv.ParseUint(l.token, 10, 8)
-	if e1 != nil || l.err {
-		return &ParseError{err: "bad SMIMEA Selector", lex: l}
-	}
-	rr.Selector = uint8(i)
-	c.Next() // zBlank
-	l, _ = c.Next()
-	i, e2 := strconv.ParseUint(l.token, 10, 8)
-	if e2 != nil || l.err {
-		return &ParseError{err: "bad SMIMEA MatchingType", lex: l}
-	}
-	rr.MatchingType = uint8(i)
-	// So this needs be e2 (i.e. different than e), because...??t
-	s, e3 := endingToString(c, "bad SMIMEA Certificate")
-	if e3 != nil {
-		return e3
-	}
-	rr.Certificate = s
-	return nil
-}
-
-func (rr *RFC3597) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	if l.token != "\\#" {
-		return &ParseError{err: "bad RFC3597 Rdata", lex: l}
-	}
-
-	c.Next() // zBlank
-	l, _ = c.Next()
-	rdlength, e := strconv.ParseUint(l.token, 10, 16)
-	if e != nil || l.err {
-		return &ParseError{err: "bad RFC3597 Rdata ", lex: l}
-	}
-
-	s, e1 := endingToString(c, "bad RFC3597 Rdata")
-	if e1 != nil {
-		return e1
-	}
-	if int(rdlength)*2 != len(s) {
-		return &ParseError{err: "bad RFC3597 Rdata", lex: l}
-	}
-	rr.Rdata = s
-	return nil
-}
-
-func (rr *SPF) parse(c *zlexer, o string) *ParseError {
-	s, e := endingToTxtSlice(c, "bad SPF Txt")
-	if e != nil {
-		return e
-	}
-	rr.Txt = s
-	return nil
-}
-
-func (rr *AVC) parse(c *zlexer, o string) *ParseError {
-	s, e := endingToTxtSlice(c, "bad AVC Txt")
-	if e != nil {
-		return e
-	}
-	rr.Txt = s
-	return nil
-}
-
-func (rr *TXT) parse(c *zlexer, o string) *ParseError {
-	// no zBlank reading here, because all this rdata is TXT
-	s, e := endingToTxtSlice(c, "bad TXT Txt")
-	if e != nil {
-		return e
-	}
-	rr.Txt = s
-	return nil
-}
-
-// identical to setTXT
-func (rr *NINFO) parse(c *zlexer, o string) *ParseError {
-	s, e := endingToTxtSlice(c, "bad NINFO ZSData")
-	if e != nil {
-		return e
-	}
-	rr.ZSData = s
-	return nil
-}
-
-// Uses the same format as TXT
-func (rr *RESINFO) parse(c *zlexer, o string) *ParseError {
-	s, e := endingToTxtSlice(c, "bad RESINFO Resinfo")
-	if e != nil {
-		return e
-	}
-	rr.Txt = s
-	return nil
-}
-
-func (rr *URI) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 16)
-	if e != nil || l.err {
-		return &ParseError{err: "bad URI Priority", lex: l}
-	}
-	rr.Priority = uint16(i)
-	c.Next() // zBlank
-	l, _ = c.Next()
-	i, e1 := strconv.ParseUint(l.token, 10, 16)
-	if e1 != nil || l.err {
-		return &ParseError{err: "bad URI Weight", lex: l}
-	}
-	rr.Weight = uint16(i)
-
-	c.Next() // zBlank
-	s, e2 := endingToTxtSlice(c, "bad URI Target")
-	if e2 != nil {
-		return e2
-	}
-	if len(s) != 1 {
-		return &ParseError{err: "bad URI Target", lex: l}
-	}
-	rr.Target = s[0]
-	return nil
-}
-
-func (rr *DHCID) parse(c *zlexer, o string) *ParseError {
-	// awesome record to parse!
-	s, e := endingToString(c, "bad DHCID Digest")
-	if e != nil {
-		return e
-	}
-	rr.Digest = s
-	return nil
-}
-
-func (rr *NID) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 16)
-	if e != nil || l.err {
-		return &ParseError{err: "bad NID Preference", lex: l}
-	}
-	rr.Preference = uint16(i)
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	u, e1 := stringToNodeID(l)
-	if e1 != nil || l.err {
-		return e1
-	}
-	rr.NodeID = u
-	return slurpRemainder(c)
-}
-
-func (rr *L32) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 16)
-	if e != nil || l.err {
-		return &ParseError{err: "bad L32 Preference", lex: l}
-	}
-	rr.Preference = uint16(i)
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	rr.Locator32 = net.ParseIP(l.token)
-	if rr.Locator32 == nil || l.err {
-		return &ParseError{err: "bad L32 Locator", lex: l}
-	}
-	return slurpRemainder(c)
-}
-
-func (rr *LP) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 16)
-	if e != nil || l.err {
-		return &ParseError{err: "bad LP Preference", lex: l}
-	}
-	rr.Preference = uint16(i)
-
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	rr.Fqdn = l.token
-	name, nameOk := toAbsoluteName(l.token, o)
-	if l.err || !nameOk {
-		return &ParseError{err: "bad LP Fqdn", lex: l}
-	}
-	rr.Fqdn = name
-	return slurpRemainder(c)
-}
-
-func (rr *L64) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 16)
-	if e != nil || l.err {
-		return &ParseError{err: "bad L64 Preference", lex: l}
-	}
-	rr.Preference = uint16(i)
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	u, e1 := stringToNodeID(l)
-	if e1 != nil || l.err {
-		return e1
-	}
-	rr.Locator64 = u
-	return slurpRemainder(c)
-}
-
-func (rr *UID) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 32)
-	if e != nil || l.err {
-		return &ParseError{err: "bad UID Uid", lex: l}
-	}
-	rr.Uid = uint32(i)
-	return slurpRemainder(c)
-}
-
-func (rr *GID) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 32)
-	if e != nil || l.err {
-		return &ParseError{err: "bad GID Gid", lex: l}
-	}
-	rr.Gid = uint32(i)
-	return slurpRemainder(c)
-}
-
-func (rr *UINFO) parse(c *zlexer, o string) *ParseError {
-	s, e := endingToTxtSlice(c, "bad UINFO Uinfo")
-	if e != nil {
-		return e
-	}
-	if ln := len(s); ln == 0 {
-		return nil
-	}
-	rr.Uinfo = s[0] // silently discard anything after the first character-string
-	return nil
-}
-
-func (rr *PX) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 16)
-	if e != nil || l.err {
-		return &ParseError{err: "bad PX Preference", lex: l}
-	}
-	rr.Preference = uint16(i)
-
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	rr.Map822 = l.token
-	map822, map822Ok := toAbsoluteName(l.token, o)
-	if l.err || !map822Ok {
-		return &ParseError{err: "bad PX Map822", lex: l}
-	}
-	rr.Map822 = map822
-
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	rr.Mapx400 = l.token
-	mapx400, mapx400Ok := toAbsoluteName(l.token, o)
-	if l.err || !mapx400Ok {
-		return &ParseError{err: "bad PX Mapx400", lex: l}
-	}
-	rr.Mapx400 = mapx400
-	return slurpRemainder(c)
-}
-
-func (rr *CAA) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 8)
-	if e != nil || l.err {
-		return &ParseError{err: "bad CAA Flag", lex: l}
-	}
-	rr.Flag = uint8(i)
-
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	if l.value != zString {
-		return &ParseError{err: "bad CAA Tag", lex: l}
-	}
-	rr.Tag = l.token
-
-	c.Next() // zBlank
-	s, e1 := endingToTxtSlice(c, "bad CAA Value")
-	if e1 != nil {
-		return e1
-	}
-	if len(s) != 1 {
-		return &ParseError{err: "bad CAA Value", lex: l}
-	}
-	rr.Value = s[0]
-	return nil
-}
-
-func (rr *TKEY) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-
-	// Algorithm
-	if l.value != zString {
-		return &ParseError{err: "bad TKEY algorithm", lex: l}
-	}
-	rr.Algorithm = l.token
-	c.Next() // zBlank
-
-	// Get the key length and key values
-	l, _ = c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 8)
-	if e != nil || l.err {
-		return &ParseError{err: "bad TKEY key length", lex: l}
-	}
-	rr.KeySize = uint16(i)
-	c.Next() // zBlank
-	l, _ = c.Next()
-	if l.value != zString {
-		return &ParseError{err: "bad TKEY key", lex: l}
-	}
-	rr.Key = l.token
-	c.Next() // zBlank
-
-	// Get the otherdata length and string data
-	l, _ = c.Next()
-	i, e1 := strconv.ParseUint(l.token, 10, 8)
-	if e1 != nil || l.err {
-		return &ParseError{err: "bad TKEY otherdata length", lex: l}
-	}
-	rr.OtherLen = uint16(i)
-	c.Next() // zBlank
-	l, _ = c.Next()
-	if l.value != zString {
-		return &ParseError{err: "bad TKEY otherday", lex: l}
-	}
-	rr.OtherData = l.token
-	return nil
-}
-
-func (rr *APL) parse(c *zlexer, o string) *ParseError {
-	var prefixes []APLPrefix
-
-	for {
-		l, _ := c.Next()
-		if l.value == zNewline || l.value == zEOF {
-			break
-		}
-		if l.value == zBlank && prefixes != nil {
-			continue
-		}
-		if l.value != zString {
-			return &ParseError{err: "unexpected APL field", lex: l}
-		}
-
-		// Expected format: [!]afi:address/prefix
-
-		colon := strings.IndexByte(l.token, ':')
-		if colon == -1 {
-			return &ParseError{err: "missing colon in APL field", lex: l}
-		}
-
-		family, cidr := l.token[:colon], l.token[colon+1:]
-
-		var negation bool
-		if family != "" && family[0] == '!' {
-			negation = true
-			family = family[1:]
-		}
-
-		afi, e := strconv.ParseUint(family, 10, 16)
-		if e != nil {
-			return &ParseError{wrappedErr: fmt.Errorf("failed to parse APL family: %w", e), lex: l}
-		}
-		var addrLen int
-		switch afi {
-		case 1:
-			addrLen = net.IPv4len
-		case 2:
-			addrLen = net.IPv6len
-		default:
-			return &ParseError{err: "unrecognized APL family", lex: l}
-		}
-
-		ip, subnet, e1 := net.ParseCIDR(cidr)
-		if e1 != nil {
-			return &ParseError{wrappedErr: fmt.Errorf("failed to parse APL address: %w", e1), lex: l}
-		}
-		if !ip.Equal(subnet.IP) {
-			return &ParseError{err: "extra bits in APL address", lex: l}
-		}
-
-		if len(subnet.IP) != addrLen {
-			return &ParseError{err: "address mismatch with the APL family", lex: l}
-		}
-
-		prefixes = append(prefixes, APLPrefix{
-			Negation: negation,
-			Network:  *subnet,
-		})
-	}
-
-	rr.Prefixes = prefixes
-	return nil
-}
-
-// escapedStringOffset finds the offset within a string (which may contain escape
-// sequences) that corresponds to a certain byte offset. If the input offset is
-// out of bounds, -1 is returned (which is *not* considered an error).
-func escapedStringOffset(s string, desiredByteOffset int) (int, bool) {
-	if desiredByteOffset == 0 {
-		return 0, true
-	}
-
-	currentByteOffset, i := 0, 0
-
-	for i < len(s) {
-		currentByteOffset += 1
-
-		// Skip escape sequences
-		if s[i] != '\\' {
-			// Single plain byte, not an escape sequence.
-			i++
-		} else if isDDD(s[i+1:]) {
-			// Skip backslash and DDD.
-			i += 4
-		} else if len(s[i+1:]) < 1 {
-			// No character following the backslash; that's an error.
-			return 0, false
-		} else {
-			// Skip backslash and following byte.
-			i += 2
-		}
-
-		if currentByteOffset >= desiredByteOffset {
-			return i, true
-		}
-	}
-
-	return -1, true
-}
diff --git a/vendor/github.com/miekg/dns/serve_mux.go b/vendor/github.com/miekg/dns/serve_mux.go
deleted file mode 100644
index e7f36e2218..0000000000
--- a/vendor/github.com/miekg/dns/serve_mux.go
+++ /dev/null
@@ -1,122 +0,0 @@
-package dns
-
-import (
-	"sync"
-)
-
-// ServeMux is an DNS request multiplexer. It matches the zone name of
-// each incoming request against a list of registered patterns add calls
-// the handler for the pattern that most closely matches the zone name.
-//
-// ServeMux is DNSSEC aware, meaning that queries for the DS record are
-// redirected to the parent zone (if that is also registered), otherwise
-// the child gets the query.
-//
-// ServeMux is also safe for concurrent access from multiple goroutines.
-//
-// The zero ServeMux is empty and ready for use.
-type ServeMux struct {
-	z map[string]Handler
-	m sync.RWMutex
-}
-
-// NewServeMux allocates and returns a new ServeMux.
-func NewServeMux() *ServeMux {
-	return new(ServeMux)
-}
-
-// DefaultServeMux is the default ServeMux used by Serve.
-var DefaultServeMux = NewServeMux()
-
-func (mux *ServeMux) match(q string, t uint16) Handler {
-	mux.m.RLock()
-	defer mux.m.RUnlock()
-	if mux.z == nil {
-		return nil
-	}
-
-	q = CanonicalName(q)
-
-	var handler Handler
-	for off, end := 0, false; !end; off, end = NextLabel(q, off) {
-		if h, ok := mux.z[q[off:]]; ok {
-			if t != TypeDS {
-				return h
-			}
-			// Continue for DS to see if we have a parent too, if so delegate to the parent
-			handler = h
-		}
-	}
-
-	// Wildcard match, if we have found nothing try the root zone as a last resort.
-	if h, ok := mux.z["."]; ok {
-		return h
-	}
-
-	return handler
-}
-
-// Handle adds a handler to the ServeMux for pattern.
-func (mux *ServeMux) Handle(pattern string, handler Handler) {
-	if pattern == "" {
-		panic("dns: invalid pattern " + pattern)
-	}
-	mux.m.Lock()
-	if mux.z == nil {
-		mux.z = make(map[string]Handler)
-	}
-	mux.z[CanonicalName(pattern)] = handler
-	mux.m.Unlock()
-}
-
-// HandleFunc adds a handler function to the ServeMux for pattern.
-func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Msg)) {
-	mux.Handle(pattern, HandlerFunc(handler))
-}
-
-// HandleRemove deregisters the handler specific for pattern from the ServeMux.
-func (mux *ServeMux) HandleRemove(pattern string) {
-	if pattern == "" {
-		panic("dns: invalid pattern " + pattern)
-	}
-	mux.m.Lock()
-	delete(mux.z, CanonicalName(pattern))
-	mux.m.Unlock()
-}
-
-// ServeDNS dispatches the request to the handler whose pattern most
-// closely matches the request message.
-//
-// ServeDNS is DNSSEC aware, meaning that queries for the DS record
-// are redirected to the parent zone (if that is also registered),
-// otherwise the child gets the query.
-//
-// If no handler is found, or there is no question, a standard REFUSED
-// message is returned
-func (mux *ServeMux) ServeDNS(w ResponseWriter, req *Msg) {
-	var h Handler
-	if len(req.Question) >= 1 { // allow more than one question
-		h = mux.match(req.Question[0].Name, req.Question[0].Qtype)
-	}
-
-	if h != nil {
-		h.ServeDNS(w, req)
-	} else {
-		handleRefused(w, req)
-	}
-}
-
-// Handle registers the handler with the given pattern
-// in the DefaultServeMux. The documentation for
-// ServeMux explains how patterns are matched.
-func Handle(pattern string, handler Handler) { DefaultServeMux.Handle(pattern, handler) }
-
-// HandleRemove deregisters the handle with the given pattern
-// in the DefaultServeMux.
-func HandleRemove(pattern string) { DefaultServeMux.HandleRemove(pattern) }
-
-// HandleFunc registers the handler function with the given pattern
-// in the DefaultServeMux.
-func HandleFunc(pattern string, handler func(ResponseWriter, *Msg)) {
-	DefaultServeMux.HandleFunc(pattern, handler)
-}
diff --git a/vendor/github.com/miekg/dns/server.go b/vendor/github.com/miekg/dns/server.go
deleted file mode 100644
index 50478b3240..0000000000
--- a/vendor/github.com/miekg/dns/server.go
+++ /dev/null
@@ -1,860 +0,0 @@
-// DNS server implementation.
-
-package dns
-
-import (
-	"context"
-	"crypto/tls"
-	"encoding/binary"
-	"errors"
-	"io"
-	"net"
-	"strings"
-	"sync"
-	"time"
-)
-
-// Default maximum number of TCP queries before we close the socket.
-const maxTCPQueries = 128
-
-// aLongTimeAgo is a non-zero time, far in the past, used for
-// immediate cancellation of network operations.
-var aLongTimeAgo = time.Unix(1, 0)
-
-// Handler is implemented by any value that implements ServeDNS.
-type Handler interface {
-	ServeDNS(w ResponseWriter, r *Msg)
-}
-
-// The HandlerFunc type is an adapter to allow the use of
-// ordinary functions as DNS handlers.  If f is a function
-// with the appropriate signature, HandlerFunc(f) is a
-// Handler object that calls f.
-type HandlerFunc func(ResponseWriter, *Msg)
-
-// ServeDNS calls f(w, r).
-func (f HandlerFunc) ServeDNS(w ResponseWriter, r *Msg) {
-	f(w, r)
-}
-
-// A ResponseWriter interface is used by an DNS handler to
-// construct an DNS response.
-type ResponseWriter interface {
-	// LocalAddr returns the net.Addr of the server
-	LocalAddr() net.Addr
-	// RemoteAddr returns the net.Addr of the client that sent the current request.
-	RemoteAddr() net.Addr
-	// WriteMsg writes a reply back to the client.
-	WriteMsg(*Msg) error
-	// Write writes a raw buffer back to the client.
-	Write([]byte) (int, error)
-	// Close closes the connection.
-	Close() error
-	// TsigStatus returns the status of the Tsig.
-	TsigStatus() error
-	// TsigTimersOnly sets the tsig timers only boolean.
-	TsigTimersOnly(bool)
-	// Hijack lets the caller take over the connection.
-	// After a call to Hijack(), the DNS package will not do anything with the connection.
-	Hijack()
-}
-
-// A ConnectionStater interface is used by a DNS Handler to access TLS connection state
-// when available.
-type ConnectionStater interface {
-	ConnectionState() *tls.ConnectionState
-}
-
-type response struct {
-	closed         bool // connection has been closed
-	hijacked       bool // connection has been hijacked by handler
-	tsigTimersOnly bool
-	tsigStatus     error
-	tsigRequestMAC string
-	tsigProvider   TsigProvider
-	udp            net.PacketConn // i/o connection if UDP was used
-	tcp            net.Conn       // i/o connection if TCP was used
-	udpSession     *SessionUDP    // oob data to get egress interface right
-	pcSession      net.Addr       // address to use when writing to a generic net.PacketConn
-	writer         Writer         // writer to output the raw DNS bits
-}
-
-// handleRefused returns a HandlerFunc that returns REFUSED for every request it gets.
-func handleRefused(w ResponseWriter, r *Msg) {
-	m := new(Msg)
-	m.SetRcode(r, RcodeRefused)
-	w.WriteMsg(m)
-}
-
-// HandleFailed returns a HandlerFunc that returns SERVFAIL for every request it gets.
-// Deprecated: This function is going away.
-func HandleFailed(w ResponseWriter, r *Msg) {
-	m := new(Msg)
-	m.SetRcode(r, RcodeServerFailure)
-	// does not matter if this write fails
-	w.WriteMsg(m)
-}
-
-// ListenAndServe Starts a server on address and network specified Invoke handler
-// for incoming queries.
-func ListenAndServe(addr string, network string, handler Handler) error {
-	server := &Server{Addr: addr, Net: network, Handler: handler}
-	return server.ListenAndServe()
-}
-
-// ListenAndServeTLS acts like http.ListenAndServeTLS, more information in
-// http://golang.org/pkg/net/http/#ListenAndServeTLS
-func ListenAndServeTLS(addr, certFile, keyFile string, handler Handler) error {
-	cert, err := tls.LoadX509KeyPair(certFile, keyFile)
-	if err != nil {
-		return err
-	}
-
-	config := tls.Config{
-		Certificates: []tls.Certificate{cert},
-	}
-
-	server := &Server{
-		Addr:      addr,
-		Net:       "tcp-tls",
-		TLSConfig: &config,
-		Handler:   handler,
-	}
-
-	return server.ListenAndServe()
-}
-
-// ActivateAndServe activates a server with a listener from systemd,
-// l and p should not both be non-nil.
-// If both l and p are not nil only p will be used.
-// Invoke handler for incoming queries.
-func ActivateAndServe(l net.Listener, p net.PacketConn, handler Handler) error {
-	server := &Server{Listener: l, PacketConn: p, Handler: handler}
-	return server.ActivateAndServe()
-}
-
-// Writer writes raw DNS messages; each call to Write should send an entire message.
-type Writer interface {
-	io.Writer
-}
-
-// Reader reads raw DNS messages; each call to ReadTCP or ReadUDP should return an entire message.
-type Reader interface {
-	// ReadTCP reads a raw message from a TCP connection. Implementations may alter
-	// connection properties, for example the read-deadline.
-	ReadTCP(conn net.Conn, timeout time.Duration) ([]byte, error)
-	// ReadUDP reads a raw message from a UDP connection. Implementations may alter
-	// connection properties, for example the read-deadline.
-	ReadUDP(conn *net.UDPConn, timeout time.Duration) ([]byte, *SessionUDP, error)
-}
-
-// PacketConnReader is an optional interface that Readers can implement to support using generic net.PacketConns.
-type PacketConnReader interface {
-	Reader
-
-	// ReadPacketConn reads a raw message from a generic net.PacketConn UDP connection. Implementations may
-	// alter connection properties, for example the read-deadline.
-	ReadPacketConn(conn net.PacketConn, timeout time.Duration) ([]byte, net.Addr, error)
-}
-
-// defaultReader is an adapter for the Server struct that implements the Reader and
-// PacketConnReader interfaces using the readTCP, readUDP and readPacketConn funcs
-// of the embedded Server.
-type defaultReader struct {
-	*Server
-}
-
-var _ PacketConnReader = defaultReader{}
-
-func (dr defaultReader) ReadTCP(conn net.Conn, timeout time.Duration) ([]byte, error) {
-	return dr.readTCP(conn, timeout)
-}
-
-func (dr defaultReader) ReadUDP(conn *net.UDPConn, timeout time.Duration) ([]byte, *SessionUDP, error) {
-	return dr.readUDP(conn, timeout)
-}
-
-func (dr defaultReader) ReadPacketConn(conn net.PacketConn, timeout time.Duration) ([]byte, net.Addr, error) {
-	return dr.readPacketConn(conn, timeout)
-}
-
-// DecorateReader is a decorator hook for extending or supplanting the functionality of a Reader.
-// Implementations should never return a nil Reader.
-// Readers should also implement the optional PacketConnReader interface.
-// PacketConnReader is required to use a generic net.PacketConn.
-type DecorateReader func(Reader) Reader
-
-// DecorateWriter is a decorator hook for extending or supplanting the functionality of a Writer.
-// Implementations should never return a nil Writer.
-type DecorateWriter func(Writer) Writer
-
-// MsgInvalidFunc is a listener hook for observing incoming messages that were discarded
-// because they could not be parsed.
-// Every message that is read by a Reader will eventually be provided to the Handler,
-// rejected (or ignored) by the MsgAcceptFunc, or passed to this function.
-type MsgInvalidFunc func(m []byte, err error)
-
-var DefaultMsgInvalidFunc MsgInvalidFunc = defaultMsgInvalidFunc
-
-func defaultMsgInvalidFunc(m []byte, err error) {}
-
-// A Server defines parameters for running an DNS server.
-type Server struct {
-	// Address to listen on, ":dns" if empty.
-	Addr string
-	// if "tcp" or "tcp-tls" (DNS over TLS) it will invoke a TCP listener, otherwise an UDP one
-	Net string
-	// TCP Listener to use, this is to aid in systemd's socket activation.
-	Listener net.Listener
-	// TLS connection configuration
-	TLSConfig *tls.Config
-	// UDP "Listener" to use, this is to aid in systemd's socket activation.
-	PacketConn net.PacketConn
-	// Handler to invoke, dns.DefaultServeMux if nil.
-	Handler Handler
-	// Default buffer size to use to read incoming UDP messages. If not set
-	// it defaults to MinMsgSize (512 B).
-	UDPSize int
-	// The net.Conn.SetReadTimeout value for new connections, defaults to 2 * time.Second.
-	ReadTimeout time.Duration
-	// The net.Conn.SetWriteTimeout value for new connections, defaults to 2 * time.Second.
-	WriteTimeout time.Duration
-	// TCP idle timeout for multiple queries, if nil, defaults to 8 * time.Second (RFC 5966).
-	IdleTimeout func() time.Duration
-	// An implementation of the TsigProvider interface. If defined it replaces TsigSecret and is used for all TSIG operations.
-	TsigProvider TsigProvider
-	// Secret(s) for Tsig map[<zonename>]<base64 secret>. The zonename must be in canonical form (lowercase, fqdn, see RFC 4034 Section 6.2).
-	TsigSecret map[string]string
-	// If NotifyStartedFunc is set it is called once the server has started listening.
-	NotifyStartedFunc func()
-	// DecorateReader is optional, allows customization of the process that reads raw DNS messages.
-	// The decorated reader must not mutate the data read from the conn.
-	DecorateReader DecorateReader
-	// DecorateWriter is optional, allows customization of the process that writes raw DNS messages.
-	DecorateWriter DecorateWriter
-	// Maximum number of TCP queries before we close the socket. Default is maxTCPQueries (unlimited if -1).
-	MaxTCPQueries int
-	// Whether to set the SO_REUSEPORT socket option, allowing multiple listeners to be bound to a single address.
-	// It is only supported on certain GOOSes and when using ListenAndServe.
-	ReusePort bool
-	// Whether to set the SO_REUSEADDR socket option, allowing multiple listeners to be bound to a single address.
-	// Crucially this allows binding when an existing server is listening on `0.0.0.0` or `::`.
-	// It is only supported on certain GOOSes and when using ListenAndServe.
-	ReuseAddr bool
-	// AcceptMsgFunc will check the incoming message and will reject it early in the process.
-	// By default DefaultMsgAcceptFunc will be used.
-	MsgAcceptFunc MsgAcceptFunc
-	// MsgInvalidFunc is optional, will be called if a message is received but cannot be parsed.
-	MsgInvalidFunc MsgInvalidFunc
-
-	// Shutdown handling
-	lock     sync.RWMutex
-	started  bool
-	shutdown chan struct{}
-	conns    map[net.Conn]struct{}
-
-	// A pool for UDP message buffers.
-	udpPool sync.Pool
-}
-
-func (srv *Server) tsigProvider() TsigProvider {
-	if srv.TsigProvider != nil {
-		return srv.TsigProvider
-	}
-	if srv.TsigSecret != nil {
-		return tsigSecretProvider(srv.TsigSecret)
-	}
-	return nil
-}
-
-func (srv *Server) isStarted() bool {
-	srv.lock.RLock()
-	started := srv.started
-	srv.lock.RUnlock()
-	return started
-}
-
-func makeUDPBuffer(size int) func() interface{} {
-	return func() interface{} {
-		return make([]byte, size)
-	}
-}
-
-func (srv *Server) init() {
-	srv.shutdown = make(chan struct{})
-	srv.conns = make(map[net.Conn]struct{})
-
-	if srv.UDPSize == 0 {
-		srv.UDPSize = MinMsgSize
-	}
-	if srv.MsgAcceptFunc == nil {
-		srv.MsgAcceptFunc = DefaultMsgAcceptFunc
-	}
-	if srv.MsgInvalidFunc == nil {
-		srv.MsgInvalidFunc = DefaultMsgInvalidFunc
-	}
-	if srv.Handler == nil {
-		srv.Handler = DefaultServeMux
-	}
-
-	srv.udpPool.New = makeUDPBuffer(srv.UDPSize)
-}
-
-func unlockOnce(l sync.Locker) func() {
-	var once sync.Once
-	return func() { once.Do(l.Unlock) }
-}
-
-// ListenAndServe starts a nameserver on the configured address in *Server.
-func (srv *Server) ListenAndServe() error {
-	unlock := unlockOnce(&srv.lock)
-	srv.lock.Lock()
-	defer unlock()
-
-	if srv.started {
-		return &Error{err: "server already started"}
-	}
-
-	addr := srv.Addr
-	if addr == "" {
-		addr = ":domain"
-	}
-
-	srv.init()
-
-	switch srv.Net {
-	case "tcp", "tcp4", "tcp6":
-		l, err := listenTCP(srv.Net, addr, srv.ReusePort, srv.ReuseAddr)
-		if err != nil {
-			return err
-		}
-		srv.Listener = l
-		srv.started = true
-		unlock()
-		return srv.serveTCP(l)
-	case "tcp-tls", "tcp4-tls", "tcp6-tls":
-		if srv.TLSConfig == nil || (len(srv.TLSConfig.Certificates) == 0 && srv.TLSConfig.GetCertificate == nil) {
-			return errors.New("neither Certificates nor GetCertificate set in config")
-		}
-		network := strings.TrimSuffix(srv.Net, "-tls")
-		l, err := listenTCP(network, addr, srv.ReusePort, srv.ReuseAddr)
-		if err != nil {
-			return err
-		}
-		l = tls.NewListener(l, srv.TLSConfig)
-		srv.Listener = l
-		srv.started = true
-		unlock()
-		return srv.serveTCP(l)
-	case "udp", "udp4", "udp6":
-		l, err := listenUDP(srv.Net, addr, srv.ReusePort, srv.ReuseAddr)
-		if err != nil {
-			return err
-		}
-		u := l.(*net.UDPConn)
-		if e := setUDPSocketOptions(u); e != nil {
-			u.Close()
-			return e
-		}
-		srv.PacketConn = l
-		srv.started = true
-		unlock()
-		return srv.serveUDP(u)
-	}
-	return &Error{err: "bad network"}
-}
-
-// ActivateAndServe starts a nameserver with the PacketConn or Listener
-// configured in *Server. Its main use is to start a server from systemd.
-func (srv *Server) ActivateAndServe() error {
-	unlock := unlockOnce(&srv.lock)
-	srv.lock.Lock()
-	defer unlock()
-
-	if srv.started {
-		return &Error{err: "server already started"}
-	}
-
-	srv.init()
-
-	if srv.PacketConn != nil {
-		// Check PacketConn interface's type is valid and value
-		// is not nil
-		if t, ok := srv.PacketConn.(*net.UDPConn); ok && t != nil {
-			if e := setUDPSocketOptions(t); e != nil {
-				return e
-			}
-		}
-		srv.started = true
-		unlock()
-		return srv.serveUDP(srv.PacketConn)
-	}
-	if srv.Listener != nil {
-		srv.started = true
-		unlock()
-		return srv.serveTCP(srv.Listener)
-	}
-	return &Error{err: "bad listeners"}
-}
-
-// Shutdown shuts down a server. After a call to Shutdown, ListenAndServe and
-// ActivateAndServe will return.
-func (srv *Server) Shutdown() error {
-	return srv.ShutdownContext(context.Background())
-}
-
-// ShutdownContext shuts down a server. After a call to ShutdownContext,
-// ListenAndServe and ActivateAndServe will return.
-//
-// A context.Context may be passed to limit how long to wait for connections
-// to terminate.
-func (srv *Server) ShutdownContext(ctx context.Context) error {
-	srv.lock.Lock()
-	if !srv.started {
-		srv.lock.Unlock()
-		return &Error{err: "server not started"}
-	}
-
-	srv.started = false
-
-	if srv.PacketConn != nil {
-		srv.PacketConn.SetReadDeadline(aLongTimeAgo) // Unblock reads
-	}
-
-	if srv.Listener != nil {
-		srv.Listener.Close()
-	}
-
-	for rw := range srv.conns {
-		rw.SetReadDeadline(aLongTimeAgo) // Unblock reads
-	}
-
-	srv.lock.Unlock()
-
-	if testShutdownNotify != nil {
-		testShutdownNotify.Broadcast()
-	}
-
-	var ctxErr error
-	select {
-	case <-srv.shutdown:
-	case <-ctx.Done():
-		ctxErr = ctx.Err()
-	}
-
-	if srv.PacketConn != nil {
-		srv.PacketConn.Close()
-	}
-
-	return ctxErr
-}
-
-var testShutdownNotify *sync.Cond
-
-// getReadTimeout is a helper func to use system timeout if server did not intend to change it.
-func (srv *Server) getReadTimeout() time.Duration {
-	if srv.ReadTimeout != 0 {
-		return srv.ReadTimeout
-	}
-	return dnsTimeout
-}
-
-// serveTCP starts a TCP listener for the server.
-func (srv *Server) serveTCP(l net.Listener) error {
-	defer l.Close()
-
-	if srv.NotifyStartedFunc != nil {
-		srv.NotifyStartedFunc()
-	}
-
-	var wg sync.WaitGroup
-	defer func() {
-		wg.Wait()
-		close(srv.shutdown)
-	}()
-
-	for srv.isStarted() {
-		rw, err := l.Accept()
-		if err != nil {
-			if !srv.isStarted() {
-				return nil
-			}
-			if neterr, ok := err.(net.Error); ok && neterr.Temporary() {
-				continue
-			}
-			return err
-		}
-		srv.lock.Lock()
-		// Track the connection to allow unblocking reads on shutdown.
-		srv.conns[rw] = struct{}{}
-		srv.lock.Unlock()
-		wg.Add(1)
-		go srv.serveTCPConn(&wg, rw)
-	}
-
-	return nil
-}
-
-// serveUDP starts a UDP listener for the server.
-func (srv *Server) serveUDP(l net.PacketConn) error {
-	defer l.Close()
-
-	reader := Reader(defaultReader{srv})
-	if srv.DecorateReader != nil {
-		reader = srv.DecorateReader(reader)
-	}
-
-	lUDP, isUDP := l.(*net.UDPConn)
-	readerPC, canPacketConn := reader.(PacketConnReader)
-	if !isUDP && !canPacketConn {
-		return &Error{err: "PacketConnReader was not implemented on Reader returned from DecorateReader but is required for net.PacketConn"}
-	}
-
-	if srv.NotifyStartedFunc != nil {
-		srv.NotifyStartedFunc()
-	}
-
-	var wg sync.WaitGroup
-	defer func() {
-		wg.Wait()
-		close(srv.shutdown)
-	}()
-
-	rtimeout := srv.getReadTimeout()
-	// deadline is not used here
-	for srv.isStarted() {
-		var (
-			m    []byte
-			sPC  net.Addr
-			sUDP *SessionUDP
-			err  error
-		)
-		if isUDP {
-			m, sUDP, err = reader.ReadUDP(lUDP, rtimeout)
-		} else {
-			m, sPC, err = readerPC.ReadPacketConn(l, rtimeout)
-		}
-		if err != nil {
-			if !srv.isStarted() {
-				return nil
-			}
-			if netErr, ok := err.(net.Error); ok && netErr.Temporary() {
-				continue
-			}
-			return err
-		}
-		if len(m) < headerSize {
-			if cap(m) == srv.UDPSize {
-				srv.udpPool.Put(m[:srv.UDPSize])
-			}
-			srv.MsgInvalidFunc(m, ErrShortRead)
-			continue
-		}
-		wg.Add(1)
-		go srv.serveUDPPacket(&wg, m, l, sUDP, sPC)
-	}
-
-	return nil
-}
-
-// Serve a new TCP connection.
-func (srv *Server) serveTCPConn(wg *sync.WaitGroup, rw net.Conn) {
-	w := &response{tsigProvider: srv.tsigProvider(), tcp: rw}
-	if srv.DecorateWriter != nil {
-		w.writer = srv.DecorateWriter(w)
-	} else {
-		w.writer = w
-	}
-
-	reader := Reader(defaultReader{srv})
-	if srv.DecorateReader != nil {
-		reader = srv.DecorateReader(reader)
-	}
-
-	idleTimeout := tcpIdleTimeout
-	if srv.IdleTimeout != nil {
-		idleTimeout = srv.IdleTimeout()
-	}
-
-	timeout := srv.getReadTimeout()
-
-	limit := srv.MaxTCPQueries
-	if limit == 0 {
-		limit = maxTCPQueries
-	}
-
-	for q := 0; (q < limit || limit == -1) && srv.isStarted(); q++ {
-		m, err := reader.ReadTCP(w.tcp, timeout)
-		if err != nil {
-			// TODO(tmthrgd): handle error
-			break
-		}
-		srv.serveDNS(m, w)
-		if w.closed {
-			break // Close() was called
-		}
-		if w.hijacked {
-			break // client will call Close() themselves
-		}
-		// The first read uses the read timeout, the rest use the
-		// idle timeout.
-		timeout = idleTimeout
-	}
-
-	if !w.hijacked {
-		w.Close()
-	}
-
-	srv.lock.Lock()
-	delete(srv.conns, w.tcp)
-	srv.lock.Unlock()
-
-	wg.Done()
-}
-
-// Serve a new UDP request.
-func (srv *Server) serveUDPPacket(wg *sync.WaitGroup, m []byte, u net.PacketConn, udpSession *SessionUDP, pcSession net.Addr) {
-	w := &response{tsigProvider: srv.tsigProvider(), udp: u, udpSession: udpSession, pcSession: pcSession}
-	if srv.DecorateWriter != nil {
-		w.writer = srv.DecorateWriter(w)
-	} else {
-		w.writer = w
-	}
-
-	srv.serveDNS(m, w)
-	wg.Done()
-}
-
-func (srv *Server) serveDNS(m []byte, w *response) {
-	dh, off, err := unpackMsgHdr(m, 0)
-	if err != nil {
-		srv.MsgInvalidFunc(m, err)
-		// Let client hang, they are sending crap; any reply can be used to amplify.
-		return
-	}
-
-	req := new(Msg)
-	req.setHdr(dh)
-
-	switch action := srv.MsgAcceptFunc(dh); action {
-	case MsgAccept:
-		err := req.unpack(dh, m, off)
-		if err == nil {
-			break
-		}
-
-		srv.MsgInvalidFunc(m, err)
-		fallthrough
-	case MsgReject, MsgRejectNotImplemented:
-		opcode := req.Opcode
-		req.SetRcodeFormatError(req)
-		req.Zero = false
-		if action == MsgRejectNotImplemented {
-			req.Opcode = opcode
-			req.Rcode = RcodeNotImplemented
-		}
-
-		// Are we allowed to delete any OPT records here?
-		req.Ns, req.Answer, req.Extra = nil, nil, nil
-
-		w.WriteMsg(req)
-		fallthrough
-	case MsgIgnore:
-		if w.udp != nil && cap(m) == srv.UDPSize {
-			srv.udpPool.Put(m[:srv.UDPSize])
-		}
-
-		return
-	}
-
-	w.tsigStatus = nil
-	if w.tsigProvider != nil {
-		if t := req.IsTsig(); t != nil {
-			w.tsigStatus = TsigVerifyWithProvider(m, w.tsigProvider, "", false)
-			w.tsigTimersOnly = false
-			w.tsigRequestMAC = t.MAC
-		}
-	}
-
-	if w.udp != nil && cap(m) == srv.UDPSize {
-		srv.udpPool.Put(m[:srv.UDPSize])
-	}
-
-	srv.Handler.ServeDNS(w, req) // Writes back to the client
-}
-
-func (srv *Server) readTCP(conn net.Conn, timeout time.Duration) ([]byte, error) {
-	// If we race with ShutdownContext, the read deadline may
-	// have been set in the distant past to unblock the read
-	// below. We must not override it, otherwise we may block
-	// ShutdownContext.
-	srv.lock.RLock()
-	if srv.started {
-		conn.SetReadDeadline(time.Now().Add(timeout))
-	}
-	srv.lock.RUnlock()
-
-	var length uint16
-	if err := binary.Read(conn, binary.BigEndian, &length); err != nil {
-		return nil, err
-	}
-
-	m := make([]byte, length)
-	if _, err := io.ReadFull(conn, m); err != nil {
-		return nil, err
-	}
-
-	return m, nil
-}
-
-func (srv *Server) readUDP(conn *net.UDPConn, timeout time.Duration) ([]byte, *SessionUDP, error) {
-	srv.lock.RLock()
-	if srv.started {
-		// See the comment in readTCP above.
-		conn.SetReadDeadline(time.Now().Add(timeout))
-	}
-	srv.lock.RUnlock()
-
-	m := srv.udpPool.Get().([]byte)
-	n, s, err := ReadFromSessionUDP(conn, m)
-	if err != nil {
-		srv.udpPool.Put(m)
-		return nil, nil, err
-	}
-	m = m[:n]
-	return m, s, nil
-}
-
-func (srv *Server) readPacketConn(conn net.PacketConn, timeout time.Duration) ([]byte, net.Addr, error) {
-	srv.lock.RLock()
-	if srv.started {
-		// See the comment in readTCP above.
-		conn.SetReadDeadline(time.Now().Add(timeout))
-	}
-	srv.lock.RUnlock()
-
-	m := srv.udpPool.Get().([]byte)
-	n, addr, err := conn.ReadFrom(m)
-	if err != nil {
-		srv.udpPool.Put(m)
-		return nil, nil, err
-	}
-	m = m[:n]
-	return m, addr, nil
-}
-
-// WriteMsg implements the ResponseWriter.WriteMsg method.
-func (w *response) WriteMsg(m *Msg) (err error) {
-	if w.closed {
-		return &Error{err: "WriteMsg called after Close"}
-	}
-
-	var data []byte
-	if w.tsigProvider != nil { // if no provider, dont check for the tsig (which is a longer check)
-		if t := m.IsTsig(); t != nil {
-			data, w.tsigRequestMAC, err = TsigGenerateWithProvider(m, w.tsigProvider, w.tsigRequestMAC, w.tsigTimersOnly)
-			if err != nil {
-				return err
-			}
-			_, err = w.writer.Write(data)
-			return err
-		}
-	}
-	data, err = m.Pack()
-	if err != nil {
-		return err
-	}
-	_, err = w.writer.Write(data)
-	return err
-}
-
-// Write implements the ResponseWriter.Write method.
-func (w *response) Write(m []byte) (int, error) {
-	if w.closed {
-		return 0, &Error{err: "Write called after Close"}
-	}
-
-	switch {
-	case w.udp != nil:
-		if u, ok := w.udp.(*net.UDPConn); ok {
-			return WriteToSessionUDP(u, m, w.udpSession)
-		}
-		return w.udp.WriteTo(m, w.pcSession)
-	case w.tcp != nil:
-		if len(m) > MaxMsgSize {
-			return 0, &Error{err: "message too large"}
-		}
-
-		msg := make([]byte, 2+len(m))
-		binary.BigEndian.PutUint16(msg, uint16(len(m)))
-		copy(msg[2:], m)
-		return w.tcp.Write(msg)
-	default:
-		panic("dns: internal error: udp and tcp both nil")
-	}
-}
-
-// LocalAddr implements the ResponseWriter.LocalAddr method.
-func (w *response) LocalAddr() net.Addr {
-	switch {
-	case w.udp != nil:
-		return w.udp.LocalAddr()
-	case w.tcp != nil:
-		return w.tcp.LocalAddr()
-	default:
-		panic("dns: internal error: udp and tcp both nil")
-	}
-}
-
-// RemoteAddr implements the ResponseWriter.RemoteAddr method.
-func (w *response) RemoteAddr() net.Addr {
-	switch {
-	case w.udpSession != nil:
-		return w.udpSession.RemoteAddr()
-	case w.pcSession != nil:
-		return w.pcSession
-	case w.tcp != nil:
-		return w.tcp.RemoteAddr()
-	default:
-		panic("dns: internal error: udpSession, pcSession and tcp are all nil")
-	}
-}
-
-// TsigStatus implements the ResponseWriter.TsigStatus method.
-func (w *response) TsigStatus() error { return w.tsigStatus }
-
-// TsigTimersOnly implements the ResponseWriter.TsigTimersOnly method.
-func (w *response) TsigTimersOnly(b bool) { w.tsigTimersOnly = b }
-
-// Hijack implements the ResponseWriter.Hijack method.
-func (w *response) Hijack() { w.hijacked = true }
-
-// Close implements the ResponseWriter.Close method
-func (w *response) Close() error {
-	if w.closed {
-		return &Error{err: "connection already closed"}
-	}
-	w.closed = true
-
-	switch {
-	case w.udp != nil:
-		// Can't close the udp conn, as that is actually the listener.
-		return nil
-	case w.tcp != nil:
-		return w.tcp.Close()
-	default:
-		panic("dns: internal error: udp and tcp both nil")
-	}
-}
-
-// ConnectionState() implements the ConnectionStater.ConnectionState() interface.
-func (w *response) ConnectionState() *tls.ConnectionState {
-	type tlsConnectionStater interface {
-		ConnectionState() tls.ConnectionState
-	}
-	if v, ok := w.tcp.(tlsConnectionStater); ok {
-		t := v.ConnectionState()
-		return &t
-	}
-	return nil
-}
diff --git a/vendor/github.com/miekg/dns/sig0.go b/vendor/github.com/miekg/dns/sig0.go
deleted file mode 100644
index 057bb57873..0000000000
--- a/vendor/github.com/miekg/dns/sig0.go
+++ /dev/null
@@ -1,193 +0,0 @@
-package dns
-
-import (
-	"crypto"
-	"crypto/ecdsa"
-	"crypto/ed25519"
-	"crypto/rsa"
-	"encoding/binary"
-	"math/big"
-	"time"
-)
-
-// Sign signs a dns.Msg. It fills the signature with the appropriate data.
-// The SIG record should have the SignerName, KeyTag, Algorithm, Inception
-// and Expiration set.
-func (rr *SIG) Sign(k crypto.Signer, m *Msg) ([]byte, error) {
-	if k == nil {
-		return nil, ErrPrivKey
-	}
-	if rr.KeyTag == 0 || rr.SignerName == "" || rr.Algorithm == 0 {
-		return nil, ErrKey
-	}
-
-	rr.Hdr = RR_Header{Name: ".", Rrtype: TypeSIG, Class: ClassANY, Ttl: 0}
-	rr.OrigTtl, rr.TypeCovered, rr.Labels = 0, 0, 0
-
-	buf := make([]byte, m.Len()+Len(rr))
-	mbuf, err := m.PackBuffer(buf)
-	if err != nil {
-		return nil, err
-	}
-	if &buf[0] != &mbuf[0] {
-		return nil, ErrBuf
-	}
-	off, err := PackRR(rr, buf, len(mbuf), nil, false)
-	if err != nil {
-		return nil, err
-	}
-	buf = buf[:off:cap(buf)]
-
-	h, cryptohash, err := hashFromAlgorithm(rr.Algorithm)
-	if err != nil {
-		return nil, err
-	}
-
-	// Write SIG rdata
-	h.Write(buf[len(mbuf)+1+2+2+4+2:])
-	// Write message
-	h.Write(buf[:len(mbuf)])
-
-	signature, err := sign(k, h.Sum(nil), cryptohash, rr.Algorithm)
-	if err != nil {
-		return nil, err
-	}
-
-	rr.Signature = toBase64(signature)
-
-	buf = append(buf, signature...)
-	if len(buf) > int(^uint16(0)) {
-		return nil, ErrBuf
-	}
-	// Adjust sig data length
-	rdoff := len(mbuf) + 1 + 2 + 2 + 4
-	rdlen := binary.BigEndian.Uint16(buf[rdoff:])
-	rdlen += uint16(len(signature))
-	binary.BigEndian.PutUint16(buf[rdoff:], rdlen)
-	// Adjust additional count
-	adc := binary.BigEndian.Uint16(buf[10:])
-	adc++
-	binary.BigEndian.PutUint16(buf[10:], adc)
-	return buf, nil
-}
-
-// Verify validates the message buf using the key k.
-// It's assumed that buf is a valid message from which rr was unpacked.
-func (rr *SIG) Verify(k *KEY, buf []byte) error {
-	if k == nil {
-		return ErrKey
-	}
-	if rr.KeyTag == 0 || rr.SignerName == "" || rr.Algorithm == 0 {
-		return ErrKey
-	}
-
-	h, cryptohash, err := hashFromAlgorithm(rr.Algorithm)
-	if err != nil {
-		return err
-	}
-
-	buflen := len(buf)
-	qdc := binary.BigEndian.Uint16(buf[4:])
-	anc := binary.BigEndian.Uint16(buf[6:])
-	auc := binary.BigEndian.Uint16(buf[8:])
-	adc := binary.BigEndian.Uint16(buf[10:])
-	offset := headerSize
-	for i := uint16(0); i < qdc && offset < buflen; i++ {
-		_, offset, err = UnpackDomainName(buf, offset)
-		if err != nil {
-			return err
-		}
-		// Skip past Type and Class
-		offset += 2 + 2
-	}
-	for i := uint16(1); i < anc+auc+adc && offset < buflen; i++ {
-		_, offset, err = UnpackDomainName(buf, offset)
-		if err != nil {
-			return err
-		}
-		// Skip past Type, Class and TTL
-		offset += 2 + 2 + 4
-		if offset+1 >= buflen {
-			continue
-		}
-		rdlen := binary.BigEndian.Uint16(buf[offset:])
-		offset += 2
-		offset += int(rdlen)
-	}
-	if offset >= buflen {
-		return &Error{err: "overflowing unpacking signed message"}
-	}
-
-	// offset should be just prior to SIG
-	bodyend := offset
-	// owner name SHOULD be root
-	_, offset, err = UnpackDomainName(buf, offset)
-	if err != nil {
-		return err
-	}
-	// Skip Type, Class, TTL, RDLen
-	offset += 2 + 2 + 4 + 2
-	sigstart := offset
-	// Skip Type Covered, Algorithm, Labels, Original TTL
-	offset += 2 + 1 + 1 + 4
-	if offset+4+4 >= buflen {
-		return &Error{err: "overflow unpacking signed message"}
-	}
-	expire := binary.BigEndian.Uint32(buf[offset:])
-	offset += 4
-	incept := binary.BigEndian.Uint32(buf[offset:])
-	offset += 4
-	now := uint32(time.Now().Unix())
-	if now < incept || now > expire {
-		return ErrTime
-	}
-	// Skip key tag
-	offset += 2
-	var signername string
-	signername, offset, err = UnpackDomainName(buf, offset)
-	if err != nil {
-		return err
-	}
-	// If key has come from the DNS name compression might
-	// have mangled the case of the name
-	if !equal(signername, k.Header().Name) {
-		return &Error{err: "signer name doesn't match key name"}
-	}
-	sigend := offset
-	h.Write(buf[sigstart:sigend])
-	h.Write(buf[:10])
-	h.Write([]byte{
-		byte((adc - 1) << 8),
-		byte(adc - 1),
-	})
-	h.Write(buf[12:bodyend])
-
-	hashed := h.Sum(nil)
-	sig := buf[sigend:]
-	switch k.Algorithm {
-	case RSASHA1, RSASHA256, RSASHA512:
-		pk := k.publicKeyRSA()
-		if pk != nil {
-			return rsa.VerifyPKCS1v15(pk, cryptohash, hashed, sig)
-		}
-	case ECDSAP256SHA256, ECDSAP384SHA384:
-		pk := k.publicKeyECDSA()
-		r := new(big.Int).SetBytes(sig[:len(sig)/2])
-		s := new(big.Int).SetBytes(sig[len(sig)/2:])
-		if pk != nil {
-			if ecdsa.Verify(pk, hashed, r, s) {
-				return nil
-			}
-			return ErrSig
-		}
-	case ED25519:
-		pk := k.publicKeyED25519()
-		if pk != nil {
-			if ed25519.Verify(pk, hashed, sig) {
-				return nil
-			}
-			return ErrSig
-		}
-	}
-	return ErrKeyAlg
-}
diff --git a/vendor/github.com/miekg/dns/smimea.go b/vendor/github.com/miekg/dns/smimea.go
deleted file mode 100644
index 89f09f0d10..0000000000
--- a/vendor/github.com/miekg/dns/smimea.go
+++ /dev/null
@@ -1,44 +0,0 @@
-package dns
-
-import (
-	"crypto/sha256"
-	"crypto/x509"
-	"encoding/hex"
-)
-
-// Sign creates a SMIMEA record from an SSL certificate.
-func (r *SMIMEA) Sign(usage, selector, matchingType int, cert *x509.Certificate) (err error) {
-	r.Hdr.Rrtype = TypeSMIMEA
-	r.Usage = uint8(usage)
-	r.Selector = uint8(selector)
-	r.MatchingType = uint8(matchingType)
-
-	r.Certificate, err = CertificateToDANE(r.Selector, r.MatchingType, cert)
-	return err
-}
-
-// Verify verifies a SMIMEA record against an SSL certificate. If it is OK
-// a nil error is returned.
-func (r *SMIMEA) Verify(cert *x509.Certificate) error {
-	c, err := CertificateToDANE(r.Selector, r.MatchingType, cert)
-	if err != nil {
-		return err // Not also ErrSig?
-	}
-	if r.Certificate == c {
-		return nil
-	}
-	return ErrSig // ErrSig, really?
-}
-
-// SMIMEAName returns the ownername of a SMIMEA resource record as per the
-// format specified in RFC 'draft-ietf-dane-smime-12' Section 2 and 3
-func SMIMEAName(email, domain string) (string, error) {
-	hasher := sha256.New()
-	hasher.Write([]byte(email))
-
-	// RFC Section 3: "The local-part is hashed using the SHA2-256
-	// algorithm with the hash truncated to 28 octets and
-	// represented in its hexadecimal representation to become the
-	// left-most label in the prepared domain name"
-	return hex.EncodeToString(hasher.Sum(nil)[:28]) + "." + "_smimecert." + domain, nil
-}
diff --git a/vendor/github.com/miekg/dns/svcb.go b/vendor/github.com/miekg/dns/svcb.go
deleted file mode 100644
index 598103c10c..0000000000
--- a/vendor/github.com/miekg/dns/svcb.go
+++ /dev/null
@@ -1,969 +0,0 @@
-package dns
-
-import (
-	"bytes"
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"net"
-	"sort"
-	"strconv"
-	"strings"
-)
-
-// SVCBKey is the type of the keys used in the SVCB RR.
-type SVCBKey uint16
-
-// Keys defined in rfc9460
-const (
-	SVCB_MANDATORY SVCBKey = iota
-	SVCB_ALPN
-	SVCB_NO_DEFAULT_ALPN
-	SVCB_PORT
-	SVCB_IPV4HINT
-	SVCB_ECHCONFIG
-	SVCB_IPV6HINT
-	SVCB_DOHPATH // rfc9461 Section 5
-	SVCB_OHTTP   // rfc9540 Section 8
-
-	svcb_RESERVED SVCBKey = 65535
-)
-
-var svcbKeyToStringMap = map[SVCBKey]string{
-	SVCB_MANDATORY:       "mandatory",
-	SVCB_ALPN:            "alpn",
-	SVCB_NO_DEFAULT_ALPN: "no-default-alpn",
-	SVCB_PORT:            "port",
-	SVCB_IPV4HINT:        "ipv4hint",
-	SVCB_ECHCONFIG:       "ech",
-	SVCB_IPV6HINT:        "ipv6hint",
-	SVCB_DOHPATH:         "dohpath",
-	SVCB_OHTTP:           "ohttp",
-}
-
-var svcbStringToKeyMap = reverseSVCBKeyMap(svcbKeyToStringMap)
-
-func reverseSVCBKeyMap(m map[SVCBKey]string) map[string]SVCBKey {
-	n := make(map[string]SVCBKey, len(m))
-	for u, s := range m {
-		n[s] = u
-	}
-	return n
-}
-
-// String takes the numerical code of an SVCB key and returns its name.
-// Returns an empty string for reserved keys.
-// Accepts unassigned keys as well as experimental/private keys.
-func (key SVCBKey) String() string {
-	if x := svcbKeyToStringMap[key]; x != "" {
-		return x
-	}
-	if key == svcb_RESERVED {
-		return ""
-	}
-	return "key" + strconv.FormatUint(uint64(key), 10)
-}
-
-// svcbStringToKey returns the numerical code of an SVCB key.
-// Returns svcb_RESERVED for reserved/invalid keys.
-// Accepts unassigned keys as well as experimental/private keys.
-func svcbStringToKey(s string) SVCBKey {
-	if strings.HasPrefix(s, "key") {
-		a, err := strconv.ParseUint(s[3:], 10, 16)
-		// no leading zeros
-		// key shouldn't be registered
-		if err != nil || a == 65535 || s[3] == '0' || svcbKeyToStringMap[SVCBKey(a)] != "" {
-			return svcb_RESERVED
-		}
-		return SVCBKey(a)
-	}
-	if key, ok := svcbStringToKeyMap[s]; ok {
-		return key
-	}
-	return svcb_RESERVED
-}
-
-func (rr *SVCB) parse(c *zlexer, o string) *ParseError {
-	l, _ := c.Next()
-	i, e := strconv.ParseUint(l.token, 10, 16)
-	if e != nil || l.err {
-		return &ParseError{file: l.token, err: "bad SVCB priority", lex: l}
-	}
-	rr.Priority = uint16(i)
-
-	c.Next()        // zBlank
-	l, _ = c.Next() // zString
-	rr.Target = l.token
-
-	name, nameOk := toAbsoluteName(l.token, o)
-	if l.err || !nameOk {
-		return &ParseError{file: l.token, err: "bad SVCB Target", lex: l}
-	}
-	rr.Target = name
-
-	// Values (if any)
-	l, _ = c.Next()
-	var xs []SVCBKeyValue
-	// Helps require whitespace between pairs.
-	// Prevents key1000="a"key1001=...
-	canHaveNextKey := true
-	for l.value != zNewline && l.value != zEOF {
-		switch l.value {
-		case zString:
-			if !canHaveNextKey {
-				// The key we can now read was probably meant to be
-				// a part of the last value.
-				return &ParseError{file: l.token, err: "bad SVCB value quotation", lex: l}
-			}
-
-			// In key=value pairs, value does not have to be quoted unless value
-			// contains whitespace. And keys don't need to have values.
-			// Similarly, keys with an equality signs after them don't need values.
-			// l.token includes at least up to the first equality sign.
-			idx := strings.IndexByte(l.token, '=')
-			var key, value string
-			if idx < 0 {
-				// Key with no value and no equality sign
-				key = l.token
-			} else if idx == 0 {
-				return &ParseError{file: l.token, err: "bad SVCB key", lex: l}
-			} else {
-				key, value = l.token[:idx], l.token[idx+1:]
-
-				if value == "" {
-					// We have a key and an equality sign. Maybe we have nothing
-					// after "=" or we have a double quote.
-					l, _ = c.Next()
-					if l.value == zQuote {
-						// Only needed when value ends with double quotes.
-						// Any value starting with zQuote ends with it.
-						canHaveNextKey = false
-
-						l, _ = c.Next()
-						switch l.value {
-						case zString:
-							// We have a value in double quotes.
-							value = l.token
-							l, _ = c.Next()
-							if l.value != zQuote {
-								return &ParseError{file: l.token, err: "SVCB unterminated value", lex: l}
-							}
-						case zQuote:
-							// There's nothing in double quotes.
-						default:
-							return &ParseError{file: l.token, err: "bad SVCB value", lex: l}
-						}
-					}
-				}
-			}
-			kv := makeSVCBKeyValue(svcbStringToKey(key))
-			if kv == nil {
-				return &ParseError{file: l.token, err: "bad SVCB key", lex: l}
-			}
-			if err := kv.parse(value); err != nil {
-				return &ParseError{file: l.token, wrappedErr: err, lex: l}
-			}
-			xs = append(xs, kv)
-		case zQuote:
-			return &ParseError{file: l.token, err: "SVCB key can't contain double quotes", lex: l}
-		case zBlank:
-			canHaveNextKey = true
-		default:
-			return &ParseError{file: l.token, err: "bad SVCB values", lex: l}
-		}
-		l, _ = c.Next()
-	}
-
-	// "In AliasMode, records SHOULD NOT include any SvcParams, and recipients MUST
-	// ignore any SvcParams that are present."
-	// However, we don't check rr.Priority == 0 && len(xs) > 0 here
-	// It is the responsibility of the user of the library to check this.
-	// This is to encourage the fixing of the source of this error.
-
-	rr.Value = xs
-	return nil
-}
-
-// makeSVCBKeyValue returns an SVCBKeyValue struct with the key or nil for reserved keys.
-func makeSVCBKeyValue(key SVCBKey) SVCBKeyValue {
-	switch key {
-	case SVCB_MANDATORY:
-		return new(SVCBMandatory)
-	case SVCB_ALPN:
-		return new(SVCBAlpn)
-	case SVCB_NO_DEFAULT_ALPN:
-		return new(SVCBNoDefaultAlpn)
-	case SVCB_PORT:
-		return new(SVCBPort)
-	case SVCB_IPV4HINT:
-		return new(SVCBIPv4Hint)
-	case SVCB_ECHCONFIG:
-		return new(SVCBECHConfig)
-	case SVCB_IPV6HINT:
-		return new(SVCBIPv6Hint)
-	case SVCB_DOHPATH:
-		return new(SVCBDoHPath)
-	case SVCB_OHTTP:
-		return new(SVCBOhttp)
-	case svcb_RESERVED:
-		return nil
-	default:
-		e := new(SVCBLocal)
-		e.KeyCode = key
-		return e
-	}
-}
-
-// SVCB RR. See RFC 9460.
-type SVCB struct {
-	Hdr      RR_Header
-	Priority uint16         // If zero, Value must be empty or discarded by the user of this library
-	Target   string         `dns:"domain-name"`
-	Value    []SVCBKeyValue `dns:"pairs"`
-}
-
-// HTTPS RR. See RFC 9460. Everything valid for SVCB applies to HTTPS as well.
-// Except that the HTTPS record is intended for use with the HTTP and HTTPS protocols.
-type HTTPS struct {
-	SVCB
-}
-
-func (rr *HTTPS) String() string {
-	return rr.SVCB.String()
-}
-
-func (rr *HTTPS) parse(c *zlexer, o string) *ParseError {
-	return rr.SVCB.parse(c, o)
-}
-
-// SVCBKeyValue defines a key=value pair for the SVCB RR type.
-// An SVCB RR can have multiple SVCBKeyValues appended to it.
-type SVCBKeyValue interface {
-	Key() SVCBKey          // Key returns the numerical key code.
-	pack() ([]byte, error) // pack returns the encoded value.
-	unpack([]byte) error   // unpack sets the value.
-	String() string        // String returns the string representation of the value.
-	parse(string) error    // parse sets the value to the given string representation of the value.
-	copy() SVCBKeyValue    // copy returns a deep-copy of the pair.
-	len() int              // len returns the length of value in the wire format.
-}
-
-// SVCBMandatory pair adds to required keys that must be interpreted for the RR
-// to be functional. If ignored, the whole RRSet must be ignored.
-// "port" and "no-default-alpn" are mandatory by default if present,
-// so they shouldn't be included here.
-//
-// It is incumbent upon the user of this library to reject the RRSet if
-// or avoid constructing such an RRSet that:
-// - "mandatory" is included as one of the keys of mandatory
-// - no key is listed multiple times in mandatory
-// - all keys listed in mandatory are present
-// - escape sequences are not used in mandatory
-// - mandatory, when present, lists at least one key
-//
-// Basic use pattern for creating a mandatory option:
-//
-//	s := &dns.SVCB{Hdr: dns.RR_Header{Name: ".", Rrtype: dns.TypeSVCB, Class: dns.ClassINET}}
-//	e := new(dns.SVCBMandatory)
-//	e.Code = []uint16{dns.SVCB_ALPN}
-//	s.Value = append(s.Value, e)
-//	t := new(dns.SVCBAlpn)
-//	t.Alpn = []string{"xmpp-client"}
-//	s.Value = append(s.Value, t)
-type SVCBMandatory struct {
-	Code []SVCBKey
-}
-
-func (*SVCBMandatory) Key() SVCBKey { return SVCB_MANDATORY }
-
-func (s *SVCBMandatory) String() string {
-	str := make([]string, len(s.Code))
-	for i, e := range s.Code {
-		str[i] = e.String()
-	}
-	return strings.Join(str, ",")
-}
-
-func (s *SVCBMandatory) pack() ([]byte, error) {
-	codes := cloneSlice(s.Code)
-	sort.Slice(codes, func(i, j int) bool {
-		return codes[i] < codes[j]
-	})
-	b := make([]byte, 2*len(codes))
-	for i, e := range codes {
-		binary.BigEndian.PutUint16(b[2*i:], uint16(e))
-	}
-	return b, nil
-}
-
-func (s *SVCBMandatory) unpack(b []byte) error {
-	if len(b)%2 != 0 {
-		return errors.New("bad svcbmandatory: value length is not a multiple of 2")
-	}
-	codes := make([]SVCBKey, 0, len(b)/2)
-	for i := 0; i < len(b); i += 2 {
-		// We assume strictly increasing order.
-		codes = append(codes, SVCBKey(binary.BigEndian.Uint16(b[i:])))
-	}
-	s.Code = codes
-	return nil
-}
-
-func (s *SVCBMandatory) parse(b string) error {
-	codes := make([]SVCBKey, 0, strings.Count(b, ",")+1)
-	for len(b) > 0 {
-		var key string
-		key, b, _ = strings.Cut(b, ",")
-		codes = append(codes, svcbStringToKey(key))
-	}
-	s.Code = codes
-	return nil
-}
-
-func (s *SVCBMandatory) len() int {
-	return 2 * len(s.Code)
-}
-
-func (s *SVCBMandatory) copy() SVCBKeyValue {
-	return &SVCBMandatory{cloneSlice(s.Code)}
-}
-
-// SVCBAlpn pair is used to list supported connection protocols.
-// The user of this library must ensure that at least one protocol is listed when alpn is present.
-// Protocol IDs can be found at:
-// https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids
-// Basic use pattern for creating an alpn option:
-//
-//	h := new(dns.HTTPS)
-//	h.Hdr = dns.RR_Header{Name: ".", Rrtype: dns.TypeHTTPS, Class: dns.ClassINET}
-//	e := new(dns.SVCBAlpn)
-//	e.Alpn = []string{"h2", "http/1.1"}
-//	h.Value = append(h.Value, e)
-type SVCBAlpn struct {
-	Alpn []string
-}
-
-func (*SVCBAlpn) Key() SVCBKey { return SVCB_ALPN }
-
-func (s *SVCBAlpn) String() string {
-	// An ALPN value is a comma-separated list of values, each of which can be
-	// an arbitrary binary value. In order to allow parsing, the comma and
-	// backslash characters are themselves escaped.
-	//
-	// However, this escaping is done in addition to the normal escaping which
-	// happens in zone files, meaning that these values must be
-	// double-escaped. This looks terrible, so if you see a never-ending
-	// sequence of backslash in a zone file this may be why.
-	//
-	// https://datatracker.ietf.org/doc/html/draft-ietf-dnsop-svcb-https-08#appendix-A.1
-	var str strings.Builder
-	for i, alpn := range s.Alpn {
-		// 4*len(alpn) is the worst case where we escape every character in the alpn as \123, plus 1 byte for the ',' separating the alpn from others
-		str.Grow(4*len(alpn) + 1)
-		if i > 0 {
-			str.WriteByte(',')
-		}
-		for j := 0; j < len(alpn); j++ {
-			e := alpn[j]
-			if ' ' > e || e > '~' {
-				str.WriteString(escapeByte(e))
-				continue
-			}
-			switch e {
-			// We escape a few characters which may confuse humans or parsers.
-			case '"', ';', ' ':
-				str.WriteByte('\\')
-				str.WriteByte(e)
-			// The comma and backslash characters themselves must be
-			// doubly-escaped. We use `\\` for the first backslash and
-			// the escaped numeric value for the other value. We especially
-			// don't want a comma in the output.
-			case ',':
-				str.WriteString(`\\\044`)
-			case '\\':
-				str.WriteString(`\\\092`)
-			default:
-				str.WriteByte(e)
-			}
-		}
-	}
-	return str.String()
-}
-
-func (s *SVCBAlpn) pack() ([]byte, error) {
-	// Liberally estimate the size of an alpn as 10 octets
-	b := make([]byte, 0, 10*len(s.Alpn))
-	for _, e := range s.Alpn {
-		if e == "" {
-			return nil, errors.New("bad svcbalpn: empty alpn-id")
-		}
-		if len(e) > 255 {
-			return nil, errors.New("bad svcbalpn: alpn-id too long")
-		}
-		b = append(b, byte(len(e)))
-		b = append(b, e...)
-	}
-	return b, nil
-}
-
-func (s *SVCBAlpn) unpack(b []byte) error {
-	// Estimate the size of the smallest alpn as 4 bytes
-	alpn := make([]string, 0, len(b)/4)
-	for i := 0; i < len(b); {
-		length := int(b[i])
-		i++
-		if i+length > len(b) {
-			return errors.New("bad svcbalpn: alpn array overflowing")
-		}
-		alpn = append(alpn, string(b[i:i+length]))
-		i += length
-	}
-	s.Alpn = alpn
-	return nil
-}
-
-func (s *SVCBAlpn) parse(b string) error {
-	if len(b) == 0 {
-		s.Alpn = []string{}
-		return nil
-	}
-
-	alpn := []string{}
-	a := []byte{}
-	for p := 0; p < len(b); {
-		c, q := nextByte(b, p)
-		if q == 0 {
-			return errors.New("bad svcbalpn: unterminated escape")
-		}
-		p += q
-		// If we find a comma, we have finished reading an alpn.
-		if c == ',' {
-			if len(a) == 0 {
-				return errors.New("bad svcbalpn: empty protocol identifier")
-			}
-			alpn = append(alpn, string(a))
-			a = []byte{}
-			continue
-		}
-		// If it's a backslash, we need to handle a comma-separated list.
-		if c == '\\' {
-			dc, dq := nextByte(b, p)
-			if dq == 0 {
-				return errors.New("bad svcbalpn: unterminated escape decoding comma-separated list")
-			}
-			if dc != '\\' && dc != ',' {
-				return errors.New("bad svcbalpn: bad escaped character decoding comma-separated list")
-			}
-			p += dq
-			c = dc
-		}
-		a = append(a, c)
-	}
-	// Add the final alpn.
-	if len(a) == 0 {
-		return errors.New("bad svcbalpn: last protocol identifier empty")
-	}
-	s.Alpn = append(alpn, string(a))
-	return nil
-}
-
-func (s *SVCBAlpn) len() int {
-	var l int
-	for _, e := range s.Alpn {
-		l += 1 + len(e)
-	}
-	return l
-}
-
-func (s *SVCBAlpn) copy() SVCBKeyValue {
-	return &SVCBAlpn{cloneSlice(s.Alpn)}
-}
-
-// SVCBNoDefaultAlpn pair signifies no support for default connection protocols.
-// Should be used in conjunction with alpn.
-// Basic use pattern for creating a no-default-alpn option:
-//
-//	s := &dns.SVCB{Hdr: dns.RR_Header{Name: ".", Rrtype: dns.TypeSVCB, Class: dns.ClassINET}}
-//	t := new(dns.SVCBAlpn)
-//	t.Alpn = []string{"xmpp-client"}
-//	s.Value = append(s.Value, t)
-//	e := new(dns.SVCBNoDefaultAlpn)
-//	s.Value = append(s.Value, e)
-type SVCBNoDefaultAlpn struct{}
-
-func (*SVCBNoDefaultAlpn) Key() SVCBKey          { return SVCB_NO_DEFAULT_ALPN }
-func (*SVCBNoDefaultAlpn) copy() SVCBKeyValue    { return &SVCBNoDefaultAlpn{} }
-func (*SVCBNoDefaultAlpn) pack() ([]byte, error) { return []byte{}, nil }
-func (*SVCBNoDefaultAlpn) String() string        { return "" }
-func (*SVCBNoDefaultAlpn) len() int              { return 0 }
-
-func (*SVCBNoDefaultAlpn) unpack(b []byte) error {
-	if len(b) != 0 {
-		return errors.New("bad svcbnodefaultalpn: no-default-alpn must have no value")
-	}
-	return nil
-}
-
-func (*SVCBNoDefaultAlpn) parse(b string) error {
-	if b != "" {
-		return errors.New("bad svcbnodefaultalpn: no-default-alpn must have no value")
-	}
-	return nil
-}
-
-// SVCBPort pair defines the port for connection.
-// Basic use pattern for creating a port option:
-//
-//	s := &dns.SVCB{Hdr: dns.RR_Header{Name: ".", Rrtype: dns.TypeSVCB, Class: dns.ClassINET}}
-//	e := new(dns.SVCBPort)
-//	e.Port = 80
-//	s.Value = append(s.Value, e)
-type SVCBPort struct {
-	Port uint16
-}
-
-func (*SVCBPort) Key() SVCBKey         { return SVCB_PORT }
-func (*SVCBPort) len() int             { return 2 }
-func (s *SVCBPort) String() string     { return strconv.FormatUint(uint64(s.Port), 10) }
-func (s *SVCBPort) copy() SVCBKeyValue { return &SVCBPort{s.Port} }
-
-func (s *SVCBPort) unpack(b []byte) error {
-	if len(b) != 2 {
-		return errors.New("bad svcbport: port length is not exactly 2 octets")
-	}
-	s.Port = binary.BigEndian.Uint16(b)
-	return nil
-}
-
-func (s *SVCBPort) pack() ([]byte, error) {
-	b := make([]byte, 2)
-	binary.BigEndian.PutUint16(b, s.Port)
-	return b, nil
-}
-
-func (s *SVCBPort) parse(b string) error {
-	port, err := strconv.ParseUint(b, 10, 16)
-	if err != nil {
-		return errors.New("bad svcbport: port out of range")
-	}
-	s.Port = uint16(port)
-	return nil
-}
-
-// SVCBIPv4Hint pair suggests an IPv4 address which may be used to open connections
-// if A and AAAA record responses for SVCB's Target domain haven't been received.
-// In that case, optionally, A and AAAA requests can be made, after which the connection
-// to the hinted IP address may be terminated and a new connection may be opened.
-// Basic use pattern for creating an ipv4hint option:
-//
-//		h := new(dns.HTTPS)
-//		h.Hdr = dns.RR_Header{Name: ".", Rrtype: dns.TypeHTTPS, Class: dns.ClassINET}
-//		e := new(dns.SVCBIPv4Hint)
-//		e.Hint = []net.IP{net.IPv4(1,1,1,1).To4()}
-//
-//	 Or
-//
-//		e.Hint = []net.IP{net.ParseIP("1.1.1.1").To4()}
-//		h.Value = append(h.Value, e)
-type SVCBIPv4Hint struct {
-	Hint []net.IP
-}
-
-func (*SVCBIPv4Hint) Key() SVCBKey { return SVCB_IPV4HINT }
-func (s *SVCBIPv4Hint) len() int   { return 4 * len(s.Hint) }
-
-func (s *SVCBIPv4Hint) pack() ([]byte, error) {
-	b := make([]byte, 0, 4*len(s.Hint))
-	for _, e := range s.Hint {
-		x := e.To4()
-		if x == nil {
-			return nil, errors.New("bad svcbipv4hint: expected ipv4, hint is ipv6")
-		}
-		b = append(b, x...)
-	}
-	return b, nil
-}
-
-func (s *SVCBIPv4Hint) unpack(b []byte) error {
-	if len(b) == 0 || len(b)%4 != 0 {
-		return errors.New("bad svcbipv4hint: ipv4 address byte array length is not a multiple of 4")
-	}
-	b = cloneSlice(b)
-	x := make([]net.IP, 0, len(b)/4)
-	for i := 0; i < len(b); i += 4 {
-		x = append(x, net.IP(b[i:i+4]))
-	}
-	s.Hint = x
-	return nil
-}
-
-func (s *SVCBIPv4Hint) String() string {
-	str := make([]string, len(s.Hint))
-	for i, e := range s.Hint {
-		x := e.To4()
-		if x == nil {
-			return "<nil>"
-		}
-		str[i] = x.String()
-	}
-	return strings.Join(str, ",")
-}
-
-func (s *SVCBIPv4Hint) parse(b string) error {
-	if b == "" {
-		return errors.New("bad svcbipv4hint: empty hint")
-	}
-	if strings.Contains(b, ":") {
-		return errors.New("bad svcbipv4hint: expected ipv4, got ipv6")
-	}
-
-	hint := make([]net.IP, 0, strings.Count(b, ",")+1)
-	for len(b) > 0 {
-		var e string
-		e, b, _ = strings.Cut(b, ",")
-		ip := net.ParseIP(e).To4()
-		if ip == nil {
-			return errors.New("bad svcbipv4hint: bad ip")
-		}
-		hint = append(hint, ip)
-	}
-	s.Hint = hint
-	return nil
-}
-
-func (s *SVCBIPv4Hint) copy() SVCBKeyValue {
-	hint := make([]net.IP, len(s.Hint))
-	for i, ip := range s.Hint {
-		hint[i] = cloneSlice(ip)
-	}
-	return &SVCBIPv4Hint{Hint: hint}
-}
-
-// SVCBECHConfig pair contains the ECHConfig structure defined in draft-ietf-tls-esni [RFC xxxx].
-// Basic use pattern for creating an ech option:
-//
-//	h := new(dns.HTTPS)
-//	h.Hdr = dns.RR_Header{Name: ".", Rrtype: dns.TypeHTTPS, Class: dns.ClassINET}
-//	e := new(dns.SVCBECHConfig)
-//	e.ECH = []byte{0xfe, 0x08, ...}
-//	h.Value = append(h.Value, e)
-type SVCBECHConfig struct {
-	ECH []byte // Specifically ECHConfigList including the redundant length prefix
-}
-
-func (*SVCBECHConfig) Key() SVCBKey     { return SVCB_ECHCONFIG }
-func (s *SVCBECHConfig) String() string { return toBase64(s.ECH) }
-func (s *SVCBECHConfig) len() int       { return len(s.ECH) }
-
-func (s *SVCBECHConfig) pack() ([]byte, error) {
-	return cloneSlice(s.ECH), nil
-}
-
-func (s *SVCBECHConfig) copy() SVCBKeyValue {
-	return &SVCBECHConfig{cloneSlice(s.ECH)}
-}
-
-func (s *SVCBECHConfig) unpack(b []byte) error {
-	s.ECH = cloneSlice(b)
-	return nil
-}
-
-func (s *SVCBECHConfig) parse(b string) error {
-	x, err := fromBase64([]byte(b))
-	if err != nil {
-		return errors.New("bad svcbech: bad base64 ech")
-	}
-	s.ECH = x
-	return nil
-}
-
-// SVCBIPv6Hint pair suggests an IPv6 address which may be used to open connections
-// if A and AAAA record responses for SVCB's Target domain haven't been received.
-// In that case, optionally, A and AAAA requests can be made, after which the
-// connection to the hinted IP address may be terminated and a new connection may be opened.
-// Basic use pattern for creating an ipv6hint option:
-//
-//	h := new(dns.HTTPS)
-//	h.Hdr = dns.RR_Header{Name: ".", Rrtype: dns.TypeHTTPS, Class: dns.ClassINET}
-//	e := new(dns.SVCBIPv6Hint)
-//	e.Hint = []net.IP{net.ParseIP("2001:db8::1")}
-//	h.Value = append(h.Value, e)
-type SVCBIPv6Hint struct {
-	Hint []net.IP
-}
-
-func (*SVCBIPv6Hint) Key() SVCBKey { return SVCB_IPV6HINT }
-func (s *SVCBIPv6Hint) len() int   { return 16 * len(s.Hint) }
-
-func (s *SVCBIPv6Hint) pack() ([]byte, error) {
-	b := make([]byte, 0, 16*len(s.Hint))
-	for _, e := range s.Hint {
-		if len(e) != net.IPv6len || e.To4() != nil {
-			return nil, errors.New("bad svcbipv6hint: expected ipv6, hint is ipv4")
-		}
-		b = append(b, e...)
-	}
-	return b, nil
-}
-
-func (s *SVCBIPv6Hint) unpack(b []byte) error {
-	if len(b) == 0 || len(b)%16 != 0 {
-		return errors.New("bas svcbipv6hint: ipv6 address byte array length not a multiple of 16")
-	}
-	b = cloneSlice(b)
-	x := make([]net.IP, 0, len(b)/16)
-	for i := 0; i < len(b); i += 16 {
-		ip := net.IP(b[i : i+16])
-		if ip.To4() != nil {
-			return errors.New("bad svcbipv6hint: expected ipv6, got ipv4")
-		}
-		x = append(x, ip)
-	}
-	s.Hint = x
-	return nil
-}
-
-func (s *SVCBIPv6Hint) String() string {
-	str := make([]string, len(s.Hint))
-	for i, e := range s.Hint {
-		if x := e.To4(); x != nil {
-			return "<nil>"
-		}
-		str[i] = e.String()
-	}
-	return strings.Join(str, ",")
-}
-
-func (s *SVCBIPv6Hint) parse(b string) error {
-	if b == "" {
-		return errors.New("bad svcbipv6hint: empty hint")
-	}
-
-	hint := make([]net.IP, 0, strings.Count(b, ",")+1)
-	for len(b) > 0 {
-		var e string
-		e, b, _ = strings.Cut(b, ",")
-		ip := net.ParseIP(e)
-		if ip == nil {
-			return errors.New("bad svcbipv6hint: bad ip")
-		}
-		if ip.To4() != nil {
-			return errors.New("bad svcbipv6hint: expected ipv6, got ipv4-mapped-ipv6")
-		}
-		hint = append(hint, ip)
-	}
-	s.Hint = hint
-	return nil
-}
-
-func (s *SVCBIPv6Hint) copy() SVCBKeyValue {
-	hint := make([]net.IP, len(s.Hint))
-	for i, ip := range s.Hint {
-		hint[i] = cloneSlice(ip)
-	}
-	return &SVCBIPv6Hint{Hint: hint}
-}
-
-// SVCBDoHPath pair is used to indicate the URI template that the
-// clients may use to construct a DNS over HTTPS URI.
-//
-// See RFC 9461 (https://datatracker.ietf.org/doc/html/rfc9461)
-// and RFC 9462 (https://datatracker.ietf.org/doc/html/rfc9462).
-//
-// A basic example of using the dohpath option together with the alpn
-// option to indicate support for DNS over HTTPS on a certain path:
-//
-//	s := new(dns.SVCB)
-//	s.Hdr = dns.RR_Header{Name: ".", Rrtype: dns.TypeSVCB, Class: dns.ClassINET}
-//	e := new(dns.SVCBAlpn)
-//	e.Alpn = []string{"h2", "h3"}
-//	p := new(dns.SVCBDoHPath)
-//	p.Template = "/dns-query{?dns}"
-//	s.Value = append(s.Value, e, p)
-//
-// The parsing currently doesn't validate that Template is a valid
-// RFC 6570 URI template.
-type SVCBDoHPath struct {
-	Template string
-}
-
-func (*SVCBDoHPath) Key() SVCBKey            { return SVCB_DOHPATH }
-func (s *SVCBDoHPath) String() string        { return svcbParamToStr([]byte(s.Template)) }
-func (s *SVCBDoHPath) len() int              { return len(s.Template) }
-func (s *SVCBDoHPath) pack() ([]byte, error) { return []byte(s.Template), nil }
-
-func (s *SVCBDoHPath) unpack(b []byte) error {
-	s.Template = string(b)
-	return nil
-}
-
-func (s *SVCBDoHPath) parse(b string) error {
-	template, err := svcbParseParam(b)
-	if err != nil {
-		return fmt.Errorf("bad svcbdohpath: %w", err)
-	}
-	s.Template = string(template)
-	return nil
-}
-
-func (s *SVCBDoHPath) copy() SVCBKeyValue {
-	return &SVCBDoHPath{
-		Template: s.Template,
-	}
-}
-
-// The "ohttp" SvcParamKey is used to indicate that a service described in a SVCB RR
-// can be accessed as a target using an associated gateway.
-// Both the presentation and wire-format values for the "ohttp" parameter MUST be empty.
-//
-// See RFC 9460 (https://datatracker.ietf.org/doc/html/rfc9460/)
-// and RFC 9230 (https://datatracker.ietf.org/doc/html/rfc9230/)
-//
-// A basic example of using the dohpath option together with the alpn
-// option to indicate support for DNS over HTTPS on a certain path:
-//
-//	s := new(dns.SVCB)
-//	s.Hdr = dns.RR_Header{Name: ".", Rrtype: dns.TypeSVCB, Class: dns.ClassINET}
-//	e := new(dns.SVCBAlpn)
-//	e.Alpn = []string{"h2", "h3"}
-//	p := new(dns.SVCBOhttp)
-//	s.Value = append(s.Value, e, p)
-type SVCBOhttp struct{}
-
-func (*SVCBOhttp) Key() SVCBKey          { return SVCB_OHTTP }
-func (*SVCBOhttp) copy() SVCBKeyValue    { return &SVCBOhttp{} }
-func (*SVCBOhttp) pack() ([]byte, error) { return []byte{}, nil }
-func (*SVCBOhttp) String() string        { return "" }
-func (*SVCBOhttp) len() int              { return 0 }
-
-func (*SVCBOhttp) unpack(b []byte) error {
-	if len(b) != 0 {
-		return errors.New("bad svcbotthp: svcbotthp must have no value")
-	}
-	return nil
-}
-
-func (*SVCBOhttp) parse(b string) error {
-	if b != "" {
-		return errors.New("bad svcbotthp: svcbotthp must have no value")
-	}
-	return nil
-}
-
-// SVCBLocal pair is intended for experimental/private use. The key is recommended
-// to be in the range [SVCB_PRIVATE_LOWER, SVCB_PRIVATE_UPPER].
-// Basic use pattern for creating a keyNNNNN option:
-//
-//	h := new(dns.HTTPS)
-//	h.Hdr = dns.RR_Header{Name: ".", Rrtype: dns.TypeHTTPS, Class: dns.ClassINET}
-//	e := new(dns.SVCBLocal)
-//	e.KeyCode = 65400
-//	e.Data = []byte("abc")
-//	h.Value = append(h.Value, e)
-type SVCBLocal struct {
-	KeyCode SVCBKey // Never 65535 or any assigned keys.
-	Data    []byte  // All byte sequences are allowed.
-}
-
-func (s *SVCBLocal) Key() SVCBKey          { return s.KeyCode }
-func (s *SVCBLocal) String() string        { return svcbParamToStr(s.Data) }
-func (s *SVCBLocal) pack() ([]byte, error) { return cloneSlice(s.Data), nil }
-func (s *SVCBLocal) len() int              { return len(s.Data) }
-
-func (s *SVCBLocal) unpack(b []byte) error {
-	s.Data = cloneSlice(b)
-	return nil
-}
-
-func (s *SVCBLocal) parse(b string) error {
-	data, err := svcbParseParam(b)
-	if err != nil {
-		return fmt.Errorf("bad svcblocal: svcb private/experimental key %w", err)
-	}
-	s.Data = data
-	return nil
-}
-
-func (s *SVCBLocal) copy() SVCBKeyValue {
-	return &SVCBLocal{s.KeyCode, cloneSlice(s.Data)}
-}
-
-func (rr *SVCB) String() string {
-	s := rr.Hdr.String() +
-		strconv.Itoa(int(rr.Priority)) + " " +
-		sprintName(rr.Target)
-	for _, e := range rr.Value {
-		s += " " + e.Key().String() + "=\"" + e.String() + "\""
-	}
-	return s
-}
-
-// areSVCBPairArraysEqual checks if SVCBKeyValue arrays are equal after sorting their
-// copies. arrA and arrB have equal lengths, otherwise zduplicate.go wouldn't call this function.
-func areSVCBPairArraysEqual(a []SVCBKeyValue, b []SVCBKeyValue) bool {
-	a = cloneSlice(a)
-	b = cloneSlice(b)
-	sort.Slice(a, func(i, j int) bool { return a[i].Key() < a[j].Key() })
-	sort.Slice(b, func(i, j int) bool { return b[i].Key() < b[j].Key() })
-	for i, e := range a {
-		if e.Key() != b[i].Key() {
-			return false
-		}
-		b1, err1 := e.pack()
-		b2, err2 := b[i].pack()
-		if err1 != nil || err2 != nil || !bytes.Equal(b1, b2) {
-			return false
-		}
-	}
-	return true
-}
-
-// svcbParamStr converts the value of an SVCB parameter into a DNS presentation-format string.
-func svcbParamToStr(s []byte) string {
-	var str strings.Builder
-	str.Grow(4 * len(s))
-	for _, e := range s {
-		if ' ' <= e && e <= '~' {
-			switch e {
-			case '"', ';', ' ', '\\':
-				str.WriteByte('\\')
-				str.WriteByte(e)
-			default:
-				str.WriteByte(e)
-			}
-		} else {
-			str.WriteString(escapeByte(e))
-		}
-	}
-	return str.String()
-}
-
-// svcbParseParam parses a DNS presentation-format string into an SVCB parameter value.
-func svcbParseParam(b string) ([]byte, error) {
-	data := make([]byte, 0, len(b))
-	for i := 0; i < len(b); {
-		if b[i] != '\\' {
-			data = append(data, b[i])
-			i++
-			continue
-		}
-		if i+1 == len(b) {
-			return nil, errors.New("escape unterminated")
-		}
-		if isDigit(b[i+1]) {
-			if i+3 < len(b) && isDigit(b[i+2]) && isDigit(b[i+3]) {
-				a, err := strconv.ParseUint(b[i+1:i+4], 10, 8)
-				if err == nil {
-					i += 4
-					data = append(data, byte(a))
-					continue
-				}
-			}
-			return nil, errors.New("bad escaped octet")
-		} else {
-			data = append(data, b[i+1])
-			i += 2
-		}
-	}
-	return data, nil
-}
diff --git a/vendor/github.com/miekg/dns/tlsa.go b/vendor/github.com/miekg/dns/tlsa.go
deleted file mode 100644
index 4e07983b97..0000000000
--- a/vendor/github.com/miekg/dns/tlsa.go
+++ /dev/null
@@ -1,44 +0,0 @@
-package dns
-
-import (
-	"crypto/x509"
-	"net"
-	"strconv"
-)
-
-// Sign creates a TLSA record from an SSL certificate.
-func (r *TLSA) Sign(usage, selector, matchingType int, cert *x509.Certificate) (err error) {
-	r.Hdr.Rrtype = TypeTLSA
-	r.Usage = uint8(usage)
-	r.Selector = uint8(selector)
-	r.MatchingType = uint8(matchingType)
-
-	r.Certificate, err = CertificateToDANE(r.Selector, r.MatchingType, cert)
-	return err
-}
-
-// Verify verifies a TLSA record against an SSL certificate. If it is OK
-// a nil error is returned.
-func (r *TLSA) Verify(cert *x509.Certificate) error {
-	c, err := CertificateToDANE(r.Selector, r.MatchingType, cert)
-	if err != nil {
-		return err // Not also ErrSig?
-	}
-	if r.Certificate == c {
-		return nil
-	}
-	return ErrSig // ErrSig, really?
-}
-
-// TLSAName returns the ownername of a TLSA resource record as per the
-// rules specified in RFC 6698, Section 3.
-func TLSAName(name, service, network string) (string, error) {
-	if !IsFqdn(name) {
-		return "", ErrFqdn
-	}
-	p, err := net.LookupPort(network, service)
-	if err != nil {
-		return "", err
-	}
-	return "_" + strconv.Itoa(p) + "._" + network + "." + name, nil
-}
diff --git a/vendor/github.com/miekg/dns/tools.go b/vendor/github.com/miekg/dns/tools.go
deleted file mode 100644
index ccf8f6bfc7..0000000000
--- a/vendor/github.com/miekg/dns/tools.go
+++ /dev/null
@@ -1,10 +0,0 @@
-//go:build tools
-// +build tools
-
-// We include our tool dependencies for `go generate` here to ensure they're
-// properly tracked by the go tool. See the Go Wiki for the rationale behind this:
-// https://github.com/golang/go/wiki/Modules#how-can-i-track-tool-dependencies-for-a-module.
-
-package dns
-
-import _ "golang.org/x/tools/go/packages"
diff --git a/vendor/github.com/miekg/dns/tsig.go b/vendor/github.com/miekg/dns/tsig.go
deleted file mode 100644
index debfe2dd99..0000000000
--- a/vendor/github.com/miekg/dns/tsig.go
+++ /dev/null
@@ -1,456 +0,0 @@
-package dns
-
-import (
-	"crypto/hmac"
-	"crypto/sha1"
-	"crypto/sha256"
-	"crypto/sha512"
-	"encoding/binary"
-	"encoding/hex"
-	"hash"
-	"strconv"
-	"strings"
-	"time"
-)
-
-// HMAC hashing codes. These are transmitted as domain names.
-const (
-	HmacSHA1   = "hmac-sha1."
-	HmacSHA224 = "hmac-sha224."
-	HmacSHA256 = "hmac-sha256."
-	HmacSHA384 = "hmac-sha384."
-	HmacSHA512 = "hmac-sha512."
-
-	HmacMD5 = "hmac-md5.sig-alg.reg.int." // Deprecated: HmacMD5 is no longer supported.
-)
-
-// TsigProvider provides the API to plug-in a custom TSIG implementation.
-type TsigProvider interface {
-	// Generate is passed the DNS message to be signed and the partial TSIG RR. It returns the signature and nil, otherwise an error.
-	Generate(msg []byte, t *TSIG) ([]byte, error)
-	// Verify is passed the DNS message to be verified and the TSIG RR. If the signature is valid it will return nil, otherwise an error.
-	Verify(msg []byte, t *TSIG) error
-}
-
-type tsigHMACProvider string
-
-func (key tsigHMACProvider) Generate(msg []byte, t *TSIG) ([]byte, error) {
-	// If we barf here, the caller is to blame
-	rawsecret, err := fromBase64([]byte(key))
-	if err != nil {
-		return nil, err
-	}
-	var h hash.Hash
-	switch CanonicalName(t.Algorithm) {
-	case HmacSHA1:
-		h = hmac.New(sha1.New, rawsecret)
-	case HmacSHA224:
-		h = hmac.New(sha256.New224, rawsecret)
-	case HmacSHA256:
-		h = hmac.New(sha256.New, rawsecret)
-	case HmacSHA384:
-		h = hmac.New(sha512.New384, rawsecret)
-	case HmacSHA512:
-		h = hmac.New(sha512.New, rawsecret)
-	default:
-		return nil, ErrKeyAlg
-	}
-	h.Write(msg)
-	return h.Sum(nil), nil
-}
-
-func (key tsigHMACProvider) Verify(msg []byte, t *TSIG) error {
-	b, err := key.Generate(msg, t)
-	if err != nil {
-		return err
-	}
-	mac, err := hex.DecodeString(t.MAC)
-	if err != nil {
-		return err
-	}
-	if !hmac.Equal(b, mac) {
-		return ErrSig
-	}
-	return nil
-}
-
-type tsigSecretProvider map[string]string
-
-func (ts tsigSecretProvider) Generate(msg []byte, t *TSIG) ([]byte, error) {
-	key, ok := ts[t.Hdr.Name]
-	if !ok {
-		return nil, ErrSecret
-	}
-	return tsigHMACProvider(key).Generate(msg, t)
-}
-
-func (ts tsigSecretProvider) Verify(msg []byte, t *TSIG) error {
-	key, ok := ts[t.Hdr.Name]
-	if !ok {
-		return ErrSecret
-	}
-	return tsigHMACProvider(key).Verify(msg, t)
-}
-
-// TSIG is the RR the holds the transaction signature of a message.
-// See RFC 2845 and RFC 4635.
-type TSIG struct {
-	Hdr        RR_Header
-	Algorithm  string `dns:"domain-name"`
-	TimeSigned uint64 `dns:"uint48"`
-	Fudge      uint16
-	MACSize    uint16
-	MAC        string `dns:"size-hex:MACSize"`
-	OrigId     uint16
-	Error      uint16
-	OtherLen   uint16
-	OtherData  string `dns:"size-hex:OtherLen"`
-}
-
-// TSIG has no official presentation format, but this will suffice.
-
-func (rr *TSIG) String() string {
-	s := "\n;; TSIG PSEUDOSECTION:\n; " // add another semi-colon to signify TSIG does not have a presentation format
-	s += rr.Hdr.String() +
-		" " + rr.Algorithm +
-		" " + tsigTimeToString(rr.TimeSigned) +
-		" " + strconv.Itoa(int(rr.Fudge)) +
-		" " + strconv.Itoa(int(rr.MACSize)) +
-		" " + strings.ToUpper(rr.MAC) +
-		" " + strconv.Itoa(int(rr.OrigId)) +
-		" " + strconv.Itoa(int(rr.Error)) + // BIND prints NOERROR
-		" " + strconv.Itoa(int(rr.OtherLen)) +
-		" " + rr.OtherData
-	return s
-}
-
-func (*TSIG) parse(c *zlexer, origin string) *ParseError {
-	return &ParseError{err: "TSIG records do not have a presentation format"}
-}
-
-// The following values must be put in wireformat, so that the MAC can be calculated.
-// RFC 2845, section 3.4.2. TSIG Variables.
-type tsigWireFmt struct {
-	// From RR_Header
-	Name  string `dns:"domain-name"`
-	Class uint16
-	Ttl   uint32
-	// Rdata of the TSIG
-	Algorithm  string `dns:"domain-name"`
-	TimeSigned uint64 `dns:"uint48"`
-	Fudge      uint16
-	// MACSize, MAC and OrigId excluded
-	Error     uint16
-	OtherLen  uint16
-	OtherData string `dns:"size-hex:OtherLen"`
-}
-
-// If we have the MAC use this type to convert it to wiredata. Section 3.4.3. Request MAC
-type macWireFmt struct {
-	MACSize uint16
-	MAC     string `dns:"size-hex:MACSize"`
-}
-
-// 3.3. Time values used in TSIG calculations
-type timerWireFmt struct {
-	TimeSigned uint64 `dns:"uint48"`
-	Fudge      uint16
-}
-
-// TsigGenerate fills out the TSIG record attached to the message.
-// The message should contain a "stub" TSIG RR with the algorithm, key name
-// (owner name of the RR), time fudge (defaults to 300 seconds) and the current
-// time The TSIG MAC is saved in that Tsig RR. When TsigGenerate is called for
-// the first time requestMAC should be set to the empty string and timersOnly to
-// false.
-func TsigGenerate(m *Msg, secret, requestMAC string, timersOnly bool) ([]byte, string, error) {
-	return TsigGenerateWithProvider(m, tsigHMACProvider(secret), requestMAC, timersOnly)
-}
-
-// TsigGenerateWithProvider is similar to TsigGenerate, but allows for a custom TsigProvider.
-func TsigGenerateWithProvider(m *Msg, provider TsigProvider, requestMAC string, timersOnly bool) ([]byte, string, error) {
-	if m.IsTsig() == nil {
-		panic("dns: TSIG not last RR in additional")
-	}
-
-	rr := m.Extra[len(m.Extra)-1].(*TSIG)
-	m.Extra = m.Extra[0 : len(m.Extra)-1] // kill the TSIG from the msg
-	mbuf, err := m.Pack()
-	if err != nil {
-		return nil, "", err
-	}
-
-	buf, err := tsigBuffer(mbuf, rr, requestMAC, timersOnly)
-	if err != nil {
-		return nil, "", err
-	}
-
-	t := new(TSIG)
-	// Copy all TSIG fields except MAC, its size, and time signed which are filled when signing.
-	*t = *rr
-	t.TimeSigned = 0
-	t.MAC = ""
-	t.MACSize = 0
-
-	// Sign unless there is a key or MAC validation error (RFC 8945 5.3.2)
-	if rr.Error != RcodeBadKey && rr.Error != RcodeBadSig {
-		mac, err := provider.Generate(buf, rr)
-		if err != nil {
-			return nil, "", err
-		}
-		t.TimeSigned = rr.TimeSigned
-		t.MAC = hex.EncodeToString(mac)
-		t.MACSize = uint16(len(t.MAC) / 2) // Size is half!
-	}
-
-	tbuf := make([]byte, Len(t))
-	off, err := PackRR(t, tbuf, 0, nil, false)
-	if err != nil {
-		return nil, "", err
-	}
-	mbuf = append(mbuf, tbuf[:off]...)
-	// Update the ArCount directly in the buffer.
-	binary.BigEndian.PutUint16(mbuf[10:], uint16(len(m.Extra)+1))
-
-	return mbuf, t.MAC, nil
-}
-
-// TsigVerify verifies the TSIG on a message. If the signature does not
-// validate the returned error contains the cause. If the signature is OK, the
-// error is nil.
-func TsigVerify(msg []byte, secret, requestMAC string, timersOnly bool) error {
-	return tsigVerify(msg, tsigHMACProvider(secret), requestMAC, timersOnly, uint64(time.Now().Unix()))
-}
-
-// TsigVerifyWithProvider is similar to TsigVerify, but allows for a custom TsigProvider.
-func TsigVerifyWithProvider(msg []byte, provider TsigProvider, requestMAC string, timersOnly bool) error {
-	return tsigVerify(msg, provider, requestMAC, timersOnly, uint64(time.Now().Unix()))
-}
-
-// actual implementation of TsigVerify, taking the current time ('now') as a parameter for the convenience of tests.
-func tsigVerify(msg []byte, provider TsigProvider, requestMAC string, timersOnly bool, now uint64) error {
-	// Strip the TSIG from the incoming msg
-	stripped, tsig, err := stripTsig(msg)
-	if err != nil {
-		return err
-	}
-
-	buf, err := tsigBuffer(stripped, tsig, requestMAC, timersOnly)
-	if err != nil {
-		return err
-	}
-
-	if err := provider.Verify(buf, tsig); err != nil {
-		return err
-	}
-
-	// Fudge factor works both ways. A message can arrive before it was signed because
-	// of clock skew.
-	// We check this after verifying the signature, following draft-ietf-dnsop-rfc2845bis
-	// instead of RFC2845, in order to prevent a security vulnerability as reported in CVE-2017-3142/3143.
-	ti := now - tsig.TimeSigned
-	if now < tsig.TimeSigned {
-		ti = tsig.TimeSigned - now
-	}
-	if uint64(tsig.Fudge) < ti {
-		return ErrTime
-	}
-
-	return nil
-}
-
-// Create a wiredata buffer for the MAC calculation.
-func tsigBuffer(msgbuf []byte, rr *TSIG, requestMAC string, timersOnly bool) ([]byte, error) {
-	var buf []byte
-	if rr.TimeSigned == 0 {
-		rr.TimeSigned = uint64(time.Now().Unix())
-	}
-	if rr.Fudge == 0 {
-		rr.Fudge = 300 // Standard (RFC) default.
-	}
-
-	// Replace message ID in header with original ID from TSIG
-	binary.BigEndian.PutUint16(msgbuf[0:2], rr.OrigId)
-
-	if requestMAC != "" {
-		m := new(macWireFmt)
-		m.MACSize = uint16(len(requestMAC) / 2)
-		m.MAC = requestMAC
-		buf = make([]byte, len(requestMAC)) // long enough
-		n, err := packMacWire(m, buf)
-		if err != nil {
-			return nil, err
-		}
-		buf = buf[:n]
-	}
-
-	tsigvar := make([]byte, DefaultMsgSize)
-	if timersOnly {
-		tsig := new(timerWireFmt)
-		tsig.TimeSigned = rr.TimeSigned
-		tsig.Fudge = rr.Fudge
-		n, err := packTimerWire(tsig, tsigvar)
-		if err != nil {
-			return nil, err
-		}
-		tsigvar = tsigvar[:n]
-	} else {
-		tsig := new(tsigWireFmt)
-		tsig.Name = CanonicalName(rr.Hdr.Name)
-		tsig.Class = ClassANY
-		tsig.Ttl = rr.Hdr.Ttl
-		tsig.Algorithm = CanonicalName(rr.Algorithm)
-		tsig.TimeSigned = rr.TimeSigned
-		tsig.Fudge = rr.Fudge
-		tsig.Error = rr.Error
-		tsig.OtherLen = rr.OtherLen
-		tsig.OtherData = rr.OtherData
-		n, err := packTsigWire(tsig, tsigvar)
-		if err != nil {
-			return nil, err
-		}
-		tsigvar = tsigvar[:n]
-	}
-
-	if requestMAC != "" {
-		x := append(buf, msgbuf...)
-		buf = append(x, tsigvar...)
-	} else {
-		buf = append(msgbuf, tsigvar...)
-	}
-	return buf, nil
-}
-
-// Strip the TSIG from the raw message.
-func stripTsig(msg []byte) ([]byte, *TSIG, error) {
-	// Copied from msg.go's Unpack() Header, but modified.
-	var (
-		dh  Header
-		err error
-	)
-	off, tsigoff := 0, 0
-
-	if dh, off, err = unpackMsgHdr(msg, off); err != nil {
-		return nil, nil, err
-	}
-	if dh.Arcount == 0 {
-		return nil, nil, ErrNoSig
-	}
-
-	// Rcode, see msg.go Unpack()
-	if int(dh.Bits&0xF) == RcodeNotAuth {
-		return nil, nil, ErrAuth
-	}
-
-	for i := 0; i < int(dh.Qdcount); i++ {
-		_, off, err = unpackQuestion(msg, off)
-		if err != nil {
-			return nil, nil, err
-		}
-	}
-
-	_, off, err = unpackRRslice(int(dh.Ancount), msg, off)
-	if err != nil {
-		return nil, nil, err
-	}
-	_, off, err = unpackRRslice(int(dh.Nscount), msg, off)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	rr := new(TSIG)
-	var extra RR
-	for i := 0; i < int(dh.Arcount); i++ {
-		tsigoff = off
-		extra, off, err = UnpackRR(msg, off)
-		if err != nil {
-			return nil, nil, err
-		}
-		if extra.Header().Rrtype == TypeTSIG {
-			rr = extra.(*TSIG)
-			// Adjust Arcount.
-			arcount := binary.BigEndian.Uint16(msg[10:])
-			binary.BigEndian.PutUint16(msg[10:], arcount-1)
-			break
-		}
-	}
-	if rr == nil {
-		return nil, nil, ErrNoSig
-	}
-	return msg[:tsigoff], rr, nil
-}
-
-// Translate the TSIG time signed into a date. There is no
-// need for RFC1982 calculations as this date is 48 bits.
-func tsigTimeToString(t uint64) string {
-	ti := time.Unix(int64(t), 0).UTC()
-	return ti.Format("20060102150405")
-}
-
-func packTsigWire(tw *tsigWireFmt, msg []byte) (int, error) {
-	// copied from zmsg.go TSIG packing
-	// RR_Header
-	off, err := PackDomainName(tw.Name, msg, 0, nil, false)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(tw.Class, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint32(tw.Ttl, msg, off)
-	if err != nil {
-		return off, err
-	}
-
-	off, err = PackDomainName(tw.Algorithm, msg, off, nil, false)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint48(tw.TimeSigned, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(tw.Fudge, msg, off)
-	if err != nil {
-		return off, err
-	}
-
-	off, err = packUint16(tw.Error, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(tw.OtherLen, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringHex(tw.OtherData, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func packMacWire(mw *macWireFmt, msg []byte) (int, error) {
-	off, err := packUint16(mw.MACSize, msg, 0)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringHex(mw.MAC, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func packTimerWire(tw *timerWireFmt, msg []byte) (int, error) {
-	off, err := packUint48(tw.TimeSigned, msg, 0)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(tw.Fudge, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
diff --git a/vendor/github.com/miekg/dns/types.go b/vendor/github.com/miekg/dns/types.go
deleted file mode 100644
index f5067cd433..0000000000
--- a/vendor/github.com/miekg/dns/types.go
+++ /dev/null
@@ -1,1712 +0,0 @@
-package dns
-
-import (
-	"bytes"
-	"fmt"
-	"net"
-	"strconv"
-	"strings"
-	"time"
-)
-
-type (
-	// Type is a DNS type.
-	Type uint16
-	// Class is a DNS class.
-	Class uint16
-	// Name is a DNS domain name.
-	Name string
-)
-
-// Packet formats
-
-// Wire constants and supported types.
-const (
-	// valid RR_Header.Rrtype and Question.qtype
-
-	TypeNone       uint16 = 0
-	TypeA          uint16 = 1
-	TypeNS         uint16 = 2
-	TypeMD         uint16 = 3
-	TypeMF         uint16 = 4
-	TypeCNAME      uint16 = 5
-	TypeSOA        uint16 = 6
-	TypeMB         uint16 = 7
-	TypeMG         uint16 = 8
-	TypeMR         uint16 = 9
-	TypeNULL       uint16 = 10
-	TypePTR        uint16 = 12
-	TypeHINFO      uint16 = 13
-	TypeMINFO      uint16 = 14
-	TypeMX         uint16 = 15
-	TypeTXT        uint16 = 16
-	TypeRP         uint16 = 17
-	TypeAFSDB      uint16 = 18
-	TypeX25        uint16 = 19
-	TypeISDN       uint16 = 20
-	TypeRT         uint16 = 21
-	TypeNSAPPTR    uint16 = 23
-	TypeSIG        uint16 = 24
-	TypeKEY        uint16 = 25
-	TypePX         uint16 = 26
-	TypeGPOS       uint16 = 27
-	TypeAAAA       uint16 = 28
-	TypeLOC        uint16 = 29
-	TypeNXT        uint16 = 30
-	TypeEID        uint16 = 31
-	TypeNIMLOC     uint16 = 32
-	TypeSRV        uint16 = 33
-	TypeATMA       uint16 = 34
-	TypeNAPTR      uint16 = 35
-	TypeKX         uint16 = 36
-	TypeCERT       uint16 = 37
-	TypeDNAME      uint16 = 39
-	TypeOPT        uint16 = 41 // EDNS
-	TypeAPL        uint16 = 42
-	TypeDS         uint16 = 43
-	TypeSSHFP      uint16 = 44
-	TypeIPSECKEY   uint16 = 45
-	TypeRRSIG      uint16 = 46
-	TypeNSEC       uint16 = 47
-	TypeDNSKEY     uint16 = 48
-	TypeDHCID      uint16 = 49
-	TypeNSEC3      uint16 = 50
-	TypeNSEC3PARAM uint16 = 51
-	TypeTLSA       uint16 = 52
-	TypeSMIMEA     uint16 = 53
-	TypeHIP        uint16 = 55
-	TypeNINFO      uint16 = 56
-	TypeRKEY       uint16 = 57
-	TypeTALINK     uint16 = 58
-	TypeCDS        uint16 = 59
-	TypeCDNSKEY    uint16 = 60
-	TypeOPENPGPKEY uint16 = 61
-	TypeCSYNC      uint16 = 62
-	TypeZONEMD     uint16 = 63
-	TypeSVCB       uint16 = 64
-	TypeHTTPS      uint16 = 65
-	TypeSPF        uint16 = 99
-	TypeUINFO      uint16 = 100
-	TypeUID        uint16 = 101
-	TypeGID        uint16 = 102
-	TypeUNSPEC     uint16 = 103
-	TypeNID        uint16 = 104
-	TypeL32        uint16 = 105
-	TypeL64        uint16 = 106
-	TypeLP         uint16 = 107
-	TypeEUI48      uint16 = 108
-	TypeEUI64      uint16 = 109
-	TypeNXNAME     uint16 = 128
-	TypeURI        uint16 = 256
-	TypeCAA        uint16 = 257
-	TypeAVC        uint16 = 258
-	TypeAMTRELAY   uint16 = 260
-	TypeRESINFO    uint16 = 261
-
-	TypeTKEY uint16 = 249
-	TypeTSIG uint16 = 250
-
-	// valid Question.Qtype only
-	TypeIXFR  uint16 = 251
-	TypeAXFR  uint16 = 252
-	TypeMAILB uint16 = 253
-	TypeMAILA uint16 = 254
-	TypeANY   uint16 = 255
-
-	TypeTA       uint16 = 32768
-	TypeDLV      uint16 = 32769
-	TypeReserved uint16 = 65535
-
-	// valid Question.Qclass
-	ClassINET   = 1
-	ClassCSNET  = 2
-	ClassCHAOS  = 3
-	ClassHESIOD = 4
-	ClassNONE   = 254
-	ClassANY    = 255
-
-	// Message Response Codes, see https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml
-	RcodeSuccess                    = 0  // NoError   - No Error                          [DNS]
-	RcodeFormatError                = 1  // FormErr   - Format Error                      [DNS]
-	RcodeServerFailure              = 2  // ServFail  - Server Failure                    [DNS]
-	RcodeNameError                  = 3  // NXDomain  - Non-Existent Domain               [DNS]
-	RcodeNotImplemented             = 4  // NotImp    - Not Implemented                   [DNS]
-	RcodeRefused                    = 5  // Refused   - Query Refused                     [DNS]
-	RcodeYXDomain                   = 6  // YXDomain  - Name Exists when it should not    [DNS Update]
-	RcodeYXRrset                    = 7  // YXRRSet   - RR Set Exists when it should not  [DNS Update]
-	RcodeNXRrset                    = 8  // NXRRSet   - RR Set that should exist does not [DNS Update]
-	RcodeNotAuth                    = 9  // NotAuth   - Server Not Authoritative for zone [DNS Update]
-	RcodeNotZone                    = 10 // NotZone   - Name not contained in zone        [DNS Update/TSIG]
-	RcodeStatefulTypeNotImplemented = 11 // DSOTypeNI - DSO-TYPE not implemented          [DNS Stateful Operations] https://www.rfc-editor.org/rfc/rfc8490.html#section-10.2
-	RcodeBadSig                     = 16 // BADSIG    - TSIG Signature Failure            [TSIG]  https://www.rfc-editor.org/rfc/rfc6895.html#section-2.3
-	RcodeBadVers                    = 16 // BADVERS   - Bad OPT Version                   [EDNS0] https://www.rfc-editor.org/rfc/rfc6895.html#section-2.3
-	RcodeBadKey                     = 17 // BADKEY    - Key not recognized                [TSIG]
-	RcodeBadTime                    = 18 // BADTIME   - Signature out of time window      [TSIG]
-	RcodeBadMode                    = 19 // BADMODE   - Bad TKEY Mode                     [TKEY]
-	RcodeBadName                    = 20 // BADNAME   - Duplicate key name                [TKEY]
-	RcodeBadAlg                     = 21 // BADALG    - Algorithm not supported           [TKEY]
-	RcodeBadTrunc                   = 22 // BADTRUNC  - Bad Truncation                    [TSIG]
-	RcodeBadCookie                  = 23 // BADCOOKIE - Bad/missing Server Cookie         [DNS Cookies]
-
-	// Message Opcodes. There is no 3.
-	OpcodeQuery    = 0
-	OpcodeIQuery   = 1
-	OpcodeStatus   = 2
-	OpcodeNotify   = 4
-	OpcodeUpdate   = 5
-	OpcodeStateful = 6
-)
-
-// Used in ZONEMD https://tools.ietf.org/html/rfc8976
-const (
-	ZoneMDSchemeSimple = 1
-
-	ZoneMDHashAlgSHA384 = 1
-	ZoneMDHashAlgSHA512 = 2
-)
-
-// Used in IPSEC https://datatracker.ietf.org/doc/html/rfc4025#section-2.3
-const (
-	IPSECGatewayNone uint8 = iota
-	IPSECGatewayIPv4
-	IPSECGatewayIPv6
-	IPSECGatewayHost
-)
-
-// Used in AMTRELAY https://datatracker.ietf.org/doc/html/rfc8777#section-4.2.3
-const (
-	AMTRELAYNone = IPSECGatewayNone
-	AMTRELAYIPv4 = IPSECGatewayIPv4
-	AMTRELAYIPv6 = IPSECGatewayIPv6
-	AMTRELAYHost = IPSECGatewayHost
-)
-
-// Stateful types as defined in RFC 8490.
-const (
-	StatefulTypeKeepAlive uint16 = iota + 1
-	StatefulTypeRetryDelay
-	StatefulTypeEncryptionPadding
-)
-
-var StatefulTypeToString = map[uint16]string{
-	StatefulTypeKeepAlive:         "KeepAlive",
-	StatefulTypeRetryDelay:        "RetryDelay",
-	StatefulTypeEncryptionPadding: "EncryptionPadding",
-}
-
-// Header is the wire format for the DNS packet header.
-type Header struct {
-	Id                                 uint16
-	Bits                               uint16
-	Qdcount, Ancount, Nscount, Arcount uint16
-}
-
-const (
-	headerSize = 12
-
-	// Header.Bits
-	_QR = 1 << 15 // query/response (response=1)
-	_AA = 1 << 10 // authoritative
-	_TC = 1 << 9  // truncated
-	_RD = 1 << 8  // recursion desired
-	_RA = 1 << 7  // recursion available
-	_Z  = 1 << 6  // Z
-	_AD = 1 << 5  // authenticated data
-	_CD = 1 << 4  // checking disabled
-)
-
-// Various constants used in the LOC RR. See RFC 1876.
-const (
-	LOC_EQUATOR       = 1 << 31 // RFC 1876, Section 2.
-	LOC_PRIMEMERIDIAN = 1 << 31 // RFC 1876, Section 2.
-	LOC_HOURS         = 60 * 1000
-	LOC_DEGREES       = 60 * LOC_HOURS
-	LOC_ALTITUDEBASE  = 100000
-)
-
-// Different Certificate Types, see RFC 4398, Section 2.1
-const (
-	CertPKIX = 1 + iota
-	CertSPKI
-	CertPGP
-	CertIPIX
-	CertISPKI
-	CertIPGP
-	CertACPKIX
-	CertIACPKIX
-	CertURI = 253
-	CertOID = 254
-)
-
-// CertTypeToString converts the Cert Type to its string representation.
-// See RFC 4398 and RFC 6944.
-var CertTypeToString = map[uint16]string{
-	CertPKIX:    "PKIX",
-	CertSPKI:    "SPKI",
-	CertPGP:     "PGP",
-	CertIPIX:    "IPIX",
-	CertISPKI:   "ISPKI",
-	CertIPGP:    "IPGP",
-	CertACPKIX:  "ACPKIX",
-	CertIACPKIX: "IACPKIX",
-	CertURI:     "URI",
-	CertOID:     "OID",
-}
-
-// Prefix for IPv4 encoded as IPv6 address
-const ipv4InIPv6Prefix = "::ffff:"
-
-//go:generate go run types_generate.go
-
-// Question holds a DNS question. Usually there is just one. While the
-// original DNS RFCs allow multiple questions in the question section of a
-// message, in practice it never works. Because most DNS servers see multiple
-// questions as an error, it is recommended to only have one question per
-// message.
-type Question struct {
-	Name   string `dns:"cdomain-name"` // "cdomain-name" specifies encoding (and may be compressed)
-	Qtype  uint16
-	Qclass uint16
-}
-
-func (q *Question) len(off int, compression map[string]struct{}) int {
-	l := domainNameLen(q.Name, off, compression, true)
-	l += 2 + 2
-	return l
-}
-
-func (q *Question) String() (s string) {
-	// prefix with ; (as in dig)
-	s = ";" + sprintName(q.Name) + "\t"
-	s += Class(q.Qclass).String() + "\t"
-	s += " " + Type(q.Qtype).String()
-	return s
-}
-
-// ANY is a wild card record. See RFC 1035, Section 3.2.3. ANY is named "*" there.
-// The ANY records can be (ab)used to create resource records without any rdata, that
-// can be used in dynamic update requests. Basic use pattern:
-//
-//	a := &ANY{RR_Header{
-//		Name:   "example.org.",
-//		Rrtype: TypeA,
-//		Class:  ClassINET,
-//	}}
-//
-// Results in an A record without rdata.
-type ANY struct {
-	Hdr RR_Header
-	// Does not have any rdata.
-}
-
-func (rr *ANY) String() string { return rr.Hdr.String() }
-
-func (*ANY) parse(c *zlexer, origin string) *ParseError {
-	return &ParseError{err: "ANY records do not have a presentation format"}
-}
-
-// NULL RR. See RFC 1035.
-type NULL struct {
-	Hdr  RR_Header
-	Data string `dns:"any"`
-}
-
-func (rr *NULL) String() string {
-	// There is no presentation format; prefix string with a comment.
-	return ";" + rr.Hdr.String() + rr.Data
-}
-
-func (*NULL) parse(c *zlexer, origin string) *ParseError {
-	return &ParseError{err: "NULL records do not have a presentation format"}
-}
-
-// NXNAME is a meta record. See https://www.iana.org/go/draft-ietf-dnsop-compact-denial-of-existence-04
-// Reference: https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml
-type NXNAME struct {
-	Hdr RR_Header
-	// Does not have any rdata
-}
-
-func (rr *NXNAME) String() string { return rr.Hdr.String() }
-
-func (*NXNAME) parse(c *zlexer, origin string) *ParseError {
-	return &ParseError{err: "NXNAME records do not have a presentation format"}
-}
-
-// CNAME RR. See RFC 1034.
-type CNAME struct {
-	Hdr    RR_Header
-	Target string `dns:"cdomain-name"`
-}
-
-func (rr *CNAME) String() string { return rr.Hdr.String() + sprintName(rr.Target) }
-
-// HINFO RR. See RFC 1034.
-type HINFO struct {
-	Hdr RR_Header
-	Cpu string
-	Os  string
-}
-
-func (rr *HINFO) String() string {
-	return rr.Hdr.String() + sprintTxt([]string{rr.Cpu, rr.Os})
-}
-
-// MB RR. See RFC 1035.
-type MB struct {
-	Hdr RR_Header
-	Mb  string `dns:"cdomain-name"`
-}
-
-func (rr *MB) String() string { return rr.Hdr.String() + sprintName(rr.Mb) }
-
-// MG RR. See RFC 1035.
-type MG struct {
-	Hdr RR_Header
-	Mg  string `dns:"cdomain-name"`
-}
-
-func (rr *MG) String() string { return rr.Hdr.String() + sprintName(rr.Mg) }
-
-// MINFO RR. See RFC 1035.
-type MINFO struct {
-	Hdr   RR_Header
-	Rmail string `dns:"cdomain-name"`
-	Email string `dns:"cdomain-name"`
-}
-
-func (rr *MINFO) String() string {
-	return rr.Hdr.String() + sprintName(rr.Rmail) + " " + sprintName(rr.Email)
-}
-
-// MR RR. See RFC 1035.
-type MR struct {
-	Hdr RR_Header
-	Mr  string `dns:"cdomain-name"`
-}
-
-func (rr *MR) String() string {
-	return rr.Hdr.String() + sprintName(rr.Mr)
-}
-
-// MF RR. See RFC 1035.
-type MF struct {
-	Hdr RR_Header
-	Mf  string `dns:"cdomain-name"`
-}
-
-func (rr *MF) String() string {
-	return rr.Hdr.String() + sprintName(rr.Mf)
-}
-
-// MD RR. See RFC 1035.
-type MD struct {
-	Hdr RR_Header
-	Md  string `dns:"cdomain-name"`
-}
-
-func (rr *MD) String() string {
-	return rr.Hdr.String() + sprintName(rr.Md)
-}
-
-// MX RR. See RFC 1035.
-type MX struct {
-	Hdr        RR_Header
-	Preference uint16
-	Mx         string `dns:"cdomain-name"`
-}
-
-func (rr *MX) String() string {
-	return rr.Hdr.String() + strconv.Itoa(int(rr.Preference)) + " " + sprintName(rr.Mx)
-}
-
-// AFSDB RR. See RFC 1183.
-type AFSDB struct {
-	Hdr      RR_Header
-	Subtype  uint16
-	Hostname string `dns:"domain-name"`
-}
-
-func (rr *AFSDB) String() string {
-	return rr.Hdr.String() + strconv.Itoa(int(rr.Subtype)) + " " + sprintName(rr.Hostname)
-}
-
-// X25 RR. See RFC 1183, Section 3.1.
-type X25 struct {
-	Hdr         RR_Header
-	PSDNAddress string
-}
-
-func (rr *X25) String() string {
-	return rr.Hdr.String() + rr.PSDNAddress
-}
-
-// ISDN RR. See RFC 1183, Section 3.2.
-type ISDN struct {
-	Hdr        RR_Header
-	Address    string
-	SubAddress string
-}
-
-func (rr *ISDN) String() string {
-	return rr.Hdr.String() + sprintTxt([]string{rr.Address, rr.SubAddress})
-}
-
-// RT RR. See RFC 1183, Section 3.3.
-type RT struct {
-	Hdr        RR_Header
-	Preference uint16
-	Host       string `dns:"domain-name"` // RFC 3597 prohibits compressing records not defined in RFC 1035.
-}
-
-func (rr *RT) String() string {
-	return rr.Hdr.String() + strconv.Itoa(int(rr.Preference)) + " " + sprintName(rr.Host)
-}
-
-// NS RR. See RFC 1035.
-type NS struct {
-	Hdr RR_Header
-	Ns  string `dns:"cdomain-name"`
-}
-
-func (rr *NS) String() string {
-	return rr.Hdr.String() + sprintName(rr.Ns)
-}
-
-// PTR RR. See RFC 1035.
-type PTR struct {
-	Hdr RR_Header
-	Ptr string `dns:"cdomain-name"`
-}
-
-func (rr *PTR) String() string {
-	return rr.Hdr.String() + sprintName(rr.Ptr)
-}
-
-// RP RR. See RFC 1138, Section 2.2.
-type RP struct {
-	Hdr  RR_Header
-	Mbox string `dns:"domain-name"`
-	Txt  string `dns:"domain-name"`
-}
-
-func (rr *RP) String() string {
-	return rr.Hdr.String() + sprintName(rr.Mbox) + " " + sprintName(rr.Txt)
-}
-
-// SOA RR. See RFC 1035.
-type SOA struct {
-	Hdr     RR_Header
-	Ns      string `dns:"cdomain-name"`
-	Mbox    string `dns:"cdomain-name"`
-	Serial  uint32
-	Refresh uint32
-	Retry   uint32
-	Expire  uint32
-	Minttl  uint32
-}
-
-func (rr *SOA) String() string {
-	return rr.Hdr.String() + sprintName(rr.Ns) + " " + sprintName(rr.Mbox) +
-		" " + strconv.FormatInt(int64(rr.Serial), 10) +
-		" " + strconv.FormatInt(int64(rr.Refresh), 10) +
-		" " + strconv.FormatInt(int64(rr.Retry), 10) +
-		" " + strconv.FormatInt(int64(rr.Expire), 10) +
-		" " + strconv.FormatInt(int64(rr.Minttl), 10)
-}
-
-// TXT RR. See RFC 1035.
-type TXT struct {
-	Hdr RR_Header
-	Txt []string `dns:"txt"`
-}
-
-func (rr *TXT) String() string { return rr.Hdr.String() + sprintTxt(rr.Txt) }
-
-func sprintName(s string) string {
-	var dst strings.Builder
-
-	for i := 0; i < len(s); {
-		if s[i] == '.' {
-			if dst.Len() != 0 {
-				dst.WriteByte('.')
-			}
-			i++
-			continue
-		}
-
-		b, n := nextByte(s, i)
-		if n == 0 {
-			// Drop "dangling" incomplete escapes.
-			if dst.Len() == 0 {
-				return s[:i]
-			}
-			break
-		}
-		if isDomainNameLabelSpecial(b) {
-			if dst.Len() == 0 {
-				dst.Grow(len(s) * 2)
-				dst.WriteString(s[:i])
-			}
-			dst.WriteByte('\\')
-			dst.WriteByte(b)
-		} else if b < ' ' || b > '~' { // unprintable, use \DDD
-			if dst.Len() == 0 {
-				dst.Grow(len(s) * 2)
-				dst.WriteString(s[:i])
-			}
-			dst.WriteString(escapeByte(b))
-		} else {
-			if dst.Len() != 0 {
-				dst.WriteByte(b)
-			}
-		}
-		i += n
-	}
-	if dst.Len() == 0 {
-		return s
-	}
-	return dst.String()
-}
-
-func sprintTxtOctet(s string) string {
-	var dst strings.Builder
-	dst.Grow(2 + len(s))
-	dst.WriteByte('"')
-	for i := 0; i < len(s); {
-		if i+1 < len(s) && s[i] == '\\' && s[i+1] == '.' {
-			dst.WriteString(s[i : i+2])
-			i += 2
-			continue
-		}
-
-		b, n := nextByte(s, i)
-		if n == 0 {
-			i++ // dangling back slash
-		} else {
-			writeTXTStringByte(&dst, b)
-		}
-		i += n
-	}
-	dst.WriteByte('"')
-	return dst.String()
-}
-
-func sprintTxt(txt []string) string {
-	var out strings.Builder
-	for i, s := range txt {
-		out.Grow(3 + len(s))
-		if i > 0 {
-			out.WriteString(` "`)
-		} else {
-			out.WriteByte('"')
-		}
-		for j := 0; j < len(s); {
-			b, n := nextByte(s, j)
-			if n == 0 {
-				break
-			}
-			writeTXTStringByte(&out, b)
-			j += n
-		}
-		out.WriteByte('"')
-	}
-	return out.String()
-}
-
-func writeTXTStringByte(s *strings.Builder, b byte) {
-	switch {
-	case b == '"' || b == '\\':
-		s.WriteByte('\\')
-		s.WriteByte(b)
-	case b < ' ' || b > '~':
-		s.WriteString(escapeByte(b))
-	default:
-		s.WriteByte(b)
-	}
-}
-
-const (
-	escapedByteSmall = "" +
-		`\000\001\002\003\004\005\006\007\008\009` +
-		`\010\011\012\013\014\015\016\017\018\019` +
-		`\020\021\022\023\024\025\026\027\028\029` +
-		`\030\031`
-	escapedByteLarge = `\127\128\129` +
-		`\130\131\132\133\134\135\136\137\138\139` +
-		`\140\141\142\143\144\145\146\147\148\149` +
-		`\150\151\152\153\154\155\156\157\158\159` +
-		`\160\161\162\163\164\165\166\167\168\169` +
-		`\170\171\172\173\174\175\176\177\178\179` +
-		`\180\181\182\183\184\185\186\187\188\189` +
-		`\190\191\192\193\194\195\196\197\198\199` +
-		`\200\201\202\203\204\205\206\207\208\209` +
-		`\210\211\212\213\214\215\216\217\218\219` +
-		`\220\221\222\223\224\225\226\227\228\229` +
-		`\230\231\232\233\234\235\236\237\238\239` +
-		`\240\241\242\243\244\245\246\247\248\249` +
-		`\250\251\252\253\254\255`
-)
-
-// escapeByte returns the \DDD escaping of b which must
-// satisfy b < ' ' || b > '~'.
-func escapeByte(b byte) string {
-	if b < ' ' {
-		return escapedByteSmall[b*4 : b*4+4]
-	}
-
-	b -= '~' + 1
-	// The cast here is needed as b*4 may overflow byte.
-	return escapedByteLarge[int(b)*4 : int(b)*4+4]
-}
-
-// isDomainNameLabelSpecial returns true if
-// a domain name label byte should be prefixed
-// with an escaping backslash.
-func isDomainNameLabelSpecial(b byte) bool {
-	switch b {
-	case '.', ' ', '\'', '@', ';', '(', ')', '"', '\\':
-		return true
-	}
-	return false
-}
-
-func nextByte(s string, offset int) (byte, int) {
-	if offset >= len(s) {
-		return 0, 0
-	}
-	if s[offset] != '\\' {
-		// not an escape sequence
-		return s[offset], 1
-	}
-	switch len(s) - offset {
-	case 1: // dangling escape
-		return 0, 0
-	case 2, 3: // too short to be \ddd
-	default: // maybe \ddd
-		if isDDD(s[offset+1:]) {
-			return dddToByte(s[offset+1:]), 4
-		}
-	}
-	// not \ddd, just an RFC 1035 "quoted" character
-	return s[offset+1], 2
-}
-
-// SPF RR. See RFC 4408, Section 3.1.1.
-type SPF struct {
-	Hdr RR_Header
-	Txt []string `dns:"txt"`
-}
-
-func (rr *SPF) String() string { return rr.Hdr.String() + sprintTxt(rr.Txt) }
-
-// AVC RR. See https://www.iana.org/assignments/dns-parameters/AVC/avc-completed-template.
-type AVC struct {
-	Hdr RR_Header
-	Txt []string `dns:"txt"`
-}
-
-func (rr *AVC) String() string { return rr.Hdr.String() + sprintTxt(rr.Txt) }
-
-// SRV RR. See RFC 2782.
-type SRV struct {
-	Hdr      RR_Header
-	Priority uint16
-	Weight   uint16
-	Port     uint16
-	Target   string `dns:"domain-name"`
-}
-
-func (rr *SRV) String() string {
-	return rr.Hdr.String() +
-		strconv.Itoa(int(rr.Priority)) + " " +
-		strconv.Itoa(int(rr.Weight)) + " " +
-		strconv.Itoa(int(rr.Port)) + " " + sprintName(rr.Target)
-}
-
-// NAPTR RR. See RFC 2915.
-type NAPTR struct {
-	Hdr         RR_Header
-	Order       uint16
-	Preference  uint16
-	Flags       string
-	Service     string
-	Regexp      string
-	Replacement string `dns:"domain-name"`
-}
-
-func (rr *NAPTR) String() string {
-	return rr.Hdr.String() +
-		strconv.Itoa(int(rr.Order)) + " " +
-		strconv.Itoa(int(rr.Preference)) + " " +
-		"\"" + rr.Flags + "\" " +
-		"\"" + rr.Service + "\" " +
-		"\"" + rr.Regexp + "\" " +
-		rr.Replacement
-}
-
-// CERT RR. See RFC 4398.
-type CERT struct {
-	Hdr         RR_Header
-	Type        uint16
-	KeyTag      uint16
-	Algorithm   uint8
-	Certificate string `dns:"base64"`
-}
-
-func (rr *CERT) String() string {
-	var (
-		ok                  bool
-		certtype, algorithm string
-	)
-	if certtype, ok = CertTypeToString[rr.Type]; !ok {
-		certtype = strconv.Itoa(int(rr.Type))
-	}
-	if algorithm, ok = AlgorithmToString[rr.Algorithm]; !ok {
-		algorithm = strconv.Itoa(int(rr.Algorithm))
-	}
-	return rr.Hdr.String() + certtype +
-		" " + strconv.Itoa(int(rr.KeyTag)) +
-		" " + algorithm +
-		" " + rr.Certificate
-}
-
-// DNAME RR. See RFC 2672.
-type DNAME struct {
-	Hdr    RR_Header
-	Target string `dns:"domain-name"`
-}
-
-func (rr *DNAME) String() string {
-	return rr.Hdr.String() + sprintName(rr.Target)
-}
-
-// A RR. See RFC 1035.
-type A struct {
-	Hdr RR_Header
-	A   net.IP `dns:"a"`
-}
-
-func (rr *A) String() string {
-	if rr.A == nil {
-		return rr.Hdr.String()
-	}
-	return rr.Hdr.String() + rr.A.String()
-}
-
-// AAAA RR. See RFC 3596.
-type AAAA struct {
-	Hdr  RR_Header
-	AAAA net.IP `dns:"aaaa"`
-}
-
-func (rr *AAAA) String() string {
-	if rr.AAAA == nil {
-		return rr.Hdr.String()
-	}
-
-	if rr.AAAA.To4() != nil {
-		return rr.Hdr.String() + ipv4InIPv6Prefix + rr.AAAA.String()
-	}
-
-	return rr.Hdr.String() + rr.AAAA.String()
-}
-
-// PX RR. See RFC 2163.
-type PX struct {
-	Hdr        RR_Header
-	Preference uint16
-	Map822     string `dns:"domain-name"`
-	Mapx400    string `dns:"domain-name"`
-}
-
-func (rr *PX) String() string {
-	return rr.Hdr.String() + strconv.Itoa(int(rr.Preference)) + " " + sprintName(rr.Map822) + " " + sprintName(rr.Mapx400)
-}
-
-// GPOS RR. See RFC 1712.
-type GPOS struct {
-	Hdr       RR_Header
-	Longitude string
-	Latitude  string
-	Altitude  string
-}
-
-func (rr *GPOS) String() string {
-	return rr.Hdr.String() + rr.Longitude + " " + rr.Latitude + " " + rr.Altitude
-}
-
-// LOC RR. See RFC 1876.
-type LOC struct {
-	Hdr       RR_Header
-	Version   uint8
-	Size      uint8
-	HorizPre  uint8
-	VertPre   uint8
-	Latitude  uint32
-	Longitude uint32
-	Altitude  uint32
-}
-
-// cmToM takes a cm value expressed in RFC 1876 SIZE mantissa/exponent
-// format and returns a string in m (two decimals for the cm).
-func cmToM(x uint8) string {
-	m := x & 0xf0 >> 4
-	e := x & 0x0f
-
-	if e < 2 {
-		if e == 1 {
-			m *= 10
-		}
-
-		return fmt.Sprintf("0.%02d", m)
-	}
-
-	s := fmt.Sprintf("%d", m)
-	for e > 2 {
-		s += "0"
-		e--
-	}
-	return s
-}
-
-func (rr *LOC) String() string {
-	s := rr.Hdr.String()
-
-	lat := rr.Latitude
-	ns := "N"
-	if lat > LOC_EQUATOR {
-		lat = lat - LOC_EQUATOR
-	} else {
-		ns = "S"
-		lat = LOC_EQUATOR - lat
-	}
-	h := lat / LOC_DEGREES
-	lat = lat % LOC_DEGREES
-	m := lat / LOC_HOURS
-	lat = lat % LOC_HOURS
-	s += fmt.Sprintf("%02d %02d %0.3f %s ", h, m, float64(lat)/1000, ns)
-
-	lon := rr.Longitude
-	ew := "E"
-	if lon > LOC_PRIMEMERIDIAN {
-		lon = lon - LOC_PRIMEMERIDIAN
-	} else {
-		ew = "W"
-		lon = LOC_PRIMEMERIDIAN - lon
-	}
-	h = lon / LOC_DEGREES
-	lon = lon % LOC_DEGREES
-	m = lon / LOC_HOURS
-	lon = lon % LOC_HOURS
-	s += fmt.Sprintf("%02d %02d %0.3f %s ", h, m, float64(lon)/1000, ew)
-
-	alt := float64(rr.Altitude) / 100
-	alt -= LOC_ALTITUDEBASE
-	if rr.Altitude%100 != 0 {
-		s += fmt.Sprintf("%.2fm ", alt)
-	} else {
-		s += fmt.Sprintf("%.0fm ", alt)
-	}
-
-	s += cmToM(rr.Size) + "m "
-	s += cmToM(rr.HorizPre) + "m "
-	s += cmToM(rr.VertPre) + "m"
-	return s
-}
-
-// SIG RR. See RFC 2535. The SIG RR is identical to RRSIG and nowadays only used for SIG(0), See RFC 2931.
-type SIG struct {
-	RRSIG
-}
-
-// RRSIG RR. See RFC 4034 and RFC 3755.
-type RRSIG struct {
-	Hdr         RR_Header
-	TypeCovered uint16
-	Algorithm   uint8
-	Labels      uint8
-	OrigTtl     uint32
-	Expiration  uint32
-	Inception   uint32
-	KeyTag      uint16
-	SignerName  string `dns:"domain-name"`
-	Signature   string `dns:"base64"`
-}
-
-func (rr *RRSIG) String() string {
-	s := rr.Hdr.String()
-	s += Type(rr.TypeCovered).String()
-	s += " " + strconv.Itoa(int(rr.Algorithm)) +
-		" " + strconv.Itoa(int(rr.Labels)) +
-		" " + strconv.FormatInt(int64(rr.OrigTtl), 10) +
-		" " + TimeToString(rr.Expiration) +
-		" " + TimeToString(rr.Inception) +
-		" " + strconv.Itoa(int(rr.KeyTag)) +
-		" " + sprintName(rr.SignerName) +
-		" " + rr.Signature
-	return s
-}
-
-// NXT RR. See RFC 2535.
-type NXT struct {
-	NSEC
-}
-
-// NSEC RR. See RFC 4034 and RFC 3755.
-type NSEC struct {
-	Hdr        RR_Header
-	NextDomain string   `dns:"domain-name"`
-	TypeBitMap []uint16 `dns:"nsec"`
-}
-
-func (rr *NSEC) String() string {
-	s := rr.Hdr.String() + sprintName(rr.NextDomain)
-	for _, t := range rr.TypeBitMap {
-		s += " " + Type(t).String()
-	}
-	return s
-}
-
-func (rr *NSEC) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += domainNameLen(rr.NextDomain, off+l, compression, false)
-	l += typeBitMapLen(rr.TypeBitMap)
-	return l
-}
-
-// DLV RR. See RFC 4431.
-type DLV struct{ DS }
-
-// CDS RR. See RFC 7344.
-type CDS struct{ DS }
-
-// DS RR. See RFC 4034 and RFC 3658.
-type DS struct {
-	Hdr        RR_Header
-	KeyTag     uint16
-	Algorithm  uint8
-	DigestType uint8
-	Digest     string `dns:"hex"`
-}
-
-func (rr *DS) String() string {
-	return rr.Hdr.String() + strconv.Itoa(int(rr.KeyTag)) +
-		" " + strconv.Itoa(int(rr.Algorithm)) +
-		" " + strconv.Itoa(int(rr.DigestType)) +
-		" " + strings.ToUpper(rr.Digest)
-}
-
-// KX RR. See RFC 2230.
-type KX struct {
-	Hdr        RR_Header
-	Preference uint16
-	Exchanger  string `dns:"domain-name"`
-}
-
-func (rr *KX) String() string {
-	return rr.Hdr.String() + strconv.Itoa(int(rr.Preference)) +
-		" " + sprintName(rr.Exchanger)
-}
-
-// TA RR. See http://www.watson.org/~weiler/INI1999-19.pdf.
-type TA struct {
-	Hdr        RR_Header
-	KeyTag     uint16
-	Algorithm  uint8
-	DigestType uint8
-	Digest     string `dns:"hex"`
-}
-
-func (rr *TA) String() string {
-	return rr.Hdr.String() + strconv.Itoa(int(rr.KeyTag)) +
-		" " + strconv.Itoa(int(rr.Algorithm)) +
-		" " + strconv.Itoa(int(rr.DigestType)) +
-		" " + strings.ToUpper(rr.Digest)
-}
-
-// TALINK RR. See https://www.iana.org/assignments/dns-parameters/TALINK/talink-completed-template.
-type TALINK struct {
-	Hdr          RR_Header
-	PreviousName string `dns:"domain-name"`
-	NextName     string `dns:"domain-name"`
-}
-
-func (rr *TALINK) String() string {
-	return rr.Hdr.String() +
-		sprintName(rr.PreviousName) + " " + sprintName(rr.NextName)
-}
-
-// SSHFP RR. See RFC 4255.
-type SSHFP struct {
-	Hdr         RR_Header
-	Algorithm   uint8
-	Type        uint8
-	FingerPrint string `dns:"hex"`
-}
-
-func (rr *SSHFP) String() string {
-	return rr.Hdr.String() + strconv.Itoa(int(rr.Algorithm)) +
-		" " + strconv.Itoa(int(rr.Type)) +
-		" " + strings.ToUpper(rr.FingerPrint)
-}
-
-// KEY RR. See RFC 2535.
-type KEY struct {
-	DNSKEY
-}
-
-// CDNSKEY RR. See RFC 7344.
-type CDNSKEY struct {
-	DNSKEY
-}
-
-// DNSKEY RR. See RFC 4034 and RFC 3755.
-type DNSKEY struct {
-	Hdr       RR_Header
-	Flags     uint16
-	Protocol  uint8
-	Algorithm uint8
-	PublicKey string `dns:"base64"`
-}
-
-func (rr *DNSKEY) String() string {
-	return rr.Hdr.String() + strconv.Itoa(int(rr.Flags)) +
-		" " + strconv.Itoa(int(rr.Protocol)) +
-		" " + strconv.Itoa(int(rr.Algorithm)) +
-		" " + rr.PublicKey
-}
-
-// IPSECKEY RR. See RFC 4025.
-type IPSECKEY struct {
-	Hdr         RR_Header
-	Precedence  uint8
-	GatewayType uint8
-	Algorithm   uint8
-	GatewayAddr net.IP `dns:"-"` // packing/unpacking/parsing/etc handled together with GatewayHost
-	GatewayHost string `dns:"ipsechost"`
-	PublicKey   string `dns:"base64"`
-}
-
-func (rr *IPSECKEY) String() string {
-	var gateway string
-	switch rr.GatewayType {
-	case IPSECGatewayIPv4, IPSECGatewayIPv6:
-		gateway = rr.GatewayAddr.String()
-	case IPSECGatewayHost:
-		gateway = rr.GatewayHost
-	case IPSECGatewayNone:
-		fallthrough
-	default:
-		gateway = "."
-	}
-
-	return rr.Hdr.String() + strconv.Itoa(int(rr.Precedence)) +
-		" " + strconv.Itoa(int(rr.GatewayType)) +
-		" " + strconv.Itoa(int(rr.Algorithm)) +
-		" " + gateway +
-		" " + rr.PublicKey
-}
-
-// AMTRELAY RR. See RFC 8777.
-type AMTRELAY struct {
-	Hdr         RR_Header
-	Precedence  uint8
-	GatewayType uint8  // discovery is packed in here at bit 0x80
-	GatewayAddr net.IP `dns:"-"` // packing/unpacking/parsing/etc handled together with GatewayHost
-	GatewayHost string `dns:"amtrelayhost"`
-}
-
-func (rr *AMTRELAY) String() string {
-	var gateway string
-	switch rr.GatewayType & 0x7f {
-	case AMTRELAYIPv4, AMTRELAYIPv6:
-		gateway = rr.GatewayAddr.String()
-	case AMTRELAYHost:
-		gateway = rr.GatewayHost
-	case AMTRELAYNone:
-		fallthrough
-	default:
-		gateway = "."
-	}
-	boolS := "0"
-	if rr.GatewayType&0x80 == 0x80 {
-		boolS = "1"
-	}
-
-	return rr.Hdr.String() + strconv.Itoa(int(rr.Precedence)) +
-		" " + boolS +
-		" " + strconv.Itoa(int(rr.GatewayType&0x7f)) +
-		" " + gateway
-}
-
-// RKEY RR. See https://www.iana.org/assignments/dns-parameters/RKEY/rkey-completed-template.
-type RKEY struct {
-	Hdr       RR_Header
-	Flags     uint16
-	Protocol  uint8
-	Algorithm uint8
-	PublicKey string `dns:"base64"`
-}
-
-func (rr *RKEY) String() string {
-	return rr.Hdr.String() + strconv.Itoa(int(rr.Flags)) +
-		" " + strconv.Itoa(int(rr.Protocol)) +
-		" " + strconv.Itoa(int(rr.Algorithm)) +
-		" " + rr.PublicKey
-}
-
-// NSAPPTR RR. See RFC 1348.
-type NSAPPTR struct {
-	Hdr RR_Header
-	Ptr string `dns:"domain-name"`
-}
-
-func (rr *NSAPPTR) String() string { return rr.Hdr.String() + sprintName(rr.Ptr) }
-
-// NSEC3 RR. See RFC 5155.
-type NSEC3 struct {
-	Hdr        RR_Header
-	Hash       uint8
-	Flags      uint8
-	Iterations uint16
-	SaltLength uint8
-	Salt       string `dns:"size-hex:SaltLength"`
-	HashLength uint8
-	NextDomain string   `dns:"size-base32:HashLength"`
-	TypeBitMap []uint16 `dns:"nsec"`
-}
-
-func (rr *NSEC3) String() string {
-	s := rr.Hdr.String()
-	s += strconv.Itoa(int(rr.Hash)) +
-		" " + strconv.Itoa(int(rr.Flags)) +
-		" " + strconv.Itoa(int(rr.Iterations)) +
-		" " + saltToString(rr.Salt) +
-		" " + rr.NextDomain
-	for _, t := range rr.TypeBitMap {
-		s += " " + Type(t).String()
-	}
-	return s
-}
-
-func (rr *NSEC3) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 6 + len(rr.Salt)/2 + 1 + len(rr.NextDomain) + 1
-	l += typeBitMapLen(rr.TypeBitMap)
-	return l
-}
-
-// NSEC3PARAM RR. See RFC 5155.
-type NSEC3PARAM struct {
-	Hdr        RR_Header
-	Hash       uint8
-	Flags      uint8
-	Iterations uint16
-	SaltLength uint8
-	Salt       string `dns:"size-hex:SaltLength"`
-}
-
-func (rr *NSEC3PARAM) String() string {
-	s := rr.Hdr.String()
-	s += strconv.Itoa(int(rr.Hash)) +
-		" " + strconv.Itoa(int(rr.Flags)) +
-		" " + strconv.Itoa(int(rr.Iterations)) +
-		" " + saltToString(rr.Salt)
-	return s
-}
-
-// TKEY RR. See RFC 2930.
-type TKEY struct {
-	Hdr        RR_Header
-	Algorithm  string `dns:"domain-name"`
-	Inception  uint32
-	Expiration uint32
-	Mode       uint16
-	Error      uint16
-	KeySize    uint16
-	Key        string `dns:"size-hex:KeySize"`
-	OtherLen   uint16
-	OtherData  string `dns:"size-hex:OtherLen"`
-}
-
-// TKEY has no official presentation format, but this will suffice.
-func (rr *TKEY) String() string {
-	s := ";" + rr.Hdr.String() +
-		" " + rr.Algorithm +
-		" " + TimeToString(rr.Inception) +
-		" " + TimeToString(rr.Expiration) +
-		" " + strconv.Itoa(int(rr.Mode)) +
-		" " + strconv.Itoa(int(rr.Error)) +
-		" " + strconv.Itoa(int(rr.KeySize)) +
-		" " + rr.Key +
-		" " + strconv.Itoa(int(rr.OtherLen)) +
-		" " + rr.OtherData
-	return s
-}
-
-// RFC3597 represents an unknown/generic RR. See RFC 3597.
-type RFC3597 struct {
-	Hdr   RR_Header
-	Rdata string `dns:"hex"`
-}
-
-func (rr *RFC3597) String() string {
-	// Let's call it a hack
-	s := rfc3597Header(rr.Hdr)
-
-	s += "\\# " + strconv.Itoa(len(rr.Rdata)/2) + " " + rr.Rdata
-	return s
-}
-
-func rfc3597Header(h RR_Header) string {
-	var s string
-
-	s += sprintName(h.Name) + "\t"
-	s += strconv.FormatInt(int64(h.Ttl), 10) + "\t"
-	s += "CLASS" + strconv.Itoa(int(h.Class)) + "\t"
-	s += "TYPE" + strconv.Itoa(int(h.Rrtype)) + "\t"
-	return s
-}
-
-// URI RR. See RFC 7553.
-type URI struct {
-	Hdr      RR_Header
-	Priority uint16
-	Weight   uint16
-	Target   string `dns:"octet"`
-}
-
-// rr.Target to be parsed as a sequence of character encoded octets according to RFC 3986
-func (rr *URI) String() string {
-	return rr.Hdr.String() + strconv.Itoa(int(rr.Priority)) +
-		" " + strconv.Itoa(int(rr.Weight)) + " " + sprintTxtOctet(rr.Target)
-}
-
-// DHCID RR. See RFC 4701.
-type DHCID struct {
-	Hdr    RR_Header
-	Digest string `dns:"base64"`
-}
-
-func (rr *DHCID) String() string { return rr.Hdr.String() + rr.Digest }
-
-// TLSA RR. See RFC 6698.
-type TLSA struct {
-	Hdr          RR_Header
-	Usage        uint8
-	Selector     uint8
-	MatchingType uint8
-	Certificate  string `dns:"hex"`
-}
-
-func (rr *TLSA) String() string {
-	return rr.Hdr.String() +
-		strconv.Itoa(int(rr.Usage)) +
-		" " + strconv.Itoa(int(rr.Selector)) +
-		" " + strconv.Itoa(int(rr.MatchingType)) +
-		" " + rr.Certificate
-}
-
-// SMIMEA RR. See RFC 8162.
-type SMIMEA struct {
-	Hdr          RR_Header
-	Usage        uint8
-	Selector     uint8
-	MatchingType uint8
-	Certificate  string `dns:"hex"`
-}
-
-func (rr *SMIMEA) String() string {
-	s := rr.Hdr.String() +
-		strconv.Itoa(int(rr.Usage)) +
-		" " + strconv.Itoa(int(rr.Selector)) +
-		" " + strconv.Itoa(int(rr.MatchingType))
-
-	// Every Nth char needs a space on this output. If we output
-	// this as one giant line, we can't read it can in because in some cases
-	// the cert length overflows scan.maxTok (2048).
-	sx := splitN(rr.Certificate, 1024) // conservative value here
-	s += " " + strings.Join(sx, " ")
-	return s
-}
-
-// HIP RR. See RFC 8005.
-type HIP struct {
-	Hdr                RR_Header
-	HitLength          uint8
-	PublicKeyAlgorithm uint8
-	PublicKeyLength    uint16
-	Hit                string   `dns:"size-hex:HitLength"`
-	PublicKey          string   `dns:"size-base64:PublicKeyLength"`
-	RendezvousServers  []string `dns:"domain-name"`
-}
-
-func (rr *HIP) String() string {
-	s := rr.Hdr.String() +
-		strconv.Itoa(int(rr.PublicKeyAlgorithm)) +
-		" " + rr.Hit +
-		" " + rr.PublicKey
-	for _, d := range rr.RendezvousServers {
-		s += " " + sprintName(d)
-	}
-	return s
-}
-
-// NINFO RR. See https://www.iana.org/assignments/dns-parameters/NINFO/ninfo-completed-template.
-type NINFO struct {
-	Hdr    RR_Header
-	ZSData []string `dns:"txt"`
-}
-
-func (rr *NINFO) String() string { return rr.Hdr.String() + sprintTxt(rr.ZSData) }
-
-// NID RR. See RFC 6742.
-type NID struct {
-	Hdr        RR_Header
-	Preference uint16
-	NodeID     uint64
-}
-
-func (rr *NID) String() string {
-	s := rr.Hdr.String() + strconv.Itoa(int(rr.Preference))
-	node := fmt.Sprintf("%0.16x", rr.NodeID)
-	s += " " + node[0:4] + ":" + node[4:8] + ":" + node[8:12] + ":" + node[12:16]
-	return s
-}
-
-// L32 RR, See RFC 6742.
-type L32 struct {
-	Hdr        RR_Header
-	Preference uint16
-	Locator32  net.IP `dns:"a"`
-}
-
-func (rr *L32) String() string {
-	if rr.Locator32 == nil {
-		return rr.Hdr.String() + strconv.Itoa(int(rr.Preference))
-	}
-	return rr.Hdr.String() + strconv.Itoa(int(rr.Preference)) +
-		" " + rr.Locator32.String()
-}
-
-// L64 RR, See RFC 6742.
-type L64 struct {
-	Hdr        RR_Header
-	Preference uint16
-	Locator64  uint64
-}
-
-func (rr *L64) String() string {
-	s := rr.Hdr.String() + strconv.Itoa(int(rr.Preference))
-	node := fmt.Sprintf("%0.16X", rr.Locator64)
-	s += " " + node[0:4] + ":" + node[4:8] + ":" + node[8:12] + ":" + node[12:16]
-	return s
-}
-
-// LP RR. See RFC 6742.
-type LP struct {
-	Hdr        RR_Header
-	Preference uint16
-	Fqdn       string `dns:"domain-name"`
-}
-
-func (rr *LP) String() string {
-	return rr.Hdr.String() + strconv.Itoa(int(rr.Preference)) + " " + sprintName(rr.Fqdn)
-}
-
-// EUI48 RR. See RFC 7043.
-type EUI48 struct {
-	Hdr     RR_Header
-	Address uint64 `dns:"uint48"`
-}
-
-func (rr *EUI48) String() string { return rr.Hdr.String() + euiToString(rr.Address, 48) }
-
-// EUI64 RR. See RFC 7043.
-type EUI64 struct {
-	Hdr     RR_Header
-	Address uint64
-}
-
-func (rr *EUI64) String() string { return rr.Hdr.String() + euiToString(rr.Address, 64) }
-
-// CAA RR. See RFC 6844.
-type CAA struct {
-	Hdr   RR_Header
-	Flag  uint8
-	Tag   string
-	Value string `dns:"octet"`
-}
-
-// rr.Value Is the character-string encoding of the value field as specified in RFC 1035, Section 5.1.
-func (rr *CAA) String() string {
-	return rr.Hdr.String() + strconv.Itoa(int(rr.Flag)) + " " + rr.Tag + " " + sprintTxtOctet(rr.Value)
-}
-
-// UID RR. Deprecated, IANA-Reserved.
-type UID struct {
-	Hdr RR_Header
-	Uid uint32
-}
-
-func (rr *UID) String() string { return rr.Hdr.String() + strconv.FormatInt(int64(rr.Uid), 10) }
-
-// GID RR. Deprecated, IANA-Reserved.
-type GID struct {
-	Hdr RR_Header
-	Gid uint32
-}
-
-func (rr *GID) String() string { return rr.Hdr.String() + strconv.FormatInt(int64(rr.Gid), 10) }
-
-// UINFO RR. Deprecated, IANA-Reserved.
-type UINFO struct {
-	Hdr   RR_Header
-	Uinfo string
-}
-
-func (rr *UINFO) String() string { return rr.Hdr.String() + sprintTxt([]string{rr.Uinfo}) }
-
-// EID RR. See http://ana-3.lcs.mit.edu/~jnc/nimrod/dns.txt.
-type EID struct {
-	Hdr      RR_Header
-	Endpoint string `dns:"hex"`
-}
-
-func (rr *EID) String() string { return rr.Hdr.String() + strings.ToUpper(rr.Endpoint) }
-
-// NIMLOC RR. See http://ana-3.lcs.mit.edu/~jnc/nimrod/dns.txt.
-type NIMLOC struct {
-	Hdr     RR_Header
-	Locator string `dns:"hex"`
-}
-
-func (rr *NIMLOC) String() string { return rr.Hdr.String() + strings.ToUpper(rr.Locator) }
-
-// OPENPGPKEY RR. See RFC 7929.
-type OPENPGPKEY struct {
-	Hdr       RR_Header
-	PublicKey string `dns:"base64"`
-}
-
-func (rr *OPENPGPKEY) String() string { return rr.Hdr.String() + rr.PublicKey }
-
-// CSYNC RR. See RFC 7477.
-type CSYNC struct {
-	Hdr        RR_Header
-	Serial     uint32
-	Flags      uint16
-	TypeBitMap []uint16 `dns:"nsec"`
-}
-
-func (rr *CSYNC) String() string {
-	s := rr.Hdr.String() + strconv.FormatInt(int64(rr.Serial), 10) + " " + strconv.Itoa(int(rr.Flags))
-
-	for _, t := range rr.TypeBitMap {
-		s += " " + Type(t).String()
-	}
-	return s
-}
-
-func (rr *CSYNC) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 4 + 2
-	l += typeBitMapLen(rr.TypeBitMap)
-	return l
-}
-
-// ZONEMD RR, from draft-ietf-dnsop-dns-zone-digest
-type ZONEMD struct {
-	Hdr    RR_Header
-	Serial uint32
-	Scheme uint8
-	Hash   uint8
-	Digest string `dns:"hex"`
-}
-
-func (rr *ZONEMD) String() string {
-	return rr.Hdr.String() +
-		strconv.Itoa(int(rr.Serial)) +
-		" " + strconv.Itoa(int(rr.Scheme)) +
-		" " + strconv.Itoa(int(rr.Hash)) +
-		" " + rr.Digest
-}
-
-// RESINFO RR. See RFC 9606.
-
-type RESINFO struct {
-	Hdr RR_Header
-	Txt []string `dns:"txt"`
-}
-
-func (rr *RESINFO) String() string { return rr.Hdr.String() + sprintTxt(rr.Txt) }
-
-// APL RR. See RFC 3123.
-type APL struct {
-	Hdr      RR_Header
-	Prefixes []APLPrefix `dns:"apl"`
-}
-
-// APLPrefix is an address prefix hold by an APL record.
-type APLPrefix struct {
-	Negation bool
-	Network  net.IPNet
-}
-
-// String returns presentation form of the APL record.
-func (rr *APL) String() string {
-	var sb strings.Builder
-	sb.WriteString(rr.Hdr.String())
-	for i, p := range rr.Prefixes {
-		if i > 0 {
-			sb.WriteByte(' ')
-		}
-		sb.WriteString(p.str())
-	}
-	return sb.String()
-}
-
-// str returns presentation form of the APL prefix.
-func (a *APLPrefix) str() string {
-	var sb strings.Builder
-	if a.Negation {
-		sb.WriteByte('!')
-	}
-
-	switch len(a.Network.IP) {
-	case net.IPv4len:
-		sb.WriteByte('1')
-	case net.IPv6len:
-		sb.WriteByte('2')
-	}
-
-	sb.WriteByte(':')
-
-	switch len(a.Network.IP) {
-	case net.IPv4len:
-		sb.WriteString(a.Network.IP.String())
-	case net.IPv6len:
-		// add prefix for IPv4-mapped IPv6
-		if v4 := a.Network.IP.To4(); v4 != nil {
-			sb.WriteString(ipv4InIPv6Prefix)
-		}
-		sb.WriteString(a.Network.IP.String())
-	}
-
-	sb.WriteByte('/')
-
-	prefix, _ := a.Network.Mask.Size()
-	sb.WriteString(strconv.Itoa(prefix))
-
-	return sb.String()
-}
-
-// equals reports whether two APL prefixes are identical.
-func (a *APLPrefix) equals(b *APLPrefix) bool {
-	return a.Negation == b.Negation &&
-		a.Network.IP.Equal(b.Network.IP) &&
-		bytes.Equal(a.Network.Mask, b.Network.Mask)
-}
-
-// copy returns a copy of the APL prefix.
-func (a *APLPrefix) copy() APLPrefix {
-	return APLPrefix{
-		Negation: a.Negation,
-		Network:  copyNet(a.Network),
-	}
-}
-
-// len returns size of the prefix in wire format.
-func (a *APLPrefix) len() int {
-	// 4-byte header and the network address prefix (see Section 4 of RFC 3123)
-	prefix, _ := a.Network.Mask.Size()
-	return 4 + (prefix+7)/8
-}
-
-// TimeToString translates the RRSIG's incep. and expir. times to the
-// string representation used when printing the record.
-// It takes serial arithmetic (RFC 1982) into account.
-func TimeToString(t uint32) string {
-	mod := (int64(t)-time.Now().Unix())/year68 - 1
-	if mod < 0 {
-		mod = 0
-	}
-	ti := time.Unix(int64(t)-mod*year68, 0).UTC()
-	return ti.Format("20060102150405")
-}
-
-// StringToTime translates the RRSIG's incep. and expir. times from
-// string values like "20110403154150" to an 32 bit integer.
-// It takes serial arithmetic (RFC 1982) into account.
-func StringToTime(s string) (uint32, error) {
-	t, err := time.Parse("20060102150405", s)
-	if err != nil {
-		return 0, err
-	}
-	mod := t.Unix()/year68 - 1
-	if mod < 0 {
-		mod = 0
-	}
-	return uint32(t.Unix() - mod*year68), nil
-}
-
-// saltToString converts a NSECX salt to uppercase and returns "-" when it is empty.
-func saltToString(s string) string {
-	if s == "" {
-		return "-"
-	}
-	return strings.ToUpper(s)
-}
-
-func euiToString(eui uint64, bits int) (hex string) {
-	switch bits {
-	case 64:
-		hex = fmt.Sprintf("%16.16x", eui)
-		hex = hex[0:2] + "-" + hex[2:4] + "-" + hex[4:6] + "-" + hex[6:8] +
-			"-" + hex[8:10] + "-" + hex[10:12] + "-" + hex[12:14] + "-" + hex[14:16]
-	case 48:
-		hex = fmt.Sprintf("%12.12x", eui)
-		hex = hex[0:2] + "-" + hex[2:4] + "-" + hex[4:6] + "-" + hex[6:8] +
-			"-" + hex[8:10] + "-" + hex[10:12]
-	}
-	return
-}
-
-// cloneSlice returns a shallow copy of s.
-func cloneSlice[E any, S ~[]E](s S) S {
-	if s == nil {
-		return nil
-	}
-	return append(S(nil), s...)
-}
-
-// copyNet returns a copy of a subnet.
-func copyNet(n net.IPNet) net.IPNet {
-	return net.IPNet{
-		IP:   cloneSlice(n.IP),
-		Mask: cloneSlice(n.Mask),
-	}
-}
-
-// SplitN splits a string into N sized string chunks.
-// This might become an exported function once.
-func splitN(s string, n int) []string {
-	if len(s) < n {
-		return []string{s}
-	}
-	sx := []string{}
-	p, i := 0, n
-	for {
-		if i <= len(s) {
-			sx = append(sx, s[p:i])
-		} else {
-			sx = append(sx, s[p:])
-			break
-
-		}
-		p, i = p+n, i+n
-	}
-
-	return sx
-}
diff --git a/vendor/github.com/miekg/dns/udp.go b/vendor/github.com/miekg/dns/udp.go
deleted file mode 100644
index d226718595..0000000000
--- a/vendor/github.com/miekg/dns/udp.go
+++ /dev/null
@@ -1,103 +0,0 @@
-//go:build !windows && !darwin
-// +build !windows,!darwin
-
-package dns
-
-import (
-	"net"
-
-	"golang.org/x/net/ipv4"
-	"golang.org/x/net/ipv6"
-)
-
-// This is the required size of the OOB buffer to pass to ReadMsgUDP.
-var udpOOBSize = func() int {
-	// We can't know whether we'll get an IPv4 control message or an
-	// IPv6 control message ahead of time. To get around this, we size
-	// the buffer equal to the largest of the two.
-
-	oob4 := ipv4.NewControlMessage(ipv4.FlagDst | ipv4.FlagInterface)
-	oob6 := ipv6.NewControlMessage(ipv6.FlagDst | ipv6.FlagInterface)
-
-	if len(oob4) > len(oob6) {
-		return len(oob4)
-	}
-
-	return len(oob6)
-}()
-
-// SessionUDP holds the remote address and the associated
-// out-of-band data.
-type SessionUDP struct {
-	raddr   *net.UDPAddr
-	context []byte
-}
-
-// RemoteAddr returns the remote network address.
-func (s *SessionUDP) RemoteAddr() net.Addr { return s.raddr }
-
-// ReadFromSessionUDP acts just like net.UDPConn.ReadFrom(), but returns a session object instead of a
-// net.UDPAddr.
-func ReadFromSessionUDP(conn *net.UDPConn, b []byte) (int, *SessionUDP, error) {
-	oob := make([]byte, udpOOBSize)
-	n, oobn, _, raddr, err := conn.ReadMsgUDP(b, oob)
-	if err != nil {
-		return n, nil, err
-	}
-	return n, &SessionUDP{raddr, oob[:oobn]}, err
-}
-
-// WriteToSessionUDP acts just like net.UDPConn.WriteTo(), but uses a *SessionUDP instead of a net.Addr.
-func WriteToSessionUDP(conn *net.UDPConn, b []byte, session *SessionUDP) (int, error) {
-	oob := correctSource(session.context)
-	n, _, err := conn.WriteMsgUDP(b, oob, session.raddr)
-	return n, err
-}
-
-func setUDPSocketOptions(conn *net.UDPConn) error {
-	// Try setting the flags for both families and ignore the errors unless they
-	// both error.
-	err6 := ipv6.NewPacketConn(conn).SetControlMessage(ipv6.FlagDst|ipv6.FlagInterface, true)
-	err4 := ipv4.NewPacketConn(conn).SetControlMessage(ipv4.FlagDst|ipv4.FlagInterface, true)
-	if err6 != nil && err4 != nil {
-		return err4
-	}
-	return nil
-}
-
-// parseDstFromOOB takes oob data and returns the destination IP.
-func parseDstFromOOB(oob []byte) net.IP {
-	// Start with IPv6 and then fallback to IPv4
-	// TODO(fastest963): Figure out a way to prefer one or the other. Looking at
-	// the lvl of the header for a 0 or 41 isn't cross-platform.
-	cm6 := new(ipv6.ControlMessage)
-	if cm6.Parse(oob) == nil && cm6.Dst != nil {
-		return cm6.Dst
-	}
-	cm4 := new(ipv4.ControlMessage)
-	if cm4.Parse(oob) == nil && cm4.Dst != nil {
-		return cm4.Dst
-	}
-	return nil
-}
-
-// correctSource takes oob data and returns new oob data with the Src equal to the Dst
-func correctSource(oob []byte) []byte {
-	dst := parseDstFromOOB(oob)
-	if dst == nil {
-		return nil
-	}
-	// If the dst is definitely an IPv6, then use ipv6's ControlMessage to
-	// respond otherwise use ipv4's because ipv6's marshal ignores ipv4
-	// addresses.
-	if dst.To4() == nil {
-		cm := new(ipv6.ControlMessage)
-		cm.Src = dst
-		oob = cm.Marshal()
-	} else {
-		cm := new(ipv4.ControlMessage)
-		cm.Src = dst
-		oob = cm.Marshal()
-	}
-	return oob
-}
diff --git a/vendor/github.com/miekg/dns/udp_no_control.go b/vendor/github.com/miekg/dns/udp_no_control.go
deleted file mode 100644
index ca3d4a633b..0000000000
--- a/vendor/github.com/miekg/dns/udp_no_control.go
+++ /dev/null
@@ -1,37 +0,0 @@
-//go:build windows || darwin
-// +build windows darwin
-
-// TODO(tmthrgd): Remove this Windows-specific code if go.dev/issue/7175 and
-//   go.dev/issue/7174 are ever fixed.
-
-// NOTICE(stek29): darwin supports PKTINFO in sendmsg, but it unbinds sockets, see https://github.com/miekg/dns/issues/724
-
-package dns
-
-import "net"
-
-// SessionUDP holds the remote address
-type SessionUDP struct {
-	raddr *net.UDPAddr
-}
-
-// RemoteAddr returns the remote network address.
-func (s *SessionUDP) RemoteAddr() net.Addr { return s.raddr }
-
-// ReadFromSessionUDP acts just like net.UDPConn.ReadFrom(), but returns a session object instead of a
-// net.UDPAddr.
-func ReadFromSessionUDP(conn *net.UDPConn, b []byte) (int, *SessionUDP, error) {
-	n, raddr, err := conn.ReadFrom(b)
-	if err != nil {
-		return n, nil, err
-	}
-	return n, &SessionUDP{raddr.(*net.UDPAddr)}, err
-}
-
-// WriteToSessionUDP acts just like net.UDPConn.WriteTo(), but uses a *SessionUDP instead of a net.Addr.
-func WriteToSessionUDP(conn *net.UDPConn, b []byte, session *SessionUDP) (int, error) {
-	return conn.WriteTo(b, session.raddr)
-}
-
-func setUDPSocketOptions(*net.UDPConn) error { return nil }
-func parseDstFromOOB([]byte, net.IP) net.IP  { return nil }
diff --git a/vendor/github.com/miekg/dns/update.go b/vendor/github.com/miekg/dns/update.go
deleted file mode 100644
index 2fef1461f5..0000000000
--- a/vendor/github.com/miekg/dns/update.go
+++ /dev/null
@@ -1,119 +0,0 @@
-package dns
-
-// NameUsed sets the RRs in the prereq section to
-// "Name is in use" RRs. RFC 2136 section 2.4.4.
-// See [ANY] on how to make RRs without rdata.
-func (u *Msg) NameUsed(rr []RR) {
-	if u.Answer == nil {
-		u.Answer = make([]RR, 0, len(rr))
-	}
-	for _, r := range rr {
-		u.Answer = append(u.Answer, &ANY{Hdr: RR_Header{Name: r.Header().Name, Ttl: 0, Rrtype: TypeANY, Class: ClassANY}})
-	}
-}
-
-// NameNotUsed sets the RRs in the prereq section to
-// "Name is in not use" RRs. RFC 2136 section 2.4.5.
-func (u *Msg) NameNotUsed(rr []RR) {
-	if u.Answer == nil {
-		u.Answer = make([]RR, 0, len(rr))
-	}
-	for _, r := range rr {
-		u.Answer = append(u.Answer, &ANY{Hdr: RR_Header{Name: r.Header().Name, Ttl: 0, Rrtype: TypeANY, Class: ClassNONE}})
-	}
-}
-
-// Used sets the RRs in the prereq section to
-// "RRset exists (value dependent -- with rdata)" RRs. RFC 2136 section 2.4.2.
-func (u *Msg) Used(rr []RR) {
-	if len(u.Question) == 0 {
-		panic("dns: empty question section")
-	}
-	if u.Answer == nil {
-		u.Answer = make([]RR, 0, len(rr))
-	}
-	for _, r := range rr {
-		hdr := r.Header()
-		hdr.Class = u.Question[0].Qclass
-		hdr.Ttl = 0
-		u.Answer = append(u.Answer, r)
-	}
-}
-
-// RRsetUsed sets the RRs in the prereq section to
-// "RRset exists (value independent -- no rdata)" RRs. RFC 2136 section 2.4.1.
-// See [ANY] on how to make RRs without rdata.
-func (u *Msg) RRsetUsed(rr []RR) {
-	if u.Answer == nil {
-		u.Answer = make([]RR, 0, len(rr))
-	}
-	for _, r := range rr {
-		h := r.Header()
-		u.Answer = append(u.Answer, &ANY{Hdr: RR_Header{Name: h.Name, Ttl: 0, Rrtype: h.Rrtype, Class: ClassANY}})
-	}
-}
-
-// RRsetNotUsed sets the RRs in the prereq section to
-// "RRset does not exist" RRs. RFC 2136 section 2.4.3.
-// See [ANY] on how to make RRs without rdata.
-func (u *Msg) RRsetNotUsed(rr []RR) {
-	if u.Answer == nil {
-		u.Answer = make([]RR, 0, len(rr))
-	}
-	for _, r := range rr {
-		h := r.Header()
-		u.Answer = append(u.Answer, &ANY{Hdr: RR_Header{Name: h.Name, Ttl: 0, Rrtype: h.Rrtype, Class: ClassNONE}})
-	}
-}
-
-// Insert creates a dynamic update packet that adds an complete RRset, see RFC 2136 section 2.5.1.
-// See [ANY] on how to make RRs without rdata.
-func (u *Msg) Insert(rr []RR) {
-	if len(u.Question) == 0 {
-		panic("dns: empty question section")
-	}
-	if u.Ns == nil {
-		u.Ns = make([]RR, 0, len(rr))
-	}
-	for _, r := range rr {
-		r.Header().Class = u.Question[0].Qclass
-		u.Ns = append(u.Ns, r)
-	}
-}
-
-// RemoveRRset creates a dynamic update packet that deletes an RRset, see RFC 2136 section 2.5.2.
-// See [ANY] on how to make RRs without rdata.
-func (u *Msg) RemoveRRset(rr []RR) {
-	if u.Ns == nil {
-		u.Ns = make([]RR, 0, len(rr))
-	}
-	for _, r := range rr {
-		h := r.Header()
-		u.Ns = append(u.Ns, &ANY{Hdr: RR_Header{Name: h.Name, Ttl: 0, Rrtype: h.Rrtype, Class: ClassANY}})
-	}
-}
-
-// RemoveName creates a dynamic update packet that deletes all RRsets of a name, see RFC 2136 section 2.5.3
-// See [ANY] on how to make RRs without rdata.
-func (u *Msg) RemoveName(rr []RR) {
-	if u.Ns == nil {
-		u.Ns = make([]RR, 0, len(rr))
-	}
-	for _, r := range rr {
-		u.Ns = append(u.Ns, &ANY{Hdr: RR_Header{Name: r.Header().Name, Ttl: 0, Rrtype: TypeANY, Class: ClassANY}})
-	}
-}
-
-// Remove creates a dynamic update packet deletes RR from a RRSset, see RFC 2136 section 2.5.4
-// See [ANY] on how to make RRs without rdata.
-func (u *Msg) Remove(rr []RR) {
-	if u.Ns == nil {
-		u.Ns = make([]RR, 0, len(rr))
-	}
-	for _, r := range rr {
-		h := r.Header()
-		h.Class = ClassNONE
-		h.Ttl = 0
-		u.Ns = append(u.Ns, r)
-	}
-}
diff --git a/vendor/github.com/miekg/dns/version.go b/vendor/github.com/miekg/dns/version.go
deleted file mode 100644
index 33cb83e5ac..0000000000
--- a/vendor/github.com/miekg/dns/version.go
+++ /dev/null
@@ -1,15 +0,0 @@
-package dns
-
-import "fmt"
-
-// Version is current version of this library.
-var Version = v{1, 1, 72}
-
-// v holds the version of this library.
-type v struct {
-	Major, Minor, Patch int
-}
-
-func (v v) String() string {
-	return fmt.Sprintf("%d.%d.%d", v.Major, v.Minor, v.Patch)
-}
diff --git a/vendor/github.com/miekg/dns/xfr.go b/vendor/github.com/miekg/dns/xfr.go
deleted file mode 100644
index 97a6424714..0000000000
--- a/vendor/github.com/miekg/dns/xfr.go
+++ /dev/null
@@ -1,290 +0,0 @@
-package dns
-
-import (
-	"crypto/tls"
-	"fmt"
-	"time"
-)
-
-// Envelope is used when doing a zone transfer with a remote server.
-type Envelope struct {
-	RR    []RR  // The set of RRs in the answer section of the xfr reply message.
-	Error error // If something went wrong, this contains the error.
-}
-
-// A Transfer defines parameters that are used during a zone transfer.
-type Transfer struct {
-	*Conn
-	DialTimeout    time.Duration     // net.DialTimeout, defaults to 2 seconds
-	ReadTimeout    time.Duration     // net.Conn.SetReadTimeout value for connections, defaults to 2 seconds
-	WriteTimeout   time.Duration     // net.Conn.SetWriteTimeout value for connections, defaults to 2 seconds
-	TsigProvider   TsigProvider      // An implementation of the TsigProvider interface. If defined it replaces TsigSecret and is used for all TSIG operations.
-	TsigSecret     map[string]string // Secret(s) for Tsig map[<zonename>]<base64 secret>, zonename must be in canonical form (lowercase, fqdn, see RFC 4034 Section 6.2)
-	tsigTimersOnly bool
-	TLS            *tls.Config // TLS config. If Xfr over TLS will be attempted
-}
-
-func (t *Transfer) tsigProvider() TsigProvider {
-	if t.TsigProvider != nil {
-		return t.TsigProvider
-	}
-	if t.TsigSecret != nil {
-		return tsigSecretProvider(t.TsigSecret)
-	}
-	return nil
-}
-
-// TODO: Think we need to away to stop the transfer
-
-// In performs an incoming transfer with the server in a.
-// If you would like to set the source IP, or some other attribute
-// of a Dialer for a Transfer, you can do so by specifying the attributes
-// in the Transfer.Conn:
-//
-//	d := net.Dialer{LocalAddr: transfer_source}
-//	con, err := d.Dial("tcp", master)
-//	dnscon := &dns.Conn{Conn:con}
-//	transfer = &dns.Transfer{Conn: dnscon}
-//	channel, err := transfer.In(message, master)
-func (t *Transfer) In(q *Msg, a string) (env chan *Envelope, err error) {
-	switch q.Question[0].Qtype {
-	case TypeAXFR, TypeIXFR:
-	default:
-		return nil, &Error{"unsupported question type"}
-	}
-
-	timeout := dnsTimeout
-	if t.DialTimeout != 0 {
-		timeout = t.DialTimeout
-	}
-
-	if t.Conn == nil {
-		if t.TLS != nil {
-			t.Conn, err = DialTimeoutWithTLS("tcp-tls", a, t.TLS, timeout)
-		} else {
-			t.Conn, err = DialTimeout("tcp", a, timeout)
-		}
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	if err := t.WriteMsg(q); err != nil {
-		return nil, err
-	}
-
-	env = make(chan *Envelope)
-	switch q.Question[0].Qtype {
-	case TypeAXFR:
-		go t.inAxfr(q, env)
-	case TypeIXFR:
-		go t.inIxfr(q, env)
-	}
-
-	return env, nil
-}
-
-func (t *Transfer) inAxfr(q *Msg, c chan *Envelope) {
-	first := true
-	defer func() {
-		// First close the connection, then the channel. This allows functions blocked on
-		// the channel to assume that the connection is closed and no further operations are
-		// pending when they resume.
-		t.Close()
-		close(c)
-	}()
-	timeout := dnsTimeout
-	if t.ReadTimeout != 0 {
-		timeout = t.ReadTimeout
-	}
-	for {
-		t.Conn.SetReadDeadline(time.Now().Add(timeout))
-		in, err := t.ReadMsg()
-		if err != nil {
-			c <- &Envelope{nil, err}
-			return
-		}
-		if q.Id != in.Id {
-			c <- &Envelope{in.Answer, ErrId}
-			return
-		}
-		if first {
-			if in.Rcode != RcodeSuccess {
-				c <- &Envelope{in.Answer, &Error{err: fmt.Sprintf(errXFR, in.Rcode)}}
-				return
-			}
-			if !isSOAFirst(in) {
-				c <- &Envelope{in.Answer, ErrSoa}
-				return
-			}
-			first = !first
-			// only one answer that is SOA, receive more
-			if len(in.Answer) == 1 {
-				t.tsigTimersOnly = true
-				c <- &Envelope{in.Answer, nil}
-				continue
-			}
-		}
-
-		if !first {
-			t.tsigTimersOnly = true // Subsequent envelopes use this.
-			if isSOALast(in) {
-				c <- &Envelope{in.Answer, nil}
-				return
-			}
-			c <- &Envelope{in.Answer, nil}
-		}
-	}
-}
-
-func (t *Transfer) inIxfr(q *Msg, c chan *Envelope) {
-	var serial uint32 // The first serial seen is the current server serial
-	axfr := true
-	n := 0
-	qser := q.Ns[0].(*SOA).Serial
-	defer func() {
-		// First close the connection, then the channel. This allows functions blocked on
-		// the channel to assume that the connection is closed and no further operations are
-		// pending when they resume.
-		t.Close()
-		close(c)
-	}()
-	timeout := dnsTimeout
-	if t.ReadTimeout != 0 {
-		timeout = t.ReadTimeout
-	}
-	for {
-		t.SetReadDeadline(time.Now().Add(timeout))
-		in, err := t.ReadMsg()
-		if err != nil {
-			c <- &Envelope{nil, err}
-			return
-		}
-		if q.Id != in.Id {
-			c <- &Envelope{in.Answer, ErrId}
-			return
-		}
-		if in.Rcode != RcodeSuccess {
-			c <- &Envelope{in.Answer, &Error{err: fmt.Sprintf(errXFR, in.Rcode)}}
-			return
-		}
-		if n == 0 {
-			// Check if the returned answer is ok
-			if !isSOAFirst(in) {
-				c <- &Envelope{in.Answer, ErrSoa}
-				return
-			}
-			// This serial is important
-			serial = in.Answer[0].(*SOA).Serial
-			// Check if there are no changes in zone
-			if qser >= serial {
-				c <- &Envelope{in.Answer, nil}
-				return
-			}
-		}
-		// Now we need to check each message for SOA records, to see what we need to do
-		t.tsigTimersOnly = true
-		for _, rr := range in.Answer {
-			if v, ok := rr.(*SOA); ok {
-				if v.Serial == serial {
-					n++
-					// quit if it's a full axfr or the servers' SOA is repeated the third time
-					if axfr && n == 2 || n == 3 {
-						c <- &Envelope{in.Answer, nil}
-						return
-					}
-				} else if axfr {
-					// it's an ixfr
-					axfr = false
-				}
-			}
-		}
-		c <- &Envelope{in.Answer, nil}
-	}
-}
-
-// Out performs an outgoing transfer with the client connecting in w.
-// Basic use pattern:
-//
-//	ch := make(chan *dns.Envelope)
-//	tr := new(dns.Transfer)
-//	var wg sync.WaitGroup
-//	wg.Add(1)
-//	go func() {
-//		tr.Out(w, r, ch)
-//		wg.Done()
-//	}()
-//	ch <- &dns.Envelope{RR: []dns.RR{soa, rr1, rr2, rr3, soa}}
-//	close(ch)
-//	wg.Wait() // wait until everything is written out
-//	w.Close() // close connection
-//
-// The server is responsible for sending the correct sequence of RRs through the channel ch.
-func (t *Transfer) Out(w ResponseWriter, q *Msg, ch chan *Envelope) error {
-	for x := range ch {
-		r := new(Msg)
-		// Compress?
-		r.SetReply(q)
-		r.Authoritative = true
-		// assume it fits TODO(miek): fix
-		r.Answer = append(r.Answer, x.RR...)
-		if tsig := q.IsTsig(); tsig != nil && w.TsigStatus() == nil {
-			r.SetTsig(tsig.Hdr.Name, tsig.Algorithm, tsig.Fudge, time.Now().Unix())
-		}
-		if err := w.WriteMsg(r); err != nil {
-			return err
-		}
-		w.TsigTimersOnly(true)
-	}
-	return nil
-}
-
-// ReadMsg reads a message from the transfer connection t.
-func (t *Transfer) ReadMsg() (*Msg, error) {
-	m := new(Msg)
-	p := make([]byte, MaxMsgSize)
-	n, err := t.Read(p)
-	if err != nil && n == 0 {
-		return nil, err
-	}
-	p = p[:n]
-	if err := m.Unpack(p); err != nil {
-		return nil, err
-	}
-
-	if tp := t.tsigProvider(); tp != nil {
-		// Need to work on the original message p, as that was used to calculate the tsig.
-		err = TsigVerifyWithProvider(p, tp, t.tsigRequestMAC, t.tsigTimersOnly)
-		if ts := m.IsTsig(); ts != nil {
-			t.tsigRequestMAC = ts.MAC
-		}
-	}
-	return m, err
-}
-
-// WriteMsg writes a message through the transfer connection t.
-func (t *Transfer) WriteMsg(m *Msg) (err error) {
-	var out []byte
-	if ts, tp := m.IsTsig(), t.tsigProvider(); ts != nil && tp != nil {
-		out, t.tsigRequestMAC, err = TsigGenerateWithProvider(m, tp, t.tsigRequestMAC, t.tsigTimersOnly)
-	} else {
-		out, err = m.Pack()
-	}
-	if err != nil {
-		return err
-	}
-	_, err = t.Write(out)
-	return err
-}
-
-func isSOAFirst(in *Msg) bool {
-	return len(in.Answer) > 0 &&
-		in.Answer[0].Header().Rrtype == TypeSOA
-}
-
-func isSOALast(in *Msg) bool {
-	return len(in.Answer) > 0 &&
-		in.Answer[len(in.Answer)-1].Header().Rrtype == TypeSOA
-}
-
-const errXFR = "bad xfr rcode: %d"
diff --git a/vendor/github.com/miekg/dns/zduplicate.go b/vendor/github.com/miekg/dns/zduplicate.go
deleted file mode 100644
index ebd9e02970..0000000000
--- a/vendor/github.com/miekg/dns/zduplicate.go
+++ /dev/null
@@ -1,1459 +0,0 @@
-// Code generated by "go run duplicate_generate.go"; DO NOT EDIT.
-
-package dns
-
-// isDuplicate() functions
-
-func (r1 *A) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*A)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if !r1.A.Equal(r2.A) {
-		return false
-	}
-	return true
-}
-
-func (r1 *AAAA) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*AAAA)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if !r1.AAAA.Equal(r2.AAAA) {
-		return false
-	}
-	return true
-}
-
-func (r1 *AFSDB) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*AFSDB)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Subtype != r2.Subtype {
-		return false
-	}
-	if !isDuplicateName(r1.Hostname, r2.Hostname) {
-		return false
-	}
-	return true
-}
-
-func (r1 *AMTRELAY) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*AMTRELAY)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Precedence != r2.Precedence {
-		return false
-	}
-	if r1.GatewayType != r2.GatewayType {
-		return false
-	}
-	switch r1.GatewayType {
-	case IPSECGatewayIPv4, IPSECGatewayIPv6:
-		if !r1.GatewayAddr.Equal(r2.GatewayAddr) {
-			return false
-		}
-	case IPSECGatewayHost:
-		if !isDuplicateName(r1.GatewayHost, r2.GatewayHost) {
-			return false
-		}
-	}
-
-	return true
-}
-
-func (r1 *ANY) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*ANY)
-	if !ok {
-		return false
-	}
-	_ = r2
-	return true
-}
-
-func (r1 *APL) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*APL)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if len(r1.Prefixes) != len(r2.Prefixes) {
-		return false
-	}
-	for i := 0; i < len(r1.Prefixes); i++ {
-		if !r1.Prefixes[i].equals(&r2.Prefixes[i]) {
-			return false
-		}
-	}
-	return true
-}
-
-func (r1 *AVC) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*AVC)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if len(r1.Txt) != len(r2.Txt) {
-		return false
-	}
-	for i := 0; i < len(r1.Txt); i++ {
-		if r1.Txt[i] != r2.Txt[i] {
-			return false
-		}
-	}
-	return true
-}
-
-func (r1 *CAA) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*CAA)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Flag != r2.Flag {
-		return false
-	}
-	if r1.Tag != r2.Tag {
-		return false
-	}
-	if r1.Value != r2.Value {
-		return false
-	}
-	return true
-}
-
-func (r1 *CDNSKEY) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*CDNSKEY)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Flags != r2.Flags {
-		return false
-	}
-	if r1.Protocol != r2.Protocol {
-		return false
-	}
-	if r1.Algorithm != r2.Algorithm {
-		return false
-	}
-	if r1.PublicKey != r2.PublicKey {
-		return false
-	}
-	return true
-}
-
-func (r1 *CDS) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*CDS)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.KeyTag != r2.KeyTag {
-		return false
-	}
-	if r1.Algorithm != r2.Algorithm {
-		return false
-	}
-	if r1.DigestType != r2.DigestType {
-		return false
-	}
-	if r1.Digest != r2.Digest {
-		return false
-	}
-	return true
-}
-
-func (r1 *CERT) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*CERT)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Type != r2.Type {
-		return false
-	}
-	if r1.KeyTag != r2.KeyTag {
-		return false
-	}
-	if r1.Algorithm != r2.Algorithm {
-		return false
-	}
-	if r1.Certificate != r2.Certificate {
-		return false
-	}
-	return true
-}
-
-func (r1 *CNAME) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*CNAME)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if !isDuplicateName(r1.Target, r2.Target) {
-		return false
-	}
-	return true
-}
-
-func (r1 *CSYNC) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*CSYNC)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Serial != r2.Serial {
-		return false
-	}
-	if r1.Flags != r2.Flags {
-		return false
-	}
-	if len(r1.TypeBitMap) != len(r2.TypeBitMap) {
-		return false
-	}
-	for i := 0; i < len(r1.TypeBitMap); i++ {
-		if r1.TypeBitMap[i] != r2.TypeBitMap[i] {
-			return false
-		}
-	}
-	return true
-}
-
-func (r1 *DHCID) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*DHCID)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Digest != r2.Digest {
-		return false
-	}
-	return true
-}
-
-func (r1 *DLV) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*DLV)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.KeyTag != r2.KeyTag {
-		return false
-	}
-	if r1.Algorithm != r2.Algorithm {
-		return false
-	}
-	if r1.DigestType != r2.DigestType {
-		return false
-	}
-	if r1.Digest != r2.Digest {
-		return false
-	}
-	return true
-}
-
-func (r1 *DNAME) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*DNAME)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if !isDuplicateName(r1.Target, r2.Target) {
-		return false
-	}
-	return true
-}
-
-func (r1 *DNSKEY) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*DNSKEY)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Flags != r2.Flags {
-		return false
-	}
-	if r1.Protocol != r2.Protocol {
-		return false
-	}
-	if r1.Algorithm != r2.Algorithm {
-		return false
-	}
-	if r1.PublicKey != r2.PublicKey {
-		return false
-	}
-	return true
-}
-
-func (r1 *DS) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*DS)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.KeyTag != r2.KeyTag {
-		return false
-	}
-	if r1.Algorithm != r2.Algorithm {
-		return false
-	}
-	if r1.DigestType != r2.DigestType {
-		return false
-	}
-	if r1.Digest != r2.Digest {
-		return false
-	}
-	return true
-}
-
-func (r1 *EID) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*EID)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Endpoint != r2.Endpoint {
-		return false
-	}
-	return true
-}
-
-func (r1 *EUI48) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*EUI48)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Address != r2.Address {
-		return false
-	}
-	return true
-}
-
-func (r1 *EUI64) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*EUI64)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Address != r2.Address {
-		return false
-	}
-	return true
-}
-
-func (r1 *GID) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*GID)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Gid != r2.Gid {
-		return false
-	}
-	return true
-}
-
-func (r1 *GPOS) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*GPOS)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Longitude != r2.Longitude {
-		return false
-	}
-	if r1.Latitude != r2.Latitude {
-		return false
-	}
-	if r1.Altitude != r2.Altitude {
-		return false
-	}
-	return true
-}
-
-func (r1 *HINFO) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*HINFO)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Cpu != r2.Cpu {
-		return false
-	}
-	if r1.Os != r2.Os {
-		return false
-	}
-	return true
-}
-
-func (r1 *HIP) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*HIP)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.HitLength != r2.HitLength {
-		return false
-	}
-	if r1.PublicKeyAlgorithm != r2.PublicKeyAlgorithm {
-		return false
-	}
-	if r1.PublicKeyLength != r2.PublicKeyLength {
-		return false
-	}
-	if r1.Hit != r2.Hit {
-		return false
-	}
-	if r1.PublicKey != r2.PublicKey {
-		return false
-	}
-	if len(r1.RendezvousServers) != len(r2.RendezvousServers) {
-		return false
-	}
-	for i := 0; i < len(r1.RendezvousServers); i++ {
-		if !isDuplicateName(r1.RendezvousServers[i], r2.RendezvousServers[i]) {
-			return false
-		}
-	}
-	return true
-}
-
-func (r1 *HTTPS) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*HTTPS)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Priority != r2.Priority {
-		return false
-	}
-	if !isDuplicateName(r1.Target, r2.Target) {
-		return false
-	}
-	if len(r1.Value) != len(r2.Value) {
-		return false
-	}
-	if !areSVCBPairArraysEqual(r1.Value, r2.Value) {
-		return false
-	}
-	return true
-}
-
-func (r1 *IPSECKEY) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*IPSECKEY)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Precedence != r2.Precedence {
-		return false
-	}
-	if r1.GatewayType != r2.GatewayType {
-		return false
-	}
-	if r1.Algorithm != r2.Algorithm {
-		return false
-	}
-	switch r1.GatewayType {
-	case IPSECGatewayIPv4, IPSECGatewayIPv6:
-		if !r1.GatewayAddr.Equal(r2.GatewayAddr) {
-			return false
-		}
-	case IPSECGatewayHost:
-		if !isDuplicateName(r1.GatewayHost, r2.GatewayHost) {
-			return false
-		}
-	}
-
-	if r1.PublicKey != r2.PublicKey {
-		return false
-	}
-	return true
-}
-
-func (r1 *ISDN) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*ISDN)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Address != r2.Address {
-		return false
-	}
-	if r1.SubAddress != r2.SubAddress {
-		return false
-	}
-	return true
-}
-
-func (r1 *KEY) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*KEY)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Flags != r2.Flags {
-		return false
-	}
-	if r1.Protocol != r2.Protocol {
-		return false
-	}
-	if r1.Algorithm != r2.Algorithm {
-		return false
-	}
-	if r1.PublicKey != r2.PublicKey {
-		return false
-	}
-	return true
-}
-
-func (r1 *KX) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*KX)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Preference != r2.Preference {
-		return false
-	}
-	if !isDuplicateName(r1.Exchanger, r2.Exchanger) {
-		return false
-	}
-	return true
-}
-
-func (r1 *L32) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*L32)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Preference != r2.Preference {
-		return false
-	}
-	if !r1.Locator32.Equal(r2.Locator32) {
-		return false
-	}
-	return true
-}
-
-func (r1 *L64) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*L64)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Preference != r2.Preference {
-		return false
-	}
-	if r1.Locator64 != r2.Locator64 {
-		return false
-	}
-	return true
-}
-
-func (r1 *LOC) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*LOC)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Version != r2.Version {
-		return false
-	}
-	if r1.Size != r2.Size {
-		return false
-	}
-	if r1.HorizPre != r2.HorizPre {
-		return false
-	}
-	if r1.VertPre != r2.VertPre {
-		return false
-	}
-	if r1.Latitude != r2.Latitude {
-		return false
-	}
-	if r1.Longitude != r2.Longitude {
-		return false
-	}
-	if r1.Altitude != r2.Altitude {
-		return false
-	}
-	return true
-}
-
-func (r1 *LP) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*LP)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Preference != r2.Preference {
-		return false
-	}
-	if !isDuplicateName(r1.Fqdn, r2.Fqdn) {
-		return false
-	}
-	return true
-}
-
-func (r1 *MB) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*MB)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if !isDuplicateName(r1.Mb, r2.Mb) {
-		return false
-	}
-	return true
-}
-
-func (r1 *MD) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*MD)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if !isDuplicateName(r1.Md, r2.Md) {
-		return false
-	}
-	return true
-}
-
-func (r1 *MF) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*MF)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if !isDuplicateName(r1.Mf, r2.Mf) {
-		return false
-	}
-	return true
-}
-
-func (r1 *MG) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*MG)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if !isDuplicateName(r1.Mg, r2.Mg) {
-		return false
-	}
-	return true
-}
-
-func (r1 *MINFO) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*MINFO)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if !isDuplicateName(r1.Rmail, r2.Rmail) {
-		return false
-	}
-	if !isDuplicateName(r1.Email, r2.Email) {
-		return false
-	}
-	return true
-}
-
-func (r1 *MR) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*MR)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if !isDuplicateName(r1.Mr, r2.Mr) {
-		return false
-	}
-	return true
-}
-
-func (r1 *MX) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*MX)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Preference != r2.Preference {
-		return false
-	}
-	if !isDuplicateName(r1.Mx, r2.Mx) {
-		return false
-	}
-	return true
-}
-
-func (r1 *NAPTR) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*NAPTR)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Order != r2.Order {
-		return false
-	}
-	if r1.Preference != r2.Preference {
-		return false
-	}
-	if r1.Flags != r2.Flags {
-		return false
-	}
-	if r1.Service != r2.Service {
-		return false
-	}
-	if r1.Regexp != r2.Regexp {
-		return false
-	}
-	if !isDuplicateName(r1.Replacement, r2.Replacement) {
-		return false
-	}
-	return true
-}
-
-func (r1 *NID) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*NID)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Preference != r2.Preference {
-		return false
-	}
-	if r1.NodeID != r2.NodeID {
-		return false
-	}
-	return true
-}
-
-func (r1 *NIMLOC) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*NIMLOC)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Locator != r2.Locator {
-		return false
-	}
-	return true
-}
-
-func (r1 *NINFO) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*NINFO)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if len(r1.ZSData) != len(r2.ZSData) {
-		return false
-	}
-	for i := 0; i < len(r1.ZSData); i++ {
-		if r1.ZSData[i] != r2.ZSData[i] {
-			return false
-		}
-	}
-	return true
-}
-
-func (r1 *NS) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*NS)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if !isDuplicateName(r1.Ns, r2.Ns) {
-		return false
-	}
-	return true
-}
-
-func (r1 *NSAPPTR) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*NSAPPTR)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if !isDuplicateName(r1.Ptr, r2.Ptr) {
-		return false
-	}
-	return true
-}
-
-func (r1 *NSEC) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*NSEC)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if !isDuplicateName(r1.NextDomain, r2.NextDomain) {
-		return false
-	}
-	if len(r1.TypeBitMap) != len(r2.TypeBitMap) {
-		return false
-	}
-	for i := 0; i < len(r1.TypeBitMap); i++ {
-		if r1.TypeBitMap[i] != r2.TypeBitMap[i] {
-			return false
-		}
-	}
-	return true
-}
-
-func (r1 *NSEC3) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*NSEC3)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Hash != r2.Hash {
-		return false
-	}
-	if r1.Flags != r2.Flags {
-		return false
-	}
-	if r1.Iterations != r2.Iterations {
-		return false
-	}
-	if r1.SaltLength != r2.SaltLength {
-		return false
-	}
-	if r1.Salt != r2.Salt {
-		return false
-	}
-	if r1.HashLength != r2.HashLength {
-		return false
-	}
-	if r1.NextDomain != r2.NextDomain {
-		return false
-	}
-	if len(r1.TypeBitMap) != len(r2.TypeBitMap) {
-		return false
-	}
-	for i := 0; i < len(r1.TypeBitMap); i++ {
-		if r1.TypeBitMap[i] != r2.TypeBitMap[i] {
-			return false
-		}
-	}
-	return true
-}
-
-func (r1 *NSEC3PARAM) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*NSEC3PARAM)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Hash != r2.Hash {
-		return false
-	}
-	if r1.Flags != r2.Flags {
-		return false
-	}
-	if r1.Iterations != r2.Iterations {
-		return false
-	}
-	if r1.SaltLength != r2.SaltLength {
-		return false
-	}
-	if r1.Salt != r2.Salt {
-		return false
-	}
-	return true
-}
-
-func (r1 *NULL) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*NULL)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Data != r2.Data {
-		return false
-	}
-	return true
-}
-
-func (r1 *NXNAME) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*NXNAME)
-	if !ok {
-		return false
-	}
-	_ = r2
-	return true
-}
-
-func (r1 *NXT) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*NXT)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if !isDuplicateName(r1.NextDomain, r2.NextDomain) {
-		return false
-	}
-	if len(r1.TypeBitMap) != len(r2.TypeBitMap) {
-		return false
-	}
-	for i := 0; i < len(r1.TypeBitMap); i++ {
-		if r1.TypeBitMap[i] != r2.TypeBitMap[i] {
-			return false
-		}
-	}
-	return true
-}
-
-func (r1 *OPENPGPKEY) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*OPENPGPKEY)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.PublicKey != r2.PublicKey {
-		return false
-	}
-	return true
-}
-
-func (r1 *PTR) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*PTR)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if !isDuplicateName(r1.Ptr, r2.Ptr) {
-		return false
-	}
-	return true
-}
-
-func (r1 *PX) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*PX)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Preference != r2.Preference {
-		return false
-	}
-	if !isDuplicateName(r1.Map822, r2.Map822) {
-		return false
-	}
-	if !isDuplicateName(r1.Mapx400, r2.Mapx400) {
-		return false
-	}
-	return true
-}
-
-func (r1 *RESINFO) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*RESINFO)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if len(r1.Txt) != len(r2.Txt) {
-		return false
-	}
-	for i := 0; i < len(r1.Txt); i++ {
-		if r1.Txt[i] != r2.Txt[i] {
-			return false
-		}
-	}
-	return true
-}
-
-func (r1 *RFC3597) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*RFC3597)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Rdata != r2.Rdata {
-		return false
-	}
-	return true
-}
-
-func (r1 *RKEY) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*RKEY)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Flags != r2.Flags {
-		return false
-	}
-	if r1.Protocol != r2.Protocol {
-		return false
-	}
-	if r1.Algorithm != r2.Algorithm {
-		return false
-	}
-	if r1.PublicKey != r2.PublicKey {
-		return false
-	}
-	return true
-}
-
-func (r1 *RP) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*RP)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if !isDuplicateName(r1.Mbox, r2.Mbox) {
-		return false
-	}
-	if !isDuplicateName(r1.Txt, r2.Txt) {
-		return false
-	}
-	return true
-}
-
-func (r1 *RRSIG) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*RRSIG)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.TypeCovered != r2.TypeCovered {
-		return false
-	}
-	if r1.Algorithm != r2.Algorithm {
-		return false
-	}
-	if r1.Labels != r2.Labels {
-		return false
-	}
-	if r1.OrigTtl != r2.OrigTtl {
-		return false
-	}
-	if r1.Expiration != r2.Expiration {
-		return false
-	}
-	if r1.Inception != r2.Inception {
-		return false
-	}
-	if r1.KeyTag != r2.KeyTag {
-		return false
-	}
-	if !isDuplicateName(r1.SignerName, r2.SignerName) {
-		return false
-	}
-	if r1.Signature != r2.Signature {
-		return false
-	}
-	return true
-}
-
-func (r1 *RT) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*RT)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Preference != r2.Preference {
-		return false
-	}
-	if !isDuplicateName(r1.Host, r2.Host) {
-		return false
-	}
-	return true
-}
-
-func (r1 *SIG) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*SIG)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.TypeCovered != r2.TypeCovered {
-		return false
-	}
-	if r1.Algorithm != r2.Algorithm {
-		return false
-	}
-	if r1.Labels != r2.Labels {
-		return false
-	}
-	if r1.OrigTtl != r2.OrigTtl {
-		return false
-	}
-	if r1.Expiration != r2.Expiration {
-		return false
-	}
-	if r1.Inception != r2.Inception {
-		return false
-	}
-	if r1.KeyTag != r2.KeyTag {
-		return false
-	}
-	if !isDuplicateName(r1.SignerName, r2.SignerName) {
-		return false
-	}
-	if r1.Signature != r2.Signature {
-		return false
-	}
-	return true
-}
-
-func (r1 *SMIMEA) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*SMIMEA)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Usage != r2.Usage {
-		return false
-	}
-	if r1.Selector != r2.Selector {
-		return false
-	}
-	if r1.MatchingType != r2.MatchingType {
-		return false
-	}
-	if r1.Certificate != r2.Certificate {
-		return false
-	}
-	return true
-}
-
-func (r1 *SOA) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*SOA)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if !isDuplicateName(r1.Ns, r2.Ns) {
-		return false
-	}
-	if !isDuplicateName(r1.Mbox, r2.Mbox) {
-		return false
-	}
-	if r1.Serial != r2.Serial {
-		return false
-	}
-	if r1.Refresh != r2.Refresh {
-		return false
-	}
-	if r1.Retry != r2.Retry {
-		return false
-	}
-	if r1.Expire != r2.Expire {
-		return false
-	}
-	if r1.Minttl != r2.Minttl {
-		return false
-	}
-	return true
-}
-
-func (r1 *SPF) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*SPF)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if len(r1.Txt) != len(r2.Txt) {
-		return false
-	}
-	for i := 0; i < len(r1.Txt); i++ {
-		if r1.Txt[i] != r2.Txt[i] {
-			return false
-		}
-	}
-	return true
-}
-
-func (r1 *SRV) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*SRV)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Priority != r2.Priority {
-		return false
-	}
-	if r1.Weight != r2.Weight {
-		return false
-	}
-	if r1.Port != r2.Port {
-		return false
-	}
-	if !isDuplicateName(r1.Target, r2.Target) {
-		return false
-	}
-	return true
-}
-
-func (r1 *SSHFP) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*SSHFP)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Algorithm != r2.Algorithm {
-		return false
-	}
-	if r1.Type != r2.Type {
-		return false
-	}
-	if r1.FingerPrint != r2.FingerPrint {
-		return false
-	}
-	return true
-}
-
-func (r1 *SVCB) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*SVCB)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Priority != r2.Priority {
-		return false
-	}
-	if !isDuplicateName(r1.Target, r2.Target) {
-		return false
-	}
-	if len(r1.Value) != len(r2.Value) {
-		return false
-	}
-	if !areSVCBPairArraysEqual(r1.Value, r2.Value) {
-		return false
-	}
-	return true
-}
-
-func (r1 *TA) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*TA)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.KeyTag != r2.KeyTag {
-		return false
-	}
-	if r1.Algorithm != r2.Algorithm {
-		return false
-	}
-	if r1.DigestType != r2.DigestType {
-		return false
-	}
-	if r1.Digest != r2.Digest {
-		return false
-	}
-	return true
-}
-
-func (r1 *TALINK) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*TALINK)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if !isDuplicateName(r1.PreviousName, r2.PreviousName) {
-		return false
-	}
-	if !isDuplicateName(r1.NextName, r2.NextName) {
-		return false
-	}
-	return true
-}
-
-func (r1 *TKEY) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*TKEY)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if !isDuplicateName(r1.Algorithm, r2.Algorithm) {
-		return false
-	}
-	if r1.Inception != r2.Inception {
-		return false
-	}
-	if r1.Expiration != r2.Expiration {
-		return false
-	}
-	if r1.Mode != r2.Mode {
-		return false
-	}
-	if r1.Error != r2.Error {
-		return false
-	}
-	if r1.KeySize != r2.KeySize {
-		return false
-	}
-	if r1.Key != r2.Key {
-		return false
-	}
-	if r1.OtherLen != r2.OtherLen {
-		return false
-	}
-	if r1.OtherData != r2.OtherData {
-		return false
-	}
-	return true
-}
-
-func (r1 *TLSA) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*TLSA)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Usage != r2.Usage {
-		return false
-	}
-	if r1.Selector != r2.Selector {
-		return false
-	}
-	if r1.MatchingType != r2.MatchingType {
-		return false
-	}
-	if r1.Certificate != r2.Certificate {
-		return false
-	}
-	return true
-}
-
-func (r1 *TSIG) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*TSIG)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if !isDuplicateName(r1.Algorithm, r2.Algorithm) {
-		return false
-	}
-	if r1.TimeSigned != r2.TimeSigned {
-		return false
-	}
-	if r1.Fudge != r2.Fudge {
-		return false
-	}
-	if r1.MACSize != r2.MACSize {
-		return false
-	}
-	if r1.MAC != r2.MAC {
-		return false
-	}
-	if r1.OrigId != r2.OrigId {
-		return false
-	}
-	if r1.Error != r2.Error {
-		return false
-	}
-	if r1.OtherLen != r2.OtherLen {
-		return false
-	}
-	if r1.OtherData != r2.OtherData {
-		return false
-	}
-	return true
-}
-
-func (r1 *TXT) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*TXT)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if len(r1.Txt) != len(r2.Txt) {
-		return false
-	}
-	for i := 0; i < len(r1.Txt); i++ {
-		if r1.Txt[i] != r2.Txt[i] {
-			return false
-		}
-	}
-	return true
-}
-
-func (r1 *UID) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*UID)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Uid != r2.Uid {
-		return false
-	}
-	return true
-}
-
-func (r1 *UINFO) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*UINFO)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Uinfo != r2.Uinfo {
-		return false
-	}
-	return true
-}
-
-func (r1 *URI) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*URI)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Priority != r2.Priority {
-		return false
-	}
-	if r1.Weight != r2.Weight {
-		return false
-	}
-	if r1.Target != r2.Target {
-		return false
-	}
-	return true
-}
-
-func (r1 *X25) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*X25)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.PSDNAddress != r2.PSDNAddress {
-		return false
-	}
-	return true
-}
-
-func (r1 *ZONEMD) isDuplicate(_r2 RR) bool {
-	r2, ok := _r2.(*ZONEMD)
-	if !ok {
-		return false
-	}
-	_ = r2
-	if r1.Serial != r2.Serial {
-		return false
-	}
-	if r1.Scheme != r2.Scheme {
-		return false
-	}
-	if r1.Hash != r2.Hash {
-		return false
-	}
-	if r1.Digest != r2.Digest {
-		return false
-	}
-	return true
-}
diff --git a/vendor/github.com/miekg/dns/zmsg.go b/vendor/github.com/miekg/dns/zmsg.go
deleted file mode 100644
index 8143ddc1b9..0000000000
--- a/vendor/github.com/miekg/dns/zmsg.go
+++ /dev/null
@@ -1,3077 +0,0 @@
-// Code generated by "go run msg_generate.go"; DO NOT EDIT.
-
-package dns
-
-import "fmt"
-
-// pack*() functions
-
-func (rr *A) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packDataA(rr.A, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *AAAA) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packDataAAAA(rr.AAAA, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *AFSDB) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.Subtype, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDomainName(rr.Hostname, msg, off, compression, false)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *AMTRELAY) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint8(rr.Precedence, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.GatewayType, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packIPSECGateway(rr.GatewayAddr, rr.GatewayHost, msg, off, rr.GatewayType, compression, false)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *ANY) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	return off, nil
-}
-
-func (rr *APL) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packDataApl(rr.Prefixes, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *AVC) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packStringTxt(rr.Txt, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *CAA) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint8(rr.Flag, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packString(rr.Tag, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringOctet(rr.Value, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *CDNSKEY) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.Flags, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Protocol, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Algorithm, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringBase64(rr.PublicKey, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *CDS) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.KeyTag, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Algorithm, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.DigestType, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringHex(rr.Digest, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *CERT) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.Type, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(rr.KeyTag, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Algorithm, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringBase64(rr.Certificate, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *CNAME) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packDomainName(rr.Target, msg, off, compression, compress)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *CSYNC) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint32(rr.Serial, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(rr.Flags, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDataNsec(rr.TypeBitMap, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *DHCID) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packStringBase64(rr.Digest, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *DLV) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.KeyTag, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Algorithm, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.DigestType, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringHex(rr.Digest, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *DNAME) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packDomainName(rr.Target, msg, off, compression, false)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *DNSKEY) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.Flags, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Protocol, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Algorithm, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringBase64(rr.PublicKey, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *DS) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.KeyTag, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Algorithm, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.DigestType, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringHex(rr.Digest, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *EID) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packStringHex(rr.Endpoint, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *EUI48) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint48(rr.Address, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *EUI64) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint64(rr.Address, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *GID) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint32(rr.Gid, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *GPOS) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packString(rr.Longitude, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packString(rr.Latitude, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packString(rr.Altitude, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *HINFO) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packString(rr.Cpu, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packString(rr.Os, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *HIP) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint8(rr.HitLength, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.PublicKeyAlgorithm, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(rr.PublicKeyLength, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringHex(rr.Hit, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringBase64(rr.PublicKey, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDataDomainNames(rr.RendezvousServers, msg, off, compression, false)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *HTTPS) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.Priority, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDomainName(rr.Target, msg, off, compression, false)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDataSVCB(rr.Value, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *IPSECKEY) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint8(rr.Precedence, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.GatewayType, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Algorithm, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packIPSECGateway(rr.GatewayAddr, rr.GatewayHost, msg, off, rr.GatewayType, compression, false)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringBase64(rr.PublicKey, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *ISDN) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packString(rr.Address, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packString(rr.SubAddress, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *KEY) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.Flags, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Protocol, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Algorithm, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringBase64(rr.PublicKey, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *KX) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.Preference, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDomainName(rr.Exchanger, msg, off, compression, false)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *L32) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.Preference, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDataA(rr.Locator32, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *L64) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.Preference, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint64(rr.Locator64, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *LOC) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint8(rr.Version, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Size, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.HorizPre, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.VertPre, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint32(rr.Latitude, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint32(rr.Longitude, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint32(rr.Altitude, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *LP) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.Preference, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDomainName(rr.Fqdn, msg, off, compression, false)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *MB) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packDomainName(rr.Mb, msg, off, compression, compress)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *MD) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packDomainName(rr.Md, msg, off, compression, compress)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *MF) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packDomainName(rr.Mf, msg, off, compression, compress)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *MG) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packDomainName(rr.Mg, msg, off, compression, compress)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *MINFO) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packDomainName(rr.Rmail, msg, off, compression, compress)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDomainName(rr.Email, msg, off, compression, compress)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *MR) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packDomainName(rr.Mr, msg, off, compression, compress)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *MX) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.Preference, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDomainName(rr.Mx, msg, off, compression, compress)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *NAPTR) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.Order, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(rr.Preference, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packString(rr.Flags, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packString(rr.Service, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packString(rr.Regexp, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDomainName(rr.Replacement, msg, off, compression, false)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *NID) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.Preference, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint64(rr.NodeID, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *NIMLOC) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packStringHex(rr.Locator, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *NINFO) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packStringTxt(rr.ZSData, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *NS) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packDomainName(rr.Ns, msg, off, compression, compress)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *NSAPPTR) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packDomainName(rr.Ptr, msg, off, compression, false)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *NSEC) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packDomainName(rr.NextDomain, msg, off, compression, false)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDataNsec(rr.TypeBitMap, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *NSEC3) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint8(rr.Hash, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Flags, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(rr.Iterations, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.SaltLength, msg, off)
-	if err != nil {
-		return off, err
-	}
-	// Only pack salt if value is not "-", i.e. empty
-	if rr.Salt != "-" {
-		off, err = packStringHex(rr.Salt, msg, off)
-		if err != nil {
-			return off, err
-		}
-	}
-	off, err = packUint8(rr.HashLength, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringBase32(rr.NextDomain, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDataNsec(rr.TypeBitMap, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *NSEC3PARAM) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint8(rr.Hash, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Flags, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(rr.Iterations, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.SaltLength, msg, off)
-	if err != nil {
-		return off, err
-	}
-	// Only pack salt if value is not "-", i.e. empty
-	if rr.Salt != "-" {
-		off, err = packStringHex(rr.Salt, msg, off)
-		if err != nil {
-			return off, err
-		}
-	}
-	return off, nil
-}
-
-func (rr *NULL) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packStringAny(rr.Data, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *NXNAME) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	return off, nil
-}
-
-func (rr *NXT) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packDomainName(rr.NextDomain, msg, off, compression, false)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDataNsec(rr.TypeBitMap, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *OPENPGPKEY) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packStringBase64(rr.PublicKey, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *OPT) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packDataOpt(rr.Option, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *PTR) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packDomainName(rr.Ptr, msg, off, compression, compress)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *PX) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.Preference, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDomainName(rr.Map822, msg, off, compression, false)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDomainName(rr.Mapx400, msg, off, compression, false)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *RESINFO) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packStringTxt(rr.Txt, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *RFC3597) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packStringHex(rr.Rdata, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *RKEY) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.Flags, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Protocol, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Algorithm, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringBase64(rr.PublicKey, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *RP) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packDomainName(rr.Mbox, msg, off, compression, false)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDomainName(rr.Txt, msg, off, compression, false)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *RRSIG) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.TypeCovered, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Algorithm, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Labels, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint32(rr.OrigTtl, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint32(rr.Expiration, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint32(rr.Inception, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(rr.KeyTag, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDomainName(rr.SignerName, msg, off, compression, false)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringBase64(rr.Signature, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *RT) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.Preference, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDomainName(rr.Host, msg, off, compression, false)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *SIG) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.TypeCovered, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Algorithm, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Labels, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint32(rr.OrigTtl, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint32(rr.Expiration, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint32(rr.Inception, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(rr.KeyTag, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDomainName(rr.SignerName, msg, off, compression, false)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringBase64(rr.Signature, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *SMIMEA) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint8(rr.Usage, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Selector, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.MatchingType, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringHex(rr.Certificate, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *SOA) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packDomainName(rr.Ns, msg, off, compression, compress)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDomainName(rr.Mbox, msg, off, compression, compress)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint32(rr.Serial, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint32(rr.Refresh, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint32(rr.Retry, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint32(rr.Expire, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint32(rr.Minttl, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *SPF) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packStringTxt(rr.Txt, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *SRV) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.Priority, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(rr.Weight, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(rr.Port, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDomainName(rr.Target, msg, off, compression, false)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *SSHFP) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint8(rr.Algorithm, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Type, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringHex(rr.FingerPrint, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *SVCB) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.Priority, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDomainName(rr.Target, msg, off, compression, false)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDataSVCB(rr.Value, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *TA) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.KeyTag, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Algorithm, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.DigestType, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringHex(rr.Digest, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *TALINK) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packDomainName(rr.PreviousName, msg, off, compression, false)
-	if err != nil {
-		return off, err
-	}
-	off, err = packDomainName(rr.NextName, msg, off, compression, false)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *TKEY) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packDomainName(rr.Algorithm, msg, off, compression, false)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint32(rr.Inception, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint32(rr.Expiration, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(rr.Mode, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(rr.Error, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(rr.KeySize, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringHex(rr.Key, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(rr.OtherLen, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringHex(rr.OtherData, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *TLSA) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint8(rr.Usage, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Selector, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.MatchingType, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringHex(rr.Certificate, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *TSIG) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packDomainName(rr.Algorithm, msg, off, compression, false)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint48(rr.TimeSigned, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(rr.Fudge, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(rr.MACSize, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringHex(rr.MAC, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(rr.OrigId, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(rr.Error, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(rr.OtherLen, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringHex(rr.OtherData, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *TXT) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packStringTxt(rr.Txt, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *UID) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint32(rr.Uid, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *UINFO) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packString(rr.Uinfo, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *URI) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint16(rr.Priority, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint16(rr.Weight, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringOctet(rr.Target, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *X25) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packString(rr.PSDNAddress, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *ZONEMD) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
-	off, err = packUint32(rr.Serial, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Scheme, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packUint8(rr.Hash, msg, off)
-	if err != nil {
-		return off, err
-	}
-	off, err = packStringHex(rr.Digest, msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-// unpack*() functions
-
-func (rr *A) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.A, off, err = unpackDataA(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("A: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *AAAA) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.AAAA, off, err = unpackDataAAAA(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("AAAA: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *AFSDB) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Subtype, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("AFSDB.Subtype: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Hostname, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("AFSDB.Hostname: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *AMTRELAY) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Precedence, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("AMTRELAY.Precedence: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.GatewayType, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("AMTRELAY.GatewayType: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.GatewayAddr, rr.GatewayHost, off, err = unpackIPSECGateway(msg, off, rr.GatewayType)
-	if err != nil {
-		return off, fmt.Errorf("AMTRELAY.GatewayHost: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *ANY) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	return off, nil
-}
-
-func (rr *APL) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Prefixes, off, err = unpackDataApl(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("APL.Prefixes: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *AVC) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Txt, off, err = unpackStringTxt(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("AVC.Txt: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *CAA) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Flag, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("CAA.Flag: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Tag, off, err = unpackString(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("CAA.Tag: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Value, off, err = unpackStringOctet(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("CAA.Value: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *CDNSKEY) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Flags, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("CDNSKEY.Flags: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Protocol, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("CDNSKEY.Protocol: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Algorithm, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("CDNSKEY.Algorithm: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.PublicKey, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
-	if err != nil {
-		return off, fmt.Errorf("CDNSKEY.PublicKey: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *CDS) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.KeyTag, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("CDS.KeyTag: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Algorithm, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("CDS.Algorithm: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.DigestType, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("CDS.DigestType: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Digest, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
-	if err != nil {
-		return off, fmt.Errorf("CDS.Digest: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *CERT) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Type, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("CERT.Type: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.KeyTag, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("CERT.KeyTag: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Algorithm, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("CERT.Algorithm: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Certificate, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
-	if err != nil {
-		return off, fmt.Errorf("CERT.Certificate: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *CNAME) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Target, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("CNAME.Target: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *CSYNC) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Serial, off, err = unpackUint32(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("CSYNC.Serial: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Flags, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("CSYNC.Flags: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.TypeBitMap, off, err = unpackDataNsec(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("CSYNC.TypeBitMap: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *DHCID) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Digest, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
-	if err != nil {
-		return off, fmt.Errorf("DHCID.Digest: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *DLV) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.KeyTag, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("DLV.KeyTag: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Algorithm, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("DLV.Algorithm: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.DigestType, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("DLV.DigestType: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Digest, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
-	if err != nil {
-		return off, fmt.Errorf("DLV.Digest: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *DNAME) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Target, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("DNAME.Target: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *DNSKEY) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Flags, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("DNSKEY.Flags: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Protocol, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("DNSKEY.Protocol: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Algorithm, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("DNSKEY.Algorithm: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.PublicKey, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
-	if err != nil {
-		return off, fmt.Errorf("DNSKEY.PublicKey: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *DS) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.KeyTag, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("DS.KeyTag: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Algorithm, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("DS.Algorithm: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.DigestType, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("DS.DigestType: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Digest, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
-	if err != nil {
-		return off, fmt.Errorf("DS.Digest: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *EID) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Endpoint, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
-	if err != nil {
-		return off, fmt.Errorf("EID.Endpoint: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *EUI48) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Address, off, err = unpackUint48(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("EUI48.Address: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *EUI64) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Address, off, err = unpackUint64(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("EUI64.Address: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *GID) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Gid, off, err = unpackUint32(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("GID.Gid: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *GPOS) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Longitude, off, err = unpackString(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("GPOS.Longitude: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Latitude, off, err = unpackString(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("GPOS.Latitude: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Altitude, off, err = unpackString(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("GPOS.Altitude: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *HINFO) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Cpu, off, err = unpackString(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("HINFO.Cpu: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Os, off, err = unpackString(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("HINFO.Os: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *HIP) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.HitLength, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("HIP.HitLength: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.PublicKeyAlgorithm, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("HIP.PublicKeyAlgorithm: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.PublicKeyLength, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("HIP.PublicKeyLength: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Hit, off, err = unpackStringHex(msg, off, off+int(rr.HitLength))
-	if err != nil {
-		return off, err
-	}
-	rr.PublicKey, off, err = unpackStringBase64(msg, off, off+int(rr.PublicKeyLength))
-	if err != nil {
-		return off, err
-	}
-	rr.RendezvousServers, off, err = unpackDataDomainNames(msg, off, rdStart+int(rr.Hdr.Rdlength))
-	if err != nil {
-		return off, fmt.Errorf("HIP.RendezvousServers: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *HTTPS) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Priority, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("HTTPS.Priority: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Target, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("HTTPS.Target: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Value, off, err = unpackDataSVCB(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("HTTPS.Value: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *IPSECKEY) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Precedence, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("IPSECKEY.Precedence: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.GatewayType, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("IPSECKEY.GatewayType: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Algorithm, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("IPSECKEY.Algorithm: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.GatewayAddr, rr.GatewayHost, off, err = unpackIPSECGateway(msg, off, rr.GatewayType)
-	if err != nil {
-		return off, fmt.Errorf("IPSECKEY.GatewayHost: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.PublicKey, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
-	if err != nil {
-		return off, fmt.Errorf("IPSECKEY.PublicKey: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *ISDN) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Address, off, err = unpackString(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("ISDN.Address: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.SubAddress, off, err = unpackString(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("ISDN.SubAddress: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *KEY) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Flags, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("KEY.Flags: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Protocol, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("KEY.Protocol: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Algorithm, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("KEY.Algorithm: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.PublicKey, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
-	if err != nil {
-		return off, fmt.Errorf("KEY.PublicKey: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *KX) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Preference, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("KX.Preference: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Exchanger, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("KX.Exchanger: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *L32) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Preference, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("L32.Preference: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Locator32, off, err = unpackDataA(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("L32.Locator32: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *L64) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Preference, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("L64.Preference: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Locator64, off, err = unpackUint64(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("L64.Locator64: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *LOC) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Version, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("LOC.Version: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Size, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("LOC.Size: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.HorizPre, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("LOC.HorizPre: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.VertPre, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("LOC.VertPre: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Latitude, off, err = unpackUint32(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("LOC.Latitude: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Longitude, off, err = unpackUint32(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("LOC.Longitude: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Altitude, off, err = unpackUint32(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("LOC.Altitude: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *LP) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Preference, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("LP.Preference: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Fqdn, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("LP.Fqdn: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *MB) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Mb, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("MB.Mb: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *MD) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Md, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("MD.Md: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *MF) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Mf, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("MF.Mf: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *MG) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Mg, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("MG.Mg: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *MINFO) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Rmail, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("MINFO.Rmail: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Email, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("MINFO.Email: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *MR) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Mr, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("MR.Mr: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *MX) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Preference, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("MX.Preference: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Mx, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("MX.Mx: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *NAPTR) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Order, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NAPTR.Order: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Preference, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NAPTR.Preference: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Flags, off, err = unpackString(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NAPTR.Flags: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Service, off, err = unpackString(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NAPTR.Service: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Regexp, off, err = unpackString(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NAPTR.Regexp: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Replacement, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NAPTR.Replacement: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *NID) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Preference, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NID.Preference: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.NodeID, off, err = unpackUint64(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NID.NodeID: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *NIMLOC) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Locator, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
-	if err != nil {
-		return off, fmt.Errorf("NIMLOC.Locator: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *NINFO) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.ZSData, off, err = unpackStringTxt(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NINFO.ZSData: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *NS) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Ns, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NS.Ns: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *NSAPPTR) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Ptr, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NSAPPTR.Ptr: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *NSEC) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.NextDomain, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NSEC.NextDomain: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.TypeBitMap, off, err = unpackDataNsec(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NSEC.TypeBitMap: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *NSEC3) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Hash, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NSEC3.Hash: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Flags, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NSEC3.Flags: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Iterations, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NSEC3.Iterations: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.SaltLength, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NSEC3.SaltLength: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Salt, off, err = unpackStringHex(msg, off, off+int(rr.SaltLength))
-	if err != nil {
-		return off, err
-	}
-	rr.HashLength, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NSEC3.HashLength: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.NextDomain, off, err = unpackStringBase32(msg, off, off+int(rr.HashLength))
-	if err != nil {
-		return off, err
-	}
-	rr.TypeBitMap, off, err = unpackDataNsec(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NSEC3.TypeBitMap: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *NSEC3PARAM) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Hash, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NSEC3PARAM.Hash: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Flags, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NSEC3PARAM.Flags: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Iterations, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NSEC3PARAM.Iterations: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.SaltLength, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NSEC3PARAM.SaltLength: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Salt, off, err = unpackStringHex(msg, off, off+int(rr.SaltLength))
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *NULL) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Data, off, err = unpackStringAny(msg, off, rdStart+int(rr.Hdr.Rdlength))
-	if err != nil {
-		return off, fmt.Errorf("NULL.Data: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *NXNAME) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	return off, nil
-}
-
-func (rr *NXT) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.NextDomain, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NXT.NextDomain: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.TypeBitMap, off, err = unpackDataNsec(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("NXT.TypeBitMap: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *OPENPGPKEY) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.PublicKey, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
-	if err != nil {
-		return off, fmt.Errorf("OPENPGPKEY.PublicKey: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *OPT) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Option, off, err = unpackDataOpt(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("OPT.Option: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *PTR) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Ptr, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("PTR.Ptr: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *PX) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Preference, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("PX.Preference: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Map822, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("PX.Map822: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Mapx400, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("PX.Mapx400: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *RESINFO) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Txt, off, err = unpackStringTxt(msg, off)
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *RFC3597) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Rdata, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
-	if err != nil {
-		return off, fmt.Errorf("RFC3597.Rdata: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *RKEY) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Flags, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("RKEY.Flags: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Protocol, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("RKEY.Protocol: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Algorithm, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("RKEY.Algorithm: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.PublicKey, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
-	if err != nil {
-		return off, fmt.Errorf("RKEY.PublicKey: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *RP) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Mbox, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("RP.Mbox: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Txt, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("RP.Txt: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *RRSIG) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.TypeCovered, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("RRSIG.TypeCovered: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Algorithm, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("RRSIG.Algorithm: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Labels, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("RRSIG.Labels: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.OrigTtl, off, err = unpackUint32(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("RRSIG.OrigTtl: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Expiration, off, err = unpackUint32(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("RRSIG.Expiration: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Inception, off, err = unpackUint32(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("RRSIG.Inception: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.KeyTag, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("RRSIG.KeyTag: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.SignerName, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("RRSIG.SignerName: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Signature, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
-	if err != nil {
-		return off, fmt.Errorf("RRSIG.Signature: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *RT) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Preference, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("RT.Preference: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Host, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("RT.Host: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *SIG) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.TypeCovered, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SIG.TypeCovered: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Algorithm, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SIG.Algorithm: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Labels, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SIG.Labels: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.OrigTtl, off, err = unpackUint32(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SIG.OrigTtl: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Expiration, off, err = unpackUint32(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SIG.Expiration: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Inception, off, err = unpackUint32(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SIG.Inception: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.KeyTag, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SIG.KeyTag: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.SignerName, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SIG.SignerName: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Signature, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
-	if err != nil {
-		return off, fmt.Errorf("SIG.Signature: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *SMIMEA) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Usage, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SMIMEA.Usage: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Selector, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SMIMEA.Selector: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.MatchingType, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SMIMEA.MatchingType: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Certificate, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
-	if err != nil {
-		return off, fmt.Errorf("SMIMEA.Certificate: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *SOA) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Ns, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SOA.Ns: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Mbox, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SOA.Mbox: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Serial, off, err = unpackUint32(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SOA.Serial: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Refresh, off, err = unpackUint32(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SOA.Refresh: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Retry, off, err = unpackUint32(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SOA.Retry: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Expire, off, err = unpackUint32(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SOA.Expire: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Minttl, off, err = unpackUint32(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SOA.Minttl: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *SPF) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Txt, off, err = unpackStringTxt(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SPF.Txt: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *SRV) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Priority, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SRV.Priority: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Weight, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SRV.Weight: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Port, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SRV.Port: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Target, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SRV.Target: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *SSHFP) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Algorithm, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SSHFP.Algorithm: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Type, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SSHFP.Type: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.FingerPrint, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
-	if err != nil {
-		return off, fmt.Errorf("SSHFP.FingerPrint: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *SVCB) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Priority, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SVCB.Priority: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Target, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SVCB.Target: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Value, off, err = unpackDataSVCB(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("SVCB.Value: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *TA) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.KeyTag, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("TA.KeyTag: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Algorithm, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("TA.Algorithm: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.DigestType, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("TA.DigestType: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Digest, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
-	if err != nil {
-		return off, fmt.Errorf("TA.Digest: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *TALINK) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.PreviousName, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("TALINK.PreviousName: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.NextName, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("TALINK.NextName: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *TKEY) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Algorithm, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("TKEY.Algorithm: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Inception, off, err = unpackUint32(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("TKEY.Inception: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Expiration, off, err = unpackUint32(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("TKEY.Expiration: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Mode, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("TKEY.Mode: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Error, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("TKEY.Error: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.KeySize, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("TKEY.KeySize: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Key, off, err = unpackStringHex(msg, off, off+int(rr.KeySize))
-	if err != nil {
-		return off, err
-	}
-	rr.OtherLen, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("TKEY.OtherLen: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.OtherData, off, err = unpackStringHex(msg, off, off+int(rr.OtherLen))
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *TLSA) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Usage, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("TLSA.Usage: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Selector, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("TLSA.Selector: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.MatchingType, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("TLSA.MatchingType: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Certificate, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
-	if err != nil {
-		return off, fmt.Errorf("TLSA.Certificate: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *TSIG) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Algorithm, off, err = UnpackDomainName(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("TSIG.Algorithm: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.TimeSigned, off, err = unpackUint48(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("TSIG.TimeSigned: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Fudge, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("TSIG.Fudge: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.MACSize, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("TSIG.MACSize: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.MAC, off, err = unpackStringHex(msg, off, off+int(rr.MACSize))
-	if err != nil {
-		return off, err
-	}
-	rr.OrigId, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("TSIG.OrigId: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Error, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("TSIG.Error: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.OtherLen, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("TSIG.OtherLen: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.OtherData, off, err = unpackStringHex(msg, off, off+int(rr.OtherLen))
-	if err != nil {
-		return off, err
-	}
-	return off, nil
-}
-
-func (rr *TXT) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Txt, off, err = unpackStringTxt(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("TXT.Txt: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *UID) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Uid, off, err = unpackUint32(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("UID.Uid: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *UINFO) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Uinfo, off, err = unpackString(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("UINFO.Uinfo: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *URI) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Priority, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("URI.Priority: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Weight, off, err = unpackUint16(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("URI.Weight: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Target, off, err = unpackStringOctet(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("URI.Target: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *X25) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.PSDNAddress, off, err = unpackString(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("X25.PSDNAddress: %w", err)
-	}
-	return off, nil
-}
-
-func (rr *ZONEMD) unpack(msg []byte, off int) (off1 int, err error) {
-	rdStart := off
-	_ = rdStart
-
-	rr.Serial, off, err = unpackUint32(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("ZONEMD.Serial: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Scheme, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("ZONEMD.Scheme: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Hash, off, err = unpackUint8(msg, off)
-	if err != nil {
-		return off, fmt.Errorf("ZONEMD.Hash: %w", err)
-	}
-	if off == len(msg) {
-		return off, nil
-	}
-	rr.Digest, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
-	if err != nil {
-		return off, fmt.Errorf("ZONEMD.Digest: %w", err)
-	}
-	return off, nil
-}
diff --git a/vendor/github.com/miekg/dns/ztypes.go b/vendor/github.com/miekg/dns/ztypes.go
deleted file mode 100644
index cea79ae772..0000000000
--- a/vendor/github.com/miekg/dns/ztypes.go
+++ /dev/null
@@ -1,1353 +0,0 @@
-// Code generated by "go run types_generate.go"; DO NOT EDIT.
-
-package dns
-
-import (
-	"encoding/base64"
-	"net"
-)
-
-// TypeToRR is a map of constructors for each RR type.
-var TypeToRR = map[uint16]func() RR{
-	TypeA:          func() RR { return new(A) },
-	TypeAAAA:       func() RR { return new(AAAA) },
-	TypeAFSDB:      func() RR { return new(AFSDB) },
-	TypeAMTRELAY:   func() RR { return new(AMTRELAY) },
-	TypeANY:        func() RR { return new(ANY) },
-	TypeAPL:        func() RR { return new(APL) },
-	TypeAVC:        func() RR { return new(AVC) },
-	TypeCAA:        func() RR { return new(CAA) },
-	TypeCDNSKEY:    func() RR { return new(CDNSKEY) },
-	TypeCDS:        func() RR { return new(CDS) },
-	TypeCERT:       func() RR { return new(CERT) },
-	TypeCNAME:      func() RR { return new(CNAME) },
-	TypeCSYNC:      func() RR { return new(CSYNC) },
-	TypeDHCID:      func() RR { return new(DHCID) },
-	TypeDLV:        func() RR { return new(DLV) },
-	TypeDNAME:      func() RR { return new(DNAME) },
-	TypeDNSKEY:     func() RR { return new(DNSKEY) },
-	TypeDS:         func() RR { return new(DS) },
-	TypeEID:        func() RR { return new(EID) },
-	TypeEUI48:      func() RR { return new(EUI48) },
-	TypeEUI64:      func() RR { return new(EUI64) },
-	TypeGID:        func() RR { return new(GID) },
-	TypeGPOS:       func() RR { return new(GPOS) },
-	TypeHINFO:      func() RR { return new(HINFO) },
-	TypeHIP:        func() RR { return new(HIP) },
-	TypeHTTPS:      func() RR { return new(HTTPS) },
-	TypeIPSECKEY:   func() RR { return new(IPSECKEY) },
-	TypeISDN:       func() RR { return new(ISDN) },
-	TypeKEY:        func() RR { return new(KEY) },
-	TypeKX:         func() RR { return new(KX) },
-	TypeL32:        func() RR { return new(L32) },
-	TypeL64:        func() RR { return new(L64) },
-	TypeLOC:        func() RR { return new(LOC) },
-	TypeLP:         func() RR { return new(LP) },
-	TypeMB:         func() RR { return new(MB) },
-	TypeMD:         func() RR { return new(MD) },
-	TypeMF:         func() RR { return new(MF) },
-	TypeMG:         func() RR { return new(MG) },
-	TypeMINFO:      func() RR { return new(MINFO) },
-	TypeMR:         func() RR { return new(MR) },
-	TypeMX:         func() RR { return new(MX) },
-	TypeNAPTR:      func() RR { return new(NAPTR) },
-	TypeNID:        func() RR { return new(NID) },
-	TypeNIMLOC:     func() RR { return new(NIMLOC) },
-	TypeNINFO:      func() RR { return new(NINFO) },
-	TypeNS:         func() RR { return new(NS) },
-	TypeNSAPPTR:    func() RR { return new(NSAPPTR) },
-	TypeNSEC:       func() RR { return new(NSEC) },
-	TypeNSEC3:      func() RR { return new(NSEC3) },
-	TypeNSEC3PARAM: func() RR { return new(NSEC3PARAM) },
-	TypeNULL:       func() RR { return new(NULL) },
-	TypeNXNAME:     func() RR { return new(NXNAME) },
-	TypeNXT:        func() RR { return new(NXT) },
-	TypeOPENPGPKEY: func() RR { return new(OPENPGPKEY) },
-	TypeOPT:        func() RR { return new(OPT) },
-	TypePTR:        func() RR { return new(PTR) },
-	TypePX:         func() RR { return new(PX) },
-	TypeRESINFO:    func() RR { return new(RESINFO) },
-	TypeRKEY:       func() RR { return new(RKEY) },
-	TypeRP:         func() RR { return new(RP) },
-	TypeRRSIG:      func() RR { return new(RRSIG) },
-	TypeRT:         func() RR { return new(RT) },
-	TypeSIG:        func() RR { return new(SIG) },
-	TypeSMIMEA:     func() RR { return new(SMIMEA) },
-	TypeSOA:        func() RR { return new(SOA) },
-	TypeSPF:        func() RR { return new(SPF) },
-	TypeSRV:        func() RR { return new(SRV) },
-	TypeSSHFP:      func() RR { return new(SSHFP) },
-	TypeSVCB:       func() RR { return new(SVCB) },
-	TypeTA:         func() RR { return new(TA) },
-	TypeTALINK:     func() RR { return new(TALINK) },
-	TypeTKEY:       func() RR { return new(TKEY) },
-	TypeTLSA:       func() RR { return new(TLSA) },
-	TypeTSIG:       func() RR { return new(TSIG) },
-	TypeTXT:        func() RR { return new(TXT) },
-	TypeUID:        func() RR { return new(UID) },
-	TypeUINFO:      func() RR { return new(UINFO) },
-	TypeURI:        func() RR { return new(URI) },
-	TypeX25:        func() RR { return new(X25) },
-	TypeZONEMD:     func() RR { return new(ZONEMD) },
-}
-
-// TypeToString is a map of strings for each RR type.
-var TypeToString = map[uint16]string{
-	TypeA:          "A",
-	TypeAAAA:       "AAAA",
-	TypeAFSDB:      "AFSDB",
-	TypeAMTRELAY:   "AMTRELAY",
-	TypeANY:        "ANY",
-	TypeAPL:        "APL",
-	TypeATMA:       "ATMA",
-	TypeAVC:        "AVC",
-	TypeAXFR:       "AXFR",
-	TypeCAA:        "CAA",
-	TypeCDNSKEY:    "CDNSKEY",
-	TypeCDS:        "CDS",
-	TypeCERT:       "CERT",
-	TypeCNAME:      "CNAME",
-	TypeCSYNC:      "CSYNC",
-	TypeDHCID:      "DHCID",
-	TypeDLV:        "DLV",
-	TypeDNAME:      "DNAME",
-	TypeDNSKEY:     "DNSKEY",
-	TypeDS:         "DS",
-	TypeEID:        "EID",
-	TypeEUI48:      "EUI48",
-	TypeEUI64:      "EUI64",
-	TypeGID:        "GID",
-	TypeGPOS:       "GPOS",
-	TypeHINFO:      "HINFO",
-	TypeHIP:        "HIP",
-	TypeHTTPS:      "HTTPS",
-	TypeIPSECKEY:   "IPSECKEY",
-	TypeISDN:       "ISDN",
-	TypeIXFR:       "IXFR",
-	TypeKEY:        "KEY",
-	TypeKX:         "KX",
-	TypeL32:        "L32",
-	TypeL64:        "L64",
-	TypeLOC:        "LOC",
-	TypeLP:         "LP",
-	TypeMAILA:      "MAILA",
-	TypeMAILB:      "MAILB",
-	TypeMB:         "MB",
-	TypeMD:         "MD",
-	TypeMF:         "MF",
-	TypeMG:         "MG",
-	TypeMINFO:      "MINFO",
-	TypeMR:         "MR",
-	TypeMX:         "MX",
-	TypeNAPTR:      "NAPTR",
-	TypeNID:        "NID",
-	TypeNIMLOC:     "NIMLOC",
-	TypeNINFO:      "NINFO",
-	TypeNS:         "NS",
-	TypeNSEC:       "NSEC",
-	TypeNSEC3:      "NSEC3",
-	TypeNSEC3PARAM: "NSEC3PARAM",
-	TypeNULL:       "NULL",
-	TypeNXNAME:     "NXNAME",
-	TypeNXT:        "NXT",
-	TypeNone:       "None",
-	TypeOPENPGPKEY: "OPENPGPKEY",
-	TypeOPT:        "OPT",
-	TypePTR:        "PTR",
-	TypePX:         "PX",
-	TypeRESINFO:    "RESINFO",
-	TypeRKEY:       "RKEY",
-	TypeRP:         "RP",
-	TypeRRSIG:      "RRSIG",
-	TypeRT:         "RT",
-	TypeReserved:   "Reserved",
-	TypeSIG:        "SIG",
-	TypeSMIMEA:     "SMIMEA",
-	TypeSOA:        "SOA",
-	TypeSPF:        "SPF",
-	TypeSRV:        "SRV",
-	TypeSSHFP:      "SSHFP",
-	TypeSVCB:       "SVCB",
-	TypeTA:         "TA",
-	TypeTALINK:     "TALINK",
-	TypeTKEY:       "TKEY",
-	TypeTLSA:       "TLSA",
-	TypeTSIG:       "TSIG",
-	TypeTXT:        "TXT",
-	TypeUID:        "UID",
-	TypeUINFO:      "UINFO",
-	TypeUNSPEC:     "UNSPEC",
-	TypeURI:        "URI",
-	TypeX25:        "X25",
-	TypeZONEMD:     "ZONEMD",
-	TypeNSAPPTR:    "NSAP-PTR",
-}
-
-func (rr *A) Header() *RR_Header          { return &rr.Hdr }
-func (rr *AAAA) Header() *RR_Header       { return &rr.Hdr }
-func (rr *AFSDB) Header() *RR_Header      { return &rr.Hdr }
-func (rr *AMTRELAY) Header() *RR_Header   { return &rr.Hdr }
-func (rr *ANY) Header() *RR_Header        { return &rr.Hdr }
-func (rr *APL) Header() *RR_Header        { return &rr.Hdr }
-func (rr *AVC) Header() *RR_Header        { return &rr.Hdr }
-func (rr *CAA) Header() *RR_Header        { return &rr.Hdr }
-func (rr *CDNSKEY) Header() *RR_Header    { return &rr.Hdr }
-func (rr *CDS) Header() *RR_Header        { return &rr.Hdr }
-func (rr *CERT) Header() *RR_Header       { return &rr.Hdr }
-func (rr *CNAME) Header() *RR_Header      { return &rr.Hdr }
-func (rr *CSYNC) Header() *RR_Header      { return &rr.Hdr }
-func (rr *DHCID) Header() *RR_Header      { return &rr.Hdr }
-func (rr *DLV) Header() *RR_Header        { return &rr.Hdr }
-func (rr *DNAME) Header() *RR_Header      { return &rr.Hdr }
-func (rr *DNSKEY) Header() *RR_Header     { return &rr.Hdr }
-func (rr *DS) Header() *RR_Header         { return &rr.Hdr }
-func (rr *EID) Header() *RR_Header        { return &rr.Hdr }
-func (rr *EUI48) Header() *RR_Header      { return &rr.Hdr }
-func (rr *EUI64) Header() *RR_Header      { return &rr.Hdr }
-func (rr *GID) Header() *RR_Header        { return &rr.Hdr }
-func (rr *GPOS) Header() *RR_Header       { return &rr.Hdr }
-func (rr *HINFO) Header() *RR_Header      { return &rr.Hdr }
-func (rr *HIP) Header() *RR_Header        { return &rr.Hdr }
-func (rr *HTTPS) Header() *RR_Header      { return &rr.Hdr }
-func (rr *IPSECKEY) Header() *RR_Header   { return &rr.Hdr }
-func (rr *ISDN) Header() *RR_Header       { return &rr.Hdr }
-func (rr *KEY) Header() *RR_Header        { return &rr.Hdr }
-func (rr *KX) Header() *RR_Header         { return &rr.Hdr }
-func (rr *L32) Header() *RR_Header        { return &rr.Hdr }
-func (rr *L64) Header() *RR_Header        { return &rr.Hdr }
-func (rr *LOC) Header() *RR_Header        { return &rr.Hdr }
-func (rr *LP) Header() *RR_Header         { return &rr.Hdr }
-func (rr *MB) Header() *RR_Header         { return &rr.Hdr }
-func (rr *MD) Header() *RR_Header         { return &rr.Hdr }
-func (rr *MF) Header() *RR_Header         { return &rr.Hdr }
-func (rr *MG) Header() *RR_Header         { return &rr.Hdr }
-func (rr *MINFO) Header() *RR_Header      { return &rr.Hdr }
-func (rr *MR) Header() *RR_Header         { return &rr.Hdr }
-func (rr *MX) Header() *RR_Header         { return &rr.Hdr }
-func (rr *NAPTR) Header() *RR_Header      { return &rr.Hdr }
-func (rr *NID) Header() *RR_Header        { return &rr.Hdr }
-func (rr *NIMLOC) Header() *RR_Header     { return &rr.Hdr }
-func (rr *NINFO) Header() *RR_Header      { return &rr.Hdr }
-func (rr *NS) Header() *RR_Header         { return &rr.Hdr }
-func (rr *NSAPPTR) Header() *RR_Header    { return &rr.Hdr }
-func (rr *NSEC) Header() *RR_Header       { return &rr.Hdr }
-func (rr *NSEC3) Header() *RR_Header      { return &rr.Hdr }
-func (rr *NSEC3PARAM) Header() *RR_Header { return &rr.Hdr }
-func (rr *NULL) Header() *RR_Header       { return &rr.Hdr }
-func (rr *NXNAME) Header() *RR_Header     { return &rr.Hdr }
-func (rr *NXT) Header() *RR_Header        { return &rr.Hdr }
-func (rr *OPENPGPKEY) Header() *RR_Header { return &rr.Hdr }
-func (rr *OPT) Header() *RR_Header        { return &rr.Hdr }
-func (rr *PTR) Header() *RR_Header        { return &rr.Hdr }
-func (rr *PX) Header() *RR_Header         { return &rr.Hdr }
-func (rr *RESINFO) Header() *RR_Header    { return &rr.Hdr }
-func (rr *RFC3597) Header() *RR_Header    { return &rr.Hdr }
-func (rr *RKEY) Header() *RR_Header       { return &rr.Hdr }
-func (rr *RP) Header() *RR_Header         { return &rr.Hdr }
-func (rr *RRSIG) Header() *RR_Header      { return &rr.Hdr }
-func (rr *RT) Header() *RR_Header         { return &rr.Hdr }
-func (rr *SIG) Header() *RR_Header        { return &rr.Hdr }
-func (rr *SMIMEA) Header() *RR_Header     { return &rr.Hdr }
-func (rr *SOA) Header() *RR_Header        { return &rr.Hdr }
-func (rr *SPF) Header() *RR_Header        { return &rr.Hdr }
-func (rr *SRV) Header() *RR_Header        { return &rr.Hdr }
-func (rr *SSHFP) Header() *RR_Header      { return &rr.Hdr }
-func (rr *SVCB) Header() *RR_Header       { return &rr.Hdr }
-func (rr *TA) Header() *RR_Header         { return &rr.Hdr }
-func (rr *TALINK) Header() *RR_Header     { return &rr.Hdr }
-func (rr *TKEY) Header() *RR_Header       { return &rr.Hdr }
-func (rr *TLSA) Header() *RR_Header       { return &rr.Hdr }
-func (rr *TSIG) Header() *RR_Header       { return &rr.Hdr }
-func (rr *TXT) Header() *RR_Header        { return &rr.Hdr }
-func (rr *UID) Header() *RR_Header        { return &rr.Hdr }
-func (rr *UINFO) Header() *RR_Header      { return &rr.Hdr }
-func (rr *URI) Header() *RR_Header        { return &rr.Hdr }
-func (rr *X25) Header() *RR_Header        { return &rr.Hdr }
-func (rr *ZONEMD) Header() *RR_Header     { return &rr.Hdr }
-
-// len() functions
-func (rr *A) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	if len(rr.A) != 0 {
-		l += net.IPv4len
-	}
-	return l
-}
-
-func (rr *AAAA) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	if len(rr.AAAA) != 0 {
-		l += net.IPv6len
-	}
-	return l
-}
-
-func (rr *AFSDB) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 2 // Subtype
-	l += domainNameLen(rr.Hostname, off+l, compression, false)
-	return l
-}
-
-func (rr *AMTRELAY) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l++ // Precedence
-	l++ // GatewayType
-	switch rr.GatewayType {
-	case AMTRELAYIPv4:
-		l += net.IPv4len
-	case AMTRELAYIPv6:
-		l += net.IPv6len
-	case AMTRELAYHost:
-		l += len(rr.GatewayHost) + 1
-	}
-	return l
-}
-
-func (rr *ANY) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	return l
-}
-
-func (rr *APL) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	for _, x := range rr.Prefixes {
-		l += x.len()
-	}
-	return l
-}
-
-func (rr *AVC) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	for _, x := range rr.Txt {
-		l += len(x) + 1
-	}
-	return l
-}
-
-func (rr *CAA) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l++ // Flag
-	l += len(rr.Tag) + 1
-	l += len(rr.Value)
-	return l
-}
-
-func (rr *CERT) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 2 // Type
-	l += 2 // KeyTag
-	l++    // Algorithm
-	l += base64.StdEncoding.DecodedLen(len(rr.Certificate))
-	return l
-}
-
-func (rr *CNAME) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += domainNameLen(rr.Target, off+l, compression, true)
-	return l
-}
-
-func (rr *DHCID) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += base64.StdEncoding.DecodedLen(len(rr.Digest))
-	return l
-}
-
-func (rr *DNAME) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += domainNameLen(rr.Target, off+l, compression, false)
-	return l
-}
-
-func (rr *DNSKEY) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 2 // Flags
-	l++    // Protocol
-	l++    // Algorithm
-	l += base64.StdEncoding.DecodedLen(len(rr.PublicKey))
-	return l
-}
-
-func (rr *DS) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 2 // KeyTag
-	l++    // Algorithm
-	l++    // DigestType
-	l += len(rr.Digest) / 2
-	return l
-}
-
-func (rr *EID) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += len(rr.Endpoint) / 2
-	return l
-}
-
-func (rr *EUI48) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 6 // Address
-	return l
-}
-
-func (rr *EUI64) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 8 // Address
-	return l
-}
-
-func (rr *GID) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 4 // Gid
-	return l
-}
-
-func (rr *GPOS) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += len(rr.Longitude) + 1
-	l += len(rr.Latitude) + 1
-	l += len(rr.Altitude) + 1
-	return l
-}
-
-func (rr *HINFO) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += len(rr.Cpu) + 1
-	l += len(rr.Os) + 1
-	return l
-}
-
-func (rr *HIP) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l++    // HitLength
-	l++    // PublicKeyAlgorithm
-	l += 2 // PublicKeyLength
-	l += len(rr.Hit) / 2
-	l += base64.StdEncoding.DecodedLen(len(rr.PublicKey))
-	for _, x := range rr.RendezvousServers {
-		l += domainNameLen(x, off+l, compression, false)
-	}
-	return l
-}
-
-func (rr *IPSECKEY) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l++ // Precedence
-	l++ // GatewayType
-	l++ // Algorithm
-	switch rr.GatewayType {
-	case IPSECGatewayIPv4:
-		l += net.IPv4len
-	case IPSECGatewayIPv6:
-		l += net.IPv6len
-	case IPSECGatewayHost:
-		l += len(rr.GatewayHost) + 1
-	}
-	l += base64.StdEncoding.DecodedLen(len(rr.PublicKey))
-	return l
-}
-
-func (rr *ISDN) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += len(rr.Address) + 1
-	l += len(rr.SubAddress) + 1
-	return l
-}
-
-func (rr *KX) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 2 // Preference
-	l += domainNameLen(rr.Exchanger, off+l, compression, false)
-	return l
-}
-
-func (rr *L32) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 2 // Preference
-	if len(rr.Locator32) != 0 {
-		l += net.IPv4len
-	}
-	return l
-}
-
-func (rr *L64) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 2 // Preference
-	l += 8 // Locator64
-	return l
-}
-
-func (rr *LOC) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l++    // Version
-	l++    // Size
-	l++    // HorizPre
-	l++    // VertPre
-	l += 4 // Latitude
-	l += 4 // Longitude
-	l += 4 // Altitude
-	return l
-}
-
-func (rr *LP) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 2 // Preference
-	l += domainNameLen(rr.Fqdn, off+l, compression, false)
-	return l
-}
-
-func (rr *MB) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += domainNameLen(rr.Mb, off+l, compression, true)
-	return l
-}
-
-func (rr *MD) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += domainNameLen(rr.Md, off+l, compression, true)
-	return l
-}
-
-func (rr *MF) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += domainNameLen(rr.Mf, off+l, compression, true)
-	return l
-}
-
-func (rr *MG) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += domainNameLen(rr.Mg, off+l, compression, true)
-	return l
-}
-
-func (rr *MINFO) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += domainNameLen(rr.Rmail, off+l, compression, true)
-	l += domainNameLen(rr.Email, off+l, compression, true)
-	return l
-}
-
-func (rr *MR) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += domainNameLen(rr.Mr, off+l, compression, true)
-	return l
-}
-
-func (rr *MX) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 2 // Preference
-	l += domainNameLen(rr.Mx, off+l, compression, true)
-	return l
-}
-
-func (rr *NAPTR) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 2 // Order
-	l += 2 // Preference
-	l += len(rr.Flags) + 1
-	l += len(rr.Service) + 1
-	l += len(rr.Regexp) + 1
-	l += domainNameLen(rr.Replacement, off+l, compression, false)
-	return l
-}
-
-func (rr *NID) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 2 // Preference
-	l += 8 // NodeID
-	return l
-}
-
-func (rr *NIMLOC) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += len(rr.Locator) / 2
-	return l
-}
-
-func (rr *NINFO) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	for _, x := range rr.ZSData {
-		l += len(x) + 1
-	}
-	return l
-}
-
-func (rr *NS) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += domainNameLen(rr.Ns, off+l, compression, true)
-	return l
-}
-
-func (rr *NSAPPTR) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += domainNameLen(rr.Ptr, off+l, compression, false)
-	return l
-}
-
-func (rr *NSEC3PARAM) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l++    // Hash
-	l++    // Flags
-	l += 2 // Iterations
-	l++    // SaltLength
-	l += len(rr.Salt) / 2
-	return l
-}
-
-func (rr *NULL) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += len(rr.Data)
-	return l
-}
-
-func (rr *NXNAME) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	return l
-}
-
-func (rr *OPENPGPKEY) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += base64.StdEncoding.DecodedLen(len(rr.PublicKey))
-	return l
-}
-
-func (rr *PTR) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += domainNameLen(rr.Ptr, off+l, compression, true)
-	return l
-}
-
-func (rr *PX) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 2 // Preference
-	l += domainNameLen(rr.Map822, off+l, compression, false)
-	l += domainNameLen(rr.Mapx400, off+l, compression, false)
-	return l
-}
-
-func (rr *RESINFO) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	for _, x := range rr.Txt {
-		l += len(x) + 1
-	}
-	return l
-}
-
-func (rr *RFC3597) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += len(rr.Rdata) / 2
-	return l
-}
-
-func (rr *RKEY) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 2 // Flags
-	l++    // Protocol
-	l++    // Algorithm
-	l += base64.StdEncoding.DecodedLen(len(rr.PublicKey))
-	return l
-}
-
-func (rr *RP) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += domainNameLen(rr.Mbox, off+l, compression, false)
-	l += domainNameLen(rr.Txt, off+l, compression, false)
-	return l
-}
-
-func (rr *RRSIG) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 2 // TypeCovered
-	l++    // Algorithm
-	l++    // Labels
-	l += 4 // OrigTtl
-	l += 4 // Expiration
-	l += 4 // Inception
-	l += 2 // KeyTag
-	l += domainNameLen(rr.SignerName, off+l, compression, false)
-	l += base64.StdEncoding.DecodedLen(len(rr.Signature))
-	return l
-}
-
-func (rr *RT) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 2 // Preference
-	l += domainNameLen(rr.Host, off+l, compression, false)
-	return l
-}
-
-func (rr *SMIMEA) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l++ // Usage
-	l++ // Selector
-	l++ // MatchingType
-	l += len(rr.Certificate) / 2
-	return l
-}
-
-func (rr *SOA) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += domainNameLen(rr.Ns, off+l, compression, true)
-	l += domainNameLen(rr.Mbox, off+l, compression, true)
-	l += 4 // Serial
-	l += 4 // Refresh
-	l += 4 // Retry
-	l += 4 // Expire
-	l += 4 // Minttl
-	return l
-}
-
-func (rr *SPF) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	for _, x := range rr.Txt {
-		l += len(x) + 1
-	}
-	return l
-}
-
-func (rr *SRV) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 2 // Priority
-	l += 2 // Weight
-	l += 2 // Port
-	l += domainNameLen(rr.Target, off+l, compression, false)
-	return l
-}
-
-func (rr *SSHFP) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l++ // Algorithm
-	l++ // Type
-	l += len(rr.FingerPrint) / 2
-	return l
-}
-
-func (rr *SVCB) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 2 // Priority
-	l += domainNameLen(rr.Target, off+l, compression, false)
-	for _, x := range rr.Value {
-		l += 4 + int(x.len())
-	}
-	return l
-}
-
-func (rr *TA) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 2 // KeyTag
-	l++    // Algorithm
-	l++    // DigestType
-	l += len(rr.Digest) / 2
-	return l
-}
-
-func (rr *TALINK) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += domainNameLen(rr.PreviousName, off+l, compression, false)
-	l += domainNameLen(rr.NextName, off+l, compression, false)
-	return l
-}
-
-func (rr *TKEY) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += domainNameLen(rr.Algorithm, off+l, compression, false)
-	l += 4 // Inception
-	l += 4 // Expiration
-	l += 2 // Mode
-	l += 2 // Error
-	l += 2 // KeySize
-	l += len(rr.Key) / 2
-	l += 2 // OtherLen
-	l += len(rr.OtherData) / 2
-	return l
-}
-
-func (rr *TLSA) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l++ // Usage
-	l++ // Selector
-	l++ // MatchingType
-	l += len(rr.Certificate) / 2
-	return l
-}
-
-func (rr *TSIG) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += domainNameLen(rr.Algorithm, off+l, compression, false)
-	l += 6 // TimeSigned
-	l += 2 // Fudge
-	l += 2 // MACSize
-	l += len(rr.MAC) / 2
-	l += 2 // OrigId
-	l += 2 // Error
-	l += 2 // OtherLen
-	l += len(rr.OtherData) / 2
-	return l
-}
-
-func (rr *TXT) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	for _, x := range rr.Txt {
-		l += len(x) + 1
-	}
-	return l
-}
-
-func (rr *UID) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 4 // Uid
-	return l
-}
-
-func (rr *UINFO) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += len(rr.Uinfo) + 1
-	return l
-}
-
-func (rr *URI) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 2 // Priority
-	l += 2 // Weight
-	l += len(rr.Target)
-	return l
-}
-
-func (rr *X25) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += len(rr.PSDNAddress) + 1
-	return l
-}
-
-func (rr *ZONEMD) len(off int, compression map[string]struct{}) int {
-	l := rr.Hdr.len(off, compression)
-	l += 4 // Serial
-	l++    // Scheme
-	l++    // Hash
-	l += len(rr.Digest) / 2
-	return l
-}
-
-// copy() functions
-func (rr *A) copy() RR {
-	return &A{rr.Hdr, cloneSlice(rr.A)}
-}
-
-func (rr *AAAA) copy() RR {
-	return &AAAA{rr.Hdr, cloneSlice(rr.AAAA)}
-}
-
-func (rr *AFSDB) copy() RR {
-	return &AFSDB{rr.Hdr, rr.Subtype, rr.Hostname}
-}
-
-func (rr *AMTRELAY) copy() RR {
-	return &AMTRELAY{
-		rr.Hdr,
-		rr.Precedence,
-		rr.GatewayType,
-		cloneSlice(rr.GatewayAddr),
-		rr.GatewayHost,
-	}
-}
-
-func (rr *ANY) copy() RR {
-	return &ANY{rr.Hdr}
-}
-
-func (rr *APL) copy() RR {
-	Prefixes := make([]APLPrefix, len(rr.Prefixes))
-	for i, e := range rr.Prefixes {
-		Prefixes[i] = e.copy()
-	}
-	return &APL{rr.Hdr, Prefixes}
-}
-
-func (rr *AVC) copy() RR {
-	return &AVC{rr.Hdr, cloneSlice(rr.Txt)}
-}
-
-func (rr *CAA) copy() RR {
-	return &CAA{
-		rr.Hdr,
-		rr.Flag,
-		rr.Tag,
-		rr.Value,
-	}
-}
-
-func (rr *CDNSKEY) copy() RR {
-	return &CDNSKEY{*rr.DNSKEY.copy().(*DNSKEY)}
-}
-
-func (rr *CDS) copy() RR {
-	return &CDS{*rr.DS.copy().(*DS)}
-}
-
-func (rr *CERT) copy() RR {
-	return &CERT{
-		rr.Hdr,
-		rr.Type,
-		rr.KeyTag,
-		rr.Algorithm,
-		rr.Certificate,
-	}
-}
-
-func (rr *CNAME) copy() RR {
-	return &CNAME{rr.Hdr, rr.Target}
-}
-
-func (rr *CSYNC) copy() RR {
-	return &CSYNC{
-		rr.Hdr,
-		rr.Serial,
-		rr.Flags,
-		cloneSlice(rr.TypeBitMap),
-	}
-}
-
-func (rr *DHCID) copy() RR {
-	return &DHCID{rr.Hdr, rr.Digest}
-}
-
-func (rr *DLV) copy() RR {
-	return &DLV{*rr.DS.copy().(*DS)}
-}
-
-func (rr *DNAME) copy() RR {
-	return &DNAME{rr.Hdr, rr.Target}
-}
-
-func (rr *DNSKEY) copy() RR {
-	return &DNSKEY{
-		rr.Hdr,
-		rr.Flags,
-		rr.Protocol,
-		rr.Algorithm,
-		rr.PublicKey,
-	}
-}
-
-func (rr *DS) copy() RR {
-	return &DS{
-		rr.Hdr,
-		rr.KeyTag,
-		rr.Algorithm,
-		rr.DigestType,
-		rr.Digest,
-	}
-}
-
-func (rr *EID) copy() RR {
-	return &EID{rr.Hdr, rr.Endpoint}
-}
-
-func (rr *EUI48) copy() RR {
-	return &EUI48{rr.Hdr, rr.Address}
-}
-
-func (rr *EUI64) copy() RR {
-	return &EUI64{rr.Hdr, rr.Address}
-}
-
-func (rr *GID) copy() RR {
-	return &GID{rr.Hdr, rr.Gid}
-}
-
-func (rr *GPOS) copy() RR {
-	return &GPOS{
-		rr.Hdr,
-		rr.Longitude,
-		rr.Latitude,
-		rr.Altitude,
-	}
-}
-
-func (rr *HINFO) copy() RR {
-	return &HINFO{rr.Hdr, rr.Cpu, rr.Os}
-}
-
-func (rr *HIP) copy() RR {
-	return &HIP{
-		rr.Hdr,
-		rr.HitLength,
-		rr.PublicKeyAlgorithm,
-		rr.PublicKeyLength,
-		rr.Hit,
-		rr.PublicKey,
-		cloneSlice(rr.RendezvousServers),
-	}
-}
-
-func (rr *HTTPS) copy() RR {
-	return &HTTPS{*rr.SVCB.copy().(*SVCB)}
-}
-
-func (rr *IPSECKEY) copy() RR {
-	return &IPSECKEY{
-		rr.Hdr,
-		rr.Precedence,
-		rr.GatewayType,
-		rr.Algorithm,
-		cloneSlice(rr.GatewayAddr),
-		rr.GatewayHost,
-		rr.PublicKey,
-	}
-}
-
-func (rr *ISDN) copy() RR {
-	return &ISDN{rr.Hdr, rr.Address, rr.SubAddress}
-}
-
-func (rr *KEY) copy() RR {
-	return &KEY{*rr.DNSKEY.copy().(*DNSKEY)}
-}
-
-func (rr *KX) copy() RR {
-	return &KX{rr.Hdr, rr.Preference, rr.Exchanger}
-}
-
-func (rr *L32) copy() RR {
-	return &L32{rr.Hdr, rr.Preference, cloneSlice(rr.Locator32)}
-}
-
-func (rr *L64) copy() RR {
-	return &L64{rr.Hdr, rr.Preference, rr.Locator64}
-}
-
-func (rr *LOC) copy() RR {
-	return &LOC{
-		rr.Hdr,
-		rr.Version,
-		rr.Size,
-		rr.HorizPre,
-		rr.VertPre,
-		rr.Latitude,
-		rr.Longitude,
-		rr.Altitude,
-	}
-}
-
-func (rr *LP) copy() RR {
-	return &LP{rr.Hdr, rr.Preference, rr.Fqdn}
-}
-
-func (rr *MB) copy() RR {
-	return &MB{rr.Hdr, rr.Mb}
-}
-
-func (rr *MD) copy() RR {
-	return &MD{rr.Hdr, rr.Md}
-}
-
-func (rr *MF) copy() RR {
-	return &MF{rr.Hdr, rr.Mf}
-}
-
-func (rr *MG) copy() RR {
-	return &MG{rr.Hdr, rr.Mg}
-}
-
-func (rr *MINFO) copy() RR {
-	return &MINFO{rr.Hdr, rr.Rmail, rr.Email}
-}
-
-func (rr *MR) copy() RR {
-	return &MR{rr.Hdr, rr.Mr}
-}
-
-func (rr *MX) copy() RR {
-	return &MX{rr.Hdr, rr.Preference, rr.Mx}
-}
-
-func (rr *NAPTR) copy() RR {
-	return &NAPTR{
-		rr.Hdr,
-		rr.Order,
-		rr.Preference,
-		rr.Flags,
-		rr.Service,
-		rr.Regexp,
-		rr.Replacement,
-	}
-}
-
-func (rr *NID) copy() RR {
-	return &NID{rr.Hdr, rr.Preference, rr.NodeID}
-}
-
-func (rr *NIMLOC) copy() RR {
-	return &NIMLOC{rr.Hdr, rr.Locator}
-}
-
-func (rr *NINFO) copy() RR {
-	return &NINFO{rr.Hdr, cloneSlice(rr.ZSData)}
-}
-
-func (rr *NS) copy() RR {
-	return &NS{rr.Hdr, rr.Ns}
-}
-
-func (rr *NSAPPTR) copy() RR {
-	return &NSAPPTR{rr.Hdr, rr.Ptr}
-}
-
-func (rr *NSEC) copy() RR {
-	return &NSEC{rr.Hdr, rr.NextDomain, cloneSlice(rr.TypeBitMap)}
-}
-
-func (rr *NSEC3) copy() RR {
-	return &NSEC3{
-		rr.Hdr,
-		rr.Hash,
-		rr.Flags,
-		rr.Iterations,
-		rr.SaltLength,
-		rr.Salt,
-		rr.HashLength,
-		rr.NextDomain,
-		cloneSlice(rr.TypeBitMap),
-	}
-}
-
-func (rr *NSEC3PARAM) copy() RR {
-	return &NSEC3PARAM{
-		rr.Hdr,
-		rr.Hash,
-		rr.Flags,
-		rr.Iterations,
-		rr.SaltLength,
-		rr.Salt,
-	}
-}
-
-func (rr *NULL) copy() RR {
-	return &NULL{rr.Hdr, rr.Data}
-}
-
-func (rr *NXNAME) copy() RR {
-	return &NXNAME{rr.Hdr}
-}
-
-func (rr *NXT) copy() RR {
-	return &NXT{*rr.NSEC.copy().(*NSEC)}
-}
-
-func (rr *OPENPGPKEY) copy() RR {
-	return &OPENPGPKEY{rr.Hdr, rr.PublicKey}
-}
-
-func (rr *OPT) copy() RR {
-	Option := make([]EDNS0, len(rr.Option))
-	for i, e := range rr.Option {
-		Option[i] = e.copy()
-	}
-	return &OPT{rr.Hdr, Option}
-}
-
-func (rr *PTR) copy() RR {
-	return &PTR{rr.Hdr, rr.Ptr}
-}
-
-func (rr *PX) copy() RR {
-	return &PX{
-		rr.Hdr,
-		rr.Preference,
-		rr.Map822,
-		rr.Mapx400,
-	}
-}
-
-func (rr *RESINFO) copy() RR {
-	return &RESINFO{rr.Hdr, cloneSlice(rr.Txt)}
-}
-
-func (rr *RFC3597) copy() RR {
-	return &RFC3597{rr.Hdr, rr.Rdata}
-}
-
-func (rr *RKEY) copy() RR {
-	return &RKEY{
-		rr.Hdr,
-		rr.Flags,
-		rr.Protocol,
-		rr.Algorithm,
-		rr.PublicKey,
-	}
-}
-
-func (rr *RP) copy() RR {
-	return &RP{rr.Hdr, rr.Mbox, rr.Txt}
-}
-
-func (rr *RRSIG) copy() RR {
-	return &RRSIG{
-		rr.Hdr,
-		rr.TypeCovered,
-		rr.Algorithm,
-		rr.Labels,
-		rr.OrigTtl,
-		rr.Expiration,
-		rr.Inception,
-		rr.KeyTag,
-		rr.SignerName,
-		rr.Signature,
-	}
-}
-
-func (rr *RT) copy() RR {
-	return &RT{rr.Hdr, rr.Preference, rr.Host}
-}
-
-func (rr *SIG) copy() RR {
-	return &SIG{*rr.RRSIG.copy().(*RRSIG)}
-}
-
-func (rr *SMIMEA) copy() RR {
-	return &SMIMEA{
-		rr.Hdr,
-		rr.Usage,
-		rr.Selector,
-		rr.MatchingType,
-		rr.Certificate,
-	}
-}
-
-func (rr *SOA) copy() RR {
-	return &SOA{
-		rr.Hdr,
-		rr.Ns,
-		rr.Mbox,
-		rr.Serial,
-		rr.Refresh,
-		rr.Retry,
-		rr.Expire,
-		rr.Minttl,
-	}
-}
-
-func (rr *SPF) copy() RR {
-	return &SPF{rr.Hdr, cloneSlice(rr.Txt)}
-}
-
-func (rr *SRV) copy() RR {
-	return &SRV{
-		rr.Hdr,
-		rr.Priority,
-		rr.Weight,
-		rr.Port,
-		rr.Target,
-	}
-}
-
-func (rr *SSHFP) copy() RR {
-	return &SSHFP{
-		rr.Hdr,
-		rr.Algorithm,
-		rr.Type,
-		rr.FingerPrint,
-	}
-}
-
-func (rr *SVCB) copy() RR {
-	Value := make([]SVCBKeyValue, len(rr.Value))
-	for i, e := range rr.Value {
-		Value[i] = e.copy()
-	}
-	return &SVCB{
-		rr.Hdr,
-		rr.Priority,
-		rr.Target,
-		Value,
-	}
-}
-
-func (rr *TA) copy() RR {
-	return &TA{
-		rr.Hdr,
-		rr.KeyTag,
-		rr.Algorithm,
-		rr.DigestType,
-		rr.Digest,
-	}
-}
-
-func (rr *TALINK) copy() RR {
-	return &TALINK{rr.Hdr, rr.PreviousName, rr.NextName}
-}
-
-func (rr *TKEY) copy() RR {
-	return &TKEY{
-		rr.Hdr,
-		rr.Algorithm,
-		rr.Inception,
-		rr.Expiration,
-		rr.Mode,
-		rr.Error,
-		rr.KeySize,
-		rr.Key,
-		rr.OtherLen,
-		rr.OtherData,
-	}
-}
-
-func (rr *TLSA) copy() RR {
-	return &TLSA{
-		rr.Hdr,
-		rr.Usage,
-		rr.Selector,
-		rr.MatchingType,
-		rr.Certificate,
-	}
-}
-
-func (rr *TSIG) copy() RR {
-	return &TSIG{
-		rr.Hdr,
-		rr.Algorithm,
-		rr.TimeSigned,
-		rr.Fudge,
-		rr.MACSize,
-		rr.MAC,
-		rr.OrigId,
-		rr.Error,
-		rr.OtherLen,
-		rr.OtherData,
-	}
-}
-
-func (rr *TXT) copy() RR {
-	return &TXT{rr.Hdr, cloneSlice(rr.Txt)}
-}
-
-func (rr *UID) copy() RR {
-	return &UID{rr.Hdr, rr.Uid}
-}
-
-func (rr *UINFO) copy() RR {
-	return &UINFO{rr.Hdr, rr.Uinfo}
-}
-
-func (rr *URI) copy() RR {
-	return &URI{
-		rr.Hdr,
-		rr.Priority,
-		rr.Weight,
-		rr.Target,
-	}
-}
-
-func (rr *X25) copy() RR {
-	return &X25{rr.Hdr, rr.PSDNAddress}
-}
-
-func (rr *ZONEMD) copy() RR {
-	return &ZONEMD{
-		rr.Hdr,
-		rr.Serial,
-		rr.Scheme,
-		rr.Hash,
-		rr.Digest,
-	}
-}
diff --git a/vendor/golang.org/x/mod/LICENSE b/vendor/golang.org/x/mod/LICENSE
deleted file mode 100644
index 2a7cf70da6..0000000000
--- a/vendor/golang.org/x/mod/LICENSE
+++ /dev/null
@@ -1,27 +0,0 @@
-Copyright 2009 The Go Authors.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-   * Neither the name of Google LLC nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/golang.org/x/mod/PATENTS b/vendor/golang.org/x/mod/PATENTS
deleted file mode 100644
index 733099041f..0000000000
--- a/vendor/golang.org/x/mod/PATENTS
+++ /dev/null
@@ -1,22 +0,0 @@
-Additional IP Rights Grant (Patents)
-
-"This implementation" means the copyrightable works distributed by
-Google as part of the Go project.
-
-Google hereby grants to You a perpetual, worldwide, non-exclusive,
-no-charge, royalty-free, irrevocable (except as stated in this section)
-patent license to make, have made, use, offer to sell, sell, import,
-transfer and otherwise run, modify and propagate the contents of this
-implementation of Go, where such license applies only to those patent
-claims, both currently owned or controlled by Google and acquired in
-the future, licensable by Google that are necessarily infringed by this
-implementation of Go.  This grant does not include claims that would be
-infringed only as a consequence of further modification of this
-implementation.  If you or your agent or exclusive licensee institute or
-order or agree to the institution of patent litigation against any
-entity (including a cross-claim or counterclaim in a lawsuit) alleging
-that this implementation of Go or any code incorporated within this
-implementation of Go constitutes direct or contributory patent
-infringement, or inducement of patent infringement, then any patent
-rights granted to you under this License for this implementation of Go
-shall terminate as of the date such litigation is filed.
diff --git a/vendor/golang.org/x/mod/semver/semver.go b/vendor/golang.org/x/mod/semver/semver.go
deleted file mode 100644
index 824b282c83..0000000000
--- a/vendor/golang.org/x/mod/semver/semver.go
+++ /dev/null
@@ -1,407 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package semver implements comparison of semantic version strings.
-// In this package, semantic version strings must begin with a leading "v",
-// as in "v1.0.0".
-//
-// The general form of a semantic version string accepted by this package is
-//
-//	vMAJOR[.MINOR[.PATCH[-PRERELEASE][+BUILD]]]
-//
-// where square brackets indicate optional parts of the syntax;
-// MAJOR, MINOR, and PATCH are decimal integers without extra leading zeros;
-// PRERELEASE and BUILD are each a series of non-empty dot-separated identifiers
-// using only alphanumeric characters and hyphens; and
-// all-numeric PRERELEASE identifiers must not have leading zeros.
-//
-// This package follows Semantic Versioning 2.0.0 (see semver.org)
-// with two exceptions. First, it requires the "v" prefix. Second, it recognizes
-// vMAJOR and vMAJOR.MINOR (with no prerelease or build suffixes)
-// as shorthands for vMAJOR.0.0 and vMAJOR.MINOR.0.
-package semver
-
-import (
-	"slices"
-	"strings"
-)
-
-// parsed returns the parsed form of a semantic version string.
-type parsed struct {
-	major      string
-	minor      string
-	patch      string
-	short      string
-	prerelease string
-	build      string
-}
-
-// IsValid reports whether v is a valid semantic version string.
-func IsValid(v string) bool {
-	_, ok := parse(v)
-	return ok
-}
-
-// Canonical returns the canonical formatting of the semantic version v.
-// It fills in any missing .MINOR or .PATCH and discards build metadata.
-// Two semantic versions compare equal only if their canonical formatting
-// is an identical string.
-// The canonical invalid semantic version is the empty string.
-func Canonical(v string) string {
-	p, ok := parse(v)
-	if !ok {
-		return ""
-	}
-	if p.build != "" {
-		return v[:len(v)-len(p.build)]
-	}
-	if p.short != "" {
-		return v + p.short
-	}
-	return v
-}
-
-// Major returns the major version prefix of the semantic version v.
-// For example, Major("v2.1.0") == "v2".
-// If v is an invalid semantic version string, Major returns the empty string.
-func Major(v string) string {
-	pv, ok := parse(v)
-	if !ok {
-		return ""
-	}
-	return v[:1+len(pv.major)]
-}
-
-// MajorMinor returns the major.minor version prefix of the semantic version v.
-// For example, MajorMinor("v2.1.0") == "v2.1".
-// If v is an invalid semantic version string, MajorMinor returns the empty string.
-func MajorMinor(v string) string {
-	pv, ok := parse(v)
-	if !ok {
-		return ""
-	}
-	i := 1 + len(pv.major)
-	if j := i + 1 + len(pv.minor); j <= len(v) && v[i] == '.' && v[i+1:j] == pv.minor {
-		return v[:j]
-	}
-	return v[:i] + "." + pv.minor
-}
-
-// Prerelease returns the prerelease suffix of the semantic version v.
-// For example, Prerelease("v2.1.0-pre+meta") == "-pre".
-// If v is an invalid semantic version string, Prerelease returns the empty string.
-func Prerelease(v string) string {
-	pv, ok := parse(v)
-	if !ok {
-		return ""
-	}
-	return pv.prerelease
-}
-
-// Build returns the build suffix of the semantic version v.
-// For example, Build("v2.1.0+meta") == "+meta".
-// If v is an invalid semantic version string, Build returns the empty string.
-func Build(v string) string {
-	pv, ok := parse(v)
-	if !ok {
-		return ""
-	}
-	return pv.build
-}
-
-// Compare returns an integer comparing two versions according to
-// semantic version precedence.
-// The result will be 0 if v == w, -1 if v < w, or +1 if v > w.
-//
-// An invalid semantic version string is considered less than a valid one.
-// All invalid semantic version strings compare equal to each other.
-func Compare(v, w string) int {
-	pv, ok1 := parse(v)
-	pw, ok2 := parse(w)
-	if !ok1 && !ok2 {
-		return 0
-	}
-	if !ok1 {
-		return -1
-	}
-	if !ok2 {
-		return +1
-	}
-	if c := compareInt(pv.major, pw.major); c != 0 {
-		return c
-	}
-	if c := compareInt(pv.minor, pw.minor); c != 0 {
-		return c
-	}
-	if c := compareInt(pv.patch, pw.patch); c != 0 {
-		return c
-	}
-	return comparePrerelease(pv.prerelease, pw.prerelease)
-}
-
-// Max canonicalizes its arguments and then returns the version string
-// that compares greater.
-//
-// Deprecated: use [Compare] instead. In most cases, returning a canonicalized
-// version is not expected or desired.
-func Max(v, w string) string {
-	v = Canonical(v)
-	w = Canonical(w)
-	if Compare(v, w) > 0 {
-		return v
-	}
-	return w
-}
-
-// ByVersion implements [sort.Interface] for sorting semantic version strings.
-type ByVersion []string
-
-func (vs ByVersion) Len() int           { return len(vs) }
-func (vs ByVersion) Swap(i, j int)      { vs[i], vs[j] = vs[j], vs[i] }
-func (vs ByVersion) Less(i, j int) bool { return compareVersion(vs[i], vs[j]) < 0 }
-
-// Sort sorts a list of semantic version strings using [Compare] and falls back
-// to use [strings.Compare] if both versions are considered equal.
-func Sort(list []string) {
-	slices.SortFunc(list, compareVersion)
-}
-
-func compareVersion(a, b string) int {
-	cmp := Compare(a, b)
-	if cmp != 0 {
-		return cmp
-	}
-	return strings.Compare(a, b)
-}
-
-func parse(v string) (p parsed, ok bool) {
-	if v == "" || v[0] != 'v' {
-		return
-	}
-	p.major, v, ok = parseInt(v[1:])
-	if !ok {
-		return
-	}
-	if v == "" {
-		p.minor = "0"
-		p.patch = "0"
-		p.short = ".0.0"
-		return
-	}
-	if v[0] != '.' {
-		ok = false
-		return
-	}
-	p.minor, v, ok = parseInt(v[1:])
-	if !ok {
-		return
-	}
-	if v == "" {
-		p.patch = "0"
-		p.short = ".0"
-		return
-	}
-	if v[0] != '.' {
-		ok = false
-		return
-	}
-	p.patch, v, ok = parseInt(v[1:])
-	if !ok {
-		return
-	}
-	if len(v) > 0 && v[0] == '-' {
-		p.prerelease, v, ok = parsePrerelease(v)
-		if !ok {
-			return
-		}
-	}
-	if len(v) > 0 && v[0] == '+' {
-		p.build, v, ok = parseBuild(v)
-		if !ok {
-			return
-		}
-	}
-	if v != "" {
-		ok = false
-		return
-	}
-	ok = true
-	return
-}
-
-func parseInt(v string) (t, rest string, ok bool) {
-	if v == "" {
-		return
-	}
-	if v[0] < '0' || '9' < v[0] {
-		return
-	}
-	i := 1
-	for i < len(v) && '0' <= v[i] && v[i] <= '9' {
-		i++
-	}
-	if v[0] == '0' && i != 1 {
-		return
-	}
-	return v[:i], v[i:], true
-}
-
-func parsePrerelease(v string) (t, rest string, ok bool) {
-	// "A pre-release version MAY be denoted by appending a hyphen and
-	// a series of dot separated identifiers immediately following the patch version.
-	// Identifiers MUST comprise only ASCII alphanumerics and hyphen [0-9A-Za-z-].
-	// Identifiers MUST NOT be empty. Numeric identifiers MUST NOT include leading zeroes."
-	if v == "" || v[0] != '-' {
-		return
-	}
-	i := 1
-	start := 1
-	for i < len(v) && v[i] != '+' {
-		if !isIdentChar(v[i]) && v[i] != '.' {
-			return
-		}
-		if v[i] == '.' {
-			if start == i || isBadNum(v[start:i]) {
-				return
-			}
-			start = i + 1
-		}
-		i++
-	}
-	if start == i || isBadNum(v[start:i]) {
-		return
-	}
-	return v[:i], v[i:], true
-}
-
-func parseBuild(v string) (t, rest string, ok bool) {
-	if v == "" || v[0] != '+' {
-		return
-	}
-	i := 1
-	start := 1
-	for i < len(v) {
-		if !isIdentChar(v[i]) && v[i] != '.' {
-			return
-		}
-		if v[i] == '.' {
-			if start == i {
-				return
-			}
-			start = i + 1
-		}
-		i++
-	}
-	if start == i {
-		return
-	}
-	return v[:i], v[i:], true
-}
-
-func isIdentChar(c byte) bool {
-	return 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || '0' <= c && c <= '9' || c == '-'
-}
-
-func isBadNum(v string) bool {
-	i := 0
-	for i < len(v) && '0' <= v[i] && v[i] <= '9' {
-		i++
-	}
-	return i == len(v) && i > 1 && v[0] == '0'
-}
-
-func isNum(v string) bool {
-	i := 0
-	for i < len(v) && '0' <= v[i] && v[i] <= '9' {
-		i++
-	}
-	return i == len(v)
-}
-
-func compareInt(x, y string) int {
-	if x == y {
-		return 0
-	}
-	if len(x) < len(y) {
-		return -1
-	}
-	if len(x) > len(y) {
-		return +1
-	}
-	if x < y {
-		return -1
-	} else {
-		return +1
-	}
-}
-
-func comparePrerelease(x, y string) int {
-	// "When major, minor, and patch are equal, a pre-release version has
-	// lower precedence than a normal version.
-	// Example: 1.0.0-alpha < 1.0.0.
-	// Precedence for two pre-release versions with the same major, minor,
-	// and patch version MUST be determined by comparing each dot separated
-	// identifier from left to right until a difference is found as follows:
-	// identifiers consisting of only digits are compared numerically and
-	// identifiers with letters or hyphens are compared lexically in ASCII
-	// sort order. Numeric identifiers always have lower precedence than
-	// non-numeric identifiers. A larger set of pre-release fields has a
-	// higher precedence than a smaller set, if all of the preceding
-	// identifiers are equal.
-	// Example: 1.0.0-alpha < 1.0.0-alpha.1 < 1.0.0-alpha.beta <
-	// 1.0.0-beta < 1.0.0-beta.2 < 1.0.0-beta.11 < 1.0.0-rc.1 < 1.0.0."
-	if x == y {
-		return 0
-	}
-	if x == "" {
-		return +1
-	}
-	if y == "" {
-		return -1
-	}
-	for x != "" && y != "" {
-		x = x[1:] // skip - or .
-		y = y[1:] // skip - or .
-		var dx, dy string
-		dx, x = nextIdent(x)
-		dy, y = nextIdent(y)
-		if dx != dy {
-			ix := isNum(dx)
-			iy := isNum(dy)
-			if ix != iy {
-				if ix {
-					return -1
-				} else {
-					return +1
-				}
-			}
-			if ix {
-				if len(dx) < len(dy) {
-					return -1
-				}
-				if len(dx) > len(dy) {
-					return +1
-				}
-			}
-			if dx < dy {
-				return -1
-			} else {
-				return +1
-			}
-		}
-	}
-	if x == "" {
-		return -1
-	} else {
-		return +1
-	}
-}
-
-func nextIdent(x string) (dx, rest string) {
-	i := 0
-	for i < len(x) && x[i] != '.' {
-		i++
-	}
-	return x[:i], x[i:]
-}
diff --git a/vendor/golang.org/x/sync/LICENSE b/vendor/golang.org/x/sync/LICENSE
deleted file mode 100644
index 2a7cf70da6..0000000000
--- a/vendor/golang.org/x/sync/LICENSE
+++ /dev/null
@@ -1,27 +0,0 @@
-Copyright 2009 The Go Authors.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-   * Neither the name of Google LLC nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/golang.org/x/sync/PATENTS b/vendor/golang.org/x/sync/PATENTS
deleted file mode 100644
index 733099041f..0000000000
--- a/vendor/golang.org/x/sync/PATENTS
+++ /dev/null
@@ -1,22 +0,0 @@
-Additional IP Rights Grant (Patents)
-
-"This implementation" means the copyrightable works distributed by
-Google as part of the Go project.
-
-Google hereby grants to You a perpetual, worldwide, non-exclusive,
-no-charge, royalty-free, irrevocable (except as stated in this section)
-patent license to make, have made, use, offer to sell, sell, import,
-transfer and otherwise run, modify and propagate the contents of this
-implementation of Go, where such license applies only to those patent
-claims, both currently owned or controlled by Google and acquired in
-the future, licensable by Google that are necessarily infringed by this
-implementation of Go.  This grant does not include claims that would be
-infringed only as a consequence of further modification of this
-implementation.  If you or your agent or exclusive licensee institute or
-order or agree to the institution of patent litigation against any
-entity (including a cross-claim or counterclaim in a lawsuit) alleging
-that this implementation of Go or any code incorporated within this
-implementation of Go constitutes direct or contributory patent
-infringement, or inducement of patent infringement, then any patent
-rights granted to you under this License for this implementation of Go
-shall terminate as of the date such litigation is filed.
diff --git a/vendor/golang.org/x/sync/errgroup/errgroup.go b/vendor/golang.org/x/sync/errgroup/errgroup.go
deleted file mode 100644
index c261a8ebbd..0000000000
--- a/vendor/golang.org/x/sync/errgroup/errgroup.go
+++ /dev/null
@@ -1,151 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package errgroup provides synchronization, error propagation, and Context
-// cancellation for groups of goroutines working on subtasks of a common task.
-//
-// [errgroup.Group] is related to [sync.WaitGroup] but adds handling of tasks
-// returning errors.
-package errgroup
-
-import (
-	"context"
-	"fmt"
-	"sync"
-)
-
-type token struct{}
-
-// A Group is a collection of goroutines working on subtasks that are part of
-// the same overall task. A Group should not be reused for different tasks.
-//
-// A zero Group is valid, has no limit on the number of active goroutines,
-// and does not cancel on error.
-type Group struct {
-	cancel func(error)
-
-	wg sync.WaitGroup
-
-	sem chan token
-
-	errOnce sync.Once
-	err     error
-}
-
-func (g *Group) done() {
-	if g.sem != nil {
-		<-g.sem
-	}
-	g.wg.Done()
-}
-
-// WithContext returns a new Group and an associated Context derived from ctx.
-//
-// The derived Context is canceled the first time a function passed to Go
-// returns a non-nil error or the first time Wait returns, whichever occurs
-// first.
-func WithContext(ctx context.Context) (*Group, context.Context) {
-	ctx, cancel := context.WithCancelCause(ctx)
-	return &Group{cancel: cancel}, ctx
-}
-
-// Wait blocks until all function calls from the Go method have returned, then
-// returns the first non-nil error (if any) from them.
-func (g *Group) Wait() error {
-	g.wg.Wait()
-	if g.cancel != nil {
-		g.cancel(g.err)
-	}
-	return g.err
-}
-
-// Go calls the given function in a new goroutine.
-//
-// The first call to Go must happen before a Wait.
-// It blocks until the new goroutine can be added without the number of
-// goroutines in the group exceeding the configured limit.
-//
-// The first goroutine in the group that returns a non-nil error will
-// cancel the associated Context, if any. The error will be returned
-// by Wait.
-func (g *Group) Go(f func() error) {
-	if g.sem != nil {
-		g.sem <- token{}
-	}
-
-	g.wg.Add(1)
-	go func() {
-		defer g.done()
-
-		// It is tempting to propagate panics from f()
-		// up to the goroutine that calls Wait, but
-		// it creates more problems than it solves:
-		// - it delays panics arbitrarily,
-		//   making bugs harder to detect;
-		// - it turns f's panic stack into a mere value,
-		//   hiding it from crash-monitoring tools;
-		// - it risks deadlocks that hide the panic entirely,
-		//   if f's panic leaves the program in a state
-		//   that prevents the Wait call from being reached.
-		// See #53757, #74275, #74304, #74306.
-
-		if err := f(); err != nil {
-			g.errOnce.Do(func() {
-				g.err = err
-				if g.cancel != nil {
-					g.cancel(g.err)
-				}
-			})
-		}
-	}()
-}
-
-// TryGo calls the given function in a new goroutine only if the number of
-// active goroutines in the group is currently below the configured limit.
-//
-// The return value reports whether the goroutine was started.
-func (g *Group) TryGo(f func() error) bool {
-	if g.sem != nil {
-		select {
-		case g.sem <- token{}:
-			// Note: this allows barging if and only if channels in general allow barging.
-		default:
-			return false
-		}
-	}
-
-	g.wg.Add(1)
-	go func() {
-		defer g.done()
-
-		if err := f(); err != nil {
-			g.errOnce.Do(func() {
-				g.err = err
-				if g.cancel != nil {
-					g.cancel(g.err)
-				}
-			})
-		}
-	}()
-	return true
-}
-
-// SetLimit limits the number of active goroutines in this group to at most n.
-// A negative value indicates no limit.
-// A limit of zero will prevent any new goroutines from being added.
-//
-// Any subsequent call to the Go method will block until it can add an active
-// goroutine without exceeding the configured limit.
-//
-// The limit must not be modified while any goroutines in the group are active.
-func (g *Group) SetLimit(n int) {
-	if n < 0 {
-		g.sem = nil
-		return
-	}
-	if active := len(g.sem); active != 0 {
-		panic(fmt.Errorf("errgroup: modify limit while %v goroutines in the group are still active", active))
-	}
-	g.sem = make(chan token, n)
-}
diff --git a/vendor/golang.org/x/tools/LICENSE b/vendor/golang.org/x/tools/LICENSE
deleted file mode 100644
index 2a7cf70da6..0000000000
--- a/vendor/golang.org/x/tools/LICENSE
+++ /dev/null
@@ -1,27 +0,0 @@
-Copyright 2009 The Go Authors.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-   * Neither the name of Google LLC nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/golang.org/x/tools/PATENTS b/vendor/golang.org/x/tools/PATENTS
deleted file mode 100644
index 733099041f..0000000000
--- a/vendor/golang.org/x/tools/PATENTS
+++ /dev/null
@@ -1,22 +0,0 @@
-Additional IP Rights Grant (Patents)
-
-"This implementation" means the copyrightable works distributed by
-Google as part of the Go project.
-
-Google hereby grants to You a perpetual, worldwide, non-exclusive,
-no-charge, royalty-free, irrevocable (except as stated in this section)
-patent license to make, have made, use, offer to sell, sell, import,
-transfer and otherwise run, modify and propagate the contents of this
-implementation of Go, where such license applies only to those patent
-claims, both currently owned or controlled by Google and acquired in
-the future, licensable by Google that are necessarily infringed by this
-implementation of Go.  This grant does not include claims that would be
-infringed only as a consequence of further modification of this
-implementation.  If you or your agent or exclusive licensee institute or
-order or agree to the institution of patent litigation against any
-entity (including a cross-claim or counterclaim in a lawsuit) alleging
-that this implementation of Go or any code incorporated within this
-implementation of Go constitutes direct or contributory patent
-infringement, or inducement of patent infringement, then any patent
-rights granted to you under this License for this implementation of Go
-shall terminate as of the date such litigation is filed.
diff --git a/vendor/golang.org/x/tools/go/ast/edge/edge.go b/vendor/golang.org/x/tools/go/ast/edge/edge.go
deleted file mode 100644
index 8dc4dd1502..0000000000
--- a/vendor/golang.org/x/tools/go/ast/edge/edge.go
+++ /dev/null
@@ -1,299 +0,0 @@
-// Copyright 2025 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package edge defines identifiers for each field of an ast.Node
-// struct type that refers to another Node.
-package edge
-
-import (
-	"fmt"
-	"go/ast"
-	"reflect"
-)
-
-// A Kind describes a field of an [ast.Node] struct.
-type Kind uint8
-
-// String returns a description of the edge kind.
-func (k Kind) String() string {
-	if k == Invalid {
-		return "<invalid>"
-	}
-	info := fieldInfos[k]
-	return fmt.Sprintf("%v.%s", info.nodeType.Elem().Name(), info.name)
-}
-
-// NodeType returns the pointer-to-struct type of the ast.Node implementation.
-func (k Kind) NodeType() reflect.Type { return fieldInfos[k].nodeType }
-
-// FieldName returns the name of the field.
-func (k Kind) FieldName() string { return fieldInfos[k].name }
-
-// FieldType returns the declared type of the field.
-func (k Kind) FieldType() reflect.Type { return fieldInfos[k].fieldType }
-
-// Get returns the direct child of n identified by (k, idx).
-// n's type must match k.NodeType().
-// idx must be a valid slice index, or -1 for a non-slice.
-func (k Kind) Get(n ast.Node, idx int) ast.Node {
-	if k.NodeType() != reflect.TypeOf(n) {
-		panic(fmt.Sprintf("%v.Get(%T): invalid node type", k, n))
-	}
-	v := reflect.ValueOf(n).Elem().Field(fieldInfos[k].index)
-
-	if v.Kind() == reflect.Slice {
-		v = v.Index(idx) // asserts valid idx
-	} else if idx != -1 {
-		panic(fmt.Sprintf("%v, Get(%T, %d): cannot index non-slice", v, n, idx))
-	}
-
-	out, _ := v.Interface().(ast.Node) // may be nil
-	return out
-}
-
-// Each [Kind] is named Type_Field, where Type is the
-// [ast.Node] struct type and Field is the name of the field
-const (
-	Invalid Kind = iota // for nodes at the root of the traversal
-
-	// As of Go1.26 these kinds are sorted alphabetically, but
-	// numbering must be stable, so any new addition of const should
-	// use a new value (be added at the end of the list).
-
-	ArrayType_Elt
-	ArrayType_Len
-	AssignStmt_Lhs
-	AssignStmt_Rhs
-	BinaryExpr_X
-	BinaryExpr_Y
-	BlockStmt_List
-	BranchStmt_Label
-	CallExpr_Args
-	CallExpr_Fun
-	CaseClause_Body
-	CaseClause_List
-	ChanType_Value
-	CommClause_Body
-	CommClause_Comm
-	CommentGroup_List
-	CompositeLit_Elts
-	CompositeLit_Type
-	DeclStmt_Decl
-	DeferStmt_Call
-	Ellipsis_Elt
-	ExprStmt_X
-	FieldList_List
-	Field_Comment
-	Field_Doc
-	Field_Names
-	Field_Tag
-	Field_Type
-	File_Decls
-	File_Doc
-	File_Name
-	ForStmt_Body
-	ForStmt_Cond
-	ForStmt_Init
-	ForStmt_Post
-	FuncDecl_Body
-	FuncDecl_Doc
-	FuncDecl_Name
-	FuncDecl_Recv
-	FuncDecl_Type
-	FuncLit_Body
-	FuncLit_Type
-	FuncType_Params
-	FuncType_Results
-	FuncType_TypeParams
-	GenDecl_Doc
-	GenDecl_Specs
-	GoStmt_Call
-	IfStmt_Body
-	IfStmt_Cond
-	IfStmt_Else
-	IfStmt_Init
-	ImportSpec_Comment
-	ImportSpec_Doc
-	ImportSpec_Name
-	ImportSpec_Path
-	IncDecStmt_X
-	IndexExpr_Index
-	IndexExpr_X
-	IndexListExpr_Indices
-	IndexListExpr_X
-	InterfaceType_Methods
-	KeyValueExpr_Key
-	KeyValueExpr_Value
-	LabeledStmt_Label
-	LabeledStmt_Stmt
-	MapType_Key
-	MapType_Value
-	ParenExpr_X
-	RangeStmt_Body
-	RangeStmt_Key
-	RangeStmt_Value
-	RangeStmt_X
-	ReturnStmt_Results
-	SelectStmt_Body
-	SelectorExpr_Sel
-	SelectorExpr_X
-	SendStmt_Chan
-	SendStmt_Value
-	SliceExpr_High
-	SliceExpr_Low
-	SliceExpr_Max
-	SliceExpr_X
-	StarExpr_X
-	StructType_Fields
-	SwitchStmt_Body
-	SwitchStmt_Init
-	SwitchStmt_Tag
-	TypeAssertExpr_Type
-	TypeAssertExpr_X
-	TypeSpec_Comment
-	TypeSpec_Doc
-	TypeSpec_Name
-	TypeSpec_Type
-	TypeSpec_TypeParams
-	TypeSwitchStmt_Assign
-	TypeSwitchStmt_Body
-	TypeSwitchStmt_Init
-	UnaryExpr_X
-	ValueSpec_Comment
-	ValueSpec_Doc
-	ValueSpec_Names
-	ValueSpec_Type
-	ValueSpec_Values
-
-	maxKind
-)
-
-// Assert that the encoding fits in 7 bits,
-// as the inspector relies on this.
-// (We are currently at 104.)
-var _ = [1 << 7]struct{}{}[maxKind]
-
-type fieldInfo struct {
-	nodeType  reflect.Type // pointer-to-struct type of ast.Node implementation
-	name      string
-	index     int
-	fieldType reflect.Type
-}
-
-func info[N ast.Node](fieldName string) fieldInfo {
-	nodePtrType := reflect.TypeFor[N]()
-	f, ok := nodePtrType.Elem().FieldByName(fieldName)
-	if !ok {
-		panic(fieldName)
-	}
-	return fieldInfo{nodePtrType, fieldName, f.Index[0], f.Type}
-}
-
-var fieldInfos = [...]fieldInfo{
-	Invalid:               {},
-	ArrayType_Elt:         info[*ast.ArrayType]("Elt"),
-	ArrayType_Len:         info[*ast.ArrayType]("Len"),
-	AssignStmt_Lhs:        info[*ast.AssignStmt]("Lhs"),
-	AssignStmt_Rhs:        info[*ast.AssignStmt]("Rhs"),
-	BinaryExpr_X:          info[*ast.BinaryExpr]("X"),
-	BinaryExpr_Y:          info[*ast.BinaryExpr]("Y"),
-	BlockStmt_List:        info[*ast.BlockStmt]("List"),
-	BranchStmt_Label:      info[*ast.BranchStmt]("Label"),
-	CallExpr_Args:         info[*ast.CallExpr]("Args"),
-	CallExpr_Fun:          info[*ast.CallExpr]("Fun"),
-	CaseClause_Body:       info[*ast.CaseClause]("Body"),
-	CaseClause_List:       info[*ast.CaseClause]("List"),
-	ChanType_Value:        info[*ast.ChanType]("Value"),
-	CommClause_Body:       info[*ast.CommClause]("Body"),
-	CommClause_Comm:       info[*ast.CommClause]("Comm"),
-	CommentGroup_List:     info[*ast.CommentGroup]("List"),
-	CompositeLit_Elts:     info[*ast.CompositeLit]("Elts"),
-	CompositeLit_Type:     info[*ast.CompositeLit]("Type"),
-	DeclStmt_Decl:         info[*ast.DeclStmt]("Decl"),
-	DeferStmt_Call:        info[*ast.DeferStmt]("Call"),
-	Ellipsis_Elt:          info[*ast.Ellipsis]("Elt"),
-	ExprStmt_X:            info[*ast.ExprStmt]("X"),
-	FieldList_List:        info[*ast.FieldList]("List"),
-	Field_Comment:         info[*ast.Field]("Comment"),
-	Field_Doc:             info[*ast.Field]("Doc"),
-	Field_Names:           info[*ast.Field]("Names"),
-	Field_Tag:             info[*ast.Field]("Tag"),
-	Field_Type:            info[*ast.Field]("Type"),
-	File_Decls:            info[*ast.File]("Decls"),
-	File_Doc:              info[*ast.File]("Doc"),
-	File_Name:             info[*ast.File]("Name"),
-	ForStmt_Body:          info[*ast.ForStmt]("Body"),
-	ForStmt_Cond:          info[*ast.ForStmt]("Cond"),
-	ForStmt_Init:          info[*ast.ForStmt]("Init"),
-	ForStmt_Post:          info[*ast.ForStmt]("Post"),
-	FuncDecl_Body:         info[*ast.FuncDecl]("Body"),
-	FuncDecl_Doc:          info[*ast.FuncDecl]("Doc"),
-	FuncDecl_Name:         info[*ast.FuncDecl]("Name"),
-	FuncDecl_Recv:         info[*ast.FuncDecl]("Recv"),
-	FuncDecl_Type:         info[*ast.FuncDecl]("Type"),
-	FuncLit_Body:          info[*ast.FuncLit]("Body"),
-	FuncLit_Type:          info[*ast.FuncLit]("Type"),
-	FuncType_Params:       info[*ast.FuncType]("Params"),
-	FuncType_Results:      info[*ast.FuncType]("Results"),
-	FuncType_TypeParams:   info[*ast.FuncType]("TypeParams"),
-	GenDecl_Doc:           info[*ast.GenDecl]("Doc"),
-	GenDecl_Specs:         info[*ast.GenDecl]("Specs"),
-	GoStmt_Call:           info[*ast.GoStmt]("Call"),
-	IfStmt_Body:           info[*ast.IfStmt]("Body"),
-	IfStmt_Cond:           info[*ast.IfStmt]("Cond"),
-	IfStmt_Else:           info[*ast.IfStmt]("Else"),
-	IfStmt_Init:           info[*ast.IfStmt]("Init"),
-	ImportSpec_Comment:    info[*ast.ImportSpec]("Comment"),
-	ImportSpec_Doc:        info[*ast.ImportSpec]("Doc"),
-	ImportSpec_Name:       info[*ast.ImportSpec]("Name"),
-	ImportSpec_Path:       info[*ast.ImportSpec]("Path"),
-	IncDecStmt_X:          info[*ast.IncDecStmt]("X"),
-	IndexExpr_Index:       info[*ast.IndexExpr]("Index"),
-	IndexExpr_X:           info[*ast.IndexExpr]("X"),
-	IndexListExpr_Indices: info[*ast.IndexListExpr]("Indices"),
-	IndexListExpr_X:       info[*ast.IndexListExpr]("X"),
-	InterfaceType_Methods: info[*ast.InterfaceType]("Methods"),
-	KeyValueExpr_Key:      info[*ast.KeyValueExpr]("Key"),
-	KeyValueExpr_Value:    info[*ast.KeyValueExpr]("Value"),
-	LabeledStmt_Label:     info[*ast.LabeledStmt]("Label"),
-	LabeledStmt_Stmt:      info[*ast.LabeledStmt]("Stmt"),
-	MapType_Key:           info[*ast.MapType]("Key"),
-	MapType_Value:         info[*ast.MapType]("Value"),
-	ParenExpr_X:           info[*ast.ParenExpr]("X"),
-	RangeStmt_Body:        info[*ast.RangeStmt]("Body"),
-	RangeStmt_Key:         info[*ast.RangeStmt]("Key"),
-	RangeStmt_Value:       info[*ast.RangeStmt]("Value"),
-	RangeStmt_X:           info[*ast.RangeStmt]("X"),
-	ReturnStmt_Results:    info[*ast.ReturnStmt]("Results"),
-	SelectStmt_Body:       info[*ast.SelectStmt]("Body"),
-	SelectorExpr_Sel:      info[*ast.SelectorExpr]("Sel"),
-	SelectorExpr_X:        info[*ast.SelectorExpr]("X"),
-	SendStmt_Chan:         info[*ast.SendStmt]("Chan"),
-	SendStmt_Value:        info[*ast.SendStmt]("Value"),
-	SliceExpr_High:        info[*ast.SliceExpr]("High"),
-	SliceExpr_Low:         info[*ast.SliceExpr]("Low"),
-	SliceExpr_Max:         info[*ast.SliceExpr]("Max"),
-	SliceExpr_X:           info[*ast.SliceExpr]("X"),
-	StarExpr_X:            info[*ast.StarExpr]("X"),
-	StructType_Fields:     info[*ast.StructType]("Fields"),
-	SwitchStmt_Body:       info[*ast.SwitchStmt]("Body"),
-	SwitchStmt_Init:       info[*ast.SwitchStmt]("Init"),
-	SwitchStmt_Tag:        info[*ast.SwitchStmt]("Tag"),
-	TypeAssertExpr_Type:   info[*ast.TypeAssertExpr]("Type"),
-	TypeAssertExpr_X:      info[*ast.TypeAssertExpr]("X"),
-	TypeSpec_Comment:      info[*ast.TypeSpec]("Comment"),
-	TypeSpec_Doc:          info[*ast.TypeSpec]("Doc"),
-	TypeSpec_Name:         info[*ast.TypeSpec]("Name"),
-	TypeSpec_Type:         info[*ast.TypeSpec]("Type"),
-	TypeSpec_TypeParams:   info[*ast.TypeSpec]("TypeParams"),
-	TypeSwitchStmt_Assign: info[*ast.TypeSwitchStmt]("Assign"),
-	TypeSwitchStmt_Body:   info[*ast.TypeSwitchStmt]("Body"),
-	TypeSwitchStmt_Init:   info[*ast.TypeSwitchStmt]("Init"),
-	UnaryExpr_X:           info[*ast.UnaryExpr]("X"),
-	ValueSpec_Comment:     info[*ast.ValueSpec]("Comment"),
-	ValueSpec_Doc:         info[*ast.ValueSpec]("Doc"),
-	ValueSpec_Names:       info[*ast.ValueSpec]("Names"),
-	ValueSpec_Type:        info[*ast.ValueSpec]("Type"),
-	ValueSpec_Values:      info[*ast.ValueSpec]("Values"),
-}
diff --git a/vendor/golang.org/x/tools/go/ast/inspector/cursor.go b/vendor/golang.org/x/tools/go/ast/inspector/cursor.go
deleted file mode 100644
index 239b10c4da..0000000000
--- a/vendor/golang.org/x/tools/go/ast/inspector/cursor.go
+++ /dev/null
@@ -1,551 +0,0 @@
-// Copyright 2025 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package inspector
-
-import (
-	"fmt"
-	"go/ast"
-	"go/token"
-	"iter"
-	"reflect"
-
-	"golang.org/x/tools/go/ast/edge"
-)
-
-// A Cursor represents an [ast.Node]. It is immutable.
-//
-// Two Cursors compare equal if they represent the same node.
-//
-// The zero value of Cursor is not valid.
-//
-// Call [Inspector.Root] to obtain a cursor for the virtual root node
-// of the traversal. This is the sole valid cursor for which [Cursor.Node]
-// returns nil.
-//
-// Use the following methods to navigate efficiently around the tree:
-//   - for ancestors, use [Cursor.Parent] and [Cursor.Enclosing];
-//   - for children, use [Cursor.Child], [Cursor.Children],
-//     [Cursor.FirstChild], and [Cursor.LastChild];
-//   - for siblings, use [Cursor.PrevSibling] and [Cursor.NextSibling];
-//   - for descendants, use [Cursor.FindByPos], [Cursor.FindNode],
-//     [Cursor.Inspect], and [Cursor.Preorder].
-//
-// Use the [Cursor.ChildAt] and [Cursor.ParentEdge] methods for
-// information about the edges in a tree: which field (and slice
-// element) of the parent node holds the child.
-type Cursor struct {
-	in    *Inspector
-	index int32 // index of push node; -1 for virtual root node
-}
-
-// Root returns a valid cursor for the virtual root node,
-// whose children are the files provided to [New].
-//
-// Its [Cursor.Node] method return nil.
-func (in *Inspector) Root() Cursor {
-	return Cursor{in, -1}
-}
-
-// At returns the cursor at the specified index in the traversal,
-// which must have been obtained from [Cursor.Index] on a Cursor
-// belonging to the same Inspector (see [Cursor.Inspector]).
-func (in *Inspector) At(index int32) Cursor {
-	if index < 0 {
-		panic("negative index")
-	}
-	if int(index) >= len(in.events) {
-		panic("index out of range for this inspector")
-	}
-	if in.events[index].index < index {
-		panic("invalid index") // (a push, not a pop)
-	}
-	return Cursor{in, index}
-}
-
-// Valid reports whether the cursor is valid.
-// The zero value of cursor is invalid.
-// Unless otherwise documented, it is not safe to call
-// any other method on an invalid cursor.
-func (c Cursor) Valid() bool {
-	return c.in != nil
-}
-
-// Inspector returns the cursor's Inspector.
-// It returns nil if the Cursor is not valid.
-func (c Cursor) Inspector() *Inspector { return c.in }
-
-// Index returns the index of this cursor position within the package.
-//
-// Clients should not assume anything about the numeric Index value
-// except that it increases monotonically throughout the traversal.
-// It is provided for use with [Inspector.At].
-//
-// Index must not be called on the Root node.
-func (c Cursor) Index() int32 {
-	if c.index < 0 {
-		panic("Index called on Root node")
-	}
-	return c.index
-}
-
-// Node returns the node at the current cursor position,
-// or nil for the cursor returned by [Inspector.Root].
-func (c Cursor) Node() ast.Node {
-	if c.index < 0 {
-		return nil
-	}
-	return c.in.events[c.index].node
-}
-
-// String returns information about the cursor's node, if any.
-func (c Cursor) String() string {
-	if !c.Valid() {
-		return "(invalid)"
-	}
-	if c.index < 0 {
-		return "(root)"
-	}
-	return reflect.TypeOf(c.Node()).String()
-}
-
-// indices return the [start, end) half-open interval of event indices.
-func (c Cursor) indices() (int32, int32) {
-	if c.index < 0 {
-		return 0, int32(len(c.in.events)) // root: all events
-	} else {
-		return c.index, c.in.events[c.index].index + 1 // just one subtree
-	}
-}
-
-// Preorder returns an iterator over the nodes of the subtree
-// represented by c in depth-first order. Each node in the sequence is
-// represented by a Cursor that allows access to the Node, but may
-// also be used to start a new traversal, or to obtain the stack of
-// nodes enclosing the cursor.
-//
-// The traversal sequence is determined by [ast.Inspect]. The types
-// argument, if non-empty, enables type-based filtering of events. The
-// function f if is called only for nodes whose type matches an
-// element of the types slice.
-//
-// If you need control over descent into subtrees,
-// or need both pre- and post-order notifications, use [Cursor.Inspect]
-func (c Cursor) Preorder(types ...ast.Node) iter.Seq[Cursor] {
-	mask := maskOf(types)
-
-	return func(yield func(Cursor) bool) {
-		events := c.in.events
-
-		for i, limit := c.indices(); i < limit; {
-			ev := events[i]
-			if ev.index > i { // push?
-				if ev.typ&mask != 0 && !yield(Cursor{c.in, i}) {
-					break
-				}
-				pop := ev.index
-				if events[pop].typ&mask == 0 {
-					// Subtree does not contain types: skip.
-					i = pop + 1
-					continue
-				}
-			}
-			i++
-		}
-	}
-}
-
-// Inspect visits the nodes of the subtree represented by c in
-// depth-first order. It calls f(n) for each node n before it
-// visits n's children. If f returns true, Inspect invokes f
-// recursively for each of the non-nil children of the node.
-//
-// Each node is represented by a Cursor that allows access to the
-// Node, but may also be used to start a new traversal, or to obtain
-// the stack of nodes enclosing the cursor.
-//
-// The complete traversal sequence is determined by [ast.Inspect].
-// The types argument, if non-empty, enables type-based filtering of
-// events. The function f if is called only for nodes whose type
-// matches an element of the types slice.
-func (c Cursor) Inspect(types []ast.Node, f func(c Cursor) (descend bool)) {
-	mask := maskOf(types)
-	events := c.in.events
-	for i, limit := c.indices(); i < limit; {
-		ev := events[i]
-		if ev.index > i {
-			// push
-			pop := ev.index
-			if ev.typ&mask != 0 && !f(Cursor{c.in, i}) ||
-				events[pop].typ&mask == 0 {
-				// The user opted not to descend, or the
-				// subtree does not contain types:
-				// skip past the pop.
-				i = pop + 1
-				continue
-			}
-		}
-		i++
-	}
-}
-
-// Enclosing returns an iterator over the nodes enclosing the current
-// current node, starting with the Cursor itself.
-//
-// Enclosing must not be called on the Root node (whose [Cursor.Node] returns nil).
-//
-// The types argument, if non-empty, enables type-based filtering of
-// events: the sequence includes only enclosing nodes whose type
-// matches an element of the types slice.
-func (c Cursor) Enclosing(types ...ast.Node) iter.Seq[Cursor] {
-	if c.index < 0 {
-		panic("Cursor.Enclosing called on Root node")
-	}
-
-	mask := maskOf(types)
-
-	return func(yield func(Cursor) bool) {
-		events := c.in.events
-		for i := c.index; i >= 0; i = events[i].parent {
-			if events[i].typ&mask != 0 && !yield(Cursor{c.in, i}) {
-				break
-			}
-		}
-	}
-}
-
-// Parent returns the parent of the current node.
-//
-// Parent must not be called on the Root node (whose [Cursor.Node] returns nil).
-func (c Cursor) Parent() Cursor {
-	if c.index < 0 {
-		panic("Cursor.Parent called on Root node")
-	}
-
-	return Cursor{c.in, c.in.events[c.index].parent}
-}
-
-// ParentEdge returns the identity of the field in the parent node
-// that holds this cursor's node, and if it is a list, the index within it.
-//
-// For example, f(x, y) is a CallExpr whose three children are Idents.
-// f has edge kind [edge.CallExpr_Fun] and index -1.
-// x and y have kind [edge.CallExpr_Args] and indices 0 and 1, respectively.
-//
-// If called on a child of the Root node, it returns ([edge.Invalid], -1).
-//
-// ParentEdge must not be called on the Root node (whose [Cursor.Node] returns nil).
-func (c Cursor) ParentEdge() (edge.Kind, int) {
-	if c.index < 0 {
-		panic("Cursor.ParentEdge called on Root node")
-	}
-	events := c.in.events
-	pop := events[c.index].index
-	return unpackEdgeKindAndIndex(events[pop].parent)
-}
-
-// ParentEdgeKind returns the kind component of the result of [Cursor.ParentEdge].
-func (c Cursor) ParentEdgeKind() edge.Kind {
-	ek, _ := c.ParentEdge()
-	return ek
-}
-
-// ParentEdgeIndex returns the index component of the result of [Cursor.ParentEdge].
-func (c Cursor) ParentEdgeIndex() int {
-	_, index := c.ParentEdge()
-	return index
-}
-
-// ChildAt returns the cursor for the child of the
-// current node identified by its edge and index.
-// The index must be -1 if the edge.Kind is not a slice.
-// The indicated child node must exist.
-//
-// ChildAt must not be called on the Root node (whose [Cursor.Node] returns nil).
-//
-// Invariant: c.Parent().ChildAt(c.ParentEdge()) == c.
-func (c Cursor) ChildAt(k edge.Kind, idx int) Cursor {
-	target := packEdgeKindAndIndex(k, idx)
-
-	// Unfortunately there's no shortcut to looping.
-	events := c.in.events
-	i := c.index + 1
-	for {
-		pop := events[i].index
-		if pop < i {
-			break
-		}
-		if events[pop].parent == target {
-			return Cursor{c.in, i}
-		}
-		i = pop + 1
-	}
-	panic(fmt.Sprintf("ChildAt(%v, %d): no such child of %v", k, idx, c))
-}
-
-// Child returns the cursor for n, which must be a direct child of c's Node.
-//
-// Child must not be called on the Root node (whose [Cursor.Node] returns nil).
-func (c Cursor) Child(n ast.Node) Cursor {
-	if c.index < 0 {
-		panic("Cursor.Child called on Root node")
-	}
-
-	if false {
-		// reference implementation
-		for child := range c.Children() {
-			if child.Node() == n {
-				return child
-			}
-		}
-
-	} else {
-		// optimized implementation
-		events := c.in.events
-		for i := c.index + 1; events[i].index > i; i = events[i].index + 1 {
-			if events[i].node == n {
-				return Cursor{c.in, i}
-			}
-		}
-	}
-	panic(fmt.Sprintf("Child(%T): not a child of %v", n, c))
-}
-
-// NextSibling returns the cursor for the next sibling node in the same list
-// (for example, of files, decls, specs, statements, fields, or expressions) as
-// the current node. It returns (zero, false) if the node is the last node in
-// the list, or is not part of a list.
-//
-// NextSibling must not be called on the Root node.
-//
-// See note at [Cursor.Children].
-func (c Cursor) NextSibling() (Cursor, bool) {
-	if c.index < 0 {
-		panic("Cursor.NextSibling called on Root node")
-	}
-
-	events := c.in.events
-	i := events[c.index].index + 1 // after corresponding pop
-	if i < int32(len(events)) {
-		if events[i].index > i { // push?
-			return Cursor{c.in, i}, true
-		}
-	}
-	return Cursor{}, false
-}
-
-// PrevSibling returns the cursor for the previous sibling node in the
-// same list (for example, of files, decls, specs, statements, fields,
-// or expressions) as the current node. It returns zero if the node is
-// the first node in the list, or is not part of a list.
-//
-// It must not be called on the Root node.
-//
-// See note at [Cursor.Children].
-func (c Cursor) PrevSibling() (Cursor, bool) {
-	if c.index < 0 {
-		panic("Cursor.PrevSibling called on Root node")
-	}
-
-	events := c.in.events
-	i := c.index - 1
-	if i >= 0 {
-		if j := events[i].index; j < i { // pop?
-			return Cursor{c.in, j}, true
-		}
-	}
-	return Cursor{}, false
-}
-
-// FirstChild returns the first direct child of the current node,
-// or zero if it has no children.
-func (c Cursor) FirstChild() (Cursor, bool) {
-	events := c.in.events
-	i := c.index + 1                                   // i=0 if c is root
-	if i < int32(len(events)) && events[i].index > i { // push?
-		return Cursor{c.in, i}, true
-	}
-	return Cursor{}, false
-}
-
-// LastChild returns the last direct child of the current node,
-// or zero if it has no children.
-func (c Cursor) LastChild() (Cursor, bool) {
-	events := c.in.events
-	if c.index < 0 { // root?
-		if len(events) > 0 {
-			// return push of final event (a pop)
-			return Cursor{c.in, events[len(events)-1].index}, true
-		}
-	} else {
-		j := events[c.index].index - 1 // before corresponding pop
-		// Inv: j == c.index if c has no children
-		//  or  j is last child's pop.
-		if j > c.index { // c has children
-			return Cursor{c.in, events[j].index}, true
-		}
-	}
-	return Cursor{}, false
-}
-
-// Children returns an iterator over the direct children of the
-// current node, if any.
-//
-// When using Children, NextChild, and PrevChild, bear in mind that a
-// Node's children may come from different fields, some of which may
-// be lists of nodes without a distinguished intervening container
-// such as [ast.BlockStmt].
-//
-// For example, [ast.CaseClause] has a field List of expressions and a
-// field Body of statements, so the children of a CaseClause are a mix
-// of expressions and statements. Other nodes that have "uncontained"
-// list fields include:
-//
-//   - [ast.ValueSpec] (Names, Values)
-//   - [ast.CompositeLit] (Type, Elts)
-//   - [ast.IndexListExpr] (X, Indices)
-//   - [ast.CallExpr] (Fun, Args)
-//   - [ast.AssignStmt] (Lhs, Rhs)
-//
-// So, do not assume that the previous sibling of an ast.Stmt is also
-// an ast.Stmt, or if it is, that they are executed sequentially,
-// unless you have established that, say, its parent is a BlockStmt
-// or its [Cursor.ParentEdge] is [edge.BlockStmt_List].
-// For example, given "for S1; ; S2 {}", the predecessor of S2 is S1,
-// even though they are not executed in sequence.
-func (c Cursor) Children() iter.Seq[Cursor] {
-	return func(yield func(Cursor) bool) {
-		c, ok := c.FirstChild()
-		for ok && yield(c) {
-			c, ok = c.NextSibling()
-		}
-	}
-}
-
-// Contains reports whether c contains or is equal to c2.
-//
-// Both Cursors must belong to the same [Inspector];
-// neither may be its Root node.
-func (c Cursor) Contains(c2 Cursor) bool {
-	if c.in != c2.in {
-		panic("different inspectors")
-	}
-	events := c.in.events
-	return c.index <= c2.index && events[c2.index].index <= events[c.index].index
-}
-
-// FindNode returns the cursor for node n if it belongs to the subtree
-// rooted at c. It returns zero if n is not found.
-func (c Cursor) FindNode(n ast.Node) (Cursor, bool) {
-
-	// FindNode is equivalent to this code,
-	// but more convenient and 15-20% faster:
-	if false {
-		for candidate := range c.Preorder(n) {
-			if candidate.Node() == n {
-				return candidate, true
-			}
-		}
-		return Cursor{}, false
-	}
-
-	// TODO(adonovan): opt: should we assume Node.Pos is accurate
-	// and combine type-based filtering with position filtering
-	// like FindByPos?
-
-	mask := maskOf([]ast.Node{n})
-	events := c.in.events
-
-	for i, limit := c.indices(); i < limit; i++ {
-		ev := events[i]
-		if ev.index > i { // push?
-			if ev.typ&mask != 0 && ev.node == n {
-				return Cursor{c.in, i}, true
-			}
-			pop := ev.index
-			if events[pop].typ&mask == 0 {
-				// Subtree does not contain type of n: skip.
-				i = pop
-			}
-		}
-	}
-	return Cursor{}, false
-}
-
-// FindByPos returns the cursor for the innermost node n in the tree
-// rooted at c such that n.Pos() <= start && end <= n.End().
-// (For an *ast.File, it uses the bounds n.FileStart-n.FileEnd.)
-//
-// An empty range (start == end) between two adjacent nodes is
-// considered to belong to the first node.
-//
-// It returns zero if none is found.
-// Precondition: start <= end.
-//
-// See also [astutil.PathEnclosingInterval], which
-// tolerates adjoining whitespace.
-func (c Cursor) FindByPos(start, end token.Pos) (Cursor, bool) {
-	if end < start {
-		panic("end < start")
-	}
-	events := c.in.events
-
-	// This algorithm could be implemented using c.Inspect,
-	// but it is about 2.5x slower.
-
-	// best is the push-index of the latest (=innermost) node containing range.
-	// (Beware: latest is not always innermost because FuncDecl.{Name,Type} overlap.)
-	best := int32(-1)
-	for i, limit := c.indices(); i < limit; i++ {
-		ev := events[i]
-		if ev.index > i { // push?
-			n := ev.node
-			var nodeEnd token.Pos
-			if file, ok := n.(*ast.File); ok {
-				nodeEnd = file.FileEnd
-				// Note: files may be out of Pos order.
-				if file.FileStart > start {
-					i = ev.index // disjoint, after; skip to next file
-					continue
-				}
-			} else {
-				// Edge case: FuncDecl.Name and .Type overlap:
-				// Don't update best from Name to FuncDecl.Type.
-				//
-				// The condition can be read as:
-				// - n is FuncType
-				// - n.parent is FuncDecl
-				// - best is strictly beneath the FuncDecl
-				if ev.typ == 1<<nFuncType &&
-					events[ev.parent].typ == 1<<nFuncDecl &&
-					best > ev.parent {
-					continue
-				}
-
-				nodeEnd = n.End()
-				if n.Pos() > start {
-					break // disjoint, after; stop
-				}
-			}
-
-			// Inv: node.{Pos,FileStart} <= start
-			if end <= nodeEnd {
-				// node fully contains target range
-				best = i
-
-				// Don't search beyond end of the first match.
-				// This is important only for an empty range (start=end)
-				// between two adjoining nodes, which would otherwise
-				// match both nodes; we want to match only the first.
-				limit = ev.index
-			} else if nodeEnd < start {
-				i = ev.index // disjoint, before; skip forward
-			}
-		}
-	}
-	if best >= 0 {
-		return Cursor{c.in, best}, true
-	}
-	return Cursor{}, false
-}
diff --git a/vendor/golang.org/x/tools/go/ast/inspector/inspector.go b/vendor/golang.org/x/tools/go/ast/inspector/inspector.go
deleted file mode 100644
index b414d17ebd..0000000000
--- a/vendor/golang.org/x/tools/go/ast/inspector/inspector.go
+++ /dev/null
@@ -1,311 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package inspector provides helper functions for traversal over the
-// syntax trees of a package, including node filtering by type, and
-// materialization of the traversal stack.
-//
-// During construction, the inspector does a complete traversal and
-// builds a list of push/pop events and their node type. Subsequent
-// method calls that request a traversal scan this list, rather than walk
-// the AST, and perform type filtering using efficient bit sets.
-// This representation is sometimes called a "balanced parenthesis tree."
-//
-// Experiments suggest the inspector's traversals are about 2.5x faster
-// than [ast.Inspect], but it may take around 5 traversals for this
-// benefit to amortize the inspector's construction cost.
-// If efficiency is the primary concern, do not use Inspector for
-// one-off traversals.
-//
-// The [Cursor] type provides a more flexible API for efficient
-// navigation of syntax trees in all four "cardinal directions". For
-// example, traversals may be nested, so you can find each node of
-// type A and then search within it for nodes of type B. Or you can
-// traverse from a node to its immediate neighbors: its parent, its
-// previous and next sibling, or its first and last child. We
-// recommend using methods of Cursor in preference to Inspector where
-// possible.
-package inspector
-
-// There are four orthogonal features in a traversal:
-//  1 type filtering
-//  2 pruning
-//  3 postorder calls to f
-//  4 stack
-// Rather than offer all of them in the API,
-// only a few combinations are exposed:
-// - Preorder is the fastest and has fewest features,
-//   but is the most commonly needed traversal.
-// - Nodes and WithStack both provide pruning and postorder calls,
-//   even though few clients need it, because supporting two versions
-//   is not justified.
-// More combinations could be supported by expressing them as
-// wrappers around a more generic traversal, but this was measured
-// and found to degrade performance significantly (30%).
-
-import (
-	"go/ast"
-
-	"golang.org/x/tools/go/ast/edge"
-)
-
-// An Inspector provides methods for inspecting
-// (traversing) the syntax trees of a package.
-type Inspector struct {
-	events []event
-}
-
-func packEdgeKindAndIndex(ek edge.Kind, index int) int32 {
-	return int32(uint32(index+1)<<7 | uint32(ek))
-}
-
-// unpackEdgeKindAndIndex unpacks the edge kind and edge index (within
-// an []ast.Node slice) from the parent field of a pop event.
-func unpackEdgeKindAndIndex(x int32) (edge.Kind, int) {
-	// The "parent" field of a pop node holds the
-	// edge Kind in the lower 7 bits and the index+1
-	// in the upper 25.
-	return edge.Kind(x & 0x7f), int(x>>7) - 1
-}
-
-// New returns an Inspector for the specified syntax trees.
-func New(files []*ast.File) *Inspector {
-	return &Inspector{traverse(files)}
-}
-
-// An event represents a push or a pop
-// of an ast.Node during a traversal.
-type event struct {
-	node   ast.Node
-	typ    uint64 // typeOf(node) on push event, or union of typ strictly between push and pop events on pop events
-	index  int32  // index of corresponding push or pop event
-	parent int32  // index of parent's push node (push nodes only), or packed edge kind/index (pop nodes only)
-}
-
-// TODO: Experiment with storing only the second word of event.node (unsafe.Pointer).
-// Type can be recovered from the sole bit in typ.
-// [Tried this, wasn't faster. --adonovan]
-
-// Preorder visits all the nodes of the files supplied to [New] in
-// depth-first order. It calls f(n) for each node n before it visits
-// n's children.
-//
-// The complete traversal sequence is determined by [ast.Inspect].
-// The types argument, if non-empty, enables type-based filtering of
-// events. The function f is called only for nodes whose type
-// matches an element of the types slice.
-//
-// The [Cursor.Preorder] method provides a richer alternative interface.
-// Example:
-//
-//	for c := range in.Root().Preorder(types) { ... }
-func (in *Inspector) Preorder(types []ast.Node, f func(ast.Node)) {
-	// Because it avoids postorder calls to f, and the pruning
-	// check, Preorder is almost twice as fast as Nodes. The two
-	// features seem to contribute similar slowdowns (~1.4x each).
-
-	// This function is equivalent to the PreorderSeq call below,
-	// but to avoid the additional dynamic call (which adds 13-35%
-	// to the benchmarks), we expand it out.
-	//
-	// in.PreorderSeq(types...)(func(n ast.Node) bool {
-	// 	f(n)
-	// 	return true
-	// })
-
-	mask := maskOf(types)
-	for i := int32(0); i < int32(len(in.events)); {
-		ev := in.events[i]
-		if ev.index > i {
-			// push
-			if ev.typ&mask != 0 {
-				f(ev.node)
-			}
-			pop := ev.index
-			if in.events[pop].typ&mask == 0 {
-				// Subtrees do not contain types: skip them and pop.
-				i = pop + 1
-				continue
-			}
-		}
-		i++
-	}
-}
-
-// Nodes visits the nodes of the files supplied to [New] in depth-first
-// order. It calls f(n, true) for each node n before it visits n's
-// children. If f returns true, Nodes invokes f recursively for each
-// of the non-nil children of the node, followed by a call of
-// f(n, false).
-//
-// The complete traversal sequence is determined by [ast.Inspect].
-// The types argument, if non-empty, enables type-based filtering of
-// events. The function f if is called only for nodes whose type
-// matches an element of the types slice.
-//
-// The [Cursor.Inspect] method provides a richer alternative interface.
-// Example:
-//
-//	in.Root().Inspect(types, func(c Cursor) bool {
-//		...
-//		return true
-//	}
-func (in *Inspector) Nodes(types []ast.Node, f func(n ast.Node, push bool) (proceed bool)) {
-	mask := maskOf(types)
-	for i := int32(0); i < int32(len(in.events)); {
-		ev := in.events[i]
-		if ev.index > i {
-			// push
-			pop := ev.index
-			if ev.typ&mask != 0 {
-				if !f(ev.node, true) {
-					i = pop + 1 // jump to corresponding pop + 1
-					continue
-				}
-			}
-			if in.events[pop].typ&mask == 0 {
-				// Subtrees do not contain types: skip them.
-				i = pop
-				continue
-			}
-		} else {
-			// pop
-			push := ev.index
-			if in.events[push].typ&mask != 0 {
-				f(ev.node, false)
-			}
-		}
-		i++
-	}
-}
-
-// WithStack visits nodes in a similar manner to Nodes, but it
-// supplies each call to f an additional argument, the current
-// traversal stack. The stack's first element is the outermost node,
-// an *ast.File; its last is the innermost, n.
-//
-// The [Cursor.Inspect] method provides a richer alternative interface.
-// Example:
-//
-//	in.Root().Inspect(types, func(c Cursor) bool {
-//		stack := slices.Collect(c.Enclosing())
-//		...
-//		return true
-//	})
-func (in *Inspector) WithStack(types []ast.Node, f func(n ast.Node, push bool, stack []ast.Node) (proceed bool)) {
-	mask := maskOf(types)
-	var stack []ast.Node
-	for i := int32(0); i < int32(len(in.events)); {
-		ev := in.events[i]
-		if ev.index > i {
-			// push
-			pop := ev.index
-			stack = append(stack, ev.node)
-			if ev.typ&mask != 0 {
-				if !f(ev.node, true, stack) {
-					i = pop + 1
-					stack = stack[:len(stack)-1]
-					continue
-				}
-			}
-			if in.events[pop].typ&mask == 0 {
-				// Subtrees does not contain types: skip them.
-				i = pop
-				continue
-			}
-		} else {
-			// pop
-			push := ev.index
-			if in.events[push].typ&mask != 0 {
-				f(ev.node, false, stack)
-			}
-			stack = stack[:len(stack)-1]
-		}
-		i++
-	}
-}
-
-// traverse builds the table of events representing a traversal.
-func traverse(files []*ast.File) []event {
-	// Preallocate approximate number of events
-	// based on source file extent of the declarations.
-	// (We use End-Pos not FileStart-FileEnd to neglect
-	// the effect of long doc comments.)
-	// This makes traverse faster by 4x (!).
-	var extent int
-	for _, f := range files {
-		extent += int(f.End() - f.Pos())
-	}
-	// This estimate is based on the net/http package.
-	capacity := min(extent*33/100, 1e6) // impose some reasonable maximum (1M)
-
-	v := &visitor{
-		events: make([]event, 0, capacity),
-		stack:  []item{{index: -1}}, // include an extra event so file nodes have a parent
-	}
-	for _, file := range files {
-		walk(v, edge.Invalid, -1, file)
-	}
-	return v.events
-}
-
-type visitor struct {
-	events []event
-	stack  []item
-}
-
-type item struct {
-	index            int32  // index of current node's push event
-	parentIndex      int32  // index of parent node's push event
-	typAccum         uint64 // accumulated type bits of current node's descendants
-	edgeKindAndIndex int32  // edge.Kind and index, bit packed
-}
-
-func (v *visitor) push(ek edge.Kind, eindex int, node ast.Node) {
-	var (
-		index       = int32(len(v.events))
-		parentIndex = v.stack[len(v.stack)-1].index
-	)
-	v.events = append(v.events, event{
-		node:   node,
-		parent: parentIndex,
-		typ:    typeOf(node),
-		index:  0, // (pop index is set later by visitor.pop)
-	})
-	v.stack = append(v.stack, item{
-		index:            index,
-		parentIndex:      parentIndex,
-		edgeKindAndIndex: packEdgeKindAndIndex(ek, eindex),
-	})
-
-	// 2B nodes ought to be enough for anyone!
-	if int32(len(v.events)) < 0 {
-		panic("event index exceeded int32")
-	}
-
-	// 32M elements in an []ast.Node ought to be enough for anyone!
-	if ek2, eindex2 := unpackEdgeKindAndIndex(packEdgeKindAndIndex(ek, eindex)); ek2 != ek || eindex2 != eindex {
-		panic("Node slice index exceeded uint25")
-	}
-}
-
-func (v *visitor) pop(node ast.Node) {
-	top := len(v.stack) - 1
-	current := v.stack[top]
-
-	push := &v.events[current.index]
-	parent := &v.stack[top-1]
-
-	push.index = int32(len(v.events))              // make push event refer to pop
-	parent.typAccum |= current.typAccum | push.typ // accumulate type bits into parent
-
-	v.stack = v.stack[:top]
-
-	v.events = append(v.events, event{
-		node:   node,
-		typ:    current.typAccum,
-		index:  current.index,
-		parent: current.edgeKindAndIndex, // see [unpackEdgeKindAndIndex]
-	})
-}
diff --git a/vendor/golang.org/x/tools/go/ast/inspector/iter.go b/vendor/golang.org/x/tools/go/ast/inspector/iter.go
deleted file mode 100644
index b68c553d41..0000000000
--- a/vendor/golang.org/x/tools/go/ast/inspector/iter.go
+++ /dev/null
@@ -1,113 +0,0 @@
-// Copyright 2024 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build go1.23
-
-package inspector
-
-import (
-	"go/ast"
-	"iter"
-)
-
-// PreorderSeq returns an iterator that visits all the
-// nodes of the files supplied to [New] in depth-first order.
-// It visits each node n before n's children.
-// The complete traversal sequence is determined by ast.Inspect.
-//
-// The types argument, if non-empty, enables type-based filtering:
-// only nodes whose type matches an element of the types slice are
-// included in the sequence.
-//
-// Example:
-//
-//	for call := range in.PreorderSeq((*ast.CallExpr)(nil)) { ... }
-//
-// The [All] function is more convenient if there is exactly one node type:
-//
-//	for call := range All[*ast.CallExpr](in) { ... }
-//
-// See also the newer and more flexible [Cursor] API, which lets you
-// start the traversal at an arbitrary node, and reports each matching
-// node by its Cursor, enabling easier navigation.
-// The above example would be written thus:
-//
-//	for curCall := range in.Root().Preorder((*ast.CallExpr)(nil)) {
-//		call := curCall.Node().(*ast.CallExpr)
-//		...
-//	}
-func (in *Inspector) PreorderSeq(types ...ast.Node) iter.Seq[ast.Node] {
-
-	// This implementation is identical to Preorder,
-	// except that it supports breaking out of the loop.
-
-	return func(yield func(ast.Node) bool) {
-		mask := maskOf(types)
-		for i := int32(0); i < int32(len(in.events)); {
-			ev := in.events[i]
-			if ev.index > i {
-				// push
-				if ev.typ&mask != 0 {
-					if !yield(ev.node) {
-						break
-					}
-				}
-				pop := ev.index
-				if in.events[pop].typ&mask == 0 {
-					// Subtrees do not contain types: skip them and pop.
-					i = pop + 1
-					continue
-				}
-			}
-			i++
-		}
-	}
-}
-
-// All[N] returns an iterator over all the nodes of type N.
-// N must be a pointer-to-struct type that implements ast.Node.
-//
-// Example:
-//
-//	for call := range All[*ast.CallExpr](in) { ... }
-//
-// See also the newer and more flexible [Cursor] API, which lets you
-// start the traversal at an arbitrary node, and reports each matching
-// node by its Cursor, enabling easier navigation.
-// The above example would be written thus:
-//
-//	for curCall := range in.Root().Preorder((*ast.CallExpr)(nil)) {
-//		call := curCall.Node().(*ast.CallExpr)
-//		...
-//	}
-func All[N interface {
-	*S
-	ast.Node
-}, S any](in *Inspector) iter.Seq[N] {
-
-	// To avoid additional dynamic call overheads,
-	// we duplicate rather than call the logic of PreorderSeq.
-
-	mask := typeOf((N)(nil))
-	return func(yield func(N) bool) {
-		for i := int32(0); i < int32(len(in.events)); {
-			ev := in.events[i]
-			if ev.index > i {
-				// push
-				if ev.typ&mask != 0 {
-					if !yield(ev.node.(N)) {
-						break
-					}
-				}
-				pop := ev.index
-				if in.events[pop].typ&mask == 0 {
-					// Subtrees do not contain types: skip them and pop.
-					i = pop + 1
-					continue
-				}
-			}
-			i++
-		}
-	}
-}
diff --git a/vendor/golang.org/x/tools/go/ast/inspector/typeof.go b/vendor/golang.org/x/tools/go/ast/inspector/typeof.go
deleted file mode 100644
index 9852331a3d..0000000000
--- a/vendor/golang.org/x/tools/go/ast/inspector/typeof.go
+++ /dev/null
@@ -1,227 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package inspector
-
-// This file defines func typeOf(ast.Node) uint64.
-//
-// The initial map-based implementation was too slow;
-// see https://go-review.googlesource.com/c/tools/+/135655/1/go/ast/inspector/inspector.go#196
-
-import (
-	"go/ast"
-	"math"
-)
-
-const (
-	nArrayType = iota
-	nAssignStmt
-	nBadDecl
-	nBadExpr
-	nBadStmt
-	nBasicLit
-	nBinaryExpr
-	nBlockStmt
-	nBranchStmt
-	nCallExpr
-	nCaseClause
-	nChanType
-	nCommClause
-	nComment
-	nCommentGroup
-	nCompositeLit
-	nDeclStmt
-	nDeferStmt
-	nEllipsis
-	nEmptyStmt
-	nExprStmt
-	nField
-	nFieldList
-	nFile
-	nForStmt
-	nFuncDecl
-	nFuncLit
-	nFuncType
-	nGenDecl
-	nGoStmt
-	nIdent
-	nIfStmt
-	nImportSpec
-	nIncDecStmt
-	nIndexExpr
-	nIndexListExpr
-	nInterfaceType
-	nKeyValueExpr
-	nLabeledStmt
-	nMapType
-	nPackage
-	nParenExpr
-	nRangeStmt
-	nReturnStmt
-	nSelectStmt
-	nSelectorExpr
-	nSendStmt
-	nSliceExpr
-	nStarExpr
-	nStructType
-	nSwitchStmt
-	nTypeAssertExpr
-	nTypeSpec
-	nTypeSwitchStmt
-	nUnaryExpr
-	nValueSpec
-)
-
-// typeOf returns a distinct single-bit value that represents the type of n.
-//
-// Various implementations were benchmarked with BenchmarkNewInspector:
-//
-//	                                                                GOGC=off
-//	- type switch					4.9-5.5ms	2.1ms
-//	- binary search over a sorted list of types	5.5-5.9ms	2.5ms
-//	- linear scan, frequency-ordered list		5.9-6.1ms	2.7ms
-//	- linear scan, unordered list			6.4ms		2.7ms
-//	- hash table					6.5ms		3.1ms
-//
-// A perfect hash seemed like overkill.
-//
-// The compiler's switch statement is the clear winner
-// as it produces a binary tree in code,
-// with constant conditions and good branch prediction.
-// (Sadly it is the most verbose in source code.)
-// Binary search suffered from poor branch prediction.
-func typeOf(n ast.Node) uint64 {
-	// Fast path: nearly half of all nodes are identifiers.
-	if _, ok := n.(*ast.Ident); ok {
-		return 1 << nIdent
-	}
-
-	// These cases include all nodes encountered by ast.Inspect.
-	switch n.(type) {
-	case *ast.ArrayType:
-		return 1 << nArrayType
-	case *ast.AssignStmt:
-		return 1 << nAssignStmt
-	case *ast.BadDecl:
-		return 1 << nBadDecl
-	case *ast.BadExpr:
-		return 1 << nBadExpr
-	case *ast.BadStmt:
-		return 1 << nBadStmt
-	case *ast.BasicLit:
-		return 1 << nBasicLit
-	case *ast.BinaryExpr:
-		return 1 << nBinaryExpr
-	case *ast.BlockStmt:
-		return 1 << nBlockStmt
-	case *ast.BranchStmt:
-		return 1 << nBranchStmt
-	case *ast.CallExpr:
-		return 1 << nCallExpr
-	case *ast.CaseClause:
-		return 1 << nCaseClause
-	case *ast.ChanType:
-		return 1 << nChanType
-	case *ast.CommClause:
-		return 1 << nCommClause
-	case *ast.Comment:
-		return 1 << nComment
-	case *ast.CommentGroup:
-		return 1 << nCommentGroup
-	case *ast.CompositeLit:
-		return 1 << nCompositeLit
-	case *ast.DeclStmt:
-		return 1 << nDeclStmt
-	case *ast.DeferStmt:
-		return 1 << nDeferStmt
-	case *ast.Ellipsis:
-		return 1 << nEllipsis
-	case *ast.EmptyStmt:
-		return 1 << nEmptyStmt
-	case *ast.ExprStmt:
-		return 1 << nExprStmt
-	case *ast.Field:
-		return 1 << nField
-	case *ast.FieldList:
-		return 1 << nFieldList
-	case *ast.File:
-		return 1 << nFile
-	case *ast.ForStmt:
-		return 1 << nForStmt
-	case *ast.FuncDecl:
-		return 1 << nFuncDecl
-	case *ast.FuncLit:
-		return 1 << nFuncLit
-	case *ast.FuncType:
-		return 1 << nFuncType
-	case *ast.GenDecl:
-		return 1 << nGenDecl
-	case *ast.GoStmt:
-		return 1 << nGoStmt
-	case *ast.Ident:
-		return 1 << nIdent
-	case *ast.IfStmt:
-		return 1 << nIfStmt
-	case *ast.ImportSpec:
-		return 1 << nImportSpec
-	case *ast.IncDecStmt:
-		return 1 << nIncDecStmt
-	case *ast.IndexExpr:
-		return 1 << nIndexExpr
-	case *ast.IndexListExpr:
-		return 1 << nIndexListExpr
-	case *ast.InterfaceType:
-		return 1 << nInterfaceType
-	case *ast.KeyValueExpr:
-		return 1 << nKeyValueExpr
-	case *ast.LabeledStmt:
-		return 1 << nLabeledStmt
-	case *ast.MapType:
-		return 1 << nMapType
-	case *ast.Package:
-		return 1 << nPackage
-	case *ast.ParenExpr:
-		return 1 << nParenExpr
-	case *ast.RangeStmt:
-		return 1 << nRangeStmt
-	case *ast.ReturnStmt:
-		return 1 << nReturnStmt
-	case *ast.SelectStmt:
-		return 1 << nSelectStmt
-	case *ast.SelectorExpr:
-		return 1 << nSelectorExpr
-	case *ast.SendStmt:
-		return 1 << nSendStmt
-	case *ast.SliceExpr:
-		return 1 << nSliceExpr
-	case *ast.StarExpr:
-		return 1 << nStarExpr
-	case *ast.StructType:
-		return 1 << nStructType
-	case *ast.SwitchStmt:
-		return 1 << nSwitchStmt
-	case *ast.TypeAssertExpr:
-		return 1 << nTypeAssertExpr
-	case *ast.TypeSpec:
-		return 1 << nTypeSpec
-	case *ast.TypeSwitchStmt:
-		return 1 << nTypeSwitchStmt
-	case *ast.UnaryExpr:
-		return 1 << nUnaryExpr
-	case *ast.ValueSpec:
-		return 1 << nValueSpec
-	}
-	return 0
-}
-
-func maskOf(nodes []ast.Node) uint64 {
-	if len(nodes) == 0 {
-		return math.MaxUint64 // match all node types
-	}
-	var mask uint64
-	for _, n := range nodes {
-		mask |= typeOf(n)
-	}
-	return mask
-}
diff --git a/vendor/golang.org/x/tools/go/ast/inspector/walk.go b/vendor/golang.org/x/tools/go/ast/inspector/walk.go
deleted file mode 100644
index 5f1c93c8a7..0000000000
--- a/vendor/golang.org/x/tools/go/ast/inspector/walk.go
+++ /dev/null
@@ -1,341 +0,0 @@
-// Copyright 2025 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package inspector
-
-// This file is a fork of ast.Inspect to reduce unnecessary dynamic
-// calls and to gather edge information.
-//
-// Consistency with the original is ensured by TestInspectAllNodes.
-
-import (
-	"fmt"
-	"go/ast"
-
-	"golang.org/x/tools/go/ast/edge"
-)
-
-func walkList[N ast.Node](v *visitor, ek edge.Kind, list []N) {
-	for i, node := range list {
-		walk(v, ek, i, node)
-	}
-}
-
-func walk(v *visitor, ek edge.Kind, index int, node ast.Node) {
-	v.push(ek, index, node)
-
-	// walk children
-	// (the order of the cases matches the order
-	// of the corresponding node types in ast.go)
-	switch n := node.(type) {
-	// Comments and fields
-	case *ast.Comment:
-		// nothing to do
-
-	case *ast.CommentGroup:
-		walkList(v, edge.CommentGroup_List, n.List)
-
-	case *ast.Field:
-		if n.Doc != nil {
-			walk(v, edge.Field_Doc, -1, n.Doc)
-		}
-		walkList(v, edge.Field_Names, n.Names)
-		if n.Type != nil {
-			walk(v, edge.Field_Type, -1, n.Type)
-		}
-		if n.Tag != nil {
-			walk(v, edge.Field_Tag, -1, n.Tag)
-		}
-		if n.Comment != nil {
-			walk(v, edge.Field_Comment, -1, n.Comment)
-		}
-
-	case *ast.FieldList:
-		walkList(v, edge.FieldList_List, n.List)
-
-	// Expressions
-	case *ast.BadExpr, *ast.Ident, *ast.BasicLit:
-		// nothing to do
-
-	case *ast.Ellipsis:
-		if n.Elt != nil {
-			walk(v, edge.Ellipsis_Elt, -1, n.Elt)
-		}
-
-	case *ast.FuncLit:
-		walk(v, edge.FuncLit_Type, -1, n.Type)
-		walk(v, edge.FuncLit_Body, -1, n.Body)
-
-	case *ast.CompositeLit:
-		if n.Type != nil {
-			walk(v, edge.CompositeLit_Type, -1, n.Type)
-		}
-		walkList(v, edge.CompositeLit_Elts, n.Elts)
-
-	case *ast.ParenExpr:
-		walk(v, edge.ParenExpr_X, -1, n.X)
-
-	case *ast.SelectorExpr:
-		walk(v, edge.SelectorExpr_X, -1, n.X)
-		walk(v, edge.SelectorExpr_Sel, -1, n.Sel)
-
-	case *ast.IndexExpr:
-		walk(v, edge.IndexExpr_X, -1, n.X)
-		walk(v, edge.IndexExpr_Index, -1, n.Index)
-
-	case *ast.IndexListExpr:
-		walk(v, edge.IndexListExpr_X, -1, n.X)
-		walkList(v, edge.IndexListExpr_Indices, n.Indices)
-
-	case *ast.SliceExpr:
-		walk(v, edge.SliceExpr_X, -1, n.X)
-		if n.Low != nil {
-			walk(v, edge.SliceExpr_Low, -1, n.Low)
-		}
-		if n.High != nil {
-			walk(v, edge.SliceExpr_High, -1, n.High)
-		}
-		if n.Max != nil {
-			walk(v, edge.SliceExpr_Max, -1, n.Max)
-		}
-
-	case *ast.TypeAssertExpr:
-		walk(v, edge.TypeAssertExpr_X, -1, n.X)
-		if n.Type != nil {
-			walk(v, edge.TypeAssertExpr_Type, -1, n.Type)
-		}
-
-	case *ast.CallExpr:
-		walk(v, edge.CallExpr_Fun, -1, n.Fun)
-		walkList(v, edge.CallExpr_Args, n.Args)
-
-	case *ast.StarExpr:
-		walk(v, edge.StarExpr_X, -1, n.X)
-
-	case *ast.UnaryExpr:
-		walk(v, edge.UnaryExpr_X, -1, n.X)
-
-	case *ast.BinaryExpr:
-		walk(v, edge.BinaryExpr_X, -1, n.X)
-		walk(v, edge.BinaryExpr_Y, -1, n.Y)
-
-	case *ast.KeyValueExpr:
-		walk(v, edge.KeyValueExpr_Key, -1, n.Key)
-		walk(v, edge.KeyValueExpr_Value, -1, n.Value)
-
-	// Types
-	case *ast.ArrayType:
-		if n.Len != nil {
-			walk(v, edge.ArrayType_Len, -1, n.Len)
-		}
-		walk(v, edge.ArrayType_Elt, -1, n.Elt)
-
-	case *ast.StructType:
-		walk(v, edge.StructType_Fields, -1, n.Fields)
-
-	case *ast.FuncType:
-		if n.TypeParams != nil {
-			walk(v, edge.FuncType_TypeParams, -1, n.TypeParams)
-		}
-		if n.Params != nil {
-			walk(v, edge.FuncType_Params, -1, n.Params)
-		}
-		if n.Results != nil {
-			walk(v, edge.FuncType_Results, -1, n.Results)
-		}
-
-	case *ast.InterfaceType:
-		walk(v, edge.InterfaceType_Methods, -1, n.Methods)
-
-	case *ast.MapType:
-		walk(v, edge.MapType_Key, -1, n.Key)
-		walk(v, edge.MapType_Value, -1, n.Value)
-
-	case *ast.ChanType:
-		walk(v, edge.ChanType_Value, -1, n.Value)
-
-	// Statements
-	case *ast.BadStmt:
-		// nothing to do
-
-	case *ast.DeclStmt:
-		walk(v, edge.DeclStmt_Decl, -1, n.Decl)
-
-	case *ast.EmptyStmt:
-		// nothing to do
-
-	case *ast.LabeledStmt:
-		walk(v, edge.LabeledStmt_Label, -1, n.Label)
-		walk(v, edge.LabeledStmt_Stmt, -1, n.Stmt)
-
-	case *ast.ExprStmt:
-		walk(v, edge.ExprStmt_X, -1, n.X)
-
-	case *ast.SendStmt:
-		walk(v, edge.SendStmt_Chan, -1, n.Chan)
-		walk(v, edge.SendStmt_Value, -1, n.Value)
-
-	case *ast.IncDecStmt:
-		walk(v, edge.IncDecStmt_X, -1, n.X)
-
-	case *ast.AssignStmt:
-		walkList(v, edge.AssignStmt_Lhs, n.Lhs)
-		walkList(v, edge.AssignStmt_Rhs, n.Rhs)
-
-	case *ast.GoStmt:
-		walk(v, edge.GoStmt_Call, -1, n.Call)
-
-	case *ast.DeferStmt:
-		walk(v, edge.DeferStmt_Call, -1, n.Call)
-
-	case *ast.ReturnStmt:
-		walkList(v, edge.ReturnStmt_Results, n.Results)
-
-	case *ast.BranchStmt:
-		if n.Label != nil {
-			walk(v, edge.BranchStmt_Label, -1, n.Label)
-		}
-
-	case *ast.BlockStmt:
-		walkList(v, edge.BlockStmt_List, n.List)
-
-	case *ast.IfStmt:
-		if n.Init != nil {
-			walk(v, edge.IfStmt_Init, -1, n.Init)
-		}
-		walk(v, edge.IfStmt_Cond, -1, n.Cond)
-		walk(v, edge.IfStmt_Body, -1, n.Body)
-		if n.Else != nil {
-			walk(v, edge.IfStmt_Else, -1, n.Else)
-		}
-
-	case *ast.CaseClause:
-		walkList(v, edge.CaseClause_List, n.List)
-		walkList(v, edge.CaseClause_Body, n.Body)
-
-	case *ast.SwitchStmt:
-		if n.Init != nil {
-			walk(v, edge.SwitchStmt_Init, -1, n.Init)
-		}
-		if n.Tag != nil {
-			walk(v, edge.SwitchStmt_Tag, -1, n.Tag)
-		}
-		walk(v, edge.SwitchStmt_Body, -1, n.Body)
-
-	case *ast.TypeSwitchStmt:
-		if n.Init != nil {
-			walk(v, edge.TypeSwitchStmt_Init, -1, n.Init)
-		}
-		walk(v, edge.TypeSwitchStmt_Assign, -1, n.Assign)
-		walk(v, edge.TypeSwitchStmt_Body, -1, n.Body)
-
-	case *ast.CommClause:
-		if n.Comm != nil {
-			walk(v, edge.CommClause_Comm, -1, n.Comm)
-		}
-		walkList(v, edge.CommClause_Body, n.Body)
-
-	case *ast.SelectStmt:
-		walk(v, edge.SelectStmt_Body, -1, n.Body)
-
-	case *ast.ForStmt:
-		if n.Init != nil {
-			walk(v, edge.ForStmt_Init, -1, n.Init)
-		}
-		if n.Cond != nil {
-			walk(v, edge.ForStmt_Cond, -1, n.Cond)
-		}
-		if n.Post != nil {
-			walk(v, edge.ForStmt_Post, -1, n.Post)
-		}
-		walk(v, edge.ForStmt_Body, -1, n.Body)
-
-	case *ast.RangeStmt:
-		if n.Key != nil {
-			walk(v, edge.RangeStmt_Key, -1, n.Key)
-		}
-		if n.Value != nil {
-			walk(v, edge.RangeStmt_Value, -1, n.Value)
-		}
-		walk(v, edge.RangeStmt_X, -1, n.X)
-		walk(v, edge.RangeStmt_Body, -1, n.Body)
-
-	// Declarations
-	case *ast.ImportSpec:
-		if n.Doc != nil {
-			walk(v, edge.ImportSpec_Doc, -1, n.Doc)
-		}
-		if n.Name != nil {
-			walk(v, edge.ImportSpec_Name, -1, n.Name)
-		}
-		walk(v, edge.ImportSpec_Path, -1, n.Path)
-		if n.Comment != nil {
-			walk(v, edge.ImportSpec_Comment, -1, n.Comment)
-		}
-
-	case *ast.ValueSpec:
-		if n.Doc != nil {
-			walk(v, edge.ValueSpec_Doc, -1, n.Doc)
-		}
-		walkList(v, edge.ValueSpec_Names, n.Names)
-		if n.Type != nil {
-			walk(v, edge.ValueSpec_Type, -1, n.Type)
-		}
-		walkList(v, edge.ValueSpec_Values, n.Values)
-		if n.Comment != nil {
-			walk(v, edge.ValueSpec_Comment, -1, n.Comment)
-		}
-
-	case *ast.TypeSpec:
-		if n.Doc != nil {
-			walk(v, edge.TypeSpec_Doc, -1, n.Doc)
-		}
-		walk(v, edge.TypeSpec_Name, -1, n.Name)
-		if n.TypeParams != nil {
-			walk(v, edge.TypeSpec_TypeParams, -1, n.TypeParams)
-		}
-		walk(v, edge.TypeSpec_Type, -1, n.Type)
-		if n.Comment != nil {
-			walk(v, edge.TypeSpec_Comment, -1, n.Comment)
-		}
-
-	case *ast.BadDecl:
-		// nothing to do
-
-	case *ast.GenDecl:
-		if n.Doc != nil {
-			walk(v, edge.GenDecl_Doc, -1, n.Doc)
-		}
-		walkList(v, edge.GenDecl_Specs, n.Specs)
-
-	case *ast.FuncDecl:
-		if n.Doc != nil {
-			walk(v, edge.FuncDecl_Doc, -1, n.Doc)
-		}
-		if n.Recv != nil {
-			walk(v, edge.FuncDecl_Recv, -1, n.Recv)
-		}
-		walk(v, edge.FuncDecl_Name, -1, n.Name)
-		walk(v, edge.FuncDecl_Type, -1, n.Type)
-		if n.Body != nil {
-			walk(v, edge.FuncDecl_Body, -1, n.Body)
-		}
-
-	case *ast.File:
-		if n.Doc != nil {
-			walk(v, edge.File_Doc, -1, n.Doc)
-		}
-		walk(v, edge.File_Name, -1, n.Name)
-		walkList(v, edge.File_Decls, n.Decls)
-		// don't walk n.Comments - they have been
-		// visited already through the individual
-		// nodes
-
-	default:
-		// (includes *ast.Package)
-		panic(fmt.Sprintf("Walk: unexpected node type %T", n))
-	}
-
-	v.pop(node)
-}
diff --git a/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go b/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go
deleted file mode 100644
index 7b90bc9235..0000000000
--- a/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go
+++ /dev/null
@@ -1,236 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package gcexportdata provides functions for reading and writing
-// export data, which is a serialized description of the API of a Go
-// package including the names, kinds, types, and locations of all
-// exported declarations.
-//
-// The standard Go compiler (cmd/compile) writes an export data file
-// for each package it compiles, which it later reads when compiling
-// packages that import the earlier one. The compiler must thus
-// contain logic to both write and read export data.
-// (See the "Export" section in the cmd/compile/README file.)
-//
-// The [Read] function in this package can read files produced by the
-// compiler, producing [go/types] data structures. As a matter of
-// policy, Read supports export data files produced by only the last
-// two Go releases plus tip; see https://go.dev/issue/68898. The
-// export data files produced by the compiler contain additional
-// details related to generics, inlining, and other optimizations that
-// cannot be decoded by the [Read] function.
-//
-// In files written by the compiler, the export data is not at the
-// start of the file. Before calling Read, use [NewReader] to locate
-// the desired portion of the file.
-//
-// The [Write] function in this package encodes the exported API of a
-// Go package ([types.Package]) as a file. Such files can be later
-// decoded by Read, but cannot be consumed by the compiler.
-//
-// # Future changes
-//
-// Although Read supports the formats written by both Write and the
-// compiler, the two are quite different, and there is an open
-// proposal (https://go.dev/issue/69491) to separate these APIs.
-//
-// Under that proposal, this package would ultimately provide only the
-// Read operation for compiler export data, which must be defined in
-// this module (golang.org/x/tools), not in the standard library, to
-// avoid version skew for developer tools that need to read compiler
-// export data both before and after a Go release, such as from Go
-// 1.23 to Go 1.24. Because this package lives in the tools module,
-// clients can update their version of the module some time before the
-// Go 1.24 release and rebuild and redeploy their tools, which will
-// then be able to consume both Go 1.23 and Go 1.24 export data files,
-// so they will work before and after the Go update. (See discussion
-// at https://go.dev/issue/15651.)
-//
-// The operations to import and export [go/types] data structures
-// would be defined in the go/types package as Import and Export.
-// [Write] would (eventually) delegate to Export,
-// and [Read], when it detects a file produced by Export,
-// would delegate to Import.
-//
-// # Deprecations
-//
-// The [NewImporter] and [Find] functions are deprecated and should
-// not be used in new code. The [WriteBundle] and [ReadBundle]
-// functions are experimental, and there is an open proposal to
-// deprecate them (https://go.dev/issue/69573).
-package gcexportdata
-
-import (
-	"bufio"
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"go/token"
-	"go/types"
-	"io"
-	"os/exec"
-
-	"golang.org/x/tools/internal/gcimporter"
-)
-
-// Find returns the name of an object (.o) or archive (.a) file
-// containing type information for the specified import path,
-// using the go command.
-// If no file was found, an empty filename is returned.
-//
-// A relative srcDir is interpreted relative to the current working directory.
-//
-// Find also returns the package's resolved (canonical) import path,
-// reflecting the effects of srcDir and vendoring on importPath.
-//
-// Deprecated: Use the higher-level API in golang.org/x/tools/go/packages,
-// which is more efficient.
-func Find(importPath, srcDir string) (filename, path string) {
-	cmd := exec.Command("go", "list", "-json", "-export", "--", importPath)
-	cmd.Dir = srcDir
-	out, err := cmd.Output()
-	if err != nil {
-		return "", ""
-	}
-	var data struct {
-		ImportPath string
-		Export     string
-	}
-	json.Unmarshal(out, &data)
-	return data.Export, data.ImportPath
-}
-
-// NewReader returns a reader for the export data section of an object
-// (.o) or archive (.a) file read from r.  The new reader may provide
-// additional trailing data beyond the end of the export data.
-func NewReader(r io.Reader) (io.Reader, error) {
-	buf := bufio.NewReader(r)
-	size, err := gcimporter.FindExportData(buf)
-	if err != nil {
-		return nil, err
-	}
-
-	// We were given an archive and found the __.PKGDEF in it.
-	// This tells us the size of the export data, and we don't
-	// need to return the entire file.
-	return &io.LimitedReader{
-		R: buf,
-		N: size,
-	}, nil
-}
-
-// readAll works the same way as io.ReadAll, but avoids allocations and copies
-// by preallocating a byte slice of the necessary size if the size is known up
-// front. This is always possible when the input is an archive. In that case,
-// NewReader will return the known size using an io.LimitedReader.
-func readAll(r io.Reader) ([]byte, error) {
-	if lr, ok := r.(*io.LimitedReader); ok {
-		data := make([]byte, lr.N)
-		_, err := io.ReadFull(lr, data)
-		return data, err
-	}
-	return io.ReadAll(r)
-}
-
-// Read reads export data from in, decodes it, and returns type
-// information for the package.
-//
-// Read is capable of reading export data produced by [Write] at the
-// same source code version, or by the last two Go releases (plus tip)
-// of the standard Go compiler. Reading files from older compilers may
-// produce an error.
-//
-// The package path (effectively its linker symbol prefix) is
-// specified by path, since unlike the package name, this information
-// may not be recorded in the export data.
-//
-// File position information is added to fset.
-//
-// Read may inspect and add to the imports map to ensure that references
-// within the export data to other packages are consistent.  The caller
-// must ensure that imports[path] does not exist, or exists but is
-// incomplete (see types.Package.Complete), and Read inserts the
-// resulting package into this map entry.
-//
-// On return, the state of the reader is undefined.
-func Read(in io.Reader, fset *token.FileSet, imports map[string]*types.Package, path string) (*types.Package, error) {
-	data, err := readAll(in)
-	if err != nil {
-		return nil, fmt.Errorf("reading export data for %q: %v", path, err)
-	}
-
-	if bytes.HasPrefix(data, []byte("!<arch>")) {
-		return nil, fmt.Errorf("can't read export data for %q directly from an archive file (call gcexportdata.NewReader first to extract export data)", path)
-	}
-
-	// The indexed export format starts with an 'i'; the older
-	// binary export format starts with a 'c', 'd', or 'v'
-	// (from "version"). Select appropriate importer.
-	if len(data) > 0 {
-		switch data[0] {
-		case 'v', 'c', 'd':
-			// binary, produced by cmd/compile till go1.10
-			return nil, fmt.Errorf("binary (%c) import format is no longer supported", data[0])
-
-		case 'i':
-			// indexed, produced by cmd/compile till go1.19,
-			// and also by [Write].
-			//
-			// If proposal #69491 is accepted, go/types
-			// serialization will be implemented by
-			// types.Export, to which Write would eventually
-			// delegate (explicitly dropping any pretence at
-			// inter-version Write-Read compatibility).
-			// This [Read] function would delegate to types.Import
-			// when it detects that the file was produced by Export.
-			_, pkg, err := gcimporter.IImportData(fset, imports, data[1:], path)
-			return pkg, err
-
-		case 'u':
-			// unified, produced by cmd/compile since go1.20
-			_, pkg, err := gcimporter.UImportData(fset, imports, data[1:], path)
-			return pkg, err
-
-		default:
-			l := min(len(data), 10)
-			return nil, fmt.Errorf("unexpected export data with prefix %q for path %s", string(data[:l]), path)
-		}
-	}
-	return nil, fmt.Errorf("empty export data for %s", path)
-}
-
-// Write writes encoded type information for the specified package to out.
-// The FileSet provides file position information for named objects.
-func Write(out io.Writer, fset *token.FileSet, pkg *types.Package) error {
-	if _, err := io.WriteString(out, "i"); err != nil {
-		return err
-	}
-	return gcimporter.IExportData(out, fset, pkg)
-}
-
-// ReadBundle reads an export bundle from in, decodes it, and returns type
-// information for the packages.
-// File position information is added to fset.
-//
-// ReadBundle may inspect and add to the imports map to ensure that references
-// within the export bundle to other packages are consistent.
-//
-// On return, the state of the reader is undefined.
-//
-// Experimental: This API is experimental and may change in the future.
-func ReadBundle(in io.Reader, fset *token.FileSet, imports map[string]*types.Package) ([]*types.Package, error) {
-	data, err := readAll(in)
-	if err != nil {
-		return nil, fmt.Errorf("reading export bundle: %v", err)
-	}
-	return gcimporter.IImportBundle(fset, imports, data)
-}
-
-// WriteBundle writes encoded type information for the specified packages to out.
-// The FileSet provides file position information for named objects.
-//
-// Experimental: This API is experimental and may change in the future.
-func WriteBundle(out io.Writer, fset *token.FileSet, pkgs []*types.Package) error {
-	return gcimporter.IExportBundle(out, fset, pkgs)
-}
diff --git a/vendor/golang.org/x/tools/go/gcexportdata/importer.go b/vendor/golang.org/x/tools/go/gcexportdata/importer.go
deleted file mode 100644
index 37a7247e26..0000000000
--- a/vendor/golang.org/x/tools/go/gcexportdata/importer.go
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gcexportdata
-
-import (
-	"fmt"
-	"go/token"
-	"go/types"
-	"os"
-)
-
-// NewImporter returns a new instance of the types.Importer interface
-// that reads type information from export data files written by gc.
-// The Importer also satisfies types.ImporterFrom.
-//
-// Export data files are located using "go build" workspace conventions
-// and the build.Default context.
-//
-// Use this importer instead of go/importer.For("gc", ...) to avoid the
-// version-skew problems described in the documentation of this package,
-// or to control the FileSet or access the imports map populated during
-// package loading.
-//
-// Deprecated: Use the higher-level API in golang.org/x/tools/go/packages,
-// which is more efficient.
-func NewImporter(fset *token.FileSet, imports map[string]*types.Package) types.ImporterFrom {
-	return importer{fset, imports}
-}
-
-type importer struct {
-	fset    *token.FileSet
-	imports map[string]*types.Package
-}
-
-func (imp importer) Import(importPath string) (*types.Package, error) {
-	return imp.ImportFrom(importPath, "", 0)
-}
-
-func (imp importer) ImportFrom(importPath, srcDir string, mode types.ImportMode) (_ *types.Package, err error) {
-	filename, path := Find(importPath, srcDir)
-	if filename == "" {
-		if importPath == "unsafe" {
-			// Even for unsafe, call Find first in case
-			// the package was vendored.
-			return types.Unsafe, nil
-		}
-		return nil, fmt.Errorf("can't find import: %s", importPath)
-	}
-
-	if pkg, ok := imp.imports[path]; ok && pkg.Complete() {
-		return pkg, nil // cache hit
-	}
-
-	// open file
-	f, err := os.Open(filename)
-	if err != nil {
-		return nil, err
-	}
-	defer func() {
-		f.Close()
-		if err != nil {
-			// add file name to error
-			err = fmt.Errorf("reading export data: %s: %v", filename, err)
-		}
-	}()
-
-	r, err := NewReader(f)
-	if err != nil {
-		return nil, err
-	}
-
-	return Read(r, imp.fset, imp.imports, path)
-}
diff --git a/vendor/golang.org/x/tools/go/packages/doc.go b/vendor/golang.org/x/tools/go/packages/doc.go
deleted file mode 100644
index 366aab6b2c..0000000000
--- a/vendor/golang.org/x/tools/go/packages/doc.go
+++ /dev/null
@@ -1,253 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-/*
-Package packages loads Go packages for inspection and analysis.
-
-The [Load] function takes as input a list of patterns and returns a
-list of [Package] values describing individual packages matched by those
-patterns.
-A [Config] specifies configuration options, the most important of which is
-the [LoadMode], which controls the amount of detail in the loaded packages.
-
-Load passes most patterns directly to the underlying build tool.
-The default build tool is the go command.
-Its supported patterns are described at
-https://pkg.go.dev/cmd/go#hdr-Package_lists_and_patterns.
-Other build systems may be supported by providing a "driver";
-see [The driver protocol].
-
-All patterns with the prefix "query=", where query is a
-non-empty string of letters from [a-z], are reserved and may be
-interpreted as query operators.
-
-Two query operators are currently supported: "file" and "pattern".
-
-The query "file=path/to/file.go" matches the package or packages enclosing
-the Go source file path/to/file.go.  For example "file=~/go/src/fmt/print.go"
-might return the packages "fmt" and "fmt [fmt.test]".
-
-The query "pattern=string" causes "string" to be passed directly to
-the underlying build tool. In most cases this is unnecessary,
-but an application can use Load("pattern=" + x) as an escaping mechanism
-to ensure that x is not interpreted as a query operator if it contains '='.
-
-All other query operators are reserved for future use and currently
-cause Load to report an error.
-
-The Package struct provides basic information about the package, including
-
-  - ID, a unique identifier for the package in the returned set;
-  - GoFiles, the names of the package's Go source files;
-  - Imports, a map from source import strings to the Packages they name;
-  - Types, the type information for the package's exported symbols;
-  - Syntax, the parsed syntax trees for the package's source code; and
-  - TypesInfo, the result of a complete type-check of the package syntax trees.
-
-(See the documentation for type Package for the complete list of fields
-and more detailed descriptions.)
-
-For example,
-
-	Load(nil, "bytes", "unicode...")
-
-returns four Package structs describing the standard library packages
-bytes, unicode, unicode/utf16, and unicode/utf8. Note that one pattern
-can match multiple packages and that a package might be matched by
-multiple patterns: in general it is not possible to determine which
-packages correspond to which patterns.
-
-Note that the list returned by Load contains only the packages matched
-by the patterns. Their dependencies can be found by walking the import
-graph using the Imports fields.
-
-The Load function can be configured by passing a pointer to a Config as
-the first argument. A nil Config is equivalent to the zero Config, which
-causes Load to run in [LoadFiles] mode, collecting minimal information.
-See the documentation for type Config for details.
-
-As noted earlier, the Config.Mode controls the amount of detail
-reported about the loaded packages. See the documentation for type LoadMode
-for details.
-
-Most tools should pass their command-line arguments (after any flags)
-uninterpreted to Load, so that it can interpret them
-according to the conventions of the underlying build system.
-
-See the Example function for typical usage.
-See also [golang.org/x/tools/go/packages/internal/linecount]
-for an example application.
-
-# The driver protocol
-
-Load may be used to load Go packages even in Go projects that use
-alternative build systems, by installing an appropriate "driver"
-program for the build system and specifying its location in the
-GOPACKAGESDRIVER environment variable.
-For example,
-https://github.com/bazelbuild/rules_go/wiki/Editor-and-tool-integration
-explains how to use the driver for Bazel.
-
-The driver program is responsible for interpreting patterns in its
-preferred notation and reporting information about the packages that
-those patterns identify. Drivers must also support the special "file="
-and "pattern=" patterns described above.
-
-The patterns are provided as positional command-line arguments. A
-JSON-encoded [DriverRequest] message providing additional information
-is written to the driver's standard input. The driver must write a
-JSON-encoded [DriverResponse] message to its standard output. (This
-message differs from the JSON schema produced by 'go list'.)
-
-The value of the PWD environment variable seen by the driver process
-is the preferred name of its working directory. (The working directory
-may have other aliases due to symbolic links; see the comment on the
-Dir field of [exec.Cmd] for related information.)
-When the driver process emits in its response the name of a file
-that is a descendant of this directory, it must use an absolute path
-that has the value of PWD as a prefix, to ensure that the returned
-filenames satisfy the original query.
-*/
-package packages // import "golang.org/x/tools/go/packages"
-
-/*
-
-Motivation and design considerations
-
-The new package's design solves problems addressed by two existing
-packages: go/build, which locates and describes packages, and
-golang.org/x/tools/go/loader, which loads, parses and type-checks them.
-The go/build.Package structure encodes too much of the 'go build' way
-of organizing projects, leaving us in need of a data type that describes a
-package of Go source code independent of the underlying build system.
-We wanted something that works equally well with go build and vgo, and
-also other build systems such as Bazel and Blaze, making it possible to
-construct analysis tools that work in all these environments.
-Tools such as errcheck and staticcheck were essentially unavailable to
-the Go community at Google, and some of Google's internal tools for Go
-are unavailable externally.
-This new package provides a uniform way to obtain package metadata by
-querying each of these build systems, optionally supporting their
-preferred command-line notations for packages, so that tools integrate
-neatly with users' build environments. The Metadata query function
-executes an external query tool appropriate to the current workspace.
-
-Loading packages always returns the complete import graph "all the way down",
-even if all you want is information about a single package, because the query
-mechanisms of all the build systems we currently support ({go,vgo} list, and
-blaze/bazel aspect-based query) cannot provide detailed information
-about one package without visiting all its dependencies too, so there is
-no additional asymptotic cost to providing transitive information.
-(This property might not be true of a hypothetical 5th build system.)
-
-In calls to TypeCheck, all initial packages, and any package that
-transitively depends on one of them, must be loaded from source.
-Consider A->B->C->D->E: if A,C are initial, A,B,C must be loaded from
-source; D may be loaded from export data, and E may not be loaded at all
-(though it's possible that D's export data mentions it, so a
-types.Package may be created for it and exposed.)
-
-The old loader had a feature to suppress type-checking of function
-bodies on a per-package basis, primarily intended to reduce the work of
-obtaining type information for imported packages. Now that imports are
-satisfied by export data, the optimization no longer seems necessary.
-
-Despite some early attempts, the old loader did not exploit export data,
-instead always using the equivalent of WholeProgram mode. This was due
-to the complexity of mixing source and export data packages (now
-resolved by the upward traversal mentioned above), and because export data
-files were nearly always missing or stale. Now that 'go build' supports
-caching, all the underlying build systems can guarantee to produce
-export data in a reasonable (amortized) time.
-
-Test "main" packages synthesized by the build system are now reported as
-first-class packages, avoiding the need for clients (such as go/ssa) to
-reinvent this generation logic.
-
-One way in which go/packages is simpler than the old loader is in its
-treatment of in-package tests. In-package tests are packages that
-consist of all the files of the library under test, plus the test files.
-The old loader constructed in-package tests by a two-phase process of
-mutation called "augmentation": first it would construct and type check
-all the ordinary library packages and type-check the packages that
-depend on them; then it would add more (test) files to the package and
-type-check again. This two-phase approach had four major problems:
-1) in processing the tests, the loader modified the library package,
-   leaving no way for a client application to see both the test
-   package and the library package; one would mutate into the other.
-2) because test files can declare additional methods on types defined in
-   the library portion of the package, the dispatch of method calls in
-   the library portion was affected by the presence of the test files.
-   This should have been a clue that the packages were logically
-   different.
-3) this model of "augmentation" assumed at most one in-package test
-   per library package, which is true of projects using 'go build',
-   but not other build systems.
-4) because of the two-phase nature of test processing, all packages that
-   import the library package had to be processed before augmentation,
-   forcing a "one-shot" API and preventing the client from calling Load
-   in several times in sequence as is now possible in WholeProgram mode.
-   (TypeCheck mode has a similar one-shot restriction for a different reason.)
-
-Early drafts of this package supported "multi-shot" operation.
-Although it allowed clients to make a sequence of calls (or concurrent
-calls) to Load, building up the graph of Packages incrementally,
-it was of marginal value: it complicated the API
-(since it allowed some options to vary across calls but not others),
-it complicated the implementation,
-it cannot be made to work in Types mode, as explained above,
-and it was less efficient than making one combined call (when this is possible).
-Among the clients we have inspected, none made multiple calls to load
-but could not be easily and satisfactorily modified to make only a single call.
-However, applications changes may be required.
-For example, the ssadump command loads the user-specified packages
-and in addition the runtime package.  It is tempting to simply append
-"runtime" to the user-provided list, but that does not work if the user
-specified an ad-hoc package such as [a.go b.go].
-Instead, ssadump no longer requests the runtime package,
-but seeks it among the dependencies of the user-specified packages,
-and emits an error if it is not found.
-
-Questions & Tasks
-
-- Add GOARCH/GOOS?
-  They are not portable concepts, but could be made portable.
-  Our goal has been to allow users to express themselves using the conventions
-  of the underlying build system: if the build system honors GOARCH
-  during a build and during a metadata query, then so should
-  applications built atop that query mechanism.
-  Conversely, if the target architecture of the build is determined by
-  command-line flags, the application can pass the relevant
-  flags through to the build system using a command such as:
-    myapp -query_flag="--cpu=amd64" -query_flag="--os=darwin"
-  However, this approach is low-level, unwieldy, and non-portable.
-  GOOS and GOARCH seem important enough to warrant a dedicated option.
-
-- How should we handle partial failures such as a mixture of good and
-  malformed patterns, existing and non-existent packages, successful and
-  failed builds, import failures, import cycles, and so on, in a call to
-  Load?
-
-- Support bazel, blaze, and go1.10 list, not just go1.11 list.
-
-- Handle (and test) various partial success cases, e.g.
-  a mixture of good packages and:
-  invalid patterns
-  nonexistent packages
-  empty packages
-  packages with malformed package or import declarations
-  unreadable files
-  import cycles
-  other parse errors
-  type errors
-  Make sure we record errors at the correct place in the graph.
-
-- Missing packages among initial arguments are not reported.
-  Return bogus packages for them, like golist does.
-
-- "undeclared name" errors (for example) are reported out of source file
-  order. I suspect this is due to the breadth-first resolution now used
-  by go/types. Is that a bug? Discuss with gri.
-
-*/
diff --git a/vendor/golang.org/x/tools/go/packages/external.go b/vendor/golang.org/x/tools/go/packages/external.go
deleted file mode 100644
index f37bc65100..0000000000
--- a/vendor/golang.org/x/tools/go/packages/external.go
+++ /dev/null
@@ -1,153 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package packages
-
-// This file defines the protocol that enables an external "driver"
-// tool to supply package metadata in place of 'go list'.
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"os"
-	"os/exec"
-	"slices"
-	"strings"
-)
-
-// DriverRequest defines the schema of a request for package metadata
-// from an external driver program. The JSON-encoded DriverRequest
-// message is provided to the driver program's standard input. The
-// query patterns are provided as command-line arguments.
-//
-// See the package documentation for an overview.
-type DriverRequest struct {
-	Mode LoadMode `json:"mode"`
-
-	// Env specifies the environment the underlying build system should be run in.
-	Env []string `json:"env"`
-
-	// BuildFlags are flags that should be passed to the underlying build system.
-	BuildFlags []string `json:"build_flags"`
-
-	// Tests specifies whether the patterns should also return test packages.
-	Tests bool `json:"tests"`
-
-	// Overlay maps file paths (relative to the driver's working directory)
-	// to the contents of overlay files (see Config.Overlay).
-	Overlay map[string][]byte `json:"overlay"`
-}
-
-// DriverResponse defines the schema of a response from an external
-// driver program, providing the results of a query for package
-// metadata. The driver program must write a JSON-encoded
-// DriverResponse message to its standard output.
-//
-// See the package documentation for an overview.
-type DriverResponse struct {
-	// NotHandled is returned if the request can't be handled by the current
-	// driver. If an external driver returns a response with NotHandled, the
-	// rest of the DriverResponse is ignored, and go/packages will fallback
-	// to the next driver. If go/packages is extended in the future to support
-	// lists of multiple drivers, go/packages will fall back to the next driver.
-	NotHandled bool
-
-	// Compiler and Arch are the arguments pass of types.SizesFor
-	// to get a types.Sizes to use when type checking.
-	Compiler string
-	Arch     string
-
-	// Roots is the set of package IDs that make up the root packages.
-	// We have to encode this separately because when we encode a single package
-	// we cannot know if it is one of the roots as that requires knowledge of the
-	// graph it is part of.
-	Roots []string `json:",omitempty"`
-
-	// Packages is the full set of packages in the graph.
-	// The packages are not connected into a graph.
-	// The Imports if populated will be stubs that only have their ID set.
-	// Imports will be connected and then type and syntax information added in a
-	// later pass (see refine).
-	Packages []*Package
-
-	// GoVersion is the minor version number used by the driver
-	// (e.g. the go command on the PATH) when selecting .go files.
-	// Zero means unknown.
-	GoVersion int
-}
-
-// driver is the type for functions that query the build system for the
-// packages named by the patterns.
-type driver func(cfg *Config, patterns []string) (*DriverResponse, error)
-
-// findExternalDriver returns the file path of a tool that supplies
-// the build system package structure, or "" if not found.
-// If GOPACKAGESDRIVER is set in the environment findExternalTool returns its
-// value, otherwise it searches for a binary named gopackagesdriver on the PATH.
-func findExternalDriver(cfg *Config) driver {
-	const toolPrefix = "GOPACKAGESDRIVER="
-	tool := ""
-	for _, env := range cfg.Env {
-		if val, ok := strings.CutPrefix(env, toolPrefix); ok {
-			tool = val
-		}
-	}
-	if tool != "" && tool == "off" {
-		return nil
-	}
-	if tool == "" {
-		var err error
-		tool, err = exec.LookPath("gopackagesdriver")
-		if err != nil {
-			return nil
-		}
-	}
-	return func(cfg *Config, patterns []string) (*DriverResponse, error) {
-		req, err := json.Marshal(DriverRequest{
-			Mode:       cfg.Mode,
-			Env:        cfg.Env,
-			BuildFlags: cfg.BuildFlags,
-			Tests:      cfg.Tests,
-			Overlay:    cfg.Overlay,
-		})
-		if err != nil {
-			return nil, fmt.Errorf("failed to encode message to driver tool: %v", err)
-		}
-
-		buf := new(bytes.Buffer)
-		stderr := new(bytes.Buffer)
-		cmd := exec.CommandContext(cfg.Context, tool, patterns...)
-		cmd.Dir = cfg.Dir
-		// The cwd gets resolved to the real path. On Darwin, where
-		// /tmp is a symlink, this breaks anything that expects the
-		// working directory to keep the original path, including the
-		// go command when dealing with modules.
-		//
-		// os.Getwd stdlib has a special feature where if the
-		// cwd and the PWD are the same node then it trusts
-		// the PWD, so by setting it in the env for the child
-		// process we fix up all the paths returned by the go
-		// command.
-		//
-		// (See similar trick in Invocation.run in ../../internal/gocommand/invoke.go)
-		cmd.Env = append(slices.Clip(cfg.Env), "PWD="+cfg.Dir)
-		cmd.Stdin = bytes.NewReader(req)
-		cmd.Stdout = buf
-		cmd.Stderr = stderr
-
-		if err := cmd.Run(); err != nil {
-			return nil, fmt.Errorf("%v: %v: %s", tool, err, cmd.Stderr)
-		}
-		if len(stderr.Bytes()) != 0 && os.Getenv("GOPACKAGESPRINTDRIVERERRORS") != "" {
-			fmt.Fprintf(os.Stderr, "%s stderr: <<%s>>\n", cmdDebugStr(cmd), stderr)
-		}
-
-		var response DriverResponse
-		if err := json.Unmarshal(buf.Bytes(), &response); err != nil {
-			return nil, err
-		}
-		return &response, nil
-	}
-}
diff --git a/vendor/golang.org/x/tools/go/packages/golist.go b/vendor/golang.org/x/tools/go/packages/golist.go
deleted file mode 100644
index 8e60cbbed7..0000000000
--- a/vendor/golang.org/x/tools/go/packages/golist.go
+++ /dev/null
@@ -1,1126 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package packages
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"log"
-	"os"
-	"os/exec"
-	"path"
-	"path/filepath"
-	"reflect"
-	"sort"
-	"strconv"
-	"strings"
-	"sync"
-	"unicode"
-
-	"golang.org/x/tools/internal/gocommand"
-	"golang.org/x/tools/internal/packagesinternal"
-)
-
-// debug controls verbose logging.
-var debug, _ = strconv.ParseBool(os.Getenv("GOPACKAGESDEBUG"))
-
-// A goTooOldError reports that the go command
-// found by exec.LookPath is too old to use the new go list behavior.
-type goTooOldError struct {
-	error
-}
-
-// responseDeduper wraps a DriverResponse, deduplicating its contents.
-type responseDeduper struct {
-	seenRoots    map[string]bool
-	seenPackages map[string]*Package
-	dr           *DriverResponse
-}
-
-func newDeduper() *responseDeduper {
-	return &responseDeduper{
-		dr:           &DriverResponse{},
-		seenRoots:    map[string]bool{},
-		seenPackages: map[string]*Package{},
-	}
-}
-
-// addAll fills in r with a DriverResponse.
-func (r *responseDeduper) addAll(dr *DriverResponse) {
-	for _, pkg := range dr.Packages {
-		r.addPackage(pkg)
-	}
-	for _, root := range dr.Roots {
-		r.addRoot(root)
-	}
-	r.dr.GoVersion = dr.GoVersion
-}
-
-func (r *responseDeduper) addPackage(p *Package) {
-	if prev := r.seenPackages[p.ID]; prev != nil {
-		// Package already seen in a previous response. Merge the file lists,
-		// removing duplicates. This can happen when the same package appears
-		// in multiple driver responses that are being merged together.
-		prev.GoFiles = appendUniqueStrings(prev.GoFiles, p.GoFiles)
-		prev.CompiledGoFiles = appendUniqueStrings(prev.CompiledGoFiles, p.CompiledGoFiles)
-		prev.OtherFiles = appendUniqueStrings(prev.OtherFiles, p.OtherFiles)
-		prev.IgnoredFiles = appendUniqueStrings(prev.IgnoredFiles, p.IgnoredFiles)
-		prev.EmbedFiles = appendUniqueStrings(prev.EmbedFiles, p.EmbedFiles)
-		prev.EmbedPatterns = appendUniqueStrings(prev.EmbedPatterns, p.EmbedPatterns)
-		return
-	}
-	r.seenPackages[p.ID] = p
-	r.dr.Packages = append(r.dr.Packages, p)
-}
-
-// appendUniqueStrings appends elements from src to dst, skipping duplicates.
-func appendUniqueStrings(dst, src []string) []string {
-	if len(src) == 0 {
-		return dst
-	}
-
-	seen := make(map[string]bool, len(dst))
-	for _, s := range dst {
-		seen[s] = true
-	}
-
-	for _, s := range src {
-		if !seen[s] {
-			dst = append(dst, s)
-		}
-	}
-
-	return dst
-}
-
-func (r *responseDeduper) addRoot(id string) {
-	if r.seenRoots[id] {
-		return
-	}
-	r.seenRoots[id] = true
-	r.dr.Roots = append(r.dr.Roots, id)
-}
-
-type golistState struct {
-	cfg *Config
-	ctx context.Context
-
-	runner *gocommand.Runner
-
-	// overlay is the JSON file that encodes the Config.Overlay
-	// mapping, used by 'go list -overlay=...'.
-	overlay string
-
-	envOnce    sync.Once
-	goEnvError error
-	goEnv      map[string]string
-
-	rootsOnce     sync.Once
-	rootDirsError error
-	rootDirs      map[string]string
-
-	goVersionOnce  sync.Once
-	goVersionError error
-	goVersion      int // The X in Go 1.X.
-
-	// vendorDirs caches the (non)existence of vendor directories.
-	vendorDirs map[string]bool
-}
-
-// getEnv returns Go environment variables. Only specific variables are
-// populated -- computing all of them is slow.
-func (state *golistState) getEnv() (map[string]string, error) {
-	state.envOnce.Do(func() {
-		var b *bytes.Buffer
-		b, state.goEnvError = state.invokeGo("env", "-json", "GOMOD", "GOPATH")
-		if state.goEnvError != nil {
-			return
-		}
-
-		state.goEnv = make(map[string]string)
-		decoder := json.NewDecoder(b)
-		if state.goEnvError = decoder.Decode(&state.goEnv); state.goEnvError != nil {
-			return
-		}
-	})
-	return state.goEnv, state.goEnvError
-}
-
-// mustGetEnv is a convenience function that can be used if getEnv has already succeeded.
-func (state *golistState) mustGetEnv() map[string]string {
-	env, err := state.getEnv()
-	if err != nil {
-		panic(fmt.Sprintf("mustGetEnv: %v", err))
-	}
-	return env
-}
-
-// goListDriver uses the go list command to interpret the patterns and produce
-// the build system package structure.
-// See driver for more details.
-//
-// overlay is the JSON file that encodes the cfg.Overlay
-// mapping, used by 'go list -overlay=...'
-func goListDriver(cfg *Config, runner *gocommand.Runner, overlay string, patterns []string) (_ *DriverResponse, err error) {
-	// Make sure that any asynchronous go commands are killed when we return.
-	parentCtx := cfg.Context
-	if parentCtx == nil {
-		parentCtx = context.Background()
-	}
-	ctx, cancel := context.WithCancel(parentCtx)
-	defer cancel()
-
-	response := newDeduper()
-
-	state := &golistState{
-		cfg:        cfg,
-		ctx:        ctx,
-		vendorDirs: map[string]bool{},
-		overlay:    overlay,
-		runner:     runner,
-	}
-
-	// Fill in response.Sizes asynchronously if necessary.
-	if cfg.Mode&NeedTypesSizes != 0 || cfg.Mode&(NeedTypes|NeedTypesInfo) != 0 {
-		errCh := make(chan error)
-		go func() {
-			compiler, arch, err := getSizesForArgs(ctx, state.cfgInvocation(), runner)
-			response.dr.Compiler = compiler
-			response.dr.Arch = arch
-			errCh <- err
-		}()
-		defer func() {
-			if sizesErr := <-errCh; sizesErr != nil {
-				err = sizesErr
-			}
-		}()
-	}
-
-	// Determine files requested in contains patterns
-	var containFiles []string
-	restPatterns := make([]string, 0, len(patterns))
-	// Extract file= and other [querytype]= patterns. Report an error if querytype
-	// doesn't exist.
-extractQueries:
-	for _, pattern := range patterns {
-		query, value, ok := strings.Cut(pattern, "=")
-		if !ok {
-			restPatterns = append(restPatterns, pattern)
-		} else {
-			switch query {
-			case "file":
-				containFiles = append(containFiles, value)
-			case "pattern":
-				restPatterns = append(restPatterns, value)
-			case "": // not a reserved query
-				restPatterns = append(restPatterns, pattern)
-			default:
-				for _, rune := range query {
-					if rune < 'a' || rune > 'z' { // not a reserved query
-						restPatterns = append(restPatterns, pattern)
-						continue extractQueries
-					}
-				}
-				// Reject all other patterns containing "="
-				return nil, fmt.Errorf("invalid query type %q in query pattern %q", query, pattern)
-			}
-		}
-	}
-
-	// See if we have any patterns to pass through to go list. Zero initial
-	// patterns also requires a go list call, since it's the equivalent of
-	// ".".
-	if len(restPatterns) > 0 || len(patterns) == 0 {
-		dr, err := state.createDriverResponse(restPatterns...)
-		if err != nil {
-			return nil, err
-		}
-		response.addAll(dr)
-	}
-
-	if len(containFiles) != 0 {
-		if err := state.runContainsQueries(response, containFiles); err != nil {
-			return nil, err
-		}
-	}
-
-	// (We may yet return an error due to defer.)
-	return response.dr, nil
-}
-
-// abs returns an absolute representation of path, based on cfg.Dir.
-func (cfg *Config) abs(path string) (string, error) {
-	if filepath.IsAbs(path) {
-		return path, nil
-	}
-	// In case cfg.Dir is relative, pass it to filepath.Abs.
-	return filepath.Abs(filepath.Join(cfg.Dir, path))
-}
-
-func (state *golistState) runContainsQueries(response *responseDeduper, queries []string) error {
-	for _, query := range queries {
-		// TODO(matloob): Do only one query per directory.
-		fdir := filepath.Dir(query)
-		// Pass absolute path of directory to go list so that it knows to treat it as a directory,
-		// not a package path.
-		pattern, err := state.cfg.abs(fdir)
-		if err != nil {
-			return fmt.Errorf("could not determine absolute path of file= query path %q: %v", query, err)
-		}
-		dirResponse, err := state.createDriverResponse(pattern)
-
-		// If there was an error loading the package, or no packages are returned,
-		// or the package is returned with errors, try to load the file as an
-		// ad-hoc package.
-		// Usually the error will appear in a returned package, but may not if we're
-		// in module mode and the ad-hoc is located outside a module.
-		if err != nil || len(dirResponse.Packages) == 0 || len(dirResponse.Packages) == 1 && len(dirResponse.Packages[0].GoFiles) == 0 &&
-			len(dirResponse.Packages[0].Errors) == 1 {
-			var queryErr error
-			if dirResponse, queryErr = state.adhocPackage(pattern, query); queryErr != nil {
-				return err // return the original error
-			}
-		}
-		isRoot := make(map[string]bool, len(dirResponse.Roots))
-		for _, root := range dirResponse.Roots {
-			isRoot[root] = true
-		}
-		for _, pkg := range dirResponse.Packages {
-			// Add any new packages to the main set
-			// We don't bother to filter packages that will be dropped by the changes of roots,
-			// that will happen anyway during graph construction outside this function.
-			// Over-reporting packages is not a problem.
-			response.addPackage(pkg)
-			// if the package was not a root one, it cannot have the file
-			if !isRoot[pkg.ID] {
-				continue
-			}
-			for _, pkgFile := range pkg.GoFiles {
-				if filepath.Base(query) == filepath.Base(pkgFile) {
-					response.addRoot(pkg.ID)
-					break
-				}
-			}
-		}
-	}
-	return nil
-}
-
-// adhocPackage attempts to load or construct an ad-hoc package for a given
-// query, if the original call to the driver produced inadequate results.
-func (state *golistState) adhocPackage(pattern, query string) (*DriverResponse, error) {
-	response, err := state.createDriverResponse(query)
-	if err != nil {
-		return nil, err
-	}
-	// If we get nothing back from `go list`,
-	// try to make this file into its own ad-hoc package.
-	// TODO(rstambler): Should this check against the original response?
-	if len(response.Packages) == 0 {
-		response.Packages = append(response.Packages, &Package{
-			ID:              "command-line-arguments",
-			PkgPath:         query,
-			GoFiles:         []string{query},
-			CompiledGoFiles: []string{query},
-			Imports:         make(map[string]*Package),
-		})
-		response.Roots = append(response.Roots, "command-line-arguments")
-	}
-	// Handle special cases.
-	if len(response.Packages) == 1 {
-		// golang/go#33482: If this is a file= query for ad-hoc packages where
-		// the file only exists on an overlay, and exists outside of a module,
-		// add the file to the package and remove the errors.
-		if response.Packages[0].ID == "command-line-arguments" ||
-			filepath.ToSlash(response.Packages[0].PkgPath) == filepath.ToSlash(query) {
-			if len(response.Packages[0].GoFiles) == 0 {
-				filename := filepath.Join(pattern, filepath.Base(query)) // avoid recomputing abspath
-				// TODO(matloob): check if the file is outside of a root dir?
-				for path := range state.cfg.Overlay {
-					if path == filename {
-						response.Packages[0].Errors = nil
-						response.Packages[0].GoFiles = []string{path}
-						response.Packages[0].CompiledGoFiles = []string{path}
-					}
-				}
-			}
-		}
-	}
-	return response, nil
-}
-
-// Fields must match go list;
-// see $GOROOT/src/cmd/go/internal/load/pkg.go.
-type jsonPackage struct {
-	ImportPath        string
-	Dir               string
-	Name              string
-	Target            string
-	Export            string
-	GoFiles           []string
-	CompiledGoFiles   []string
-	IgnoredGoFiles    []string
-	IgnoredOtherFiles []string
-	EmbedPatterns     []string
-	EmbedFiles        []string
-	CFiles            []string
-	CgoFiles          []string
-	CXXFiles          []string
-	MFiles            []string
-	HFiles            []string
-	FFiles            []string
-	SFiles            []string
-	SwigFiles         []string
-	SwigCXXFiles      []string
-	SysoFiles         []string
-	Imports           []string
-	ImportMap         map[string]string
-	Deps              []string
-	Module            *Module
-	TestGoFiles       []string
-	TestImports       []string
-	XTestGoFiles      []string
-	XTestImports      []string
-	ForTest           string // q in a "p [q.test]" package, else ""
-	DepOnly           bool
-
-	Error      *packagesinternal.PackageError
-	DepsErrors []*packagesinternal.PackageError
-}
-
-func otherFiles(p *jsonPackage) [][]string {
-	return [][]string{p.CFiles, p.CXXFiles, p.MFiles, p.HFiles, p.FFiles, p.SFiles, p.SwigFiles, p.SwigCXXFiles, p.SysoFiles}
-}
-
-// createDriverResponse uses the "go list" command to expand the pattern
-// words and return a response for the specified packages.
-func (state *golistState) createDriverResponse(words ...string) (*DriverResponse, error) {
-	// go list uses the following identifiers in ImportPath and Imports:
-	//
-	// 	"p"			-- importable package or main (command)
-	// 	"q.test"		-- q's test executable
-	// 	"p [q.test]"		-- variant of p as built for q's test executable
-	// 	"q_test [q.test]"	-- q's external test package
-	//
-	// The packages p that are built differently for a test q.test
-	// are q itself, plus any helpers used by the external test q_test,
-	// typically including "testing" and all its dependencies.
-
-	// Run "go list" for complete
-	// information on the specified packages.
-	goVersion, err := state.getGoVersion()
-	if err != nil {
-		return nil, err
-	}
-	buf, err := state.invokeGo("list", golistargs(state.cfg, words, goVersion)...)
-	if err != nil {
-		return nil, err
-	}
-
-	seen := make(map[string]*jsonPackage)
-	pkgs := make(map[string]*Package)
-	additionalErrors := make(map[string][]Error)
-	// Decode the JSON and convert it to Package form.
-	response := &DriverResponse{
-		GoVersion: goVersion,
-	}
-	for dec := json.NewDecoder(buf); dec.More(); {
-		p := new(jsonPackage)
-		if err := dec.Decode(p); err != nil {
-			return nil, fmt.Errorf("JSON decoding failed: %v", err)
-		}
-
-		if p.ImportPath == "" {
-			// The documentation for go list says that “[e]rroneous packages will have
-			// a non-empty ImportPath”. If for some reason it comes back empty, we
-			// prefer to error out rather than silently discarding data or handing
-			// back a package without any way to refer to it.
-			if p.Error != nil {
-				return nil, Error{
-					Pos: p.Error.Pos,
-					Msg: p.Error.Err,
-				}
-			}
-			return nil, fmt.Errorf("package missing import path: %+v", p)
-		}
-
-		// Work around https://golang.org/issue/33157:
-		// go list -e, when given an absolute path, will find the package contained at
-		// that directory. But when no package exists there, it will return a fake package
-		// with an error and the ImportPath set to the absolute path provided to go list.
-		// Try to convert that absolute path to what its package path would be if it's
-		// contained in a known module or GOPATH entry. This will allow the package to be
-		// properly "reclaimed" when overlays are processed.
-		if filepath.IsAbs(p.ImportPath) && p.Error != nil {
-			pkgPath, ok, err := state.getPkgPath(p.ImportPath)
-			if err != nil {
-				return nil, err
-			}
-			if ok {
-				p.ImportPath = pkgPath
-			}
-		}
-
-		if old, found := seen[p.ImportPath]; found {
-			// If one version of the package has an error, and the other doesn't, assume
-			// that this is a case where go list is reporting a fake dependency variant
-			// of the imported package: When a package tries to invalidly import another
-			// package, go list emits a variant of the imported package (with the same
-			// import path, but with an error on it, and the package will have a
-			// DepError set on it). An example of when this can happen is for imports of
-			// main packages: main packages can not be imported, but they may be
-			// separately matched and listed by another pattern.
-			// See golang.org/issue/36188 for more details.
-
-			// The plan is that eventually, hopefully in Go 1.15, the error will be
-			// reported on the importing package rather than the duplicate "fake"
-			// version of the imported package. Once all supported versions of Go
-			// have the new behavior this logic can be deleted.
-			// TODO(matloob): delete the workaround logic once all supported versions of
-			// Go return the errors on the proper package.
-
-			// There should be exactly one version of a package that doesn't have an
-			// error.
-			if old.Error == nil && p.Error == nil {
-				if !reflect.DeepEqual(p, old) {
-					return nil, fmt.Errorf("internal error: go list gives conflicting information for package %v", p.ImportPath)
-				}
-				continue
-			}
-
-			// Determine if this package's error needs to be bubbled up.
-			// This is a hack, and we expect for go list to eventually set the error
-			// on the package.
-			if old.Error != nil {
-				var errkind string
-				if strings.Contains(old.Error.Err, "not an importable package") {
-					errkind = "not an importable package"
-				} else if strings.Contains(old.Error.Err, "use of internal package") && strings.Contains(old.Error.Err, "not allowed") {
-					errkind = "use of internal package not allowed"
-				}
-				if errkind != "" {
-					if len(old.Error.ImportStack) < 1 {
-						return nil, fmt.Errorf(`internal error: go list gave a %q error with empty import stack`, errkind)
-					}
-					importingPkg := old.Error.ImportStack[len(old.Error.ImportStack)-1]
-					if importingPkg == old.ImportPath {
-						// Using an older version of Go which put this package itself on top of import
-						// stack, instead of the importer. Look for importer in second from top
-						// position.
-						if len(old.Error.ImportStack) < 2 {
-							return nil, fmt.Errorf(`internal error: go list gave a %q error with an import stack without importing package`, errkind)
-						}
-						importingPkg = old.Error.ImportStack[len(old.Error.ImportStack)-2]
-					}
-					additionalErrors[importingPkg] = append(additionalErrors[importingPkg], Error{
-						Pos:  old.Error.Pos,
-						Msg:  old.Error.Err,
-						Kind: ListError,
-					})
-				}
-			}
-
-			// Make sure that if there's a version of the package without an error,
-			// that's the one reported to the user.
-			if old.Error == nil {
-				continue
-			}
-
-			// This package will replace the old one at the end of the loop.
-		}
-		seen[p.ImportPath] = p
-
-		pkg := &Package{
-			Name:            p.Name,
-			ID:              p.ImportPath,
-			Dir:             p.Dir,
-			Target:          p.Target,
-			GoFiles:         absJoin(p.Dir, p.GoFiles, p.CgoFiles),
-			CompiledGoFiles: absJoin(p.Dir, p.CompiledGoFiles),
-			OtherFiles:      absJoin(p.Dir, otherFiles(p)...),
-			EmbedFiles:      absJoin(p.Dir, p.EmbedFiles),
-			EmbedPatterns:   absJoin(p.Dir, p.EmbedPatterns),
-			IgnoredFiles:    absJoin(p.Dir, p.IgnoredGoFiles, p.IgnoredOtherFiles),
-			ForTest:         p.ForTest,
-			depsErrors:      p.DepsErrors,
-			Module:          p.Module,
-		}
-
-		if (state.cfg.Mode&typecheckCgo) != 0 && len(p.CgoFiles) != 0 {
-			if len(p.CompiledGoFiles) > len(p.GoFiles) {
-				// We need the cgo definitions, which are in the first
-				// CompiledGoFile after the non-cgo ones. This is a hack but there
-				// isn't currently a better way to find it. We also need the pure
-				// Go files and unprocessed cgo files, all of which are already
-				// in pkg.GoFiles.
-				cgoTypes := p.CompiledGoFiles[len(p.GoFiles)]
-				pkg.CompiledGoFiles = append([]string{cgoTypes}, pkg.GoFiles...)
-			} else {
-				// golang/go#38990: go list silently fails to do cgo processing
-				pkg.CompiledGoFiles = nil
-
-				var msg strings.Builder
-				fmt.Fprintf(&msg, "go list failed to return CompiledGoFiles for %q.\n", p.Name)
-
-				for _, err := range p.DepsErrors {
-					msg.WriteString(strings.TrimSpace(err.Err))
-					msg.WriteByte('\n')
-				}
-
-				msg.WriteString("This may indicate failure to perform cgo processing; try building at the command line. See https://golang.org/issue/38990.")
-				pkg.Errors = append(pkg.Errors, Error{
-					Msg:  msg.String(),
-					Kind: ListError,
-				})
-			}
-		}
-
-		// Work around https://golang.org/issue/28749:
-		// cmd/go puts assembly, C, and C++ files in CompiledGoFiles.
-		// Remove files from CompiledGoFiles that are non-go files
-		// (or are not files that look like they are from the cache).
-		if len(pkg.CompiledGoFiles) > 0 {
-			out := pkg.CompiledGoFiles[:0]
-			for _, f := range pkg.CompiledGoFiles {
-				if ext := filepath.Ext(f); ext != ".go" && ext != "" { // ext == "" means the file is from the cache, so probably cgo-processed file
-					continue
-				}
-				out = append(out, f)
-			}
-			pkg.CompiledGoFiles = out
-		}
-
-		// Extract the PkgPath from the package's ID.
-		if i := strings.IndexByte(pkg.ID, ' '); i >= 0 {
-			pkg.PkgPath = pkg.ID[:i]
-		} else {
-			pkg.PkgPath = pkg.ID
-		}
-
-		if pkg.PkgPath == "unsafe" {
-			pkg.CompiledGoFiles = nil // ignore fake unsafe.go file (#59929)
-		} else if len(pkg.CompiledGoFiles) == 0 {
-			// Work around for pre-go.1.11 versions of go list.
-			// TODO(matloob): they should be handled by the fallback.
-			// Can we delete this?
-			pkg.CompiledGoFiles = pkg.GoFiles
-		}
-
-		// Assume go list emits only absolute paths for Dir.
-		if p.Dir != "" && !filepath.IsAbs(p.Dir) {
-			log.Fatalf("internal error: go list returned non-absolute Package.Dir: %s", p.Dir)
-		}
-
-		if p.Export != "" && !filepath.IsAbs(p.Export) {
-			pkg.ExportFile = filepath.Join(p.Dir, p.Export)
-		} else {
-			pkg.ExportFile = p.Export
-		}
-
-		// imports
-		//
-		// Imports contains the IDs of all imported packages.
-		// ImportsMap records (path, ID) only where they differ.
-		ids := make(map[string]bool)
-		for _, id := range p.Imports {
-			ids[id] = true
-		}
-		pkg.Imports = make(map[string]*Package)
-		for path, id := range p.ImportMap {
-			pkg.Imports[path] = &Package{ID: id} // non-identity import
-			delete(ids, id)
-		}
-		for id := range ids {
-			if id == "C" {
-				continue
-			}
-
-			pkg.Imports[id] = &Package{ID: id} // identity import
-		}
-		if !p.DepOnly {
-			response.Roots = append(response.Roots, pkg.ID)
-		}
-
-		// Temporary work-around for golang/go#39986. Parse filenames out of
-		// error messages. This happens if there are unrecoverable syntax
-		// errors in the source, so we can't match on a specific error message.
-		//
-		// TODO(rfindley): remove this heuristic, in favor of considering
-		// InvalidGoFiles from the list driver.
-		if err := p.Error; err != nil && state.shouldAddFilenameFromError(p) {
-			addFilenameFromPos := func(pos string) bool {
-				split := strings.Split(pos, ":")
-				if len(split) < 1 {
-					return false
-				}
-				filename := strings.TrimSpace(split[0])
-				if filename == "" {
-					return false
-				}
-				if !filepath.IsAbs(filename) {
-					filename = filepath.Join(state.cfg.Dir, filename)
-				}
-				info, _ := os.Stat(filename)
-				if info == nil {
-					return false
-				}
-				pkg.CompiledGoFiles = append(pkg.CompiledGoFiles, filename)
-				pkg.GoFiles = append(pkg.GoFiles, filename)
-				return true
-			}
-			found := addFilenameFromPos(err.Pos)
-			// In some cases, go list only reports the error position in the
-			// error text, not the error position. One such case is when the
-			// file's package name is a keyword (see golang.org/issue/39763).
-			if !found {
-				addFilenameFromPos(err.Err)
-			}
-		}
-
-		if p.Error != nil {
-			msg := strings.TrimSpace(p.Error.Err) // Trim to work around golang.org/issue/32363.
-			// Address golang.org/issue/35964 by appending import stack to error message.
-			if msg == "import cycle not allowed" && len(p.Error.ImportStack) != 0 {
-				msg += fmt.Sprintf(": import stack: %v", p.Error.ImportStack)
-			}
-			pkg.Errors = append(pkg.Errors, Error{
-				Pos:  p.Error.Pos,
-				Msg:  msg,
-				Kind: ListError,
-			})
-		}
-
-		pkgs[pkg.ID] = pkg
-	}
-
-	for id, errs := range additionalErrors {
-		if p, ok := pkgs[id]; ok {
-			p.Errors = append(p.Errors, errs...)
-		}
-	}
-	for _, pkg := range pkgs {
-		response.Packages = append(response.Packages, pkg)
-	}
-	sort.Slice(response.Packages, func(i, j int) bool { return response.Packages[i].ID < response.Packages[j].ID })
-
-	return response, nil
-}
-
-func (state *golistState) shouldAddFilenameFromError(p *jsonPackage) bool {
-	if len(p.GoFiles) > 0 || len(p.CompiledGoFiles) > 0 {
-		return false
-	}
-
-	goV, err := state.getGoVersion()
-	if err != nil {
-		return false
-	}
-
-	// On Go 1.14 and earlier, only add filenames from errors if the import stack is empty.
-	// The import stack behaves differently for these versions than newer Go versions.
-	if goV < 15 {
-		return len(p.Error.ImportStack) == 0
-	}
-
-	// On Go 1.15 and later, only parse filenames out of error if there's no import stack,
-	// or the current package is at the top of the import stack. This is not guaranteed
-	// to work perfectly, but should avoid some cases where files in errors don't belong to this
-	// package.
-	return len(p.Error.ImportStack) == 0 || p.Error.ImportStack[len(p.Error.ImportStack)-1] == p.ImportPath
-}
-
-// getGoVersion returns the effective minor version of the go command.
-func (state *golistState) getGoVersion() (int, error) {
-	state.goVersionOnce.Do(func() {
-		state.goVersion, state.goVersionError = gocommand.GoVersion(state.ctx, state.cfgInvocation(), state.runner)
-	})
-	return state.goVersion, state.goVersionError
-}
-
-// getPkgPath finds the package path of a directory if it's relative to a root
-// directory.
-func (state *golistState) getPkgPath(dir string) (string, bool, error) {
-	if !filepath.IsAbs(dir) {
-		panic("non-absolute dir passed to getPkgPath")
-	}
-	roots, err := state.determineRootDirs()
-	if err != nil {
-		return "", false, err
-	}
-
-	for rdir, rpath := range roots {
-		// Make sure that the directory is in the module,
-		// to avoid creating a path relative to another module.
-		if !strings.HasPrefix(dir, rdir) {
-			continue
-		}
-		// TODO(matloob): This doesn't properly handle symlinks.
-		r, err := filepath.Rel(rdir, dir)
-		if err != nil {
-			continue
-		}
-		if rpath != "" {
-			// We choose only one root even though the directory even it can belong in multiple modules
-			// or GOPATH entries. This is okay because we only need to work with absolute dirs when a
-			// file is missing from disk, for instance when gopls calls go/packages in an overlay.
-			// Once the file is saved, gopls, or the next invocation of the tool will get the correct
-			// result straight from golist.
-			// TODO(matloob): Implement module tiebreaking?
-			return path.Join(rpath, filepath.ToSlash(r)), true, nil
-		}
-		return filepath.ToSlash(r), true, nil
-	}
-	return "", false, nil
-}
-
-// absJoin absolutizes and flattens the lists of files.
-func absJoin(dir string, fileses ...[]string) (res []string) {
-	for _, files := range fileses {
-		for _, file := range files {
-			if !filepath.IsAbs(file) {
-				file = filepath.Join(dir, file)
-			}
-			res = append(res, file)
-		}
-	}
-	return res
-}
-
-func jsonFlag(cfg *Config, goVersion int) string {
-	if goVersion < 19 {
-		return "-json"
-	}
-	var fields []string
-	added := make(map[string]bool)
-	addFields := func(fs ...string) {
-		for _, f := range fs {
-			if !added[f] {
-				added[f] = true
-				fields = append(fields, f)
-			}
-		}
-	}
-	addFields("Name", "ImportPath", "Error") // These fields are always needed
-	if cfg.Mode&NeedFiles != 0 || cfg.Mode&(NeedTypes|NeedTypesInfo) != 0 {
-		addFields("Dir", "GoFiles", "IgnoredGoFiles", "IgnoredOtherFiles", "CFiles",
-			"CgoFiles", "CXXFiles", "MFiles", "HFiles", "FFiles", "SFiles",
-			"SwigFiles", "SwigCXXFiles", "SysoFiles")
-		if cfg.Tests {
-			addFields("TestGoFiles", "XTestGoFiles")
-		}
-	}
-	if cfg.Mode&(NeedTypes|NeedTypesInfo) != 0 {
-		// CompiledGoFiles seems to be required for the test case TestCgoNoSyntax,
-		// even when -compiled isn't passed in.
-		// TODO(#52435): Should we make the test ask for -compiled, or automatically
-		// request CompiledGoFiles in certain circumstances?
-		addFields("Dir", "CompiledGoFiles")
-	}
-	if cfg.Mode&NeedCompiledGoFiles != 0 {
-		addFields("Dir", "CompiledGoFiles", "Export")
-	}
-	if cfg.Mode&NeedImports != 0 {
-		// When imports are requested, DepOnly is used to distinguish between packages
-		// explicitly requested and transitive imports of those packages.
-		addFields("DepOnly", "Imports", "ImportMap")
-		if cfg.Tests {
-			addFields("TestImports", "XTestImports")
-		}
-	}
-	if cfg.Mode&NeedDeps != 0 {
-		addFields("DepOnly")
-	}
-	if usesExportData(cfg) {
-		// Request Dir in the unlikely case Export is not absolute.
-		addFields("Dir", "Export")
-	}
-	if cfg.Mode&NeedForTest != 0 {
-		addFields("ForTest")
-	}
-	if cfg.Mode&needInternalDepsErrors != 0 {
-		addFields("DepsErrors")
-	}
-	if cfg.Mode&NeedModule != 0 {
-		addFields("Module")
-	}
-	if cfg.Mode&NeedEmbedFiles != 0 {
-		addFields("EmbedFiles")
-	}
-	if cfg.Mode&NeedEmbedPatterns != 0 {
-		addFields("EmbedPatterns")
-	}
-	if cfg.Mode&NeedTarget != 0 {
-		addFields("Target")
-	}
-	return "-json=" + strings.Join(fields, ",")
-}
-
-func golistargs(cfg *Config, words []string, goVersion int) []string {
-	const findFlags = NeedImports | NeedTypes | NeedSyntax | NeedTypesInfo
-	fullargs := []string{
-		"-e", jsonFlag(cfg, goVersion),
-		fmt.Sprintf("-compiled=%t", cfg.Mode&(NeedCompiledGoFiles|NeedSyntax|NeedTypes|NeedTypesInfo|NeedTypesSizes) != 0),
-		fmt.Sprintf("-test=%t", cfg.Tests),
-		fmt.Sprintf("-export=%t", usesExportData(cfg)),
-		fmt.Sprintf("-deps=%t", cfg.Mode&NeedImports != 0),
-		// go list doesn't let you pass -test and -find together,
-		// probably because you'd just get the TestMain.
-		fmt.Sprintf("-find=%t", !cfg.Tests && cfg.Mode&findFlags == 0 && !usesExportData(cfg)),
-		// VCS information is not needed when not printing Stale or StaleReason fields
-		"-buildvcs=false",
-	}
-
-	// golang/go#60456: with go1.21 and later, go list serves pgo variants, which
-	// can be costly to compute and may result in redundant processing for the
-	// caller. Disable these variants. If someone wants to add e.g. a NeedPGO
-	// mode flag, that should be a separate proposal.
-	if goVersion >= 21 {
-		fullargs = append(fullargs, "-pgo=off")
-	}
-
-	fullargs = append(fullargs, cfg.BuildFlags...)
-	fullargs = append(fullargs, "--")
-	fullargs = append(fullargs, words...)
-	return fullargs
-}
-
-// cfgInvocation returns an Invocation that reflects cfg's settings.
-func (state *golistState) cfgInvocation() gocommand.Invocation {
-	cfg := state.cfg
-	return gocommand.Invocation{
-		BuildFlags: cfg.BuildFlags,
-		CleanEnv:   cfg.Env != nil,
-		Env:        cfg.Env,
-		Logf:       cfg.Logf,
-		WorkingDir: cfg.Dir,
-		Overlay:    state.overlay,
-	}
-}
-
-// invokeGo returns the stdout of a go command invocation.
-func (state *golistState) invokeGo(verb string, args ...string) (*bytes.Buffer, error) {
-	cfg := state.cfg
-
-	inv := state.cfgInvocation()
-	inv.Verb = verb
-	inv.Args = args
-
-	stdout, stderr, friendlyErr, err := state.runner.RunRaw(cfg.Context, inv)
-	if err != nil {
-		// Check for 'go' executable not being found.
-		if ee, ok := err.(*exec.Error); ok && ee.Err == exec.ErrNotFound {
-			return nil, fmt.Errorf("'go list' driver requires 'go', but %s", exec.ErrNotFound)
-		}
-
-		exitErr, ok := err.(*exec.ExitError)
-		if !ok {
-			// Catastrophic error:
-			// - context cancellation
-			return nil, fmt.Errorf("couldn't run 'go': %w", err)
-		}
-
-		// Old go version?
-		if strings.Contains(stderr.String(), "flag provided but not defined") {
-			return nil, goTooOldError{fmt.Errorf("unsupported version of go: %s: %s", exitErr, stderr)}
-		}
-
-		// Related to #24854
-		if len(stderr.String()) > 0 && strings.Contains(stderr.String(), "unexpected directory layout") {
-			return nil, friendlyErr
-		}
-
-		// Return an error if 'go list' failed due to missing tools in
-		// $GOROOT/pkg/tool/$GOOS_$GOARCH (#69606).
-		if len(stderr.String()) > 0 && strings.Contains(stderr.String(), `go: no such tool`) {
-			return nil, friendlyErr
-		}
-
-		// Is there an error running the C compiler in cgo? This will be reported in the "Error" field
-		// and should be suppressed by go list -e.
-		//
-		// This condition is not perfect yet because the error message can include other error messages than runtime/cgo.
-		isPkgPathRune := func(r rune) bool {
-			// From https://golang.org/ref/spec#Import_declarations:
-			//    Implementation restriction: A compiler may restrict ImportPaths to non-empty strings
-			//    using only characters belonging to Unicode's L, M, N, P, and S general categories
-			//    (the Graphic characters without spaces) and may also exclude the
-			//    characters !"#$%&'()*,:;<=>?[\]^`{|} and the Unicode replacement character U+FFFD.
-			return unicode.IsOneOf([]*unicode.RangeTable{unicode.L, unicode.M, unicode.N, unicode.P, unicode.S}, r) &&
-				!strings.ContainsRune("!\"#$%&'()*,:;<=>?[\\]^`{|}\uFFFD", r)
-		}
-		// golang/go#36770: Handle case where cmd/go prints module download messages before the error.
-		msg := stderr.String()
-		for strings.HasPrefix(msg, "go: downloading") {
-			msg = msg[strings.IndexRune(msg, '\n')+1:]
-		}
-		if len(stderr.String()) > 0 && strings.HasPrefix(stderr.String(), "# ") {
-			msg := msg[len("# "):]
-			if strings.HasPrefix(strings.TrimLeftFunc(msg, isPkgPathRune), "\n") {
-				return stdout, nil
-			}
-			// Treat pkg-config errors as a special case (golang.org/issue/36770).
-			if strings.HasPrefix(msg, "pkg-config") {
-				return stdout, nil
-			}
-		}
-
-		// This error only appears in stderr. See golang.org/cl/166398 for a fix in go list to show
-		// the error in the Err section of stdout in case -e option is provided.
-		// This fix is provided for backwards compatibility.
-		if len(stderr.String()) > 0 && strings.Contains(stderr.String(), "named files must be .go files") {
-			output := fmt.Sprintf(`{"ImportPath": "command-line-arguments","Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
-				strings.Trim(stderr.String(), "\n"))
-			return bytes.NewBufferString(output), nil
-		}
-
-		// Similar to the previous error, but currently lacks a fix in Go.
-		if len(stderr.String()) > 0 && strings.Contains(stderr.String(), "named files must all be in one directory") {
-			output := fmt.Sprintf(`{"ImportPath": "command-line-arguments","Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
-				strings.Trim(stderr.String(), "\n"))
-			return bytes.NewBufferString(output), nil
-		}
-
-		// Backwards compatibility for Go 1.11 because 1.12 and 1.13 put the directory in the ImportPath.
-		// If the package doesn't exist, put the absolute path of the directory into the error message,
-		// as Go 1.13 list does.
-		const noSuchDirectory = "no such directory"
-		if len(stderr.String()) > 0 && strings.Contains(stderr.String(), noSuchDirectory) {
-			errstr := stderr.String()
-			abspath := strings.TrimSpace(errstr[strings.Index(errstr, noSuchDirectory)+len(noSuchDirectory):])
-			output := fmt.Sprintf(`{"ImportPath": %q,"Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
-				abspath, strings.Trim(stderr.String(), "\n"))
-			return bytes.NewBufferString(output), nil
-		}
-
-		// Workaround for #29280: go list -e has incorrect behavior when an ad-hoc package doesn't exist.
-		// Note that the error message we look for in this case is different that the one looked for above.
-		if len(stderr.String()) > 0 && strings.Contains(stderr.String(), "no such file or directory") {
-			output := fmt.Sprintf(`{"ImportPath": "command-line-arguments","Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
-				strings.Trim(stderr.String(), "\n"))
-			return bytes.NewBufferString(output), nil
-		}
-
-		// Workaround for #34273. go list -e with GO111MODULE=on has incorrect behavior when listing a
-		// directory outside any module.
-		if len(stderr.String()) > 0 && strings.Contains(stderr.String(), "outside available modules") {
-			output := fmt.Sprintf(`{"ImportPath": %q,"Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
-				// TODO(matloob): command-line-arguments isn't correct here.
-				"command-line-arguments", strings.Trim(stderr.String(), "\n"))
-			return bytes.NewBufferString(output), nil
-		}
-
-		// Another variation of the previous error
-		if len(stderr.String()) > 0 && strings.Contains(stderr.String(), "outside module root") {
-			output := fmt.Sprintf(`{"ImportPath": %q,"Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
-				// TODO(matloob): command-line-arguments isn't correct here.
-				"command-line-arguments", strings.Trim(stderr.String(), "\n"))
-			return bytes.NewBufferString(output), nil
-		}
-
-		// Workaround for an instance of golang.org/issue/26755: go list -e  will return a non-zero exit
-		// status if there's a dependency on a package that doesn't exist. But it should return
-		// a zero exit status and set an error on that package.
-		if len(stderr.String()) > 0 && strings.Contains(stderr.String(), "no Go files in") {
-			// Don't clobber stdout if `go list` actually returned something.
-			if len(stdout.String()) > 0 {
-				return stdout, nil
-			}
-			// try to extract package name from string
-			stderrStr := stderr.String()
-			var importPath string
-			colon := strings.Index(stderrStr, ":")
-			if colon > 0 && strings.HasPrefix(stderrStr, "go build ") {
-				importPath = stderrStr[len("go build "):colon]
-			}
-			output := fmt.Sprintf(`{"ImportPath": %q,"Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
-				importPath, strings.Trim(stderrStr, "\n"))
-			return bytes.NewBufferString(output), nil
-		}
-
-		// Export mode entails a build.
-		// If that build fails, errors appear on stderr
-		// (despite the -e flag) and the Export field is blank.
-		// Do not fail in that case.
-		// The same is true if an ad-hoc package given to go list doesn't exist.
-		// TODO(matloob): Remove these once we can depend on go list to exit with a zero status with -e even when
-		// packages don't exist or a build fails.
-		if !usesExportData(cfg) && !containsGoFile(args) {
-			return nil, friendlyErr
-		}
-	}
-	return stdout, nil
-}
-
-func containsGoFile(s []string) bool {
-	for _, f := range s {
-		if strings.HasSuffix(f, ".go") {
-			return true
-		}
-	}
-	return false
-}
-
-func cmdDebugStr(cmd *exec.Cmd) string {
-	env := make(map[string]string)
-	for _, kv := range cmd.Env {
-		split := strings.SplitN(kv, "=", 2)
-		k, v := split[0], split[1]
-		env[k] = v
-	}
-
-	var args []string
-	for _, arg := range cmd.Args {
-		quoted := strconv.Quote(arg)
-		if quoted[1:len(quoted)-1] != arg || strings.Contains(arg, " ") {
-			args = append(args, quoted)
-		} else {
-			args = append(args, arg)
-		}
-	}
-	return fmt.Sprintf("GOROOT=%v GOPATH=%v GO111MODULE=%v GOPROXY=%v PWD=%v %v", env["GOROOT"], env["GOPATH"], env["GO111MODULE"], env["GOPROXY"], env["PWD"], strings.Join(args, " "))
-}
-
-// getSizesForArgs queries 'go list' for the appropriate
-// Compiler and GOARCH arguments to pass to [types.SizesFor].
-func getSizesForArgs(ctx context.Context, inv gocommand.Invocation, gocmdRunner *gocommand.Runner) (string, string, error) {
-	inv.Verb = "list"
-	inv.Args = []string{"-f", "{{context.GOARCH}} {{context.Compiler}}", "--", "unsafe"}
-	stdout, stderr, friendlyErr, rawErr := gocmdRunner.RunRaw(ctx, inv)
-	var goarch, compiler string
-	if rawErr != nil {
-		rawErrMsg := rawErr.Error()
-		if strings.Contains(rawErrMsg, "cannot find main module") ||
-			strings.Contains(rawErrMsg, "go.mod file not found") {
-			// User's running outside of a module.
-			// All bets are off. Get GOARCH and guess compiler is gc.
-			// TODO(matloob): Is this a problem in practice?
-			inv.Verb = "env"
-			inv.Args = []string{"GOARCH"}
-			envout, enverr := gocmdRunner.Run(ctx, inv)
-			if enverr != nil {
-				return "", "", enverr
-			}
-			goarch = strings.TrimSpace(envout.String())
-			compiler = "gc"
-		} else if friendlyErr != nil {
-			return "", "", friendlyErr
-		} else {
-			// This should be unreachable, but be defensive
-			// in case RunRaw's error results are inconsistent.
-			return "", "", rawErr
-		}
-	} else {
-		fields := strings.Fields(stdout.String())
-		if len(fields) < 2 {
-			return "", "", fmt.Errorf("could not parse GOARCH and Go compiler in format \"<GOARCH> <compiler>\":\nstdout: <<%s>>\nstderr: <<%s>>",
-				stdout.String(), stderr.String())
-		}
-		goarch = fields[0]
-		compiler = fields[1]
-	}
-	return compiler, goarch, nil
-}
diff --git a/vendor/golang.org/x/tools/go/packages/golist_overlay.go b/vendor/golang.org/x/tools/go/packages/golist_overlay.go
deleted file mode 100644
index d9d5a45cd4..0000000000
--- a/vendor/golang.org/x/tools/go/packages/golist_overlay.go
+++ /dev/null
@@ -1,83 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package packages
-
-import (
-	"encoding/json"
-	"path/filepath"
-
-	"golang.org/x/tools/internal/gocommand"
-)
-
-// determineRootDirs returns a mapping from absolute directories that could
-// contain code to their corresponding import path prefixes.
-func (state *golistState) determineRootDirs() (map[string]string, error) {
-	env, err := state.getEnv()
-	if err != nil {
-		return nil, err
-	}
-	if env["GOMOD"] != "" {
-		state.rootsOnce.Do(func() {
-			state.rootDirs, state.rootDirsError = state.determineRootDirsModules()
-		})
-	} else {
-		state.rootsOnce.Do(func() {
-			state.rootDirs, state.rootDirsError = state.determineRootDirsGOPATH()
-		})
-	}
-	return state.rootDirs, state.rootDirsError
-}
-
-func (state *golistState) determineRootDirsModules() (map[string]string, error) {
-	// List all of the modules--the first will be the directory for the main
-	// module. Any replaced modules will also need to be treated as roots.
-	// Editing files in the module cache isn't a great idea, so we don't
-	// plan to ever support that.
-	out, err := state.invokeGo("list", "-m", "-json", "all")
-	if err != nil {
-		// 'go list all' will fail if we're outside of a module and
-		// GO111MODULE=on. Try falling back without 'all'.
-		var innerErr error
-		out, innerErr = state.invokeGo("list", "-m", "-json")
-		if innerErr != nil {
-			return nil, err
-		}
-	}
-	roots := map[string]string{}
-	modules := map[string]string{}
-	var i int
-	for dec := json.NewDecoder(out); dec.More(); {
-		mod := new(gocommand.ModuleJSON)
-		if err := dec.Decode(mod); err != nil {
-			return nil, err
-		}
-		if mod.Dir != "" && mod.Path != "" {
-			// This is a valid module; add it to the map.
-			absDir, err := state.cfg.abs(mod.Dir)
-			if err != nil {
-				return nil, err
-			}
-			modules[absDir] = mod.Path
-			// The first result is the main module.
-			if i == 0 || mod.Replace != nil && mod.Replace.Path != "" {
-				roots[absDir] = mod.Path
-			}
-		}
-		i++
-	}
-	return roots, nil
-}
-
-func (state *golistState) determineRootDirsGOPATH() (map[string]string, error) {
-	m := map[string]string{}
-	for _, dir := range filepath.SplitList(state.mustGetEnv()["GOPATH"]) {
-		absDir, err := filepath.Abs(dir)
-		if err != nil {
-			return nil, err
-		}
-		m[filepath.Join(absDir, "src")] = ""
-	}
-	return m, nil
-}
diff --git a/vendor/golang.org/x/tools/go/packages/loadmode_string.go b/vendor/golang.org/x/tools/go/packages/loadmode_string.go
deleted file mode 100644
index 69eec9f44d..0000000000
--- a/vendor/golang.org/x/tools/go/packages/loadmode_string.go
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package packages
-
-import (
-	"fmt"
-	"strings"
-)
-
-var modes = [...]struct {
-	mode LoadMode
-	name string
-}{
-	{NeedName, "NeedName"},
-	{NeedFiles, "NeedFiles"},
-	{NeedCompiledGoFiles, "NeedCompiledGoFiles"},
-	{NeedImports, "NeedImports"},
-	{NeedDeps, "NeedDeps"},
-	{NeedExportFile, "NeedExportFile"},
-	{NeedTypes, "NeedTypes"},
-	{NeedSyntax, "NeedSyntax"},
-	{NeedTypesInfo, "NeedTypesInfo"},
-	{NeedTypesSizes, "NeedTypesSizes"},
-	{NeedForTest, "NeedForTest"},
-	{NeedModule, "NeedModule"},
-	{NeedEmbedFiles, "NeedEmbedFiles"},
-	{NeedEmbedPatterns, "NeedEmbedPatterns"},
-	{NeedTarget, "NeedTarget"},
-}
-
-func (mode LoadMode) String() string {
-	if mode == 0 {
-		return "LoadMode(0)"
-	}
-	var out []string
-	// named bits
-	for _, item := range modes {
-		if (mode & item.mode) != 0 {
-			mode ^= item.mode
-			out = append(out, item.name)
-		}
-	}
-	// unnamed residue
-	if mode != 0 {
-		if out == nil {
-			return fmt.Sprintf("LoadMode(%#x)", int(mode))
-		}
-		out = append(out, fmt.Sprintf("%#x", int(mode)))
-	}
-	if len(out) == 1 {
-		return out[0]
-	}
-	return "(" + strings.Join(out, "|") + ")"
-}
diff --git a/vendor/golang.org/x/tools/go/packages/packages.go b/vendor/golang.org/x/tools/go/packages/packages.go
deleted file mode 100644
index 1e5549abe4..0000000000
--- a/vendor/golang.org/x/tools/go/packages/packages.go
+++ /dev/null
@@ -1,1605 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package packages
-
-// See doc.go for package documentation and implementation notes.
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"go/ast"
-	"go/parser"
-	"go/scanner"
-	"go/token"
-	"go/types"
-	"log"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"golang.org/x/sync/errgroup"
-
-	"golang.org/x/tools/go/gcexportdata"
-	"golang.org/x/tools/internal/gocommand"
-	"golang.org/x/tools/internal/packagesinternal"
-	"golang.org/x/tools/internal/typesinternal"
-)
-
-// A LoadMode controls the amount of detail to return when loading.
-// The bits below can be combined to specify which fields should be
-// filled in the result packages.
-//
-// The zero value is a special case, equivalent to combining
-// the NeedName, NeedFiles, and NeedCompiledGoFiles bits.
-//
-// ID and Errors (if present) will always be filled.
-// [Load] may return more information than requested.
-//
-// The Mode flag is a union of several bits named NeedName,
-// NeedFiles, and so on, each of which determines whether
-// a given field of Package (Name, Files, etc) should be
-// populated.
-//
-// For convenience, we provide named constants for the most
-// common combinations of Need flags:
-//
-//	[LoadFiles]     lists of files in each package
-//	[LoadImports]   ... plus imports
-//	[LoadTypes]     ... plus type information
-//	[LoadSyntax]    ... plus type-annotated syntax
-//	[LoadAllSyntax] ... for all dependencies
-//
-// Unfortunately there are a number of open bugs related to
-// interactions among the LoadMode bits:
-//   - https://go.dev/issue/56633
-//   - https://go.dev/issue/56677
-//   - https://go.dev/issue/58726
-//   - https://go.dev/issue/63517
-type LoadMode int
-
-const (
-	// NeedName adds Name and PkgPath.
-	NeedName LoadMode = 1 << iota
-
-	// NeedFiles adds Dir, GoFiles, OtherFiles, and IgnoredFiles
-	NeedFiles
-
-	// NeedCompiledGoFiles adds CompiledGoFiles.
-	NeedCompiledGoFiles
-
-	// NeedImports adds Imports. If NeedDeps is not set, the Imports field will contain
-	// "placeholder" Packages with only the ID set.
-	NeedImports
-
-	// NeedDeps adds the fields requested by the LoadMode in the packages in Imports.
-	NeedDeps
-
-	// NeedExportFile adds ExportFile.
-	NeedExportFile
-
-	// NeedTypes adds Types, Fset, and IllTyped.
-	NeedTypes
-
-	// NeedSyntax adds Syntax and Fset.
-	NeedSyntax
-
-	// NeedTypesInfo adds TypesInfo and Fset.
-	NeedTypesInfo
-
-	// NeedTypesSizes adds TypesSizes.
-	NeedTypesSizes
-
-	// needInternalDepsErrors adds the internal deps errors field for use by gopls.
-	needInternalDepsErrors
-
-	// NeedForTest adds ForTest.
-	//
-	// Tests must also be set on the context for this field to be populated.
-	NeedForTest
-
-	// typecheckCgo enables full support for type checking cgo. Requires Go 1.15+.
-	// Modifies CompiledGoFiles and Types, and has no effect on its own.
-	typecheckCgo
-
-	// NeedModule adds Module.
-	NeedModule
-
-	// NeedEmbedFiles adds EmbedFiles.
-	NeedEmbedFiles
-
-	// NeedEmbedPatterns adds EmbedPatterns.
-	NeedEmbedPatterns
-
-	// NeedTarget adds Target.
-	NeedTarget
-
-	// Be sure to update loadmode_string.go when adding new items!
-)
-
-const (
-	// LoadFiles loads the name and file names for the initial packages.
-	LoadFiles = NeedName | NeedFiles | NeedCompiledGoFiles
-
-	// LoadImports loads the name, file names, and import mapping for the initial packages.
-	LoadImports = LoadFiles | NeedImports
-
-	// LoadTypes loads exported type information for the initial packages.
-	LoadTypes = LoadImports | NeedTypes | NeedTypesSizes
-
-	// LoadSyntax loads typed syntax for the initial packages.
-	LoadSyntax = LoadTypes | NeedSyntax | NeedTypesInfo
-
-	// LoadAllSyntax loads typed syntax for the initial packages and all dependencies.
-	LoadAllSyntax = LoadSyntax | NeedDeps
-
-	// Deprecated: NeedExportsFile is a historical misspelling of NeedExportFile.
-	//
-	//go:fix inline
-	NeedExportsFile = NeedExportFile
-)
-
-// A Config specifies details about how packages should be loaded.
-// The zero value is a valid configuration.
-//
-// Calls to [Load] do not modify this struct.
-type Config struct {
-	// Mode controls the level of information returned for each package.
-	Mode LoadMode
-
-	// Context specifies the context for the load operation.
-	// Cancelling the context may cause [Load] to abort and
-	// return an error.
-	Context context.Context
-
-	// Logf is the logger for the config.
-	// If the user provides a logger, debug logging is enabled.
-	// If the GOPACKAGESDEBUG environment variable is set to true,
-	// but the logger is nil, default to log.Printf.
-	Logf func(format string, args ...any)
-
-	// Dir is the directory in which to run the build system's query tool
-	// that provides information about the packages.
-	// If Dir is empty, the tool is run in the current directory.
-	Dir string
-
-	// Env is the environment to use when invoking the build system's query tool.
-	// If Env is nil, the current environment is used.
-	// As in os/exec's Cmd, only the last value in the slice for
-	// each environment key is used. To specify the setting of only
-	// a few variables, append to the current environment, as in:
-	//
-	//	opt.Env = append(os.Environ(), "GOOS=plan9", "GOARCH=386")
-	//
-	Env []string
-
-	// BuildFlags is a list of command-line flags to be passed through to
-	// the build system's query tool.
-	BuildFlags []string
-
-	// Fset provides source position information for syntax trees and types.
-	// If Fset is nil, Load will use a new fileset, but preserve Fset's value.
-	Fset *token.FileSet
-
-	// ParseFile is called to read and parse each file
-	// when preparing a package's type-checked syntax tree.
-	// It must be safe to call ParseFile simultaneously from multiple goroutines.
-	// If ParseFile is nil, the loader will uses parser.ParseFile.
-	//
-	// ParseFile should parse the source from src and use filename only for
-	// recording position information.
-	//
-	// An application may supply a custom implementation of ParseFile
-	// to change the effective file contents or the behavior of the parser,
-	// or to modify the syntax tree. For example, selectively eliminating
-	// unwanted function bodies can significantly accelerate type checking.
-	ParseFile func(fset *token.FileSet, filename string, src []byte) (*ast.File, error)
-
-	// If Tests is set, the loader includes not just the packages
-	// matching a particular pattern but also any related test packages,
-	// including test-only variants of the package and the test executable.
-	//
-	// For example, when using the go command, loading "fmt" with Tests=true
-	// returns four packages, with IDs "fmt" (the standard package),
-	// "fmt [fmt.test]" (the package as compiled for the test),
-	// "fmt_test" (the test functions from source files in package fmt_test),
-	// and "fmt.test" (the test binary).
-	//
-	// In build systems with explicit names for tests,
-	// setting Tests may have no effect.
-	Tests bool
-
-	// Overlay is a mapping from absolute file paths to file contents.
-	//
-	// For each map entry, [Load] uses the alternative file
-	// contents provided by the overlay mapping instead of reading
-	// from the file system. This mechanism can be used to enable
-	// editor-integrated tools to correctly analyze the contents
-	// of modified but unsaved buffers, for example.
-	//
-	// The overlay mapping is passed to the build system's driver
-	// (see "The driver protocol") so that it too can report
-	// consistent package metadata about unsaved files. However,
-	// drivers may vary in their level of support for overlays.
-	Overlay map[string][]byte
-}
-
-// Load loads and returns the Go packages named by the given patterns.
-//
-// The cfg parameter specifies loading options; nil behaves the same as an empty [Config].
-//
-// The [Config.Mode] field is a set of bits that determine what kinds
-// of information should be computed and returned. Modes that require
-// more information tend to be slower. See [LoadMode] for details
-// and important caveats. Its zero value is equivalent to
-// [NeedName] | [NeedFiles] | [NeedCompiledGoFiles].
-//
-// Each call to Load returns a new set of [Package] instances.
-// The Packages and their Imports form a directed acyclic graph.
-//
-// If the [NeedTypes] mode flag was set, each call to Load uses a new
-// [types.Importer], so [types.Object] and [types.Type] values from
-// different calls to Load must not be mixed as they will have
-// inconsistent notions of type identity.
-//
-// If any of the patterns was invalid as defined by the
-// underlying build system, Load returns an error.
-// It may return an empty list of packages without an error,
-// for instance for an empty expansion of a valid wildcard.
-// Errors associated with a particular package are recorded in the
-// corresponding Package's Errors list, and do not cause Load to
-// return an error. Clients may need to handle such errors before
-// proceeding with further analysis. The [PrintErrors] function is
-// provided for convenient display of all errors.
-func Load(cfg *Config, patterns ...string) ([]*Package, error) {
-	ld := newLoader(cfg)
-	response, external, err := defaultDriver(&ld.Config, patterns...)
-	if err != nil {
-		return nil, err
-	}
-
-	ld.sizes = types.SizesFor(response.Compiler, response.Arch)
-	if ld.sizes == nil && ld.Config.Mode&(NeedTypes|NeedTypesSizes|NeedTypesInfo) != 0 {
-		// Type size information is needed but unavailable.
-		if external {
-			// An external driver may fail to populate the Compiler/GOARCH fields,
-			// especially since they are relatively new (see #63700).
-			// Provide a sensible fallback in this case.
-			ld.sizes = types.SizesFor("gc", runtime.GOARCH)
-			if ld.sizes == nil { // gccgo-only arch
-				ld.sizes = types.SizesFor("gc", "amd64")
-			}
-		} else {
-			// Go list should never fail to deliver accurate size information.
-			// Reject the whole Load since the error is the same for every package.
-			return nil, fmt.Errorf("can't determine type sizes for compiler %q on GOARCH %q",
-				response.Compiler, response.Arch)
-		}
-	}
-
-	ld.externalDriver = external
-
-	return ld.refine(response)
-}
-
-// defaultDriver is a driver that implements go/packages' fallback behavior.
-// It will try to request to an external driver, if one exists. If there's
-// no external driver, or the driver returns a response with NotHandled set,
-// defaultDriver will fall back to the go list driver.
-// The boolean result indicates that an external driver handled the request.
-func defaultDriver(cfg *Config, patterns ...string) (*DriverResponse, bool, error) {
-	const (
-		// windowsArgMax specifies the maximum command line length for
-		// the Windows' CreateProcess function.
-		windowsArgMax = 32767
-		// maxEnvSize is a very rough estimation of the maximum environment
-		// size of a user.
-		maxEnvSize = 16384
-		// safeArgMax specifies the maximum safe command line length to use
-		// by the underlying driver excl. the environment. We choose the Windows'
-		// ARG_MAX as the starting point because it's one of the lowest ARG_MAX
-		// constants out of the different supported platforms,
-		// e.g., https://www.in-ulm.de/~mascheck/various/argmax/#results.
-		safeArgMax = windowsArgMax - maxEnvSize
-	)
-	chunks, err := splitIntoChunks(patterns, safeArgMax)
-	if err != nil {
-		return nil, false, err
-	}
-
-	if driver := findExternalDriver(cfg); driver != nil {
-		response, err := callDriverOnChunks(driver, cfg, chunks)
-		if err != nil {
-			return nil, false, err
-		} else if !response.NotHandled {
-			return response, true, nil
-		}
-		// not handled: fall through
-	}
-
-	// go list fallback
-
-	// Write overlays once, as there are many calls
-	// to 'go list' (one per chunk plus others too).
-	overlayFile, cleanupOverlay, err := gocommand.WriteOverlays(cfg.Overlay)
-	if err != nil {
-		return nil, false, err
-	}
-	defer cleanupOverlay()
-
-	var runner gocommand.Runner // (shared across many 'go list' calls)
-	driver := func(cfg *Config, patterns []string) (*DriverResponse, error) {
-		return goListDriver(cfg, &runner, overlayFile, patterns)
-	}
-	response, err := callDriverOnChunks(driver, cfg, chunks)
-	if err != nil {
-		return nil, false, err
-	}
-	return response, false, err
-}
-
-// splitIntoChunks chunks the slice so that the total number of characters
-// in a chunk is no longer than argMax.
-func splitIntoChunks(patterns []string, argMax int) ([][]string, error) {
-	if argMax <= 0 {
-		return nil, errors.New("failed to split patterns into chunks, negative safe argMax value")
-	}
-	var chunks [][]string
-	charsInChunk := 0
-	nextChunkStart := 0
-	for i, v := range patterns {
-		vChars := len(v)
-		if vChars > argMax {
-			// a single pattern is longer than the maximum safe ARG_MAX, hardly should happen
-			return nil, errors.New("failed to split patterns into chunks, a pattern is too long")
-		}
-		charsInChunk += vChars + 1 // +1 is for a whitespace between patterns that has to be counted too
-		if charsInChunk > argMax {
-			chunks = append(chunks, patterns[nextChunkStart:i])
-			nextChunkStart = i
-			charsInChunk = vChars
-		}
-	}
-	// add the last chunk
-	if nextChunkStart < len(patterns) {
-		chunks = append(chunks, patterns[nextChunkStart:])
-	}
-	return chunks, nil
-}
-
-func callDriverOnChunks(driver driver, cfg *Config, chunks [][]string) (*DriverResponse, error) {
-	if len(chunks) == 0 {
-		return driver(cfg, nil)
-	}
-	responses := make([]*DriverResponse, len(chunks))
-	errNotHandled := errors.New("driver returned NotHandled")
-	var g errgroup.Group
-	for i, chunk := range chunks {
-		g.Go(func() (err error) {
-			responses[i], err = driver(cfg, chunk)
-			if responses[i] != nil && responses[i].NotHandled {
-				err = errNotHandled
-			}
-			return err
-		})
-	}
-	if err := g.Wait(); err != nil {
-		if errors.Is(err, errNotHandled) {
-			return &DriverResponse{NotHandled: true}, nil
-		}
-		return nil, err
-	}
-	return mergeResponses(responses...), nil
-}
-
-func mergeResponses(responses ...*DriverResponse) *DriverResponse {
-	if len(responses) == 0 {
-		return nil
-	}
-	// No dedup needed
-	if len(responses) == 1 {
-		return responses[0]
-	}
-	response := newDeduper()
-	response.dr.NotHandled = false
-	response.dr.Compiler = responses[0].Compiler
-	response.dr.Arch = responses[0].Arch
-	response.dr.GoVersion = responses[0].GoVersion
-	for _, v := range responses {
-		response.addAll(v)
-	}
-	return response.dr
-}
-
-// A Package describes a loaded Go package.
-//
-// It also defines part of the JSON schema of [DriverResponse].
-// See the package documentation for an overview.
-type Package struct {
-	// ID is a unique identifier for a package,
-	// in a syntax provided by the underlying build system.
-	//
-	// Because the syntax varies based on the build system,
-	// clients should treat IDs as opaque and not attempt to
-	// interpret them.
-	ID string
-
-	// Name is the package name as it appears in the package source code.
-	Name string
-
-	// PkgPath is the package path as used by the go/types package.
-	PkgPath string
-
-	// Dir is the directory associated with the package, if it exists.
-	//
-	// For packages listed by the go command, this is the directory containing
-	// the package files.
-	Dir string
-
-	// Errors contains any errors encountered querying the metadata
-	// of the package, or while parsing or type-checking its files.
-	Errors []Error
-
-	// TypeErrors contains the subset of errors produced during type checking.
-	TypeErrors []types.Error
-
-	// GoFiles lists the absolute file paths of the package's Go source files.
-	// It may include files that should not be compiled, for example because
-	// they contain non-matching build tags, are documentary pseudo-files such as
-	// unsafe/unsafe.go or builtin/builtin.go, or are subject to cgo preprocessing.
-	GoFiles []string
-
-	// CompiledGoFiles lists the absolute file paths of the package's source
-	// files that are suitable for type checking.
-	// This may differ from GoFiles if files are processed before compilation.
-	CompiledGoFiles []string
-
-	// OtherFiles lists the absolute file paths of the package's non-Go source files,
-	// including assembly, C, C++, Fortran, Objective-C, SWIG, and so on.
-	OtherFiles []string
-
-	// EmbedFiles lists the absolute file paths of the package's files
-	// embedded with go:embed.
-	EmbedFiles []string
-
-	// EmbedPatterns lists the absolute file patterns of the package's
-	// files embedded with go:embed.
-	EmbedPatterns []string
-
-	// IgnoredFiles lists source files that are not part of the package
-	// using the current build configuration but that might be part of
-	// the package using other build configurations.
-	IgnoredFiles []string
-
-	// ExportFile is the absolute path to a file containing type
-	// information for the package as provided by the build system.
-	ExportFile string
-
-	// Target is the absolute install path of the .a file, for libraries,
-	// and of the executable file, for binaries.
-	Target string
-
-	// Imports maps import paths appearing in the package's Go source files
-	// to corresponding loaded Packages.
-	Imports map[string]*Package
-
-	// Module is the module information for the package if it exists.
-	//
-	// Note: it may be missing for std and cmd; see Go issue #65816.
-	Module *Module
-
-	// -- The following fields are not part of the driver JSON schema. --
-
-	// Types provides type information for the package.
-	// The NeedTypes LoadMode bit sets this field for packages matching the
-	// patterns; type information for dependencies may be missing or incomplete,
-	// unless NeedDeps and NeedImports are also set.
-	//
-	// Each call to [Load] returns a consistent set of type
-	// symbols, as defined by the comment at [types.Identical].
-	// Avoid mixing type information from two or more calls to [Load].
-	Types *types.Package `json:"-"`
-
-	// Fset provides position information for Types, TypesInfo, and Syntax.
-	// It is set only when Types is set.
-	Fset *token.FileSet `json:"-"`
-
-	// IllTyped indicates whether the package or any dependency contains errors.
-	// It is set only when Types is set.
-	IllTyped bool `json:"-"`
-
-	// Syntax is the package's syntax trees, for the files listed in CompiledGoFiles.
-	//
-	// The NeedSyntax LoadMode bit populates this field for packages matching the patterns.
-	// If NeedDeps and NeedImports are also set, this field will also be populated
-	// for dependencies.
-	//
-	// Syntax is kept in the same order as CompiledGoFiles, with the caveat that nils are
-	// removed.  If parsing returned nil, Syntax may be shorter than CompiledGoFiles.
-	Syntax []*ast.File `json:"-"`
-
-	// TypesInfo provides type information about the package's syntax trees.
-	// It is set only when Syntax is set.
-	TypesInfo *types.Info `json:"-"`
-
-	// TypesSizes provides the effective size function for types in TypesInfo.
-	TypesSizes types.Sizes `json:"-"`
-
-	// -- internal --
-
-	// ForTest is the package under test, if any.
-	ForTest string
-
-	// depsErrors is the DepsErrors field from the go list response, if any.
-	depsErrors []*packagesinternal.PackageError
-
-	// exportDataError is the error encountered reading export data, if any.
-	// Decoding export data should ordinarily be infallible, so this typically
-	// indicates a producer/consumer version skew.
-	exportDataError error
-}
-
-// Module provides module information for a package.
-//
-// It also defines part of the JSON schema of [DriverResponse].
-// See the package documentation for an overview.
-type Module struct {
-	Path      string       // module path
-	Version   string       // module version
-	Replace   *Module      // replaced by this module
-	Time      *time.Time   // time version was created
-	Main      bool         // is this the main module?
-	Indirect  bool         // is this module only an indirect dependency of main module?
-	Dir       string       // directory holding files for this module, if any
-	GoMod     string       // path to go.mod file used when loading this module, if any
-	GoVersion string       // go version used in module
-	Error     *ModuleError // error loading module
-}
-
-// ModuleError holds errors loading a module.
-type ModuleError struct {
-	Err string // the error itself
-}
-
-func init() {
-	packagesinternal.GetDepsErrors = func(p any) []*packagesinternal.PackageError {
-		return p.(*Package).depsErrors
-	}
-	packagesinternal.TypecheckCgo = int(typecheckCgo)
-	packagesinternal.DepsErrors = int(needInternalDepsErrors)
-}
-
-// An Error describes a problem with a package's metadata, syntax, or types.
-type Error struct {
-	Pos  string // "file:line:col" or "file:line" or "" or "-"
-	Msg  string
-	Kind ErrorKind
-}
-
-// ErrorKind describes the source of the error, allowing the user to
-// differentiate between errors generated by the driver, the parser, or the
-// type-checker.
-type ErrorKind int
-
-const (
-	UnknownError ErrorKind = iota
-	ListError
-	ParseError
-	TypeError
-)
-
-func (err Error) Error() string {
-	pos := err.Pos
-	if pos == "" {
-		pos = "-" // like token.Position{}.String()
-	}
-	return pos + ": " + err.Msg
-}
-
-// flatPackage is the JSON form of Package
-// It drops all the type and syntax fields, and transforms the Imports
-//
-// TODO(adonovan): identify this struct with Package, effectively
-// publishing the JSON protocol.
-type flatPackage struct {
-	ID              string
-	Name            string            `json:",omitempty"`
-	PkgPath         string            `json:",omitempty"`
-	Errors          []Error           `json:",omitempty"`
-	GoFiles         []string          `json:",omitempty"`
-	CompiledGoFiles []string          `json:",omitempty"`
-	OtherFiles      []string          `json:",omitempty"`
-	EmbedFiles      []string          `json:",omitempty"`
-	EmbedPatterns   []string          `json:",omitempty"`
-	IgnoredFiles    []string          `json:",omitempty"`
-	ExportFile      string            `json:",omitempty"`
-	Imports         map[string]string `json:",omitempty"`
-}
-
-// MarshalJSON returns the Package in its JSON form.
-// For the most part, the structure fields are written out unmodified, and
-// the type and syntax fields are skipped.
-// The imports are written out as just a map of path to package id.
-// The errors are written using a custom type that tries to preserve the
-// structure of error types we know about.
-//
-// This method exists to enable support for additional build systems.  It is
-// not intended for use by clients of the API and we may change the format.
-func (p *Package) MarshalJSON() ([]byte, error) {
-	flat := &flatPackage{
-		ID:              p.ID,
-		Name:            p.Name,
-		PkgPath:         p.PkgPath,
-		Errors:          p.Errors,
-		GoFiles:         p.GoFiles,
-		CompiledGoFiles: p.CompiledGoFiles,
-		OtherFiles:      p.OtherFiles,
-		EmbedFiles:      p.EmbedFiles,
-		EmbedPatterns:   p.EmbedPatterns,
-		IgnoredFiles:    p.IgnoredFiles,
-		ExportFile:      p.ExportFile,
-	}
-	if len(p.Imports) > 0 {
-		flat.Imports = make(map[string]string, len(p.Imports))
-		for path, ipkg := range p.Imports {
-			flat.Imports[path] = ipkg.ID
-		}
-	}
-	return json.Marshal(flat)
-}
-
-// UnmarshalJSON reads in a Package from its JSON format.
-// See MarshalJSON for details about the format accepted.
-func (p *Package) UnmarshalJSON(b []byte) error {
-	flat := &flatPackage{}
-	if err := json.Unmarshal(b, &flat); err != nil {
-		return err
-	}
-	*p = Package{
-		ID:              flat.ID,
-		Name:            flat.Name,
-		PkgPath:         flat.PkgPath,
-		Errors:          flat.Errors,
-		GoFiles:         flat.GoFiles,
-		CompiledGoFiles: flat.CompiledGoFiles,
-		OtherFiles:      flat.OtherFiles,
-		EmbedFiles:      flat.EmbedFiles,
-		EmbedPatterns:   flat.EmbedPatterns,
-		IgnoredFiles:    flat.IgnoredFiles,
-		ExportFile:      flat.ExportFile,
-	}
-	if len(flat.Imports) > 0 {
-		p.Imports = make(map[string]*Package, len(flat.Imports))
-		for path, id := range flat.Imports {
-			p.Imports[path] = &Package{ID: id}
-		}
-	}
-	return nil
-}
-
-func (p *Package) String() string { return p.ID }
-
-// loaderPackage augments Package with state used during the loading phase
-type loaderPackage struct {
-	*Package
-	importErrors    map[string]error // maps each bad import to its error
-	preds           []*loaderPackage // packages that import this one
-	unfinishedSuccs atomic.Int32     // number of direct imports not yet loaded
-	color           uint8            // for cycle detection
-	needsrc         bool             // load from source (Mode >= LoadTypes)
-	needtypes       bool             // type information is either requested or depended on
-	initial         bool             // package was matched by a pattern
-	goVersion       int              // minor version number of go command on PATH
-}
-
-// loader holds the working state of a single call to load.
-type loader struct {
-	pkgs map[string]*loaderPackage // keyed by Package.ID
-	Config
-	sizes          types.Sizes // non-nil if needed by mode
-	parseCache     map[string]*parseValue
-	parseCacheMu   sync.Mutex
-	exportMu       sync.Mutex // enforces mutual exclusion of exportdata operations
-	externalDriver bool       // true if an external GOPACKAGESDRIVER handled the request
-
-	// Config.Mode contains the implied mode (see impliedLoadMode).
-	// Implied mode contains all the fields we need the data for.
-	// In requestedMode there are the actually requested fields.
-	// We'll zero them out before returning packages to the user.
-	// This makes it easier for us to get the conditions where
-	// we need certain modes right.
-	requestedMode LoadMode
-}
-
-type parseValue struct {
-	f     *ast.File
-	err   error
-	ready chan struct{}
-}
-
-func newLoader(cfg *Config) *loader {
-	ld := &loader{
-		parseCache: map[string]*parseValue{},
-	}
-	if cfg != nil {
-		ld.Config = *cfg
-		// If the user has provided a logger, use it.
-		ld.Config.Logf = cfg.Logf
-	}
-	if ld.Config.Logf == nil {
-		// If the GOPACKAGESDEBUG environment variable is set to true,
-		// but the user has not provided a logger, default to log.Printf.
-		if debug {
-			ld.Config.Logf = log.Printf
-		} else {
-			ld.Config.Logf = func(format string, args ...any) {}
-		}
-	}
-	if ld.Config.Mode == 0 {
-		ld.Config.Mode = NeedName | NeedFiles | NeedCompiledGoFiles // Preserve zero behavior of Mode for backwards compatibility.
-	}
-	if ld.Config.Env == nil {
-		ld.Config.Env = os.Environ()
-	}
-	if ld.Context == nil {
-		ld.Context = context.Background()
-	}
-	if ld.Dir == "" {
-		if dir, err := os.Getwd(); err == nil {
-			ld.Dir = dir
-		}
-	}
-
-	// Save the actually requested fields. We'll zero them out before returning packages to the user.
-	ld.requestedMode = ld.Mode
-	ld.Mode = impliedLoadMode(ld.Mode)
-
-	if ld.Mode&(NeedSyntax|NeedTypes|NeedTypesInfo) != 0 {
-		if ld.Fset == nil {
-			ld.Fset = token.NewFileSet()
-		}
-
-		// ParseFile is required even in LoadTypes mode
-		// because we load source if export data is missing.
-		if ld.ParseFile == nil {
-			ld.ParseFile = func(fset *token.FileSet, filename string, src []byte) (*ast.File, error) {
-				// We implicitly promise to keep doing ast.Object resolution. :(
-				const mode = parser.AllErrors | parser.ParseComments
-				return parser.ParseFile(fset, filename, src, mode)
-			}
-		}
-	}
-
-	return ld
-}
-
-// refine connects the supplied packages into a graph and then adds type
-// and syntax information as requested by the LoadMode.
-func (ld *loader) refine(response *DriverResponse) ([]*Package, error) {
-	roots := response.Roots
-	rootMap := make(map[string]int, len(roots))
-	for i, root := range roots {
-		rootMap[root] = i
-	}
-	ld.pkgs = make(map[string]*loaderPackage)
-	// first pass, fixup and build the map and roots
-	var initial = make([]*loaderPackage, len(roots))
-	for _, pkg := range response.Packages {
-		rootIndex := -1
-		if i, found := rootMap[pkg.ID]; found {
-			rootIndex = i
-		}
-
-		// Overlays can invalidate export data.
-		// TODO(matloob): make this check fine-grained based on dependencies on overlaid files
-		exportDataInvalid := len(ld.Overlay) > 0 || pkg.ExportFile == "" && pkg.PkgPath != "unsafe"
-		// This package needs type information if the caller requested types and the package is
-		// either a root, or it's a non-root and the user requested dependencies ...
-		needtypes := (ld.Mode&(NeedTypes|NeedTypesInfo) != 0 && (rootIndex >= 0 || ld.Mode&NeedDeps != 0))
-		// This package needs source if the call requested source (or types info, which implies source)
-		// and the package is either a root, or itas a non- root and the user requested dependencies...
-		needsrc := ((ld.Mode&(NeedSyntax|NeedTypesInfo) != 0 && (rootIndex >= 0 || ld.Mode&NeedDeps != 0)) ||
-			// ... or if we need types and the exportData is invalid. We fall back to (incompletely)
-			// typechecking packages from source if they fail to compile.
-			(ld.Mode&(NeedTypes|NeedTypesInfo) != 0 && exportDataInvalid)) && pkg.PkgPath != "unsafe"
-		lpkg := &loaderPackage{
-			Package:   pkg,
-			needtypes: needtypes,
-			needsrc:   needsrc,
-			goVersion: response.GoVersion,
-		}
-		// Don't trust the driver to respond with duplicate-free
-		// package names (go.dev/issue/63822).
-		if _, ok := ld.pkgs[lpkg.ID]; ok {
-			return nil, fmt.Errorf("%s response contained duplicate packages for ID %q",
-				cond(ld.externalDriver, "go/packages driver", "go list"), lpkg.ID)
-		}
-		ld.pkgs[lpkg.ID] = lpkg
-		if rootIndex >= 0 {
-			initial[rootIndex] = lpkg
-			lpkg.initial = true
-		}
-	}
-	for i, root := range roots {
-		if initial[i] == nil {
-			return nil, fmt.Errorf("root package %v is missing", root)
-		}
-	}
-
-	// Materialize the import graph if it is needed (NeedImports),
-	// or if we'll be using loadPackages (Need{Syntax|Types|TypesInfo}).
-	var leaves []*loaderPackage // packages with no unfinished successors
-	if ld.Mode&(NeedImports|NeedSyntax|NeedTypes|NeedTypesInfo) != 0 {
-		const (
-			white = 0 // new
-			grey  = 1 // in progress
-			black = 2 // complete
-		)
-
-		// visit traverses the import graph, depth-first,
-		// and materializes the graph as Packages.Imports.
-		//
-		// Valid imports are saved in the Packages.Import map.
-		// Invalid imports (cycles and missing nodes) are saved in the importErrors map.
-		// Thus, even in the presence of both kinds of errors,
-		// the Import graph remains a DAG.
-		//
-		// visit returns whether the package needs src or has a transitive
-		// dependency on a package that does. These are the only packages
-		// for which we load source code.
-		var stack []*loaderPackage
-		var visit func(from, lpkg *loaderPackage) bool
-		visit = func(from, lpkg *loaderPackage) bool {
-			if lpkg.color == grey {
-				panic("internal error: grey node")
-			}
-			if lpkg.color == white {
-				lpkg.color = grey
-				stack = append(stack, lpkg) // push
-				stubs := lpkg.Imports       // the structure form has only stubs with the ID in the Imports
-				lpkg.Imports = make(map[string]*Package, len(stubs))
-				for importPath, ipkg := range stubs {
-					var importErr error
-					imp := ld.pkgs[ipkg.ID]
-					if imp == nil {
-						// (includes package "C" when DisableCgo)
-						importErr = fmt.Errorf("missing package: %q", ipkg.ID)
-					} else if imp.color == grey {
-						importErr = fmt.Errorf("import cycle: %s", stack)
-					}
-					if importErr != nil {
-						if lpkg.importErrors == nil {
-							lpkg.importErrors = make(map[string]error)
-						}
-						lpkg.importErrors[importPath] = importErr
-						continue
-					}
-
-					if visit(lpkg, imp) {
-						lpkg.needsrc = true
-					}
-					lpkg.Imports[importPath] = imp.Package
-				}
-
-				// -- postorder --
-
-				// Complete type information is required for the
-				// immediate dependencies of each source package.
-				if lpkg.needsrc && ld.Mode&NeedTypes != 0 {
-					for _, ipkg := range lpkg.Imports {
-						ld.pkgs[ipkg.ID].needtypes = true
-					}
-				}
-
-				// NeedTypeSizes causes TypeSizes to be set even
-				// on packages for which types aren't needed.
-				if ld.Mode&NeedTypesSizes != 0 {
-					lpkg.TypesSizes = ld.sizes
-				}
-
-				// Add packages with no imports directly to the queue of leaves.
-				if len(lpkg.Imports) == 0 {
-					leaves = append(leaves, lpkg)
-				}
-
-				stack = stack[:len(stack)-1] // pop
-				lpkg.color = black
-			}
-
-			// Add edge from predecessor.
-			if from != nil {
-				from.unfinishedSuccs.Add(+1) // incref
-				lpkg.preds = append(lpkg.preds, from)
-			}
-
-			return lpkg.needsrc
-		}
-
-		// For each initial package, create its import DAG.
-		for _, lpkg := range initial {
-			visit(nil, lpkg)
-		}
-
-	} else {
-		// !NeedImports: drop the stub (ID-only) import packages
-		// that we are not even going to try to resolve.
-		for _, lpkg := range initial {
-			lpkg.Imports = nil
-		}
-	}
-
-	// Load type data and syntax if needed, starting at
-	// the initial packages (roots of the import DAG).
-	if ld.Mode&(NeedSyntax|NeedTypes|NeedTypesInfo) != 0 {
-
-		// We avoid using g.SetLimit to limit concurrency as
-		// it makes g.Go stop accepting work, which prevents
-		// workers from enqeuing, and thus finishing, and thus
-		// allowing the group to make progress: deadlock.
-		//
-		// Instead we use the ioLimit and cpuLimit semaphores.
-		g, _ := errgroup.WithContext(ld.Context)
-
-		// enqueues adds a package to the type-checking queue.
-		// It must have no unfinished successors.
-		var enqueue func(*loaderPackage)
-		enqueue = func(lpkg *loaderPackage) {
-			g.Go(func() error {
-				// Parse and type-check.
-				ld.loadPackage(lpkg)
-
-				// Notify each waiting predecessor,
-				// and enqueue it when it becomes a leaf.
-				for _, pred := range lpkg.preds {
-					if pred.unfinishedSuccs.Add(-1) == 0 { // decref
-						enqueue(pred)
-					}
-				}
-
-				return nil
-			})
-		}
-
-		// Load leaves first, adding new packages
-		// to the queue as they become leaves.
-		for _, leaf := range leaves {
-			enqueue(leaf)
-		}
-
-		if err := g.Wait(); err != nil {
-			return nil, err // cancelled
-		}
-	}
-
-	// If the context is done, return its error and
-	// throw out [likely] incomplete packages.
-	if err := ld.Context.Err(); err != nil {
-		return nil, err
-	}
-
-	result := make([]*Package, len(initial))
-	for i, lpkg := range initial {
-		result[i] = lpkg.Package
-	}
-	for i := range ld.pkgs {
-		// Clear all unrequested fields,
-		// to catch programs that use more than they request.
-		if ld.requestedMode&NeedName == 0 {
-			ld.pkgs[i].Name = ""
-			ld.pkgs[i].PkgPath = ""
-		}
-		if ld.requestedMode&NeedFiles == 0 {
-			ld.pkgs[i].GoFiles = nil
-			ld.pkgs[i].OtherFiles = nil
-			ld.pkgs[i].IgnoredFiles = nil
-		}
-		if ld.requestedMode&NeedEmbedFiles == 0 {
-			ld.pkgs[i].EmbedFiles = nil
-		}
-		if ld.requestedMode&NeedEmbedPatterns == 0 {
-			ld.pkgs[i].EmbedPatterns = nil
-		}
-		if ld.requestedMode&NeedCompiledGoFiles == 0 {
-			ld.pkgs[i].CompiledGoFiles = nil
-		}
-		if ld.requestedMode&NeedImports == 0 {
-			ld.pkgs[i].Imports = nil
-		}
-		if ld.requestedMode&NeedExportFile == 0 {
-			ld.pkgs[i].ExportFile = ""
-		}
-		if ld.requestedMode&NeedTypes == 0 {
-			ld.pkgs[i].Types = nil
-			ld.pkgs[i].IllTyped = false
-		}
-		if ld.requestedMode&NeedSyntax == 0 {
-			ld.pkgs[i].Syntax = nil
-		}
-		if ld.requestedMode&(NeedSyntax|NeedTypes|NeedTypesInfo) == 0 {
-			ld.pkgs[i].Fset = nil
-		}
-		if ld.requestedMode&NeedTypesInfo == 0 {
-			ld.pkgs[i].TypesInfo = nil
-		}
-		if ld.requestedMode&NeedTypesSizes == 0 {
-			ld.pkgs[i].TypesSizes = nil
-		}
-		if ld.requestedMode&NeedModule == 0 {
-			ld.pkgs[i].Module = nil
-		}
-	}
-
-	return result, nil
-}
-
-// loadPackage loads/parses/typechecks the specified package.
-// It must be called only once per Package,
-// after immediate dependencies are loaded.
-// Precondition: ld.Mode&(NeedSyntax|NeedTypes|NeedTypesInfo) != 0.
-func (ld *loader) loadPackage(lpkg *loaderPackage) {
-	if lpkg.PkgPath == "unsafe" {
-		// To avoid surprises, fill in the blanks consistent
-		// with other packages. (For example, some analyzers
-		// assert that each needed types.Info map is non-nil
-		// even when there is no syntax that would cause them
-		// to consult the map.)
-		lpkg.Types = types.Unsafe
-		lpkg.Fset = ld.Fset
-		lpkg.Syntax = []*ast.File{}
-		lpkg.TypesInfo = ld.newTypesInfo()
-		lpkg.TypesSizes = ld.sizes
-		return
-	}
-
-	// Call NewPackage directly with explicit name.
-	// This avoids skew between golist and go/types when the files'
-	// package declarations are inconsistent.
-	lpkg.Types = types.NewPackage(lpkg.PkgPath, lpkg.Name)
-	lpkg.Fset = ld.Fset
-
-	// Start shutting down if the context is done and do not load
-	// source or export data files.
-	// Packages that import this one will have ld.Context.Err() != nil.
-	// ld.Context.Err() will be returned later by refine.
-	if ld.Context.Err() != nil {
-		return
-	}
-
-	// Subtle: we populate all Types fields with an empty Package
-	// before loading export data so that export data processing
-	// never has to create a types.Package for an indirect dependency,
-	// which would then require that such created packages be explicitly
-	// inserted back into the Import graph as a final step after export data loading.
-	// (Hence this return is after the Types assignment.)
-	// The Diamond test exercises this case.
-	if !lpkg.needtypes && !lpkg.needsrc {
-		return
-	}
-
-	// TODO(adonovan): this condition looks wrong:
-	// I think it should be lpkg.needtypes && !lpkg.needsrc,
-	// so that NeedSyntax without NeedTypes can be satisfied by export data.
-	if !lpkg.needsrc {
-		if err := ld.loadFromExportData(lpkg); err != nil {
-			lpkg.exportDataError = err
-			lpkg.Errors = append(lpkg.Errors, Error{
-				Pos:  "-",
-				Msg:  err.Error(),
-				Kind: UnknownError, // e.g. can't find/open/parse export data
-			})
-		}
-		return // not a source package, don't get syntax trees
-	}
-
-	appendError := func(err error) {
-		// Convert various error types into the one true Error.
-		var errs []Error
-		switch err := err.(type) {
-		case Error:
-			// from driver
-			errs = append(errs, err)
-
-		case *os.PathError:
-			// from parser
-			errs = append(errs, Error{
-				Pos:  err.Path + ":1",
-				Msg:  err.Err.Error(),
-				Kind: ParseError,
-			})
-
-		case scanner.ErrorList:
-			// from parser
-			for _, err := range err {
-				errs = append(errs, Error{
-					Pos:  err.Pos.String(),
-					Msg:  err.Msg,
-					Kind: ParseError,
-				})
-			}
-
-		case types.Error:
-			// from type checker
-			lpkg.TypeErrors = append(lpkg.TypeErrors, err)
-			errs = append(errs, Error{
-				Pos:  err.Fset.Position(err.Pos).String(),
-				Msg:  err.Msg,
-				Kind: TypeError,
-			})
-
-		default:
-			// unexpected impoverished error from parser?
-			errs = append(errs, Error{
-				Pos:  "-",
-				Msg:  err.Error(),
-				Kind: UnknownError,
-			})
-
-			// If you see this error message, please file a bug.
-			log.Printf("internal error: error %q (%T) without position", err, err)
-		}
-
-		lpkg.Errors = append(lpkg.Errors, errs...)
-	}
-
-	// If the go command on the PATH is newer than the runtime,
-	// then the go/{scanner,ast,parser,types} packages from the
-	// standard library may be unable to process the files
-	// selected by go list.
-	//
-	// There is currently no way to downgrade the effective
-	// version of the go command (see issue 52078), so we proceed
-	// with the newer go command but, in case of parse or type
-	// errors, we emit an additional diagnostic.
-	//
-	// See:
-	// - golang.org/issue/52078 (flag to set release tags)
-	// - golang.org/issue/50825 (gopls legacy version support)
-	// - golang.org/issue/55883 (go/packages confusing error)
-	//
-	// Should we assert a hard minimum of (currently) go1.16 here?
-	var runtimeVersion int
-	if _, err := fmt.Sscanf(runtime.Version(), "go1.%d", &runtimeVersion); err == nil && runtimeVersion < lpkg.goVersion {
-		defer func() {
-			if len(lpkg.Errors) > 0 {
-				appendError(Error{
-					Pos:  "-",
-					Msg:  fmt.Sprintf("This application uses version go1.%d of the source-processing packages but runs version go1.%d of 'go list'. It may fail to process source files that rely on newer language features. If so, rebuild the application using a newer version of Go.", runtimeVersion, lpkg.goVersion),
-					Kind: UnknownError,
-				})
-			}
-		}()
-	}
-
-	if ld.Config.Mode&NeedTypes != 0 && len(lpkg.CompiledGoFiles) == 0 && lpkg.ExportFile != "" {
-		// The config requested loading sources and types, but sources are missing.
-		// Add an error to the package and fall back to loading from export data.
-		appendError(Error{"-", fmt.Sprintf("sources missing for package %s", lpkg.ID), ParseError})
-		_ = ld.loadFromExportData(lpkg) // ignore any secondary errors
-
-		return // can't get syntax trees for this package
-	}
-
-	files, errs := ld.parseFiles(lpkg.CompiledGoFiles)
-	for _, err := range errs {
-		appendError(err)
-	}
-
-	lpkg.Syntax = files
-	if ld.Config.Mode&(NeedTypes|NeedTypesInfo) == 0 {
-		return
-	}
-
-	// Start shutting down if the context is done and do not type check.
-	// Packages that import this one will have ld.Context.Err() != nil.
-	// ld.Context.Err() will be returned later by refine.
-	if ld.Context.Err() != nil {
-		return
-	}
-
-	lpkg.TypesInfo = ld.newTypesInfo()
-	lpkg.TypesSizes = ld.sizes
-
-	importer := importerFunc(func(path string) (*types.Package, error) {
-		if path == "unsafe" {
-			return types.Unsafe, nil
-		}
-
-		// The imports map is keyed by import path.
-		ipkg := lpkg.Imports[path]
-		if ipkg == nil {
-			if err := lpkg.importErrors[path]; err != nil {
-				return nil, err
-			}
-			// There was skew between the metadata and the
-			// import declarations, likely due to an edit
-			// race, or because the ParseFile feature was
-			// used to supply alternative file contents.
-			return nil, fmt.Errorf("no metadata for %s", path)
-		}
-
-		if ipkg.Types != nil && ipkg.Types.Complete() {
-			return ipkg.Types, nil
-		}
-
-		// If types are unavailable, there must be an export data error.
-		if ipkg.exportDataError != nil {
-			return nil, ipkg.exportDataError
-		}
-
-		log.Fatalf("internal error: expected complete types for package %q", path)
-		panic("unreachable")
-	})
-
-	// type-check
-	tc := &types.Config{
-		Importer: importer,
-
-		// Type-check bodies of functions only in initial packages.
-		// Example: for import graph A->B->C and initial packages {A,C},
-		// we can ignore function bodies in B.
-		IgnoreFuncBodies: ld.Mode&NeedDeps == 0 && !lpkg.initial,
-
-		Error: appendError,
-		Sizes: ld.sizes, // may be nil
-	}
-	if lpkg.Module != nil && lpkg.Module.GoVersion != "" {
-		tc.GoVersion = "go" + lpkg.Module.GoVersion
-	} else if ld.externalDriver && lpkg.goVersion != 0 {
-		// Module information is missing when GOPACKAGESDRIVER is used,
-		// so use the go version from the driver response.
-		tc.GoVersion = fmt.Sprintf("go1.%d", lpkg.goVersion)
-	}
-	if (ld.Mode & typecheckCgo) != 0 {
-		if !typesinternal.SetUsesCgo(tc) {
-			appendError(Error{
-				Msg:  "typecheckCgo requires Go 1.15+",
-				Kind: ListError,
-			})
-			return
-		}
-	}
-
-	// Type-checking is CPU intensive.
-	cpuLimit <- unit{}            // acquire a token
-	defer func() { <-cpuLimit }() // release a token
-
-	typErr := types.NewChecker(tc, ld.Fset, lpkg.Types, lpkg.TypesInfo).Files(lpkg.Syntax)
-	lpkg.importErrors = nil // no longer needed
-
-	// In go/types go1.21 and go1.22, Checker.Files failed fast with a
-	// a "too new" error, without calling tc.Error and without
-	// proceeding to type-check the package (#66525).
-	// We rely on the runtimeVersion error to give the suggested remedy.
-	if typErr != nil && len(lpkg.Errors) == 0 && len(lpkg.Syntax) > 0 {
-		if msg := typErr.Error(); strings.HasPrefix(msg, "package requires newer Go version") {
-			appendError(types.Error{
-				Fset: ld.Fset,
-				Pos:  lpkg.Syntax[0].Package,
-				Msg:  msg,
-			})
-		}
-	}
-
-	// If !Cgo, the type-checker uses FakeImportC mode, so
-	// it doesn't invoke the importer for import "C",
-	// nor report an error for the import,
-	// or for any undefined C.f reference.
-	// We must detect this explicitly and correctly
-	// mark the package as IllTyped (by reporting an error).
-	// TODO(adonovan): if these errors are annoying,
-	// we could just set IllTyped quietly.
-	if tc.FakeImportC {
-	outer:
-		for _, f := range lpkg.Syntax {
-			for _, imp := range f.Imports {
-				if imp.Path.Value == `"C"` {
-					err := types.Error{Fset: ld.Fset, Pos: imp.Pos(), Msg: `import "C" ignored`}
-					appendError(err)
-					break outer
-				}
-			}
-		}
-	}
-
-	// If types.Checker.Files had an error that was unreported,
-	// make sure to report the unknown error so the package is illTyped.
-	if typErr != nil && len(lpkg.Errors) == 0 {
-		appendError(typErr)
-	}
-
-	// Record accumulated errors.
-	illTyped := len(lpkg.Errors) > 0
-	if !illTyped {
-		for _, imp := range lpkg.Imports {
-			if imp.IllTyped {
-				illTyped = true
-				break
-			}
-		}
-	}
-	lpkg.IllTyped = illTyped
-}
-
-func (ld *loader) newTypesInfo() *types.Info {
-	// Populate TypesInfo only if needed, as it
-	// causes the type checker to work much harder.
-	if ld.Config.Mode&NeedTypesInfo == 0 {
-		return nil
-	}
-	return &types.Info{
-		Types:        make(map[ast.Expr]types.TypeAndValue),
-		Defs:         make(map[*ast.Ident]types.Object),
-		Uses:         make(map[*ast.Ident]types.Object),
-		Implicits:    make(map[ast.Node]types.Object),
-		Instances:    make(map[*ast.Ident]types.Instance),
-		Scopes:       make(map[ast.Node]*types.Scope),
-		Selections:   make(map[*ast.SelectorExpr]*types.Selection),
-		FileVersions: make(map[*ast.File]string),
-	}
-}
-
-// An importFunc is an implementation of the single-method
-// types.Importer interface based on a function value.
-type importerFunc func(path string) (*types.Package, error)
-
-func (f importerFunc) Import(path string) (*types.Package, error) { return f(path) }
-
-// We use a counting semaphore to limit
-// the number of parallel I/O calls or CPU threads per process.
-var (
-	ioLimit  = make(chan unit, 20)
-	cpuLimit = make(chan unit, runtime.GOMAXPROCS(0))
-)
-
-func (ld *loader) parseFile(filename string) (*ast.File, error) {
-	ld.parseCacheMu.Lock()
-	v, ok := ld.parseCache[filename]
-	if ok {
-		// cache hit
-		ld.parseCacheMu.Unlock()
-		<-v.ready
-	} else {
-		// cache miss
-		v = &parseValue{ready: make(chan struct{})}
-		ld.parseCache[filename] = v
-		ld.parseCacheMu.Unlock()
-
-		var src []byte
-		for f, contents := range ld.Config.Overlay {
-			// TODO(adonovan): Inefficient for large overlays.
-			// Do an exact name-based map lookup
-			// (for nonexistent files) followed by a
-			// FileID-based map lookup (for existing ones).
-			if sameFile(f, filename) {
-				src = contents
-				break
-			}
-		}
-		var err error
-		if src == nil {
-			ioLimit <- unit{} // acquire a token
-			src, err = os.ReadFile(filename)
-			<-ioLimit // release a token
-		}
-		if err != nil {
-			v.err = err
-		} else {
-			// Parsing is CPU intensive.
-			cpuLimit <- unit{} // acquire a token
-			v.f, v.err = ld.ParseFile(ld.Fset, filename, src)
-			<-cpuLimit // release a token
-		}
-
-		close(v.ready)
-	}
-	return v.f, v.err
-}
-
-// parseFiles reads and parses the Go source files and returns the ASTs
-// of the ones that could be at least partially parsed, along with a
-// list of I/O and parse errors encountered.
-//
-// Because files are scanned in parallel, the token.Pos
-// positions of the resulting ast.Files are not ordered.
-func (ld *loader) parseFiles(filenames []string) ([]*ast.File, []error) {
-	var (
-		n      = len(filenames)
-		parsed = make([]*ast.File, n)
-		errors = make([]error, n)
-	)
-	var g errgroup.Group
-	for i, filename := range filenames {
-		// This creates goroutines unnecessarily in the
-		// cache-hit case, but that case is uncommon.
-		g.Go(func() error {
-			parsed[i], errors[i] = ld.parseFile(filename)
-			return nil
-		})
-	}
-	g.Wait()
-
-	// Eliminate nils, preserving order.
-	var o int
-	for _, f := range parsed {
-		if f != nil {
-			parsed[o] = f
-			o++
-		}
-	}
-	parsed = parsed[:o]
-
-	o = 0
-	for _, err := range errors {
-		if err != nil {
-			errors[o] = err
-			o++
-		}
-	}
-	errors = errors[:o]
-
-	return parsed, errors
-}
-
-// sameFile returns true if x and y have the same basename and denote
-// the same file.
-func sameFile(x, y string) bool {
-	if x == y {
-		// It could be the case that y doesn't exist.
-		// For instance, it may be an overlay file that
-		// hasn't been written to disk. To handle that case
-		// let x == y through. (We added the exact absolute path
-		// string to the CompiledGoFiles list, so the unwritten
-		// overlay case implies x==y.)
-		return true
-	}
-	if strings.EqualFold(filepath.Base(x), filepath.Base(y)) { // (optimisation)
-		if xi, err := os.Stat(x); err == nil {
-			if yi, err := os.Stat(y); err == nil {
-				return os.SameFile(xi, yi)
-			}
-		}
-	}
-	return false
-}
-
-// loadFromExportData ensures that type information is present for the specified
-// package, loading it from an export data file on the first request.
-// On success it sets lpkg.Types to a new Package.
-func (ld *loader) loadFromExportData(lpkg *loaderPackage) error {
-	if lpkg.PkgPath == "" {
-		log.Fatalf("internal error: Package %s has no PkgPath", lpkg)
-	}
-
-	// Because gcexportdata.Read has the potential to create or
-	// modify the types.Package for each node in the transitive
-	// closure of dependencies of lpkg, all exportdata operations
-	// must be sequential. (Finer-grained locking would require
-	// changes to the gcexportdata API.)
-	//
-	// The exportMu lock guards the lpkg.Types field and the
-	// types.Package it points to, for each loaderPackage in the graph.
-	//
-	// Not all accesses to Package.Pkg need to be protected by exportMu:
-	// graph ordering ensures that direct dependencies of source
-	// packages are fully loaded before the importer reads their Pkg field.
-	ld.exportMu.Lock()
-	defer ld.exportMu.Unlock()
-
-	if tpkg := lpkg.Types; tpkg != nil && tpkg.Complete() {
-		return nil // cache hit
-	}
-
-	lpkg.IllTyped = true // fail safe
-
-	if lpkg.ExportFile == "" {
-		// Errors while building export data will have been printed to stderr.
-		return fmt.Errorf("no export data file")
-	}
-	f, err := os.Open(lpkg.ExportFile)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	// Read gc export data.
-	//
-	// We don't currently support gccgo export data because all
-	// underlying workspaces use the gc toolchain. (Even build
-	// systems that support gccgo don't use it for workspace
-	// queries.)
-	r, err := gcexportdata.NewReader(f)
-	if err != nil {
-		return fmt.Errorf("reading %s: %v", lpkg.ExportFile, err)
-	}
-
-	// Build the view.
-	//
-	// The gcexportdata machinery has no concept of package ID.
-	// It identifies packages by their PkgPath, which although not
-	// globally unique is unique within the scope of one invocation
-	// of the linker, type-checker, or gcexportdata.
-	//
-	// So, we must build a PkgPath-keyed view of the global
-	// (conceptually ID-keyed) cache of packages and pass it to
-	// gcexportdata. The view must contain every existing
-	// package that might possibly be mentioned by the
-	// current package---its transitive closure.
-	//
-	// In loadPackage, we unconditionally create a types.Package for
-	// each dependency so that export data loading does not
-	// create new ones.
-	//
-	// TODO(adonovan): it would be simpler and more efficient
-	// if the export data machinery invoked a callback to
-	// get-or-create a package instead of a map.
-	//
-	view := make(map[string]*types.Package) // view seen by gcexportdata
-	seen := make(map[*loaderPackage]bool)   // all visited packages
-	var visit func(pkgs map[string]*Package)
-	visit = func(pkgs map[string]*Package) {
-		for _, p := range pkgs {
-			lpkg := ld.pkgs[p.ID]
-			if !seen[lpkg] {
-				seen[lpkg] = true
-				view[lpkg.PkgPath] = lpkg.Types
-				visit(lpkg.Imports)
-			}
-		}
-	}
-	visit(lpkg.Imports)
-
-	viewLen := len(view) + 1 // adding the self package
-	// Parse the export data.
-	// (May modify incomplete packages in view but not create new ones.)
-	tpkg, err := gcexportdata.Read(r, ld.Fset, view, lpkg.PkgPath)
-	if err != nil {
-		return fmt.Errorf("reading %s: %v", lpkg.ExportFile, err)
-	}
-	if _, ok := view["go.shape"]; ok {
-		// Account for the pseudopackage "go.shape" that gets
-		// created by generic code.
-		viewLen++
-	}
-	if viewLen != len(view) {
-		log.Panicf("golang.org/x/tools/go/packages: unexpected new packages during load of %s", lpkg.PkgPath)
-	}
-
-	lpkg.Types = tpkg
-	lpkg.IllTyped = false
-	return nil
-}
-
-// impliedLoadMode returns loadMode with its dependencies.
-func impliedLoadMode(loadMode LoadMode) LoadMode {
-	if loadMode&(NeedDeps|NeedTypes|NeedTypesInfo) != 0 {
-		// All these things require knowing the import graph.
-		loadMode |= NeedImports
-	}
-	if loadMode&NeedTypes != 0 {
-		// Types require the GoVersion from Module.
-		loadMode |= NeedModule
-	}
-
-	return loadMode
-}
-
-func usesExportData(cfg *Config) bool {
-	return cfg.Mode&NeedExportFile != 0 || cfg.Mode&NeedTypes != 0 && cfg.Mode&NeedDeps == 0
-}
-
-type unit struct{}
-
-func cond[T any](cond bool, t, f T) T {
-	if cond {
-		return t
-	} else {
-		return f
-	}
-}
diff --git a/vendor/golang.org/x/tools/go/packages/visit.go b/vendor/golang.org/x/tools/go/packages/visit.go
deleted file mode 100644
index c546b1b63e..0000000000
--- a/vendor/golang.org/x/tools/go/packages/visit.go
+++ /dev/null
@@ -1,133 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package packages
-
-import (
-	"cmp"
-	"fmt"
-	"iter"
-	"os"
-	"slices"
-)
-
-// Visit visits all the packages in the import graph whose roots are
-// pkgs, calling the optional pre function the first time each package
-// is encountered (preorder), and the optional post function after a
-// package's dependencies have been visited (postorder).
-// The boolean result of pre(pkg) determines whether
-// the imports of package pkg are visited.
-//
-// Example:
-//
-//	pkgs, err := Load(...)
-//	if err != nil { ... }
-//	Visit(pkgs, nil, func(pkg *Package) {
-//		log.Println(pkg)
-//	})
-//
-// In most cases, it is more convenient to use [Postorder]:
-//
-//	for pkg := range Postorder(pkgs) {
-//		log.Println(pkg)
-//	}
-func Visit(pkgs []*Package, pre func(*Package) bool, post func(*Package)) {
-	seen := make(map[*Package]bool)
-	var visit func(*Package)
-	visit = func(pkg *Package) {
-		if !seen[pkg] {
-			seen[pkg] = true
-
-			if pre == nil || pre(pkg) {
-				for _, imp := range sorted(pkg.Imports) { // for determinism
-					visit(imp)
-				}
-			}
-
-			if post != nil {
-				post(pkg)
-			}
-		}
-	}
-	for _, pkg := range pkgs {
-		visit(pkg)
-	}
-}
-
-// PrintErrors prints to os.Stderr the accumulated errors of all
-// packages in the import graph rooted at pkgs, dependencies first.
-// PrintErrors returns the number of errors printed.
-func PrintErrors(pkgs []*Package) int {
-	var n int
-	errModules := make(map[*Module]bool)
-	for pkg := range Postorder(pkgs) {
-		for _, err := range pkg.Errors {
-			fmt.Fprintln(os.Stderr, err)
-			n++
-		}
-
-		// Print pkg.Module.Error once if present.
-		mod := pkg.Module
-		if mod != nil && mod.Error != nil && !errModules[mod] {
-			errModules[mod] = true
-			fmt.Fprintln(os.Stderr, mod.Error.Err)
-			n++
-		}
-	}
-	return n
-}
-
-// Postorder returns an iterator over the packages in
-// the import graph whose roots are pkg.
-// Packages are enumerated in dependencies-first order.
-func Postorder(pkgs []*Package) iter.Seq[*Package] {
-	return func(yield func(*Package) bool) {
-		seen := make(map[*Package]bool)
-		var visit func(*Package) bool
-		visit = func(pkg *Package) bool {
-			if !seen[pkg] {
-				seen[pkg] = true
-				for _, imp := range sorted(pkg.Imports) { // for determinism
-					if !visit(imp) {
-						return false
-					}
-				}
-				if !yield(pkg) {
-					return false
-				}
-			}
-			return true
-		}
-		for _, pkg := range pkgs {
-			if !visit(pkg) {
-				break
-			}
-		}
-	}
-}
-
-// -- copied from golang.org.x/tools/gopls/internal/util/moremaps --
-
-// sorted returns an iterator over the entries of m in key order.
-func sorted[M ~map[K]V, K cmp.Ordered, V any](m M) iter.Seq2[K, V] {
-	// TODO(adonovan): use maps.Sorted if proposal #68598 is accepted.
-	return func(yield func(K, V) bool) {
-		keys := keySlice(m)
-		slices.Sort(keys)
-		for _, k := range keys {
-			if !yield(k, m[k]) {
-				break
-			}
-		}
-	}
-}
-
-// KeySlice returns the keys of the map M, like slices.Collect(maps.Keys(m)).
-func keySlice[M ~map[K]V, K comparable, V any](m M) []K {
-	r := make([]K, 0, len(m))
-	for k := range m {
-		r = append(r, k)
-	}
-	return r
-}
diff --git a/vendor/golang.org/x/tools/go/types/objectpath/objectpath.go b/vendor/golang.org/x/tools/go/types/objectpath/objectpath.go
deleted file mode 100644
index 0d6d0bced0..0000000000
--- a/vendor/golang.org/x/tools/go/types/objectpath/objectpath.go
+++ /dev/null
@@ -1,945 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package objectpath defines a naming scheme for types.Objects
-// (that is, named entities in Go programs) relative to their enclosing
-// package.
-//
-// Type-checker objects are canonical, so they are usually identified by
-// their address in memory (a pointer), but a pointer has meaning only
-// within one address space. By contrast, objectpath names allow the
-// identity of an object to be sent from one program to another,
-// establishing a correspondence between types.Object variables that are
-// distinct but logically equivalent.
-//
-// A single object may have multiple paths. In this example,
-//
-//	type A struct{ X int }
-//	type B A
-//
-// the field X has two paths due to its membership of both A and B.
-// The For(obj) function always returns one of these paths, arbitrarily
-// but consistently.
-package objectpath
-
-import (
-	"encoding/binary"
-	"fmt"
-	"go/types"
-	"slices"
-	"strconv"
-	"strings"
-
-	"golang.org/x/tools/internal/typesinternal"
-)
-
-// TODO(adonovan): think about generic aliases.
-
-// A Path is an opaque name that identifies a types.Object
-// relative to its package. Conceptually, the name consists of a
-// sequence of destructuring operations applied to the package scope
-// to obtain the original object.
-// The name does not include the package itself.
-type Path string
-
-// Encoding
-//
-// An object path is a textual and (with training) human-readable encoding
-// of a sequence of destructuring operators, starting from a types.Package.
-// The sequences represent a path through the package/object/type graph.
-// We classify these operators by their type:
-//
-//	PO package->object	Package.Scope.Lookup
-//	OT  object->type 	Object.Type
-//	TT    type->type 	Type.{Elem,Key,{,{,Recv}Type}Params,Results,Underlying,Rhs} [EKPRUTrCa]
-//	TO   type->object	Type.{At,Field,Method,Obj} [AFMO]
-//
-// All valid paths start with a package and end at an object
-// and thus may be defined by the regular language:
-//
-//	objectpath = PO (OT TT* TO)*
-//
-// The concrete encoding follows directly:
-//   - The only PO operator is Package.Scope.Lookup, which requires an identifier.
-//   - The only OT operator is Object.Type,
-//     which we encode as '.' because dot cannot appear in an identifier.
-//   - The TT operators are encoded as [EKPRUTrCa];
-//     two of these ({,Recv}TypeParams) require an integer operand,
-//     which is encoded as a string of decimal digits.
-//   - The TO operators are encoded as [AFMO];
-//     three of these (At,Field,Method) require an integer operand,
-//     which is encoded as a string of decimal digits.
-//     These indices are stable across different representations
-//     of the same package, even source and export data.
-//     The indices used are implementation specific and may not correspond to
-//     the argument to the go/types function.
-//
-// In the example below,
-//
-//	package p
-//
-//	type T interface {
-//		f() (a string, b struct{ X int })
-//	}
-//
-// field X has the path "T.UM0.RA1.F0",
-// representing the following sequence of operations:
-//
-//	p.Lookup("T")					T
-//	.Type().Underlying().Method(0).			f
-//	.Type().Results().At(1)				b
-//	.Type().Field(0)					X
-//
-// The encoding is not maximally compact---every R or P is
-// followed by an A, for example---but this simplifies the
-// encoder and decoder.
-const (
-	// object->type operators
-	opType = '.' // .Type()		  (Object)
-
-	// type->type operators
-	opElem          = 'E' // .Elem()		(Pointer, Slice, Array, Chan, Map)
-	opKey           = 'K' // .Key()			(Map)
-	opParams        = 'P' // .Params()		(Signature)
-	opResults       = 'R' // .Results()		(Signature)
-	opUnderlying    = 'U' // .Underlying()		(Named)
-	opTypeParam     = 'T' // .TypeParams.At(i)	(Named, Signature)
-	opRecvTypeParam = 'r' // .RecvTypeParams.At(i)	(Signature)
-	opConstraint    = 'C' // .Constraint()		(TypeParam)
-	opRhs           = 'a' // .Rhs()			(Alias)
-
-	// type->object operators
-	opAt     = 'A' // .At(i)	(Tuple)
-	opField  = 'F' // .Field(i)	(Struct)
-	opMethod = 'M' // .Method(i)	(Named or Interface; not Struct: "promoted" names are ignored)
-	opObj    = 'O' // .Obj()	(Named, TypeParam)
-)
-
-// For is equivalent to new(Encoder).For(obj).
-//
-// It may be more efficient to reuse a single Encoder across several calls.
-func For(obj types.Object) (Path, error) {
-	return new(Encoder).For(obj)
-}
-
-// An Encoder amortizes the cost of encoding the paths of multiple objects.
-// The zero value of an Encoder is ready to use.
-type Encoder struct {
-	pkgIndex map[*types.Package]*pkgIndex
-}
-
-// A traversal encapsulates the state of a single traversal of the object/type graph.
-type traversal struct {
-	pkg *types.Package
-	ix  *pkgIndex // non-nil if we are building the index
-
-	target types.Object // the sought symbol (if ix == nil)
-	found  Path         // the found path    (if ix == nil)
-
-	// These maps are used to short circuit cycles through
-	// interface methods, such as occur in the following example:
-	//
-	//	type I interface { f() interface{I} }
-	//
-	// See golang/go#68046 for details.
-	seenTParamNames map[*types.TypeName]bool // global cycle breaking through type parameters
-	seenMethods     map[*types.Func]bool     // global cycle breaking through recursive interfaces
-}
-
-// A pkgIndex holds a compressed index of objectpaths of all symbols
-// (fields, methods, params) requiring search for an entire package.
-//
-// The first time a search for a given package is requested, we simply
-// traverse the type graph for the target object, maintaining the
-// current object path as a stack. If we find the target object, we
-// save the path and terminate the main loop (but it's not worth
-// breaking out of the current recursion).
-//
-// On the second search (a pkgIndex exists but its data is nil), we
-// build an index of the traversal, which we use for all subsequent
-// searches.
-//
-// The traversal index is encoded in the data field as a list of records,
-// one per node, in preorder. Records are of two types:
-//
-//   - A record for a package-level object consists of a pair
-//     (parent, nameIndex uvarint), where parent is zero and
-//     nameIndex is the index of the object's name in the sorted
-//     pkg.Scope().Names() slice.
-//
-//   - A record for a nested node (a segment of an object path)
-//     consists of (parent uvarint, op byte, index uvarint), where
-//     parent is the index of the record for the parent node,
-//     op is the destructuring operator, and index (if op = [AFMTr])
-//     is its integer operand.
-//
-// Since data[0] = 0 all nodes have positive offsets. In effect the
-// encoding is a trie in which each node stores one path segment
-// and points to the node for its prefix.
-//
-// TODO(adonovan): opt: evaluate an only 2-level tree with nodes for
-// package-level objects and the-rest-of-the-path. One calculation
-// suggested that it might be similar speed but 30% more compact.
-type pkgIndex struct {
-	pkg        *types.Package
-	data       []byte                  // encoding of traversal; nil if not yet constructed
-	scopeNames []string                // memo of pkg.Scope().Names() to avoid O(n) alloc/sort at lookup
-	offsets    map[types.Object]uint32 // each object's node offset within encoded traversal data
-}
-
-// For returns the path to an object relative to its package,
-// or an error if the object is not accessible from the package's Scope.
-//
-// The For function guarantees to return a path only for the following objects:
-// - package-level types
-// - exported package-level non-types
-// - methods
-// - parameter and result variables
-// - struct fields
-// These objects are sufficient to define the API of their package.
-// The objects described by a package's export data are drawn from this set.
-//
-// The set of objects accessible from a package's Scope depends on
-// whether the package was produced by type-checking syntax, or
-// reading export data; the latter may have a smaller Scope since
-// export data trims objects that are not reachable from an exported
-// declaration. For example, the For function will return a path for
-// an exported method of an unexported type that is not reachable
-// from any public declaration; this path will cause the Object
-// function to fail if called on a package loaded from export data.
-// TODO(adonovan): is this a bug or feature? Should this package
-// compute accessibility in the same way?
-//
-// For does not return a path for predeclared names, imported package
-// names, local names, and unexported package-level names (except
-// types).
-//
-// Example: given this definition,
-//
-//	package p
-//
-//	type T interface {
-//		f() (a string, b struct{ X int })
-//	}
-//
-// For(X) would return a path that denotes the following sequence of operations:
-//
-//	p.Scope().Lookup("T")				(TypeName T)
-//	.Type().Underlying().Method(0).			(method Func f)
-//	.Type().Results().At(1)				(field Var b)
-//	.Type().Field(0)					(field Var X)
-//
-// where p is the package (*types.Package) to which X belongs.
-func (enc *Encoder) For(obj types.Object) (Path, error) {
-	pkg := obj.Pkg()
-
-	// This table lists the cases of interest.
-	//
-	// Object				Action
-	// ------                               ------
-	// nil					reject
-	// builtin				reject
-	// pkgname				reject
-	// label				reject
-	// var
-	//    package-level			accept
-	//    func param/result			accept
-	//    local				reject
-	//    struct field			accept
-	// const
-	//    package-level			accept
-	//    local				reject
-	// func
-	//    package-level			accept
-	//    init functions			reject
-	//    concrete method			accept
-	//    interface method			accept
-	// type
-	//    package-level			accept
-	//    local				reject
-	//
-	// The only accessible package-level objects are members of pkg itself.
-	//
-	// The cases are handled in four steps:
-	//
-	// 1. reject nil and builtin
-	// 2. accept package-level objects
-	// 3. reject obviously invalid objects
-	// 4. search the API for the path to the param/result/field/method.
-
-	// 1. reference to nil or builtin?
-	if pkg == nil {
-		return "", fmt.Errorf("predeclared %s has no path", obj)
-	}
-
-	// 2. package-level object?
-	if pkg.Scope().Lookup(obj.Name()) == obj {
-		// Only exported objects (and non-exported types) have a path.
-		// Non-exported types may be referenced by other objects.
-		if _, ok := obj.(*types.TypeName); !ok && !obj.Exported() {
-			return "", fmt.Errorf("no path for non-exported %v", obj)
-		}
-		return Path(obj.Name()), nil
-	}
-
-	// 3. Not a package-level object.
-	//    Reject obviously non-viable cases.
-	switch obj := obj.(type) {
-	case *types.TypeName:
-		if _, ok := types.Unalias(obj.Type()).(*types.TypeParam); !ok {
-			// With the exception of type parameters, only package-level type names
-			// have a path.
-			return "", fmt.Errorf("no path for %v", obj)
-		}
-
-	case *types.Const, // Only package-level constants have a path.
-		*types.Label,   // Labels are function-local.
-		*types.PkgName: // PkgNames are file-local.
-		return "", fmt.Errorf("no path for %v", obj)
-
-	case *types.Var:
-		// A var, if not package-level, must be a
-		// parameter (incl. receiver) or result, or a struct field.
-		if obj.Kind() == types.LocalVar {
-			return "", fmt.Errorf("no path for local %v", obj)
-		}
-
-	case *types.Func:
-		// A func, if not package-level, must be a method.
-		if recv := obj.Signature().Recv(); recv == nil {
-			return "", fmt.Errorf("func is not a method: %v", obj)
-		}
-
-		if path, ok := enc.concreteMethod(obj); ok {
-			// Fast path for concrete methods that avoids looping over scope.
-			return path, nil
-		}
-
-	default:
-		panic(obj)
-	}
-
-	// 4. Search the object/type graph for the path to
-	//    the var (field/param/result) or method.
-	ix, ok := enc.pkgIndex[pkg]
-	if !ok {
-		// First search: don't build an index, just traverse.
-		// This avoids allocation in [For], whose Encoder
-		// lives for a single call.
-		ix = &pkgIndex{pkg: pkg}
-
-		if enc.pkgIndex == nil {
-			enc.pkgIndex = make(map[*types.Package]*pkgIndex)
-		}
-		enc.pkgIndex[pkg] = ix // build the index next time
-
-		f := traversal{pkg: pkg, target: obj}
-		f.traverse()
-
-		if f.found != "" {
-			return f.found, nil
-		}
-	} else {
-		// Second search: build an index while traversing.
-		if ix.data == nil {
-			ix.offsets = make(map[types.Object]uint32)
-			ix.data = []byte{0} // offset 0 is sentinel
-			(&traversal{pkg: pkg, ix: ix}).traverse()
-		}
-
-		// Second and later searches: consult the index.
-		if offset, ok := ix.offsets[obj]; ok {
-			return ix.path(offset), nil
-		}
-	}
-
-	return "", fmt.Errorf("can't find path for %v in %s", obj, pkg.Path())
-}
-
-// traverse performs a complete traversal of all symbols reachable from the package.
-func (tr *traversal) traverse() {
-	scope := tr.pkg.Scope()
-	names := scope.Names()
-	if tr.ix != nil {
-		tr.ix.scopeNames = names
-	}
-
-	empty := make([]byte, 0, 48) // initial space for stack (ix == nil)
-
-	// First inspect package-level type names.
-	// In the presence of path aliases, these give
-	// the best paths because non-types may
-	// refer to types, but not the reverse.
-	for i, name := range names {
-		if tr.found != "" {
-			return // found (ix == nil)
-		}
-
-		obj := scope.Lookup(name)
-		if _, ok := obj.(*types.TypeName); !ok {
-			continue // handle non-types in second pass
-		}
-
-		// emit (name, opType)
-		var path []byte
-		var offset uint32
-		if tr.ix == nil {
-			path = append(empty, name...)
-			path = append(path, opType)
-		} else {
-			offset = tr.ix.emitPackageLevel(i)
-			tr.ix.offsets[obj] = offset
-			offset = tr.ix.emitPathSegment(offset, opType, -1)
-		}
-
-		// A TypeName (for Named or Alias) may have type parameters.
-		switch t := obj.Type().(type) {
-		case *types.Alias:
-			tr.tparams(t.TypeParams(), path, offset, opTypeParam)
-			tr.typ(path, offset, opRhs, -1, t.Rhs())
-		case *types.Named:
-			tr.tparams(t.TypeParams(), path, offset, opTypeParam)
-			tr.typ(path, offset, opUnderlying, -1, t.Underlying())
-		}
-	}
-
-	// Then inspect everything else:
-	// exported non-types, and declared methods of defined types.
-	for i, name := range names {
-		if tr.found != "" {
-			return // found (ix == nil)
-		}
-
-		obj := scope.Lookup(name)
-
-		if tname, ok := obj.(*types.TypeName); !ok {
-			if obj.Exported() {
-				// exported non-type (const, var, func)
-				var path []byte
-				var offset uint32
-				if tr.ix == nil {
-					path = append(empty, name...)
-				} else {
-					offset = tr.ix.emitPackageLevel(i)
-					tr.ix.offsets[obj] = offset
-				}
-				tr.typ(path, offset, opType, -1, obj.Type())
-			}
-
-		} else if T, ok := types.Unalias(tname.Type()).(*types.Named); ok {
-			// defined type
-			var path []byte
-			var offset uint32
-			if tr.ix == nil {
-				path = append(empty, name...)
-				path = append(path, opType)
-			} else {
-				// Inv: map entry for obj was populated in first pass.
-				offset = tr.ix.emitPathSegment(tr.ix.offsets[obj], opType, -1)
-			}
-
-			// Inspect declared methods of defined types.
-			//
-			// The method index here is always with respect
-			// to the underlying go/types data structures,
-			// which ultimately derives from source order
-			// and must be preserved by export data.
-			for i := 0; i < T.NumMethods(); i++ {
-				m := T.Method(i)
-				tr.object(path, offset, opMethod, i, m)
-			}
-		}
-	}
-}
-
-func (tr *traversal) visitType(path []byte, offset uint32, T types.Type) {
-	switch T := T.(type) {
-	case *types.Alias:
-		tr.typ(path, offset, opRhs, -1, T.Rhs())
-
-	case *types.Basic, *types.Named:
-		// Named types belonging to pkg were handled already,
-		// so T must belong to another package. No path.
-		return
-
-	case *types.Pointer, *types.Slice, *types.Array, *types.Chan:
-		type hasElem interface{ Elem() types.Type } // note: includes Map
-		tr.typ(path, offset, opElem, -1, T.(hasElem).Elem())
-
-	case *types.Map:
-		tr.typ(path, offset, opKey, -1, T.Key())
-		tr.typ(path, offset, opElem, -1, T.Elem())
-
-	case *types.Signature:
-		tr.tparams(T.RecvTypeParams(), path, offset, opRecvTypeParam)
-		tr.tparams(T.TypeParams(), path, offset, opTypeParam)
-		tr.typ(path, offset, opParams, -1, T.Params())
-		tr.typ(path, offset, opResults, -1, T.Results())
-
-	case *types.Struct:
-		for i := 0; i < T.NumFields(); i++ {
-			tr.object(path, offset, opField, i, T.Field(i))
-		}
-
-	case *types.Tuple:
-		for i := 0; i < T.Len(); i++ {
-			tr.object(path, offset, opAt, i, T.At(i))
-		}
-
-	case *types.Interface:
-		for i := 0; i < T.NumMethods(); i++ {
-			m := T.Method(i)
-			if m.Pkg() != nil && m.Pkg() != tr.pkg {
-				continue // embedded method from another package
-			}
-			if !tr.seenMethods[m] {
-				if tr.seenMethods == nil {
-					tr.seenMethods = make(map[*types.Func]bool)
-				}
-				tr.seenMethods[m] = true
-				tr.object(path, offset, opMethod, i, m)
-			}
-		}
-
-	case *types.TypeParam:
-		tname := T.Obj()
-		if tname.Pkg() != nil && tname.Pkg() != tr.pkg {
-			return // type parameter from another package
-		}
-		if !tr.seenTParamNames[tname] {
-			if tr.seenTParamNames == nil {
-				tr.seenTParamNames = make(map[*types.TypeName]bool)
-			}
-			tr.seenTParamNames[tname] = true
-			tr.object(path, offset, opObj, -1, tname)
-			tr.typ(path, offset, opConstraint, -1, T.Constraint())
-		}
-	}
-}
-
-func (tr *traversal) tparams(list *types.TypeParamList, path []byte, offset uint32, op byte) {
-	for i := 0; i < list.Len(); i++ {
-		tr.typ(path, offset, op, i, list.At(i))
-	}
-}
-
-// typ descends the type graph edge (op, index), then proceeds to traverse type t.
-func (tr *traversal) typ(path []byte, offset uint32, op byte, index int, t types.Type) {
-	if tr.ix == nil {
-		path = appendOpArg(path, op, index)
-	} else {
-		offset = tr.ix.emitPathSegment(offset, op, index)
-	}
-	tr.visitType(path, offset, t)
-}
-
-// object descends the type graph edge (op, index), records object
-// obj, then proceeds to traverse its type.
-func (tr *traversal) object(path []byte, offset uint32, op byte, index int, obj types.Object) {
-	if tr.ix == nil {
-		path = appendOpArg(path, op, index)
-		if obj == tr.target && tr.found == "" {
-			tr.found = Path(path)
-		}
-		path = append(path, opType)
-	} else {
-		offset = tr.ix.emitPathSegment(offset, op, index)
-		if _, ok := tr.ix.offsets[obj]; !ok {
-			tr.ix.offsets[obj] = offset
-		}
-		offset = tr.ix.emitPathSegment(offset, opType, -1)
-	}
-	tr.visitType(path, offset, obj.Type())
-}
-
-// emitPackageLevel encodes a record for a package-level symbol,
-// identified by its index in ix.scopeNames.
-func (p *pkgIndex) emitPackageLevel(index int) uint32 {
-	off := uint32(len(p.data))
-	p.data = append(p.data, 0) // zero varint => no parent
-	p.data = binary.AppendUvarint(p.data, uint64(index))
-	return off
-}
-
-// emitPathSegment emits a record for a non-initial object path segment.
-func (p *pkgIndex) emitPathSegment(parent uint32, op byte, index int) uint32 {
-	off := uint32(len(p.data))
-	p.data = binary.AppendUvarint(p.data, uint64(parent))
-	p.data = append(p.data, op)
-	switch op {
-	case opAt, opField, opMethod, opTypeParam, opRecvTypeParam:
-		p.data = binary.AppendUvarint(p.data, uint64(index))
-	}
-	return off
-}
-
-// path returns the Path for the encoded node at the specified offset.
-func (p *pkgIndex) path(offset uint32) Path {
-	var elems []string // path elements in reverse
-	for {
-		// Read parent index.
-		parent, n := binary.Uvarint(p.data[offset:])
-		offset += uint32(n)
-
-		if parent == 0 {
-			break // root (end of path)
-		}
-
-		op := p.data[offset]
-		offset++
-
-		// The [AFMTr] operators have a numeric operand.
-		switch op {
-		case opAt, opField, opMethod, opTypeParam, opRecvTypeParam:
-			val, n := binary.Uvarint(p.data[offset:])
-			offset += uint32(n)
-			elems = append(elems, strconv.Itoa(int(val)))
-		}
-
-		elems = append(elems, string([]byte{op}))
-
-		offset = uint32(parent)
-	}
-	idx, _ := binary.Uvarint(p.data[offset:])
-
-	// Convert index to Path string.
-	name := p.scopeNames[idx]
-	sz := len(name)
-	for _, elem := range elems {
-		sz += len(elem)
-	}
-	var buf strings.Builder
-	buf.Grow(sz)
-	buf.WriteString(name)
-	for _, elem := range slices.Backward(elems) {
-		buf.WriteString(elem)
-	}
-	return Path(buf.String())
-}
-
-// appendOpArg appends (op, index) to the object path.
-// A negative index is ignored.
-func appendOpArg(path []byte, op byte, index int) []byte {
-	path = append(path, op)
-	if index >= 0 {
-		path = strconv.AppendInt(path, int64(index), 10)
-	}
-	return path
-}
-
-// concreteMethod returns the path for meth, which must have a non-nil receiver.
-// The second return value indicates success and may be false if the method is
-// an interface method or if it is an instantiated method.
-//
-// This function is just an optimization that avoids the general scope walking
-// approach. You are expected to fall back to the general approach if this
-// function fails.
-func (enc *Encoder) concreteMethod(meth *types.Func) (Path, bool) {
-	// Concrete methods can only be declared on package-scoped named types. For
-	// that reason we can skip the expensive walk over the package scope: the
-	// path will always be package -> named type -> method. We can trivially get
-	// the type name from the receiver, and only have to look over the type's
-	// methods to find the method index.
-	//
-	// Methods on generic types require special consideration, however. Consider
-	// the following package:
-	//
-	// 	L1: type S[T any] struct{}
-	// 	L2: func (recv S[A]) Foo() { recv.Bar() }
-	// 	L3: func (recv S[B]) Bar() { }
-	// 	L4: type Alias = S[int]
-	// 	L5: func _[T any]() { var s S[int]; s.Foo() }
-	//
-	// The receivers of methods on generic types are instantiations. L2 and L3
-	// instantiate S with the type-parameters A and B, which are scoped to the
-	// respective methods. L4 and L5 each instantiate S with int. Each of these
-	// instantiations has its own method set, full of methods (and thus objects)
-	// with receivers whose types are the respective instantiations. In other
-	// words, we have
-	//
-	// S[A].Foo, S[A].Bar
-	// S[B].Foo, S[B].Bar
-	// S[int].Foo, S[int].Bar
-	//
-	// We may thus be trying to produce object paths for any of these objects.
-	//
-	// S[A].Foo and S[B].Bar are the origin methods, and their paths are S.Foo
-	// and S.Bar, which are the paths that this function naturally produces.
-	//
-	// S[A].Bar, S[B].Foo, and both methods on S[int] are instantiations that
-	// don't correspond to the origin methods. For S[int], this is significant.
-	// The most precise object path for S[int].Foo, for example, is Alias.Foo,
-	// not S.Foo. Our function, however, would produce S.Foo, which would
-	// resolve to a different object.
-	//
-	// For S[A].Bar and S[B].Foo it could be argued that S.Bar and S.Foo are
-	// still the correct paths, since only the origin methods have meaningful
-	// paths. But this is likely only true for trivial cases and has edge cases.
-	// Since this function is only an optimization, we err on the side of giving
-	// up, deferring to the slower but definitely correct algorithm. Most users
-	// of objectpath will only be giving us origin methods, anyway, as referring
-	// to instantiated methods is usually not useful.
-
-	if meth.Origin() != meth {
-		return "", false
-	}
-
-	_, named := typesinternal.ReceiverNamed(meth.Signature().Recv())
-	if named == nil {
-		return "", false
-	}
-
-	if types.IsInterface(named) {
-		// Named interfaces don't have to be package-scoped
-		//
-		// TODO(dominikh): opt: if scope.Lookup(name) == named, then we can apply this optimization to interface
-		// methods, too, I think.
-		return "", false
-	}
-
-	// Preallocate space for the name, opType, opMethod, and some digits.
-	name := named.Obj().Name()
-	path := make([]byte, 0, len(name)+8)
-	path = append(path, name...)
-	path = append(path, opType)
-
-	// Method indices are w.r.t. the go/types data structures,
-	// ultimately deriving from source order,
-	// which is preserved by export data.
-	for i := 0; i < named.NumMethods(); i++ {
-		if named.Method(i) == meth {
-			path = appendOpArg(path, opMethod, i)
-			return Path(path), true
-		}
-	}
-
-	// Due to golang/go#59944, go/types fails to associate the receiver with
-	// certain methods on cgo types.
-	//
-	// TODO(rfindley): replace this panic once golang/go#59944 is fixed in all Go
-	// versions gopls supports.
-	return "", false
-	// panic(fmt.Sprintf("couldn't find method %s on type %s; methods: %#v", meth, named, enc.namedMethods(named)))
-}
-
-// Object returns the object denoted by path p within the package pkg.
-func Object(pkg *types.Package, p Path) (types.Object, error) {
-	pathstr := string(p)
-	if pathstr == "" {
-		return nil, fmt.Errorf("empty path")
-	}
-
-	var pkgobj, suffix string
-	if dot := strings.IndexByte(pathstr, opType); dot < 0 {
-		pkgobj = pathstr
-	} else {
-		pkgobj = pathstr[:dot]
-		suffix = pathstr[dot:] // suffix starts with "."
-	}
-
-	obj := pkg.Scope().Lookup(pkgobj)
-	if obj == nil {
-		return nil, fmt.Errorf("package %s does not contain %q", pkg.Path(), pkgobj)
-	}
-
-	// abstraction of *types.{Pointer,Slice,Array,Chan,Map}
-	type hasElem interface {
-		Elem() types.Type
-	}
-	// abstraction of *types.{Named,Signature}
-	type hasTypeParams interface {
-		TypeParams() *types.TypeParamList
-	}
-	// abstraction of *types.{Alias,Named,TypeParam}
-	type hasObj interface {
-		Obj() *types.TypeName
-	}
-
-	// The loop state is the pair (t, obj),
-	// exactly one of which is non-nil, initially obj.
-	// All suffixes start with '.' (the only object->type operation),
-	// followed by optional type->type operations,
-	// then a type->object operation.
-	// The cycle then repeats.
-	var t types.Type
-	for suffix != "" {
-		code := suffix[0]
-		suffix = suffix[1:]
-
-		// Codes [AFMTr] have an integer operand.
-		var index int
-		switch code {
-		case opAt, opField, opMethod, opTypeParam, opRecvTypeParam:
-			rest := strings.TrimLeft(suffix, "0123456789")
-			numerals := suffix[:len(suffix)-len(rest)]
-			suffix = rest
-			i, err := strconv.Atoi(numerals)
-			if err != nil {
-				return nil, fmt.Errorf("invalid path: bad numeric operand %q for code %q", numerals, code)
-			}
-			index = int(i)
-		case opObj:
-			// no operand
-		default:
-			// The suffix must end with a type->object operation.
-			if suffix == "" {
-				return nil, fmt.Errorf("invalid path: ends with %q, want [AFMO]", code)
-			}
-		}
-
-		if code == opType {
-			if t != nil {
-				return nil, fmt.Errorf("invalid path: unexpected %q in type context", opType)
-			}
-			t = obj.Type()
-			obj = nil
-			continue
-		}
-
-		if t == nil {
-			return nil, fmt.Errorf("invalid path: code %q in object context", code)
-		}
-
-		// Inv: t != nil, obj == nil
-
-		t = types.Unalias(t)
-		switch code {
-		case opElem:
-			hasElem, ok := t.(hasElem) // Pointer, Slice, Array, Chan, Map
-			if !ok {
-				return nil, fmt.Errorf("cannot apply %q to %s (got %T, want pointer, slice, array, chan or map)", code, t, t)
-			}
-			t = hasElem.Elem()
-
-		case opKey:
-			mapType, ok := t.(*types.Map)
-			if !ok {
-				return nil, fmt.Errorf("cannot apply %q to %s (got %T, want map)", code, t, t)
-			}
-			t = mapType.Key()
-
-		case opParams:
-			sig, ok := t.(*types.Signature)
-			if !ok {
-				return nil, fmt.Errorf("cannot apply %q to %s (got %T, want signature)", code, t, t)
-			}
-			t = sig.Params()
-
-		case opResults:
-			sig, ok := t.(*types.Signature)
-			if !ok {
-				return nil, fmt.Errorf("cannot apply %q to %s (got %T, want signature)", code, t, t)
-			}
-			t = sig.Results()
-
-		case opUnderlying:
-			named, ok := t.(*types.Named)
-			if !ok {
-				return nil, fmt.Errorf("cannot apply %q to %s (got %T, want named)", code, t, t)
-			}
-			t = named.Underlying()
-
-		case opRhs:
-			if alias, ok := t.(*types.Alias); ok {
-				t = alias.Rhs()
-			} else if false {
-				// Now that go1.24 is assured, we should be able to
-				// replace this with "if true {", but it causes objectpath
-				// tests to fail. TODO(adonovan): investigate.
-				return nil, fmt.Errorf("cannot apply %q to %s (got %T, want alias)", code, t, t)
-			}
-
-		case opTypeParam:
-			hasTypeParams, ok := t.(hasTypeParams) // Named, Signature
-			if !ok {
-				return nil, fmt.Errorf("cannot apply %q to %s (got %T, want named or signature)", code, t, t)
-			}
-			tparams := hasTypeParams.TypeParams()
-			if n := tparams.Len(); index >= n {
-				return nil, fmt.Errorf("type parameter index %d out of range [0-%d)", index, n)
-			}
-			t = tparams.At(index)
-
-		case opRecvTypeParam:
-			sig, ok := t.(*types.Signature) // Signature
-			if !ok {
-				return nil, fmt.Errorf("cannot apply %q to %s (got %T, want signature)", code, t, t)
-			}
-			rtparams := sig.RecvTypeParams()
-			if n := rtparams.Len(); index >= n {
-				return nil, fmt.Errorf("receiver type parameter index %d out of range [0-%d)", index, n)
-			}
-			t = rtparams.At(index)
-
-		case opConstraint:
-			tparam, ok := t.(*types.TypeParam)
-			if !ok {
-				return nil, fmt.Errorf("cannot apply %q to %s (got %T, want type parameter)", code, t, t)
-			}
-			t = tparam.Constraint()
-
-		case opAt:
-			tuple, ok := t.(*types.Tuple)
-			if !ok {
-				return nil, fmt.Errorf("cannot apply %q to %s (got %T, want tuple)", code, t, t)
-			}
-			if n := tuple.Len(); index >= n {
-				return nil, fmt.Errorf("tuple index %d out of range [0-%d)", index, n)
-			}
-			obj = tuple.At(index)
-			t = nil
-
-		case opField:
-			structType, ok := t.(*types.Struct)
-			if !ok {
-				return nil, fmt.Errorf("cannot apply %q to %s (got %T, want struct)", code, t, t)
-			}
-			if n := structType.NumFields(); index >= n {
-				return nil, fmt.Errorf("field index %d out of range [0-%d)", index, n)
-			}
-			obj = structType.Field(index)
-			t = nil
-
-		case opMethod:
-			switch t := t.(type) {
-			case *types.Interface:
-				if index >= t.NumMethods() {
-					return nil, fmt.Errorf("method index %d out of range [0-%d)", index, t.NumMethods())
-				}
-				obj = t.Method(index) // Id-ordered
-
-			case *types.Named:
-				if index >= t.NumMethods() {
-					return nil, fmt.Errorf("method index %d out of range [0-%d)", index, t.NumMethods())
-				}
-				obj = t.Method(index)
-
-			default:
-				return nil, fmt.Errorf("cannot apply %q to %s (got %T, want interface or named)", code, t, t)
-			}
-			t = nil
-
-		case opObj:
-			hasObj, ok := t.(hasObj)
-			if !ok {
-				return nil, fmt.Errorf("cannot apply %q to %s (got %T, want named or type param)", code, t, t)
-			}
-			obj = hasObj.Obj()
-			t = nil
-
-		default:
-			return nil, fmt.Errorf("invalid path: unknown code %q", code)
-		}
-	}
-
-	if obj == nil {
-		panic(p) // path does not end in an object-valued operator
-	}
-
-	if obj.Pkg() != pkg {
-		return nil, fmt.Errorf("path denotes %s, which belongs to a different package", obj)
-	}
-
-	return obj, nil // success
-}
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/callee.go b/vendor/golang.org/x/tools/go/types/typeutil/callee.go
deleted file mode 100644
index 3d24a8c637..0000000000
--- a/vendor/golang.org/x/tools/go/types/typeutil/callee.go
+++ /dev/null
@@ -1,86 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package typeutil
-
-import (
-	"go/ast"
-	"go/types"
-	_ "unsafe" // for linkname
-)
-
-// Callee returns the named target of a function call, if any:
-// a function, method, builtin, or variable.
-// It returns nil for a T(x) conversion.
-//
-// Functions and methods may potentially have type parameters.
-//
-// Note: for calls of instantiated functions and methods, Callee returns
-// the corresponding generic function or method on the generic type.
-func Callee(info *types.Info, call *ast.CallExpr) types.Object {
-	obj := info.Uses[usedIdent(info, call.Fun)]
-	if obj == nil {
-		return nil
-	}
-	if _, ok := obj.(*types.TypeName); ok {
-		return nil
-	}
-	return obj
-}
-
-// StaticCallee returns the target (function or method) of a static function
-// call, if any. It returns nil for calls to builtins.
-//
-// Note: for calls of instantiated functions and methods, StaticCallee returns
-// the corresponding generic function or method on the generic type.
-func StaticCallee(info *types.Info, call *ast.CallExpr) *types.Func {
-	obj := info.Uses[usedIdent(info, call.Fun)]
-	fn, _ := obj.(*types.Func)
-	if fn == nil || interfaceMethod(fn) {
-		return nil
-	}
-	return fn
-}
-
-// usedIdent is the implementation of [internal/typesinternal.UsedIdent].
-// It returns the identifier associated with e.
-// See typesinternal.UsedIdent for a fuller description.
-// This function should live in typesinternal, but cannot because it would
-// create an import cycle.
-//
-//go:linkname usedIdent golang.org/x/tools/go/types/typeutil.usedIdent
-func usedIdent(info *types.Info, e ast.Expr) *ast.Ident {
-	if info.Types == nil || info.Uses == nil {
-		panic("one of info.Types or info.Uses is nil; both must be populated")
-	}
-	// Look through type instantiation if necessary.
-	switch d := ast.Unparen(e).(type) {
-	case *ast.IndexExpr:
-		if info.Types[d.Index].IsType() {
-			e = d.X
-		}
-	case *ast.IndexListExpr:
-		e = d.X
-	}
-
-	switch e := ast.Unparen(e).(type) {
-	// info.Uses always has the object we want, even for selector expressions.
-	// We don't need info.Selections.
-	// See go/types/recording.go:recordSelection.
-	case *ast.Ident:
-		return e
-	case *ast.SelectorExpr:
-		return e.Sel
-	}
-	return nil
-}
-
-// interfaceMethod reports whether its argument is a method of an interface.
-// This function should live in typesinternal, but cannot because it would create an import cycle.
-//
-//go:linkname interfaceMethod golang.org/x/tools/go/types/typeutil.interfaceMethod
-func interfaceMethod(f *types.Func) bool {
-	recv := f.Signature().Recv()
-	return recv != nil && types.IsInterface(recv.Type())
-}
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/imports.go b/vendor/golang.org/x/tools/go/types/typeutil/imports.go
deleted file mode 100644
index b81ce0c330..0000000000
--- a/vendor/golang.org/x/tools/go/types/typeutil/imports.go
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package typeutil
-
-import "go/types"
-
-// Dependencies returns all dependencies of the specified packages.
-//
-// Dependent packages appear in topological order: if package P imports
-// package Q, Q appears earlier than P in the result.
-// The algorithm follows import statements in the order they
-// appear in the source code, so the result is a total order.
-func Dependencies(pkgs ...*types.Package) []*types.Package {
-	var result []*types.Package
-	seen := make(map[*types.Package]bool)
-	var visit func(pkgs []*types.Package)
-	visit = func(pkgs []*types.Package) {
-		for _, p := range pkgs {
-			if !seen[p] {
-				seen[p] = true
-				visit(p.Imports())
-				result = append(result, p)
-			}
-		}
-	}
-	visit(pkgs)
-	return result
-}
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/map.go b/vendor/golang.org/x/tools/go/types/typeutil/map.go
deleted file mode 100644
index 36624572a6..0000000000
--- a/vendor/golang.org/x/tools/go/types/typeutil/map.go
+++ /dev/null
@@ -1,459 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package typeutil defines various utilities for types, such as [Map],
-// a hash table that maps [types.Type] to any value.
-package typeutil
-
-import (
-	"bytes"
-	"fmt"
-	"go/types"
-	"hash/maphash"
-
-	"golang.org/x/tools/internal/typeparams"
-)
-
-// Map is a hash-table-based mapping from types (types.Type) to
-// arbitrary values.  The concrete types that implement
-// the Type interface are pointers.  Since they are not canonicalized,
-// == cannot be used to check for equivalence, and thus we cannot
-// simply use a Go map.
-//
-// Just as with map[K]V, a nil *Map is a valid empty map.
-//
-// Read-only map operations ([Map.At], [Map.Len], and so on) may
-// safely be called concurrently.
-//
-// TODO(adonovan): deprecate in favor of https://go.dev/issues/69420
-// and 69559, if the latter proposals for a generic hash-map type and
-// a types.Hash function are accepted.
-type Map struct {
-	table  map[uint32][]entry // maps hash to bucket; entry.key==nil means unused
-	length int                // number of map entries
-}
-
-// entry is an entry (key/value association) in a hash bucket.
-type entry struct {
-	key   types.Type
-	value any
-}
-
-// SetHasher has no effect.
-//
-// It is a relic of an optimization that is no longer profitable. Do
-// not use [Hasher], [MakeHasher], or [SetHasher] in new code.
-func (m *Map) SetHasher(Hasher) {}
-
-// Delete removes the entry with the given key, if any.
-// It returns true if the entry was found.
-func (m *Map) Delete(key types.Type) bool {
-	if m != nil && m.table != nil {
-		hash := hash(key)
-		bucket := m.table[hash]
-		for i, e := range bucket {
-			if e.key != nil && types.Identical(key, e.key) {
-				// We can't compact the bucket as it
-				// would disturb iterators.
-				bucket[i] = entry{}
-				m.length--
-				return true
-			}
-		}
-	}
-	return false
-}
-
-// At returns the map entry for the given key.
-// The result is nil if the entry is not present.
-func (m *Map) At(key types.Type) any {
-	if m != nil && m.table != nil {
-		for _, e := range m.table[hash(key)] {
-			if e.key != nil && types.Identical(key, e.key) {
-				return e.value
-			}
-		}
-	}
-	return nil
-}
-
-// Set sets the map entry for key to val,
-// and returns the previous entry, if any.
-func (m *Map) Set(key types.Type, value any) (prev any) {
-	if m.table != nil {
-		hash := hash(key)
-		bucket := m.table[hash]
-		var hole *entry
-		for i, e := range bucket {
-			if e.key == nil {
-				hole = &bucket[i]
-			} else if types.Identical(key, e.key) {
-				prev = e.value
-				bucket[i].value = value
-				return
-			}
-		}
-
-		if hole != nil {
-			*hole = entry{key, value} // overwrite deleted entry
-		} else {
-			m.table[hash] = append(bucket, entry{key, value})
-		}
-	} else {
-		hash := hash(key)
-		m.table = map[uint32][]entry{hash: {entry{key, value}}}
-	}
-
-	m.length++
-	return
-}
-
-// Len returns the number of map entries.
-func (m *Map) Len() int {
-	if m != nil {
-		return m.length
-	}
-	return 0
-}
-
-// Iterate calls function f on each entry in the map in unspecified order.
-//
-// If f should mutate the map, Iterate provides the same guarantees as
-// Go maps: if f deletes a map entry that Iterate has not yet reached,
-// f will not be invoked for it, but if f inserts a map entry that
-// Iterate has not yet reached, whether or not f will be invoked for
-// it is unspecified.
-func (m *Map) Iterate(f func(key types.Type, value any)) {
-	if m != nil {
-		for _, bucket := range m.table {
-			for _, e := range bucket {
-				if e.key != nil {
-					f(e.key, e.value)
-				}
-			}
-		}
-	}
-}
-
-// Keys returns a new slice containing the set of map keys.
-// The order is unspecified.
-func (m *Map) Keys() []types.Type {
-	keys := make([]types.Type, 0, m.Len())
-	m.Iterate(func(key types.Type, _ any) {
-		keys = append(keys, key)
-	})
-	return keys
-}
-
-func (m *Map) toString(values bool) string {
-	if m == nil {
-		return "{}"
-	}
-	var buf bytes.Buffer
-	fmt.Fprint(&buf, "{")
-	sep := ""
-	m.Iterate(func(key types.Type, value any) {
-		fmt.Fprint(&buf, sep)
-		sep = ", "
-		fmt.Fprint(&buf, key)
-		if values {
-			fmt.Fprintf(&buf, ": %q", value)
-		}
-	})
-	fmt.Fprint(&buf, "}")
-	return buf.String()
-}
-
-// String returns a string representation of the map's entries.
-// Values are printed using fmt.Sprintf("%v", v).
-// Order is unspecified.
-func (m *Map) String() string {
-	return m.toString(true)
-}
-
-// KeysString returns a string representation of the map's key set.
-// Order is unspecified.
-func (m *Map) KeysString() string {
-	return m.toString(false)
-}
-
-// -- Hasher --
-
-// hash returns the hash of type t.
-// TODO(adonovan): replace by types.Hash when Go proposal #69420 is accepted.
-func hash(t types.Type) uint32 {
-	return theHasher.Hash(t)
-}
-
-// A Hasher provides a [Hasher.Hash] method to map a type to its hash value.
-// Hashers are stateless, and all are equivalent.
-type Hasher struct{}
-
-var theHasher Hasher
-
-// MakeHasher returns Hasher{}.
-// Hashers are stateless; all are equivalent.
-func MakeHasher() Hasher { return theHasher }
-
-// Hash computes a hash value for the given type t such that
-// Identical(t, t') => Hash(t) == Hash(t').
-func (h Hasher) Hash(t types.Type) uint32 {
-	return hasher{inGenericSig: false}.hash(t)
-}
-
-// hasher holds the state of a single Hash traversal: whether we are
-// inside the signature of a generic function; this is used to
-// optimize [hasher.hashTypeParam].
-type hasher struct{ inGenericSig bool }
-
-// hashString computes the Fowler–Noll–Vo hash of s.
-func hashString(s string) uint32 {
-	var h uint32
-	for i := 0; i < len(s); i++ {
-		h ^= uint32(s[i])
-		h *= 16777619
-	}
-	return h
-}
-
-// hash computes the hash of t.
-func (h hasher) hash(t types.Type) uint32 {
-	// See Identical for rationale.
-	switch t := t.(type) {
-	case *types.Basic:
-		return uint32(t.Kind())
-
-	case *types.Alias:
-		return h.hash(types.Unalias(t))
-
-	case *types.Array:
-		return 9043 + 2*uint32(t.Len()) + 3*h.hash(t.Elem())
-
-	case *types.Slice:
-		return 9049 + 2*h.hash(t.Elem())
-
-	case *types.Struct:
-		var hash uint32 = 9059
-		for i, n := 0, t.NumFields(); i < n; i++ {
-			f := t.Field(i)
-			if f.Anonymous() {
-				hash += 8861
-			}
-			hash += hashString(t.Tag(i))
-			hash += hashString(f.Name()) // (ignore f.Pkg)
-			hash += h.hash(f.Type())
-		}
-		return hash
-
-	case *types.Pointer:
-		return 9067 + 2*h.hash(t.Elem())
-
-	case *types.Signature:
-		var hash uint32 = 9091
-		if t.Variadic() {
-			hash *= 8863
-		}
-
-		tparams := t.TypeParams()
-		if n := tparams.Len(); n > 0 {
-			h.inGenericSig = true // affects constraints, params, and results
-
-			for i := range n {
-				tparam := tparams.At(i)
-				hash += 7 * h.hash(tparam.Constraint())
-			}
-		}
-
-		return hash + 3*h.hashTuple(t.Params()) + 5*h.hashTuple(t.Results())
-
-	case *types.Union:
-		return h.hashUnion(t)
-
-	case *types.Interface:
-		// Interfaces are identical if they have the same set of methods, with
-		// identical names and types, and they have the same set of type
-		// restrictions. See go/types.identical for more details.
-		var hash uint32 = 9103
-
-		// Hash methods.
-		for i, n := 0, t.NumMethods(); i < n; i++ {
-			// Method order is not significant.
-			// Ignore m.Pkg().
-			m := t.Method(i)
-			// Use shallow hash on method signature to
-			// avoid anonymous interface cycles.
-			hash += 3*hashString(m.Name()) + 5*h.shallowHash(m.Type())
-		}
-
-		// Hash type restrictions.
-		terms, err := typeparams.InterfaceTermSet(t)
-		// if err != nil t has invalid type restrictions.
-		if err == nil {
-			hash += h.hashTermSet(terms)
-		}
-
-		return hash
-
-	case *types.Map:
-		return 9109 + 2*h.hash(t.Key()) + 3*h.hash(t.Elem())
-
-	case *types.Chan:
-		return 9127 + 2*uint32(t.Dir()) + 3*h.hash(t.Elem())
-
-	case *types.Named:
-		hash := h.hashTypeName(t.Obj())
-		targs := t.TypeArgs()
-		for targ := range targs.Types() {
-			hash += 2 * h.hash(targ)
-		}
-		return hash
-
-	case *types.TypeParam:
-		return h.hashTypeParam(t)
-
-	case *types.Tuple:
-		return h.hashTuple(t)
-	}
-
-	panic(fmt.Sprintf("%T: %v", t, t))
-}
-
-func (h hasher) hashTuple(tuple *types.Tuple) uint32 {
-	// See go/types.identicalTypes for rationale.
-	n := tuple.Len()
-	hash := 9137 + 2*uint32(n)
-	for i := range n {
-		hash += 3 * h.hash(tuple.At(i).Type())
-	}
-	return hash
-}
-
-func (h hasher) hashUnion(t *types.Union) uint32 {
-	// Hash type restrictions.
-	terms, err := typeparams.UnionTermSet(t)
-	// if err != nil t has invalid type restrictions. Fall back on a non-zero
-	// hash.
-	if err != nil {
-		return 9151
-	}
-	return h.hashTermSet(terms)
-}
-
-func (h hasher) hashTermSet(terms []*types.Term) uint32 {
-	hash := 9157 + 2*uint32(len(terms))
-	for _, term := range terms {
-		// term order is not significant.
-		termHash := h.hash(term.Type())
-		if term.Tilde() {
-			termHash *= 9161
-		}
-		hash += 3 * termHash
-	}
-	return hash
-}
-
-// hashTypeParam returns the hash of a type parameter.
-func (h hasher) hashTypeParam(t *types.TypeParam) uint32 {
-	// Within the signature of a generic function, TypeParams are
-	// identical if they have the same index and constraint, so we
-	// hash them based on index.
-	//
-	// When we are outside a generic function, free TypeParams are
-	// identical iff they are the same object, so we can use a
-	// more discriminating hash consistent with object identity.
-	// This optimization saves [Map] about 4% when hashing all the
-	// types.Info.Types in the forward closure of net/http.
-	if !h.inGenericSig {
-		// Optimization: outside a generic function signature,
-		// use a more discrimating hash consistent with object identity.
-		return h.hashTypeName(t.Obj())
-	}
-	return 9173 + 3*uint32(t.Index())
-}
-
-var theSeed = maphash.MakeSeed()
-
-// hashTypeName hashes the pointer of tname.
-func (hasher) hashTypeName(tname *types.TypeName) uint32 {
-	// Since types.Identical uses == to compare TypeNames,
-	// the Hash function uses maphash.Comparable.
-	hash := maphash.Comparable(theSeed, tname)
-	return uint32(hash ^ (hash >> 32))
-}
-
-// shallowHash computes a hash of t without looking at any of its
-// element Types, to avoid potential anonymous cycles in the types of
-// interface methods.
-//
-// When an unnamed non-empty interface type appears anywhere among the
-// arguments or results of an interface method, there is a potential
-// for endless recursion. Consider:
-//
-//	type X interface { m() []*interface { X } }
-//
-// The problem is that the Methods of the interface in m's result type
-// include m itself; there is no mention of the named type X that
-// might help us break the cycle.
-// (See comment in go/types.identical, case *Interface, for more.)
-func (h hasher) shallowHash(t types.Type) uint32 {
-	// t is the type of an interface method (Signature),
-	// its params or results (Tuples), or their immediate
-	// elements (mostly Slice, Pointer, Basic, Named),
-	// so there's no need to optimize anything else.
-	switch t := t.(type) {
-	case *types.Alias:
-		return h.shallowHash(types.Unalias(t))
-
-	case *types.Signature:
-		var hash uint32 = 604171
-		if t.Variadic() {
-			hash *= 971767
-		}
-		// The Signature/Tuple recursion is always finite
-		// and invariably shallow.
-		return hash + 1062599*h.shallowHash(t.Params()) + 1282529*h.shallowHash(t.Results())
-
-	case *types.Tuple:
-		n := t.Len()
-		hash := 9137 + 2*uint32(n)
-		for i := range n {
-			hash += 53471161 * h.shallowHash(t.At(i).Type())
-		}
-		return hash
-
-	case *types.Basic:
-		return 45212177 * uint32(t.Kind())
-
-	case *types.Array:
-		return 1524181 + 2*uint32(t.Len())
-
-	case *types.Slice:
-		return 2690201
-
-	case *types.Struct:
-		return 3326489
-
-	case *types.Pointer:
-		return 4393139
-
-	case *types.Union:
-		return 562448657
-
-	case *types.Interface:
-		return 2124679 // no recursion here
-
-	case *types.Map:
-		return 9109
-
-	case *types.Chan:
-		return 9127
-
-	case *types.Named:
-		return h.hashTypeName(t.Obj())
-
-	case *types.TypeParam:
-		return h.hashTypeParam(t)
-	}
-	panic(fmt.Sprintf("shallowHash: %T: %v", t, t))
-}
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/methodsetcache.go b/vendor/golang.org/x/tools/go/types/typeutil/methodsetcache.go
deleted file mode 100644
index f7666028fe..0000000000
--- a/vendor/golang.org/x/tools/go/types/typeutil/methodsetcache.go
+++ /dev/null
@@ -1,71 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements a cache of method sets.
-
-package typeutil
-
-import (
-	"go/types"
-	"sync"
-)
-
-// A MethodSetCache records the method set of each type T for which
-// MethodSet(T) is called so that repeat queries are fast.
-// The zero value is a ready-to-use cache instance.
-type MethodSetCache struct {
-	mu     sync.Mutex
-	named  map[*types.Named]struct{ value, pointer *types.MethodSet } // method sets for named N and *N
-	others map[types.Type]*types.MethodSet                            // all other types
-}
-
-// MethodSet returns the method set of type T.  It is thread-safe.
-//
-// If cache is nil, this function is equivalent to types.NewMethodSet(T).
-// Utility functions can thus expose an optional *MethodSetCache
-// parameter to clients that care about performance.
-func (cache *MethodSetCache) MethodSet(T types.Type) *types.MethodSet {
-	if cache == nil {
-		return types.NewMethodSet(T)
-	}
-	cache.mu.Lock()
-	defer cache.mu.Unlock()
-
-	switch T := types.Unalias(T).(type) {
-	case *types.Named:
-		return cache.lookupNamed(T).value
-
-	case *types.Pointer:
-		if N, ok := types.Unalias(T.Elem()).(*types.Named); ok {
-			return cache.lookupNamed(N).pointer
-		}
-	}
-
-	// all other types
-	// (The map uses pointer equivalence, not type identity.)
-	mset := cache.others[T]
-	if mset == nil {
-		mset = types.NewMethodSet(T)
-		if cache.others == nil {
-			cache.others = make(map[types.Type]*types.MethodSet)
-		}
-		cache.others[T] = mset
-	}
-	return mset
-}
-
-func (cache *MethodSetCache) lookupNamed(named *types.Named) struct{ value, pointer *types.MethodSet } {
-	if cache.named == nil {
-		cache.named = make(map[*types.Named]struct{ value, pointer *types.MethodSet })
-	}
-	// Avoid recomputing mset(*T) for each distinct Pointer
-	// instance whose underlying type is a named type.
-	msets, ok := cache.named[named]
-	if !ok {
-		msets.value = types.NewMethodSet(named)
-		msets.pointer = types.NewMethodSet(types.NewPointer(named))
-		cache.named[named] = msets
-	}
-	return msets
-}
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/ui.go b/vendor/golang.org/x/tools/go/types/typeutil/ui.go
deleted file mode 100644
index 9dda6a25df..0000000000
--- a/vendor/golang.org/x/tools/go/types/typeutil/ui.go
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package typeutil
-
-// This file defines utilities for user interfaces that display types.
-
-import (
-	"go/types"
-)
-
-// IntuitiveMethodSet returns the intuitive method set of a type T,
-// which is the set of methods you can call on an addressable value of
-// that type.
-//
-// The result always contains MethodSet(T), and is exactly MethodSet(T)
-// for interface types and for pointer-to-concrete types.
-// For all other concrete types T, the result additionally
-// contains each method belonging to *T if there is no identically
-// named method on T itself.
-//
-// This corresponds to user intuition about method sets;
-// this function is intended only for user interfaces.
-//
-// The order of the result is as for types.MethodSet(T).
-func IntuitiveMethodSet(T types.Type, msets *MethodSetCache) []*types.Selection {
-	isPointerToConcrete := func(T types.Type) bool {
-		ptr, ok := types.Unalias(T).(*types.Pointer)
-		return ok && !types.IsInterface(ptr.Elem())
-	}
-
-	var result []*types.Selection
-	mset := msets.MethodSet(T)
-	if types.IsInterface(T) || isPointerToConcrete(T) {
-		for i, n := 0, mset.Len(); i < n; i++ {
-			result = append(result, mset.At(i))
-		}
-	} else {
-		// T is some other concrete type.
-		// Report methods of T and *T, preferring those of T.
-		pmset := msets.MethodSet(types.NewPointer(T))
-		for i, n := 0, pmset.Len(); i < n; i++ {
-			meth := pmset.At(i)
-			if m := mset.Lookup(meth.Obj().Pkg(), meth.Obj().Name()); m != nil {
-				meth = m
-			}
-			result = append(result, meth)
-		}
-
-	}
-	return result
-}
diff --git a/vendor/golang.org/x/tools/internal/aliases/aliases.go b/vendor/golang.org/x/tools/internal/aliases/aliases.go
deleted file mode 100644
index a4ae04bc71..0000000000
--- a/vendor/golang.org/x/tools/internal/aliases/aliases.go
+++ /dev/null
@@ -1,18 +0,0 @@
-// Copyright 2024 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package aliases
-
-import (
-	"go/token"
-	"go/types"
-)
-
-// New creates a new TypeName in Package pkg that
-// is an alias for the type rhs.
-func New(pos token.Pos, pkg *types.Package, name string, rhs types.Type, tparams []*types.TypeParam) *types.TypeName {
-	tname := types.NewTypeName(pos, pkg, name, nil)
-	types.NewAlias(tname, rhs).SetTypeParams(tparams)
-	return tname
-}
diff --git a/vendor/golang.org/x/tools/internal/event/core/event.go b/vendor/golang.org/x/tools/internal/event/core/event.go
deleted file mode 100644
index 42c218818a..0000000000
--- a/vendor/golang.org/x/tools/internal/event/core/event.go
+++ /dev/null
@@ -1,95 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package core provides support for event based telemetry.
-package core
-
-import (
-	"fmt"
-	"iter"
-	"time"
-
-	"golang.org/x/tools/internal/event/label"
-)
-
-// Event holds the information about an event of note that occurred.
-type Event struct {
-	at time.Time
-
-	// As events are often on the stack, storing the first few labels directly
-	// in the event can avoid an allocation at all for the very common cases of
-	// simple events.
-	// The length needs to be large enough to cope with the majority of events
-	// but no so large as to cause undue stack pressure.
-	// A log message with two values will use 3 labels (one for each value and
-	// one for the message itself).
-
-	static  [3]label.Label // inline storage for the first few labels
-	dynamic []label.Label  // dynamically sized storage for remaining labels
-}
-
-func (ev Event) At() time.Time { return ev.at }
-
-func (ev Event) Format(f fmt.State, r rune) {
-	if !ev.at.IsZero() {
-		fmt.Fprint(f, ev.at.Format("2006/01/02 15:04:05 "))
-	}
-	for l := range ev.Labels() {
-		fmt.Fprintf(f, "\n\t%v", l)
-	}
-}
-
-func (ev Event) Valid(index int) bool {
-	return index >= 0 && index < len(ev.static)+len(ev.dynamic)
-}
-
-func (ev Event) Label(index int) label.Label {
-	if index < len(ev.static) {
-		return ev.static[index]
-	}
-	return ev.dynamic[index-len(ev.static)]
-}
-
-// Labels returns an iterator over the event's valid labels.
-func (ev Event) Labels() iter.Seq[label.Label] {
-	return func(yield func(label.Label) bool) {
-		for _, l := range ev.static {
-			if l.Valid() && !yield(l) {
-				return
-			}
-		}
-		for _, l := range ev.dynamic {
-			if l.Valid() && !yield(l) {
-				return
-			}
-		}
-	}
-}
-
-func (ev Event) Find(key label.Key) label.Label {
-	for _, l := range ev.static {
-		if l.Key() == key {
-			return l
-		}
-	}
-	for _, l := range ev.dynamic {
-		if l.Key() == key {
-			return l
-		}
-	}
-	return label.Label{}
-}
-
-func MakeEvent(static [3]label.Label, labels []label.Label) Event {
-	return Event{
-		static:  static,
-		dynamic: labels,
-	}
-}
-
-// CloneEvent event returns a copy of the event with the time adjusted to at.
-func CloneEvent(ev Event, at time.Time) Event {
-	ev.at = at
-	return ev
-}
diff --git a/vendor/golang.org/x/tools/internal/event/core/export.go b/vendor/golang.org/x/tools/internal/event/core/export.go
deleted file mode 100644
index 16ae6bb021..0000000000
--- a/vendor/golang.org/x/tools/internal/event/core/export.go
+++ /dev/null
@@ -1,67 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package core
-
-import (
-	"context"
-	"sync/atomic"
-	"time"
-
-	"golang.org/x/tools/internal/event/label"
-)
-
-// Exporter is a function that handles events.
-// It may return a modified context and event.
-type Exporter func(context.Context, Event, label.Map) context.Context
-
-var exporter atomic.Pointer[Exporter]
-
-// SetExporter sets the global exporter function that handles all events.
-// The exporter is called synchronously from the event call site, so it should
-// return quickly so as not to hold up user code.
-func SetExporter(e Exporter) {
-	if e == nil {
-		// &e is always valid, and so p is always valid, but for the early abort
-		// of ProcessEvent to be efficient it needs to make the nil check on the
-		// pointer without having to dereference it, so we make the nil function
-		// also a nil pointer
-		exporter.Store(nil)
-	} else {
-		exporter.Store(&e)
-	}
-}
-
-// deliver is called to deliver an event to the supplied exporter.
-// it will fill in the time.
-func deliver(ctx context.Context, exporter Exporter, ev Event) context.Context {
-	// add the current time to the event
-	ev.at = time.Now()
-	// hand the event off to the current exporter
-	return exporter(ctx, ev, ev)
-}
-
-// Export is called to deliver an event to the global exporter if set.
-func Export(ctx context.Context, ev Event) context.Context {
-	// get the global exporter and abort early if there is not one
-	exporterPtr := exporter.Load()
-	if exporterPtr == nil {
-		return ctx
-	}
-	return deliver(ctx, *exporterPtr, ev)
-}
-
-// ExportPair is called to deliver a start event to the supplied exporter.
-// It also returns a function that will deliver the end event to the same
-// exporter.
-// It will fill in the time.
-func ExportPair(ctx context.Context, begin, end Event) (context.Context, func()) {
-	// get the global exporter and abort early if there is not one
-	exporterPtr := exporter.Load()
-	if exporterPtr == nil {
-		return ctx, func() {}
-	}
-	ctx = deliver(ctx, *exporterPtr, begin)
-	return ctx, func() { deliver(ctx, *exporterPtr, end) }
-}
diff --git a/vendor/golang.org/x/tools/internal/event/core/fast.go b/vendor/golang.org/x/tools/internal/event/core/fast.go
deleted file mode 100644
index 06c1d4615e..0000000000
--- a/vendor/golang.org/x/tools/internal/event/core/fast.go
+++ /dev/null
@@ -1,77 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package core
-
-import (
-	"context"
-
-	"golang.org/x/tools/internal/event/keys"
-	"golang.org/x/tools/internal/event/label"
-)
-
-// Log1 takes a message and one label delivers a log event to the exporter.
-// It is a customized version of Print that is faster and does no allocation.
-func Log1(ctx context.Context, message string, t1 label.Label) {
-	Export(ctx, MakeEvent([3]label.Label{
-		keys.Msg.Of(message),
-		t1,
-	}, nil))
-}
-
-// Log2 takes a message and two labels and delivers a log event to the exporter.
-// It is a customized version of Print that is faster and does no allocation.
-func Log2(ctx context.Context, message string, t1 label.Label, t2 label.Label) {
-	Export(ctx, MakeEvent([3]label.Label{
-		keys.Msg.Of(message),
-		t1,
-		t2,
-	}, nil))
-}
-
-// Metric1 sends a label event to the exporter with the supplied labels.
-func Metric1(ctx context.Context, t1 label.Label) context.Context {
-	return Export(ctx, MakeEvent([3]label.Label{
-		keys.Metric.New(),
-		t1,
-	}, nil))
-}
-
-// Metric2 sends a label event to the exporter with the supplied labels.
-func Metric2(ctx context.Context, t1, t2 label.Label) context.Context {
-	return Export(ctx, MakeEvent([3]label.Label{
-		keys.Metric.New(),
-		t1,
-		t2,
-	}, nil))
-}
-
-// Start1 sends a span start event with the supplied label list to the exporter.
-// It also returns a function that will end the span, which should normally be
-// deferred.
-func Start1(ctx context.Context, name string, t1 label.Label) (context.Context, func()) {
-	return ExportPair(ctx,
-		MakeEvent([3]label.Label{
-			keys.Start.Of(name),
-			t1,
-		}, nil),
-		MakeEvent([3]label.Label{
-			keys.End.New(),
-		}, nil))
-}
-
-// Start2 sends a span start event with the supplied label list to the exporter.
-// It also returns a function that will end the span, which should normally be
-// deferred.
-func Start2(ctx context.Context, name string, t1, t2 label.Label) (context.Context, func()) {
-	return ExportPair(ctx,
-		MakeEvent([3]label.Label{
-			keys.Start.Of(name),
-			t1,
-			t2,
-		}, nil),
-		MakeEvent([3]label.Label{
-			keys.End.New(),
-		}, nil))
-}
diff --git a/vendor/golang.org/x/tools/internal/event/doc.go b/vendor/golang.org/x/tools/internal/event/doc.go
deleted file mode 100644
index 5dc6e6babe..0000000000
--- a/vendor/golang.org/x/tools/internal/event/doc.go
+++ /dev/null
@@ -1,7 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package event provides a set of packages that cover the main
-// concepts of telemetry in an implementation agnostic way.
-package event
diff --git a/vendor/golang.org/x/tools/internal/event/event.go b/vendor/golang.org/x/tools/internal/event/event.go
deleted file mode 100644
index 4d55e577d1..0000000000
--- a/vendor/golang.org/x/tools/internal/event/event.go
+++ /dev/null
@@ -1,127 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package event
-
-import (
-	"context"
-
-	"golang.org/x/tools/internal/event/core"
-	"golang.org/x/tools/internal/event/keys"
-	"golang.org/x/tools/internal/event/label"
-)
-
-// Exporter is a function that handles events.
-// It may return a modified context and event.
-type Exporter func(context.Context, core.Event, label.Map) context.Context
-
-// SetExporter sets the global exporter function that handles all events.
-// The exporter is called synchronously from the event call site, so it should
-// return quickly so as not to hold up user code.
-func SetExporter(e Exporter) {
-	core.SetExporter(core.Exporter(e))
-}
-
-// Log takes a message and a label list and combines them into a single event
-// before delivering them to the exporter.
-func Log(ctx context.Context, message string, labels ...label.Label) {
-	core.Export(ctx, core.MakeEvent([3]label.Label{
-		keys.Msg.Of(message),
-	}, labels))
-}
-
-// IsLog returns true if the event was built by the Log function.
-// It is intended to be used in exporters to identify the semantics of the
-// event when deciding what to do with it.
-func IsLog(ev core.Event) bool {
-	return ev.Label(0).Key() == keys.Msg
-}
-
-// Error takes a message and a label list and combines them into a single event
-// before delivering them to the exporter. It captures the error in the
-// delivered event.
-func Error(ctx context.Context, message string, err error, labels ...label.Label) {
-	core.Export(ctx, core.MakeEvent([3]label.Label{
-		keys.Msg.Of(message),
-		keys.Err.Of(err),
-	}, labels))
-}
-
-// IsError returns true if the event was built by the Error function.
-// It is intended to be used in exporters to identify the semantics of the
-// event when deciding what to do with it.
-func IsError(ev core.Event) bool {
-	return ev.Label(0).Key() == keys.Msg &&
-		ev.Label(1).Key() == keys.Err
-}
-
-// Metric sends a label event to the exporter with the supplied labels.
-func Metric(ctx context.Context, labels ...label.Label) {
-	core.Export(ctx, core.MakeEvent([3]label.Label{
-		keys.Metric.New(),
-	}, labels))
-}
-
-// IsMetric returns true if the event was built by the Metric function.
-// It is intended to be used in exporters to identify the semantics of the
-// event when deciding what to do with it.
-func IsMetric(ev core.Event) bool {
-	return ev.Label(0).Key() == keys.Metric
-}
-
-// Label sends a label event to the exporter with the supplied labels.
-func Label(ctx context.Context, labels ...label.Label) context.Context {
-	return core.Export(ctx, core.MakeEvent([3]label.Label{
-		keys.Label.New(),
-	}, labels))
-}
-
-// IsLabel returns true if the event was built by the Label function.
-// It is intended to be used in exporters to identify the semantics of the
-// event when deciding what to do with it.
-func IsLabel(ev core.Event) bool {
-	return ev.Label(0).Key() == keys.Label
-}
-
-// Start sends a span start event with the supplied label list to the exporter.
-// It also returns a function that will end the span, which should normally be
-// deferred.
-func Start(ctx context.Context, name string, labels ...label.Label) (context.Context, func()) {
-	return core.ExportPair(ctx,
-		core.MakeEvent([3]label.Label{
-			keys.Start.Of(name),
-		}, labels),
-		core.MakeEvent([3]label.Label{
-			keys.End.New(),
-		}, nil))
-}
-
-// IsStart returns true if the event was built by the Start function.
-// It is intended to be used in exporters to identify the semantics of the
-// event when deciding what to do with it.
-func IsStart(ev core.Event) bool {
-	return ev.Label(0).Key() == keys.Start
-}
-
-// IsEnd returns true if the event was built by the End function.
-// It is intended to be used in exporters to identify the semantics of the
-// event when deciding what to do with it.
-func IsEnd(ev core.Event) bool {
-	return ev.Label(0).Key() == keys.End
-}
-
-// Detach returns a context without an associated span.
-// This allows the creation of spans that are not children of the current span.
-func Detach(ctx context.Context) context.Context {
-	return core.Export(ctx, core.MakeEvent([3]label.Label{
-		keys.Detach.New(),
-	}, nil))
-}
-
-// IsDetach returns true if the event was built by the Detach function.
-// It is intended to be used in exporters to identify the semantics of the
-// event when deciding what to do with it.
-func IsDetach(ev core.Event) bool {
-	return ev.Label(0).Key() == keys.Detach
-}
diff --git a/vendor/golang.org/x/tools/internal/event/keys/keys.go b/vendor/golang.org/x/tools/internal/event/keys/keys.go
deleted file mode 100644
index ac78bc3b9c..0000000000
--- a/vendor/golang.org/x/tools/internal/event/keys/keys.go
+++ /dev/null
@@ -1,237 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package keys
-
-import (
-	"fmt"
-	"math"
-	"strconv"
-
-	"golang.org/x/tools/internal/event/label"
-)
-
-// Value is a [label.Key] for untyped values.
-type Value struct {
-	name        string
-	description string
-}
-
-// New creates a new Key for untyped values.
-func New(name, description string) *Value {
-	return &Value{name: name, description: description}
-}
-
-func (k *Value) Name() string        { return k.name }
-func (k *Value) Description() string { return k.description }
-
-func (k *Value) Append(buf []byte, l label.Label) []byte {
-	return fmt.Append(buf, k.From(l))
-}
-
-// Get returns the label for the key of a label.Map.
-func (k *Value) Get(lm label.Map) any {
-	if t := lm.Find(k); t.Valid() {
-		return k.From(t)
-	}
-	return nil
-}
-
-// From returns the value of a Label.
-func (k *Value) From(t label.Label) any { return t.UnpackValue() }
-
-// Of creates a new Label with this key and the supplied value.
-func (k *Value) Of(value any) label.Label { return label.OfValue(k, value) }
-
-// Tag represents a key for tagging labels that have no value.
-// These are used when the existence of the label is the entire information it
-// carries, such as marking events to be of a specific kind, or from a specific
-// package.
-type Tag struct {
-	name        string
-	description string
-}
-
-// NewTag creates a new [label.Key] for tagging labels.
-func NewTag(name, description string) *Tag {
-	return &Tag{name: name, description: description}
-}
-
-func (k *Tag) Name() string        { return k.name }
-func (k *Tag) Description() string { return k.description }
-
-func (k *Tag) Append(buf []byte, l label.Label) []byte { return buf }
-
-// New creates a new Label with this key.
-func (k *Tag) New() label.Label { return label.OfValue(k, nil) }
-
-// Int is a [label.Key] for signed integers.
-type Int struct {
-	name        string
-	description string
-}
-
-// NewInt returns a new [label.Key] for int64 values.
-func NewInt(name, description string) *Int {
-	return &Int{name: name, description: description}
-}
-
-func (k *Int) Name() string        { return k.name }
-func (k *Int) Description() string { return k.description }
-
-func (k *Int) Append(buf []byte, l label.Label) []byte {
-	return strconv.AppendInt(buf, k.From(l), 10)
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *Int) Of(v int) label.Label { return k.Of64(int64(v)) }
-
-// Of64 creates a new Label with this key and the supplied value.
-func (k *Int) Of64(v int64) label.Label { return label.Of64(k, uint64(v)) }
-
-// Get returns the label for the key of a label.Map.
-func (k *Int) Get(lm label.Map) int64 {
-	if t := lm.Find(k); t.Valid() {
-		return k.From(t)
-	}
-	return 0
-}
-
-// From returns the value of a Label.
-func (k *Int) From(t label.Label) int64 { return int64(t.Unpack64()) }
-
-// Uint is a [label.Key] for unsigned integers.
-type Uint struct {
-	name        string
-	description string
-}
-
-// NewUint creates a new [label.Key] for unsigned values.
-func NewUint(name, description string) *Uint {
-	return &Uint{name: name, description: description}
-}
-
-func (k *Uint) Name() string        { return k.name }
-func (k *Uint) Description() string { return k.description }
-
-func (k *Uint) Append(buf []byte, l label.Label) []byte {
-	return strconv.AppendUint(buf, k.From(l), 10)
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *Uint) Of(v uint64) label.Label { return label.Of64(k, v) }
-
-// Get returns the label for the key of a label.Map.
-func (k *Uint) Get(lm label.Map) uint64 {
-	if t := lm.Find(k); t.Valid() {
-		return k.From(t)
-	}
-	return 0
-}
-
-// From returns the value of a Label.
-func (k *Uint) From(t label.Label) uint64 { return t.Unpack64() }
-
-// Float is a label.Key for floating-point values.
-type Float struct {
-	name        string
-	description string
-}
-
-// NewFloat creates a new [label.Key] for floating-point values.
-func NewFloat(name, description string) *Float {
-	return &Float{name: name, description: description}
-}
-
-func (k *Float) Name() string        { return k.name }
-func (k *Float) Description() string { return k.description }
-
-func (k *Float) Append(buf []byte, l label.Label) []byte {
-	return strconv.AppendFloat(buf, k.From(l), 'E', -1, 64)
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *Float) Of(v float64) label.Label {
-	return label.Of64(k, math.Float64bits(v))
-}
-
-// Get returns the label for the key of a label.Map.
-func (k *Float) Get(lm label.Map) float64 {
-	if t := lm.Find(k); t.Valid() {
-		return k.From(t)
-	}
-	return 0
-}
-
-// From returns the value of a Label.
-func (k *Float) From(t label.Label) float64 {
-	return math.Float64frombits(t.Unpack64())
-}
-
-// String represents a key
-type String struct {
-	name        string
-	description string
-}
-
-// NewString creates a new Key for int64 values.
-func NewString(name, description string) *String {
-	return &String{name: name, description: description}
-}
-
-func (k *String) Name() string        { return k.name }
-func (k *String) Description() string { return k.description }
-
-func (k *String) Append(buf []byte, l label.Label) []byte {
-	return strconv.AppendQuote(buf, k.From(l))
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *String) Of(v string) label.Label { return label.OfString(k, v) }
-
-// Get returns the label for the key of a label.Map.
-func (k *String) Get(lm label.Map) string {
-	if t := lm.Find(k); t.Valid() {
-		return k.From(t)
-	}
-	return ""
-}
-
-// From returns the value of a Label.
-func (k *String) From(t label.Label) string { return t.UnpackString() }
-
-// Error represents a key
-type Error struct {
-	name        string
-	description string
-}
-
-// NewError returns a new [label.Key] for error values.
-func NewError(name, description string) *Error {
-	return &Error{name: name, description: description}
-}
-
-func (k *Error) Name() string        { return k.name }
-func (k *Error) Description() string { return k.description }
-
-func (k *Error) Append(buf []byte, l label.Label) []byte {
-	return append(buf, k.From(l).Error()...)
-}
-
-// Of returns a new Label with this key and the supplied value.
-func (k *Error) Of(v error) label.Label { return label.OfValue(k, v) }
-
-// Get returns the label for the key of a label.Map.
-func (k *Error) Get(lm label.Map) error {
-	if t := lm.Find(k); t.Valid() {
-		return k.From(t)
-	}
-	return nil
-}
-
-// From returns the value of a Label.
-func (k *Error) From(t label.Label) error {
-	err, _ := t.UnpackValue().(error)
-	return err
-}
diff --git a/vendor/golang.org/x/tools/internal/event/keys/standard.go b/vendor/golang.org/x/tools/internal/event/keys/standard.go
deleted file mode 100644
index 7e95866592..0000000000
--- a/vendor/golang.org/x/tools/internal/event/keys/standard.go
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package keys
-
-var (
-	// Msg is a key used to add message strings to label lists.
-	Msg = NewString("message", "a readable message")
-	// Label is a key used to indicate an event adds labels to the context.
-	Label = NewTag("label", "a label context marker")
-	// Start is used for things like traces that have a name.
-	Start = NewString("start", "span start")
-	// Metric is a key used to indicate an event records metrics.
-	End = NewTag("end", "a span end marker")
-	// Metric is a key used to indicate an event records metrics.
-	Detach = NewTag("detach", "a span detach marker")
-	// Err is a key used to add error values to label lists.
-	Err = NewError("error", "an error that occurred")
-	// Metric is a key used to indicate an event records metrics.
-	Metric = NewTag("metric", "a metric event marker")
-)
diff --git a/vendor/golang.org/x/tools/internal/event/keys/util.go b/vendor/golang.org/x/tools/internal/event/keys/util.go
deleted file mode 100644
index c0e8e731c9..0000000000
--- a/vendor/golang.org/x/tools/internal/event/keys/util.go
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright 2023 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package keys
-
-import (
-	"sort"
-	"strings"
-)
-
-// Join returns a canonical join of the keys in S:
-// a sorted comma-separated string list.
-func Join[S ~[]T, T ~string](s S) string {
-	strs := make([]string, 0, len(s))
-	for _, v := range s {
-		strs = append(strs, string(v))
-	}
-	sort.Strings(strs)
-	return strings.Join(strs, ",")
-}
diff --git a/vendor/golang.org/x/tools/internal/event/label/label.go b/vendor/golang.org/x/tools/internal/event/label/label.go
deleted file mode 100644
index e84226f879..0000000000
--- a/vendor/golang.org/x/tools/internal/event/label/label.go
+++ /dev/null
@@ -1,203 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package label
-
-import (
-	"fmt"
-	"io"
-	"slices"
-	"unsafe"
-)
-
-// Key is used as the identity of a Label.
-// Keys are intended to be compared by pointer only, the name should be unique
-// for communicating with external systems, but it is not required or enforced.
-type Key interface {
-	// Name returns the key name.
-	Name() string
-	// Description returns a string that can be used to describe the value.
-	Description() string
-	// Append appends the formatted value of the label to the supplied buffer.
-	Append(buf []byte, l Label) []byte
-}
-
-// Label holds a key and value pair.
-// It is normally used when passing around lists of labels.
-type Label struct {
-	key     Key
-	packed  uint64
-	untyped any
-}
-
-// Map is the interface to a collection of Labels indexed by key.
-type Map interface {
-	// Find returns the label that matches the supplied key.
-	Find(key Key) Label
-}
-
-// List is the interface to something that provides an iterable
-// list of labels.
-// Iteration should start from 0 and continue until Valid returns false.
-type List interface {
-	// Valid returns true if the index is within range for the list.
-	// It does not imply the label at that index will itself be valid.
-	Valid(index int) bool
-	// Label returns the label at the given index.
-	Label(index int) Label
-}
-
-// list implements LabelList for a list of Labels.
-type list struct {
-	labels []Label
-}
-
-// filter wraps a LabelList filtering out specific labels.
-type filter struct {
-	keys       []Key
-	underlying List
-}
-
-// listMap implements LabelMap for a simple list of labels.
-type listMap struct {
-	labels []Label
-}
-
-// mapChain implements LabelMap for a list of underlying LabelMap.
-type mapChain struct {
-	maps []Map
-}
-
-// OfValue creates a new label from the key and value.
-// This method is for implementing new key types, label creation should
-// normally be done with the Of method of the key.
-func OfValue(k Key, value any) Label { return Label{key: k, untyped: value} }
-
-// UnpackValue assumes the label was built using LabelOfValue and returns the value
-// that was passed to that constructor.
-// This method is for implementing new key types, for type safety normal
-// access should be done with the From method of the key.
-func (t Label) UnpackValue() any { return t.untyped }
-
-// Of64 creates a new label from a key and a uint64. This is often
-// used for non uint64 values that can be packed into a uint64.
-// This method is for implementing new key types, label creation should
-// normally be done with the Of method of the key.
-func Of64(k Key, v uint64) Label { return Label{key: k, packed: v} }
-
-// Unpack64 assumes the label was built using LabelOf64 and returns the value that
-// was passed to that constructor.
-// This method is for implementing new key types, for type safety normal
-// access should be done with the From method of the key.
-func (t Label) Unpack64() uint64 { return t.packed }
-
-type stringptr unsafe.Pointer
-
-// OfString creates a new label from a key and a string.
-// This method is for implementing new key types, label creation should
-// normally be done with the Of method of the key.
-func OfString(k Key, v string) Label {
-	return Label{
-		key:     k,
-		packed:  uint64(len(v)),
-		untyped: stringptr(unsafe.StringData(v)),
-	}
-}
-
-// UnpackString assumes the label was built using LabelOfString and returns the
-// value that was passed to that constructor.
-// This method is for implementing new key types, for type safety normal
-// access should be done with the From method of the key.
-func (t Label) UnpackString() string {
-	return unsafe.String((*byte)(t.untyped.(stringptr)), int(t.packed))
-}
-
-// Valid returns true if the Label is a valid one (it has a key).
-func (t Label) Valid() bool { return t.key != nil }
-
-// Key returns the key of this Label.
-func (t Label) Key() Key { return t.key }
-
-// Format is used for debug printing of labels.
-func (t Label) Format(f fmt.State, r rune) {
-	if !t.Valid() {
-		io.WriteString(f, `nil`)
-		return
-	}
-	io.WriteString(f, t.Key().Name())
-	io.WriteString(f, "=")
-	f.Write(t.Key().Append(nil, t)) // ignore error
-}
-
-func (l *list) Valid(index int) bool {
-	return index >= 0 && index < len(l.labels)
-}
-
-func (l *list) Label(index int) Label {
-	return l.labels[index]
-}
-
-func (f *filter) Valid(index int) bool {
-	return f.underlying.Valid(index)
-}
-
-func (f *filter) Label(index int) Label {
-	l := f.underlying.Label(index)
-	if slices.Contains(f.keys, l.Key()) {
-		return Label{}
-	}
-	return l
-}
-
-func (lm listMap) Find(key Key) Label {
-	for _, l := range lm.labels {
-		if l.Key() == key {
-			return l
-		}
-	}
-	return Label{}
-}
-
-func (c mapChain) Find(key Key) Label {
-	for _, src := range c.maps {
-		l := src.Find(key)
-		if l.Valid() {
-			return l
-		}
-	}
-	return Label{}
-}
-
-var emptyList = &list{}
-
-func NewList(labels ...Label) List {
-	if len(labels) == 0 {
-		return emptyList
-	}
-	return &list{labels: labels}
-}
-
-func Filter(l List, keys ...Key) List {
-	if len(keys) == 0 {
-		return l
-	}
-	return &filter{keys: keys, underlying: l}
-}
-
-func NewMap(labels ...Label) Map {
-	return listMap{labels: labels}
-}
-
-func MergeMaps(srcs ...Map) Map {
-	var nonNil []Map
-	for _, src := range srcs {
-		if src != nil {
-			nonNil = append(nonNil, src)
-		}
-	}
-	if len(nonNil) == 1 {
-		return nonNil[0]
-	}
-	return mapChain{maps: nonNil}
-}
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/bimport.go b/vendor/golang.org/x/tools/internal/gcimporter/bimport.go
deleted file mode 100644
index 555ef626c0..0000000000
--- a/vendor/golang.org/x/tools/internal/gcimporter/bimport.go
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file contains the remaining vestiges of
-// $GOROOT/src/go/internal/gcimporter/bimport.go.
-
-package gcimporter
-
-import (
-	"fmt"
-	"go/token"
-	"go/types"
-	"sync"
-)
-
-func errorf(format string, args ...any) {
-	panic(fmt.Sprintf(format, args...))
-}
-
-const deltaNewFile = -64 // see cmd/compile/internal/gc/bexport.go
-
-// Synthesize a token.Pos
-type fakeFileSet struct {
-	fset  *token.FileSet
-	files map[string]*fileInfo
-}
-
-type fileInfo struct {
-	file     *token.File
-	lastline int
-}
-
-const maxlines = 64 * 1024
-
-func (s *fakeFileSet) pos(file string, line, column int) token.Pos {
-	_ = column // TODO(mdempsky): Make use of column.
-
-	// Since we don't know the set of needed file positions, we reserve maxlines
-	// positions per file. We delay calling token.File.SetLines until all
-	// positions have been calculated (by way of fakeFileSet.setLines), so that
-	// we can avoid setting unnecessary lines. See also golang/go#46586.
-	f := s.files[file]
-	if f == nil {
-		f = &fileInfo{file: s.fset.AddFile(file, -1, maxlines)}
-		s.files[file] = f
-	}
-	if line > maxlines {
-		line = 1
-	}
-	if line > f.lastline {
-		f.lastline = line
-	}
-
-	// Return a fake position assuming that f.file consists only of newlines.
-	return token.Pos(f.file.Base() + line - 1)
-}
-
-func (s *fakeFileSet) setLines() {
-	fakeLinesOnce.Do(func() {
-		fakeLines = make([]int, maxlines)
-		for i := range fakeLines {
-			fakeLines[i] = i
-		}
-	})
-	for _, f := range s.files {
-		f.file.SetLines(fakeLines[:f.lastline])
-	}
-}
-
-var (
-	fakeLines     []int
-	fakeLinesOnce sync.Once
-)
-
-func chanDir(d int) types.ChanDir {
-	// tag values must match the constants in cmd/compile/internal/gc/go.go
-	switch d {
-	case 1 /* Crecv */ :
-		return types.RecvOnly
-	case 2 /* Csend */ :
-		return types.SendOnly
-	case 3 /* Cboth */ :
-		return types.SendRecv
-	default:
-		errorf("unexpected channel dir %d", d)
-		return 0
-	}
-}
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/exportdata.go b/vendor/golang.org/x/tools/internal/gcimporter/exportdata.go
deleted file mode 100644
index 5662a311da..0000000000
--- a/vendor/golang.org/x/tools/internal/gcimporter/exportdata.go
+++ /dev/null
@@ -1,421 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file should be kept in sync with $GOROOT/src/internal/exportdata/exportdata.go.
-// This file also additionally implements FindExportData for gcexportdata.NewReader.
-
-package gcimporter
-
-import (
-	"bufio"
-	"bytes"
-	"errors"
-	"fmt"
-	"go/build"
-	"io"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"sync"
-)
-
-// FindExportData positions the reader r at the beginning of the
-// export data section of an underlying cmd/compile created archive
-// file by reading from it. The reader must be positioned at the
-// start of the file before calling this function.
-// This returns the length of the export data in bytes.
-//
-// This function is needed by [gcexportdata.Read], which must
-// accept inputs produced by the last two releases of cmd/compile,
-// plus tip.
-func FindExportData(r *bufio.Reader) (size int64, err error) {
-	arsize, err := FindPackageDefinition(r)
-	if err != nil {
-		return
-	}
-	size = int64(arsize)
-
-	objapi, headers, err := ReadObjectHeaders(r)
-	if err != nil {
-		return
-	}
-	size -= int64(len(objapi))
-	for _, h := range headers {
-		size -= int64(len(h))
-	}
-
-	// Check for the binary export data section header "$$B\n".
-	// TODO(taking): Unify with ReadExportDataHeader so that it stops at the 'u' instead of reading
-	line, err := r.ReadSlice('\n')
-	if err != nil {
-		return
-	}
-	hdr := string(line)
-	if hdr != "$$B\n" {
-		err = fmt.Errorf("unknown export data header: %q", hdr)
-		return
-	}
-	size -= int64(len(hdr))
-
-	// For files with a binary export data header "$$B\n",
-	// these are always terminated by an end-of-section marker "\n$$\n".
-	// So the last bytes must always be this constant.
-	//
-	// The end-of-section marker is not a part of the export data itself.
-	// Do not include these in size.
-	//
-	// It would be nice to have sanity check that the final bytes after
-	// the export data are indeed the end-of-section marker. The split
-	// of gcexportdata.NewReader and gcexportdata.Read make checking this
-	// ugly so gcimporter gives up enforcing this. The compiler and go/types
-	// importer do enforce this, which seems good enough.
-	const endofsection = "\n$$\n"
-	size -= int64(len(endofsection))
-
-	if size < 0 {
-		err = fmt.Errorf("invalid size (%d) in the archive file: %d bytes remain without section headers (recompile package)", arsize, size)
-		return
-	}
-
-	return
-}
-
-// ReadUnified reads the contents of the unified export data from a reader r
-// that contains the contents of a GC-created archive file.
-//
-// On success, the reader will be positioned after the end-of-section marker "\n$$\n".
-//
-// Supported GC-created archive files have 4 layers of nesting:
-//   - An archive file containing a package definition file.
-//   - The package definition file contains headers followed by a data section.
-//     Headers are lines (≤ 4kb) that do not start with "$$".
-//   - The data section starts with "$$B\n" followed by export data followed
-//     by an end of section marker "\n$$\n". (The section start "$$\n" is no
-//     longer supported.)
-//   - The export data starts with a format byte ('u') followed by the <data> in
-//     the given format. (See ReadExportDataHeader for older formats.)
-//
-// Putting this together, the bytes in a GC-created archive files are expected
-// to look like the following.
-// See cmd/internal/archive for more details on ar file headers.
-//
-// | <!arch>\n             | ar file signature
-// | __.PKGDEF...size...\n | ar header for __.PKGDEF including size.
-// | go object <...>\n     | objabi header
-// | <optional headers>\n  | other headers such as build id
-// | $$B\n                 | binary format marker
-// | u<data>\n             | unified export <data>
-// | $$\n                  | end-of-section marker
-// | [optional padding]    | padding byte (0x0A) if size is odd
-// | [ar file header]      | other ar files
-// | [ar file data]        |
-func ReadUnified(r *bufio.Reader) (data []byte, err error) {
-	// We historically guaranteed headers at the default buffer size (4096) work.
-	// This ensures we can use ReadSlice throughout.
-	const minBufferSize = 4096
-	r = bufio.NewReaderSize(r, minBufferSize)
-
-	size, err := FindPackageDefinition(r)
-	if err != nil {
-		return
-	}
-	n := size
-
-	objapi, headers, err := ReadObjectHeaders(r)
-	if err != nil {
-		return
-	}
-	n -= len(objapi)
-	for _, h := range headers {
-		n -= len(h)
-	}
-
-	hdrlen, err := ReadExportDataHeader(r)
-	if err != nil {
-		return
-	}
-	n -= hdrlen
-
-	// size also includes the end of section marker. Remove that many bytes from the end.
-	const marker = "\n$$\n"
-	n -= len(marker)
-
-	if n < 0 {
-		err = fmt.Errorf("invalid size (%d) in the archive file: %d bytes remain without section headers (recompile package)", size, n)
-		return
-	}
-
-	// Read n bytes from buf.
-	data = make([]byte, n)
-	_, err = io.ReadFull(r, data)
-	if err != nil {
-		return
-	}
-
-	// Check for marker at the end.
-	var suffix [len(marker)]byte
-	_, err = io.ReadFull(r, suffix[:])
-	if err != nil {
-		return
-	}
-	if s := string(suffix[:]); s != marker {
-		err = fmt.Errorf("read %q instead of end-of-section marker (%q)", s, marker)
-		return
-	}
-
-	return
-}
-
-// FindPackageDefinition positions the reader r at the beginning of a package
-// definition file ("__.PKGDEF") within a GC-created archive by reading
-// from it, and returns the size of the package definition file in the archive.
-//
-// The reader must be positioned at the start of the archive file before calling
-// this function, and "__.PKGDEF" is assumed to be the first file in the archive.
-//
-// See cmd/internal/archive for details on the archive format.
-func FindPackageDefinition(r *bufio.Reader) (size int, err error) {
-	// Uses ReadSlice to limit risk of malformed inputs.
-
-	// Read first line to make sure this is an object file.
-	line, err := r.ReadSlice('\n')
-	if err != nil {
-		err = fmt.Errorf("can't find export data (%v)", err)
-		return
-	}
-
-	// Is the first line an archive file signature?
-	if string(line) != "!<arch>\n" {
-		err = fmt.Errorf("not the start of an archive file (%q)", line)
-		return
-	}
-
-	// package export block should be first
-	size = readArchiveHeader(r, "__.PKGDEF")
-	if size <= 0 {
-		err = fmt.Errorf("not a package file")
-		return
-	}
-
-	return
-}
-
-// ReadObjectHeaders reads object headers from the reader. Object headers are
-// lines that do not start with an end-of-section marker "$$". The first header
-// is the objabi header. On success, the reader will be positioned at the beginning
-// of the end-of-section marker.
-//
-// It returns an error if any header does not fit in r.Size() bytes.
-func ReadObjectHeaders(r *bufio.Reader) (objapi string, headers []string, err error) {
-	// line is a temporary buffer for headers.
-	// Use bounded reads (ReadSlice, Peek) to limit risk of malformed inputs.
-	var line []byte
-
-	// objapi header should be the first line
-	if line, err = r.ReadSlice('\n'); err != nil {
-		err = fmt.Errorf("can't find export data (%v)", err)
-		return
-	}
-	objapi = string(line)
-
-	// objapi header begins with "go object ".
-	if !strings.HasPrefix(objapi, "go object ") {
-		err = fmt.Errorf("not a go object file: %s", objapi)
-		return
-	}
-
-	// process remaining object header lines
-	for {
-		// check for an end of section marker "$$"
-		line, err = r.Peek(2)
-		if err != nil {
-			return
-		}
-		if string(line) == "$$" {
-			return // stop
-		}
-
-		// read next header
-		line, err = r.ReadSlice('\n')
-		if err != nil {
-			return
-		}
-		headers = append(headers, string(line))
-	}
-}
-
-// ReadExportDataHeader reads the export data header and format from r.
-// It returns the number of bytes read, or an error if the format is no longer
-// supported or it failed to read.
-//
-// The only currently supported format is binary export data in the
-// unified export format.
-func ReadExportDataHeader(r *bufio.Reader) (n int, err error) {
-	// Read export data header.
-	line, err := r.ReadSlice('\n')
-	if err != nil {
-		return
-	}
-
-	hdr := string(line)
-	switch hdr {
-	case "$$\n":
-		err = fmt.Errorf("old textual export format no longer supported (recompile package)")
-		return
-
-	case "$$B\n":
-		var format byte
-		format, err = r.ReadByte()
-		if err != nil {
-			return
-		}
-		// The unified export format starts with a 'u'.
-		switch format {
-		case 'u':
-		default:
-			// Older no longer supported export formats include:
-			// indexed export format which started with an 'i'; and
-			// the older binary export format which started with a 'c',
-			// 'd', or 'v' (from "version").
-			err = fmt.Errorf("binary export format %q is no longer supported (recompile package)", format)
-			return
-		}
-
-	default:
-		err = fmt.Errorf("unknown export data header: %q", hdr)
-		return
-	}
-
-	n = len(hdr) + 1 // + 1 is for 'u'
-	return
-}
-
-// FindPkg returns the filename and unique package id for an import
-// path based on package information provided by build.Import (using
-// the build.Default build.Context). A relative srcDir is interpreted
-// relative to the current working directory.
-//
-// FindPkg is only used in tests within x/tools.
-func FindPkg(path, srcDir string) (filename, id string, err error) {
-	// TODO(taking): Move internal/exportdata.FindPkg into its own file,
-	// and then this copy into a _test package.
-	if path == "" {
-		return "", "", errors.New("path is empty")
-	}
-
-	var noext string
-	switch {
-	default:
-		// "x" -> "$GOPATH/pkg/$GOOS_$GOARCH/x.ext", "x"
-		// Don't require the source files to be present.
-		if abs, err := filepath.Abs(srcDir); err == nil { // see issue 14282
-			srcDir = abs
-		}
-		var bp *build.Package
-		bp, err = build.Import(path, srcDir, build.FindOnly|build.AllowBinary)
-		if bp.PkgObj == "" {
-			if bp.Goroot && bp.Dir != "" {
-				filename, err = lookupGorootExport(bp.Dir)
-				if err == nil {
-					_, err = os.Stat(filename)
-				}
-				if err == nil {
-					return filename, bp.ImportPath, nil
-				}
-			}
-			goto notfound
-		} else {
-			noext = strings.TrimSuffix(bp.PkgObj, ".a")
-		}
-		id = bp.ImportPath
-
-	case build.IsLocalImport(path):
-		// "./x" -> "/this/directory/x.ext", "/this/directory/x"
-		noext = filepath.Join(srcDir, path)
-		id = noext
-
-	case filepath.IsAbs(path):
-		// for completeness only - go/build.Import
-		// does not support absolute imports
-		// "/x" -> "/x.ext", "/x"
-		noext = path
-		id = path
-	}
-
-	if false { // for debugging
-		if path != id {
-			fmt.Printf("%s -> %s\n", path, id)
-		}
-	}
-
-	// try extensions
-	for _, ext := range pkgExts {
-		filename = noext + ext
-		f, statErr := os.Stat(filename)
-		if statErr == nil && !f.IsDir() {
-			return filename, id, nil
-		}
-		if err == nil {
-			err = statErr
-		}
-	}
-
-notfound:
-	if err == nil {
-		return "", path, fmt.Errorf("can't find import: %q", path)
-	}
-	return "", path, fmt.Errorf("can't find import: %q: %w", path, err)
-}
-
-var pkgExts = [...]string{".a", ".o"} // a file from the build cache will have no extension
-
-var exportMap sync.Map // package dir → func() (string, error)
-
-// lookupGorootExport returns the location of the export data
-// (normally found in the build cache, but located in GOROOT/pkg
-// in prior Go releases) for the package located in pkgDir.
-//
-// (We use the package's directory instead of its import path
-// mainly to simplify handling of the packages in src/vendor
-// and cmd/vendor.)
-//
-// lookupGorootExport is only used in tests within x/tools.
-func lookupGorootExport(pkgDir string) (string, error) {
-	f, ok := exportMap.Load(pkgDir)
-	if !ok {
-		var (
-			listOnce   sync.Once
-			exportPath string
-			err        error
-		)
-		f, _ = exportMap.LoadOrStore(pkgDir, func() (string, error) {
-			listOnce.Do(func() {
-				cmd := exec.Command(filepath.Join(build.Default.GOROOT, "bin", "go"), "list", "-export", "-f", "{{.Export}}", pkgDir)
-				cmd.Dir = build.Default.GOROOT
-				cmd.Env = append(os.Environ(), "PWD="+cmd.Dir, "GOROOT="+build.Default.GOROOT)
-				var output []byte
-				output, err = cmd.Output()
-				if err != nil {
-					if ee, ok := err.(*exec.ExitError); ok && len(ee.Stderr) > 0 {
-						err = errors.New(string(ee.Stderr))
-					}
-					return
-				}
-
-				exports := strings.Split(string(bytes.TrimSpace(output)), "\n")
-				if len(exports) != 1 {
-					err = fmt.Errorf("go list reported %d exports; expected 1", len(exports))
-					return
-				}
-
-				exportPath = exports[0]
-			})
-
-			return exportPath, err
-		})
-	}
-
-	return f.(func() (string, error))()
-}
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/gcimporter.go b/vendor/golang.org/x/tools/internal/gcimporter/gcimporter.go
deleted file mode 100644
index 3dbd21d1b9..0000000000
--- a/vendor/golang.org/x/tools/internal/gcimporter/gcimporter.go
+++ /dev/null
@@ -1,108 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file is a reduced copy of $GOROOT/src/go/internal/gcimporter/gcimporter.go.
-
-// Package gcimporter provides various functions for reading
-// gc-generated object files that can be used to implement the
-// Importer interface defined by the Go 1.5 standard library package.
-//
-// The encoding is deterministic: if the encoder is applied twice to
-// the same types.Package data structure, both encodings are equal.
-// This property may be important to avoid spurious changes in
-// applications such as build systems.
-//
-// However, the encoder is not necessarily idempotent. Importing an
-// exported package may yield a types.Package that, while it
-// represents the same set of Go types as the original, may differ in
-// the details of its internal representation. Because of these
-// differences, re-encoding the imported package may yield a
-// different, but equally valid, encoding of the package.
-package gcimporter // import "golang.org/x/tools/internal/gcimporter"
-
-import (
-	"bufio"
-	"fmt"
-	"go/token"
-	"go/types"
-	"io"
-	"os"
-)
-
-const (
-	// Enable debug during development: it adds some additional checks, and
-	// prevents errors from being recovered.
-	debug = false
-
-	// If trace is set, debugging output is printed to std out.
-	trace = false
-)
-
-// Import imports a gc-generated package given its import path and srcDir, adds
-// the corresponding package object to the packages map, and returns the object.
-// The packages map must contain all packages already imported.
-//
-// Import is only used in tests.
-func Import(fset *token.FileSet, packages map[string]*types.Package, path, srcDir string, lookup func(path string) (io.ReadCloser, error)) (pkg *types.Package, err error) {
-	var rc io.ReadCloser
-	var id string
-	if lookup != nil {
-		// With custom lookup specified, assume that caller has
-		// converted path to a canonical import path for use in the map.
-		if path == "unsafe" {
-			return types.Unsafe, nil
-		}
-		id = path
-
-		// No need to re-import if the package was imported completely before.
-		if pkg = packages[id]; pkg != nil && pkg.Complete() {
-			return
-		}
-		f, err := lookup(path)
-		if err != nil {
-			return nil, err
-		}
-		rc = f
-	} else {
-		var filename string
-		filename, id, err = FindPkg(path, srcDir)
-		if filename == "" {
-			if path == "unsafe" {
-				return types.Unsafe, nil
-			}
-			return nil, err
-		}
-
-		// no need to re-import if the package was imported completely before
-		if pkg = packages[id]; pkg != nil && pkg.Complete() {
-			return
-		}
-
-		// open file
-		f, err := os.Open(filename)
-		if err != nil {
-			return nil, err
-		}
-		defer func() {
-			if err != nil {
-				// add file name to error
-				err = fmt.Errorf("%s: %v", filename, err)
-			}
-		}()
-		rc = f
-	}
-	defer rc.Close()
-
-	buf := bufio.NewReader(rc)
-	data, err := ReadUnified(buf)
-	if err != nil {
-		err = fmt.Errorf("import %q: %v", path, err)
-		return
-	}
-
-	// unified: emitted by cmd/compile since go1.20.
-	_, pkg, err = UImportData(fset, packages, data, id)
-
-	return
-}
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/iexport.go b/vendor/golang.org/x/tools/internal/gcimporter/iexport.go
deleted file mode 100644
index 686f171d3b..0000000000
--- a/vendor/golang.org/x/tools/internal/gcimporter/iexport.go
+++ /dev/null
@@ -1,1605 +0,0 @@
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Indexed package export.
-//
-// The indexed export data format is an evolution of the previous
-// binary export data format. Its chief contribution is introducing an
-// index table, which allows efficient random access of individual
-// declarations and inline function bodies. In turn, this allows
-// avoiding unnecessary work for compilation units that import large
-// packages.
-//
-//
-// The top-level data format is structured as:
-//
-//     Header struct {
-//         Tag        byte   // 'i'
-//         Version    uvarint
-//         StringSize uvarint
-//         DataSize   uvarint
-//     }
-//
-//     Strings [StringSize]byte
-//     Data    [DataSize]byte
-//
-//     MainIndex []struct{
-//         PkgPath   stringOff
-//         PkgName   stringOff
-//         PkgHeight uvarint
-//
-//         Decls []struct{
-//             Name   stringOff
-//             Offset declOff
-//         }
-//     }
-//
-//     Fingerprint [8]byte
-//
-// uvarint means a uint64 written out using uvarint encoding.
-//
-// []T means a uvarint followed by that many T objects. In other
-// words:
-//
-//     Len   uvarint
-//     Elems [Len]T
-//
-// stringOff means a uvarint that indicates an offset within the
-// Strings section. At that offset is another uvarint, followed by
-// that many bytes, which form the string value.
-//
-// declOff means a uvarint that indicates an offset within the Data
-// section where the associated declaration can be found.
-//
-//
-// There are five kinds of declarations, distinguished by their first
-// byte:
-//
-//     type Var struct {
-//         Tag  byte // 'V'
-//         Pos  Pos
-//         Type typeOff
-//     }
-//
-//     type Func struct {
-//         Tag       byte // 'F' or 'G'
-//         Pos       Pos
-//         TypeParams []typeOff  // only present if Tag == 'G'
-//         Signature Signature
-//     }
-//
-//     type Const struct {
-//         Tag   byte // 'C'
-//         Pos   Pos
-//         Value Value
-//     }
-//
-//     type Type struct {
-//         Tag        byte // 'T' or 'U'
-//         Pos        Pos
-//         TypeParams []typeOff  // only present if Tag == 'U'
-//         Underlying typeOff
-//
-//         Methods []struct{  // omitted if Underlying is an interface type
-//             Pos       Pos
-//             Name      stringOff
-//             Recv      Param
-//             Signature Signature
-//         }
-//     }
-//
-//     type Alias struct {
-//         Tag  byte // 'A' or 'B'
-//         Pos  Pos
-//         TypeParams []typeOff  // only present if Tag == 'B'
-//         Type typeOff
-//     }
-//
-//     // "Automatic" declaration of each typeparam
-//     type TypeParam struct {
-//         Tag        byte // 'P'
-//         Pos        Pos
-//         Implicit   bool
-//         Constraint typeOff
-//     }
-//
-// typeOff means a uvarint that either indicates a predeclared type,
-// or an offset into the Data section. If the uvarint is less than
-// predeclReserved, then it indicates the index into the predeclared
-// types list (see predeclared in bexport.go for order). Otherwise,
-// subtracting predeclReserved yields the offset of a type descriptor.
-//
-// Value means a type, kind, and type-specific value. See
-// (*exportWriter).value for details.
-//
-//
-// There are twelve kinds of type descriptors, distinguished by an itag:
-//
-//     type DefinedType struct {
-//         Tag     itag // definedType
-//         Name    stringOff
-//         PkgPath stringOff
-//     }
-//
-//     type PointerType struct {
-//         Tag  itag // pointerType
-//         Elem typeOff
-//     }
-//
-//     type SliceType struct {
-//         Tag  itag // sliceType
-//         Elem typeOff
-//     }
-//
-//     type ArrayType struct {
-//         Tag  itag // arrayType
-//         Len  uint64
-//         Elem typeOff
-//     }
-//
-//     type ChanType struct {
-//         Tag  itag   // chanType
-//         Dir  uint64 // 1 RecvOnly; 2 SendOnly; 3 SendRecv
-//         Elem typeOff
-//     }
-//
-//     type MapType struct {
-//         Tag  itag // mapType
-//         Key  typeOff
-//         Elem typeOff
-//     }
-//
-//     type FuncType struct {
-//         Tag       itag // signatureType
-//         PkgPath   stringOff
-//         Signature Signature
-//     }
-//
-//     type StructType struct {
-//         Tag     itag // structType
-//         PkgPath stringOff
-//         Fields []struct {
-//             Pos      Pos
-//             Name     stringOff
-//             Type     typeOff
-//             Embedded bool
-//             Note     stringOff
-//         }
-//     }
-//
-//     type InterfaceType struct {
-//         Tag     itag // interfaceType
-//         PkgPath stringOff
-//         Embeddeds []struct {
-//             Pos  Pos
-//             Type typeOff
-//         }
-//         Methods []struct {
-//             Pos       Pos
-//             Name      stringOff
-//             Signature Signature
-//         }
-//     }
-//
-//     // Reference to a type param declaration
-//     type TypeParamType struct {
-//         Tag     itag // typeParamType
-//         Name    stringOff
-//         PkgPath stringOff
-//     }
-//
-//     // Instantiation of a generic type (like List[T2] or List[int])
-//     type InstanceType struct {
-//         Tag     itag // instanceType
-//         Pos     pos
-//         TypeArgs []typeOff
-//         BaseType typeOff
-//     }
-//
-//     type UnionType struct {
-//         Tag     itag // interfaceType
-//         Terms   []struct {
-//             tilde bool
-//             Type  typeOff
-//         }
-//     }
-//
-//
-//
-//     type Signature struct {
-//         Params   []Param
-//         Results  []Param
-//         Variadic bool  // omitted if Results is empty
-//     }
-//
-//     type Param struct {
-//         Pos  Pos
-//         Name stringOff
-//         Type typOff
-//     }
-//
-//
-// Pos encodes a file:line:column triple, incorporating a simple delta
-// encoding scheme within a data object. See exportWriter.pos for
-// details.
-
-package gcimporter
-
-import (
-	"bytes"
-	"encoding/binary"
-	"fmt"
-	"go/constant"
-	"go/token"
-	"go/types"
-	"io"
-	"math/big"
-	"reflect"
-	"slices"
-	"sort"
-	"strconv"
-	"strings"
-
-	"golang.org/x/tools/go/types/objectpath"
-)
-
-// IExportShallow encodes "shallow" export data for the specified package.
-//
-// For types, we use "shallow" export data. Historically, the Go
-// compiler always produced a summary of the types for a given package
-// that included types from other packages that it indirectly
-// referenced: "deep" export data. This had the advantage that the
-// compiler (and analogous tools such as gopls) need only load one
-// file per direct import.  However, it meant that the files tended to
-// get larger based on the level of the package in the import
-// graph. For example, higher-level packages in the kubernetes module
-// have over 1MB of "deep" export data, even when they have almost no
-// content of their own, merely because they mention a major type that
-// references many others. In pathological cases the export data was
-// 300x larger than the source for a package due to this quadratic
-// growth.
-//
-// "Shallow" export data means that the serialized types describe only
-// a single package. If those types mention types from other packages,
-// the type checker may need to request additional packages beyond
-// just the direct imports. Type information for the entire transitive
-// closure of imports is provided (lazily) by the DAG.
-//
-// No promises are made about the encoding other than that it can be decoded by
-// the same version of IIExportShallow. If you plan to save export data in the
-// file system, be sure to include a cryptographic digest of the executable in
-// the key to avoid version skew.
-//
-// If the provided reportf func is non-nil, it is used for reporting
-// bugs (e.g. recovered panics) encountered during export, enabling us
-// to obtain via telemetry the stack that would otherwise be lost by
-// merely returning an error.
-func IExportShallow(fset *token.FileSet, pkg *types.Package, reportf ReportFunc) ([]byte, error) {
-	// In principle this operation can only fail if out.Write fails,
-	// but that's impossible for bytes.Buffer---and as a matter of
-	// fact iexportCommon doesn't even check for I/O errors.
-	// TODO(adonovan): handle I/O errors properly.
-	// TODO(adonovan): use byte slices throughout, avoiding copying.
-	const bundle, shallow = false, true
-	var out bytes.Buffer
-	err := iexportCommon(&out, fset, bundle, shallow, iexportVersion, []*types.Package{pkg}, reportf)
-	return out.Bytes(), err
-}
-
-// IImportShallow decodes "shallow" types.Package data encoded by
-// [IExportShallow] in the same executable. This function cannot import data
-// from cmd/compile or gcexportdata.Write.
-//
-// The importer calls getPackages to obtain package symbols for all
-// packages mentioned in the export data, including the one being
-// decoded.
-//
-// If the provided reportf func is non-nil, it will be used for reporting bugs
-// encountered during import.
-// TODO(rfindley): remove reportf when we are confident enough in the new
-// objectpath encoding.
-func IImportShallow(fset *token.FileSet, getPackages GetPackagesFunc, data []byte, path string, reportf ReportFunc) (*types.Package, error) {
-	const bundle = false
-	const shallow = true
-	pkgs, err := iimportCommon(fset, getPackages, data, bundle, path, shallow, reportf)
-	if err != nil {
-		return nil, err
-	}
-	return pkgs[0], nil
-}
-
-// ReportFunc is the type of a function used to report formatted bugs.
-type ReportFunc = func(string, ...any)
-
-// Current bundled export format version. Increase with each format change.
-// 0: initial implementation
-const bundleVersion = 0
-
-// IExportData writes indexed export data for pkg to out.
-//
-// If no file set is provided, position info will be missing.
-// The package path of the top-level package will not be recorded,
-// so that calls to IImportData can override with a provided package path.
-func IExportData(out io.Writer, fset *token.FileSet, pkg *types.Package) error {
-	const bundle, shallow = false, false
-	return iexportCommon(out, fset, bundle, shallow, iexportVersion, []*types.Package{pkg}, nil)
-}
-
-// IExportBundle writes an indexed export bundle for pkgs to out.
-func IExportBundle(out io.Writer, fset *token.FileSet, pkgs []*types.Package) error {
-	const bundle, shallow = true, false
-	return iexportCommon(out, fset, bundle, shallow, iexportVersion, pkgs, nil)
-}
-
-func iexportCommon(out io.Writer, fset *token.FileSet, bundle, shallow bool, version int, pkgs []*types.Package, reportf ReportFunc) (err error) {
-	if !debug {
-		defer func() {
-			if e := recover(); e != nil {
-				// Report the stack via telemetry (see #71067).
-				if reportf != nil {
-					reportf("panic in exporter")
-				}
-				if ierr, ok := e.(internalError); ok {
-					// internalError usually means we exported a
-					// bad go/types data structure: a violation
-					// of an implicit precondition of Export.
-					err = ierr
-					return
-				}
-				// Not an internal error; panic again.
-				panic(e)
-			}
-		}()
-	}
-
-	p := iexporter{
-		fset:        fset,
-		version:     version,
-		shallow:     shallow,
-		allPkgs:     map[*types.Package]bool{},
-		stringIndex: map[string]uint64{},
-		declIndex:   map[types.Object]uint64{},
-		tparamNames: map[types.Object]string{},
-		typIndex:    map[types.Type]uint64{},
-	}
-	if !bundle {
-		p.localpkg = pkgs[0]
-	}
-
-	for i, pt := range predeclared() {
-		p.typIndex[pt] = uint64(i)
-	}
-	if len(p.typIndex) > predeclReserved {
-		panic(internalErrorf("too many predeclared types: %d > %d", len(p.typIndex), predeclReserved))
-	}
-
-	// Initialize work queue with exported declarations.
-	for _, pkg := range pkgs {
-		scope := pkg.Scope()
-		for _, name := range scope.Names() {
-			if token.IsExported(name) {
-				p.pushDecl(scope.Lookup(name))
-			}
-		}
-
-		if bundle {
-			// Ensure pkg and its imports are included in the index.
-			p.allPkgs[pkg] = true
-			for _, imp := range pkg.Imports() {
-				p.allPkgs[imp] = true
-			}
-		}
-	}
-
-	// Loop until no more work.
-	for !p.declTodo.empty() {
-		p.doDecl(p.declTodo.popHead())
-	}
-
-	// Produce index of offset of each file record in files.
-	var files intWriter
-	var fileOffset []uint64 // fileOffset[i] is offset in files of file encoded as i
-	if p.shallow {
-		fileOffset = make([]uint64, len(p.fileInfos))
-		for i, info := range p.fileInfos {
-			fileOffset[i] = uint64(files.Len())
-			p.encodeFile(&files, info.file, info.needed)
-		}
-	}
-
-	// Append indices to data0 section.
-	dataLen := uint64(p.data0.Len())
-	w := p.newWriter()
-	w.writeIndex(p.declIndex)
-
-	if bundle {
-		w.uint64(uint64(len(pkgs)))
-		for _, pkg := range pkgs {
-			w.pkg(pkg)
-			imps := pkg.Imports()
-			w.uint64(uint64(len(imps)))
-			for _, imp := range imps {
-				w.pkg(imp)
-			}
-		}
-	}
-	w.flush()
-
-	// Assemble header.
-	var hdr intWriter
-	if bundle {
-		hdr.uint64(bundleVersion)
-	}
-	hdr.uint64(uint64(p.version))
-	hdr.uint64(uint64(p.strings.Len()))
-	if p.shallow {
-		hdr.uint64(uint64(files.Len()))
-		hdr.uint64(uint64(len(fileOffset)))
-		for _, offset := range fileOffset {
-			hdr.uint64(offset)
-		}
-	}
-	hdr.uint64(dataLen)
-
-	// Flush output.
-	io.Copy(out, &hdr)
-	io.Copy(out, &p.strings)
-	if p.shallow {
-		io.Copy(out, &files)
-	}
-	io.Copy(out, &p.data0)
-
-	return nil
-}
-
-// encodeFile writes to w a representation of the file sufficient to
-// faithfully restore position information about all needed offsets.
-// Mutates the needed array.
-func (p *iexporter) encodeFile(w *intWriter, file *token.File, needed []uint64) {
-	_ = needed[0] // precondition: needed is non-empty
-
-	w.uint64(p.stringOff(file.Name()))
-
-	size := uint64(file.Size())
-	w.uint64(size)
-
-	// Sort the set of needed offsets. Duplicates are harmless.
-	slices.Sort(needed)
-
-	lines := file.Lines() // byte offset of each line start
-	w.uint64(uint64(len(lines)))
-
-	// Rather than record the entire array of line start offsets,
-	// we save only a sparse list of (index, offset) pairs for
-	// the start of each line that contains a needed position.
-	var sparse [][2]int // (index, offset) pairs
-outer:
-	for i, lineStart := range lines {
-		lineEnd := size
-		if i < len(lines)-1 {
-			lineEnd = uint64(lines[i+1])
-		}
-		// Does this line contains a needed offset?
-		if needed[0] < lineEnd {
-			sparse = append(sparse, [2]int{i, lineStart})
-			for needed[0] < lineEnd {
-				needed = needed[1:]
-				if len(needed) == 0 {
-					break outer
-				}
-			}
-		}
-	}
-
-	// Delta-encode the columns.
-	w.uint64(uint64(len(sparse)))
-	var prev [2]int
-	for _, pair := range sparse {
-		w.uint64(uint64(pair[0] - prev[0]))
-		w.uint64(uint64(pair[1] - prev[1]))
-		prev = pair
-	}
-}
-
-// writeIndex writes out an object index. mainIndex indicates whether
-// we're writing out the main index, which is also read by
-// non-compiler tools and includes a complete package description
-// (i.e., name and height).
-func (w *exportWriter) writeIndex(index map[types.Object]uint64) {
-	type pkgObj struct {
-		obj  types.Object
-		name string // qualified name; differs from obj.Name for type params
-	}
-	// Build a map from packages to objects from that package.
-	pkgObjs := map[*types.Package][]pkgObj{}
-
-	// For the main index, make sure to include every package that
-	// we reference, even if we're not exporting (or reexporting)
-	// any symbols from it.
-	if w.p.localpkg != nil {
-		pkgObjs[w.p.localpkg] = nil
-	}
-	for pkg := range w.p.allPkgs {
-		pkgObjs[pkg] = nil
-	}
-
-	for obj := range index {
-		name := w.p.exportName(obj)
-		pkgObjs[obj.Pkg()] = append(pkgObjs[obj.Pkg()], pkgObj{obj, name})
-	}
-
-	var pkgs []*types.Package
-	for pkg, objs := range pkgObjs {
-		pkgs = append(pkgs, pkg)
-
-		sort.Slice(objs, func(i, j int) bool {
-			return objs[i].name < objs[j].name
-		})
-	}
-
-	sort.Slice(pkgs, func(i, j int) bool {
-		return w.exportPath(pkgs[i]) < w.exportPath(pkgs[j])
-	})
-
-	w.uint64(uint64(len(pkgs)))
-	for _, pkg := range pkgs {
-		w.string(w.exportPath(pkg))
-		w.string(pkg.Name())
-		w.uint64(uint64(0)) // package height is not needed for go/types
-
-		objs := pkgObjs[pkg]
-		w.uint64(uint64(len(objs)))
-		for _, obj := range objs {
-			w.string(obj.name)
-			w.uint64(index[obj.obj])
-		}
-	}
-}
-
-// exportName returns the 'exported' name of an object. It differs from
-// obj.Name() only for type parameters (see tparamExportName for details).
-func (p *iexporter) exportName(obj types.Object) (res string) {
-	if name := p.tparamNames[obj]; name != "" {
-		return name
-	}
-	return obj.Name()
-}
-
-type iexporter struct {
-	fset    *token.FileSet
-	version int
-
-	shallow    bool                // don't put types from other packages in the index
-	objEncoder *objectpath.Encoder // encodes objects from other packages in shallow mode; lazily allocated
-	localpkg   *types.Package      // (nil in bundle mode)
-
-	// allPkgs tracks all packages that have been referenced by
-	// the export data, so we can ensure to include them in the
-	// main index.
-	allPkgs map[*types.Package]bool
-
-	declTodo objQueue
-
-	strings     intWriter
-	stringIndex map[string]uint64
-
-	// In shallow mode, object positions are encoded as (file, offset).
-	// Each file is recorded as a line-number table.
-	// Only the lines of needed positions are saved faithfully.
-	fileInfo  map[*token.File]uint64 // value is index in fileInfos
-	fileInfos []*filePositions
-
-	data0       intWriter
-	declIndex   map[types.Object]uint64
-	tparamNames map[types.Object]string // typeparam->exported name
-	typIndex    map[types.Type]uint64
-
-	indent int // for tracing support
-}
-
-type filePositions struct {
-	file   *token.File
-	needed []uint64 // unordered list of needed file offsets
-}
-
-func (p *iexporter) trace(format string, args ...any) {
-	if !trace {
-		// Call sites should also be guarded, but having this check here allows
-		// easily enabling/disabling debug trace statements.
-		return
-	}
-	fmt.Printf(strings.Repeat("..", p.indent)+format+"\n", args...)
-}
-
-// objectpathEncoder returns the lazily allocated objectpath.Encoder to use
-// when encoding objects in other packages during shallow export.
-//
-// Using a shared Encoder amortizes some of cost of objectpath search.
-func (p *iexporter) objectpathEncoder() *objectpath.Encoder {
-	if p.objEncoder == nil {
-		p.objEncoder = new(objectpath.Encoder)
-	}
-	return p.objEncoder
-}
-
-// stringOff returns the offset of s within the string section.
-// If not already present, it's added to the end.
-func (p *iexporter) stringOff(s string) uint64 {
-	off, ok := p.stringIndex[s]
-	if !ok {
-		off = uint64(p.strings.Len())
-		p.stringIndex[s] = off
-
-		p.strings.uint64(uint64(len(s)))
-		p.strings.WriteString(s)
-	}
-	return off
-}
-
-// fileIndexAndOffset returns the index of the token.File and the byte offset of pos within it.
-func (p *iexporter) fileIndexAndOffset(file *token.File, pos token.Pos) (uint64, uint64) {
-	index, ok := p.fileInfo[file]
-	if !ok {
-		index = uint64(len(p.fileInfo))
-		p.fileInfos = append(p.fileInfos, &filePositions{file: file})
-		if p.fileInfo == nil {
-			p.fileInfo = make(map[*token.File]uint64)
-		}
-		p.fileInfo[file] = index
-	}
-	// Record each needed offset.
-	info := p.fileInfos[index]
-	offset := uint64(file.Offset(pos))
-	info.needed = append(info.needed, offset)
-
-	return index, offset
-}
-
-// pushDecl adds n to the declaration work queue, if not already present.
-func (p *iexporter) pushDecl(obj types.Object) {
-	// Package unsafe is known to the compiler and predeclared.
-	// Caller should not ask us to do export it.
-	if obj.Pkg() == types.Unsafe {
-		panic("cannot export package unsafe")
-	}
-
-	// Shallow export data: don't index decls from other packages.
-	if p.shallow && obj.Pkg() != p.localpkg {
-		return
-	}
-
-	if _, ok := p.declIndex[obj]; ok {
-		return
-	}
-
-	p.declIndex[obj] = ^uint64(0) // mark obj present in work queue
-	p.declTodo.pushTail(obj)
-}
-
-// exportWriter handles writing out individual data section chunks.
-type exportWriter struct {
-	p *iexporter
-
-	data       intWriter
-	prevFile   string
-	prevLine   int64
-	prevColumn int64
-}
-
-func (w *exportWriter) exportPath(pkg *types.Package) string {
-	if pkg == w.p.localpkg {
-		return ""
-	}
-	return pkg.Path()
-}
-
-func (p *iexporter) doDecl(obj types.Object) {
-	if trace {
-		p.trace("exporting decl %v (%T)", obj, obj)
-		p.indent++
-		defer func() {
-			p.indent--
-			p.trace("=> %s", obj)
-		}()
-	}
-	w := p.newWriter()
-
-	switch obj := obj.(type) {
-	case *types.Var:
-		w.tag(varTag)
-		w.pos(obj.Pos())
-		w.typ(obj.Type(), obj.Pkg())
-
-	case *types.Func:
-		sig, _ := obj.Type().(*types.Signature)
-		if sig.Recv() != nil {
-			// We shouldn't see methods in the package scope,
-			// but the type checker may repair "func () F() {}"
-			// to "func (Invalid) F()" and then treat it like "func F()",
-			// so allow that. See golang/go#57729.
-			if sig.Recv().Type() != types.Typ[types.Invalid] {
-				panic(internalErrorf("unexpected method: %v", sig))
-			}
-		}
-
-		// Function.
-		if sig.TypeParams().Len() == 0 {
-			w.tag(funcTag)
-		} else {
-			w.tag(genericFuncTag)
-		}
-		w.pos(obj.Pos())
-		// The tparam list of the function type is the declaration of the type
-		// params. So, write out the type params right now. Then those type params
-		// will be referenced via their type offset (via typOff) in all other
-		// places in the signature and function where they are used.
-		//
-		// While importing the type parameters, tparamList computes and records
-		// their export name, so that it can be later used when writing the index.
-		if tparams := sig.TypeParams(); tparams.Len() > 0 {
-			w.tparamList(obj.Name(), tparams, obj.Pkg())
-		}
-		w.signature(sig)
-
-	case *types.Const:
-		w.tag(constTag)
-		w.pos(obj.Pos())
-		w.value(obj.Type(), obj.Val())
-
-	case *types.TypeName:
-		t := obj.Type()
-
-		if tparam, ok := types.Unalias(t).(*types.TypeParam); ok {
-			w.tag(typeParamTag)
-			w.pos(obj.Pos())
-			constraint := tparam.Constraint()
-			if p.version >= iexportVersionGo1_18 {
-				implicit := false
-				if iface, _ := types.Unalias(constraint).(*types.Interface); iface != nil {
-					implicit = iface.IsImplicit()
-				}
-				w.bool(implicit)
-			}
-			w.typ(constraint, obj.Pkg())
-			break
-		}
-
-		if obj.IsAlias() {
-			alias, materialized := t.(*types.Alias) // perhaps false for certain built-ins?
-
-			var tparams *types.TypeParamList
-			if materialized {
-				tparams = alias.TypeParams()
-			}
-			if tparams.Len() == 0 {
-				w.tag(aliasTag)
-			} else {
-				w.tag(genericAliasTag)
-			}
-			w.pos(obj.Pos())
-			if tparams.Len() > 0 {
-				w.tparamList(obj.Name(), tparams, obj.Pkg())
-			}
-			if materialized {
-				// Preserve materialized aliases,
-				// even of non-exported types.
-				t = alias.Rhs()
-			}
-			w.typ(t, obj.Pkg())
-			break
-		}
-
-		// Defined type.
-		named, ok := t.(*types.Named)
-		if !ok {
-			panic(internalErrorf("%s is not a defined type", t))
-		}
-
-		if named.TypeParams().Len() == 0 {
-			w.tag(typeTag)
-		} else {
-			w.tag(genericTypeTag)
-		}
-		w.pos(obj.Pos())
-
-		if named.TypeParams().Len() > 0 {
-			// While importing the type parameters, tparamList computes and records
-			// their export name, so that it can be later used when writing the index.
-			w.tparamList(obj.Name(), named.TypeParams(), obj.Pkg())
-		}
-
-		underlying := named.Underlying()
-		w.typ(underlying, obj.Pkg())
-
-		if types.IsInterface(t) {
-			break
-		}
-
-		n := named.NumMethods()
-		w.uint64(uint64(n))
-		for i := range n {
-			m := named.Method(i)
-			w.pos(m.Pos())
-			w.string(m.Name())
-			sig, _ := m.Type().(*types.Signature)
-			if w.p.version >= iexportVersionGenericMethods && w.bool(sig.TypeParams().Len() > 0) {
-				w.tparamList(obj.Name()+"."+m.Name(), sig.TypeParams(), obj.Pkg())
-			}
-
-			// Receiver type parameters are type arguments of the receiver type, so
-			// their name must be qualified before exporting recv.
-			if rparams := sig.RecvTypeParams(); rparams.Len() > 0 {
-				prefix := obj.Name() + "." + m.Name()
-				for rparam := range rparams.TypeParams() {
-					name := tparamExportName(prefix, rparam)
-					w.p.tparamNames[rparam.Obj()] = name
-				}
-			}
-			w.param(sig.Recv())
-			w.signature(sig)
-		}
-
-	default:
-		panic(internalErrorf("unexpected object: %v", obj))
-	}
-
-	p.declIndex[obj] = w.flush()
-}
-
-func (w *exportWriter) tag(tag byte) {
-	w.data.WriteByte(tag)
-}
-
-func (w *exportWriter) pos(pos token.Pos) {
-	if w.p.shallow {
-		w.posV2(pos)
-	} else if w.p.version >= iexportVersionPosCol {
-		w.posV1(pos)
-	} else {
-		w.posV0(pos)
-	}
-}
-
-// posV2 encoding (used only in shallow mode) records positions as
-// (file, offset), where file is the index in the token.File table
-// (which records the file name and newline offsets) and offset is a
-// byte offset. It effectively ignores //line directives.
-func (w *exportWriter) posV2(pos token.Pos) {
-	if pos == token.NoPos {
-		w.uint64(0)
-		return
-	}
-	file := w.p.fset.File(pos) // fset must be non-nil
-	index, offset := w.p.fileIndexAndOffset(file, pos)
-	w.uint64(1 + index)
-	w.uint64(offset)
-}
-
-func (w *exportWriter) posV1(pos token.Pos) {
-	if w.p.fset == nil {
-		w.int64(0)
-		return
-	}
-
-	p := w.p.fset.Position(pos)
-	file := p.Filename
-	line := int64(p.Line)
-	column := int64(p.Column)
-
-	deltaColumn := (column - w.prevColumn) << 1
-	deltaLine := (line - w.prevLine) << 1
-
-	if file != w.prevFile {
-		deltaLine |= 1
-	}
-	if deltaLine != 0 {
-		deltaColumn |= 1
-	}
-
-	w.int64(deltaColumn)
-	if deltaColumn&1 != 0 {
-		w.int64(deltaLine)
-		if deltaLine&1 != 0 {
-			w.string(file)
-		}
-	}
-
-	w.prevFile = file
-	w.prevLine = line
-	w.prevColumn = column
-}
-
-func (w *exportWriter) posV0(pos token.Pos) {
-	if w.p.fset == nil {
-		w.int64(0)
-		return
-	}
-
-	p := w.p.fset.Position(pos)
-	file := p.Filename
-	line := int64(p.Line)
-
-	// When file is the same as the last position (common case),
-	// we can save a few bytes by delta encoding just the line
-	// number.
-	//
-	// Note: Because data objects may be read out of order (or not
-	// at all), we can only apply delta encoding within a single
-	// object. This is handled implicitly by tracking prevFile and
-	// prevLine as fields of exportWriter.
-
-	if file == w.prevFile {
-		delta := line - w.prevLine
-		w.int64(delta)
-		if delta == deltaNewFile {
-			w.int64(-1)
-		}
-	} else {
-		w.int64(deltaNewFile)
-		w.int64(line) // line >= 0
-		w.string(file)
-		w.prevFile = file
-	}
-	w.prevLine = line
-}
-
-func (w *exportWriter) pkg(pkg *types.Package) {
-	if pkg == nil {
-		// [exportWriter.typ] accepts a nil pkg only for types
-		// of constants, which cannot contain named objects
-		// such as fields or methods and thus should never
-		// reach this method (#76222).
-		panic("nil package")
-	}
-	// Ensure any referenced packages are declared in the main index.
-	w.p.allPkgs[pkg] = true
-
-	w.string(w.exportPath(pkg))
-}
-
-func (w *exportWriter) qualifiedType(obj *types.TypeName) {
-	name := w.p.exportName(obj)
-
-	// Ensure any referenced declarations are written out too.
-	w.p.pushDecl(obj)
-	w.string(name)
-	w.pkg(obj.Pkg())
-}
-
-// typ emits the specified type.
-//
-// Objects within the type (struct fields and interface methods) are
-// qualified by pkg. It may be nil if the type cannot contain objects,
-// such as the type of a constant.
-func (w *exportWriter) typ(t types.Type, pkg *types.Package) {
-	w.data.uint64(w.p.typOff(t, pkg))
-}
-
-func (p *iexporter) newWriter() *exportWriter {
-	return &exportWriter{p: p}
-}
-
-func (w *exportWriter) flush() uint64 {
-	off := uint64(w.p.data0.Len())
-	io.Copy(&w.p.data0, &w.data)
-	return off
-}
-
-func (p *iexporter) typOff(t types.Type, pkg *types.Package) uint64 {
-	off, ok := p.typIndex[t]
-	if !ok {
-		w := p.newWriter()
-		w.doTyp(t, pkg)
-		off = predeclReserved + w.flush()
-		p.typIndex[t] = off
-	}
-	return off
-}
-
-func (w *exportWriter) startType(k itag) {
-	w.data.uint64(uint64(k))
-}
-
-// doTyp is the implementation of [exportWriter.typ].
-func (w *exportWriter) doTyp(t types.Type, pkg *types.Package) {
-	if trace {
-		w.p.trace("exporting type %s (%T)", t, t)
-		w.p.indent++
-		defer func() {
-			w.p.indent--
-			w.p.trace("=> %s", t)
-		}()
-	}
-	switch t := t.(type) {
-	case *types.Alias:
-		if targs := t.TypeArgs(); targs.Len() > 0 {
-			w.startType(instanceType)
-			w.pos(t.Obj().Pos())
-			w.typeList(targs, pkg)
-			w.typ(t.Origin(), pkg)
-			return
-		}
-		w.startType(aliasType)
-		w.qualifiedType(t.Obj())
-
-	case *types.Named:
-		if targs := t.TypeArgs(); targs.Len() > 0 {
-			w.startType(instanceType)
-			// TODO(rfindley): investigate if this position is correct, and if it
-			// matters.
-			w.pos(t.Obj().Pos())
-			w.typeList(targs, pkg)
-			w.typ(t.Origin(), pkg)
-			return
-		}
-		w.startType(definedType)
-		w.qualifiedType(t.Obj())
-
-	case *types.TypeParam:
-		w.startType(typeParamType)
-		w.qualifiedType(t.Obj())
-
-	case *types.Pointer:
-		w.startType(pointerType)
-		w.typ(t.Elem(), pkg)
-
-	case *types.Slice:
-		w.startType(sliceType)
-		w.typ(t.Elem(), pkg)
-
-	case *types.Array:
-		w.startType(arrayType)
-		w.uint64(uint64(t.Len()))
-		w.typ(t.Elem(), pkg)
-
-	case *types.Chan:
-		w.startType(chanType)
-		// 1 RecvOnly; 2 SendOnly; 3 SendRecv
-		var dir uint64
-		switch t.Dir() {
-		case types.RecvOnly:
-			dir = 1
-		case types.SendOnly:
-			dir = 2
-		case types.SendRecv:
-			dir = 3
-		}
-		w.uint64(dir)
-		w.typ(t.Elem(), pkg)
-
-	case *types.Map:
-		w.startType(mapType)
-		w.typ(t.Key(), pkg)
-		w.typ(t.Elem(), pkg)
-
-	case *types.Signature:
-		w.startType(signatureType)
-		w.pkg(pkg) // qualifies param/result vars
-		w.signature(t)
-
-	case *types.Struct:
-		w.startType(structType)
-		n := t.NumFields()
-		// Even for struct{} we must emit some qualifying package, because that's
-		// what the compiler does, and thus that's what the importer expects.
-		fieldPkg := pkg
-		if n > 0 {
-			fieldPkg = t.Field(0).Pkg()
-		}
-		if fieldPkg == nil {
-			// TODO(rfindley): improve this very hacky logic.
-			//
-			// The importer expects a package to be set for all struct types, even
-			// those with no fields. A better encoding might be to set NumFields
-			// before pkg. setPkg panics with a nil package, which may be possible
-			// to reach with invalid packages (and perhaps valid packages, too?), so
-			// (arbitrarily) set the localpkg if available.
-			//
-			// Alternatively, we may be able to simply guarantee that pkg != nil, by
-			// reconsidering the encoding of constant values.
-			if w.p.shallow {
-				fieldPkg = w.p.localpkg
-			} else {
-				panic(internalErrorf("no package to set for empty struct"))
-			}
-		}
-		w.pkg(fieldPkg)
-		w.uint64(uint64(n))
-
-		for i := range n {
-			f := t.Field(i)
-			if w.p.shallow {
-				w.objectPath(f)
-			}
-			w.pos(f.Pos())
-			w.string(f.Name()) // unexported fields implicitly qualified by prior setPkg
-			w.typ(f.Type(), fieldPkg)
-			w.bool(f.Anonymous())
-			w.string(t.Tag(i)) // note (or tag)
-		}
-
-	case *types.Interface:
-		w.startType(interfaceType)
-		w.pkg(pkg) // qualifies unexported method funcs
-
-		n := t.NumEmbeddeds()
-		w.uint64(uint64(n))
-		for i := 0; i < n; i++ {
-			ft := t.EmbeddedType(i)
-			if named, _ := types.Unalias(ft).(*types.Named); named != nil {
-				w.pos(named.Obj().Pos())
-			} else {
-				// e.g. ~int
-				w.pos(token.NoPos)
-			}
-			w.typ(ft, pkg)
-		}
-
-		// See comment for struct fields. In shallow mode we change the encoding
-		// for interface methods that are promoted from other packages.
-
-		n = t.NumExplicitMethods()
-		w.uint64(uint64(n))
-		for i := 0; i < n; i++ {
-			m := t.ExplicitMethod(i)
-			if w.p.shallow {
-				w.objectPath(m)
-			}
-			w.pos(m.Pos())
-			w.string(m.Name())
-			sig, _ := m.Type().(*types.Signature)
-			w.signature(sig)
-		}
-
-	case *types.Union:
-		w.startType(unionType)
-		nt := t.Len()
-		w.uint64(uint64(nt))
-		for i := range nt {
-			term := t.Term(i)
-			w.bool(term.Tilde())
-			w.typ(term.Type(), pkg)
-		}
-
-	default:
-		panic(internalErrorf("unexpected type: %v, %v", t, reflect.TypeOf(t)))
-	}
-}
-
-// objectPath writes the package and objectPath to use to look up obj in a
-// different package, when encoding in "shallow" mode.
-//
-// When doing a shallow import, the importer creates only the local package,
-// and requests package symbols for dependencies from the client.
-// However, certain types defined in the local package may hold objects defined
-// (perhaps deeply) within another package.
-//
-// For example, consider the following:
-//
-//	package a
-//	func F() chan * map[string] struct { X int }
-//
-//	package b
-//	import "a"
-//	var B = a.F()
-//
-// In this example, the type of b.B holds fields defined in package a.
-// In order to have the correct canonical objects for the field defined in the
-// type of B, they are encoded as objectPaths and later looked up in the
-// importer. The same problem applies to interface methods.
-func (w *exportWriter) objectPath(obj types.Object) {
-	if obj.Pkg() == nil || obj.Pkg() == w.p.localpkg {
-		// obj.Pkg() may be nil for the builtin error.Error.
-		// In this case, or if obj is declared in the local package, no need to
-		// encode.
-		w.string("")
-		return
-	}
-	objectPath, err := w.p.objectpathEncoder().For(obj)
-	if err != nil {
-		// Fall back to the empty string, which will cause the importer to create a
-		// new object, which matches earlier behavior. Creating a new object is
-		// sufficient for many purposes (such as type checking), but causes certain
-		// references algorithms to fail (golang/go#60819). However, we didn't
-		// notice this problem during months of gopls@v0.12.0 testing.
-		//
-		// TODO(golang/go#61674): this workaround is insufficient, as in the case
-		// where the field forwarded from an instantiated type that may not appear
-		// in the export data of the original package:
-		//
-		//  // package a
-		//  type A[P any] struct{ F P }
-		//
-		//  // package b
-		//  type B a.A[int]
-		//
-		// We need to update references algorithms not to depend on this
-		// de-duplication, at which point we may want to simply remove the
-		// workaround here.
-		w.string("")
-		return
-	}
-	w.string(string(objectPath))
-	w.pkg(obj.Pkg())
-}
-
-func (w *exportWriter) signature(sig *types.Signature) {
-	w.paramList(sig.Params())
-	w.paramList(sig.Results())
-	if sig.Params().Len() > 0 {
-		w.bool(sig.Variadic())
-	}
-}
-
-func (w *exportWriter) typeList(ts *types.TypeList, pkg *types.Package) {
-	w.uint64(uint64(ts.Len()))
-	for t := range ts.Types() {
-		w.typ(t, pkg)
-	}
-}
-
-func (w *exportWriter) tparamList(prefix string, list *types.TypeParamList, pkg *types.Package) {
-	ll := uint64(list.Len())
-	w.uint64(ll)
-	for tparam := range list.TypeParams() {
-		// Set the type parameter exportName before exporting its type.
-		exportName := tparamExportName(prefix, tparam)
-		w.p.tparamNames[tparam.Obj()] = exportName
-		w.typ(tparam, pkg)
-	}
-}
-
-const blankMarker = "$"
-
-// tparamExportName returns the 'exported' name of a type parameter, which
-// differs from its actual object name: it is prefixed with a qualifier, and
-// blank type parameter names are disambiguated by their index in the type
-// parameter list.
-func tparamExportName(prefix string, tparam *types.TypeParam) string {
-	assert(prefix != "")
-	name := tparam.Obj().Name()
-	if name == "_" {
-		name = blankMarker + strconv.Itoa(tparam.Index())
-	}
-	return prefix + "." + name
-}
-
-// tparamName returns the real name of a type parameter, after stripping its
-// qualifying prefix and reverting blank-name encoding. See tparamExportName
-// for details.
-func tparamName(exportName string) string {
-	// Remove the "path" from the type param name that makes it unique.
-	ix := strings.LastIndex(exportName, ".")
-	if ix < 0 {
-		errorf("malformed type parameter export name %s: missing prefix", exportName)
-	}
-	name := exportName[ix+1:]
-	if strings.HasPrefix(name, blankMarker) {
-		return "_"
-	}
-	return name
-}
-
-func (w *exportWriter) paramList(tup *types.Tuple) {
-	n := tup.Len()
-	w.uint64(uint64(n))
-	for i := range n {
-		w.param(tup.At(i))
-	}
-}
-
-func (w *exportWriter) param(obj types.Object) {
-	w.pos(obj.Pos())
-	w.localIdent(obj)
-	w.typ(obj.Type(), obj.Pkg())
-}
-
-func (w *exportWriter) value(typ types.Type, v constant.Value) {
-	w.typ(typ, nil)
-	if w.p.version >= iexportVersionGo1_18 {
-		w.int64(int64(v.Kind()))
-	}
-
-	if v.Kind() == constant.Unknown {
-		// golang/go#60605: treat unknown constant values as if they have invalid type
-		//
-		// This loses some fidelity over the package type-checked from source, but that
-		// is acceptable.
-		//
-		// TODO(rfindley): we should switch on the recorded constant kind rather
-		// than the constant type
-		return
-	}
-
-	switch b := typ.Underlying().(*types.Basic); b.Info() & types.IsConstType {
-	case types.IsBoolean:
-		w.bool(constant.BoolVal(v))
-	case types.IsInteger:
-		var i big.Int
-		if i64, exact := constant.Int64Val(v); exact {
-			i.SetInt64(i64)
-		} else if ui64, exact := constant.Uint64Val(v); exact {
-			i.SetUint64(ui64)
-		} else {
-			i.SetString(v.ExactString(), 10)
-		}
-		w.mpint(&i, typ)
-	case types.IsFloat:
-		f := constantToFloat(v)
-		w.mpfloat(f, typ)
-	case types.IsComplex:
-		w.mpfloat(constantToFloat(constant.Real(v)), typ)
-		w.mpfloat(constantToFloat(constant.Imag(v)), typ)
-	case types.IsString:
-		w.string(constant.StringVal(v))
-	default:
-		if b.Kind() == types.Invalid {
-			// package contains type errors
-			break
-		}
-		panic(internalErrorf("unexpected type %v (%v)", typ, typ.Underlying()))
-	}
-}
-
-// constantToFloat converts a constant.Value with kind constant.Float to a
-// big.Float.
-func constantToFloat(x constant.Value) *big.Float {
-	x = constant.ToFloat(x)
-	// Use the same floating-point precision (512) as cmd/compile
-	// (see Mpprec in cmd/compile/internal/gc/mpfloat.go).
-	const mpprec = 512
-	var f big.Float
-	f.SetPrec(mpprec)
-	if v, exact := constant.Float64Val(x); exact {
-		// float64
-		f.SetFloat64(v)
-	} else if num, denom := constant.Num(x), constant.Denom(x); num.Kind() == constant.Int {
-		// TODO(gri): add big.Rat accessor to constant.Value.
-		n := valueToRat(num)
-		d := valueToRat(denom)
-		f.SetRat(n.Quo(n, d))
-	} else {
-		// Value too large to represent as a fraction => inaccessible.
-		// TODO(gri): add big.Float accessor to constant.Value.
-		_, ok := f.SetString(x.ExactString())
-		assert(ok)
-	}
-	return &f
-}
-
-func valueToRat(x constant.Value) *big.Rat {
-	// Convert little-endian to big-endian.
-	// I can't believe this is necessary.
-	bytes := constant.Bytes(x)
-	for i := 0; i < len(bytes)/2; i++ {
-		bytes[i], bytes[len(bytes)-1-i] = bytes[len(bytes)-1-i], bytes[i]
-	}
-	return new(big.Rat).SetInt(new(big.Int).SetBytes(bytes))
-}
-
-// mpint exports a multi-precision integer.
-//
-// For unsigned types, small values are written out as a single
-// byte. Larger values are written out as a length-prefixed big-endian
-// byte string, where the length prefix is encoded as its complement.
-// For example, bytes 0, 1, and 2 directly represent the integer
-// values 0, 1, and 2; while bytes 255, 254, and 253 indicate a 1-,
-// 2-, and 3-byte big-endian string follow.
-//
-// Encoding for signed types use the same general approach as for
-// unsigned types, except small values use zig-zag encoding and the
-// bottom bit of length prefix byte for large values is reserved as a
-// sign bit.
-//
-// The exact boundary between small and large encodings varies
-// according to the maximum number of bytes needed to encode a value
-// of type typ. As a special case, 8-bit types are always encoded as a
-// single byte.
-//
-// TODO(mdempsky): Is this level of complexity really worthwhile?
-func (w *exportWriter) mpint(x *big.Int, typ types.Type) {
-	basic, ok := typ.Underlying().(*types.Basic)
-	if !ok {
-		panic(internalErrorf("unexpected type %v (%T)", typ.Underlying(), typ.Underlying()))
-	}
-
-	signed, maxBytes := intSize(basic)
-
-	negative := x.Sign() < 0
-	if !signed && negative {
-		panic(internalErrorf("negative unsigned integer; type %v, value %v", typ, x))
-	}
-
-	b := x.Bytes()
-	if len(b) > 0 && b[0] == 0 {
-		panic(internalErrorf("leading zeros"))
-	}
-	if uint(len(b)) > maxBytes {
-		panic(internalErrorf("bad mpint length: %d > %d (type %v, value %v)", len(b), maxBytes, typ, x))
-	}
-
-	maxSmall := 256 - maxBytes
-	if signed {
-		maxSmall = 256 - 2*maxBytes
-	}
-	if maxBytes == 1 {
-		maxSmall = 256
-	}
-
-	// Check if x can use small value encoding.
-	if len(b) <= 1 {
-		var ux uint
-		if len(b) == 1 {
-			ux = uint(b[0])
-		}
-		if signed {
-			ux <<= 1
-			if negative {
-				ux--
-			}
-		}
-		if ux < maxSmall {
-			w.data.WriteByte(byte(ux))
-			return
-		}
-	}
-
-	n := 256 - uint(len(b))
-	if signed {
-		n = 256 - 2*uint(len(b))
-		if negative {
-			n |= 1
-		}
-	}
-	if n < maxSmall || n >= 256 {
-		panic(internalErrorf("encoding mistake: %d, %v, %v => %d", len(b), signed, negative, n))
-	}
-
-	w.data.WriteByte(byte(n))
-	w.data.Write(b)
-}
-
-// mpfloat exports a multi-precision floating point number.
-//
-// The number's value is decomposed into mantissa × 2**exponent, where
-// mantissa is an integer. The value is written out as mantissa (as a
-// multi-precision integer) and then the exponent, except exponent is
-// omitted if mantissa is zero.
-func (w *exportWriter) mpfloat(f *big.Float, typ types.Type) {
-	if f.IsInf() {
-		panic("infinite constant")
-	}
-
-	// Break into f = mant × 2**exp, with 0.5 <= mant < 1.
-	var mant big.Float
-	exp := int64(f.MantExp(&mant))
-
-	// Scale so that mant is an integer.
-	prec := mant.MinPrec()
-	mant.SetMantExp(&mant, int(prec))
-	exp -= int64(prec)
-
-	manti, acc := mant.Int(nil)
-	if acc != big.Exact {
-		panic(internalErrorf("mantissa scaling failed for %f (%s)", f, acc))
-	}
-	w.mpint(manti, typ)
-	if manti.Sign() != 0 {
-		w.int64(exp)
-	}
-}
-
-func (w *exportWriter) bool(b bool) bool {
-	var x uint64
-	if b {
-		x = 1
-	}
-	w.uint64(x)
-	return b
-}
-
-func (w *exportWriter) int64(x int64)   { w.data.int64(x) }
-func (w *exportWriter) uint64(x uint64) { w.data.uint64(x) }
-func (w *exportWriter) string(s string) { w.uint64(w.p.stringOff(s)) }
-
-func (w *exportWriter) localIdent(obj types.Object) {
-	// Anonymous parameters.
-	if obj == nil {
-		w.string("")
-		return
-	}
-
-	name := obj.Name()
-	if name == "_" {
-		w.string("_")
-		return
-	}
-
-	w.string(name)
-}
-
-type intWriter struct {
-	bytes.Buffer
-}
-
-func (w *intWriter) int64(x int64) {
-	var buf [binary.MaxVarintLen64]byte
-	n := binary.PutVarint(buf[:], x)
-	w.Write(buf[:n])
-}
-
-func (w *intWriter) uint64(x uint64) {
-	var buf [binary.MaxVarintLen64]byte
-	n := binary.PutUvarint(buf[:], x)
-	w.Write(buf[:n])
-}
-
-func assert(cond bool) {
-	if !cond {
-		panic("internal error: assertion failed")
-	}
-}
-
-// The below is copied from go/src/cmd/compile/internal/gc/syntax.go.
-
-// objQueue is a FIFO queue of types.Object. The zero value of objQueue is
-// a ready-to-use empty queue.
-type objQueue struct {
-	ring       []types.Object
-	head, tail int
-}
-
-// empty returns true if q contains no Nodes.
-func (q *objQueue) empty() bool {
-	return q.head == q.tail
-}
-
-// pushTail appends n to the tail of the queue.
-func (q *objQueue) pushTail(obj types.Object) {
-	if len(q.ring) == 0 {
-		q.ring = make([]types.Object, 16)
-	} else if q.head+len(q.ring) == q.tail {
-		// Grow the ring.
-		nring := make([]types.Object, len(q.ring)*2)
-		// Copy the old elements.
-		part := q.ring[q.head%len(q.ring):]
-		if q.tail-q.head <= len(part) {
-			part = part[:q.tail-q.head]
-			copy(nring, part)
-		} else {
-			pos := copy(nring, part)
-			copy(nring[pos:], q.ring[:q.tail%len(q.ring)])
-		}
-		q.ring, q.head, q.tail = nring, 0, q.tail-q.head
-	}
-
-	q.ring[q.tail%len(q.ring)] = obj
-	q.tail++
-}
-
-// popHead pops a node from the head of the queue. It panics if q is empty.
-func (q *objQueue) popHead() types.Object {
-	if q.empty() {
-		panic("dequeue empty")
-	}
-	obj := q.ring[q.head%len(q.ring)]
-	q.head++
-	return obj
-}
-
-// internalError represents an error generated inside this package.
-type internalError string
-
-func (e internalError) Error() string { return "gcimporter: " + string(e) }
-
-// TODO(adonovan): make this call panic, so that it's symmetric with errorf.
-// Otherwise it's easy to forget to do anything with the error.
-//
-// TODO(adonovan): also, consider switching the names "errorf" and
-// "internalErrorf" as the former is used for bugs, whose cause is
-// internal inconsistency, whereas the latter is used for ordinary
-// situations like bad input, whose cause is external.
-func internalErrorf(format string, args ...any) error {
-	return internalError(fmt.Sprintf(format, args...))
-}
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/iimport.go b/vendor/golang.org/x/tools/internal/gcimporter/iimport.go
deleted file mode 100644
index 7b1723e0fc..0000000000
--- a/vendor/golang.org/x/tools/internal/gcimporter/iimport.go
+++ /dev/null
@@ -1,1122 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Indexed package import.
-// See iexport.go for the export data format.
-
-package gcimporter
-
-import (
-	"bytes"
-	"encoding/binary"
-	"fmt"
-	"go/constant"
-	"go/token"
-	"go/types"
-	"io"
-	"math/big"
-	"slices"
-	"sort"
-	"strings"
-
-	"golang.org/x/tools/go/types/objectpath"
-	"golang.org/x/tools/internal/aliases"
-	"golang.org/x/tools/internal/typesinternal"
-)
-
-type intReader struct {
-	*bytes.Reader
-	path string
-}
-
-func (r *intReader) int64() int64 {
-	i, err := binary.ReadVarint(r.Reader)
-	if err != nil {
-		errorf("import %q: read varint error: %v", r.path, err)
-	}
-	return i
-}
-
-func (r *intReader) uint64() uint64 {
-	i, err := binary.ReadUvarint(r.Reader)
-	if err != nil {
-		errorf("import %q: read varint error: %v", r.path, err)
-	}
-	return i
-}
-
-// Keep this in sync with constants in iexport.go.
-const (
-	iexportVersionGo1_11         = 0
-	iexportVersionPosCol         = 1
-	iexportVersionGo1_18         = 2
-	iexportVersionGenerics       = 2
-	iexportVersionGenericMethods = 3
-	iexportVersion               = iexportVersionGenericMethods
-
-	iexportVersionCurrent = 3
-)
-
-type ident struct {
-	pkg  *types.Package
-	name string
-}
-
-const predeclReserved = 32
-
-type itag uint64
-
-const (
-	// Types
-	definedType itag = iota
-	pointerType
-	sliceType
-	arrayType
-	chanType
-	mapType
-	signatureType
-	structType
-	interfaceType
-	typeParamType
-	instanceType
-	unionType
-	aliasType
-)
-
-// Object tags
-const (
-	varTag          = 'V'
-	funcTag         = 'F'
-	genericFuncTag  = 'G'
-	constTag        = 'C'
-	aliasTag        = 'A'
-	genericAliasTag = 'B'
-	typeParamTag    = 'P'
-	typeTag         = 'T'
-	genericTypeTag  = 'U'
-)
-
-// IImportData imports a package from the serialized package data
-// and returns 0 and a reference to the package.
-// If the export data version is not recognized or the format is otherwise
-// compromised, an error is returned.
-func IImportData(fset *token.FileSet, imports map[string]*types.Package, data []byte, path string) (int, *types.Package, error) {
-	pkgs, err := iimportCommon(fset, GetPackagesFromMap(imports), data, false, path, false, nil)
-	if err != nil {
-		return 0, nil, err
-	}
-	return 0, pkgs[0], nil
-}
-
-// IImportBundle imports a set of packages from the serialized package bundle.
-func IImportBundle(fset *token.FileSet, imports map[string]*types.Package, data []byte) ([]*types.Package, error) {
-	return iimportCommon(fset, GetPackagesFromMap(imports), data, true, "", false, nil)
-}
-
-// A GetPackagesFunc function obtains the non-nil symbols for a set of
-// packages, creating and recursively importing them as needed. An
-// implementation should store each package symbol is in the Pkg
-// field of the items array.
-//
-// Any error causes importing to fail. This can be used to quickly read
-// the import manifest of an export data file without fully decoding it.
-type GetPackagesFunc = func(items []GetPackagesItem) error
-
-// A GetPackagesItem is a request from the importer for the package
-// symbol of the specified name and path.
-type GetPackagesItem struct {
-	Name, Path string
-	Pkg        *types.Package // to be filled in by GetPackagesFunc call
-
-	// private importer state
-	pathOffset uint64
-	nameIndex  map[string]uint64
-}
-
-// GetPackagesFromMap returns a GetPackagesFunc that retrieves
-// packages from the given map of package path to package.
-//
-// The returned function may mutate m: each requested package that is not
-// found is created with types.NewPackage and inserted into m.
-func GetPackagesFromMap(m map[string]*types.Package) GetPackagesFunc {
-	return func(items []GetPackagesItem) error {
-		for i, item := range items {
-			pkg, ok := m[item.Path]
-			if !ok {
-				pkg = types.NewPackage(item.Path, item.Name)
-				m[item.Path] = pkg
-			}
-			items[i].Pkg = pkg
-		}
-		return nil
-	}
-}
-
-func iimportCommon(fset *token.FileSet, getPackages GetPackagesFunc, data []byte, bundle bool, path string, shallow bool, reportf ReportFunc) (pkgs []*types.Package, err error) {
-	const currentVersion = iexportVersionCurrent
-	version := int64(-1)
-	if !debug {
-		defer func() {
-			if e := recover(); e != nil {
-				if bundle {
-					err = fmt.Errorf("%v", e)
-				} else if version > currentVersion {
-					err = fmt.Errorf("cannot import %q (%v), export data is newer version - update tool", path, e)
-				} else {
-					err = fmt.Errorf("internal error while importing %q (%v); please report an issue", path, e)
-				}
-			}
-		}()
-	}
-
-	r := &intReader{bytes.NewReader(data), path}
-
-	if bundle {
-		if v := r.uint64(); v != bundleVersion {
-			errorf("unknown bundle format version %d", v)
-		}
-	}
-
-	version = int64(r.uint64())
-	switch version {
-	case iexportVersionGenericMethods, iexportVersionGo1_18, iexportVersionPosCol, iexportVersionGo1_11:
-	default:
-		if version > iexportVersionGenericMethods {
-			errorf("unstable iexport format version %d, just rebuild compiler and std library", version)
-		} else {
-			errorf("unknown iexport format version %d", version)
-		}
-	}
-
-	sLen := int64(r.uint64())
-	var fLen int64
-	var fileOffset []uint64
-	if shallow {
-		// Shallow mode uses a different position encoding.
-		fLen = int64(r.uint64())
-		fileOffset = make([]uint64, r.uint64())
-		for i := range fileOffset {
-			fileOffset[i] = r.uint64()
-		}
-	}
-	dLen := int64(r.uint64())
-
-	whence, _ := r.Seek(0, io.SeekCurrent)
-	stringData := data[whence : whence+sLen]
-	fileData := data[whence+sLen : whence+sLen+fLen]
-	declData := data[whence+sLen+fLen : whence+sLen+fLen+dLen]
-	r.Seek(sLen+fLen+dLen, io.SeekCurrent)
-
-	p := iimporter{
-		version: int(version),
-		ipath:   path,
-		shallow: shallow,
-		reportf: reportf,
-
-		stringData:  stringData,
-		stringCache: make(map[uint64]string),
-		fileOffset:  fileOffset,
-		fileData:    fileData,
-		fileCache:   make([]*token.File, len(fileOffset)),
-		pkgCache:    make(map[uint64]*types.Package),
-
-		declData: declData,
-		pkgIndex: make(map[*types.Package]map[string]uint64),
-		typCache: make(map[uint64]types.Type),
-		// Separate map for typeparams, keyed by their package and unique
-		// name.
-		tparamIndex: make(map[ident]types.Type),
-
-		fake: fakeFileSet{
-			fset:  fset,
-			files: make(map[string]*fileInfo),
-		},
-	}
-	defer p.fake.setLines() // set lines for files in fset
-
-	for i, pt := range predeclared() {
-		p.typCache[uint64(i)] = pt
-	}
-
-	// Gather the relevant packages from the manifest.
-	items := make([]GetPackagesItem, r.uint64())
-	uniquePkgPaths := make(map[string]bool)
-	for i := range items {
-		pkgPathOff := r.uint64()
-		pkgPath := p.stringAt(pkgPathOff)
-		pkgName := p.stringAt(r.uint64())
-		_ = r.uint64() // package height; unused by go/types
-
-		if pkgPath == "" {
-			pkgPath = path
-		}
-		items[i].Name = pkgName
-		items[i].Path = pkgPath
-		items[i].pathOffset = pkgPathOff
-
-		// Read index for package.
-		nameIndex := make(map[string]uint64)
-		nSyms := r.uint64()
-		// In shallow mode, only the current package (i=0) has an index.
-		assert(!(shallow && i > 0 && nSyms != 0))
-		for ; nSyms > 0; nSyms-- {
-			name := p.stringAt(r.uint64())
-			nameIndex[name] = r.uint64()
-		}
-
-		items[i].nameIndex = nameIndex
-
-		uniquePkgPaths[pkgPath] = true
-	}
-	// Debugging #63822; hypothesis: there are duplicate PkgPaths.
-	if len(uniquePkgPaths) != len(items) {
-		reportf("found duplicate PkgPaths while reading export data manifest: %v", items)
-	}
-
-	// Request packages all at once from the client,
-	// enabling a parallel implementation.
-	if err := getPackages(items); err != nil {
-		return nil, err // don't wrap this error
-	}
-
-	// Check the results and complete the index.
-	pkgList := make([]*types.Package, len(items))
-	for i, item := range items {
-		pkg := item.Pkg
-		if pkg == nil {
-			errorf("internal error: getPackages returned nil package for %q", item.Path)
-		} else if pkg.Path() != item.Path {
-			errorf("internal error: getPackages returned wrong path %q, want %q", pkg.Path(), item.Path)
-		} else if pkg.Name() != item.Name {
-			errorf("internal error: getPackages returned wrong name %s for package %q, want %s", pkg.Name(), item.Path, item.Name)
-		}
-		p.pkgCache[item.pathOffset] = pkg
-		p.pkgIndex[pkg] = item.nameIndex
-		pkgList[i] = pkg
-	}
-
-	if bundle {
-		pkgs = make([]*types.Package, r.uint64())
-		for i := range pkgs {
-			pkg := p.pkgAt(r.uint64())
-			imps := make([]*types.Package, r.uint64())
-			for j := range imps {
-				imps[j] = p.pkgAt(r.uint64())
-			}
-			pkg.SetImports(imps)
-			pkgs[i] = pkg
-		}
-	} else {
-		if len(pkgList) == 0 {
-			errorf("no packages found for %s", path)
-			panic("unreachable")
-		}
-		pkgs = pkgList[:1]
-
-		// record all referenced packages as imports
-		list := slices.Clone(pkgList[1:])
-		sort.Sort(byPath(list))
-		pkgs[0].SetImports(list)
-	}
-
-	for _, pkg := range pkgs {
-		if pkg.Complete() {
-			continue
-		}
-
-		names := make([]string, 0, len(p.pkgIndex[pkg]))
-		for name := range p.pkgIndex[pkg] {
-			names = append(names, name)
-		}
-		sort.Strings(names)
-		for _, name := range names {
-			p.doDecl(pkg, name)
-		}
-
-		// package was imported completely and without errors
-		pkg.MarkComplete()
-	}
-
-	// SetConstraint can't be called if the constraint type is not yet complete.
-	// When type params are created in the typeParamTag case of (*importReader).obj(),
-	// the associated constraint type may not be complete due to recursion.
-	// Therefore, we defer calling SetConstraint there, and call it here instead
-	// after all types are complete.
-	for _, d := range p.later {
-		d.t.SetConstraint(d.constraint)
-	}
-
-	for _, typ := range p.interfaceList {
-		typ.Complete()
-	}
-
-	// Workaround for golang/go#61561. See the doc for instanceList for details.
-	for _, typ := range p.instanceList {
-		if iface, _ := typ.Underlying().(*types.Interface); iface != nil {
-			iface.Complete()
-		}
-	}
-
-	return pkgs, nil
-}
-
-type setConstraintArgs struct {
-	t          *types.TypeParam
-	constraint types.Type
-}
-
-type iimporter struct {
-	version int
-	ipath   string
-
-	shallow bool
-	reportf ReportFunc // if non-nil, used to report bugs
-
-	stringData  []byte
-	stringCache map[uint64]string
-	fileOffset  []uint64 // fileOffset[i] is offset in fileData for info about file encoded as i
-	fileData    []byte
-	fileCache   []*token.File // memoized decoding of file encoded as i
-	pkgCache    map[uint64]*types.Package
-
-	declData    []byte
-	pkgIndex    map[*types.Package]map[string]uint64
-	typCache    map[uint64]types.Type
-	tparamIndex map[ident]types.Type
-
-	fake          fakeFileSet
-	interfaceList []*types.Interface
-
-	// Workaround for the go/types bug golang/go#61561: instances produced during
-	// instantiation may contain incomplete interfaces. Here we only complete the
-	// underlying type of the instance, which is the most common case but doesn't
-	// handle parameterized interface literals defined deeper in the type.
-	instanceList []types.Type // instances for later completion (see golang/go#61561)
-
-	// Arguments for calls to SetConstraint that are deferred due to recursive types
-	later []setConstraintArgs
-
-	indent int // for tracing support
-}
-
-func (p *iimporter) trace(format string, args ...any) {
-	if !trace {
-		// Call sites should also be guarded, but having this check here allows
-		// easily enabling/disabling debug trace statements.
-		return
-	}
-	fmt.Printf(strings.Repeat("..", p.indent)+format+"\n", args...)
-}
-
-func (p *iimporter) doDecl(pkg *types.Package, name string) {
-	if debug {
-		p.trace("import decl %s", name)
-		p.indent++
-		defer func() {
-			p.indent--
-			p.trace("=> %s", name)
-		}()
-	}
-	// See if we've already imported this declaration.
-	if obj := pkg.Scope().Lookup(name); obj != nil {
-		return
-	}
-
-	off, ok := p.pkgIndex[pkg][name]
-	if !ok {
-		// In deep mode, the index should be complete. In shallow
-		// mode, we should have already recursively loaded necessary
-		// dependencies so the above Lookup succeeds.
-		errorf("%v.%v not in index", pkg, name)
-	}
-
-	r := &importReader{p: p}
-	r.declReader.Reset(p.declData[off:])
-
-	r.obj(pkg, name)
-}
-
-func (p *iimporter) stringAt(off uint64) string {
-	if s, ok := p.stringCache[off]; ok {
-		return s
-	}
-
-	slen, n := binary.Uvarint(p.stringData[off:])
-	if n <= 0 {
-		errorf("varint failed")
-	}
-	spos := off + uint64(n)
-	s := string(p.stringData[spos : spos+slen])
-	p.stringCache[off] = s
-	return s
-}
-
-func (p *iimporter) fileAt(index uint64) *token.File {
-	file := p.fileCache[index]
-	if file == nil {
-		off := p.fileOffset[index]
-		file = p.decodeFile(intReader{bytes.NewReader(p.fileData[off:]), p.ipath})
-		p.fileCache[index] = file
-	}
-	return file
-}
-
-func (p *iimporter) decodeFile(rd intReader) *token.File {
-	filename := p.stringAt(rd.uint64())
-	size := int(rd.uint64())
-	file := p.fake.fset.AddFile(filename, -1, size)
-
-	// SetLines requires a nondecreasing sequence.
-	// Because it is common for clients to derive the interval
-	// [start, start+len(name)] from a start position, and we
-	// want to ensure that the end offset is on the same line,
-	// we fill in the gaps of the sparse encoding with values
-	// that strictly increase by the largest possible amount.
-	// This allows us to avoid having to record the actual end
-	// offset of each needed line.
-
-	lines := make([]int, int(rd.uint64()))
-	var index, offset int
-	for i, n := 0, int(rd.uint64()); i < n; i++ {
-		index += int(rd.uint64())
-		offset += int(rd.uint64())
-		lines[index] = offset
-
-		// Ensure monotonicity between points.
-		for j := index - 1; j > 0 && lines[j] == 0; j-- {
-			lines[j] = lines[j+1] - 1
-		}
-	}
-
-	// Ensure monotonicity after last point.
-	for j := len(lines) - 1; j > 0 && lines[j] == 0; j-- {
-		size--
-		lines[j] = size
-	}
-
-	if !file.SetLines(lines) {
-		errorf("SetLines failed: %d", lines) // can't happen
-	}
-	return file
-}
-
-func (p *iimporter) pkgAt(off uint64) *types.Package {
-	if pkg, ok := p.pkgCache[off]; ok {
-		return pkg
-	}
-	path := p.stringAt(off)
-	errorf("missing package %q in %q", path, p.ipath)
-	return nil
-}
-
-func (p *iimporter) typAt(off uint64, base *types.Named) types.Type {
-	if t, ok := p.typCache[off]; ok && canReuse(base, t) {
-		return t
-	}
-
-	if off < predeclReserved {
-		errorf("predeclared type missing from cache: %v", off)
-	}
-
-	r := &importReader{p: p}
-	r.declReader.Reset(p.declData[off-predeclReserved:])
-	t := r.doType(base)
-
-	if canReuse(base, t) {
-		p.typCache[off] = t
-	}
-	return t
-}
-
-// canReuse reports whether the type rhs on the RHS of the declaration for def
-// may be re-used.
-//
-// Specifically, if def is non-nil and rhs is an interface type with methods, it
-// may not be re-used because we have a convention of setting the receiver type
-// for interface methods to def.
-func canReuse(def *types.Named, rhs types.Type) bool {
-	if def == nil {
-		return true
-	}
-	iface, _ := types.Unalias(rhs).(*types.Interface)
-	if iface == nil {
-		return true
-	}
-	// Don't use iface.Empty() here as iface may not be complete.
-	return iface.NumEmbeddeds() == 0 && iface.NumExplicitMethods() == 0
-}
-
-type importReader struct {
-	p          *iimporter
-	declReader bytes.Reader
-	prevFile   string
-	prevLine   int64
-	prevColumn int64
-}
-
-// markBlack is redefined in iimport_go123.go, to work around golang/go#69912.
-//
-// If TypeNames are not marked black (in the sense of go/types cycle
-// detection), they may be mutated when dot-imported. Fix this by punching a
-// hole through the type, when compiling with Go 1.23. (The bug has been fixed
-// for 1.24, but the fix was not worth back-porting).
-var markBlack = func(name *types.TypeName) {}
-
-// obj decodes and declares the package-level object denoted by (pkg, name).
-func (r *importReader) obj(pkg *types.Package, name string) {
-	tag := r.byte()
-	pos := r.pos()
-
-	switch tag {
-	case aliasTag, genericAliasTag:
-		var tparams []*types.TypeParam
-		if tag == genericAliasTag {
-			tparams = r.tparamList()
-		}
-		typ := r.typ()
-		obj := aliases.New(pos, pkg, name, typ, tparams)
-		markBlack(obj) // workaround for golang/go#69912
-		r.declare(obj)
-
-	case constTag:
-		typ, val := r.value()
-
-		r.declare(types.NewConst(pos, pkg, name, typ, val))
-
-	case funcTag, genericFuncTag:
-		var tparams []*types.TypeParam
-		if tag == genericFuncTag {
-			tparams = r.tparamList()
-		}
-		sig := r.signature(pkg, nil, nil, tparams)
-		r.declare(types.NewFunc(pos, pkg, name, sig))
-
-	case typeTag, genericTypeTag:
-		// Types can be recursive. We need to setup a stub
-		// declaration before recursing.
-		obj := types.NewTypeName(pos, pkg, name, nil)
-		named := types.NewNamed(obj, nil, nil)
-
-		markBlack(obj) // workaround for golang/go#69912
-
-		// Declare obj before calling r.tparamList, so the new type name is recognized
-		// if used in the constraint of one of its own typeparams (see #48280).
-		r.declare(obj)
-		if tag == genericTypeTag {
-			tparams := r.tparamList()
-			named.SetTypeParams(tparams)
-		}
-
-		underlying := r.p.typAt(r.uint64(), named).Underlying()
-		named.SetUnderlying(underlying)
-
-		if !isInterface(underlying) {
-			for n := r.uint64(); n > 0; n-- {
-				mpos := r.pos()
-				mname := r.ident()
-				var tpars []*types.TypeParam
-				if r.p.version >= iexportVersionGenericMethods && r.bool() {
-					tpars = r.tparamList()
-				}
-				recv := r.param(pkg)
-
-				// If the receiver has any targs, set those as the
-				// rparams of the method (since those are the
-				// typeparams being used in the method sig/body).
-				_, recvNamed := typesinternal.ReceiverNamed(recv)
-				targs := recvNamed.TypeArgs()
-				var rparams []*types.TypeParam
-				if targs.Len() > 0 {
-					rparams = make([]*types.TypeParam, targs.Len())
-					for i := range rparams {
-						rparams[i] = types.Unalias(targs.At(i)).(*types.TypeParam)
-					}
-				}
-				msig := r.signature(pkg, recv, rparams, tpars)
-				named.AddMethod(types.NewFunc(mpos, pkg, mname, msig))
-			}
-		}
-
-	case typeParamTag:
-		// We need to "declare" a typeparam in order to have a name that
-		// can be referenced recursively (if needed) in the type param's
-		// bound.
-		if r.p.version < iexportVersionGenerics {
-			errorf("unexpected type param type")
-		}
-		name0 := tparamName(name)
-		tn := types.NewTypeName(pos, pkg, name0, nil)
-		t := types.NewTypeParam(tn, nil)
-
-		// To handle recursive references to the typeparam within its
-		// bound, save the partial type in tparamIndex before reading the bounds.
-		id := ident{pkg, name}
-		r.p.tparamIndex[id] = t
-		var implicit bool
-		if r.p.version >= iexportVersionGo1_18 {
-			implicit = r.bool()
-		}
-		constraint := r.typ()
-		if implicit {
-			iface, _ := types.Unalias(constraint).(*types.Interface)
-			if iface == nil {
-				errorf("non-interface constraint marked implicit")
-			}
-			iface.MarkImplicit()
-		}
-		// The constraint type may not be complete, if we
-		// are in the middle of a type recursion involving type
-		// constraints. So, we defer SetConstraint until we have
-		// completely set up all types in ImportData.
-		r.p.later = append(r.p.later, setConstraintArgs{t: t, constraint: constraint})
-
-	case varTag:
-		typ := r.typ()
-
-		v := types.NewVar(pos, pkg, name, typ)
-		typesinternal.SetVarKind(v, typesinternal.PackageVar)
-		r.declare(v)
-
-	default:
-		errorf("unexpected tag: %v", tag)
-	}
-}
-
-func (r *importReader) declare(obj types.Object) {
-	obj.Pkg().Scope().Insert(obj)
-}
-
-func (r *importReader) value() (typ types.Type, val constant.Value) {
-	typ = r.typ()
-	if r.p.version >= iexportVersionGo1_18 {
-		// TODO: add support for using the kind.
-		_ = constant.Kind(r.int64())
-	}
-
-	switch b := typ.Underlying().(*types.Basic); b.Info() & types.IsConstType {
-	case types.IsBoolean:
-		val = constant.MakeBool(r.bool())
-
-	case types.IsString:
-		val = constant.MakeString(r.string())
-
-	case types.IsInteger:
-		var x big.Int
-		r.mpint(&x, b)
-		val = constant.Make(&x)
-
-	case types.IsFloat:
-		val = r.mpfloat(b)
-
-	case types.IsComplex:
-		re := r.mpfloat(b)
-		im := r.mpfloat(b)
-		val = constant.BinaryOp(re, token.ADD, constant.MakeImag(im))
-
-	default:
-		if b.Kind() == types.Invalid {
-			val = constant.MakeUnknown()
-			return
-		}
-		errorf("unexpected type %v", typ) // panics
-		panic("unreachable")
-	}
-
-	return
-}
-
-func intSize(b *types.Basic) (signed bool, maxBytes uint) {
-	if (b.Info() & types.IsUntyped) != 0 {
-		return true, 64
-	}
-
-	switch b.Kind() {
-	case types.Float32, types.Complex64:
-		return true, 3
-	case types.Float64, types.Complex128:
-		return true, 7
-	}
-
-	signed = (b.Info() & types.IsUnsigned) == 0
-	switch b.Kind() {
-	case types.Int8, types.Uint8:
-		maxBytes = 1
-	case types.Int16, types.Uint16:
-		maxBytes = 2
-	case types.Int32, types.Uint32:
-		maxBytes = 4
-	default:
-		maxBytes = 8
-	}
-
-	return
-}
-
-func (r *importReader) mpint(x *big.Int, typ *types.Basic) {
-	signed, maxBytes := intSize(typ)
-
-	maxSmall := 256 - maxBytes
-	if signed {
-		maxSmall = 256 - 2*maxBytes
-	}
-	if maxBytes == 1 {
-		maxSmall = 256
-	}
-
-	n, _ := r.declReader.ReadByte()
-	if uint(n) < maxSmall {
-		v := int64(n)
-		if signed {
-			v >>= 1
-			if n&1 != 0 {
-				v = ^v
-			}
-		}
-		x.SetInt64(v)
-		return
-	}
-
-	v := -n
-	if signed {
-		v = -(n &^ 1) >> 1
-	}
-	if v < 1 || uint(v) > maxBytes {
-		errorf("weird decoding: %v, %v => %v", n, signed, v)
-	}
-	b := make([]byte, v)
-	io.ReadFull(&r.declReader, b)
-	x.SetBytes(b)
-	if signed && n&1 != 0 {
-		x.Neg(x)
-	}
-}
-
-func (r *importReader) mpfloat(typ *types.Basic) constant.Value {
-	var mant big.Int
-	r.mpint(&mant, typ)
-	var f big.Float
-	f.SetInt(&mant)
-	if f.Sign() != 0 {
-		f.SetMantExp(&f, int(r.int64()))
-	}
-	return constant.Make(&f)
-}
-
-func (r *importReader) ident() string {
-	return r.string()
-}
-
-func (r *importReader) qualifiedIdent() (*types.Package, string) {
-	name := r.string()
-	pkg := r.pkg()
-	return pkg, name
-}
-
-func (r *importReader) pos() token.Pos {
-	if r.p.shallow {
-		// precise offsets are encoded only in shallow mode
-		return r.posv2()
-	}
-	if r.p.version >= iexportVersionPosCol {
-		r.posv1()
-	} else {
-		r.posv0()
-	}
-
-	if r.prevFile == "" && r.prevLine == 0 && r.prevColumn == 0 {
-		return token.NoPos
-	}
-	return r.p.fake.pos(r.prevFile, int(r.prevLine), int(r.prevColumn))
-}
-
-func (r *importReader) posv0() {
-	delta := r.int64()
-	if delta != deltaNewFile {
-		r.prevLine += delta
-	} else if l := r.int64(); l == -1 {
-		r.prevLine += deltaNewFile
-	} else {
-		r.prevFile = r.string()
-		r.prevLine = l
-	}
-}
-
-func (r *importReader) posv1() {
-	delta := r.int64()
-	r.prevColumn += delta >> 1
-	if delta&1 != 0 {
-		delta = r.int64()
-		r.prevLine += delta >> 1
-		if delta&1 != 0 {
-			r.prevFile = r.string()
-		}
-	}
-}
-
-func (r *importReader) posv2() token.Pos {
-	file := r.uint64()
-	if file == 0 {
-		return token.NoPos
-	}
-	tf := r.p.fileAt(file - 1)
-	return tf.Pos(int(r.uint64()))
-}
-
-func (r *importReader) typ() types.Type {
-	return r.p.typAt(r.uint64(), nil)
-}
-
-func isInterface(t types.Type) bool {
-	_, ok := types.Unalias(t).(*types.Interface)
-	return ok
-}
-
-func (r *importReader) pkg() *types.Package { return r.p.pkgAt(r.uint64()) }
-func (r *importReader) string() string      { return r.p.stringAt(r.uint64()) }
-
-func (r *importReader) doType(base *types.Named) (res types.Type) {
-	k := r.kind()
-	if debug {
-		r.p.trace("importing type %d (base: %v)", k, base)
-		r.p.indent++
-		defer func() {
-			r.p.indent--
-			r.p.trace("=> %s", res)
-		}()
-	}
-	switch k {
-	default:
-		errorf("unexpected kind tag in %q: %v", r.p.ipath, k)
-		return nil
-
-	case aliasType, definedType:
-		pkg, name := r.qualifiedIdent()
-		r.p.doDecl(pkg, name)
-		return pkg.Scope().Lookup(name).(*types.TypeName).Type()
-	case pointerType:
-		return types.NewPointer(r.typ())
-	case sliceType:
-		return types.NewSlice(r.typ())
-	case arrayType:
-		n := r.uint64()
-		return types.NewArray(r.typ(), int64(n))
-	case chanType:
-		dir := chanDir(int(r.uint64()))
-		return types.NewChan(dir, r.typ())
-	case mapType:
-		return types.NewMap(r.typ(), r.typ())
-	case signatureType:
-		paramPkg := r.pkg()
-		return r.signature(paramPkg, nil, nil, nil)
-
-	case structType:
-		fieldPkg := r.pkg()
-
-		fields := make([]*types.Var, r.uint64())
-		tags := make([]string, len(fields))
-		for i := range fields {
-			var field *types.Var
-			if r.p.shallow {
-				field, _ = r.objectPathObject().(*types.Var)
-			}
-
-			fpos := r.pos()
-			fname := r.ident()
-			ftyp := r.typ()
-			emb := r.bool()
-			tag := r.string()
-
-			// Either this is not a shallow import, the field is local, or the
-			// encoded objectPath failed to produce an object (a bug).
-			//
-			// Even in this last, buggy case, fall back on creating a new field. As
-			// discussed in iexport.go, this is not correct, but mostly works and is
-			// preferable to failing (for now at least).
-			if field == nil {
-				field = types.NewField(fpos, fieldPkg, fname, ftyp, emb)
-			}
-
-			fields[i] = field
-			tags[i] = tag
-		}
-		return types.NewStruct(fields, tags)
-
-	case interfaceType:
-		methodPkg := r.pkg() // qualifies methods and their param/result vars
-
-		embeddeds := make([]types.Type, r.uint64())
-		for i := range embeddeds {
-			_ = r.pos()
-			embeddeds[i] = r.typ()
-		}
-
-		methods := make([]*types.Func, r.uint64())
-		for i := range methods {
-			var method *types.Func
-			if r.p.shallow {
-				method, _ = r.objectPathObject().(*types.Func)
-			}
-
-			mpos := r.pos()
-			mname := r.ident()
-
-			// TODO(mdempsky): Matches bimport.go, but I
-			// don't agree with this.
-			var recv *types.Var
-			if base != nil {
-				recv = types.NewVar(token.NoPos, methodPkg, "", base)
-			}
-			msig := r.signature(methodPkg, recv, nil, nil)
-
-			if method == nil {
-				method = types.NewFunc(mpos, methodPkg, mname, msig)
-			}
-			methods[i] = method
-		}
-
-		typ := types.NewInterfaceType(methods, embeddeds)
-		r.p.interfaceList = append(r.p.interfaceList, typ)
-		return typ
-
-	case typeParamType:
-		if r.p.version < iexportVersionGenerics {
-			errorf("unexpected type param type")
-		}
-		pkg, name := r.qualifiedIdent()
-		id := ident{pkg, name}
-		if t, ok := r.p.tparamIndex[id]; ok {
-			// We're already in the process of importing this typeparam.
-			return t
-		}
-		// Otherwise, import the definition of the typeparam now.
-		r.p.doDecl(pkg, name)
-		return r.p.tparamIndex[id]
-
-	case instanceType:
-		if r.p.version < iexportVersionGenerics {
-			errorf("unexpected instantiation type")
-		}
-		// pos does not matter for instances: they are positioned on the original
-		// type.
-		_ = r.pos()
-		len := r.uint64()
-		targs := make([]types.Type, len)
-		for i := range targs {
-			targs[i] = r.typ()
-		}
-		baseType := r.typ()
-		// The imported instantiated type doesn't include any methods, so
-		// we must always use the methods of the base (orig) type.
-		// TODO provide a non-nil *Environment
-		t, _ := types.Instantiate(nil, baseType, targs, false)
-
-		// Workaround for golang/go#61561. See the doc for instanceList for details.
-		r.p.instanceList = append(r.p.instanceList, t)
-		return t
-
-	case unionType:
-		if r.p.version < iexportVersionGenerics {
-			errorf("unexpected instantiation type")
-		}
-		terms := make([]*types.Term, r.uint64())
-		for i := range terms {
-			terms[i] = types.NewTerm(r.bool(), r.typ())
-		}
-		return types.NewUnion(terms)
-	}
-}
-
-func (r *importReader) kind() itag {
-	return itag(r.uint64())
-}
-
-// objectPathObject is the inverse of exportWriter.objectPath.
-//
-// In shallow mode, certain fields and methods may need to be looked up in an
-// imported package. See the doc for exportWriter.objectPath for a full
-// explanation.
-func (r *importReader) objectPathObject() types.Object {
-	objPath := objectpath.Path(r.string())
-	if objPath == "" {
-		return nil
-	}
-	pkg := r.pkg()
-	obj, err := objectpath.Object(pkg, objPath)
-	if err != nil {
-		if r.p.reportf != nil {
-			r.p.reportf("failed to find object for objectPath %q: %v", objPath, err)
-		}
-	}
-	return obj
-}
-
-func (r *importReader) signature(paramPkg *types.Package, recv *types.Var, rparams []*types.TypeParam, tparams []*types.TypeParam) *types.Signature {
-	params := r.paramList(paramPkg)
-	results := r.paramList(paramPkg)
-	variadic := params.Len() > 0 && r.bool()
-	return types.NewSignatureType(recv, rparams, tparams, params, results, variadic)
-}
-
-func (r *importReader) tparamList() []*types.TypeParam {
-	n := r.uint64()
-	if n == 0 {
-		return nil
-	}
-	xs := make([]*types.TypeParam, n)
-	for i := range xs {
-		// Note: the standard library importer is tolerant of nil types here,
-		// though would panic in SetTypeParams.
-		xs[i] = types.Unalias(r.typ()).(*types.TypeParam)
-	}
-	return xs
-}
-
-func (r *importReader) paramList(pkg *types.Package) *types.Tuple {
-	xs := make([]*types.Var, r.uint64())
-	for i := range xs {
-		xs[i] = r.param(pkg)
-	}
-	return types.NewTuple(xs...)
-}
-
-func (r *importReader) param(pkg *types.Package) *types.Var {
-	pos := r.pos()
-	name := r.ident()
-	typ := r.typ()
-	return types.NewParam(pos, pkg, name, typ)
-}
-
-func (r *importReader) bool() bool {
-	return r.uint64() != 0
-}
-
-func (r *importReader) int64() int64 {
-	n, err := binary.ReadVarint(&r.declReader)
-	if err != nil {
-		errorf("readVarint: %v", err)
-	}
-	return n
-}
-
-func (r *importReader) uint64() uint64 {
-	n, err := binary.ReadUvarint(&r.declReader)
-	if err != nil {
-		errorf("readUvarint: %v", err)
-	}
-	return n
-}
-
-func (r *importReader) byte() byte {
-	x, err := r.declReader.ReadByte()
-	if err != nil {
-		errorf("declReader.ReadByte: %v", err)
-	}
-	return x
-}
-
-type byPath []*types.Package
-
-func (a byPath) Len() int           { return len(a) }
-func (a byPath) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
-func (a byPath) Less(i, j int) bool { return a[i].Path() < a[j].Path() }
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/predeclared.go b/vendor/golang.org/x/tools/internal/gcimporter/predeclared.go
deleted file mode 100644
index 907c8557a5..0000000000
--- a/vendor/golang.org/x/tools/internal/gcimporter/predeclared.go
+++ /dev/null
@@ -1,91 +0,0 @@
-// Copyright 2024 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gcimporter
-
-import (
-	"go/types"
-	"sync"
-)
-
-// predecl is a cache for the predeclared types in types.Universe.
-//
-// Cache a distinct result based on the runtime value of any.
-// The pointer value of the any type varies based on GODEBUG settings.
-var predeclMu sync.Mutex
-var predecl map[types.Type][]types.Type
-
-func predeclared() []types.Type {
-	anyt := types.Universe.Lookup("any").Type()
-
-	predeclMu.Lock()
-	defer predeclMu.Unlock()
-
-	if pre, ok := predecl[anyt]; ok {
-		return pre
-	}
-
-	if predecl == nil {
-		predecl = make(map[types.Type][]types.Type)
-	}
-
-	decls := []types.Type{ // basic types
-		types.Typ[types.Bool],
-		types.Typ[types.Int],
-		types.Typ[types.Int8],
-		types.Typ[types.Int16],
-		types.Typ[types.Int32],
-		types.Typ[types.Int64],
-		types.Typ[types.Uint],
-		types.Typ[types.Uint8],
-		types.Typ[types.Uint16],
-		types.Typ[types.Uint32],
-		types.Typ[types.Uint64],
-		types.Typ[types.Uintptr],
-		types.Typ[types.Float32],
-		types.Typ[types.Float64],
-		types.Typ[types.Complex64],
-		types.Typ[types.Complex128],
-		types.Typ[types.String],
-
-		// basic type aliases
-		types.Universe.Lookup("byte").Type(),
-		types.Universe.Lookup("rune").Type(),
-
-		// error
-		types.Universe.Lookup("error").Type(),
-
-		// untyped types
-		types.Typ[types.UntypedBool],
-		types.Typ[types.UntypedInt],
-		types.Typ[types.UntypedRune],
-		types.Typ[types.UntypedFloat],
-		types.Typ[types.UntypedComplex],
-		types.Typ[types.UntypedString],
-		types.Typ[types.UntypedNil],
-
-		// package unsafe
-		types.Typ[types.UnsafePointer],
-
-		// invalid type
-		types.Typ[types.Invalid], // only appears in packages with errors
-
-		// used internally by gc; never used by this package or in .a files
-		anyType{},
-
-		// comparable
-		types.Universe.Lookup("comparable").Type(),
-
-		// any
-		anyt,
-	}
-
-	predecl[anyt] = decls
-	return decls
-}
-
-type anyType struct{}
-
-func (t anyType) Underlying() types.Type { return t }
-func (t anyType) String() string         { return "any" }
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/support.go b/vendor/golang.org/x/tools/internal/gcimporter/support.go
deleted file mode 100644
index 4af810dc41..0000000000
--- a/vendor/golang.org/x/tools/internal/gcimporter/support.go
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright 2024 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gcimporter
-
-import (
-	"bufio"
-	"io"
-	"strconv"
-	"strings"
-)
-
-// Copy of $GOROOT/src/cmd/internal/archive.ReadHeader.
-func readArchiveHeader(b *bufio.Reader, name string) int {
-	// architecture-independent object file output
-	const HeaderSize = 60
-
-	var buf [HeaderSize]byte
-	if _, err := io.ReadFull(b, buf[:]); err != nil {
-		return -1
-	}
-	aname := strings.Trim(string(buf[0:16]), " ")
-	if !strings.HasPrefix(aname, name) {
-		return -1
-	}
-	asize := strings.Trim(string(buf[48:58]), " ")
-	i, _ := strconv.Atoi(asize)
-	return i
-}
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/ureader.go b/vendor/golang.org/x/tools/internal/gcimporter/ureader.go
deleted file mode 100644
index 5d3b7c867a..0000000000
--- a/vendor/golang.org/x/tools/internal/gcimporter/ureader.go
+++ /dev/null
@@ -1,813 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Derived from go/internal/gcimporter/ureader.go
-
-package gcimporter
-
-import (
-	"fmt"
-	"go/token"
-	"go/types"
-	"sort"
-	"strings"
-
-	"golang.org/x/tools/internal/aliases"
-	"golang.org/x/tools/internal/pkgbits"
-	"golang.org/x/tools/internal/typesinternal"
-)
-
-// A pkgReader holds the shared state for reading a unified IR package
-// description.
-type pkgReader struct {
-	pkgbits.PkgDecoder
-
-	fake fakeFileSet
-
-	ctxt    *types.Context
-	imports map[string]*types.Package // previously imported packages, indexed by path
-
-	// lazily initialized arrays corresponding to the unified IR
-	// PosBase, Pkg, and Type sections, respectively.
-	posBases []string // position bases (i.e., file names)
-	pkgs     []*types.Package
-	typs     []types.Type
-
-	// laterFns holds functions that need to be invoked at the end of
-	// import reading.
-	//
-	// TODO(mdempsky): Is it safe to have a single "later" slice or do
-	// we need to have multiple passes? See comments on CL 386002 and
-	// go.dev/issue/52104.
-	laterFns []func()
-	// laterFors is used in case of 'type A B' to ensure that B is processed before A.
-	laterFors map[types.Type]int
-
-	// ifaces holds a list of constructed Interfaces, which need to have
-	// Complete called after importing is done.
-	ifaces []*types.Interface
-}
-
-// later adds a function to be invoked at the end of import reading.
-func (pr *pkgReader) later(fn func()) {
-	pr.laterFns = append(pr.laterFns, fn)
-}
-
-// See cmd/compile/internal/noder.derivedInfo.
-type derivedInfo struct {
-	idx pkgbits.Index
-}
-
-// See cmd/compile/internal/noder.typeInfo.
-type typeInfo struct {
-	idx     pkgbits.Index
-	derived bool
-}
-
-func UImportData(fset *token.FileSet, imports map[string]*types.Package, data []byte, path string) (_ int, pkg *types.Package, err error) {
-	if !debug {
-		defer func() {
-			if x := recover(); x != nil {
-				err = fmt.Errorf("internal error in importing %q (%v); please report an issue", path, x)
-			}
-		}()
-	}
-
-	s := string(data)
-	input := pkgbits.NewPkgDecoder(path, s)
-	pkg = readUnifiedPackage(fset, nil, imports, input)
-	return
-}
-
-// laterFor adds a function to be invoked at the end of import reading, and records the type that function is finishing.
-func (pr *pkgReader) laterFor(t types.Type, fn func()) {
-	if pr.laterFors == nil {
-		pr.laterFors = make(map[types.Type]int)
-	}
-	pr.laterFors[t] = len(pr.laterFns)
-	pr.laterFns = append(pr.laterFns, fn)
-}
-
-// readUnifiedPackage reads a package description from the given
-// unified IR export data decoder.
-func readUnifiedPackage(fset *token.FileSet, ctxt *types.Context, imports map[string]*types.Package, input pkgbits.PkgDecoder) *types.Package {
-	pr := pkgReader{
-		PkgDecoder: input,
-
-		fake: fakeFileSet{
-			fset:  fset,
-			files: make(map[string]*fileInfo),
-		},
-
-		ctxt:    ctxt,
-		imports: imports,
-
-		posBases: make([]string, input.NumElems(pkgbits.RelocPosBase)),
-		pkgs:     make([]*types.Package, input.NumElems(pkgbits.RelocPkg)),
-		typs:     make([]types.Type, input.NumElems(pkgbits.RelocType)),
-	}
-	defer pr.fake.setLines()
-
-	r := pr.newReader(pkgbits.RelocMeta, pkgbits.PublicRootIdx, pkgbits.SyncPublic)
-	pkg := r.pkg()
-	if r.Version().Has(pkgbits.HasInit) {
-		r.Bool()
-	}
-
-	for i, n := 0, r.Len(); i < n; i++ {
-		// As if r.obj(), but avoiding the Scope.Lookup call,
-		// to avoid eager loading of imports.
-		r.Sync(pkgbits.SyncObject)
-		if r.Version().Has(pkgbits.DerivedFuncInstance) {
-			assert(!r.Bool())
-		}
-		r.p.objIdx(r.Reloc(pkgbits.RelocObj))
-		assert(r.Len() == 0)
-	}
-
-	r.Sync(pkgbits.SyncEOF)
-
-	for _, fn := range pr.laterFns {
-		fn()
-	}
-
-	for _, iface := range pr.ifaces {
-		iface.Complete()
-	}
-
-	// Imports() of pkg are all of the transitive packages that were loaded.
-	var imps []*types.Package
-	for _, imp := range pr.pkgs {
-		if imp != nil && imp != pkg {
-			imps = append(imps, imp)
-		}
-	}
-	sort.Sort(byPath(imps))
-	pkg.SetImports(imps)
-
-	pkg.MarkComplete()
-	return pkg
-}
-
-// A reader holds the state for reading a single unified IR element
-// within a package.
-type reader struct {
-	pkgbits.Decoder
-
-	p *pkgReader
-
-	dict *readerDict
-}
-
-// A readerDict holds the state for type parameters that parameterize
-// the current unified IR element.
-type readerDict struct {
-	rtbounds []typeInfo         // contains constraint types for each parameter in rtparams
-	rtparams []*types.TypeParam // contains receiver type parameters for an element
-
-	tbounds []typeInfo         // contains constraint types for each parameter in tparams
-	tparams []*types.TypeParam // contains type parameters for an element
-
-	// derived is a slice of types derived from tparams, which may be
-	// instantiated while reading the current element.
-	derived      []derivedInfo
-	derivedTypes []types.Type // lazily instantiated from derived
-}
-
-func (pr *pkgReader) newReader(k pkgbits.RelocKind, idx pkgbits.Index, marker pkgbits.SyncMarker) *reader {
-	return &reader{
-		Decoder: pr.NewDecoder(k, idx, marker),
-		p:       pr,
-	}
-}
-
-func (pr *pkgReader) tempReader(k pkgbits.RelocKind, idx pkgbits.Index, marker pkgbits.SyncMarker) *reader {
-	return &reader{
-		Decoder: pr.TempDecoder(k, idx, marker),
-		p:       pr,
-	}
-}
-
-func (pr *pkgReader) retireReader(r *reader) {
-	pr.RetireDecoder(&r.Decoder)
-}
-
-// @@@ Positions
-
-func (r *reader) pos() token.Pos {
-	r.Sync(pkgbits.SyncPos)
-	if !r.Bool() {
-		return token.NoPos
-	}
-
-	// TODO(mdempsky): Delta encoding.
-	posBase := r.posBase()
-	line := r.Uint()
-	col := r.Uint()
-	return r.p.fake.pos(posBase, int(line), int(col))
-}
-
-func (r *reader) posBase() string {
-	return r.p.posBaseIdx(r.Reloc(pkgbits.RelocPosBase))
-}
-
-func (pr *pkgReader) posBaseIdx(idx pkgbits.Index) string {
-	if b := pr.posBases[idx]; b != "" {
-		return b
-	}
-
-	var filename string
-	{
-		r := pr.tempReader(pkgbits.RelocPosBase, idx, pkgbits.SyncPosBase)
-
-		// Within types2, position bases have a lot more details (e.g.,
-		// keeping track of where //line directives appeared exactly).
-		//
-		// For go/types, we just track the file name.
-
-		filename = r.String()
-
-		if r.Bool() { // file base
-			// Was: "b = token.NewTrimmedFileBase(filename, true)"
-		} else { // line base
-			pos := r.pos()
-			line := r.Uint()
-			col := r.Uint()
-
-			// Was: "b = token.NewLineBase(pos, filename, true, line, col)"
-			_, _, _ = pos, line, col
-		}
-		pr.retireReader(r)
-	}
-	b := filename
-	pr.posBases[idx] = b
-	return b
-}
-
-// @@@ Packages
-
-func (r *reader) pkg() *types.Package {
-	r.Sync(pkgbits.SyncPkg)
-	return r.p.pkgIdx(r.Reloc(pkgbits.RelocPkg))
-}
-
-func (pr *pkgReader) pkgIdx(idx pkgbits.Index) *types.Package {
-	// TODO(mdempsky): Consider using some non-nil pointer to indicate
-	// the universe scope, so we don't need to keep re-reading it.
-	if pkg := pr.pkgs[idx]; pkg != nil {
-		return pkg
-	}
-
-	pkg := pr.newReader(pkgbits.RelocPkg, idx, pkgbits.SyncPkgDef).doPkg()
-	pr.pkgs[idx] = pkg
-	return pkg
-}
-
-func (r *reader) doPkg() *types.Package {
-	path := r.String()
-	switch path {
-	// cmd/compile emits path="main" for main packages because
-	// that's the linker symbol prefix it used; but we need
-	// the package's path as it would be reported by go list,
-	// hence "main" below.
-	// See test at go/packages.TestMainPackagePathInModeTypes.
-	case "", "main":
-		path = r.p.PkgPath()
-	case "builtin":
-		return nil // universe
-	case "unsafe":
-		return types.Unsafe
-	}
-
-	if pkg := r.p.imports[path]; pkg != nil {
-		return pkg
-	}
-
-	name := r.String()
-
-	pkg := types.NewPackage(path, name)
-	r.p.imports[path] = pkg
-
-	return pkg
-}
-
-// @@@ Types
-
-func (r *reader) typ() types.Type {
-	return r.p.typIdx(r.typInfo(), r.dict)
-}
-
-func (r *reader) typInfo() typeInfo {
-	r.Sync(pkgbits.SyncType)
-	if r.Bool() {
-		return typeInfo{idx: pkgbits.Index(r.Len()), derived: true}
-	}
-	return typeInfo{idx: r.Reloc(pkgbits.RelocType), derived: false}
-}
-
-func (pr *pkgReader) typIdx(info typeInfo, dict *readerDict) types.Type {
-	idx := info.idx
-	var where *types.Type
-	if info.derived {
-		where = &dict.derivedTypes[idx]
-		idx = dict.derived[idx].idx
-	} else {
-		where = &pr.typs[idx]
-	}
-
-	if typ := *where; typ != nil {
-		return typ
-	}
-
-	var typ types.Type
-	{
-		r := pr.tempReader(pkgbits.RelocType, idx, pkgbits.SyncTypeIdx)
-		r.dict = dict
-
-		typ = r.doTyp()
-		assert(typ != nil)
-		pr.retireReader(r)
-	}
-	// See comment in pkgReader.typIdx explaining how this happens.
-	if prev := *where; prev != nil {
-		return prev
-	}
-
-	*where = typ
-	return typ
-}
-
-func (r *reader) doTyp() (res types.Type) {
-	switch tag := pkgbits.CodeType(r.Code(pkgbits.SyncType)); tag {
-	default:
-		errorf("unhandled type tag: %v", tag)
-		panic("unreachable")
-
-	case pkgbits.TypeBasic:
-		return types.Typ[r.Len()]
-
-	case pkgbits.TypeNamed:
-		obj, targs := r.obj()
-		name := obj.(*types.TypeName)
-		if len(targs) != 0 {
-			t, _ := types.Instantiate(r.p.ctxt, name.Type(), targs, false)
-			return t
-		}
-		return name.Type()
-
-	case pkgbits.TypeTypeParam:
-		n := r.Len()
-		if n < len(r.dict.rtbounds) {
-			return r.dict.rtparams[n]
-		}
-		return r.dict.tparams[n-len(r.dict.rtbounds)]
-
-	case pkgbits.TypeArray:
-		len := int64(r.Uint64())
-		return types.NewArray(r.typ(), len)
-	case pkgbits.TypeChan:
-		dir := types.ChanDir(r.Len())
-		return types.NewChan(dir, r.typ())
-	case pkgbits.TypeMap:
-		return types.NewMap(r.typ(), r.typ())
-	case pkgbits.TypePointer:
-		return types.NewPointer(r.typ())
-	case pkgbits.TypeSignature:
-		return r.signature(nil, nil, nil)
-	case pkgbits.TypeSlice:
-		return types.NewSlice(r.typ())
-	case pkgbits.TypeStruct:
-		return r.structType()
-	case pkgbits.TypeInterface:
-		return r.interfaceType()
-	case pkgbits.TypeUnion:
-		return r.unionType()
-	}
-}
-
-func (r *reader) structType() *types.Struct {
-	fields := make([]*types.Var, r.Len())
-	var tags []string
-	for i := range fields {
-		pos := r.pos()
-		pkg, name := r.selector()
-		ftyp := r.typ()
-		tag := r.String()
-		embedded := r.Bool()
-
-		fields[i] = types.NewField(pos, pkg, name, ftyp, embedded)
-		if tag != "" {
-			for len(tags) < i {
-				tags = append(tags, "")
-			}
-			tags = append(tags, tag)
-		}
-	}
-	return types.NewStruct(fields, tags)
-}
-
-func (r *reader) unionType() *types.Union {
-	terms := make([]*types.Term, r.Len())
-	for i := range terms {
-		terms[i] = types.NewTerm(r.Bool(), r.typ())
-	}
-	return types.NewUnion(terms)
-}
-
-func (r *reader) interfaceType() *types.Interface {
-	methods := make([]*types.Func, r.Len())
-	embeddeds := make([]types.Type, r.Len())
-	implicit := len(methods) == 0 && len(embeddeds) == 1 && r.Bool()
-
-	for i := range methods {
-		pos := r.pos()
-		pkg, name := r.selector()
-		mtyp := r.signature(nil, nil, nil)
-		methods[i] = types.NewFunc(pos, pkg, name, mtyp)
-	}
-
-	for i := range embeddeds {
-		embeddeds[i] = r.typ()
-	}
-
-	iface := types.NewInterfaceType(methods, embeddeds)
-	if implicit {
-		iface.MarkImplicit()
-	}
-
-	// We need to call iface.Complete(), but if there are any embedded
-	// defined types, then we may not have set their underlying
-	// interface type yet. So we need to defer calling Complete until
-	// after we've called SetUnderlying everywhere.
-	//
-	// TODO(mdempsky): After CL 424876 lands, it should be safe to call
-	// iface.Complete() immediately.
-	r.p.ifaces = append(r.p.ifaces, iface)
-
-	return iface
-}
-
-func (r *reader) signature(recv *types.Var, rtparams, tparams []*types.TypeParam) *types.Signature {
-	r.Sync(pkgbits.SyncSignature)
-
-	params := r.params()
-	results := r.params()
-	variadic := r.Bool()
-
-	return types.NewSignatureType(recv, rtparams, tparams, params, results, variadic)
-}
-
-func (r *reader) params() *types.Tuple {
-	r.Sync(pkgbits.SyncParams)
-
-	params := make([]*types.Var, r.Len())
-	for i := range params {
-		params[i] = r.param()
-	}
-
-	return types.NewTuple(params...)
-}
-
-func (r *reader) param() *types.Var {
-	r.Sync(pkgbits.SyncParam)
-
-	pos := r.pos()
-	pkg, name := r.localIdent()
-	typ := r.typ()
-
-	return types.NewParam(pos, pkg, name, typ)
-}
-
-// @@@ Objects
-
-func (r *reader) obj() (types.Object, []types.Type) {
-	r.Sync(pkgbits.SyncObject)
-
-	if r.Version().Has(pkgbits.DerivedFuncInstance) {
-		assert(!r.Bool())
-	}
-
-	pkg, name := r.p.objIdx(r.Reloc(pkgbits.RelocObj))
-	obj := pkgScope(pkg).Lookup(name)
-
-	targs := make([]types.Type, r.Len())
-	for i := range targs {
-		targs[i] = r.typ()
-	}
-
-	return obj, targs
-}
-
-func (pr *pkgReader) objIdx(idx pkgbits.Index) (*types.Package, string) {
-
-	var objPkg *types.Package
-	var objName string
-	var tag pkgbits.CodeObj
-	{
-		rname := pr.tempReader(pkgbits.RelocName, idx, pkgbits.SyncObject1)
-
-		objPkg, objName = rname.qualifiedIdent()
-		assert(objName != "")
-
-		tag = pkgbits.CodeObj(rname.Code(pkgbits.SyncCodeObj))
-		pr.retireReader(rname)
-	}
-
-	if tag == pkgbits.ObjStub {
-		assert(objPkg == nil || objPkg == types.Unsafe)
-		return objPkg, objName
-	}
-
-	// Ignore local types promoted to global scope (#55110).
-	if _, suffix := splitVargenSuffix(objName); suffix != "" {
-		return objPkg, objName
-	}
-
-	// TODO(mark): This, like the above splitVargenSuffix, is not ideal.
-	// Ignore generic methods promoted to global scope.
-	if strings.Contains(objName, ".") {
-		return objPkg, objName
-	}
-
-	if objPkg.Scope().Lookup(objName) == nil {
-		dict := pr.objDictIdx(idx)
-
-		r := pr.newReader(pkgbits.RelocObj, idx, pkgbits.SyncObject1)
-		r.dict = dict
-
-		declare := func(obj types.Object) {
-			objPkg.Scope().Insert(obj)
-		}
-
-		switch tag {
-		default:
-			panic("weird")
-
-		case pkgbits.ObjAlias:
-			pos := r.pos()
-			var tparams []*types.TypeParam
-			if r.Version().Has(pkgbits.AliasTypeParamNames) {
-				tparams = r.typeParamNames(false)
-			}
-			typ := r.typ()
-			declare(aliases.New(pos, objPkg, objName, typ, tparams))
-
-		case pkgbits.ObjConst:
-			pos := r.pos()
-			typ := r.typ()
-			val := r.Value()
-			declare(types.NewConst(pos, objPkg, objName, typ, val))
-
-		case pkgbits.ObjFunc:
-			pos := r.pos()
-			if r.Version().Has(pkgbits.GenericMethods) {
-				assert(!r.Bool()) // generic methods are read in their defining type
-			}
-			tparams := r.typeParamNames(false)
-			sig := r.signature(nil, nil, tparams)
-			declare(types.NewFunc(pos, objPkg, objName, sig))
-
-		case pkgbits.ObjType:
-			pos := r.pos()
-
-			obj := types.NewTypeName(pos, objPkg, objName, nil)
-			named := types.NewNamed(obj, nil, nil)
-			declare(obj)
-
-			named.SetTypeParams(r.typeParamNames(false))
-
-			setUnderlying := func(underlying types.Type) {
-				// If the underlying type is an interface, we need to
-				// duplicate its methods so we can replace the receiver
-				// parameter's type (#49906).
-				if iface, ok := types.Unalias(underlying).(*types.Interface); ok && iface.NumExplicitMethods() != 0 {
-					methods := make([]*types.Func, iface.NumExplicitMethods())
-					for i := range methods {
-						fn := iface.ExplicitMethod(i)
-						sig := fn.Type().(*types.Signature)
-
-						recv := types.NewVar(fn.Pos(), fn.Pkg(), "", named)
-						typesinternal.SetVarKind(recv, typesinternal.RecvVar)
-						methods[i] = types.NewFunc(fn.Pos(), fn.Pkg(), fn.Name(), types.NewSignatureType(recv, nil, nil, sig.Params(), sig.Results(), sig.Variadic()))
-					}
-
-					embeds := make([]types.Type, iface.NumEmbeddeds())
-					for i := range embeds {
-						embeds[i] = iface.EmbeddedType(i)
-					}
-
-					newIface := types.NewInterfaceType(methods, embeds)
-					r.p.ifaces = append(r.p.ifaces, newIface)
-					underlying = newIface
-				}
-
-				named.SetUnderlying(underlying)
-			}
-
-			// Since go.dev/cl/455279, we can assume rhs.Underlying() will
-			// always be non-nil. However, to temporarily support users of
-			// older snapshot releases, we continue to fallback to the old
-			// behavior for now.
-			//
-			// TODO(mdempsky): Remove fallback code and simplify after
-			// allowing time for snapshot users to upgrade.
-			rhs := r.typ()
-			if underlying := rhs.Underlying(); underlying != nil {
-				setUnderlying(underlying)
-			} else {
-				pk := r.p
-				pk.laterFor(named, func() {
-					// First be sure that the rhs is initialized, if it needs to be initialized.
-					delete(pk.laterFors, named) // prevent cycles
-					if i, ok := pk.laterFors[rhs]; ok {
-						f := pk.laterFns[i]
-						pk.laterFns[i] = func() {} // function is running now, so replace it with a no-op
-						f()                        // initialize RHS
-					}
-					setUnderlying(rhs.Underlying())
-				})
-			}
-
-			for i, n := 0, r.Len(); i < n; i++ {
-				named.AddMethod(r.method())
-			}
-
-			if r.Version().Has(pkgbits.GenericMethods) {
-				for range r.Len() {
-					// Careful: objIdx is used to read in package-scoped declarations, which
-					// methods are not. Instead, decode it here. This makes it easier to
-					// associate it with the type and avoids the main objIdx loop.
-					idx := r.Reloc(pkgbits.RelocObj)
-
-					r := pr.tempReader(pkgbits.RelocObj, idx, pkgbits.SyncObject1)
-					r.dict = pr.objDictIdx(idx)
-
-					pos := r.pos()
-					assert(r.Bool()) // generic method
-					pkg, name := r.selector()
-					rtparams := r.typeParamNames(true)
-					recv := r.param()
-					tparams := r.typeParamNames(false)
-					sig := r.signature(recv, rtparams, tparams)
-
-					pr.retireReader(r)
-					named.AddMethod(types.NewFunc(pos, pkg, name, sig))
-				}
-			}
-
-		case pkgbits.ObjVar:
-			pos := r.pos()
-			typ := r.typ()
-			v := types.NewVar(pos, objPkg, objName, typ)
-			typesinternal.SetVarKind(v, typesinternal.PackageVar)
-			declare(v)
-		}
-	}
-
-	return objPkg, objName
-}
-
-func (pr *pkgReader) objDictIdx(idx pkgbits.Index) *readerDict {
-
-	var dict readerDict
-
-	{
-		r := pr.tempReader(pkgbits.RelocObjDict, idx, pkgbits.SyncObject1)
-		if implicits := r.Len(); implicits != 0 {
-			errorf("unexpected object with %v implicit type parameter(s)", implicits)
-		}
-
-		nreceivers := 0
-		if r.Version().Has(pkgbits.GenericMethods) {
-			nreceivers = r.Len()
-		}
-		nexplicits := r.Len()
-
-		dict.rtbounds = make([]typeInfo, nreceivers)
-		for i := range dict.rtbounds {
-			dict.rtbounds[i] = r.typInfo()
-		}
-
-		dict.tbounds = make([]typeInfo, nexplicits)
-		for i := range dict.tbounds {
-			dict.tbounds[i] = r.typInfo()
-		}
-
-		dict.derived = make([]derivedInfo, r.Len())
-		dict.derivedTypes = make([]types.Type, len(dict.derived))
-		for i := range dict.derived {
-			dict.derived[i] = derivedInfo{idx: r.Reloc(pkgbits.RelocType)}
-			if r.Version().Has(pkgbits.DerivedInfoNeeded) {
-				assert(!r.Bool())
-			}
-		}
-
-		pr.retireReader(r)
-	}
-	// function references follow, but reader doesn't need those
-
-	return &dict
-}
-
-func (r *reader) typeParamNames(isGenMeth bool) []*types.TypeParam {
-	r.Sync(pkgbits.SyncTypeParamNames)
-
-	// Note: This code assumes there are no implicit type parameters.
-	// This is fine since it only reads exported declarations, which
-	// never have implicits.
-
-	var in []typeInfo
-	var out *[]*types.TypeParam
-	if isGenMeth {
-		in = r.dict.rtbounds
-		out = &r.dict.rtparams
-	} else {
-		in = r.dict.tbounds
-		out = &r.dict.tparams
-	}
-
-	if len(in) == 0 {
-		return nil
-	}
-
-	// Careful: Type parameter lists may have cycles. To allow for this,
-	// we construct the type parameter list in two passes: first we
-	// create all the TypeNames and TypeParams, then we construct and
-	// set the bound type.
-
-	// We have to save tparams outside of the closure, because typeParamNames
-	// can be called multiple times with the same dictionary instance.
-	tparams := make([]*types.TypeParam, len(in))
-	*out = tparams
-
-	for i := range in {
-		pos := r.pos()
-		pkg, name := r.localIdent()
-
-		tname := types.NewTypeName(pos, pkg, name, nil)
-		tparams[i] = types.NewTypeParam(tname, nil)
-	}
-
-	// The reader dictionary will continue mutating before we have time
-	// to call delayed functions; make a local copy of the constraints.
-	types := make([]types.Type, len(in))
-	for i, info := range in {
-		types[i] = r.p.typIdx(info, r.dict)
-	}
-
-	// This needs to happen later to make sure SetUnderlying has been called.
-	r.p.later(func() {
-		for i, typ := range types {
-			tparams[i].SetConstraint(typ)
-		}
-	})
-
-	return tparams
-}
-
-func (r *reader) method() *types.Func {
-	r.Sync(pkgbits.SyncMethod)
-	pos := r.pos()
-	pkg, name := r.selector()
-
-	rparams := r.typeParamNames(false)
-	sig := r.signature(r.param(), rparams, nil)
-
-	_ = r.pos() // TODO(mdempsky): Remove; this is a hacker for linker.go.
-	return types.NewFunc(pos, pkg, name, sig)
-}
-
-func (r *reader) qualifiedIdent() (*types.Package, string) { return r.ident(pkgbits.SyncSym) }
-func (r *reader) localIdent() (*types.Package, string)     { return r.ident(pkgbits.SyncLocalIdent) }
-func (r *reader) selector() (*types.Package, string)       { return r.ident(pkgbits.SyncSelector) }
-
-func (r *reader) ident(marker pkgbits.SyncMarker) (*types.Package, string) {
-	r.Sync(marker)
-	return r.pkg(), r.String()
-}
-
-// pkgScope returns pkg.Scope().
-// If pkg is nil, it returns types.Universe instead.
-//
-// TODO(mdempsky): Remove after x/tools can depend on Go 1.19.
-func pkgScope(pkg *types.Package) *types.Scope {
-	if pkg != nil {
-		return pkg.Scope()
-	}
-	return types.Universe
-}
-
-// See cmd/compile/internal/types.SplitVargenSuffix.
-func splitVargenSuffix(name string) (base, suffix string) {
-	i := len(name)
-	for i > 0 && name[i-1] >= '0' && name[i-1] <= '9' {
-		i--
-	}
-	const dot = "·"
-	if i >= len(dot) && name[i-len(dot):i] == dot {
-		i -= len(dot)
-		return name[:i], name[i:]
-	}
-	return name, ""
-}
diff --git a/vendor/golang.org/x/tools/internal/gocommand/invoke.go b/vendor/golang.org/x/tools/internal/gocommand/invoke.go
deleted file mode 100644
index 58721202de..0000000000
--- a/vendor/golang.org/x/tools/internal/gocommand/invoke.go
+++ /dev/null
@@ -1,567 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package gocommand is a helper for calling the go command.
-package gocommand
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"log"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"regexp"
-	"runtime"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"golang.org/x/tools/internal/event"
-	"golang.org/x/tools/internal/event/keys"
-	"golang.org/x/tools/internal/event/label"
-)
-
-// A Runner will run go command invocations and serialize
-// them if it sees a concurrency error.
-type Runner struct {
-	// once guards the runner initialization.
-	once sync.Once
-
-	// inFlight tracks available workers.
-	inFlight chan struct{}
-
-	// serialized guards the ability to run a go command serially,
-	// to avoid deadlocks when claiming workers.
-	serialized chan struct{}
-}
-
-const maxInFlight = 10
-
-func (runner *Runner) initialize() {
-	runner.once.Do(func() {
-		runner.inFlight = make(chan struct{}, maxInFlight)
-		runner.serialized = make(chan struct{}, 1)
-	})
-}
-
-// 1.13: go: updates to go.mod needed, but contents have changed
-// 1.14: go: updating go.mod: existing contents have changed since last read
-var modConcurrencyError = regexp.MustCompile(`go:.*go.mod.*contents have changed`)
-
-// event keys for go command invocations
-var (
-	verb      = keys.NewString("verb", "go command verb")
-	directory = keys.NewString("directory", "")
-)
-
-func invLabels(inv Invocation) []label.Label {
-	return []label.Label{verb.Of(inv.Verb), directory.Of(inv.WorkingDir)}
-}
-
-// Run is a convenience wrapper around RunRaw.
-// It returns only stdout and a "friendly" error.
-func (runner *Runner) Run(ctx context.Context, inv Invocation) (*bytes.Buffer, error) {
-	ctx, done := event.Start(ctx, "gocommand.Runner.Run", invLabels(inv)...)
-	defer done()
-
-	stdout, _, friendly, _ := runner.RunRaw(ctx, inv)
-	return stdout, friendly
-}
-
-// RunPiped runs the invocation serially, always waiting for any concurrent
-// invocations to complete first.
-func (runner *Runner) RunPiped(ctx context.Context, inv Invocation, stdout, stderr io.Writer) error {
-	ctx, done := event.Start(ctx, "gocommand.Runner.RunPiped", invLabels(inv)...)
-	defer done()
-
-	_, err := runner.runPiped(ctx, inv, stdout, stderr)
-	return err
-}
-
-// RunRaw runs the invocation, serializing requests only if they fight over
-// go.mod changes.
-// Postcondition: both error results have same nilness.
-func (runner *Runner) RunRaw(ctx context.Context, inv Invocation) (*bytes.Buffer, *bytes.Buffer, error, error) {
-	ctx, done := event.Start(ctx, "gocommand.Runner.RunRaw", invLabels(inv)...)
-	defer done()
-	// Make sure the runner is always initialized.
-	runner.initialize()
-
-	// First, try to run the go command concurrently.
-	stdout, stderr, friendlyErr, err := runner.runConcurrent(ctx, inv)
-
-	// If we encounter a load concurrency error, we need to retry serially.
-	if friendlyErr != nil && modConcurrencyError.MatchString(friendlyErr.Error()) {
-		event.Error(ctx, "Load concurrency error, will retry serially", err)
-
-		// Run serially by calling runPiped.
-		stdout.Reset()
-		stderr.Reset()
-		friendlyErr, err = runner.runPiped(ctx, inv, stdout, stderr)
-	}
-
-	return stdout, stderr, friendlyErr, err
-}
-
-// Postcondition: both error results have same nilness.
-func (runner *Runner) runConcurrent(ctx context.Context, inv Invocation) (*bytes.Buffer, *bytes.Buffer, error, error) {
-	// Wait for 1 worker to become available.
-	select {
-	case <-ctx.Done():
-		return nil, nil, ctx.Err(), ctx.Err()
-	case runner.inFlight <- struct{}{}:
-		defer func() { <-runner.inFlight }()
-	}
-
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	friendlyErr, err := inv.runWithFriendlyError(ctx, stdout, stderr)
-	return stdout, stderr, friendlyErr, err
-}
-
-// Postcondition: both error results have same nilness.
-func (runner *Runner) runPiped(ctx context.Context, inv Invocation, stdout, stderr io.Writer) (error, error) {
-	// Make sure the runner is always initialized.
-	runner.initialize()
-
-	// Acquire the serialization lock. This avoids deadlocks between two
-	// runPiped commands.
-	select {
-	case <-ctx.Done():
-		return ctx.Err(), ctx.Err()
-	case runner.serialized <- struct{}{}:
-		defer func() { <-runner.serialized }()
-	}
-
-	// Wait for all in-progress go commands to return before proceeding,
-	// to avoid load concurrency errors.
-	for range maxInFlight {
-		select {
-		case <-ctx.Done():
-			return ctx.Err(), ctx.Err()
-		case runner.inFlight <- struct{}{}:
-			// Make sure we always "return" any workers we took.
-			defer func() { <-runner.inFlight }()
-		}
-	}
-
-	return inv.runWithFriendlyError(ctx, stdout, stderr)
-}
-
-// An Invocation represents a call to the go command.
-type Invocation struct {
-	Verb       string
-	Args       []string
-	BuildFlags []string
-
-	// If ModFlag is set, the go command is invoked with -mod=ModFlag.
-	// TODO(rfindley): remove, in favor of Args.
-	ModFlag string
-
-	// If ModFile is set, the go command is invoked with -modfile=ModFile.
-	// TODO(rfindley): remove, in favor of Args.
-	ModFile string
-
-	// Overlay is the name of the JSON overlay file that describes
-	// unsaved editor buffers; see [WriteOverlays].
-	// If set, the go command is invoked with -overlay=Overlay.
-	// TODO(rfindley): remove, in favor of Args.
-	Overlay string
-
-	// If CleanEnv is set, the invocation will run only with the environment
-	// in Env, not starting with os.Environ.
-	CleanEnv   bool
-	Env        []string
-	WorkingDir string
-	Logf       func(format string, args ...any)
-}
-
-// Postcondition: both error results have same nilness.
-func (i *Invocation) runWithFriendlyError(ctx context.Context, stdout, stderr io.Writer) (friendlyError error, rawError error) {
-	rawError = i.run(ctx, stdout, stderr)
-	if rawError != nil {
-		friendlyError = rawError
-		// Check for 'go' executable not being found.
-		if ee, ok := rawError.(*exec.Error); ok && ee.Err == exec.ErrNotFound {
-			friendlyError = fmt.Errorf("go command required, not found: %v", ee)
-		}
-		if ctx.Err() != nil {
-			friendlyError = ctx.Err()
-		}
-		friendlyError = fmt.Errorf("err: %v: stderr: %s", friendlyError, stderr)
-	}
-	return
-}
-
-// logf logs if i.Logf is non-nil.
-func (i *Invocation) logf(format string, args ...any) {
-	if i.Logf != nil {
-		i.Logf(format, args...)
-	}
-}
-
-func (i *Invocation) run(ctx context.Context, stdout, stderr io.Writer) error {
-	goArgs := []string{i.Verb}
-
-	appendModFile := func() {
-		if i.ModFile != "" {
-			goArgs = append(goArgs, "-modfile="+i.ModFile)
-		}
-	}
-	appendModFlag := func() {
-		if i.ModFlag != "" {
-			goArgs = append(goArgs, "-mod="+i.ModFlag)
-		}
-	}
-	appendOverlayFlag := func() {
-		if i.Overlay != "" {
-			goArgs = append(goArgs, "-overlay="+i.Overlay)
-		}
-	}
-
-	switch i.Verb {
-	case "env", "version":
-		goArgs = append(goArgs, i.Args...)
-	case "mod":
-		// mod needs the sub-verb before flags.
-		goArgs = append(goArgs, i.Args[0])
-		appendModFile()
-		goArgs = append(goArgs, i.Args[1:]...)
-	case "get":
-		goArgs = append(goArgs, i.BuildFlags...)
-		appendModFile()
-		goArgs = append(goArgs, i.Args...)
-
-	default: // notably list and build.
-		goArgs = append(goArgs, i.BuildFlags...)
-		appendModFile()
-		appendModFlag()
-		appendOverlayFlag()
-		goArgs = append(goArgs, i.Args...)
-	}
-	cmd := exec.Command("go", goArgs...)
-	cmd.Stdout = stdout
-	cmd.Stderr = stderr
-
-	// https://go.dev/issue/59541: don't wait forever copying stderr
-	// after the command has exited.
-	// After CL 484741 we copy stdout manually, so we we'll stop reading that as
-	// soon as ctx is done. However, we also don't want to wait around forever
-	// for stderr. Give a much-longer-than-reasonable delay and then assume that
-	// something has wedged in the kernel or runtime.
-	cmd.WaitDelay = 30 * time.Second
-
-	// The cwd gets resolved to the real path. On Darwin, where
-	// /tmp is a symlink, this breaks anything that expects the
-	// working directory to keep the original path, including the
-	// go command when dealing with modules.
-	//
-	// os.Getwd has a special feature where if the cwd and the PWD
-	// are the same node then it trusts the PWD, so by setting it
-	// in the env for the child process we fix up all the paths
-	// returned by the go command.
-	if !i.CleanEnv {
-		cmd.Env = os.Environ()
-	}
-	cmd.Env = append(cmd.Env, i.Env...)
-	if i.WorkingDir != "" {
-		cmd.Env = append(cmd.Env, "PWD="+i.WorkingDir)
-		cmd.Dir = i.WorkingDir
-	}
-
-	debugStr := cmdDebugStr(cmd)
-	i.logf("starting %v", debugStr)
-	start := time.Now()
-	defer func() {
-		i.logf("%s for %v", time.Since(start), debugStr)
-	}()
-
-	return runCmdContext(ctx, cmd)
-}
-
-// DebugHangingGoCommands may be set by tests to enable additional
-// instrumentation (including panics) for debugging hanging Go commands.
-//
-// See golang/go#54461 for details.
-var DebugHangingGoCommands = false
-
-// runCmdContext is like exec.CommandContext except it sends os.Interrupt
-// before os.Kill.
-func runCmdContext(ctx context.Context, cmd *exec.Cmd) (err error) {
-	// If cmd.Stdout is not an *os.File, the exec package will create a pipe and
-	// copy it to the Writer in a goroutine until the process has finished and
-	// either the pipe reaches EOF or command's WaitDelay expires.
-	//
-	// However, the output from 'go list' can be quite large, and we don't want to
-	// keep reading (and allocating buffers) if we've already decided we don't
-	// care about the output. We don't want to wait for the process to finish, and
-	// we don't wait to wait for the WaitDelay to expire either.
-	//
-	// Instead, if cmd.Stdout requires a copying goroutine we explicitly replace
-	// it with a pipe (which is an *os.File), which we can close in order to stop
-	// copying output as soon as we realize we don't care about it.
-	var stdoutW *os.File
-	if cmd.Stdout != nil {
-		if _, ok := cmd.Stdout.(*os.File); !ok {
-			var stdoutR *os.File
-			stdoutR, stdoutW, err = os.Pipe()
-			if err != nil {
-				return err
-			}
-			prevStdout := cmd.Stdout
-			cmd.Stdout = stdoutW
-
-			stdoutErr := make(chan error, 1)
-			go func() {
-				_, err := io.Copy(prevStdout, stdoutR)
-				if err != nil {
-					err = fmt.Errorf("copying stdout: %w", err)
-				}
-				stdoutErr <- err
-			}()
-			defer func() {
-				// We started a goroutine to copy a stdout pipe.
-				// Wait for it to finish, or terminate it if need be.
-				var err2 error
-				select {
-				case err2 = <-stdoutErr:
-					stdoutR.Close()
-				case <-ctx.Done():
-					stdoutR.Close()
-					// Per https://pkg.go.dev/os#File.Close, the call to stdoutR.Close
-					// should cause the Read call in io.Copy to unblock and return
-					// immediately, but we still need to receive from stdoutErr to confirm
-					// that it has happened.
-					<-stdoutErr
-					err2 = ctx.Err()
-				}
-				if err == nil {
-					err = err2
-				}
-			}()
-
-			// Per https://pkg.go.dev/os/exec#Cmd, “If Stdout and Stderr are the
-			// same writer, and have a type that can be compared with ==, at most
-			// one goroutine at a time will call Write.”
-			//
-			// Since we're starting a goroutine that writes to cmd.Stdout, we must
-			// also update cmd.Stderr so that it still holds.
-			func() {
-				defer func() { recover() }()
-				if cmd.Stderr == prevStdout {
-					cmd.Stderr = cmd.Stdout
-				}
-			}()
-		}
-	}
-
-	startTime := time.Now()
-	err = cmd.Start()
-	if stdoutW != nil {
-		// The child process has inherited the pipe file,
-		// so close the copy held in this process.
-		stdoutW.Close()
-		stdoutW = nil
-	}
-	if err != nil {
-		return err
-	}
-
-	resChan := make(chan error, 1)
-	go func() {
-		resChan <- cmd.Wait()
-	}()
-
-	// If we're interested in debugging hanging Go commands, stop waiting after a
-	// minute and panic with interesting information.
-	debug := DebugHangingGoCommands
-	if debug {
-		timer := time.NewTimer(1 * time.Minute)
-		defer timer.Stop()
-		select {
-		case err := <-resChan:
-			return err
-		case <-timer.C:
-			// HandleHangingGoCommand terminates this process.
-			// Pass off resChan in case we can collect the command error.
-			handleHangingGoCommand(startTime, cmd, resChan)
-		case <-ctx.Done():
-		}
-	} else {
-		select {
-		case err := <-resChan:
-			return err
-		case <-ctx.Done():
-		}
-	}
-
-	// Cancelled. Interrupt and see if it ends voluntarily.
-	if err := cmd.Process.Signal(os.Interrupt); err == nil {
-		// (We used to wait only 1s but this proved
-		// fragile on loaded builder machines.)
-		timer := time.NewTimer(5 * time.Second)
-		defer timer.Stop()
-		select {
-		case err := <-resChan:
-			return err
-		case <-timer.C:
-		}
-	}
-
-	// Didn't shut down in response to interrupt. Kill it hard.
-	if err := cmd.Process.Kill(); err != nil && !errors.Is(err, os.ErrProcessDone) && debug {
-		log.Printf("error killing the Go command: %v", err)
-	}
-
-	return <-resChan
-}
-
-// handleHangingGoCommand outputs debugging information to help diagnose the
-// cause of a hanging Go command, and then exits with log.Fatalf.
-func handleHangingGoCommand(start time.Time, cmd *exec.Cmd, resChan chan error) {
-	switch runtime.GOOS {
-	case "linux", "darwin", "freebsd", "netbsd", "openbsd":
-		fmt.Fprintln(os.Stderr, `DETECTED A HANGING GO COMMAND
-
-			The gopls test runner has detected a hanging go command. In order to debug
-			this, the output of ps and lsof/fstat is printed below.
-
-			See golang/go#54461 for more details.`)
-
-		fmt.Fprintln(os.Stderr, "\nps axo ppid,pid,command:")
-		fmt.Fprintln(os.Stderr, "-------------------------")
-		psCmd := exec.Command("ps", "axo", "ppid,pid,command")
-		psCmd.Stdout = os.Stderr
-		psCmd.Stderr = os.Stderr
-		if err := psCmd.Run(); err != nil {
-			log.Printf("Handling hanging Go command: running ps: %v", err)
-		}
-
-		listFiles := "lsof"
-		if runtime.GOOS == "freebsd" || runtime.GOOS == "netbsd" {
-			listFiles = "fstat"
-		}
-
-		fmt.Fprintln(os.Stderr, "\n"+listFiles+":")
-		fmt.Fprintln(os.Stderr, "-----")
-		listFilesCmd := exec.Command(listFiles)
-		listFilesCmd.Stdout = os.Stderr
-		listFilesCmd.Stderr = os.Stderr
-		if err := listFilesCmd.Run(); err != nil {
-			log.Printf("Handling hanging Go command: running %s: %v", listFiles, err)
-		}
-		// Try to extract information about the slow go process by issuing a SIGQUIT.
-		if err := cmd.Process.Signal(sigStuckProcess); err == nil {
-			select {
-			case err := <-resChan:
-				stderr := "not a bytes.Buffer"
-				if buf, _ := cmd.Stderr.(*bytes.Buffer); buf != nil {
-					stderr = buf.String()
-				}
-				log.Printf("Quit hanging go command:\n\terr:%v\n\tstderr:\n%v\n\n", err, stderr)
-			case <-time.After(5 * time.Second):
-			}
-		} else {
-			log.Printf("Sending signal %d to hanging go command: %v", sigStuckProcess, err)
-		}
-	}
-	log.Fatalf("detected hanging go command (golang/go#54461); waited %s\n\tcommand:%s\n\tpid:%d", time.Since(start), cmd, cmd.Process.Pid)
-}
-
-func cmdDebugStr(cmd *exec.Cmd) string {
-	env := make(map[string]string)
-	for _, kv := range cmd.Env {
-		split := strings.SplitN(kv, "=", 2)
-		if len(split) == 2 {
-			k, v := split[0], split[1]
-			env[k] = v
-		}
-	}
-
-	var args []string
-	for _, arg := range cmd.Args {
-		quoted := strconv.Quote(arg)
-		if quoted[1:len(quoted)-1] != arg || strings.Contains(arg, " ") {
-			args = append(args, quoted)
-		} else {
-			args = append(args, arg)
-		}
-	}
-	return fmt.Sprintf("GOROOT=%v GOPATH=%v GO111MODULE=%v GOPROXY=%v PWD=%v %v", env["GOROOT"], env["GOPATH"], env["GO111MODULE"], env["GOPROXY"], env["PWD"], strings.Join(args, " "))
-}
-
-// WriteOverlays writes each value in the overlay (see the Overlay
-// field of go/packages.Config) to a temporary file and returns the name
-// of a JSON file describing the mapping that is suitable for the "go
-// list -overlay" flag.
-//
-// On success, the caller must call the cleanup function exactly once
-// when the files are no longer needed.
-func WriteOverlays(overlay map[string][]byte) (filename string, cleanup func(), err error) {
-	// Do nothing if there are no overlays in the config.
-	if len(overlay) == 0 {
-		return "", func() {}, nil
-	}
-
-	dir, err := os.MkdirTemp("", "gocommand-*")
-	if err != nil {
-		return "", nil, err
-	}
-
-	// The caller must clean up this directory,
-	// unless this function returns an error.
-	// (The cleanup operand of each return
-	// statement below is ignored.)
-	defer func() {
-		cleanup = func() {
-			os.RemoveAll(dir)
-		}
-		if err != nil {
-			cleanup()
-			cleanup = nil
-		}
-	}()
-
-	// Write each map entry to a temporary file.
-	overlays := make(map[string]string)
-	for k, v := range overlay {
-		// Use a unique basename for each file (001-foo.go),
-		// to avoid creating nested directories.
-		base := fmt.Sprintf("%d-%s", 1+len(overlays), filepath.Base(k))
-		filename := filepath.Join(dir, base)
-		err := os.WriteFile(filename, v, 0666)
-		if err != nil {
-			return "", nil, err
-		}
-		overlays[k] = filename
-	}
-
-	// Write the JSON overlay file that maps logical file names to temp files.
-	//
-	// OverlayJSON is the format overlay files are expected to be in.
-	// The Replace map maps from overlaid paths to replacement paths:
-	// the Go command will forward all reads trying to open
-	// each overlaid path to its replacement path, or consider the overlaid
-	// path not to exist if the replacement path is empty.
-	//
-	// From golang/go#39958.
-	type OverlayJSON struct {
-		Replace map[string]string `json:"replace,omitempty"`
-	}
-	b, err := json.Marshal(OverlayJSON{Replace: overlays})
-	if err != nil {
-		return "", nil, err
-	}
-	filename = filepath.Join(dir, "overlay.json")
-	if err := os.WriteFile(filename, b, 0666); err != nil {
-		return "", nil, err
-	}
-
-	return filename, nil, nil
-}
diff --git a/vendor/golang.org/x/tools/internal/gocommand/invoke_notunix.go b/vendor/golang.org/x/tools/internal/gocommand/invoke_notunix.go
deleted file mode 100644
index 469c648e4d..0000000000
--- a/vendor/golang.org/x/tools/internal/gocommand/invoke_notunix.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2025 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build !unix
-
-package gocommand
-
-import "os"
-
-// sigStuckProcess is the signal to send to kill a hanging subprocess.
-// On Unix we send SIGQUIT, but on non-Unix we only have os.Kill.
-var sigStuckProcess = os.Kill
diff --git a/vendor/golang.org/x/tools/internal/gocommand/invoke_unix.go b/vendor/golang.org/x/tools/internal/gocommand/invoke_unix.go
deleted file mode 100644
index 169d37c8e9..0000000000
--- a/vendor/golang.org/x/tools/internal/gocommand/invoke_unix.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2025 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build unix
-
-package gocommand
-
-import "syscall"
-
-// Sigstuckprocess is the signal to send to kill a hanging subprocess.
-// Send SIGQUIT to get a stack trace.
-var sigStuckProcess = syscall.SIGQUIT
diff --git a/vendor/golang.org/x/tools/internal/gocommand/vendor.go b/vendor/golang.org/x/tools/internal/gocommand/vendor.go
deleted file mode 100644
index e38d1fb488..0000000000
--- a/vendor/golang.org/x/tools/internal/gocommand/vendor.go
+++ /dev/null
@@ -1,163 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gocommand
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-	"time"
-
-	"golang.org/x/mod/semver"
-)
-
-// ModuleJSON holds information about a module.
-type ModuleJSON struct {
-	Path      string      // module path
-	Version   string      // module version
-	Versions  []string    // available module versions (with -versions)
-	Replace   *ModuleJSON // replaced by this module
-	Time      *time.Time  // time version was created
-	Update    *ModuleJSON // available update, if any (with -u)
-	Main      bool        // is this the main module?
-	Indirect  bool        // is this module only an indirect dependency of main module?
-	Dir       string      // directory holding files for this module, if any
-	GoMod     string      // path to go.mod file used when loading this module, if any
-	GoVersion string      // go version used in module
-}
-
-var modFlagRegexp = regexp.MustCompile(`-mod[ =](\w+)`)
-
-// VendorEnabled reports whether vendoring is enabled. It takes a *Runner to execute Go commands
-// with the supplied context.Context and Invocation. The Invocation can contain pre-defined fields,
-// of which only Verb and Args are modified to run the appropriate Go command.
-// Inspired by setDefaultBuildMod in modload/init.go
-func VendorEnabled(ctx context.Context, inv Invocation, r *Runner) (bool, *ModuleJSON, error) {
-	mainMod, go114, err := getMainModuleAnd114(ctx, inv, r)
-	if err != nil {
-		return false, nil, err
-	}
-
-	// We check the GOFLAGS to see if there is anything overridden or not.
-	inv.Verb = "env"
-	inv.Args = []string{"GOFLAGS"}
-	stdout, err := r.Run(ctx, inv)
-	if err != nil {
-		return false, nil, err
-	}
-	goflags := string(bytes.TrimSpace(stdout.Bytes()))
-	matches := modFlagRegexp.FindStringSubmatch(goflags)
-	var modFlag string
-	if len(matches) != 0 {
-		modFlag = matches[1]
-	}
-	// Don't override an explicit '-mod=' argument.
-	if modFlag == "vendor" {
-		return true, mainMod, nil
-	} else if modFlag != "" {
-		return false, nil, nil
-	}
-	if mainMod == nil || !go114 {
-		return false, nil, nil
-	}
-	// Check 1.14's automatic vendor mode.
-	if fi, err := os.Stat(filepath.Join(mainMod.Dir, "vendor")); err == nil && fi.IsDir() {
-		if mainMod.GoVersion != "" && semver.Compare("v"+mainMod.GoVersion, "v1.14") >= 0 {
-			// The Go version is at least 1.14, and a vendor directory exists.
-			// Set -mod=vendor by default.
-			return true, mainMod, nil
-		}
-	}
-	return false, nil, nil
-}
-
-// getMainModuleAnd114 gets one of the main modules' information and whether the
-// go command in use is 1.14+. This is the information needed to figure out
-// if vendoring should be enabled.
-func getMainModuleAnd114(ctx context.Context, inv Invocation, r *Runner) (*ModuleJSON, bool, error) {
-	const format = `{{.Path}}
-{{.Dir}}
-{{.GoMod}}
-{{.GoVersion}}
-{{range context.ReleaseTags}}{{if eq . "go1.14"}}{{.}}{{end}}{{end}}
-`
-	inv.Verb = "list"
-	inv.Args = []string{"-m", "-f", format}
-	stdout, err := r.Run(ctx, inv)
-	if err != nil {
-		return nil, false, err
-	}
-
-	lines := strings.Split(stdout.String(), "\n")
-	if len(lines) < 5 {
-		return nil, false, fmt.Errorf("unexpected stdout: %q", stdout.String())
-	}
-	mod := &ModuleJSON{
-		Path:      lines[0],
-		Dir:       lines[1],
-		GoMod:     lines[2],
-		GoVersion: lines[3],
-		Main:      true,
-	}
-	return mod, lines[4] == "go1.14", nil
-}
-
-// WorkspaceVendorEnabled reports whether workspace vendoring is enabled. It takes a *Runner to execute Go commands
-// with the supplied context.Context and Invocation. The Invocation can contain pre-defined fields,
-// of which only Verb and Args are modified to run the appropriate Go command.
-// Inspired by setDefaultBuildMod in modload/init.go
-func WorkspaceVendorEnabled(ctx context.Context, inv Invocation, r *Runner) (bool, []*ModuleJSON, error) {
-	inv.Verb = "env"
-	inv.Args = []string{"GOWORK"}
-	stdout, err := r.Run(ctx, inv)
-	if err != nil {
-		return false, nil, err
-	}
-	goWork := string(bytes.TrimSpace(stdout.Bytes()))
-	if fi, err := os.Stat(filepath.Join(filepath.Dir(goWork), "vendor")); err == nil && fi.IsDir() {
-		mainMods, err := getWorkspaceMainModules(ctx, inv, r)
-		if err != nil {
-			return false, nil, err
-		}
-		return true, mainMods, nil
-	}
-	return false, nil, nil
-}
-
-// getWorkspaceMainModules gets the main modules' information.
-// This is the information needed to figure out if vendoring should be enabled.
-func getWorkspaceMainModules(ctx context.Context, inv Invocation, r *Runner) ([]*ModuleJSON, error) {
-	const format = `{{.Path}}
-{{.Dir}}
-{{.GoMod}}
-{{.GoVersion}}
-`
-	inv.Verb = "list"
-	inv.Args = []string{"-m", "-f", format}
-	stdout, err := r.Run(ctx, inv)
-	if err != nil {
-		return nil, err
-	}
-
-	lines := strings.Split(strings.TrimSuffix(stdout.String(), "\n"), "\n")
-	if len(lines) < 4 {
-		return nil, fmt.Errorf("unexpected stdout: %q", stdout.String())
-	}
-	mods := make([]*ModuleJSON, 0, len(lines)/4)
-	for i := 0; i < len(lines); i += 4 {
-		mods = append(mods, &ModuleJSON{
-			Path:      lines[i],
-			Dir:       lines[i+1],
-			GoMod:     lines[i+2],
-			GoVersion: lines[i+3],
-			Main:      true,
-		})
-	}
-	return mods, nil
-}
diff --git a/vendor/golang.org/x/tools/internal/gocommand/version.go b/vendor/golang.org/x/tools/internal/gocommand/version.go
deleted file mode 100644
index d82f13a7e6..0000000000
--- a/vendor/golang.org/x/tools/internal/gocommand/version.go
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gocommand
-
-import (
-	"context"
-	"fmt"
-	"regexp"
-	"slices"
-	"strings"
-)
-
-// GoVersion reports the minor version number of the highest release
-// tag built into the go command on the PATH.
-//
-// Note that this may be higher than the version of the go tool used
-// to build this application, and thus the versions of the standard
-// go/{scanner,parser,ast,types} packages that are linked into it.
-// In that case, callers should either downgrade to the version of
-// go used to build the application, or report an error that the
-// application is too old to use the go command on the PATH.
-func GoVersion(ctx context.Context, inv Invocation, r *Runner) (int, error) {
-	inv.Verb = "list"
-	inv.Args = []string{"-e", "-f", `{{context.ReleaseTags}}`, `--`, `unsafe`}
-	inv.BuildFlags = nil // This is not a build command.
-	inv.ModFlag = ""
-	inv.ModFile = ""
-	// Set GO111MODULE=off so that we are immune to errors in go.{work,mod}.
-	// Unfortunately, this breaks the Go 1.21+ toolchain directive and
-	// may affect the set of ReleaseTags; see #68495.
-	inv.Env = append(inv.Env[:len(inv.Env):len(inv.Env)], "GO111MODULE=off")
-
-	stdoutBytes, err := r.Run(ctx, inv)
-	if err != nil {
-		return 0, err
-	}
-	stdout := stdoutBytes.String()
-	if len(stdout) < 3 {
-		return 0, fmt.Errorf("bad ReleaseTags output: %q", stdout)
-	}
-	// Split up "[go1.1 go1.15]" and return highest go1.X value.
-	tags := strings.Fields(stdout[1 : len(stdout)-2])
-	for _, tag := range slices.Backward(tags) {
-		var version int
-		if _, err := fmt.Sscanf(tag, "go1.%d", &version); err != nil {
-			continue
-		}
-		return version, nil
-	}
-	return 0, fmt.Errorf("no parseable ReleaseTags in %v", tags)
-}
-
-// GoVersionOutput returns the complete output of the go version command.
-func GoVersionOutput(ctx context.Context, inv Invocation, r *Runner) (string, error) {
-	inv.Verb = "version"
-	goVersion, err := r.Run(ctx, inv)
-	if err != nil {
-		return "", err
-	}
-	return goVersion.String(), nil
-}
-
-// ParseGoVersionOutput extracts the Go version string
-// from the output of the "go version" command.
-// Given an unrecognized form, it returns an empty string.
-func ParseGoVersionOutput(data string) string {
-	re := regexp.MustCompile(`^go version (go\S+|devel \S+)`)
-	m := re.FindStringSubmatch(data)
-	if len(m) != 2 {
-		return "" // unrecognized version
-	}
-	return m[1]
-}
diff --git a/vendor/golang.org/x/tools/internal/packagesinternal/packages.go b/vendor/golang.org/x/tools/internal/packagesinternal/packages.go
deleted file mode 100644
index 929b470beb..0000000000
--- a/vendor/golang.org/x/tools/internal/packagesinternal/packages.go
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package packagesinternal exposes internal-only fields from go/packages.
-package packagesinternal
-
-import "fmt"
-
-var GetDepsErrors = func(p any) []*PackageError { return nil }
-
-type PackageError struct {
-	ImportStack []string // shortest path from package named on command line to this one
-	Pos         string   // position of error (if present, file:line:col)
-	Err         string   // the error itself
-}
-
-func (err PackageError) String() string {
-	return fmt.Sprintf("%s: %s (import stack: %s)", err.Pos, err.Err, err.ImportStack)
-}
-
-var TypecheckCgo int
-var DepsErrors int // must be set as a LoadMode to call GetDepsErrors
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/codes.go b/vendor/golang.org/x/tools/internal/pkgbits/codes.go
deleted file mode 100644
index f0cabde96e..0000000000
--- a/vendor/golang.org/x/tools/internal/pkgbits/codes.go
+++ /dev/null
@@ -1,77 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pkgbits
-
-// A Code is an enum value that can be encoded into bitstreams.
-//
-// Code types are preferable for enum types, because they allow
-// Decoder to detect desyncs.
-type Code interface {
-	// Marker returns the SyncMarker for the Code's dynamic type.
-	Marker() SyncMarker
-
-	// Value returns the Code's ordinal value.
-	Value() int
-}
-
-// A CodeVal distinguishes among go/constant.Value encodings.
-type CodeVal int
-
-func (c CodeVal) Marker() SyncMarker { return SyncVal }
-func (c CodeVal) Value() int         { return int(c) }
-
-// Note: These values are public and cannot be changed without
-// updating the go/types importers.
-
-const (
-	ValBool CodeVal = iota
-	ValString
-	ValInt64
-	ValBigInt
-	ValBigRat
-	ValBigFloat
-)
-
-// A CodeType distinguishes among go/types.Type encodings.
-type CodeType int
-
-func (c CodeType) Marker() SyncMarker { return SyncType }
-func (c CodeType) Value() int         { return int(c) }
-
-// Note: These values are public and cannot be changed without
-// updating the go/types importers.
-
-const (
-	TypeBasic CodeType = iota
-	TypeNamed
-	TypePointer
-	TypeSlice
-	TypeArray
-	TypeChan
-	TypeMap
-	TypeSignature
-	TypeStruct
-	TypeInterface
-	TypeUnion
-	TypeTypeParam
-)
-
-// A CodeObj distinguishes among go/types.Object encodings.
-type CodeObj int
-
-func (c CodeObj) Marker() SyncMarker { return SyncCodeObj }
-func (c CodeObj) Value() int         { return int(c) }
-
-// Note: These values are public and cannot be changed without
-// updating the go/types importers.
-
-const (
-	ObjAlias CodeObj = iota
-	ObjConst
-	ObjType
-	ObjFunc
-	ObjVar
-	ObjStub
-)
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/decoder.go b/vendor/golang.org/x/tools/internal/pkgbits/decoder.go
deleted file mode 100644
index c0aba26c48..0000000000
--- a/vendor/golang.org/x/tools/internal/pkgbits/decoder.go
+++ /dev/null
@@ -1,519 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pkgbits
-
-import (
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"go/constant"
-	"go/token"
-	"io"
-	"math/big"
-	"os"
-	"runtime"
-	"strings"
-)
-
-// A PkgDecoder provides methods for decoding a package's Unified IR
-// export data.
-type PkgDecoder struct {
-	// version is the file format version.
-	version Version
-
-	// sync indicates whether the file uses sync markers.
-	sync bool
-
-	// pkgPath is the package path for the package to be decoded.
-	//
-	// TODO(mdempsky): Remove; unneeded since CL 391014.
-	pkgPath string
-
-	// elemData is the full data payload of the encoded package.
-	// Elements are densely and contiguously packed together.
-	//
-	// The last 8 bytes of elemData are the package fingerprint.
-	elemData string
-
-	// elemEnds stores the byte-offset end positions of element
-	// bitstreams within elemData.
-	//
-	// For example, element I's bitstream data starts at elemEnds[I-1]
-	// (or 0, if I==0) and ends at elemEnds[I].
-	//
-	// Note: elemEnds is indexed by absolute indices, not
-	// section-relative indices.
-	elemEnds []uint32
-
-	// elemEndsEnds stores the index-offset end positions of relocation
-	// sections within elemEnds.
-	//
-	// For example, section K's end positions start at elemEndsEnds[K-1]
-	// (or 0, if K==0) and end at elemEndsEnds[K].
-	elemEndsEnds [numRelocs]uint32
-
-	scratchRelocEnt []RelocEnt
-}
-
-// PkgPath returns the package path for the package
-//
-// TODO(mdempsky): Remove; unneeded since CL 391014.
-func (pr *PkgDecoder) PkgPath() string { return pr.pkgPath }
-
-// SyncMarkers reports whether pr uses sync markers.
-func (pr *PkgDecoder) SyncMarkers() bool { return pr.sync }
-
-// NewPkgDecoder returns a PkgDecoder initialized to read the Unified
-// IR export data from input. pkgPath is the package path for the
-// compilation unit that produced the export data.
-func NewPkgDecoder(pkgPath, input string) PkgDecoder {
-	pr := PkgDecoder{
-		pkgPath: pkgPath,
-	}
-
-	// TODO(mdempsky): Implement direct indexing of input string to
-	// avoid copying the position information.
-
-	r := strings.NewReader(input)
-
-	var ver uint32
-	assert(binary.Read(r, binary.LittleEndian, &ver) == nil)
-	pr.version = Version(ver)
-
-	if pr.version >= numVersions {
-		panic(fmt.Errorf("cannot decode %q, export data version %d is greater than maximum supported version %d", pkgPath, pr.version, numVersions-1))
-	}
-
-	if pr.version.Has(Flags) {
-		var flags uint32
-		assert(binary.Read(r, binary.LittleEndian, &flags) == nil)
-		pr.sync = flags&flagSyncMarkers != 0
-	}
-
-	assert(binary.Read(r, binary.LittleEndian, pr.elemEndsEnds[:]) == nil)
-
-	pr.elemEnds = make([]uint32, pr.elemEndsEnds[len(pr.elemEndsEnds)-1])
-	assert(binary.Read(r, binary.LittleEndian, pr.elemEnds[:]) == nil)
-
-	pos, err := r.Seek(0, io.SeekCurrent)
-	assert(err == nil)
-
-	pr.elemData = input[pos:]
-
-	const fingerprintSize = 8
-	assert(len(pr.elemData)-fingerprintSize == int(pr.elemEnds[len(pr.elemEnds)-1]))
-
-	return pr
-}
-
-// NumElems returns the number of elements in section k.
-func (pr *PkgDecoder) NumElems(k RelocKind) int {
-	count := int(pr.elemEndsEnds[k])
-	if k > 0 {
-		count -= int(pr.elemEndsEnds[k-1])
-	}
-	return count
-}
-
-// TotalElems returns the total number of elements across all sections.
-func (pr *PkgDecoder) TotalElems() int {
-	return len(pr.elemEnds)
-}
-
-// Fingerprint returns the package fingerprint.
-func (pr *PkgDecoder) Fingerprint() [8]byte {
-	var fp [8]byte
-	copy(fp[:], pr.elemData[len(pr.elemData)-8:])
-	return fp
-}
-
-// AbsIdx returns the absolute index for the given (section, index)
-// pair.
-func (pr *PkgDecoder) AbsIdx(k RelocKind, idx Index) int {
-	absIdx := int(idx)
-	if k > 0 {
-		absIdx += int(pr.elemEndsEnds[k-1])
-	}
-	if absIdx >= int(pr.elemEndsEnds[k]) {
-		panicf("%v:%v is out of bounds; %v", k, idx, pr.elemEndsEnds)
-	}
-	return absIdx
-}
-
-// DataIdx returns the raw element bitstream for the given (section,
-// index) pair.
-func (pr *PkgDecoder) DataIdx(k RelocKind, idx Index) string {
-	absIdx := pr.AbsIdx(k, idx)
-
-	var start uint32
-	if absIdx > 0 {
-		start = pr.elemEnds[absIdx-1]
-	}
-	end := pr.elemEnds[absIdx]
-
-	return pr.elemData[start:end]
-}
-
-// StringIdx returns the string value for the given string index.
-func (pr *PkgDecoder) StringIdx(idx Index) string {
-	return pr.DataIdx(RelocString, idx)
-}
-
-// NewDecoder returns a Decoder for the given (section, index) pair,
-// and decodes the given SyncMarker from the element bitstream.
-func (pr *PkgDecoder) NewDecoder(k RelocKind, idx Index, marker SyncMarker) Decoder {
-	r := pr.NewDecoderRaw(k, idx)
-	r.Sync(marker)
-	return r
-}
-
-// TempDecoder returns a Decoder for the given (section, index) pair,
-// and decodes the given SyncMarker from the element bitstream.
-// If possible the Decoder should be RetireDecoder'd when it is no longer
-// needed, this will avoid heap allocations.
-func (pr *PkgDecoder) TempDecoder(k RelocKind, idx Index, marker SyncMarker) Decoder {
-	r := pr.TempDecoderRaw(k, idx)
-	r.Sync(marker)
-	return r
-}
-
-func (pr *PkgDecoder) RetireDecoder(d *Decoder) {
-	pr.scratchRelocEnt = d.Relocs
-	d.Relocs = nil
-}
-
-// NewDecoderRaw returns a Decoder for the given (section, index) pair.
-//
-// Most callers should use NewDecoder instead.
-func (pr *PkgDecoder) NewDecoderRaw(k RelocKind, idx Index) Decoder {
-	r := Decoder{
-		common: pr,
-		k:      k,
-		Idx:    idx,
-	}
-
-	r.Data.Reset(pr.DataIdx(k, idx))
-	r.Sync(SyncRelocs)
-	r.Relocs = make([]RelocEnt, r.Len())
-	for i := range r.Relocs {
-		r.Sync(SyncReloc)
-		r.Relocs[i] = RelocEnt{RelocKind(r.Len()), Index(r.Len())}
-	}
-
-	return r
-}
-
-func (pr *PkgDecoder) TempDecoderRaw(k RelocKind, idx Index) Decoder {
-	r := Decoder{
-		common: pr,
-		k:      k,
-		Idx:    idx,
-	}
-
-	r.Data.Reset(pr.DataIdx(k, idx))
-	r.Sync(SyncRelocs)
-	l := r.Len()
-	if cap(pr.scratchRelocEnt) >= l {
-		r.Relocs = pr.scratchRelocEnt[:l]
-		pr.scratchRelocEnt = nil
-	} else {
-		r.Relocs = make([]RelocEnt, l)
-	}
-	for i := range r.Relocs {
-		r.Sync(SyncReloc)
-		r.Relocs[i] = RelocEnt{RelocKind(r.Len()), Index(r.Len())}
-	}
-
-	return r
-}
-
-// A Decoder provides methods for decoding an individual element's
-// bitstream data.
-type Decoder struct {
-	common *PkgDecoder
-
-	Relocs []RelocEnt
-	Data   strings.Reader
-
-	k   RelocKind
-	Idx Index
-}
-
-func (r *Decoder) checkErr(err error) {
-	if err != nil {
-		panicf("unexpected decoding error: %w", err)
-	}
-}
-
-func (r *Decoder) rawUvarint() uint64 {
-	x, err := readUvarint(&r.Data)
-	r.checkErr(err)
-	return x
-}
-
-// readUvarint is a type-specialized copy of encoding/binary.ReadUvarint.
-// This avoids the interface conversion and thus has better escape properties,
-// which flows up the stack.
-func readUvarint(r *strings.Reader) (uint64, error) {
-	var x uint64
-	var s uint
-	for i := range binary.MaxVarintLen64 {
-		b, err := r.ReadByte()
-		if err != nil {
-			if i > 0 && err == io.EOF {
-				err = io.ErrUnexpectedEOF
-			}
-			return x, err
-		}
-		if b < 0x80 {
-			if i == binary.MaxVarintLen64-1 && b > 1 {
-				return x, overflow
-			}
-			return x | uint64(b)<<s, nil
-		}
-		x |= uint64(b&0x7f) << s
-		s += 7
-	}
-	return x, overflow
-}
-
-var overflow = errors.New("pkgbits: readUvarint overflows a 64-bit integer")
-
-func (r *Decoder) rawVarint() int64 {
-	ux := r.rawUvarint()
-
-	// Zig-zag decode.
-	x := int64(ux >> 1)
-	if ux&1 != 0 {
-		x = ^x
-	}
-	return x
-}
-
-func (r *Decoder) rawReloc(k RelocKind, idx int) Index {
-	e := r.Relocs[idx]
-	assert(e.Kind == k)
-	return e.Idx
-}
-
-// Sync decodes a sync marker from the element bitstream and asserts
-// that it matches the expected marker.
-//
-// If r.common.sync is false, then Sync is a no-op.
-func (r *Decoder) Sync(mWant SyncMarker) {
-	if !r.common.sync {
-		return
-	}
-
-	pos, _ := r.Data.Seek(0, io.SeekCurrent)
-	mHave := SyncMarker(r.rawUvarint())
-	writerPCs := make([]int, r.rawUvarint())
-	for i := range writerPCs {
-		writerPCs[i] = int(r.rawUvarint())
-	}
-
-	if mHave == mWant {
-		return
-	}
-
-	// There's some tension here between printing:
-	//
-	// (1) full file paths that tools can recognize (e.g., so emacs
-	//     hyperlinks the "file:line" text for easy navigation), or
-	//
-	// (2) short file paths that are easier for humans to read (e.g., by
-	//     omitting redundant or irrelevant details, so it's easier to
-	//     focus on the useful bits that remain).
-	//
-	// The current formatting favors the former, as it seems more
-	// helpful in practice. But perhaps the formatting could be improved
-	// to better address both concerns. For example, use relative file
-	// paths if they would be shorter, or rewrite file paths to contain
-	// "$GOROOT" (like objabi.AbsFile does) if tools can be taught how
-	// to reliably expand that again.
-
-	fmt.Printf("export data desync: package %q, section %v, index %v, offset %v\n", r.common.pkgPath, r.k, r.Idx, pos)
-
-	fmt.Printf("\nfound %v, written at:\n", mHave)
-	if len(writerPCs) == 0 {
-		fmt.Printf("\t[stack trace unavailable; recompile package %q with -d=syncframes]\n", r.common.pkgPath)
-	}
-	for _, pc := range writerPCs {
-		fmt.Printf("\t%s\n", r.common.StringIdx(r.rawReloc(RelocString, pc)))
-	}
-
-	fmt.Printf("\nexpected %v, reading at:\n", mWant)
-	var readerPCs [32]uintptr // TODO(mdempsky): Dynamically size?
-	n := runtime.Callers(2, readerPCs[:])
-	for _, pc := range fmtFrames(readerPCs[:n]...) {
-		fmt.Printf("\t%s\n", pc)
-	}
-
-	// We already printed a stack trace for the reader, so now we can
-	// simply exit. Printing a second one with panic or base.Fatalf
-	// would just be noise.
-	os.Exit(1)
-}
-
-// Bool decodes and returns a bool value from the element bitstream.
-func (r *Decoder) Bool() bool {
-	r.Sync(SyncBool)
-	x, err := r.Data.ReadByte()
-	r.checkErr(err)
-	assert(x < 2)
-	return x != 0
-}
-
-// Int64 decodes and returns an int64 value from the element bitstream.
-func (r *Decoder) Int64() int64 {
-	r.Sync(SyncInt64)
-	return r.rawVarint()
-}
-
-// Uint64 decodes and returns a uint64 value from the element bitstream.
-func (r *Decoder) Uint64() uint64 {
-	r.Sync(SyncUint64)
-	return r.rawUvarint()
-}
-
-// Len decodes and returns a non-negative int value from the element bitstream.
-func (r *Decoder) Len() int { x := r.Uint64(); v := int(x); assert(uint64(v) == x); return v }
-
-// Int decodes and returns an int value from the element bitstream.
-func (r *Decoder) Int() int { x := r.Int64(); v := int(x); assert(int64(v) == x); return v }
-
-// Uint decodes and returns a uint value from the element bitstream.
-func (r *Decoder) Uint() uint { x := r.Uint64(); v := uint(x); assert(uint64(v) == x); return v }
-
-// Code decodes a Code value from the element bitstream and returns
-// its ordinal value. It's the caller's responsibility to convert the
-// result to an appropriate Code type.
-//
-// TODO(mdempsky): Ideally this method would have signature "Code[T
-// Code] T" instead, but we don't allow generic methods and the
-// compiler can't depend on generics yet anyway.
-func (r *Decoder) Code(mark SyncMarker) int {
-	r.Sync(mark)
-	return r.Len()
-}
-
-// Reloc decodes a relocation of expected section k from the element
-// bitstream and returns an index to the referenced element.
-func (r *Decoder) Reloc(k RelocKind) Index {
-	r.Sync(SyncUseReloc)
-	return r.rawReloc(k, r.Len())
-}
-
-// String decodes and returns a string value from the element
-// bitstream.
-func (r *Decoder) String() string {
-	r.Sync(SyncString)
-	return r.common.StringIdx(r.Reloc(RelocString))
-}
-
-// Strings decodes and returns a variable-length slice of strings from
-// the element bitstream.
-func (r *Decoder) Strings() []string {
-	res := make([]string, r.Len())
-	for i := range res {
-		res[i] = r.String()
-	}
-	return res
-}
-
-// Value decodes and returns a constant.Value from the element
-// bitstream.
-func (r *Decoder) Value() constant.Value {
-	r.Sync(SyncValue)
-	isComplex := r.Bool()
-	val := r.scalar()
-	if isComplex {
-		val = constant.BinaryOp(val, token.ADD, constant.MakeImag(r.scalar()))
-	}
-	return val
-}
-
-func (r *Decoder) scalar() constant.Value {
-	switch tag := CodeVal(r.Code(SyncVal)); tag {
-	default:
-		panic(fmt.Errorf("unexpected scalar tag: %v", tag))
-
-	case ValBool:
-		return constant.MakeBool(r.Bool())
-	case ValString:
-		return constant.MakeString(r.String())
-	case ValInt64:
-		return constant.MakeInt64(r.Int64())
-	case ValBigInt:
-		return constant.Make(r.bigInt())
-	case ValBigRat:
-		num := r.bigInt()
-		denom := r.bigInt()
-		return constant.Make(new(big.Rat).SetFrac(num, denom))
-	case ValBigFloat:
-		return constant.Make(r.bigFloat())
-	}
-}
-
-func (r *Decoder) bigInt() *big.Int {
-	v := new(big.Int).SetBytes([]byte(r.String()))
-	if r.Bool() {
-		v.Neg(v)
-	}
-	return v
-}
-
-func (r *Decoder) bigFloat() *big.Float {
-	v := new(big.Float).SetPrec(512)
-	assert(v.UnmarshalText([]byte(r.String())) == nil)
-	return v
-}
-
-// @@@ Helpers
-
-// TODO(mdempsky): These should probably be removed. I think they're a
-// smell that the export data format is not yet quite right.
-
-// PeekPkgPath returns the package path for the specified package
-// index.
-func (pr *PkgDecoder) PeekPkgPath(idx Index) string {
-	var path string
-	{
-		r := pr.TempDecoder(RelocPkg, idx, SyncPkgDef)
-		path = r.String()
-		pr.RetireDecoder(&r)
-	}
-	if path == "" {
-		path = pr.pkgPath
-	}
-	return path
-}
-
-// PeekObj returns the package path, object name, and CodeObj for the
-// specified object index.
-func (pr *PkgDecoder) PeekObj(idx Index) (string, string, CodeObj) {
-	var ridx Index
-	var name string
-	var rcode int
-	{
-		r := pr.TempDecoder(RelocName, idx, SyncObject1)
-		r.Sync(SyncSym)
-		r.Sync(SyncPkg)
-		ridx = r.Reloc(RelocPkg)
-		name = r.String()
-		rcode = r.Code(SyncCodeObj)
-		pr.RetireDecoder(&r)
-	}
-
-	path := pr.PeekPkgPath(ridx)
-	assert(name != "")
-
-	tag := CodeObj(rcode)
-
-	return path, name, tag
-}
-
-// Version reports the version of the bitstream.
-func (w *Decoder) Version() Version { return w.common.version }
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/doc.go b/vendor/golang.org/x/tools/internal/pkgbits/doc.go
deleted file mode 100644
index c8a2796b5e..0000000000
--- a/vendor/golang.org/x/tools/internal/pkgbits/doc.go
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright 2022 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package pkgbits implements low-level coding abstractions for
-// Unified IR's export data format.
-//
-// At a low-level, a package is a collection of bitstream elements.
-// Each element has a "kind" and a dense, non-negative index.
-// Elements can be randomly accessed given their kind and index.
-//
-// Individual elements are sequences of variable-length values (e.g.,
-// integers, booleans, strings, go/constant values, cross-references
-// to other elements). Package pkgbits provides APIs for encoding and
-// decoding these low-level values, but the details of mapping
-// higher-level Go constructs into elements is left to higher-level
-// abstractions.
-//
-// Elements may cross-reference each other with "relocations." For
-// example, an element representing a pointer type has a relocation
-// referring to the element type.
-//
-// Go constructs may be composed as a constellation of multiple
-// elements. For example, a declared function may have one element to
-// describe the object (e.g., its name, type, position), and a
-// separate element to describe its function body. This allows readers
-// some flexibility in efficiently seeking or re-reading data (e.g.,
-// inlining requires re-reading the function body for each inlined
-// call, without needing to re-read the object-level details).
-//
-// This is a copy of internal/pkgbits in the Go implementation.
-package pkgbits
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/encoder.go b/vendor/golang.org/x/tools/internal/pkgbits/encoder.go
deleted file mode 100644
index c17a12399d..0000000000
--- a/vendor/golang.org/x/tools/internal/pkgbits/encoder.go
+++ /dev/null
@@ -1,392 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pkgbits
-
-import (
-	"bytes"
-	"crypto/md5"
-	"encoding/binary"
-	"go/constant"
-	"io"
-	"math/big"
-	"runtime"
-	"strings"
-)
-
-// A PkgEncoder provides methods for encoding a package's Unified IR
-// export data.
-type PkgEncoder struct {
-	// version of the bitstream.
-	version Version
-
-	// elems holds the bitstream for previously encoded elements.
-	elems [numRelocs][]string
-
-	// stringsIdx maps previously encoded strings to their index within
-	// the RelocString section, to allow deduplication. That is,
-	// elems[RelocString][stringsIdx[s]] == s (if present).
-	stringsIdx map[string]Index
-
-	// syncFrames is the number of frames to write at each sync
-	// marker. A negative value means sync markers are omitted.
-	syncFrames int
-}
-
-// SyncMarkers reports whether pw uses sync markers.
-func (pw *PkgEncoder) SyncMarkers() bool { return pw.syncFrames >= 0 }
-
-// NewPkgEncoder returns an initialized PkgEncoder.
-//
-// syncFrames is the number of caller frames that should be serialized
-// at Sync points. Serializing additional frames results in larger
-// export data files, but can help diagnosing desync errors in
-// higher-level Unified IR reader/writer code. If syncFrames is
-// negative, then sync markers are omitted entirely.
-func NewPkgEncoder(version Version, syncFrames int) PkgEncoder {
-	return PkgEncoder{
-		version:    version,
-		stringsIdx: make(map[string]Index),
-		syncFrames: syncFrames,
-	}
-}
-
-// DumpTo writes the package's encoded data to out0 and returns the
-// package fingerprint.
-func (pw *PkgEncoder) DumpTo(out0 io.Writer) (fingerprint [8]byte) {
-	h := md5.New()
-	out := io.MultiWriter(out0, h)
-
-	writeUint32 := func(x uint32) {
-		assert(binary.Write(out, binary.LittleEndian, x) == nil)
-	}
-
-	writeUint32(uint32(pw.version))
-
-	if pw.version.Has(Flags) {
-		var flags uint32
-		if pw.SyncMarkers() {
-			flags |= flagSyncMarkers
-		}
-		writeUint32(flags)
-	}
-
-	// Write elemEndsEnds.
-	var sum uint32
-	for _, elems := range &pw.elems {
-		sum += uint32(len(elems))
-		writeUint32(sum)
-	}
-
-	// Write elemEnds.
-	sum = 0
-	for _, elems := range &pw.elems {
-		for _, elem := range elems {
-			sum += uint32(len(elem))
-			writeUint32(sum)
-		}
-	}
-
-	// Write elemData.
-	for _, elems := range &pw.elems {
-		for _, elem := range elems {
-			_, err := io.WriteString(out, elem)
-			assert(err == nil)
-		}
-	}
-
-	// Write fingerprint.
-	copy(fingerprint[:], h.Sum(nil))
-	_, err := out0.Write(fingerprint[:])
-	assert(err == nil)
-
-	return
-}
-
-// StringIdx adds a string value to the strings section, if not
-// already present, and returns its index.
-func (pw *PkgEncoder) StringIdx(s string) Index {
-	if idx, ok := pw.stringsIdx[s]; ok {
-		assert(pw.elems[RelocString][idx] == s)
-		return idx
-	}
-
-	idx := Index(len(pw.elems[RelocString]))
-	pw.elems[RelocString] = append(pw.elems[RelocString], s)
-	pw.stringsIdx[s] = idx
-	return idx
-}
-
-// NewEncoder returns an Encoder for a new element within the given
-// section, and encodes the given SyncMarker as the start of the
-// element bitstream.
-func (pw *PkgEncoder) NewEncoder(k RelocKind, marker SyncMarker) Encoder {
-	e := pw.NewEncoderRaw(k)
-	e.Sync(marker)
-	return e
-}
-
-// NewEncoderRaw returns an Encoder for a new element within the given
-// section.
-//
-// Most callers should use NewEncoder instead.
-func (pw *PkgEncoder) NewEncoderRaw(k RelocKind) Encoder {
-	idx := Index(len(pw.elems[k]))
-	pw.elems[k] = append(pw.elems[k], "") // placeholder
-
-	return Encoder{
-		p:   pw,
-		k:   k,
-		Idx: idx,
-	}
-}
-
-// An Encoder provides methods for encoding an individual element's
-// bitstream data.
-type Encoder struct {
-	p *PkgEncoder
-
-	Relocs   []RelocEnt
-	RelocMap map[RelocEnt]uint32
-	Data     bytes.Buffer // accumulated element bitstream data
-
-	encodingRelocHeader bool
-
-	k   RelocKind
-	Idx Index // index within relocation section
-}
-
-// Flush finalizes the element's bitstream and returns its Index.
-func (w *Encoder) Flush() Index {
-	var sb strings.Builder
-
-	// Backup the data so we write the relocations at the front.
-	var tmp bytes.Buffer
-	io.Copy(&tmp, &w.Data)
-
-	// TODO(mdempsky): Consider writing these out separately so they're
-	// easier to strip, along with function bodies, so that we can prune
-	// down to just the data that's relevant to go/types.
-	if w.encodingRelocHeader {
-		panic("encodingRelocHeader already true; recursive flush?")
-	}
-	w.encodingRelocHeader = true
-	w.Sync(SyncRelocs)
-	w.Len(len(w.Relocs))
-	for _, rEnt := range w.Relocs {
-		w.Sync(SyncReloc)
-		w.Len(int(rEnt.Kind))
-		w.Len(int(rEnt.Idx))
-	}
-
-	io.Copy(&sb, &w.Data)
-	io.Copy(&sb, &tmp)
-	w.p.elems[w.k][w.Idx] = sb.String()
-
-	return w.Idx
-}
-
-func (w *Encoder) checkErr(err error) {
-	if err != nil {
-		panicf("unexpected encoding error: %v", err)
-	}
-}
-
-func (w *Encoder) rawUvarint(x uint64) {
-	var buf [binary.MaxVarintLen64]byte
-	n := binary.PutUvarint(buf[:], x)
-	_, err := w.Data.Write(buf[:n])
-	w.checkErr(err)
-}
-
-func (w *Encoder) rawVarint(x int64) {
-	// Zig-zag encode.
-	ux := uint64(x) << 1
-	if x < 0 {
-		ux = ^ux
-	}
-
-	w.rawUvarint(ux)
-}
-
-func (w *Encoder) rawReloc(r RelocKind, idx Index) int {
-	e := RelocEnt{r, idx}
-	if w.RelocMap != nil {
-		if i, ok := w.RelocMap[e]; ok {
-			return int(i)
-		}
-	} else {
-		w.RelocMap = make(map[RelocEnt]uint32)
-	}
-
-	i := len(w.Relocs)
-	w.RelocMap[e] = uint32(i)
-	w.Relocs = append(w.Relocs, e)
-	return i
-}
-
-func (w *Encoder) Sync(m SyncMarker) {
-	if !w.p.SyncMarkers() {
-		return
-	}
-
-	// Writing out stack frame string references requires working
-	// relocations, but writing out the relocations themselves involves
-	// sync markers. To prevent infinite recursion, we simply trim the
-	// stack frame for sync markers within the relocation header.
-	var frames []string
-	if !w.encodingRelocHeader && w.p.syncFrames > 0 {
-		pcs := make([]uintptr, w.p.syncFrames)
-		n := runtime.Callers(2, pcs)
-		frames = fmtFrames(pcs[:n]...)
-	}
-
-	// TODO(mdempsky): Save space by writing out stack frames as a
-	// linked list so we can share common stack frames.
-	w.rawUvarint(uint64(m))
-	w.rawUvarint(uint64(len(frames)))
-	for _, frame := range frames {
-		w.rawUvarint(uint64(w.rawReloc(RelocString, w.p.StringIdx(frame))))
-	}
-}
-
-// Bool encodes and writes a bool value into the element bitstream,
-// and then returns the bool value.
-//
-// For simple, 2-alternative encodings, the idiomatic way to call Bool
-// is something like:
-//
-//	if w.Bool(x != 0) {
-//		// alternative #1
-//	} else {
-//		// alternative #2
-//	}
-//
-// For multi-alternative encodings, use Code instead.
-func (w *Encoder) Bool(b bool) bool {
-	w.Sync(SyncBool)
-	var x byte
-	if b {
-		x = 1
-	}
-	err := w.Data.WriteByte(x)
-	w.checkErr(err)
-	return b
-}
-
-// Int64 encodes and writes an int64 value into the element bitstream.
-func (w *Encoder) Int64(x int64) {
-	w.Sync(SyncInt64)
-	w.rawVarint(x)
-}
-
-// Uint64 encodes and writes a uint64 value into the element bitstream.
-func (w *Encoder) Uint64(x uint64) {
-	w.Sync(SyncUint64)
-	w.rawUvarint(x)
-}
-
-// Len encodes and writes a non-negative int value into the element bitstream.
-func (w *Encoder) Len(x int) { assert(x >= 0); w.Uint64(uint64(x)) }
-
-// Int encodes and writes an int value into the element bitstream.
-func (w *Encoder) Int(x int) { w.Int64(int64(x)) }
-
-// Uint encodes and writes a uint value into the element bitstream.
-func (w *Encoder) Uint(x uint) { w.Uint64(uint64(x)) }
-
-// Reloc encodes and writes a relocation for the given (section,
-// index) pair into the element bitstream.
-//
-// Note: Only the index is formally written into the element
-// bitstream, so bitstream decoders must know from context which
-// section an encoded relocation refers to.
-func (w *Encoder) Reloc(r RelocKind, idx Index) {
-	w.Sync(SyncUseReloc)
-	w.Len(w.rawReloc(r, idx))
-}
-
-// Code encodes and writes a Code value into the element bitstream.
-func (w *Encoder) Code(c Code) {
-	w.Sync(c.Marker())
-	w.Len(c.Value())
-}
-
-// String encodes and writes a string value into the element
-// bitstream.
-//
-// Internally, strings are deduplicated by adding them to the strings
-// section (if not already present), and then writing a relocation
-// into the element bitstream.
-func (w *Encoder) String(s string) {
-	w.StringRef(w.p.StringIdx(s))
-}
-
-// StringRef writes a reference to the given index, which must be a
-// previously encoded string value.
-func (w *Encoder) StringRef(idx Index) {
-	w.Sync(SyncString)
-	w.Reloc(RelocString, idx)
-}
-
-// Strings encodes and writes a variable-length slice of strings into
-// the element bitstream.
-func (w *Encoder) Strings(ss []string) {
-	w.Len(len(ss))
-	for _, s := range ss {
-		w.String(s)
-	}
-}
-
-// Value encodes and writes a constant.Value into the element
-// bitstream.
-func (w *Encoder) Value(val constant.Value) {
-	w.Sync(SyncValue)
-	if w.Bool(val.Kind() == constant.Complex) {
-		w.scalar(constant.Real(val))
-		w.scalar(constant.Imag(val))
-	} else {
-		w.scalar(val)
-	}
-}
-
-func (w *Encoder) scalar(val constant.Value) {
-	switch v := constant.Val(val).(type) {
-	default:
-		panicf("unhandled %v (%v)", val, val.Kind())
-	case bool:
-		w.Code(ValBool)
-		w.Bool(v)
-	case string:
-		w.Code(ValString)
-		w.String(v)
-	case int64:
-		w.Code(ValInt64)
-		w.Int64(v)
-	case *big.Int:
-		w.Code(ValBigInt)
-		w.bigInt(v)
-	case *big.Rat:
-		w.Code(ValBigRat)
-		w.bigInt(v.Num())
-		w.bigInt(v.Denom())
-	case *big.Float:
-		w.Code(ValBigFloat)
-		w.bigFloat(v)
-	}
-}
-
-func (w *Encoder) bigInt(v *big.Int) {
-	b := v.Bytes()
-	w.String(string(b)) // TODO: More efficient encoding.
-	w.Bool(v.Sign() < 0)
-}
-
-func (w *Encoder) bigFloat(v *big.Float) {
-	b := v.Append(nil, 'p', -1)
-	w.String(string(b)) // TODO: More efficient encoding.
-}
-
-// Version reports the version of the bitstream.
-func (w *Encoder) Version() Version { return w.p.version }
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/flags.go b/vendor/golang.org/x/tools/internal/pkgbits/flags.go
deleted file mode 100644
index 654222745f..0000000000
--- a/vendor/golang.org/x/tools/internal/pkgbits/flags.go
+++ /dev/null
@@ -1,9 +0,0 @@
-// Copyright 2022 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pkgbits
-
-const (
-	flagSyncMarkers = 1 << iota // file format contains sync markers
-)
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/reloc.go b/vendor/golang.org/x/tools/internal/pkgbits/reloc.go
deleted file mode 100644
index fcdfb97ca9..0000000000
--- a/vendor/golang.org/x/tools/internal/pkgbits/reloc.go
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pkgbits
-
-// A RelocKind indicates a particular section within a unified IR export.
-type RelocKind int32
-
-// An Index represents a bitstream element index within a particular
-// section.
-type Index int32
-
-// A relocEnt (relocation entry) is an entry in an element's local
-// reference table.
-//
-// TODO(mdempsky): Rename this too.
-type RelocEnt struct {
-	Kind RelocKind
-	Idx  Index
-}
-
-// Reserved indices within the meta relocation section.
-const (
-	PublicRootIdx  Index = 0
-	PrivateRootIdx Index = 1
-)
-
-const (
-	RelocString RelocKind = iota
-	RelocMeta
-	RelocPosBase
-	RelocPkg
-	RelocName
-	RelocType
-	RelocObj
-	RelocObjExt
-	RelocObjDict
-	RelocBody
-
-	numRelocs = iota
-)
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/support.go b/vendor/golang.org/x/tools/internal/pkgbits/support.go
deleted file mode 100644
index 50534a2955..0000000000
--- a/vendor/golang.org/x/tools/internal/pkgbits/support.go
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright 2022 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pkgbits
-
-import "fmt"
-
-func assert(b bool) {
-	if !b {
-		panic("assertion failed")
-	}
-}
-
-func panicf(format string, args ...any) {
-	panic(fmt.Errorf(format, args...))
-}
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/sync.go b/vendor/golang.org/x/tools/internal/pkgbits/sync.go
deleted file mode 100644
index 1520b73afb..0000000000
--- a/vendor/golang.org/x/tools/internal/pkgbits/sync.go
+++ /dev/null
@@ -1,136 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pkgbits
-
-import (
-	"fmt"
-	"runtime"
-	"strings"
-)
-
-// fmtFrames formats a backtrace for reporting reader/writer desyncs.
-func fmtFrames(pcs ...uintptr) []string {
-	res := make([]string, 0, len(pcs))
-	walkFrames(pcs, func(file string, line int, name string, offset uintptr) {
-		// Trim package from function name. It's just redundant noise.
-		name = strings.TrimPrefix(name, "cmd/compile/internal/noder.")
-
-		res = append(res, fmt.Sprintf("%s:%v: %s +0x%v", file, line, name, offset))
-	})
-	return res
-}
-
-type frameVisitor func(file string, line int, name string, offset uintptr)
-
-// walkFrames calls visit for each call frame represented by pcs.
-//
-// pcs should be a slice of PCs, as returned by runtime.Callers.
-func walkFrames(pcs []uintptr, visit frameVisitor) {
-	if len(pcs) == 0 {
-		return
-	}
-
-	frames := runtime.CallersFrames(pcs)
-	for {
-		frame, more := frames.Next()
-		visit(frame.File, frame.Line, frame.Function, frame.PC-frame.Entry)
-		if !more {
-			return
-		}
-	}
-}
-
-// SyncMarker is an enum type that represents markers that may be
-// written to export data to ensure the reader and writer stay
-// synchronized.
-type SyncMarker int
-
-//go:generate stringer -type=SyncMarker -trimprefix=Sync
-
-const (
-	_ SyncMarker = iota
-
-	// Public markers (known to go/types importers).
-
-	// Low-level coding markers.
-	SyncEOF
-	SyncBool
-	SyncInt64
-	SyncUint64
-	SyncString
-	SyncValue
-	SyncVal
-	SyncRelocs
-	SyncReloc
-	SyncUseReloc
-
-	// Higher-level object and type markers.
-	SyncPublic
-	SyncPos
-	SyncPosBase
-	SyncObject
-	SyncObject1
-	SyncPkg
-	SyncPkgDef
-	SyncMethod
-	SyncType
-	SyncTypeIdx
-	SyncTypeParamNames
-	SyncSignature
-	SyncParams
-	SyncParam
-	SyncCodeObj
-	SyncSym
-	SyncLocalIdent
-	SyncSelector
-
-	// Private markers (only known to cmd/compile).
-	SyncPrivate
-
-	SyncFuncExt
-	SyncVarExt
-	SyncTypeExt
-	SyncPragma
-
-	SyncExprList
-	SyncExprs
-	SyncExpr
-	SyncExprType
-	SyncAssign
-	SyncOp
-	SyncFuncLit
-	SyncCompLit
-
-	SyncDecl
-	SyncFuncBody
-	SyncOpenScope
-	SyncCloseScope
-	SyncCloseAnotherScope
-	SyncDeclNames
-	SyncDeclName
-
-	SyncStmts
-	SyncBlockStmt
-	SyncIfStmt
-	SyncForStmt
-	SyncSwitchStmt
-	SyncRangeStmt
-	SyncCaseClause
-	SyncCommClause
-	SyncSelectStmt
-	SyncDecls
-	SyncLabeledStmt
-	SyncUseObjLocal
-	SyncAddLocal
-	SyncLinkname
-	SyncStmt1
-	SyncStmtsEnd
-	SyncLabel
-	SyncOptLabel
-
-	SyncMultiExpr
-	SyncRType
-	SyncConvRTTI
-)
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/syncmarker_string.go b/vendor/golang.org/x/tools/internal/pkgbits/syncmarker_string.go
deleted file mode 100644
index 582ad56d3e..0000000000
--- a/vendor/golang.org/x/tools/internal/pkgbits/syncmarker_string.go
+++ /dev/null
@@ -1,92 +0,0 @@
-// Code generated by "stringer -type=SyncMarker -trimprefix=Sync"; DO NOT EDIT.
-
-package pkgbits
-
-import "strconv"
-
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[SyncEOF-1]
-	_ = x[SyncBool-2]
-	_ = x[SyncInt64-3]
-	_ = x[SyncUint64-4]
-	_ = x[SyncString-5]
-	_ = x[SyncValue-6]
-	_ = x[SyncVal-7]
-	_ = x[SyncRelocs-8]
-	_ = x[SyncReloc-9]
-	_ = x[SyncUseReloc-10]
-	_ = x[SyncPublic-11]
-	_ = x[SyncPos-12]
-	_ = x[SyncPosBase-13]
-	_ = x[SyncObject-14]
-	_ = x[SyncObject1-15]
-	_ = x[SyncPkg-16]
-	_ = x[SyncPkgDef-17]
-	_ = x[SyncMethod-18]
-	_ = x[SyncType-19]
-	_ = x[SyncTypeIdx-20]
-	_ = x[SyncTypeParamNames-21]
-	_ = x[SyncSignature-22]
-	_ = x[SyncParams-23]
-	_ = x[SyncParam-24]
-	_ = x[SyncCodeObj-25]
-	_ = x[SyncSym-26]
-	_ = x[SyncLocalIdent-27]
-	_ = x[SyncSelector-28]
-	_ = x[SyncPrivate-29]
-	_ = x[SyncFuncExt-30]
-	_ = x[SyncVarExt-31]
-	_ = x[SyncTypeExt-32]
-	_ = x[SyncPragma-33]
-	_ = x[SyncExprList-34]
-	_ = x[SyncExprs-35]
-	_ = x[SyncExpr-36]
-	_ = x[SyncExprType-37]
-	_ = x[SyncAssign-38]
-	_ = x[SyncOp-39]
-	_ = x[SyncFuncLit-40]
-	_ = x[SyncCompLit-41]
-	_ = x[SyncDecl-42]
-	_ = x[SyncFuncBody-43]
-	_ = x[SyncOpenScope-44]
-	_ = x[SyncCloseScope-45]
-	_ = x[SyncCloseAnotherScope-46]
-	_ = x[SyncDeclNames-47]
-	_ = x[SyncDeclName-48]
-	_ = x[SyncStmts-49]
-	_ = x[SyncBlockStmt-50]
-	_ = x[SyncIfStmt-51]
-	_ = x[SyncForStmt-52]
-	_ = x[SyncSwitchStmt-53]
-	_ = x[SyncRangeStmt-54]
-	_ = x[SyncCaseClause-55]
-	_ = x[SyncCommClause-56]
-	_ = x[SyncSelectStmt-57]
-	_ = x[SyncDecls-58]
-	_ = x[SyncLabeledStmt-59]
-	_ = x[SyncUseObjLocal-60]
-	_ = x[SyncAddLocal-61]
-	_ = x[SyncLinkname-62]
-	_ = x[SyncStmt1-63]
-	_ = x[SyncStmtsEnd-64]
-	_ = x[SyncLabel-65]
-	_ = x[SyncOptLabel-66]
-	_ = x[SyncMultiExpr-67]
-	_ = x[SyncRType-68]
-	_ = x[SyncConvRTTI-69]
-}
-
-const _SyncMarker_name = "EOFBoolInt64Uint64StringValueValRelocsRelocUseRelocPublicPosPosBaseObjectObject1PkgPkgDefMethodTypeTypeIdxTypeParamNamesSignatureParamsParamCodeObjSymLocalIdentSelectorPrivateFuncExtVarExtTypeExtPragmaExprListExprsExprExprTypeAssignOpFuncLitCompLitDeclFuncBodyOpenScopeCloseScopeCloseAnotherScopeDeclNamesDeclNameStmtsBlockStmtIfStmtForStmtSwitchStmtRangeStmtCaseClauseCommClauseSelectStmtDeclsLabeledStmtUseObjLocalAddLocalLinknameStmt1StmtsEndLabelOptLabelMultiExprRTypeConvRTTI"
-
-var _SyncMarker_index = [...]uint16{0, 3, 7, 12, 18, 24, 29, 32, 38, 43, 51, 57, 60, 67, 73, 80, 83, 89, 95, 99, 106, 120, 129, 135, 140, 147, 150, 160, 168, 175, 182, 188, 195, 201, 209, 214, 218, 226, 232, 234, 241, 248, 252, 260, 269, 279, 296, 305, 313, 318, 327, 333, 340, 350, 359, 369, 379, 389, 394, 405, 416, 424, 432, 437, 445, 450, 458, 467, 472, 480}
-
-func (i SyncMarker) String() string {
-	i -= 1
-	if i < 0 || i >= SyncMarker(len(_SyncMarker_index)-1) {
-		return "SyncMarker(" + strconv.FormatInt(int64(i+1), 10) + ")"
-	}
-	return _SyncMarker_name[_SyncMarker_index[i]:_SyncMarker_index[i+1]]
-}
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/version.go b/vendor/golang.org/x/tools/internal/pkgbits/version.go
deleted file mode 100644
index 0db9652748..0000000000
--- a/vendor/golang.org/x/tools/internal/pkgbits/version.go
+++ /dev/null
@@ -1,102 +0,0 @@
-// Copyright 2024 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pkgbits
-
-// Version indicates a version of a unified IR bitstream.
-// Each Version indicates the addition, removal, or change of
-// new data in the bitstream.
-//
-// These are serialized to disk and the interpretation remains fixed.
-type Version uint32
-
-const (
-	// V0: initial prototype.
-	//
-	// All data that is not assigned a Field is in version V0
-	// and has not been deprecated.
-	V0 Version = iota
-
-	// V1: adds the Flags uint32 word
-	V1
-
-	// V2: removes unused legacy fields and supports type parameters for aliases.
-	// - remove the legacy "has init" bool from the public root
-	// - remove obj's "derived func instance" bool
-	// - add a TypeParamNames field to ObjAlias
-	// - remove derived info "needed" bool
-	V2
-
-	// V3: introduces a more compact format for composite literal element lists
-	// - negative lengths indicate that (some) elements may have keys
-	// - positive lengths indicate that no element has a key
-	// - a negative struct field index indicates an embedded field
-	V3
-
-	// V4: encodes generic methods as standalone function objects
-	V4
-
-	numVersions = iota
-)
-
-// Field denotes a unit of data in the serialized unified IR bitstream.
-// It is conceptually a like field in a structure.
-//
-// We only really need Fields when the data may or may not be present
-// in a stream based on the Version of the bitstream.
-//
-// Unlike much of pkgbits, Fields are not serialized and
-// can change values as needed.
-type Field int
-
-const (
-	// Flags in a uint32 in the header of a bitstream
-	// that is used to indicate whether optional features are enabled.
-	Flags Field = iota
-
-	// Deprecated: HasInit was a bool indicating whether a package
-	// has any init functions.
-	HasInit
-
-	// Deprecated: DerivedFuncInstance was a bool indicating
-	// whether an object was a function instance.
-	DerivedFuncInstance
-
-	// ObjAlias has a list of TypeParamNames.
-	AliasTypeParamNames
-
-	// Deprecated: DerivedInfoNeeded was a bool indicating
-	// whether a type was a derived type.
-	DerivedInfoNeeded
-
-	// Composite literals use a more compact format for element lists.
-	CompactCompLiterals
-
-	// Generic methods may appear as standalone function objects.
-	GenericMethods
-
-	numFields = iota
-)
-
-// introduced is the version a field was added.
-var introduced = [numFields]Version{
-	Flags:               V1,
-	AliasTypeParamNames: V2,
-	CompactCompLiterals: V3,
-	GenericMethods:      V4,
-}
-
-// removed is the version a field was removed in or 0 for fields
-// that have not yet been deprecated.
-// (So removed[f]-1 is the last version it is included in.)
-var removed = [numFields]Version{
-	HasInit:             V2,
-	DerivedFuncInstance: V2,
-	DerivedInfoNeeded:   V2,
-}
-
-// Has reports whether field f is present in a bitstream at version v.
-func (v Version) Has(f Field) bool {
-	return introduced[f] <= v && (v < removed[f] || removed[f] == V0)
-}
diff --git a/vendor/golang.org/x/tools/internal/stdlib/deps.go b/vendor/golang.org/x/tools/internal/stdlib/deps.go
deleted file mode 100644
index dacfc1dfff..0000000000
--- a/vendor/golang.org/x/tools/internal/stdlib/deps.go
+++ /dev/null
@@ -1,527 +0,0 @@
-// Copyright 2025 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate.go. DO NOT EDIT.
-
-package stdlib
-
-type pkginfo struct {
-	name string
-	deps string // list of indices of dependencies, as varint-encoded deltas
-}
-
-var deps = [...]pkginfo{
-	{"archive/tar", "\x03q\x03F=\x01\n\x01$\x01\x01\x02\x05\b\x02\x01\x02\x02\r"},
-	{"archive/zip", "\x02\x04g\a\x03\x13\x021=\x01+\x05\x01\x0f\x03\x02\x0f\x04"},
-	{"bufio", "\x03q\x86\x01D\x15"},
-	{"bytes", "t+[\x03\fH\x02\x02"},
-	{"cmp", ""},
-	{"compress/bzip2", "\x02\x02\xf6\x01A"},
-	{"compress/flate", "\x02r\x03\x83\x01\f\x033\x01\x03"},
-	{"compress/gzip", "\x02\x04g\a\x03\x15nU"},
-	{"compress/lzw", "\x02r\x03\x83\x01"},
-	{"compress/zlib", "\x02\x04g\a\x03\x13\x01o"},
-	{"container/heap", "\xbc\x02"},
-	{"container/list", ""},
-	{"container/ring", ""},
-	{"context", "t\\p\x01\x0e"},
-	{"crypto", "\x8a\x01pC"},
-	{"crypto/aes", "\x10\v\t\x99\x02"},
-	{"crypto/cipher", "\x03!\x01\x01 \x12\x1c,Z"},
-	{"crypto/des", "\x10\x16 .,\x9d\x01\x03"},
-	{"crypto/dsa", "F\x03+\x86\x01\r"},
-	{"crypto/ecdh", "\x03\v\r\x10\x04\x17\x03\x0f\x1c\x86\x01"},
-	{"crypto/ecdsa", "\x0e\x05\x03\x05\x01\x10\b\v\x06\x01\x03\x0e\x01\x1c\x86\x01\r\x05L\x01"},
-	{"crypto/ed25519", "\x0e\x1f\x12\a\x03\b\a\x1cI=C"},
-	{"crypto/elliptic", "4@\x86\x01\r9"},
-	{"crypto/fips140", "#\x05\x95\x01\x98\x01"},
-	{"crypto/hkdf", "0\x15\x01.\x16"},
-	{"crypto/hmac", "\x1b\x16\x14\x01\x122"},
-	{"crypto/hpke", "\x03\v\x02\x03\x04\x01\f\x01\x05\x1f\x05\a\x01\x01\x1d\x03\x13\x16\x9b\x01\x1c"},
-	{"crypto/internal/boring", "\x0e\x02\x0el"},
-	{"crypto/internal/boring/bbig", "\x1b\xec\x01N"},
-	{"crypto/internal/boring/bcache", "\xc1\x02\x14"},
-	{"crypto/internal/boring/sig", ""},
-	{"crypto/internal/constanttime", ""},
-	{"crypto/internal/cryptotest", "\x03\r\v\b%\x10\x19\x06\x13\x12 \x04\x06\t\x19\x01\x11\x11\x1b\x01\a\x05\b\x03\x05\f"},
-	{"crypto/internal/entropy", "K"},
-	{"crypto/internal/entropy/v1.0.0", "D0\x95\x018\x14"},
-	{"crypto/internal/fips140", "C1\xbf\x01\v\x17"},
-	{"crypto/internal/fips140/aes", "\x03 \x03\x02\x14\x05\x01\x01\x05,\x95\x014"},
-	{"crypto/internal/fips140/aes/gcm", "#\x01\x02\x02\x02\x12\x05\x01\x06,\x92\x01"},
-	{"crypto/internal/fips140/alias", "\xd5\x02"},
-	{"crypto/internal/fips140/bigmod", "(\x19\x01\x06,\x95\x01"},
-	{"crypto/internal/fips140/check", "#\x0e\a\t\x02\xb7\x01["},
-	{"crypto/internal/fips140/check/checktest", "(\x8b\x02\""},
-	{"crypto/internal/fips140/drbg", "\x03\x1f\x01\x01\x04\x14\x05\n)\x86\x01\x0f7\x01"},
-	{"crypto/internal/fips140/ecdh", "\x03 \x05\x02\n\r3\x86\x01\x0f7"},
-	{"crypto/internal/fips140/ecdsa", "\x03 \x04\x01\x02\a\x03\x06:\x16pF"},
-	{"crypto/internal/fips140/ed25519", "\x03 \x05\x02\x04\f:\xc9\x01\x03"},
-	{"crypto/internal/fips140/edwards25519", "\x1f\t\a\x123\x95\x017"},
-	{"crypto/internal/fips140/edwards25519/field", "(\x14\x053\x95\x01"},
-	{"crypto/internal/fips140/hkdf", "\x03 \x05\t\a<\x16"},
-	{"crypto/internal/fips140/hmac", "\x03 \x15\x01\x01:\x16"},
-	{"crypto/internal/fips140/mldsa", "\x03\x1c\x04\x05\x02\x0e\x01\x03\x053\x95\x017"},
-	{"crypto/internal/fips140/mlkem", "\x03 \x05\x02\x0f\x03\x053\xcc\x01"},
-	{"crypto/internal/fips140/nistec", "\x1f\t\r\f3\x95\x01*\r\x15"},
-	{"crypto/internal/fips140/nistec/fiat", "(\x148\x95\x01"},
-	{"crypto/internal/fips140/pbkdf2", "\x03 \x05\t\a<\x16"},
-	{"crypto/internal/fips140/rsa", "\x03\x1c\x04\x04\x01\x02\x0e\x01\x01\x028\x16pF"},
-	{"crypto/internal/fips140/sha256", "\x03 \x1e\x01\x06,\x16\x7f"},
-	{"crypto/internal/fips140/sha3", "\x03 \x19\x05\x012\x95\x01L"},
-	{"crypto/internal/fips140/sha512", "\x03 \x1e\x01\x06,\x16\x7f"},
-	{"crypto/internal/fips140/ssh", "(b"},
-	{"crypto/internal/fips140/subtle", "\x1f\a\x1b\xc8\x01"},
-	{"crypto/internal/fips140/tls12", "\x03 \x05\t\a\x02:\x16"},
-	{"crypto/internal/fips140/tls13", "\x03 \x05\b\b\t3\x16"},
-	{"crypto/internal/fips140cache", "\xb3\x02\r'"},
-	{"crypto/internal/fips140deps", ""},
-	{"crypto/internal/fips140deps/byteorder", "\xa0\x01"},
-	{"crypto/internal/fips140deps/cpu", "\xb5\x01\a"},
-	{"crypto/internal/fips140deps/godebug", "\xbd\x01"},
-	{"crypto/internal/fips140deps/time", "\xcf\x02"},
-	{"crypto/internal/fips140hash", "9\x1d4\xcb\x01"},
-	{"crypto/internal/fips140only", "\x17\x13\x0e\x01\x01Pp"},
-	{"crypto/internal/fips140test", ""},
-	{"crypto/internal/impl", "\xbe\x02"},
-	{"crypto/internal/rand", "\x1b\x0f s=["},
-	{"crypto/internal/randutil", "\xfa\x01\x12"},
-	{"crypto/internal/sysrand", "tq! \r\r\x01\x01\r\x06"},
-	{"crypto/internal/sysrand/internal/seccomp", "t"},
-	{"crypto/md5", "\x0e8.\x16\x16i"},
-	{"crypto/mlkem", "\x0e%"},
-	{"crypto/mlkem/mlkemtest", "3\x13\b&"},
-	{"crypto/pbkdf2", "6\x0f\x01.\x16"},
-	{"crypto/rand", "\x1b\x0f\x1c\x03+\x86\x01\rN"},
-	{"crypto/rc4", "& .\xc9\x01"},
-	{"crypto/rsa", "\x0e\r\x01\v\x10\x0e\x01\x03\b\a\x1c\x03\x133=\f\x01"},
-	{"crypto/sha1", "\x0e\r+\x02,\x16\x16\x15T"},
-	{"crypto/sha256", "\x0e\r\x1dR"},
-	{"crypto/sha3", "\x0e+Q\xcb\x01"},
-	{"crypto/sha512", "\x0e\r\x1fP"},
-	{"crypto/subtle", "\x1f\x1d\x9f\x01z"},
-	{"crypto/tls", "\x03\b\x02\x01\x01\x01\x01\x02\x01\x01\x01\x02\x01\x01\x01\t\x01\x18\x01\x0f\x01\x03\x01\x01\x01\x01\x02\x01\x02\x01\x17\x02\x03\x13\x16\x15\b=\x16\x16\r\b\x01\x01\x01\x02\x01\x0e\x06\x02\x01\x0f"},
-	{"crypto/tls/internal/fips140tls", "\x17\xaa\x02"},
-	{"crypto/x509", "\x03\v\x01\x01\x01\x01\x01\x01\x01\x017\x06\x01\x01\x02\x05\x0e\x06\x02\x02\x03F\x03:\x01\x02\b\x01\x01\x02\a\x10\x05\x01\x06\a\b\x02\x01\x02\x0f\x02\x01\x01\x02\x03\x01"},
-	{"crypto/x509/pkix", "j\x06\a\x90\x01H"},
-	{"database/sql", "\x03\nQ\x16\x03\x83\x01\v\a\"\x05\b\x02\x03\x01\x0e\x02\x02\x02"},
-	{"database/sql/driver", "\rg\x03\xb7\x01\x0f\x12"},
-	{"debug/buildinfo", "\x03^\x02\x01\x01\b\a\x03g\x1a\x02\x01+\x0f "},
-	{"debug/dwarf", "\x03j\a\x03\x83\x011\x11\x01\x01"},
-	{"debug/elf", "\x03\x06W\r\a\x03g\x1b\x01\f \x17\x01\x17"},
-	{"debug/gosym", "\x03j\n$\xa1\x01\x01\x01\x02"},
-	{"debug/macho", "\x03\x06W\r\ng\x1c,\x17\x01"},
-	{"debug/pe", "\x03\x06W\r\a\x03g\x1c,\x17\x01\x17"},
-	{"debug/plan9obj", "m\a\x03g\x1c,"},
-	{"embed", "t+B\x19\x01T"},
-	{"embed/internal/embedtest", ""},
-	{"encoding", ""},
-	{"encoding/ascii85", "\xfa\x01C"},
-	{"encoding/asn1", "\x03q\x03g(\x01'\r\x02\x01\x11\x03\x01"},
-	{"encoding/base32", "\xfa\x01A\x02"},
-	{"encoding/base64", "\xa0\x01ZA\x02"},
-	{"encoding/binary", "t\x86\x01\f(\r\x05"},
-	{"encoding/csv", "\x02\x01q\x03\x83\x01D\x13\x02"},
-	{"encoding/gob", "\x02f\x05\a\x03g\x1c\v\x01\x03\x1d\b\x12\x01\x10\x02"},
-	{"encoding/hex", "t\x03\x83\x01A\x03"},
-	{"encoding/json", "\x03\x01d\x04\b\x03\x83\x01\f(\r\x02\x01\x02\x11\x01\x01\x02"},
-	{"encoding/pem", "\x03i\b\x86\x01A\x03"},
-	{"encoding/xml", "\x02\x01e\f\x03\x83\x014\x05\n\x01\x02\x11\x02"},
-	{"errors", "\xd0\x01\x85\x01"},
-	{"expvar", "qLA\b\v\x15\r\b\x02\x03\x01\x12"},
-	{"flag", "h\f\x03\x83\x01,\b\x05\b\x02\x01\x11"},
-	{"fmt", "tF'\x19\f \b\r\x02\x03\x13"},
-	{"go/ast", "\x03\x01s\x0f\x01s\x03)\b\r\x02\x01\x13\x02"},
-	{"go/build", "\x02\x01q\x03\x01\x02\x02\b\x02\x01\x17\x1f\x04\x02\b\x1c\x13\x01+\x01\x04\x01\a\b\x02\x01\x13\x02\x02"},
-	{"go/build/constraint", "t\xc9\x01\x01\x13\x02"},
-	{"go/constant", "w\x10\x7f\x01\x024\x01\x02\x13"},
-	{"go/doc", "\x04s\x01\x05\n=61\x10\x02\x01\x13\x02"},
-	{"go/doc/comment", "\x03t\xc4\x01\x01\x01\x01\x13\x02"},
-	{"go/format", "\x03t\x01\f\x01\x02sD"},
-	{"go/importer", "y\a\x01\x02\x04\x01r9"},
-	{"go/internal/gccgoimporter", "\x02\x01^\x13\x03\x04\f\x01p\x02,\x01\x05\x11\x01\r\b"},
-	{"go/internal/gcimporter", "\x02u\x10\x010\x05\r0,\x15\x03\x02"},
-	{"go/internal/scannerhooks", "\x87\x01"},
-	{"go/internal/srcimporter", "w\x01\x01\v\x03\x01r,\x01\x05\x12\x02\x15"},
-	{"go/parser", "\x03q\x03\x01\x02\b\x04\x01s\x01+\x06\x12"},
-	{"go/printer", "w\x01\x02\x03\ns\f \x15\x02\x01\x02\f\x05\x02"},
-	{"go/scanner", "\x03t\v\x05s2\x10\x01\x14\x02"},
-	{"go/token", "\x04s\x86\x01>\x02\x03\x01\x10\x02"},
-	{"go/types", "\x03\x01\x06j\x03\x01\x03\t\x03\x024\x063\x04\x03\t \x06\a\b\x01\x01\x01\x02\x01\x10\x02\x02"},
-	{"go/version", "\xc2\x01|"},
-	{"hash", "\xfa\x01"},
-	{"hash/adler32", "t\x16\x16"},
-	{"hash/crc32", "t\x16\x16\x15\x8b\x01\x01\x14"},
-	{"hash/crc64", "t\x16\x16\xa0\x01"},
-	{"hash/fnv", "t\x16\x16i"},
-	{"hash/maphash", "\x8a\x01\x11<~"},
-	{"html", "\xbe\x02\x02\x13"},
-	{"html/template", "\x03n\x06\x19-=\x01\n!\x05\x01\x02\x03\f\x01\x02\r\x01\x03\x02"},
-	{"image", "\x02r\x1fg\x0f4\x03\x01"},
-	{"image/color", ""},
-	{"image/color/palette", "\x93\x01"},
-	{"image/draw", "\x92\x01\x01\x04"},
-	{"image/gif", "\x02\x01\x05l\x03\x1b\x01\x01\x01\vZ\x0f"},
-	{"image/internal/imageutil", "\x92\x01"},
-	{"image/jpeg", "\x02r\x1e\x01\x04c"},
-	{"image/png", "\x02\ad\n\x13\x02\x06\x01gC"},
-	{"index/suffixarray", "\x03j\a\x86\x01\f+\n\x01"},
-	{"internal/abi", "\xbc\x01\x99\x01"},
-	{"internal/asan", "\xd5\x02"},
-	{"internal/bisect", "\xb3\x02\r\x01"},
-	{"internal/buildcfg", "wHg\x06\x02\x05\n\x01"},
-	{"internal/bytealg", "\xb5\x01\xa0\x01"},
-	{"internal/byteorder", ""},
-	{"internal/cfg", ""},
-	{"internal/cgrouptest", "w[T\x06\x0f\x02\x01\x04\x01"},
-	{"internal/chacha8rand", "\xa0\x01\x15\a\x99\x01"},
-	{"internal/copyright", ""},
-	{"internal/coverage", ""},
-	{"internal/coverage/calloc", ""},
-	{"internal/coverage/cfile", "q\x06\x17\x17\x01\x02\x01\x01\x01\x01\x01\x01\x01\"\x02',\x06\a\n\x01\x03\x0e\x06"},
-	{"internal/coverage/cformat", "\x04s.\x04Q\v6\x01\x02\x0e"},
-	{"internal/coverage/cmerge", "w.a"},
-	{"internal/coverage/decodecounter", "m\n.\v\x02H,\x17\x18"},
-	{"internal/coverage/decodemeta", "\x02k\n\x17\x17\v\x02H,"},
-	{"internal/coverage/encodecounter", "\x02k\n.\f\x01\x02F\v!\x15"},
-	{"internal/coverage/encodemeta", "\x02\x01j\n\x13\x04\x17\r\x02F,/"},
-	{"internal/coverage/pods", "\x04s.\x81\x01\x06\x05\n\x02\x01"},
-	{"internal/coverage/rtcov", "\xd5\x02"},
-	{"internal/coverage/slicereader", "m\n\x83\x01["},
-	{"internal/coverage/slicewriter", "w\x83\x01"},
-	{"internal/coverage/stringtab", "w9\x04F"},
-	{"internal/coverage/test", ""},
-	{"internal/coverage/uleb128", ""},
-	{"internal/cpu", "\xd5\x02"},
-	{"internal/dag", "\x04s\xc4\x01\x03"},
-	{"internal/diff", "\x03t\xc5\x01\x02"},
-	{"internal/exportdata", "\x02\x01q\x03\x02e\x1c,\x01\x05\x11\x01\x02"},
-	{"internal/filepathlite", "t+B\x1a@"},
-	{"internal/fmtsort", "\x04\xaa\x02\r"},
-	{"internal/fuzz", "\x03\nH\x18\x04\x03\x03\x01\f\x036=\f\x03\x1d\x01\x05\x02\x05\n\x01\x02\x01\x01\r\x04\x02"},
-	{"internal/goarch", ""},
-	{"internal/godebug", "\x9d\x01!\x82\x01\x01\x14"},
-	{"internal/godebugs", ""},
-	{"internal/goexperiment", ""},
-	{"internal/goos", ""},
-	{"internal/goroot", "\xa6\x02\x01\x05\x12\x02"},
-	{"internal/gover", "\x04"},
-	{"internal/goversion", ""},
-	{"internal/lazyregexp", "\xa6\x02\v\r\x02"},
-	{"internal/lazytemplate", "\xfa\x01,\x18\x02\r"},
-	{"internal/msan", "\xd5\x02"},
-	{"internal/nettrace", ""},
-	{"internal/obscuretestdata", "l\x8e\x01,"},
-	{"internal/oserror", "t"},
-	{"internal/pkgbits", "\x03R\x18\a\x03\x04\fs\r\x1f\r\n\x01"},
-	{"internal/platform", ""},
-	{"internal/poll", "tl\x05\x159\r\x01\x01\r\x06"},
-	{"internal/profile", "\x03\x04m\x03\x83\x017\n\x01\x01\x01\x11"},
-	{"internal/profilerecord", ""},
-	{"internal/race", "\x9b\x01\xba\x01"},
-	{"internal/reflectlite", "\x9b\x01!;<\""},
-	{"internal/runtime/atomic", "\xbc\x01\x99\x01"},
-	{"internal/runtime/cgroup", "\x9f\x01=\x04u"},
-	{"internal/runtime/exithook", "\xd1\x01\x84\x01"},
-	{"internal/runtime/gc", "\xbc\x01"},
-	{"internal/runtime/gc/internal/gen", "\nc\n\x18k\x04\v\x1d\b\x10\x02"},
-	{"internal/runtime/gc/scan", "\xb5\x01\a\x18\az"},
-	{"internal/runtime/maps", "\x9b\x01\x01 \n\t\t\x03z"},
-	{"internal/runtime/math", "\xbc\x01"},
-	{"internal/runtime/pprof/label", ""},
-	{"internal/runtime/startlinetest", ""},
-	{"internal/runtime/sys", "\xbc\x01\x04"},
-	{"internal/runtime/syscall/linux", "\xbc\x01\x99\x01"},
-	{"internal/runtime/wasitest", ""},
-	{"internal/saferio", "\xfa\x01["},
-	{"internal/singleflight", "\xc0\x02"},
-	{"internal/strconv", "\x89\x02L"},
-	{"internal/stringslite", "\x9f\x01\xb6\x01"},
-	{"internal/sync", "\x9b\x01!\x13r\x14"},
-	{"internal/synctest", "\x9b\x01\xba\x01"},
-	{"internal/syscall/execenv", "\xc2\x02"},
-	{"internal/syscall/unix", "\xb3\x02\x0e\x01\x13"},
-	{"internal/sysinfo", "\x02\x01\xb2\x01E,\x18\x02"},
-	{"internal/syslist", ""},
-	{"internal/testenv", "\x03\ng\x02\x01*\x1b\x0f0+\x01\x05\a\n\x01\x02\x02\x01\f"},
-	{"internal/testhash", "\x03\x87\x01p\x118\f"},
-	{"internal/testlog", "\xc0\x02\x01\x14"},
-	{"internal/testpty", "t\x03\xaf\x01"},
-	{"internal/trace", "\x02\x01\x01\x06c\a\x03w\x03\x03\x06\x03\t+\n\x01\x01\x01\x11\x06"},
-	{"internal/trace/internal/testgen", "\x03j\nu\x03\x02\x03\x011\v\r\x11"},
-	{"internal/trace/internal/tracev1", "\x03\x01i\a\x03}\x06\f5\x01"},
-	{"internal/trace/raw", "\x02k\nz\x03\x06C\x01\x13"},
-	{"internal/trace/testtrace", "\x02\x01q\x03q\x04\x03\x05\x01\x05,\v\x02\b\x02\x01\x05"},
-	{"internal/trace/tracev2", ""},
-	{"internal/trace/traceviewer", "\x02d\v\x06\x1a<\x1f\a\a\x04\b\v\x15\x01\x05\a\n\x01\x02\x0f"},
-	{"internal/trace/traceviewer/format", ""},
-	{"internal/trace/version", "wz\t"},
-	{"internal/txtar", "\x03t\xaf\x01\x18"},
-	{"internal/types/errors", "\xbd\x02"},
-	{"internal/unsafeheader", "\xd5\x02"},
-	{"internal/xcoff", "`\r\a\x03g\x1c,\x17\x01"},
-	{"internal/zstd", "m\a\x03\x83\x01\x0f"},
-	{"io", "t\xcc\x01"},
-	{"io/fs", "t+*11\x10\x14\x04"},
-	{"io/ioutil", "\xfa\x01\x01+\x15\x03"},
-	{"iter", "\xcf\x01d\""},
-	{"log", "w\x83\x01\x05'\r\r\x01\x0e"},
-	{"log/internal", ""},
-	{"log/slog", "\x03\n[\t\x03\x03\x83\x01\x04\x01\x02\x02\x03(\x05\b\x02\x01\x02\x01\x0e\x02\x02\x02"},
-	{"log/slog/internal", ""},
-	{"log/slog/internal/benchmarks", "\rg\x03\x83\x01\x06\x03:\x12"},
-	{"log/slog/internal/buffer", "\xc0\x02"},
-	{"log/syslog", "t\x03\x87\x01\x12\x16\x18\x02\x0f"},
-	{"maps", "\xfd\x01X"},
-	{"math", "\xb5\x01TL"},
-	{"math/big", "\x03q\x03)\x15E\f\x03\x020\x02\x01\x02\x15"},
-	{"math/big/internal/asmgen", "\x03\x01s\x92\x012\x03"},
-	{"math/bits", "\xd5\x02"},
-	{"math/cmplx", "\x86\x02\x03"},
-	{"math/rand", "\xbd\x01I:\x01\x14"},
-	{"math/rand/v2", "t,\x03c\x03L"},
-	{"mime", "\x02\x01i\b\x03\x83\x01\v!\x15\x03\x02\x11\x02"},
-	{"mime/multipart", "\x02\x01N#\x03F=\v\x01\a\x02\x15\x02\x06\x0f\x02\x01\x17"},
-	{"mime/quotedprintable", "\x02\x01t\x83\x01"},
-	{"net", "\x04\tg+\x1e\n\x05\x13\x01\x01\x04\x15\x01%\x06\r\b\x05\x01\x01\r\x06\a"},
-	{"net/http", "\x02\x01\x03\x01\x04\x02D\b\x13\x01\a\x03F=\x01\x03\a\x01\x03\x02\x02\x01\x02\x06\x02\x01\x01\n\x01\x01\x05\x01\x02\x05\b\x01\x01\x01\x02\x01\x0e\x02\x02\x02\b\x01\x01\x01"},
-	{"net/http/cgi", "\x02W\x1b\x03\x83\x01\x04\a\v\x01\x13\x01\x01\x01\x04\x01\x05\x02\b\x02\x01\x11\x0e"},
-	{"net/http/cookiejar", "\x04p\x03\x99\x01\x01\b\a\x05\x16\x03\x02\x0f\x04"},
-	{"net/http/fcgi", "\x02\x01\n`\a\x03\x83\x01\x16\x01\x01\x14\x18\x02\x0f"},
-	{"net/http/httptest", "\x02\x01\nL\x02\x1b\x01\x83\x01\x04\x12\x01\n\t\x02\x17\x01\x02\x0f\x0e"},
-	{"net/http/httptrace", "\rLnI\x14\n!"},
-	{"net/http/httputil", "\x02\x01\ng\x03\x83\x01\x04\x0f\x03\x01\x05\x02\x01\v\x01\x19\x02\x01\x0e\x0e"},
-	{"net/http/internal", "\x02\x01q\x03\x83\x01"},
-	{"net/http/internal/ascii", "\xbe\x02\x13"},
-	{"net/http/internal/httpcommon", "\rg\x03\x9f\x01\x0e\x01\x17\x01\x01\x02\x1d\x02"},
-	{"net/http/internal/testcert", "\xbe\x02"},
-	{"net/http/pprof", "\x02\x01\nj\x19-\x02\x0e-\x04\x13\x14\x01\r\x04\x03\x01\x02\x01\x11"},
-	{"net/internal/cgotest", ""},
-	{"net/internal/socktest", "w\xc9\x01\x02"},
-	{"net/mail", "\x02r\x03\x83\x01\x04\x0f\x03\x14\x1a\x02\x0f\x04"},
-	{"net/netip", "\x04p+\x01f\x034\x17"},
-	{"net/rpc", "\x02m\x05\x03\x10\ni\x04\x12\x01\x1d\r\x03\x02"},
-	{"net/rpc/jsonrpc", "q\x03\x03\x83\x01\x16\x11\x1f"},
-	{"net/smtp", "\x194\f\x13\b\x03\x83\x01\x16\x14\x1a"},
-	{"net/textproto", "\x02\x01q\x03\x83\x01\f\n-\x01\x02\x15"},
-	{"net/url", "t\x03Fc\v\x10\x02\x01\x17"},
-	{"os", "t+\x01\x19\x03\x10\x14\x01\x03\x01\x05\x10\x018\b\x05\x01\x01\r\x06"},
-	{"os/exec", "\x03\ngI'\x01\x15\x01+\x06\a\n\x01\x03\x01\r"},
-	{"os/exec/internal/fdtest", "\xc2\x02"},
-	{"os/signal", "\r\x99\x02\x15\x05\x02"},
-	{"os/user", "\x02\x01q\x03\x83\x01,\r\n\x01\x02"},
-	{"path", "t+\xb4\x01"},
-	{"path/filepath", "t+\x1aB+\r\b\x03\x04\x11"},
-	{"plugin", "t"},
-	{"reflect", "t'\x04\x1d\x13\b\x04\x05\x17\x06\t-\n\x03\x11\x02\x02"},
-	{"reflect/internal/example1", ""},
-	{"reflect/internal/example2", ""},
-	{"regexp", "\x03\xf7\x018\t\x02\x01\x02\x11\x02"},
-	{"regexp/syntax", "\xbb\x02\x01\x01\x01\x02\x11\x02"},
-	{"runtime", "\x9b\x01\x04\x01\x03\f\x06\a\x02\x01\x01\x0e\x03\x01\x01\x01\x02\x01\x01\x01\x02\x01\x04\x01\x10\x18L"},
-	{"runtime/coverage", "\xa7\x01S"},
-	{"runtime/debug", "wUZ\r\b\x02\x01\x11\x06"},
-	{"runtime/metrics", "\xbe\x01H-\""},
-	{"runtime/pprof", "\x02\x01\x01\x03\x06`\a\x03$$\x0f\v!\f \r\b\x01\x01\x01\x02\x02\n\x03\x06"},
-	{"runtime/race", "\xb9\x02"},
-	{"runtime/race/internal/amd64v1", ""},
-	{"runtime/trace", "\rg\x03z\t9\b\x05\x01\x0e\x06"},
-	{"slices", "\x04\xf9\x01\fL"},
-	{"sort", "\xd0\x0192"},
-	{"strconv", "t+A\x01r"},
-	{"strings", "t'\x04B\x19\x03\f7\x11\x02\x02"},
-	{"structs", ""},
-	{"sync", "\xcf\x01\x13\x01P\x0e\x14"},
-	{"sync/atomic", "\xd5\x02"},
-	{"syscall", "t(\x03\x01\x1c\n\x03\x06\r\x04S\b\x05\x01\x14"},
-	{"testing", "\x03\ng\x02\x01X\x17\x14\f\x05\x1b\x06\x02\x05\x02\x05\x01\x02\x01\x02\x01\x0e\x02\x04"},
-	{"testing/cryptotest", "QOZ\x124\x03\x12"},
-	{"testing/fstest", "t\x03\x83\x01\x01\n&\x10\x03\t\b"},
-	{"testing/internal/testdeps", "\x02\v\xae\x01/\x10,\x03\x05\x03\x06\a\x02\x0f"},
-	{"testing/iotest", "\x03q\x03\x83\x01\x04"},
-	{"testing/quick", "v\x01\x8f\x01\x05#\x10\x11"},
-	{"testing/slogtest", "\rg\x03\x89\x01.\x05\x10\f"},
-	{"testing/synctest", "\xe3\x01`\x12"},
-	{"text/scanner", "\x03t\x83\x01,+\x02"},
-	{"text/tabwriter", "w\x83\x01Y"},
-	{"text/template", "t\x03C@\x01\n \x01\x05\x01\x02\x05\v\x02\x0e\x03\x02"},
-	{"text/template/parse", "\x03t\xbc\x01\n\x01\x13\x02"},
-	{"time", "t+\x1e$(*\r\x02\x13"},
-	{"time/tzdata", "t\xce\x01\x13"},
-	{"unicode", ""},
-	{"unicode/utf16", ""},
-	{"unicode/utf8", ""},
-	{"unique", "\x9b\x01!%\x01Q\r\x01\x14\x12"},
-	{"unsafe", ""},
-	{"vendor/golang.org/x/crypto/chacha20", "\x10]\a\x95\x01*'"},
-	{"vendor/golang.org/x/crypto/chacha20poly1305", "\x10\aV\a\xe2\x01\x04\x01\a"},
-	{"vendor/golang.org/x/crypto/cryptobyte", "j\n\x03\x90\x01'!\n"},
-	{"vendor/golang.org/x/crypto/cryptobyte/asn1", ""},
-	{"vendor/golang.org/x/crypto/internal/alias", "\xd5\x02"},
-	{"vendor/golang.org/x/crypto/internal/poly1305", "X\x15\x9c\x01"},
-	{"vendor/golang.org/x/net/dns/dnsmessage", "t\xc7\x01"},
-	{"vendor/golang.org/x/net/http/httpguts", "\x90\x02\x14\x1a\x15\r"},
-	{"vendor/golang.org/x/net/http/httpproxy", "t\x03\x99\x01\x10\x05\x01\x18\x15\r"},
-	{"vendor/golang.org/x/net/http2/hpack", "\x03q\x03\x83\x01F"},
-	{"vendor/golang.org/x/net/idna", "w\x8f\x018\x15\x10\x02\x01"},
-	{"vendor/golang.org/x/net/nettest", "\x03j\a\x03\x83\x01\x11\x05\x16\x01\f\n\x01\x02\x02\x01\f"},
-	{"vendor/golang.org/x/sys/cpu", "\xa6\x02\r\n\x01\x17"},
-	{"vendor/golang.org/x/text/secure/bidirule", "t\xdf\x01\x11\x01"},
-	{"vendor/golang.org/x/text/transform", "\x03q\x86\x01Y"},
-	{"vendor/golang.org/x/text/unicode/bidi", "\x03\bl\x87\x01>\x17"},
-	{"vendor/golang.org/x/text/unicode/norm", "m\n\x83\x01F\x13\x11"},
-	{"weak", "\x9b\x01\x98\x01\""},
-}
-
-// bootstrap is the list of bootstrap packages extracted from cmd/dist.
-var bootstrap = map[string]bool{
-	"cmp":                                     true,
-	"cmd/asm":                                 true,
-	"cmd/asm/internal/arch":                   true,
-	"cmd/asm/internal/asm":                    true,
-	"cmd/asm/internal/flags":                  true,
-	"cmd/asm/internal/lex":                    true,
-	"cmd/cgo":                                 true,
-	"cmd/compile":                             true,
-	"cmd/compile/internal/abi":                true,
-	"cmd/compile/internal/abt":                true,
-	"cmd/compile/internal/amd64":              true,
-	"cmd/compile/internal/arm":                true,
-	"cmd/compile/internal/arm64":              true,
-	"cmd/compile/internal/base":               true,
-	"cmd/compile/internal/bitvec":             true,
-	"cmd/compile/internal/bloop":              true,
-	"cmd/compile/internal/compare":            true,
-	"cmd/compile/internal/coverage":           true,
-	"cmd/compile/internal/deadlocals":         true,
-	"cmd/compile/internal/devirtualize":       true,
-	"cmd/compile/internal/dwarfgen":           true,
-	"cmd/compile/internal/escape":             true,
-	"cmd/compile/internal/gc":                 true,
-	"cmd/compile/internal/importer":           true,
-	"cmd/compile/internal/inline":             true,
-	"cmd/compile/internal/inline/inlheur":     true,
-	"cmd/compile/internal/inline/interleaved": true,
-	"cmd/compile/internal/ir":                 true,
-	"cmd/compile/internal/liveness":           true,
-	"cmd/compile/internal/logopt":             true,
-	"cmd/compile/internal/loong64":            true,
-	"cmd/compile/internal/loopvar":            true,
-	"cmd/compile/internal/mips":               true,
-	"cmd/compile/internal/mips64":             true,
-	"cmd/compile/internal/noder":              true,
-	"cmd/compile/internal/objw":               true,
-	"cmd/compile/internal/pgoir":              true,
-	"cmd/compile/internal/pkginit":            true,
-	"cmd/compile/internal/ppc64":              true,
-	"cmd/compile/internal/rangefunc":          true,
-	"cmd/compile/internal/reflectdata":        true,
-	"cmd/compile/internal/riscv64":            true,
-	"cmd/compile/internal/rttype":             true,
-	"cmd/compile/internal/s390x":              true,
-	"cmd/compile/internal/slice":              true,
-	"cmd/compile/internal/ssa":                true,
-	"cmd/compile/internal/ssagen":             true,
-	"cmd/compile/internal/staticdata":         true,
-	"cmd/compile/internal/staticinit":         true,
-	"cmd/compile/internal/syntax":             true,
-	"cmd/compile/internal/test":               true,
-	"cmd/compile/internal/typebits":           true,
-	"cmd/compile/internal/typecheck":          true,
-	"cmd/compile/internal/types":              true,
-	"cmd/compile/internal/types2":             true,
-	"cmd/compile/internal/walk":               true,
-	"cmd/compile/internal/wasm":               true,
-	"cmd/compile/internal/x86":                true,
-	"cmd/internal/archive":                    true,
-	"cmd/internal/bio":                        true,
-	"cmd/internal/codesign":                   true,
-	"cmd/internal/dwarf":                      true,
-	"cmd/internal/edit":                       true,
-	"cmd/internal/gcprog":                     true,
-	"cmd/internal/goobj":                      true,
-	"cmd/internal/hash":                       true,
-	"cmd/internal/macho":                      true,
-	"cmd/internal/obj":                        true,
-	"cmd/internal/obj/arm":                    true,
-	"cmd/internal/obj/arm64":                  true,
-	"cmd/internal/obj/loong64":                true,
-	"cmd/internal/obj/mips":                   true,
-	"cmd/internal/obj/ppc64":                  true,
-	"cmd/internal/obj/riscv":                  true,
-	"cmd/internal/obj/s390x":                  true,
-	"cmd/internal/obj/wasm":                   true,
-	"cmd/internal/obj/x86":                    true,
-	"cmd/internal/objabi":                     true,
-	"cmd/internal/par":                        true,
-	"cmd/internal/pgo":                        true,
-	"cmd/internal/pkgpath":                    true,
-	"cmd/internal/quoted":                     true,
-	"cmd/internal/src":                        true,
-	"cmd/internal/sys":                        true,
-	"cmd/internal/telemetry":                  true,
-	"cmd/internal/telemetry/counter":          true,
-	"cmd/link":                                true,
-	"cmd/link/internal/amd64":                 true,
-	"cmd/link/internal/arm":                   true,
-	"cmd/link/internal/arm64":                 true,
-	"cmd/link/internal/benchmark":             true,
-	"cmd/link/internal/dwtest":                true,
-	"cmd/link/internal/ld":                    true,
-	"cmd/link/internal/loadelf":               true,
-	"cmd/link/internal/loader":                true,
-	"cmd/link/internal/loadmacho":             true,
-	"cmd/link/internal/loadpe":                true,
-	"cmd/link/internal/loadxcoff":             true,
-	"cmd/link/internal/loong64":               true,
-	"cmd/link/internal/mips":                  true,
-	"cmd/link/internal/mips64":                true,
-	"cmd/link/internal/ppc64":                 true,
-	"cmd/link/internal/riscv64":               true,
-	"cmd/link/internal/s390x":                 true,
-	"cmd/link/internal/sym":                   true,
-	"cmd/link/internal/wasm":                  true,
-	"cmd/link/internal/x86":                   true,
-	"compress/flate":                          true,
-	"compress/zlib":                           true,
-	"container/heap":                          true,
-	"debug/dwarf":                             true,
-	"debug/elf":                               true,
-	"debug/macho":                             true,
-	"debug/pe":                                true,
-	"go/build/constraint":                     true,
-	"go/constant":                             true,
-	"go/version":                              true,
-	"internal/abi":                            true,
-	"internal/coverage":                       true,
-	"cmd/internal/cov/covcmd":                 true,
-	"internal/bisect":                         true,
-	"internal/buildcfg":                       true,
-	"internal/exportdata":                     true,
-	"internal/goarch":                         true,
-	"internal/godebugs":                       true,
-	"internal/goexperiment":                   true,
-	"internal/goroot":                         true,
-	"internal/gover":                          true,
-	"internal/goversion":                      true,
-	"internal/lazyregexp":                     true,
-	"internal/pkgbits":                        true,
-	"internal/platform":                       true,
-	"internal/profile":                        true,
-	"internal/race":                           true,
-	"internal/runtime/gc":                     true,
-	"internal/saferio":                        true,
-	"internal/syscall/unix":                   true,
-	"internal/types/errors":                   true,
-	"internal/unsafeheader":                   true,
-	"internal/xcoff":                          true,
-	"internal/zstd":                           true,
-	"math/bits":                               true,
-	"sort":                                    true,
-}
-
-// BootstrapVersion is the minor version of Go used during toolchain
-// bootstrapping. Packages for which [IsBootstrapPackage] must not use
-// features of Go newer than this version.
-const BootstrapVersion = Version(24) // go1.24.6
diff --git a/vendor/golang.org/x/tools/internal/stdlib/import.go b/vendor/golang.org/x/tools/internal/stdlib/import.go
deleted file mode 100644
index 8ecc672b8b..0000000000
--- a/vendor/golang.org/x/tools/internal/stdlib/import.go
+++ /dev/null
@@ -1,97 +0,0 @@
-// Copyright 2025 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package stdlib
-
-// This file provides the API for the import graph of the standard library.
-//
-// Be aware that the compiler-generated code for every package
-// implicitly depends on package "runtime" and a handful of others
-// (see runtimePkgs in GOROOT/src/cmd/internal/objabi/pkgspecial.go).
-
-import (
-	"encoding/binary"
-	"iter"
-	"slices"
-	"strings"
-)
-
-// Imports returns the sequence of packages directly imported by the
-// named standard packages, in name order.
-// The imports of an unknown package are the empty set.
-//
-// The graph is built into the application and may differ from the
-// graph in the Go source tree being analyzed by the application.
-func Imports(pkgs ...string) iter.Seq[string] {
-	return func(yield func(string) bool) {
-		for _, pkg := range pkgs {
-			if i, ok := find(pkg); ok {
-				var depIndex uint64
-				for data := []byte(deps[i].deps); len(data) > 0; {
-					delta, n := binary.Uvarint(data)
-					depIndex += delta
-					if !yield(deps[depIndex].name) {
-						return
-					}
-					data = data[n:]
-				}
-			}
-		}
-	}
-}
-
-// Dependencies returns the set of all dependencies of the named
-// standard packages, including the initial package,
-// in a deterministic topological order.
-// The dependencies of an unknown package are the empty set.
-//
-// The graph is built into the application and may differ from the
-// graph in the Go source tree being analyzed by the application.
-func Dependencies(pkgs ...string) iter.Seq[string] {
-	return func(yield func(string) bool) {
-		for _, pkg := range pkgs {
-			if i, ok := find(pkg); ok {
-				var seen [1 + len(deps)/8]byte // bit set of seen packages
-				var visit func(i int) bool
-				visit = func(i int) bool {
-					bit := byte(1) << (i % 8)
-					if seen[i/8]&bit == 0 {
-						seen[i/8] |= bit
-						var depIndex uint64
-						for data := []byte(deps[i].deps); len(data) > 0; {
-							delta, n := binary.Uvarint(data)
-							depIndex += delta
-							if !visit(int(depIndex)) {
-								return false
-							}
-							data = data[n:]
-						}
-						if !yield(deps[i].name) {
-							return false
-						}
-					}
-					return true
-				}
-				if !visit(i) {
-					return
-				}
-			}
-		}
-	}
-}
-
-// find returns the index of pkg in the deps table.
-func find(pkg string) (int, bool) {
-	return slices.BinarySearchFunc(deps[:], pkg, func(p pkginfo, n string) int {
-		return strings.Compare(p.name, n)
-	})
-}
-
-// IsBootstrapPackage reports whether pkg is one of the low-level
-// packages in the Go distribution that must compile with the older
-// language version specified by [BootstrapVersion] during toolchain
-// bootstrapping; see golang.org/s/go15bootstrap.
-func IsBootstrapPackage(pkg string) bool {
-	return bootstrap[pkg]
-}
diff --git a/vendor/golang.org/x/tools/internal/stdlib/manifest.go b/vendor/golang.org/x/tools/internal/stdlib/manifest.go
deleted file mode 100644
index 33e4f505f3..0000000000
--- a/vendor/golang.org/x/tools/internal/stdlib/manifest.go
+++ /dev/null
@@ -1,18328 +0,0 @@
-// Copyright 2025 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by generate.go. DO NOT EDIT.
-
-package stdlib
-
-var PackageSymbols = map[string][]Symbol{
-	"archive/tar": {
-		{"(*Header).FileInfo", Method, 1, ""},
-		{"(*Reader).Next", Method, 0, ""},
-		{"(*Reader).Read", Method, 0, ""},
-		{"(*Writer).AddFS", Method, 22, ""},
-		{"(*Writer).Close", Method, 0, ""},
-		{"(*Writer).Flush", Method, 0, ""},
-		{"(*Writer).Write", Method, 0, ""},
-		{"(*Writer).WriteHeader", Method, 0, ""},
-		{"(FileInfoNames).Gname", Method, 23, ""},
-		{"(FileInfoNames).IsDir", Method, 23, ""},
-		{"(FileInfoNames).ModTime", Method, 23, ""},
-		{"(FileInfoNames).Mode", Method, 23, ""},
-		{"(FileInfoNames).Name", Method, 23, ""},
-		{"(FileInfoNames).Size", Method, 23, ""},
-		{"(FileInfoNames).Sys", Method, 23, ""},
-		{"(FileInfoNames).Uname", Method, 23, ""},
-		{"(Format).String", Method, 10, ""},
-		{"ErrFieldTooLong", Var, 0, ""},
-		{"ErrHeader", Var, 0, ""},
-		{"ErrInsecurePath", Var, 20, ""},
-		{"ErrWriteAfterClose", Var, 0, ""},
-		{"ErrWriteTooLong", Var, 0, ""},
-		{"FileInfoHeader", Func, 1, "func(fi fs.FileInfo, link string) (*Header, error)"},
-		{"FileInfoNames", Type, 23, ""},
-		{"Format", Type, 10, ""},
-		{"FormatGNU", Const, 10, ""},
-		{"FormatPAX", Const, 10, ""},
-		{"FormatUSTAR", Const, 10, ""},
-		{"FormatUnknown", Const, 10, ""},
-		{"Header", Type, 0, ""},
-		{"Header.AccessTime", Field, 0, ""},
-		{"Header.ChangeTime", Field, 0, ""},
-		{"Header.Devmajor", Field, 0, ""},
-		{"Header.Devminor", Field, 0, ""},
-		{"Header.Format", Field, 10, ""},
-		{"Header.Gid", Field, 0, ""},
-		{"Header.Gname", Field, 0, ""},
-		{"Header.Linkname", Field, 0, ""},
-		{"Header.ModTime", Field, 0, ""},
-		{"Header.Mode", Field, 0, ""},
-		{"Header.Name", Field, 0, ""},
-		{"Header.PAXRecords", Field, 10, ""},
-		{"Header.Size", Field, 0, ""},
-		{"Header.Typeflag", Field, 0, ""},
-		{"Header.Uid", Field, 0, ""},
-		{"Header.Uname", Field, 0, ""},
-		{"Header.Xattrs", Field, 3, ""},
-		{"NewReader", Func, 0, "func(r io.Reader) *Reader"},
-		{"NewWriter", Func, 0, "func(w io.Writer) *Writer"},
-		{"Reader", Type, 0, ""},
-		{"TypeBlock", Const, 0, ""},
-		{"TypeChar", Const, 0, ""},
-		{"TypeCont", Const, 0, ""},
-		{"TypeDir", Const, 0, ""},
-		{"TypeFifo", Const, 0, ""},
-		{"TypeGNULongLink", Const, 1, ""},
-		{"TypeGNULongName", Const, 1, ""},
-		{"TypeGNUSparse", Const, 3, ""},
-		{"TypeLink", Const, 0, ""},
-		{"TypeReg", Const, 0, ""},
-		{"TypeRegA", Const, 0, ""},
-		{"TypeSymlink", Const, 0, ""},
-		{"TypeXGlobalHeader", Const, 0, ""},
-		{"TypeXHeader", Const, 0, ""},
-		{"Writer", Type, 0, ""},
-	},
-	"archive/zip": {
-		{"(*File).DataOffset", Method, 2, ""},
-		{"(*File).FileInfo", Method, 0, ""},
-		{"(*File).ModTime", Method, 0, ""},
-		{"(*File).Mode", Method, 0, ""},
-		{"(*File).Open", Method, 0, ""},
-		{"(*File).OpenRaw", Method, 17, ""},
-		{"(*File).SetModTime", Method, 0, ""},
-		{"(*File).SetMode", Method, 0, ""},
-		{"(*FileHeader).FileInfo", Method, 0, ""},
-		{"(*FileHeader).ModTime", Method, 0, ""},
-		{"(*FileHeader).Mode", Method, 0, ""},
-		{"(*FileHeader).SetModTime", Method, 0, ""},
-		{"(*FileHeader).SetMode", Method, 0, ""},
-		{"(*ReadCloser).Close", Method, 0, ""},
-		{"(*ReadCloser).Open", Method, 16, ""},
-		{"(*ReadCloser).RegisterDecompressor", Method, 6, ""},
-		{"(*Reader).Open", Method, 16, ""},
-		{"(*Reader).RegisterDecompressor", Method, 6, ""},
-		{"(*Writer).AddFS", Method, 22, ""},
-		{"(*Writer).Close", Method, 0, ""},
-		{"(*Writer).Copy", Method, 17, ""},
-		{"(*Writer).Create", Method, 0, ""},
-		{"(*Writer).CreateHeader", Method, 0, ""},
-		{"(*Writer).CreateRaw", Method, 17, ""},
-		{"(*Writer).Flush", Method, 4, ""},
-		{"(*Writer).RegisterCompressor", Method, 6, ""},
-		{"(*Writer).SetComment", Method, 10, ""},
-		{"(*Writer).SetOffset", Method, 5, ""},
-		{"Compressor", Type, 2, ""},
-		{"Decompressor", Type, 2, ""},
-		{"Deflate", Const, 0, ""},
-		{"ErrAlgorithm", Var, 0, ""},
-		{"ErrChecksum", Var, 0, ""},
-		{"ErrFormat", Var, 0, ""},
-		{"ErrInsecurePath", Var, 20, ""},
-		{"File", Type, 0, ""},
-		{"File.FileHeader", Field, 0, ""},
-		{"FileHeader", Type, 0, ""},
-		{"FileHeader.CRC32", Field, 0, ""},
-		{"FileHeader.Comment", Field, 0, ""},
-		{"FileHeader.CompressedSize", Field, 0, ""},
-		{"FileHeader.CompressedSize64", Field, 1, ""},
-		{"FileHeader.CreatorVersion", Field, 0, ""},
-		{"FileHeader.ExternalAttrs", Field, 0, ""},
-		{"FileHeader.Extra", Field, 0, ""},
-		{"FileHeader.Flags", Field, 0, ""},
-		{"FileHeader.Method", Field, 0, ""},
-		{"FileHeader.Modified", Field, 10, ""},
-		{"FileHeader.ModifiedDate", Field, 0, ""},
-		{"FileHeader.ModifiedTime", Field, 0, ""},
-		{"FileHeader.Name", Field, 0, ""},
-		{"FileHeader.NonUTF8", Field, 10, ""},
-		{"FileHeader.ReaderVersion", Field, 0, ""},
-		{"FileHeader.UncompressedSize", Field, 0, ""},
-		{"FileHeader.UncompressedSize64", Field, 1, ""},
-		{"FileInfoHeader", Func, 0, "func(fi fs.FileInfo) (*FileHeader, error)"},
-		{"NewReader", Func, 0, "func(r io.ReaderAt, size int64) (*Reader, error)"},
-		{"NewWriter", Func, 0, "func(w io.Writer) *Writer"},
-		{"OpenReader", Func, 0, "func(name string) (*ReadCloser, error)"},
-		{"ReadCloser", Type, 0, ""},
-		{"ReadCloser.Reader", Field, 0, ""},
-		{"Reader", Type, 0, ""},
-		{"Reader.Comment", Field, 0, ""},
-		{"Reader.File", Field, 0, ""},
-		{"RegisterCompressor", Func, 2, "func(method uint16, comp Compressor)"},
-		{"RegisterDecompressor", Func, 2, "func(method uint16, dcomp Decompressor)"},
-		{"Store", Const, 0, ""},
-		{"Writer", Type, 0, ""},
-	},
-	"bufio": {
-		{"(*Reader).Buffered", Method, 0, ""},
-		{"(*Reader).Discard", Method, 5, ""},
-		{"(*Reader).Peek", Method, 0, ""},
-		{"(*Reader).Read", Method, 0, ""},
-		{"(*Reader).ReadByte", Method, 0, ""},
-		{"(*Reader).ReadBytes", Method, 0, ""},
-		{"(*Reader).ReadLine", Method, 0, ""},
-		{"(*Reader).ReadRune", Method, 0, ""},
-		{"(*Reader).ReadSlice", Method, 0, ""},
-		{"(*Reader).ReadString", Method, 0, ""},
-		{"(*Reader).Reset", Method, 2, ""},
-		{"(*Reader).Size", Method, 10, ""},
-		{"(*Reader).UnreadByte", Method, 0, ""},
-		{"(*Reader).UnreadRune", Method, 0, ""},
-		{"(*Reader).WriteTo", Method, 1, ""},
-		{"(*Scanner).Buffer", Method, 6, ""},
-		{"(*Scanner).Bytes", Method, 1, ""},
-		{"(*Scanner).Err", Method, 1, ""},
-		{"(*Scanner).Scan", Method, 1, ""},
-		{"(*Scanner).Split", Method, 1, ""},
-		{"(*Scanner).Text", Method, 1, ""},
-		{"(*Writer).Available", Method, 0, ""},
-		{"(*Writer).AvailableBuffer", Method, 18, ""},
-		{"(*Writer).Buffered", Method, 0, ""},
-		{"(*Writer).Flush", Method, 0, ""},
-		{"(*Writer).ReadFrom", Method, 1, ""},
-		{"(*Writer).Reset", Method, 2, ""},
-		{"(*Writer).Size", Method, 10, ""},
-		{"(*Writer).Write", Method, 0, ""},
-		{"(*Writer).WriteByte", Method, 0, ""},
-		{"(*Writer).WriteRune", Method, 0, ""},
-		{"(*Writer).WriteString", Method, 0, ""},
-		{"(ReadWriter).Available", Method, 0, ""},
-		{"(ReadWriter).AvailableBuffer", Method, 18, ""},
-		{"(ReadWriter).Discard", Method, 5, ""},
-		{"(ReadWriter).Flush", Method, 0, ""},
-		{"(ReadWriter).Peek", Method, 0, ""},
-		{"(ReadWriter).Read", Method, 0, ""},
-		{"(ReadWriter).ReadByte", Method, 0, ""},
-		{"(ReadWriter).ReadBytes", Method, 0, ""},
-		{"(ReadWriter).ReadFrom", Method, 1, ""},
-		{"(ReadWriter).ReadLine", Method, 0, ""},
-		{"(ReadWriter).ReadRune", Method, 0, ""},
-		{"(ReadWriter).ReadSlice", Method, 0, ""},
-		{"(ReadWriter).ReadString", Method, 0, ""},
-		{"(ReadWriter).UnreadByte", Method, 0, ""},
-		{"(ReadWriter).UnreadRune", Method, 0, ""},
-		{"(ReadWriter).Write", Method, 0, ""},
-		{"(ReadWriter).WriteByte", Method, 0, ""},
-		{"(ReadWriter).WriteRune", Method, 0, ""},
-		{"(ReadWriter).WriteString", Method, 0, ""},
-		{"(ReadWriter).WriteTo", Method, 1, ""},
-		{"ErrAdvanceTooFar", Var, 1, ""},
-		{"ErrBadReadCount", Var, 15, ""},
-		{"ErrBufferFull", Var, 0, ""},
-		{"ErrFinalToken", Var, 6, ""},
-		{"ErrInvalidUnreadByte", Var, 0, ""},
-		{"ErrInvalidUnreadRune", Var, 0, ""},
-		{"ErrNegativeAdvance", Var, 1, ""},
-		{"ErrNegativeCount", Var, 0, ""},
-		{"ErrTooLong", Var, 1, ""},
-		{"MaxScanTokenSize", Const, 1, ""},
-		{"NewReadWriter", Func, 0, "func(r *Reader, w *Writer) *ReadWriter"},
-		{"NewReader", Func, 0, "func(rd io.Reader) *Reader"},
-		{"NewReaderSize", Func, 0, "func(rd io.Reader, size int) *Reader"},
-		{"NewScanner", Func, 1, "func(r io.Reader) *Scanner"},
-		{"NewWriter", Func, 0, "func(w io.Writer) *Writer"},
-		{"NewWriterSize", Func, 0, "func(w io.Writer, size int) *Writer"},
-		{"ReadWriter", Type, 0, ""},
-		{"ReadWriter.Reader", Field, 0, ""},
-		{"ReadWriter.Writer", Field, 0, ""},
-		{"Reader", Type, 0, ""},
-		{"ScanBytes", Func, 1, "func(data []byte, atEOF bool) (advance int, token []byte, err error)"},
-		{"ScanLines", Func, 1, "func(data []byte, atEOF bool) (advance int, token []byte, err error)"},
-		{"ScanRunes", Func, 1, "func(data []byte, atEOF bool) (advance int, token []byte, err error)"},
-		{"ScanWords", Func, 1, "func(data []byte, atEOF bool) (advance int, token []byte, err error)"},
-		{"Scanner", Type, 1, ""},
-		{"SplitFunc", Type, 1, ""},
-		{"Writer", Type, 0, ""},
-	},
-	"bytes": {
-		{"(*Buffer).Available", Method, 21, ""},
-		{"(*Buffer).AvailableBuffer", Method, 21, ""},
-		{"(*Buffer).Bytes", Method, 0, ""},
-		{"(*Buffer).Cap", Method, 5, ""},
-		{"(*Buffer).Grow", Method, 1, ""},
-		{"(*Buffer).Len", Method, 0, ""},
-		{"(*Buffer).Next", Method, 0, ""},
-		{"(*Buffer).Peek", Method, 26, ""},
-		{"(*Buffer).Read", Method, 0, ""},
-		{"(*Buffer).ReadByte", Method, 0, ""},
-		{"(*Buffer).ReadBytes", Method, 0, ""},
-		{"(*Buffer).ReadFrom", Method, 0, ""},
-		{"(*Buffer).ReadRune", Method, 0, ""},
-		{"(*Buffer).ReadString", Method, 0, ""},
-		{"(*Buffer).Reset", Method, 0, ""},
-		{"(*Buffer).String", Method, 0, ""},
-		{"(*Buffer).Truncate", Method, 0, ""},
-		{"(*Buffer).UnreadByte", Method, 0, ""},
-		{"(*Buffer).UnreadRune", Method, 0, ""},
-		{"(*Buffer).Write", Method, 0, ""},
-		{"(*Buffer).WriteByte", Method, 0, ""},
-		{"(*Buffer).WriteRune", Method, 0, ""},
-		{"(*Buffer).WriteString", Method, 0, ""},
-		{"(*Buffer).WriteTo", Method, 0, ""},
-		{"(*Reader).Len", Method, 0, ""},
-		{"(*Reader).Read", Method, 0, ""},
-		{"(*Reader).ReadAt", Method, 0, ""},
-		{"(*Reader).ReadByte", Method, 0, ""},
-		{"(*Reader).ReadRune", Method, 0, ""},
-		{"(*Reader).Reset", Method, 7, ""},
-		{"(*Reader).Seek", Method, 0, ""},
-		{"(*Reader).Size", Method, 5, ""},
-		{"(*Reader).UnreadByte", Method, 0, ""},
-		{"(*Reader).UnreadRune", Method, 0, ""},
-		{"(*Reader).WriteTo", Method, 1, ""},
-		{"Buffer", Type, 0, ""},
-		{"Clone", Func, 20, "func(b []byte) []byte"},
-		{"Compare", Func, 0, "func(a []byte, b []byte) int"},
-		{"Contains", Func, 0, "func(b []byte, subslice []byte) bool"},
-		{"ContainsAny", Func, 7, "func(b []byte, chars string) bool"},
-		{"ContainsFunc", Func, 21, "func(b []byte, f func(rune) bool) bool"},
-		{"ContainsRune", Func, 7, "func(b []byte, r rune) bool"},
-		{"Count", Func, 0, "func(s []byte, sep []byte) int"},
-		{"Cut", Func, 18, "func(s []byte, sep []byte) (before []byte, after []byte, found bool)"},
-		{"CutPrefix", Func, 20, "func(s []byte, prefix []byte) (after []byte, found bool)"},
-		{"CutSuffix", Func, 20, "func(s []byte, suffix []byte) (before []byte, found bool)"},
-		{"Equal", Func, 0, "func(a []byte, b []byte) bool"},
-		{"EqualFold", Func, 0, "func(s []byte, t []byte) bool"},
-		{"ErrTooLarge", Var, 0, ""},
-		{"Fields", Func, 0, "func(s []byte) [][]byte"},
-		{"FieldsFunc", Func, 0, "func(s []byte, f func(rune) bool) [][]byte"},
-		{"FieldsFuncSeq", Func, 24, "func(s []byte, f func(rune) bool) iter.Seq[[]byte]"},
-		{"FieldsSeq", Func, 24, "func(s []byte) iter.Seq[[]byte]"},
-		{"HasPrefix", Func, 0, "func(s []byte, prefix []byte) bool"},
-		{"HasSuffix", Func, 0, "func(s []byte, suffix []byte) bool"},
-		{"Index", Func, 0, "func(s []byte, sep []byte) int"},
-		{"IndexAny", Func, 0, "func(s []byte, chars string) int"},
-		{"IndexByte", Func, 0, "func(b []byte, c byte) int"},
-		{"IndexFunc", Func, 0, "func(s []byte, f func(r rune) bool) int"},
-		{"IndexRune", Func, 0, "func(s []byte, r rune) int"},
-		{"Join", Func, 0, "func(s [][]byte, sep []byte) []byte"},
-		{"LastIndex", Func, 0, "func(s []byte, sep []byte) int"},
-		{"LastIndexAny", Func, 0, "func(s []byte, chars string) int"},
-		{"LastIndexByte", Func, 5, "func(s []byte, c byte) int"},
-		{"LastIndexFunc", Func, 0, "func(s []byte, f func(r rune) bool) int"},
-		{"Lines", Func, 24, "func(s []byte) iter.Seq[[]byte]"},
-		{"Map", Func, 0, "func(mapping func(r rune) rune, s []byte) []byte"},
-		{"MinRead", Const, 0, ""},
-		{"NewBuffer", Func, 0, "func(buf []byte) *Buffer"},
-		{"NewBufferString", Func, 0, "func(s string) *Buffer"},
-		{"NewReader", Func, 0, "func(b []byte) *Reader"},
-		{"Reader", Type, 0, ""},
-		{"Repeat", Func, 0, "func(b []byte, count int) []byte"},
-		{"Replace", Func, 0, "func(s []byte, old []byte, new []byte, n int) []byte"},
-		{"ReplaceAll", Func, 12, "func(s []byte, old []byte, new []byte) []byte"},
-		{"Runes", Func, 0, "func(s []byte) []rune"},
-		{"Split", Func, 0, "func(s []byte, sep []byte) [][]byte"},
-		{"SplitAfter", Func, 0, "func(s []byte, sep []byte) [][]byte"},
-		{"SplitAfterN", Func, 0, "func(s []byte, sep []byte, n int) [][]byte"},
-		{"SplitAfterSeq", Func, 24, "func(s []byte, sep []byte) iter.Seq[[]byte]"},
-		{"SplitN", Func, 0, "func(s []byte, sep []byte, n int) [][]byte"},
-		{"SplitSeq", Func, 24, "func(s []byte, sep []byte) iter.Seq[[]byte]"},
-		{"Title", Func, 0, "func(s []byte) []byte"},
-		{"ToLower", Func, 0, "func(s []byte) []byte"},
-		{"ToLowerSpecial", Func, 0, "func(c unicode.SpecialCase, s []byte) []byte"},
-		{"ToTitle", Func, 0, "func(s []byte) []byte"},
-		{"ToTitleSpecial", Func, 0, "func(c unicode.SpecialCase, s []byte) []byte"},
-		{"ToUpper", Func, 0, "func(s []byte) []byte"},
-		{"ToUpperSpecial", Func, 0, "func(c unicode.SpecialCase, s []byte) []byte"},
-		{"ToValidUTF8", Func, 13, "func(s []byte, replacement []byte) []byte"},
-		{"Trim", Func, 0, "func(s []byte, cutset string) []byte"},
-		{"TrimFunc", Func, 0, "func(s []byte, f func(r rune) bool) []byte"},
-		{"TrimLeft", Func, 0, "func(s []byte, cutset string) []byte"},
-		{"TrimLeftFunc", Func, 0, "func(s []byte, f func(r rune) bool) []byte"},
-		{"TrimPrefix", Func, 1, "func(s []byte, prefix []byte) []byte"},
-		{"TrimRight", Func, 0, "func(s []byte, cutset string) []byte"},
-		{"TrimRightFunc", Func, 0, "func(s []byte, f func(r rune) bool) []byte"},
-		{"TrimSpace", Func, 0, "func(s []byte) []byte"},
-		{"TrimSuffix", Func, 1, "func(s []byte, suffix []byte) []byte"},
-	},
-	"cmp": {
-		{"Compare", Func, 21, "func[T Ordered](x T, y T) int"},
-		{"Less", Func, 21, "func[T Ordered](x T, y T) bool"},
-		{"Or", Func, 22, "func[T comparable](vals ...T) T"},
-		{"Ordered", Type, 21, ""},
-	},
-	"compress/bzip2": {
-		{"(StructuralError).Error", Method, 0, ""},
-		{"NewReader", Func, 0, "func(r io.Reader) io.Reader"},
-		{"StructuralError", Type, 0, ""},
-	},
-	"compress/flate": {
-		{"(*ReadError).Error", Method, 0, ""},
-		{"(*WriteError).Error", Method, 0, ""},
-		{"(*Writer).Close", Method, 0, ""},
-		{"(*Writer).Flush", Method, 0, ""},
-		{"(*Writer).Reset", Method, 2, ""},
-		{"(*Writer).Write", Method, 0, ""},
-		{"(CorruptInputError).Error", Method, 0, ""},
-		{"(InternalError).Error", Method, 0, ""},
-		{"(Reader).Read", Method, 0, ""},
-		{"(Reader).ReadByte", Method, 0, ""},
-		{"(Resetter).Reset", Method, 4, ""},
-		{"BestCompression", Const, 0, ""},
-		{"BestSpeed", Const, 0, ""},
-		{"CorruptInputError", Type, 0, ""},
-		{"DefaultCompression", Const, 0, ""},
-		{"HuffmanOnly", Const, 7, ""},
-		{"InternalError", Type, 0, ""},
-		{"NewReader", Func, 0, "func(r io.Reader) io.ReadCloser"},
-		{"NewReaderDict", Func, 0, "func(r io.Reader, dict []byte) io.ReadCloser"},
-		{"NewWriter", Func, 0, "func(w io.Writer, level int) (*Writer, error)"},
-		{"NewWriterDict", Func, 0, "func(w io.Writer, level int, dict []byte) (*Writer, error)"},
-		{"NoCompression", Const, 0, ""},
-		{"ReadError", Type, 0, ""},
-		{"ReadError.Err", Field, 0, ""},
-		{"ReadError.Offset", Field, 0, ""},
-		{"Reader", Type, 0, ""},
-		{"Resetter", Type, 4, ""},
-		{"WriteError", Type, 0, ""},
-		{"WriteError.Err", Field, 0, ""},
-		{"WriteError.Offset", Field, 0, ""},
-		{"Writer", Type, 0, ""},
-	},
-	"compress/gzip": {
-		{"(*Reader).Close", Method, 0, ""},
-		{"(*Reader).Multistream", Method, 4, ""},
-		{"(*Reader).Read", Method, 0, ""},
-		{"(*Reader).Reset", Method, 3, ""},
-		{"(*Writer).Close", Method, 0, ""},
-		{"(*Writer).Flush", Method, 1, ""},
-		{"(*Writer).Reset", Method, 2, ""},
-		{"(*Writer).Write", Method, 0, ""},
-		{"BestCompression", Const, 0, ""},
-		{"BestSpeed", Const, 0, ""},
-		{"DefaultCompression", Const, 0, ""},
-		{"ErrChecksum", Var, 0, ""},
-		{"ErrHeader", Var, 0, ""},
-		{"Header", Type, 0, ""},
-		{"Header.Comment", Field, 0, ""},
-		{"Header.Extra", Field, 0, ""},
-		{"Header.ModTime", Field, 0, ""},
-		{"Header.Name", Field, 0, ""},
-		{"Header.OS", Field, 0, ""},
-		{"HuffmanOnly", Const, 8, ""},
-		{"NewReader", Func, 0, "func(r io.Reader) (*Reader, error)"},
-		{"NewWriter", Func, 0, "func(w io.Writer) *Writer"},
-		{"NewWriterLevel", Func, 0, "func(w io.Writer, level int) (*Writer, error)"},
-		{"NoCompression", Const, 0, ""},
-		{"Reader", Type, 0, ""},
-		{"Reader.Header", Field, 0, ""},
-		{"Writer", Type, 0, ""},
-		{"Writer.Header", Field, 0, ""},
-	},
-	"compress/lzw": {
-		{"(*Reader).Close", Method, 17, ""},
-		{"(*Reader).Read", Method, 17, ""},
-		{"(*Reader).Reset", Method, 17, ""},
-		{"(*Writer).Close", Method, 17, ""},
-		{"(*Writer).Reset", Method, 17, ""},
-		{"(*Writer).Write", Method, 17, ""},
-		{"LSB", Const, 0, ""},
-		{"MSB", Const, 0, ""},
-		{"NewReader", Func, 0, "func(r io.Reader, order Order, litWidth int) io.ReadCloser"},
-		{"NewWriter", Func, 0, "func(w io.Writer, order Order, litWidth int) io.WriteCloser"},
-		{"Order", Type, 0, ""},
-		{"Reader", Type, 17, ""},
-		{"Writer", Type, 17, ""},
-	},
-	"compress/zlib": {
-		{"(*Writer).Close", Method, 0, ""},
-		{"(*Writer).Flush", Method, 0, ""},
-		{"(*Writer).Reset", Method, 2, ""},
-		{"(*Writer).Write", Method, 0, ""},
-		{"(Resetter).Reset", Method, 4, ""},
-		{"BestCompression", Const, 0, ""},
-		{"BestSpeed", Const, 0, ""},
-		{"DefaultCompression", Const, 0, ""},
-		{"ErrChecksum", Var, 0, ""},
-		{"ErrDictionary", Var, 0, ""},
-		{"ErrHeader", Var, 0, ""},
-		{"HuffmanOnly", Const, 8, ""},
-		{"NewReader", Func, 0, "func(r io.Reader) (io.ReadCloser, error)"},
-		{"NewReaderDict", Func, 0, "func(r io.Reader, dict []byte) (io.ReadCloser, error)"},
-		{"NewWriter", Func, 0, "func(w io.Writer) *Writer"},
-		{"NewWriterLevel", Func, 0, "func(w io.Writer, level int) (*Writer, error)"},
-		{"NewWriterLevelDict", Func, 0, "func(w io.Writer, level int, dict []byte) (*Writer, error)"},
-		{"NoCompression", Const, 0, ""},
-		{"Resetter", Type, 4, ""},
-		{"Writer", Type, 0, ""},
-	},
-	"container/heap": {
-		{"(Interface).Len", Method, 0, ""},
-		{"(Interface).Less", Method, 0, ""},
-		{"(Interface).Pop", Method, 0, ""},
-		{"(Interface).Push", Method, 0, ""},
-		{"(Interface).Swap", Method, 0, ""},
-		{"Fix", Func, 2, "func(h Interface, i int)"},
-		{"Init", Func, 0, "func(h Interface)"},
-		{"Interface", Type, 0, ""},
-		{"Pop", Func, 0, "func(h Interface) any"},
-		{"Push", Func, 0, "func(h Interface, x any)"},
-		{"Remove", Func, 0, "func(h Interface, i int) any"},
-	},
-	"container/list": {
-		{"(*Element).Next", Method, 0, ""},
-		{"(*Element).Prev", Method, 0, ""},
-		{"(*List).Back", Method, 0, ""},
-		{"(*List).Front", Method, 0, ""},
-		{"(*List).Init", Method, 0, ""},
-		{"(*List).InsertAfter", Method, 0, ""},
-		{"(*List).InsertBefore", Method, 0, ""},
-		{"(*List).Len", Method, 0, ""},
-		{"(*List).MoveAfter", Method, 2, ""},
-		{"(*List).MoveBefore", Method, 2, ""},
-		{"(*List).MoveToBack", Method, 0, ""},
-		{"(*List).MoveToFront", Method, 0, ""},
-		{"(*List).PushBack", Method, 0, ""},
-		{"(*List).PushBackList", Method, 0, ""},
-		{"(*List).PushFront", Method, 0, ""},
-		{"(*List).PushFrontList", Method, 0, ""},
-		{"(*List).Remove", Method, 0, ""},
-		{"Element", Type, 0, ""},
-		{"Element.Value", Field, 0, ""},
-		{"List", Type, 0, ""},
-		{"New", Func, 0, "func() *List"},
-	},
-	"container/ring": {
-		{"(*Ring).Do", Method, 0, ""},
-		{"(*Ring).Len", Method, 0, ""},
-		{"(*Ring).Link", Method, 0, ""},
-		{"(*Ring).Move", Method, 0, ""},
-		{"(*Ring).Next", Method, 0, ""},
-		{"(*Ring).Prev", Method, 0, ""},
-		{"(*Ring).Unlink", Method, 0, ""},
-		{"New", Func, 0, "func(n int) *Ring"},
-		{"Ring", Type, 0, ""},
-		{"Ring.Value", Field, 0, ""},
-	},
-	"context": {
-		{"(Context).Deadline", Method, 7, ""},
-		{"(Context).Done", Method, 7, ""},
-		{"(Context).Err", Method, 7, ""},
-		{"(Context).Value", Method, 7, ""},
-		{"AfterFunc", Func, 21, "func(ctx Context, f func()) (stop func() bool)"},
-		{"Background", Func, 7, "func() Context"},
-		{"CancelCauseFunc", Type, 20, ""},
-		{"CancelFunc", Type, 7, ""},
-		{"Canceled", Var, 7, ""},
-		{"Cause", Func, 20, "func(c Context) error"},
-		{"Context", Type, 7, ""},
-		{"DeadlineExceeded", Var, 7, ""},
-		{"TODO", Func, 7, "func() Context"},
-		{"WithCancel", Func, 7, "func(parent Context) (ctx Context, cancel CancelFunc)"},
-		{"WithCancelCause", Func, 20, "func(parent Context) (ctx Context, cancel CancelCauseFunc)"},
-		{"WithDeadline", Func, 7, "func(parent Context, d time.Time) (Context, CancelFunc)"},
-		{"WithDeadlineCause", Func, 21, "func(parent Context, d time.Time, cause error) (Context, CancelFunc)"},
-		{"WithTimeout", Func, 7, "func(parent Context, timeout time.Duration) (Context, CancelFunc)"},
-		{"WithTimeoutCause", Func, 21, "func(parent Context, timeout time.Duration, cause error) (Context, CancelFunc)"},
-		{"WithValue", Func, 7, "func(parent Context, key any, val any) Context"},
-		{"WithoutCancel", Func, 21, "func(parent Context) Context"},
-	},
-	"crypto": {
-		{"(Decapsulator).Decapsulate", Method, 26, ""},
-		{"(Decapsulator).Encapsulator", Method, 26, ""},
-		{"(Decrypter).Decrypt", Method, 5, ""},
-		{"(Decrypter).Public", Method, 5, ""},
-		{"(Encapsulator).Bytes", Method, 26, ""},
-		{"(Encapsulator).Encapsulate", Method, 26, ""},
-		{"(Hash).Available", Method, 0, ""},
-		{"(Hash).HashFunc", Method, 4, ""},
-		{"(Hash).New", Method, 0, ""},
-		{"(Hash).Size", Method, 0, ""},
-		{"(Hash).String", Method, 15, ""},
-		{"(MessageSigner).Public", Method, 25, ""},
-		{"(MessageSigner).Sign", Method, 25, ""},
-		{"(MessageSigner).SignMessage", Method, 25, ""},
-		{"(Signer).Public", Method, 4, ""},
-		{"(Signer).Sign", Method, 4, ""},
-		{"(SignerOpts).HashFunc", Method, 4, ""},
-		{"BLAKE2b_256", Const, 9, ""},
-		{"BLAKE2b_384", Const, 9, ""},
-		{"BLAKE2b_512", Const, 9, ""},
-		{"BLAKE2s_256", Const, 9, ""},
-		{"Decapsulator", Type, 26, ""},
-		{"Decrypter", Type, 5, ""},
-		{"DecrypterOpts", Type, 5, ""},
-		{"Encapsulator", Type, 26, ""},
-		{"Hash", Type, 0, ""},
-		{"MD4", Const, 0, ""},
-		{"MD5", Const, 0, ""},
-		{"MD5SHA1", Const, 0, ""},
-		{"MessageSigner", Type, 25, ""},
-		{"PrivateKey", Type, 0, ""},
-		{"PublicKey", Type, 2, ""},
-		{"RIPEMD160", Const, 0, ""},
-		{"RegisterHash", Func, 0, "func(h Hash, f func() hash.Hash)"},
-		{"SHA1", Const, 0, ""},
-		{"SHA224", Const, 0, ""},
-		{"SHA256", Const, 0, ""},
-		{"SHA384", Const, 0, ""},
-		{"SHA3_224", Const, 4, ""},
-		{"SHA3_256", Const, 4, ""},
-		{"SHA3_384", Const, 4, ""},
-		{"SHA3_512", Const, 4, ""},
-		{"SHA512", Const, 0, ""},
-		{"SHA512_224", Const, 5, ""},
-		{"SHA512_256", Const, 5, ""},
-		{"SignMessage", Func, 25, "func(signer Signer, rand io.Reader, msg []byte, opts SignerOpts) (signature []byte, err error)"},
-		{"Signer", Type, 4, ""},
-		{"SignerOpts", Type, 4, ""},
-	},
-	"crypto/aes": {
-		{"(KeySizeError).Error", Method, 0, ""},
-		{"BlockSize", Const, 0, ""},
-		{"KeySizeError", Type, 0, ""},
-		{"NewCipher", Func, 0, "func(key []byte) (cipher.Block, error)"},
-	},
-	"crypto/cipher": {
-		{"(AEAD).NonceSize", Method, 2, ""},
-		{"(AEAD).Open", Method, 2, ""},
-		{"(AEAD).Overhead", Method, 2, ""},
-		{"(AEAD).Seal", Method, 2, ""},
-		{"(Block).BlockSize", Method, 0, ""},
-		{"(Block).Decrypt", Method, 0, ""},
-		{"(Block).Encrypt", Method, 0, ""},
-		{"(BlockMode).BlockSize", Method, 0, ""},
-		{"(BlockMode).CryptBlocks", Method, 0, ""},
-		{"(Stream).XORKeyStream", Method, 0, ""},
-		{"(StreamReader).Read", Method, 0, ""},
-		{"(StreamWriter).Close", Method, 0, ""},
-		{"(StreamWriter).Write", Method, 0, ""},
-		{"AEAD", Type, 2, ""},
-		{"Block", Type, 0, ""},
-		{"BlockMode", Type, 0, ""},
-		{"NewCBCDecrypter", Func, 0, "func(b Block, iv []byte) BlockMode"},
-		{"NewCBCEncrypter", Func, 0, "func(b Block, iv []byte) BlockMode"},
-		{"NewCFBDecrypter", Func, 0, "func(block Block, iv []byte) Stream"},
-		{"NewCFBEncrypter", Func, 0, "func(block Block, iv []byte) Stream"},
-		{"NewCTR", Func, 0, "func(block Block, iv []byte) Stream"},
-		{"NewGCM", Func, 2, "func(cipher Block) (AEAD, error)"},
-		{"NewGCMWithNonceSize", Func, 5, "func(cipher Block, size int) (AEAD, error)"},
-		{"NewGCMWithRandomNonce", Func, 24, "func(cipher Block) (AEAD, error)"},
-		{"NewGCMWithTagSize", Func, 11, "func(cipher Block, tagSize int) (AEAD, error)"},
-		{"NewOFB", Func, 0, "func(b Block, iv []byte) Stream"},
-		{"Stream", Type, 0, ""},
-		{"StreamReader", Type, 0, ""},
-		{"StreamReader.R", Field, 0, ""},
-		{"StreamReader.S", Field, 0, ""},
-		{"StreamWriter", Type, 0, ""},
-		{"StreamWriter.Err", Field, 0, ""},
-		{"StreamWriter.S", Field, 0, ""},
-		{"StreamWriter.W", Field, 0, ""},
-	},
-	"crypto/des": {
-		{"(KeySizeError).Error", Method, 0, ""},
-		{"BlockSize", Const, 0, ""},
-		{"KeySizeError", Type, 0, ""},
-		{"NewCipher", Func, 0, "func(key []byte) (cipher.Block, error)"},
-		{"NewTripleDESCipher", Func, 0, "func(key []byte) (cipher.Block, error)"},
-	},
-	"crypto/dsa": {
-		{"ErrInvalidPublicKey", Var, 0, ""},
-		{"GenerateKey", Func, 0, "func(priv *PrivateKey, rand io.Reader) error"},
-		{"GenerateParameters", Func, 0, "func(params *Parameters, rand io.Reader, sizes ParameterSizes) error"},
-		{"L1024N160", Const, 0, ""},
-		{"L2048N224", Const, 0, ""},
-		{"L2048N256", Const, 0, ""},
-		{"L3072N256", Const, 0, ""},
-		{"ParameterSizes", Type, 0, ""},
-		{"Parameters", Type, 0, ""},
-		{"Parameters.G", Field, 0, ""},
-		{"Parameters.P", Field, 0, ""},
-		{"Parameters.Q", Field, 0, ""},
-		{"PrivateKey", Type, 0, ""},
-		{"PrivateKey.PublicKey", Field, 0, ""},
-		{"PrivateKey.X", Field, 0, ""},
-		{"PublicKey", Type, 0, ""},
-		{"PublicKey.Parameters", Field, 0, ""},
-		{"PublicKey.Y", Field, 0, ""},
-		{"Sign", Func, 0, "func(random io.Reader, priv *PrivateKey, hash []byte) (r *big.Int, s *big.Int, err error)"},
-		{"Verify", Func, 0, "func(pub *PublicKey, hash []byte, r *big.Int, s *big.Int) bool"},
-	},
-	"crypto/ecdh": {
-		{"(*PrivateKey).Bytes", Method, 20, ""},
-		{"(*PrivateKey).Curve", Method, 20, ""},
-		{"(*PrivateKey).ECDH", Method, 20, ""},
-		{"(*PrivateKey).Equal", Method, 20, ""},
-		{"(*PrivateKey).Public", Method, 20, ""},
-		{"(*PrivateKey).PublicKey", Method, 20, ""},
-		{"(*PublicKey).Bytes", Method, 20, ""},
-		{"(*PublicKey).Curve", Method, 20, ""},
-		{"(*PublicKey).Equal", Method, 20, ""},
-		{"(Curve).GenerateKey", Method, 20, ""},
-		{"(Curve).NewPrivateKey", Method, 20, ""},
-		{"(Curve).NewPublicKey", Method, 20, ""},
-		{"(KeyExchanger).Curve", Method, 26, ""},
-		{"(KeyExchanger).ECDH", Method, 26, ""},
-		{"(KeyExchanger).PublicKey", Method, 26, ""},
-		{"KeyExchanger", Type, 26, ""},
-		{"P256", Func, 20, "func() Curve"},
-		{"P384", Func, 20, "func() Curve"},
-		{"P521", Func, 20, "func() Curve"},
-		{"PrivateKey", Type, 20, ""},
-		{"PublicKey", Type, 20, ""},
-		{"X25519", Func, 20, "func() Curve"},
-	},
-	"crypto/ecdsa": {
-		{"(*PrivateKey).Bytes", Method, 25, ""},
-		{"(*PrivateKey).ECDH", Method, 20, ""},
-		{"(*PrivateKey).Equal", Method, 15, ""},
-		{"(*PrivateKey).Public", Method, 4, ""},
-		{"(*PrivateKey).Sign", Method, 4, ""},
-		{"(*PublicKey).Bytes", Method, 25, ""},
-		{"(*PublicKey).ECDH", Method, 20, ""},
-		{"(*PublicKey).Equal", Method, 15, ""},
-		{"(PrivateKey).Add", Method, 0, ""},
-		{"(PrivateKey).Double", Method, 0, ""},
-		{"(PrivateKey).IsOnCurve", Method, 0, ""},
-		{"(PrivateKey).Params", Method, 0, ""},
-		{"(PrivateKey).ScalarBaseMult", Method, 0, ""},
-		{"(PrivateKey).ScalarMult", Method, 0, ""},
-		{"(PublicKey).Add", Method, 0, ""},
-		{"(PublicKey).Double", Method, 0, ""},
-		{"(PublicKey).IsOnCurve", Method, 0, ""},
-		{"(PublicKey).Params", Method, 0, ""},
-		{"(PublicKey).ScalarBaseMult", Method, 0, ""},
-		{"(PublicKey).ScalarMult", Method, 0, ""},
-		{"GenerateKey", Func, 0, "func(c elliptic.Curve, r io.Reader) (*PrivateKey, error)"},
-		{"ParseRawPrivateKey", Func, 25, "func(curve elliptic.Curve, data []byte) (*PrivateKey, error)"},
-		{"ParseUncompressedPublicKey", Func, 25, "func(curve elliptic.Curve, data []byte) (*PublicKey, error)"},
-		{"PrivateKey", Type, 0, ""},
-		{"PrivateKey.D", Field, 0, ""},
-		{"PrivateKey.PublicKey", Field, 0, ""},
-		{"PublicKey", Type, 0, ""},
-		{"PublicKey.Curve", Field, 0, ""},
-		{"PublicKey.X", Field, 0, ""},
-		{"PublicKey.Y", Field, 0, ""},
-		{"Sign", Func, 0, "func(rand io.Reader, priv *PrivateKey, hash []byte) (r *big.Int, s *big.Int, err error)"},
-		{"SignASN1", Func, 15, "func(r io.Reader, priv *PrivateKey, hash []byte) ([]byte, error)"},
-		{"Verify", Func, 0, "func(pub *PublicKey, hash []byte, r *big.Int, s *big.Int) bool"},
-		{"VerifyASN1", Func, 15, "func(pub *PublicKey, hash []byte, sig []byte) bool"},
-	},
-	"crypto/ed25519": {
-		{"(*Options).HashFunc", Method, 20, ""},
-		{"(PrivateKey).Equal", Method, 15, ""},
-		{"(PrivateKey).Public", Method, 13, ""},
-		{"(PrivateKey).Seed", Method, 13, ""},
-		{"(PrivateKey).Sign", Method, 13, ""},
-		{"(PublicKey).Equal", Method, 15, ""},
-		{"GenerateKey", Func, 13, "func(random io.Reader) (PublicKey, PrivateKey, error)"},
-		{"NewKeyFromSeed", Func, 13, "func(seed []byte) PrivateKey"},
-		{"Options", Type, 20, ""},
-		{"Options.Context", Field, 20, ""},
-		{"Options.Hash", Field, 20, ""},
-		{"PrivateKey", Type, 13, ""},
-		{"PrivateKeySize", Const, 13, ""},
-		{"PublicKey", Type, 13, ""},
-		{"PublicKeySize", Const, 13, ""},
-		{"SeedSize", Const, 13, ""},
-		{"Sign", Func, 13, "func(privateKey PrivateKey, message []byte) []byte"},
-		{"SignatureSize", Const, 13, ""},
-		{"Verify", Func, 13, "func(publicKey PublicKey, message []byte, sig []byte) bool"},
-		{"VerifyWithOptions", Func, 20, "func(publicKey PublicKey, message []byte, sig []byte, opts *Options) error"},
-	},
-	"crypto/elliptic": {
-		{"(*CurveParams).Add", Method, 0, ""},
-		{"(*CurveParams).Double", Method, 0, ""},
-		{"(*CurveParams).IsOnCurve", Method, 0, ""},
-		{"(*CurveParams).Params", Method, 0, ""},
-		{"(*CurveParams).ScalarBaseMult", Method, 0, ""},
-		{"(*CurveParams).ScalarMult", Method, 0, ""},
-		{"(Curve).Add", Method, 0, ""},
-		{"(Curve).Double", Method, 0, ""},
-		{"(Curve).IsOnCurve", Method, 0, ""},
-		{"(Curve).Params", Method, 0, ""},
-		{"(Curve).ScalarBaseMult", Method, 0, ""},
-		{"(Curve).ScalarMult", Method, 0, ""},
-		{"Curve", Type, 0, ""},
-		{"CurveParams", Type, 0, ""},
-		{"CurveParams.B", Field, 0, ""},
-		{"CurveParams.BitSize", Field, 0, ""},
-		{"CurveParams.Gx", Field, 0, ""},
-		{"CurveParams.Gy", Field, 0, ""},
-		{"CurveParams.N", Field, 0, ""},
-		{"CurveParams.Name", Field, 5, ""},
-		{"CurveParams.P", Field, 0, ""},
-		{"GenerateKey", Func, 0, "func(curve Curve, rand io.Reader) (priv []byte, x *big.Int, y *big.Int, err error)"},
-		{"Marshal", Func, 0, "func(curve Curve, x *big.Int, y *big.Int) []byte"},
-		{"MarshalCompressed", Func, 15, "func(curve Curve, x *big.Int, y *big.Int) []byte"},
-		{"P224", Func, 0, "func() Curve"},
-		{"P256", Func, 0, "func() Curve"},
-		{"P384", Func, 0, "func() Curve"},
-		{"P521", Func, 0, "func() Curve"},
-		{"Unmarshal", Func, 0, "func(curve Curve, data []byte) (x *big.Int, y *big.Int)"},
-		{"UnmarshalCompressed", Func, 15, "func(curve Curve, data []byte) (x *big.Int, y *big.Int)"},
-	},
-	"crypto/fips140": {
-		{"Enabled", Func, 24, "func() bool"},
-		{"Enforced", Func, 26, "func() bool"},
-		{"Version", Func, 26, "func() string"},
-		{"WithoutEnforcement", Func, 26, "func(f func())"},
-	},
-	"crypto/hkdf": {
-		{"Expand", Func, 24, "func[H hash.Hash](h func() H, pseudorandomKey []byte, info string, keyLength int) ([]byte, error)"},
-		{"Extract", Func, 24, "func[H hash.Hash](h func() H, secret []byte, salt []byte) ([]byte, error)"},
-		{"Key", Func, 24, "func[Hash hash.Hash](h func() Hash, secret []byte, salt []byte, info string, keyLength int) ([]byte, error)"},
-	},
-	"crypto/hmac": {
-		{"Equal", Func, 1, "func(mac1 []byte, mac2 []byte) bool"},
-		{"New", Func, 0, "func(h func() hash.Hash, key []byte) hash.Hash"},
-	},
-	"crypto/hpke": {
-		{"(*Recipient).Export", Method, 26, ""},
-		{"(*Recipient).Open", Method, 26, ""},
-		{"(*Sender).Export", Method, 26, ""},
-		{"(*Sender).Seal", Method, 26, ""},
-		{"(AEAD).ID", Method, 26, ""},
-		{"(KDF).ID", Method, 26, ""},
-		{"(KEM).DeriveKeyPair", Method, 26, ""},
-		{"(KEM).GenerateKey", Method, 26, ""},
-		{"(KEM).ID", Method, 26, ""},
-		{"(KEM).NewPrivateKey", Method, 26, ""},
-		{"(KEM).NewPublicKey", Method, 26, ""},
-		{"(PrivateKey).Bytes", Method, 26, ""},
-		{"(PrivateKey).KEM", Method, 26, ""},
-		{"(PrivateKey).PublicKey", Method, 26, ""},
-		{"(PublicKey).Bytes", Method, 26, ""},
-		{"(PublicKey).KEM", Method, 26, ""},
-		{"AES128GCM", Func, 26, "func() AEAD"},
-		{"AES256GCM", Func, 26, "func() AEAD"},
-		{"ChaCha20Poly1305", Func, 26, "func() AEAD"},
-		{"DHKEM", Func, 26, "func(curve ecdh.Curve) KEM"},
-		{"ExportOnly", Func, 26, "func() AEAD"},
-		{"HKDFSHA256", Func, 26, "func() KDF"},
-		{"HKDFSHA384", Func, 26, "func() KDF"},
-		{"HKDFSHA512", Func, 26, "func() KDF"},
-		{"MLKEM1024", Func, 26, "func() KEM"},
-		{"MLKEM1024P384", Func, 26, "func() KEM"},
-		{"MLKEM768", Func, 26, "func() KEM"},
-		{"MLKEM768P256", Func, 26, "func() KEM"},
-		{"MLKEM768X25519", Func, 26, "func() KEM"},
-		{"NewAEAD", Func, 26, "func(id uint16) (AEAD, error)"},
-		{"NewDHKEMPrivateKey", Func, 26, "func(priv ecdh.KeyExchanger) (PrivateKey, error)"},
-		{"NewDHKEMPublicKey", Func, 26, "func(pub *ecdh.PublicKey) (PublicKey, error)"},
-		{"NewHybridPrivateKey", Func, 26, "func(pq crypto.Decapsulator, t ecdh.KeyExchanger) (PrivateKey, error)"},
-		{"NewHybridPublicKey", Func, 26, "func(pq crypto.Encapsulator, t *ecdh.PublicKey) (PublicKey, error)"},
-		{"NewKDF", Func, 26, "func(id uint16) (KDF, error)"},
-		{"NewKEM", Func, 26, "func(id uint16) (KEM, error)"},
-		{"NewMLKEMPrivateKey", Func, 26, "func(priv crypto.Decapsulator) (PrivateKey, error)"},
-		{"NewMLKEMPublicKey", Func, 26, "func(pub crypto.Encapsulator) (PublicKey, error)"},
-		{"NewRecipient", Func, 26, "func(enc []byte, k PrivateKey, kdf KDF, aead AEAD, info []byte) (*Recipient, error)"},
-		{"NewSender", Func, 26, "func(pk PublicKey, kdf KDF, aead AEAD, info []byte) (enc []byte, s *Sender, err error)"},
-		{"Open", Func, 26, "func(k PrivateKey, kdf KDF, aead AEAD, info []byte, ciphertext []byte) ([]byte, error)"},
-		{"Recipient", Type, 26, ""},
-		{"SHAKE128", Func, 26, "func() KDF"},
-		{"SHAKE256", Func, 26, "func() KDF"},
-		{"Seal", Func, 26, "func(pk PublicKey, kdf KDF, aead AEAD, info []byte, plaintext []byte) ([]byte, error)"},
-		{"Sender", Type, 26, ""},
-	},
-	"crypto/md5": {
-		{"BlockSize", Const, 0, ""},
-		{"New", Func, 0, "func() hash.Hash"},
-		{"Size", Const, 0, ""},
-		{"Sum", Func, 2, "func(data []byte) [16]byte"},
-	},
-	"crypto/mlkem": {
-		{"(*DecapsulationKey1024).Bytes", Method, 24, ""},
-		{"(*DecapsulationKey1024).Decapsulate", Method, 24, ""},
-		{"(*DecapsulationKey1024).EncapsulationKey", Method, 24, ""},
-		{"(*DecapsulationKey1024).Encapsulator", Method, 26, ""},
-		{"(*DecapsulationKey768).Bytes", Method, 24, ""},
-		{"(*DecapsulationKey768).Decapsulate", Method, 24, ""},
-		{"(*DecapsulationKey768).EncapsulationKey", Method, 24, ""},
-		{"(*DecapsulationKey768).Encapsulator", Method, 26, ""},
-		{"(*EncapsulationKey1024).Bytes", Method, 24, ""},
-		{"(*EncapsulationKey1024).Encapsulate", Method, 24, ""},
-		{"(*EncapsulationKey768).Bytes", Method, 24, ""},
-		{"(*EncapsulationKey768).Encapsulate", Method, 24, ""},
-		{"CiphertextSize1024", Const, 24, ""},
-		{"CiphertextSize768", Const, 24, ""},
-		{"DecapsulationKey1024", Type, 24, ""},
-		{"DecapsulationKey768", Type, 24, ""},
-		{"EncapsulationKey1024", Type, 24, ""},
-		{"EncapsulationKey768", Type, 24, ""},
-		{"EncapsulationKeySize1024", Const, 24, ""},
-		{"EncapsulationKeySize768", Const, 24, ""},
-		{"GenerateKey1024", Func, 24, "func() (*DecapsulationKey1024, error)"},
-		{"GenerateKey768", Func, 24, "func() (*DecapsulationKey768, error)"},
-		{"NewDecapsulationKey1024", Func, 24, "func(seed []byte) (*DecapsulationKey1024, error)"},
-		{"NewDecapsulationKey768", Func, 24, "func(seed []byte) (*DecapsulationKey768, error)"},
-		{"NewEncapsulationKey1024", Func, 24, "func(encapsulationKey []byte) (*EncapsulationKey1024, error)"},
-		{"NewEncapsulationKey768", Func, 24, "func(encapsulationKey []byte) (*EncapsulationKey768, error)"},
-		{"SeedSize", Const, 24, ""},
-		{"SharedKeySize", Const, 24, ""},
-	},
-	"crypto/mlkem/mlkemtest": {
-		{"Encapsulate1024", Func, 26, "func(ek *mlkem.EncapsulationKey1024, random []byte) (sharedKey []byte, ciphertext []byte, err error)"},
-		{"Encapsulate768", Func, 26, "func(ek *mlkem.EncapsulationKey768, random []byte) (sharedKey []byte, ciphertext []byte, err error)"},
-	},
-	"crypto/pbkdf2": {
-		{"Key", Func, 24, "func[Hash hash.Hash](h func() Hash, password string, salt []byte, iter int, keyLength int) ([]byte, error)"},
-	},
-	"crypto/rand": {
-		{"Int", Func, 0, "func(rand io.Reader, max *big.Int) (n *big.Int, err error)"},
-		{"Prime", Func, 0, "func(r io.Reader, bits int) (*big.Int, error)"},
-		{"Read", Func, 0, "func(b []byte) (n int, err error)"},
-		{"Reader", Var, 0, ""},
-		{"Text", Func, 24, "func() string"},
-	},
-	"crypto/rc4": {
-		{"(*Cipher).Reset", Method, 0, ""},
-		{"(*Cipher).XORKeyStream", Method, 0, ""},
-		{"(KeySizeError).Error", Method, 0, ""},
-		{"Cipher", Type, 0, ""},
-		{"KeySizeError", Type, 0, ""},
-		{"NewCipher", Func, 0, "func(key []byte) (*Cipher, error)"},
-	},
-	"crypto/rsa": {
-		{"(*PSSOptions).HashFunc", Method, 4, ""},
-		{"(*PrivateKey).Decrypt", Method, 5, ""},
-		{"(*PrivateKey).Equal", Method, 15, ""},
-		{"(*PrivateKey).Precompute", Method, 0, ""},
-		{"(*PrivateKey).Public", Method, 4, ""},
-		{"(*PrivateKey).Sign", Method, 4, ""},
-		{"(*PrivateKey).Size", Method, 11, ""},
-		{"(*PrivateKey).Validate", Method, 0, ""},
-		{"(*PublicKey).Equal", Method, 15, ""},
-		{"(*PublicKey).Size", Method, 11, ""},
-		{"CRTValue", Type, 0, ""},
-		{"CRTValue.Coeff", Field, 0, ""},
-		{"CRTValue.Exp", Field, 0, ""},
-		{"CRTValue.R", Field, 0, ""},
-		{"DecryptOAEP", Func, 0, "func(hash hash.Hash, random io.Reader, priv *PrivateKey, ciphertext []byte, label []byte) ([]byte, error)"},
-		{"DecryptPKCS1v15", Func, 0, "func(random io.Reader, priv *PrivateKey, ciphertext []byte) ([]byte, error)"},
-		{"DecryptPKCS1v15SessionKey", Func, 0, "func(random io.Reader, priv *PrivateKey, ciphertext []byte, key []byte) error"},
-		{"EncryptOAEP", Func, 0, "func(hash hash.Hash, random io.Reader, pub *PublicKey, msg []byte, label []byte) ([]byte, error)"},
-		{"EncryptOAEPWithOptions", Func, 26, "func(random io.Reader, pub *PublicKey, msg []byte, opts *OAEPOptions) ([]byte, error)"},
-		{"EncryptPKCS1v15", Func, 0, "func(random io.Reader, pub *PublicKey, msg []byte) ([]byte, error)"},
-		{"ErrDecryption", Var, 0, ""},
-		{"ErrMessageTooLong", Var, 0, ""},
-		{"ErrVerification", Var, 0, ""},
-		{"GenerateKey", Func, 0, "func(random io.Reader, bits int) (*PrivateKey, error)"},
-		{"GenerateMultiPrimeKey", Func, 0, "func(random io.Reader, nprimes int, bits int) (*PrivateKey, error)"},
-		{"OAEPOptions", Type, 5, ""},
-		{"OAEPOptions.Hash", Field, 5, ""},
-		{"OAEPOptions.Label", Field, 5, ""},
-		{"OAEPOptions.MGFHash", Field, 20, ""},
-		{"PKCS1v15DecryptOptions", Type, 5, ""},
-		{"PKCS1v15DecryptOptions.SessionKeyLen", Field, 5, ""},
-		{"PSSOptions", Type, 2, ""},
-		{"PSSOptions.Hash", Field, 4, ""},
-		{"PSSOptions.SaltLength", Field, 2, ""},
-		{"PSSSaltLengthAuto", Const, 2, ""},
-		{"PSSSaltLengthEqualsHash", Const, 2, ""},
-		{"PrecomputedValues", Type, 0, ""},
-		{"PrecomputedValues.CRTValues", Field, 0, ""},
-		{"PrecomputedValues.Dp", Field, 0, ""},
-		{"PrecomputedValues.Dq", Field, 0, ""},
-		{"PrecomputedValues.Qinv", Field, 0, ""},
-		{"PrivateKey", Type, 0, ""},
-		{"PrivateKey.D", Field, 0, ""},
-		{"PrivateKey.Precomputed", Field, 0, ""},
-		{"PrivateKey.Primes", Field, 0, ""},
-		{"PrivateKey.PublicKey", Field, 0, ""},
-		{"PublicKey", Type, 0, ""},
-		{"PublicKey.E", Field, 0, ""},
-		{"PublicKey.N", Field, 0, ""},
-		{"SignPKCS1v15", Func, 0, "func(random io.Reader, priv *PrivateKey, hash crypto.Hash, hashed []byte) ([]byte, error)"},
-		{"SignPSS", Func, 2, "func(random io.Reader, priv *PrivateKey, hash crypto.Hash, digest []byte, opts *PSSOptions) ([]byte, error)"},
-		{"VerifyPKCS1v15", Func, 0, "func(pub *PublicKey, hash crypto.Hash, hashed []byte, sig []byte) error"},
-		{"VerifyPSS", Func, 2, "func(pub *PublicKey, hash crypto.Hash, digest []byte, sig []byte, opts *PSSOptions) error"},
-	},
-	"crypto/sha1": {
-		{"BlockSize", Const, 0, ""},
-		{"New", Func, 0, "func() hash.Hash"},
-		{"Size", Const, 0, ""},
-		{"Sum", Func, 2, "func(data []byte) [20]byte"},
-	},
-	"crypto/sha256": {
-		{"BlockSize", Const, 0, ""},
-		{"New", Func, 0, "func() hash.Hash"},
-		{"New224", Func, 0, "func() hash.Hash"},
-		{"Size", Const, 0, ""},
-		{"Size224", Const, 0, ""},
-		{"Sum224", Func, 2, "func(data []byte) [28]byte"},
-		{"Sum256", Func, 2, "func(data []byte) [32]byte"},
-	},
-	"crypto/sha3": {
-		{"(*SHA3).AppendBinary", Method, 24, ""},
-		{"(*SHA3).BlockSize", Method, 24, ""},
-		{"(*SHA3).Clone", Method, 25, ""},
-		{"(*SHA3).MarshalBinary", Method, 24, ""},
-		{"(*SHA3).Reset", Method, 24, ""},
-		{"(*SHA3).Size", Method, 24, ""},
-		{"(*SHA3).Sum", Method, 24, ""},
-		{"(*SHA3).UnmarshalBinary", Method, 24, ""},
-		{"(*SHA3).Write", Method, 24, ""},
-		{"(*SHAKE).AppendBinary", Method, 24, ""},
-		{"(*SHAKE).BlockSize", Method, 24, ""},
-		{"(*SHAKE).MarshalBinary", Method, 24, ""},
-		{"(*SHAKE).Read", Method, 24, ""},
-		{"(*SHAKE).Reset", Method, 24, ""},
-		{"(*SHAKE).UnmarshalBinary", Method, 24, ""},
-		{"(*SHAKE).Write", Method, 24, ""},
-		{"New224", Func, 24, "func() *SHA3"},
-		{"New256", Func, 24, "func() *SHA3"},
-		{"New384", Func, 24, "func() *SHA3"},
-		{"New512", Func, 24, "func() *SHA3"},
-		{"NewCSHAKE128", Func, 24, "func(N []byte, S []byte) *SHAKE"},
-		{"NewCSHAKE256", Func, 24, "func(N []byte, S []byte) *SHAKE"},
-		{"NewSHAKE128", Func, 24, "func() *SHAKE"},
-		{"NewSHAKE256", Func, 24, "func() *SHAKE"},
-		{"SHA3", Type, 24, ""},
-		{"SHAKE", Type, 24, ""},
-		{"Sum224", Func, 24, "func(data []byte) [28]byte"},
-		{"Sum256", Func, 24, "func(data []byte) [32]byte"},
-		{"Sum384", Func, 24, "func(data []byte) [48]byte"},
-		{"Sum512", Func, 24, "func(data []byte) [64]byte"},
-		{"SumSHAKE128", Func, 24, "func(data []byte, length int) []byte"},
-		{"SumSHAKE256", Func, 24, "func(data []byte, length int) []byte"},
-	},
-	"crypto/sha512": {
-		{"BlockSize", Const, 0, ""},
-		{"New", Func, 0, "func() hash.Hash"},
-		{"New384", Func, 0, "func() hash.Hash"},
-		{"New512_224", Func, 5, "func() hash.Hash"},
-		{"New512_256", Func, 5, "func() hash.Hash"},
-		{"Size", Const, 0, ""},
-		{"Size224", Const, 5, ""},
-		{"Size256", Const, 5, ""},
-		{"Size384", Const, 0, ""},
-		{"Sum384", Func, 2, "func(data []byte) [48]byte"},
-		{"Sum512", Func, 2, "func(data []byte) [64]byte"},
-		{"Sum512_224", Func, 5, "func(data []byte) [28]byte"},
-		{"Sum512_256", Func, 5, "func(data []byte) [32]byte"},
-	},
-	"crypto/subtle": {
-		{"ConstantTimeByteEq", Func, 0, "func(x uint8, y uint8) int"},
-		{"ConstantTimeCompare", Func, 0, "func(x []byte, y []byte) int"},
-		{"ConstantTimeCopy", Func, 0, "func(v int, x []byte, y []byte)"},
-		{"ConstantTimeEq", Func, 0, "func(x int32, y int32) int"},
-		{"ConstantTimeLessOrEq", Func, 2, "func(x int, y int) int"},
-		{"ConstantTimeSelect", Func, 0, "func(v int, x int, y int) int"},
-		{"WithDataIndependentTiming", Func, 24, "func(f func())"},
-		{"XORBytes", Func, 20, "func(dst []byte, x []byte, y []byte) int"},
-	},
-	"crypto/tls": {
-		{"(*CertificateRequestInfo).Context", Method, 17, ""},
-		{"(*CertificateRequestInfo).SupportsCertificate", Method, 14, ""},
-		{"(*CertificateVerificationError).Error", Method, 20, ""},
-		{"(*CertificateVerificationError).Unwrap", Method, 20, ""},
-		{"(*ClientHelloInfo).Context", Method, 17, ""},
-		{"(*ClientHelloInfo).SupportsCertificate", Method, 14, ""},
-		{"(*ClientSessionState).ResumptionState", Method, 21, ""},
-		{"(*Config).BuildNameToCertificate", Method, 0, ""},
-		{"(*Config).Clone", Method, 8, ""},
-		{"(*Config).DecryptTicket", Method, 21, ""},
-		{"(*Config).EncryptTicket", Method, 21, ""},
-		{"(*Config).SetSessionTicketKeys", Method, 5, ""},
-		{"(*Conn).Close", Method, 0, ""},
-		{"(*Conn).CloseWrite", Method, 8, ""},
-		{"(*Conn).ConnectionState", Method, 0, ""},
-		{"(*Conn).Handshake", Method, 0, ""},
-		{"(*Conn).HandshakeContext", Method, 17, ""},
-		{"(*Conn).LocalAddr", Method, 0, ""},
-		{"(*Conn).NetConn", Method, 18, ""},
-		{"(*Conn).OCSPResponse", Method, 0, ""},
-		{"(*Conn).Read", Method, 0, ""},
-		{"(*Conn).RemoteAddr", Method, 0, ""},
-		{"(*Conn).SetDeadline", Method, 0, ""},
-		{"(*Conn).SetReadDeadline", Method, 0, ""},
-		{"(*Conn).SetWriteDeadline", Method, 0, ""},
-		{"(*Conn).VerifyHostname", Method, 0, ""},
-		{"(*Conn).Write", Method, 0, ""},
-		{"(*ConnectionState).ExportKeyingMaterial", Method, 11, ""},
-		{"(*Dialer).Dial", Method, 15, ""},
-		{"(*Dialer).DialContext", Method, 15, ""},
-		{"(*ECHRejectionError).Error", Method, 23, ""},
-		{"(*QUICConn).Close", Method, 21, ""},
-		{"(*QUICConn).ConnectionState", Method, 21, ""},
-		{"(*QUICConn).HandleData", Method, 21, ""},
-		{"(*QUICConn).NextEvent", Method, 21, ""},
-		{"(*QUICConn).SendSessionTicket", Method, 21, ""},
-		{"(*QUICConn).SetTransportParameters", Method, 21, ""},
-		{"(*QUICConn).Start", Method, 21, ""},
-		{"(*QUICConn).StoreSession", Method, 23, ""},
-		{"(*SessionState).Bytes", Method, 21, ""},
-		{"(AlertError).Error", Method, 21, ""},
-		{"(ClientAuthType).String", Method, 15, ""},
-		{"(ClientSessionCache).Get", Method, 3, ""},
-		{"(ClientSessionCache).Put", Method, 3, ""},
-		{"(CurveID).String", Method, 15, ""},
-		{"(QUICEncryptionLevel).String", Method, 21, ""},
-		{"(RecordHeaderError).Error", Method, 6, ""},
-		{"(SignatureScheme).String", Method, 15, ""},
-		{"AlertError", Type, 21, ""},
-		{"Certificate", Type, 0, ""},
-		{"Certificate.Certificate", Field, 0, ""},
-		{"Certificate.Leaf", Field, 0, ""},
-		{"Certificate.OCSPStaple", Field, 0, ""},
-		{"Certificate.PrivateKey", Field, 0, ""},
-		{"Certificate.SignedCertificateTimestamps", Field, 5, ""},
-		{"Certificate.SupportedSignatureAlgorithms", Field, 14, ""},
-		{"CertificateRequestInfo", Type, 8, ""},
-		{"CertificateRequestInfo.AcceptableCAs", Field, 8, ""},
-		{"CertificateRequestInfo.SignatureSchemes", Field, 8, ""},
-		{"CertificateRequestInfo.Version", Field, 14, ""},
-		{"CertificateVerificationError", Type, 20, ""},
-		{"CertificateVerificationError.Err", Field, 20, ""},
-		{"CertificateVerificationError.UnverifiedCertificates", Field, 20, ""},
-		{"CipherSuite", Type, 14, ""},
-		{"CipherSuite.ID", Field, 14, ""},
-		{"CipherSuite.Insecure", Field, 14, ""},
-		{"CipherSuite.Name", Field, 14, ""},
-		{"CipherSuite.SupportedVersions", Field, 14, ""},
-		{"CipherSuiteName", Func, 14, "func(id uint16) string"},
-		{"CipherSuites", Func, 14, "func() []*CipherSuite"},
-		{"Client", Func, 0, "func(conn net.Conn, config *Config) *Conn"},
-		{"ClientAuthType", Type, 0, ""},
-		{"ClientHelloInfo", Type, 4, ""},
-		{"ClientHelloInfo.CipherSuites", Field, 4, ""},
-		{"ClientHelloInfo.Conn", Field, 8, ""},
-		{"ClientHelloInfo.Extensions", Field, 24, ""},
-		{"ClientHelloInfo.HelloRetryRequest", Field, 26, ""},
-		{"ClientHelloInfo.ServerName", Field, 4, ""},
-		{"ClientHelloInfo.SignatureSchemes", Field, 8, ""},
-		{"ClientHelloInfo.SupportedCurves", Field, 4, ""},
-		{"ClientHelloInfo.SupportedPoints", Field, 4, ""},
-		{"ClientHelloInfo.SupportedProtos", Field, 8, ""},
-		{"ClientHelloInfo.SupportedVersions", Field, 8, ""},
-		{"ClientSessionCache", Type, 3, ""},
-		{"ClientSessionState", Type, 3, ""},
-		{"Config", Type, 0, ""},
-		{"Config.Certificates", Field, 0, ""},
-		{"Config.CipherSuites", Field, 0, ""},
-		{"Config.ClientAuth", Field, 0, ""},
-		{"Config.ClientCAs", Field, 0, ""},
-		{"Config.ClientSessionCache", Field, 3, ""},
-		{"Config.CurvePreferences", Field, 3, ""},
-		{"Config.DynamicRecordSizingDisabled", Field, 7, ""},
-		{"Config.EncryptedClientHelloConfigList", Field, 23, ""},
-		{"Config.EncryptedClientHelloKeys", Field, 24, ""},
-		{"Config.EncryptedClientHelloRejectionVerify", Field, 23, ""},
-		{"Config.GetCertificate", Field, 4, ""},
-		{"Config.GetClientCertificate", Field, 8, ""},
-		{"Config.GetConfigForClient", Field, 8, ""},
-		{"Config.GetEncryptedClientHelloKeys", Field, 25, ""},
-		{"Config.InsecureSkipVerify", Field, 0, ""},
-		{"Config.KeyLogWriter", Field, 8, ""},
-		{"Config.MaxVersion", Field, 2, ""},
-		{"Config.MinVersion", Field, 2, ""},
-		{"Config.NameToCertificate", Field, 0, ""},
-		{"Config.NextProtos", Field, 0, ""},
-		{"Config.PreferServerCipherSuites", Field, 1, ""},
-		{"Config.Rand", Field, 0, ""},
-		{"Config.Renegotiation", Field, 7, ""},
-		{"Config.RootCAs", Field, 0, ""},
-		{"Config.ServerName", Field, 0, ""},
-		{"Config.SessionTicketKey", Field, 1, ""},
-		{"Config.SessionTicketsDisabled", Field, 1, ""},
-		{"Config.Time", Field, 0, ""},
-		{"Config.UnwrapSession", Field, 21, ""},
-		{"Config.VerifyConnection", Field, 15, ""},
-		{"Config.VerifyPeerCertificate", Field, 8, ""},
-		{"Config.WrapSession", Field, 21, ""},
-		{"Conn", Type, 0, ""},
-		{"ConnectionState", Type, 0, ""},
-		{"ConnectionState.CipherSuite", Field, 0, ""},
-		{"ConnectionState.CurveID", Field, 25, ""},
-		{"ConnectionState.DidResume", Field, 1, ""},
-		{"ConnectionState.ECHAccepted", Field, 23, ""},
-		{"ConnectionState.HandshakeComplete", Field, 0, ""},
-		{"ConnectionState.HelloRetryRequest", Field, 26, ""},
-		{"ConnectionState.NegotiatedProtocol", Field, 0, ""},
-		{"ConnectionState.NegotiatedProtocolIsMutual", Field, 0, ""},
-		{"ConnectionState.OCSPResponse", Field, 5, ""},
-		{"ConnectionState.PeerCertificates", Field, 0, ""},
-		{"ConnectionState.ServerName", Field, 0, ""},
-		{"ConnectionState.SignedCertificateTimestamps", Field, 5, ""},
-		{"ConnectionState.TLSUnique", Field, 4, ""},
-		{"ConnectionState.VerifiedChains", Field, 0, ""},
-		{"ConnectionState.Version", Field, 3, ""},
-		{"CurveID", Type, 3, ""},
-		{"CurveP256", Const, 3, ""},
-		{"CurveP384", Const, 3, ""},
-		{"CurveP521", Const, 3, ""},
-		{"Dial", Func, 0, "func(network string, addr string, config *Config) (*Conn, error)"},
-		{"DialWithDialer", Func, 3, "func(dialer *net.Dialer, network string, addr string, config *Config) (*Conn, error)"},
-		{"Dialer", Type, 15, ""},
-		{"Dialer.Config", Field, 15, ""},
-		{"Dialer.NetDialer", Field, 15, ""},
-		{"ECDSAWithP256AndSHA256", Const, 8, ""},
-		{"ECDSAWithP384AndSHA384", Const, 8, ""},
-		{"ECDSAWithP521AndSHA512", Const, 8, ""},
-		{"ECDSAWithSHA1", Const, 10, ""},
-		{"ECHRejectionError", Type, 23, ""},
-		{"ECHRejectionError.RetryConfigList", Field, 23, ""},
-		{"Ed25519", Const, 13, ""},
-		{"EncryptedClientHelloKey", Type, 24, ""},
-		{"EncryptedClientHelloKey.Config", Field, 24, ""},
-		{"EncryptedClientHelloKey.PrivateKey", Field, 24, ""},
-		{"EncryptedClientHelloKey.SendAsRetry", Field, 24, ""},
-		{"InsecureCipherSuites", Func, 14, "func() []*CipherSuite"},
-		{"Listen", Func, 0, "func(network string, laddr string, config *Config) (net.Listener, error)"},
-		{"LoadX509KeyPair", Func, 0, "func(certFile string, keyFile string) (Certificate, error)"},
-		{"NewLRUClientSessionCache", Func, 3, "func(capacity int) ClientSessionCache"},
-		{"NewListener", Func, 0, "func(inner net.Listener, config *Config) net.Listener"},
-		{"NewResumptionState", Func, 21, "func(ticket []byte, state *SessionState) (*ClientSessionState, error)"},
-		{"NoClientCert", Const, 0, ""},
-		{"PKCS1WithSHA1", Const, 8, ""},
-		{"PKCS1WithSHA256", Const, 8, ""},
-		{"PKCS1WithSHA384", Const, 8, ""},
-		{"PKCS1WithSHA512", Const, 8, ""},
-		{"PSSWithSHA256", Const, 8, ""},
-		{"PSSWithSHA384", Const, 8, ""},
-		{"PSSWithSHA512", Const, 8, ""},
-		{"ParseSessionState", Func, 21, "func(data []byte) (*SessionState, error)"},
-		{"QUICClient", Func, 21, "func(config *QUICConfig) *QUICConn"},
-		{"QUICConfig", Type, 21, ""},
-		{"QUICConfig.EnableSessionEvents", Field, 23, ""},
-		{"QUICConfig.TLSConfig", Field, 21, ""},
-		{"QUICConn", Type, 21, ""},
-		{"QUICEncryptionLevel", Type, 21, ""},
-		{"QUICEncryptionLevelApplication", Const, 21, ""},
-		{"QUICEncryptionLevelEarly", Const, 21, ""},
-		{"QUICEncryptionLevelHandshake", Const, 21, ""},
-		{"QUICEncryptionLevelInitial", Const, 21, ""},
-		{"QUICErrorEvent", Const, 26, ""},
-		{"QUICEvent", Type, 21, ""},
-		{"QUICEvent.Data", Field, 21, ""},
-		{"QUICEvent.Err", Field, 26, ""},
-		{"QUICEvent.Kind", Field, 21, ""},
-		{"QUICEvent.Level", Field, 21, ""},
-		{"QUICEvent.SessionState", Field, 23, ""},
-		{"QUICEvent.Suite", Field, 21, ""},
-		{"QUICEventKind", Type, 21, ""},
-		{"QUICHandshakeDone", Const, 21, ""},
-		{"QUICNoEvent", Const, 21, ""},
-		{"QUICRejectedEarlyData", Const, 21, ""},
-		{"QUICResumeSession", Const, 23, ""},
-		{"QUICServer", Func, 21, "func(config *QUICConfig) *QUICConn"},
-		{"QUICSessionTicketOptions", Type, 21, ""},
-		{"QUICSessionTicketOptions.EarlyData", Field, 21, ""},
-		{"QUICSessionTicketOptions.Extra", Field, 23, ""},
-		{"QUICSetReadSecret", Const, 21, ""},
-		{"QUICSetWriteSecret", Const, 21, ""},
-		{"QUICStoreSession", Const, 23, ""},
-		{"QUICTransportParameters", Const, 21, ""},
-		{"QUICTransportParametersRequired", Const, 21, ""},
-		{"QUICWriteData", Const, 21, ""},
-		{"RecordHeaderError", Type, 6, ""},
-		{"RecordHeaderError.Conn", Field, 12, ""},
-		{"RecordHeaderError.Msg", Field, 6, ""},
-		{"RecordHeaderError.RecordHeader", Field, 6, ""},
-		{"RenegotiateFreelyAsClient", Const, 7, ""},
-		{"RenegotiateNever", Const, 7, ""},
-		{"RenegotiateOnceAsClient", Const, 7, ""},
-		{"RenegotiationSupport", Type, 7, ""},
-		{"RequestClientCert", Const, 0, ""},
-		{"RequireAndVerifyClientCert", Const, 0, ""},
-		{"RequireAnyClientCert", Const, 0, ""},
-		{"SecP256r1MLKEM768", Const, 26, ""},
-		{"SecP384r1MLKEM1024", Const, 26, ""},
-		{"Server", Func, 0, "func(conn net.Conn, config *Config) *Conn"},
-		{"SessionState", Type, 21, ""},
-		{"SessionState.EarlyData", Field, 21, ""},
-		{"SessionState.Extra", Field, 21, ""},
-		{"SignatureScheme", Type, 8, ""},
-		{"TLS_AES_128_GCM_SHA256", Const, 12, ""},
-		{"TLS_AES_256_GCM_SHA384", Const, 12, ""},
-		{"TLS_CHACHA20_POLY1305_SHA256", Const, 12, ""},
-		{"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA", Const, 2, ""},
-		{"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256", Const, 8, ""},
-		{"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256", Const, 2, ""},
-		{"TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA", Const, 2, ""},
-		{"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384", Const, 5, ""},
-		{"TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305", Const, 8, ""},
-		{"TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256", Const, 14, ""},
-		{"TLS_ECDHE_ECDSA_WITH_RC4_128_SHA", Const, 2, ""},
-		{"TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA", Const, 0, ""},
-		{"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA", Const, 0, ""},
-		{"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256", Const, 8, ""},
-		{"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256", Const, 2, ""},
-		{"TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA", Const, 1, ""},
-		{"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384", Const, 5, ""},
-		{"TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305", Const, 8, ""},
-		{"TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256", Const, 14, ""},
-		{"TLS_ECDHE_RSA_WITH_RC4_128_SHA", Const, 0, ""},
-		{"TLS_FALLBACK_SCSV", Const, 4, ""},
-		{"TLS_RSA_WITH_3DES_EDE_CBC_SHA", Const, 0, ""},
-		{"TLS_RSA_WITH_AES_128_CBC_SHA", Const, 0, ""},
-		{"TLS_RSA_WITH_AES_128_CBC_SHA256", Const, 8, ""},
-		{"TLS_RSA_WITH_AES_128_GCM_SHA256", Const, 6, ""},
-		{"TLS_RSA_WITH_AES_256_CBC_SHA", Const, 1, ""},
-		{"TLS_RSA_WITH_AES_256_GCM_SHA384", Const, 6, ""},
-		{"TLS_RSA_WITH_RC4_128_SHA", Const, 0, ""},
-		{"VerifyClientCertIfGiven", Const, 0, ""},
-		{"VersionName", Func, 21, "func(version uint16) string"},
-		{"VersionSSL30", Const, 2, ""},
-		{"VersionTLS10", Const, 2, ""},
-		{"VersionTLS11", Const, 2, ""},
-		{"VersionTLS12", Const, 2, ""},
-		{"VersionTLS13", Const, 12, ""},
-		{"X25519", Const, 8, ""},
-		{"X25519MLKEM768", Const, 24, ""},
-		{"X509KeyPair", Func, 0, "func(certPEMBlock []byte, keyPEMBlock []byte) (Certificate, error)"},
-	},
-	"crypto/x509": {
-		{"(*CertPool).AddCert", Method, 0, ""},
-		{"(*CertPool).AddCertWithConstraint", Method, 22, ""},
-		{"(*CertPool).AppendCertsFromPEM", Method, 0, ""},
-		{"(*CertPool).Clone", Method, 19, ""},
-		{"(*CertPool).Equal", Method, 19, ""},
-		{"(*CertPool).Subjects", Method, 0, ""},
-		{"(*Certificate).CheckCRLSignature", Method, 0, ""},
-		{"(*Certificate).CheckSignature", Method, 0, ""},
-		{"(*Certificate).CheckSignatureFrom", Method, 0, ""},
-		{"(*Certificate).CreateCRL", Method, 0, ""},
-		{"(*Certificate).Equal", Method, 0, ""},
-		{"(*Certificate).Verify", Method, 0, ""},
-		{"(*Certificate).VerifyHostname", Method, 0, ""},
-		{"(*CertificateRequest).CheckSignature", Method, 5, ""},
-		{"(*OID).UnmarshalBinary", Method, 23, ""},
-		{"(*OID).UnmarshalText", Method, 23, ""},
-		{"(*RevocationList).CheckSignatureFrom", Method, 19, ""},
-		{"(CertificateInvalidError).Error", Method, 0, ""},
-		{"(ConstraintViolationError).Error", Method, 0, ""},
-		{"(ExtKeyUsage).OID", Method, 26, ""},
-		{"(ExtKeyUsage).String", Method, 26, ""},
-		{"(HostnameError).Error", Method, 0, ""},
-		{"(InsecureAlgorithmError).Error", Method, 6, ""},
-		{"(KeyUsage).String", Method, 26, ""},
-		{"(OID).AppendBinary", Method, 24, ""},
-		{"(OID).AppendText", Method, 24, ""},
-		{"(OID).Equal", Method, 22, ""},
-		{"(OID).EqualASN1OID", Method, 22, ""},
-		{"(OID).MarshalBinary", Method, 23, ""},
-		{"(OID).MarshalText", Method, 23, ""},
-		{"(OID).String", Method, 22, ""},
-		{"(PublicKeyAlgorithm).String", Method, 10, ""},
-		{"(SignatureAlgorithm).String", Method, 6, ""},
-		{"(SystemRootsError).Error", Method, 1, ""},
-		{"(SystemRootsError).Unwrap", Method, 16, ""},
-		{"(UnhandledCriticalExtension).Error", Method, 0, ""},
-		{"(UnknownAuthorityError).Error", Method, 0, ""},
-		{"CANotAuthorizedForExtKeyUsage", Const, 10, ""},
-		{"CANotAuthorizedForThisName", Const, 0, ""},
-		{"CertPool", Type, 0, ""},
-		{"Certificate", Type, 0, ""},
-		{"Certificate.AuthorityKeyId", Field, 0, ""},
-		{"Certificate.BasicConstraintsValid", Field, 0, ""},
-		{"Certificate.CRLDistributionPoints", Field, 2, ""},
-		{"Certificate.DNSNames", Field, 0, ""},
-		{"Certificate.EmailAddresses", Field, 0, ""},
-		{"Certificate.ExcludedDNSDomains", Field, 9, ""},
-		{"Certificate.ExcludedEmailAddresses", Field, 10, ""},
-		{"Certificate.ExcludedIPRanges", Field, 10, ""},
-		{"Certificate.ExcludedURIDomains", Field, 10, ""},
-		{"Certificate.ExtKeyUsage", Field, 0, ""},
-		{"Certificate.Extensions", Field, 2, ""},
-		{"Certificate.ExtraExtensions", Field, 2, ""},
-		{"Certificate.IPAddresses", Field, 1, ""},
-		{"Certificate.InhibitAnyPolicy", Field, 24, ""},
-		{"Certificate.InhibitAnyPolicyZero", Field, 24, ""},
-		{"Certificate.InhibitPolicyMapping", Field, 24, ""},
-		{"Certificate.InhibitPolicyMappingZero", Field, 24, ""},
-		{"Certificate.IsCA", Field, 0, ""},
-		{"Certificate.Issuer", Field, 0, ""},
-		{"Certificate.IssuingCertificateURL", Field, 2, ""},
-		{"Certificate.KeyUsage", Field, 0, ""},
-		{"Certificate.MaxPathLen", Field, 0, ""},
-		{"Certificate.MaxPathLenZero", Field, 4, ""},
-		{"Certificate.NotAfter", Field, 0, ""},
-		{"Certificate.NotBefore", Field, 0, ""},
-		{"Certificate.OCSPServer", Field, 2, ""},
-		{"Certificate.PermittedDNSDomains", Field, 0, ""},
-		{"Certificate.PermittedDNSDomainsCritical", Field, 0, ""},
-		{"Certificate.PermittedEmailAddresses", Field, 10, ""},
-		{"Certificate.PermittedIPRanges", Field, 10, ""},
-		{"Certificate.PermittedURIDomains", Field, 10, ""},
-		{"Certificate.Policies", Field, 22, ""},
-		{"Certificate.PolicyIdentifiers", Field, 0, ""},
-		{"Certificate.PolicyMappings", Field, 24, ""},
-		{"Certificate.PublicKey", Field, 0, ""},
-		{"Certificate.PublicKeyAlgorithm", Field, 0, ""},
-		{"Certificate.Raw", Field, 0, ""},
-		{"Certificate.RawIssuer", Field, 0, ""},
-		{"Certificate.RawSubject", Field, 0, ""},
-		{"Certificate.RawSubjectPublicKeyInfo", Field, 0, ""},
-		{"Certificate.RawTBSCertificate", Field, 0, ""},
-		{"Certificate.RequireExplicitPolicy", Field, 24, ""},
-		{"Certificate.RequireExplicitPolicyZero", Field, 24, ""},
-		{"Certificate.SerialNumber", Field, 0, ""},
-		{"Certificate.Signature", Field, 0, ""},
-		{"Certificate.SignatureAlgorithm", Field, 0, ""},
-		{"Certificate.Subject", Field, 0, ""},
-		{"Certificate.SubjectKeyId", Field, 0, ""},
-		{"Certificate.URIs", Field, 10, ""},
-		{"Certificate.UnhandledCriticalExtensions", Field, 5, ""},
-		{"Certificate.UnknownExtKeyUsage", Field, 0, ""},
-		{"Certificate.Version", Field, 0, ""},
-		{"CertificateInvalidError", Type, 0, ""},
-		{"CertificateInvalidError.Cert", Field, 0, ""},
-		{"CertificateInvalidError.Detail", Field, 10, ""},
-		{"CertificateInvalidError.Reason", Field, 0, ""},
-		{"CertificateRequest", Type, 3, ""},
-		{"CertificateRequest.Attributes", Field, 3, ""},
-		{"CertificateRequest.DNSNames", Field, 3, ""},
-		{"CertificateRequest.EmailAddresses", Field, 3, ""},
-		{"CertificateRequest.Extensions", Field, 3, ""},
-		{"CertificateRequest.ExtraExtensions", Field, 3, ""},
-		{"CertificateRequest.IPAddresses", Field, 3, ""},
-		{"CertificateRequest.PublicKey", Field, 3, ""},
-		{"CertificateRequest.PublicKeyAlgorithm", Field, 3, ""},
-		{"CertificateRequest.Raw", Field, 3, ""},
-		{"CertificateRequest.RawSubject", Field, 3, ""},
-		{"CertificateRequest.RawSubjectPublicKeyInfo", Field, 3, ""},
-		{"CertificateRequest.RawTBSCertificateRequest", Field, 3, ""},
-		{"CertificateRequest.Signature", Field, 3, ""},
-		{"CertificateRequest.SignatureAlgorithm", Field, 3, ""},
-		{"CertificateRequest.Subject", Field, 3, ""},
-		{"CertificateRequest.URIs", Field, 10, ""},
-		{"CertificateRequest.Version", Field, 3, ""},
-		{"ConstraintViolationError", Type, 0, ""},
-		{"CreateCertificate", Func, 0, "func(rand io.Reader, template *Certificate, parent *Certificate, pub any, priv any) ([]byte, error)"},
-		{"CreateCertificateRequest", Func, 3, "func(rand io.Reader, template *CertificateRequest, priv any) (csr []byte, err error)"},
-		{"CreateRevocationList", Func, 15, "func(rand io.Reader, template *RevocationList, issuer *Certificate, priv crypto.Signer) ([]byte, error)"},
-		{"DSA", Const, 0, ""},
-		{"DSAWithSHA1", Const, 0, ""},
-		{"DSAWithSHA256", Const, 0, ""},
-		{"DecryptPEMBlock", Func, 1, "func(b *pem.Block, password []byte) ([]byte, error)"},
-		{"ECDSA", Const, 1, ""},
-		{"ECDSAWithSHA1", Const, 1, ""},
-		{"ECDSAWithSHA256", Const, 1, ""},
-		{"ECDSAWithSHA384", Const, 1, ""},
-		{"ECDSAWithSHA512", Const, 1, ""},
-		{"Ed25519", Const, 13, ""},
-		{"EncryptPEMBlock", Func, 1, "func(rand io.Reader, blockType string, data []byte, password []byte, alg PEMCipher) (*pem.Block, error)"},
-		{"ErrUnsupportedAlgorithm", Var, 0, ""},
-		{"Expired", Const, 0, ""},
-		{"ExtKeyUsage", Type, 0, ""},
-		{"ExtKeyUsageAny", Const, 0, ""},
-		{"ExtKeyUsageClientAuth", Const, 0, ""},
-		{"ExtKeyUsageCodeSigning", Const, 0, ""},
-		{"ExtKeyUsageEmailProtection", Const, 0, ""},
-		{"ExtKeyUsageIPSECEndSystem", Const, 1, ""},
-		{"ExtKeyUsageIPSECTunnel", Const, 1, ""},
-		{"ExtKeyUsageIPSECUser", Const, 1, ""},
-		{"ExtKeyUsageMicrosoftCommercialCodeSigning", Const, 10, ""},
-		{"ExtKeyUsageMicrosoftKernelCodeSigning", Const, 10, ""},
-		{"ExtKeyUsageMicrosoftServerGatedCrypto", Const, 1, ""},
-		{"ExtKeyUsageNetscapeServerGatedCrypto", Const, 1, ""},
-		{"ExtKeyUsageOCSPSigning", Const, 0, ""},
-		{"ExtKeyUsageServerAuth", Const, 0, ""},
-		{"ExtKeyUsageTimeStamping", Const, 0, ""},
-		{"HostnameError", Type, 0, ""},
-		{"HostnameError.Certificate", Field, 0, ""},
-		{"HostnameError.Host", Field, 0, ""},
-		{"IncompatibleUsage", Const, 1, ""},
-		{"IncorrectPasswordError", Var, 1, ""},
-		{"InsecureAlgorithmError", Type, 6, ""},
-		{"InvalidReason", Type, 0, ""},
-		{"IsEncryptedPEMBlock", Func, 1, "func(b *pem.Block) bool"},
-		{"KeyUsage", Type, 0, ""},
-		{"KeyUsageCRLSign", Const, 0, ""},
-		{"KeyUsageCertSign", Const, 0, ""},
-		{"KeyUsageContentCommitment", Const, 0, ""},
-		{"KeyUsageDataEncipherment", Const, 0, ""},
-		{"KeyUsageDecipherOnly", Const, 0, ""},
-		{"KeyUsageDigitalSignature", Const, 0, ""},
-		{"KeyUsageEncipherOnly", Const, 0, ""},
-		{"KeyUsageKeyAgreement", Const, 0, ""},
-		{"KeyUsageKeyEncipherment", Const, 0, ""},
-		{"MD2WithRSA", Const, 0, ""},
-		{"MD5WithRSA", Const, 0, ""},
-		{"MarshalECPrivateKey", Func, 2, "func(key *ecdsa.PrivateKey) ([]byte, error)"},
-		{"MarshalPKCS1PrivateKey", Func, 0, "func(key *rsa.PrivateKey) []byte"},
-		{"MarshalPKCS1PublicKey", Func, 10, "func(key *rsa.PublicKey) []byte"},
-		{"MarshalPKCS8PrivateKey", Func, 10, "func(key any) ([]byte, error)"},
-		{"MarshalPKIXPublicKey", Func, 0, "func(pub any) ([]byte, error)"},
-		{"NameConstraintsWithoutSANs", Const, 10, ""},
-		{"NameMismatch", Const, 8, ""},
-		{"NewCertPool", Func, 0, "func() *CertPool"},
-		{"NoValidChains", Const, 24, ""},
-		{"NotAuthorizedToSign", Const, 0, ""},
-		{"OID", Type, 22, ""},
-		{"OIDFromASN1OID", Func, 26, "func(asn1OID asn1.ObjectIdentifier) (OID, error)"},
-		{"OIDFromInts", Func, 22, "func(oid []uint64) (OID, error)"},
-		{"PEMCipher", Type, 1, ""},
-		{"PEMCipher3DES", Const, 1, ""},
-		{"PEMCipherAES128", Const, 1, ""},
-		{"PEMCipherAES192", Const, 1, ""},
-		{"PEMCipherAES256", Const, 1, ""},
-		{"PEMCipherDES", Const, 1, ""},
-		{"ParseCRL", Func, 0, "func(crlBytes []byte) (*pkix.CertificateList, error)"},
-		{"ParseCertificate", Func, 0, "func(der []byte) (*Certificate, error)"},
-		{"ParseCertificateRequest", Func, 3, "func(asn1Data []byte) (*CertificateRequest, error)"},
-		{"ParseCertificates", Func, 0, "func(der []byte) ([]*Certificate, error)"},
-		{"ParseDERCRL", Func, 0, "func(derBytes []byte) (*pkix.CertificateList, error)"},
-		{"ParseECPrivateKey", Func, 1, "func(der []byte) (*ecdsa.PrivateKey, error)"},
-		{"ParseOID", Func, 23, "func(oid string) (OID, error)"},
-		{"ParsePKCS1PrivateKey", Func, 0, "func(der []byte) (*rsa.PrivateKey, error)"},
-		{"ParsePKCS1PublicKey", Func, 10, "func(der []byte) (*rsa.PublicKey, error)"},
-		{"ParsePKCS8PrivateKey", Func, 0, "func(der []byte) (key any, err error)"},
-		{"ParsePKIXPublicKey", Func, 0, "func(derBytes []byte) (pub any, err error)"},
-		{"ParseRevocationList", Func, 19, "func(der []byte) (*RevocationList, error)"},
-		{"PolicyMapping", Type, 24, ""},
-		{"PolicyMapping.IssuerDomainPolicy", Field, 24, ""},
-		{"PolicyMapping.SubjectDomainPolicy", Field, 24, ""},
-		{"PublicKeyAlgorithm", Type, 0, ""},
-		{"PureEd25519", Const, 13, ""},
-		{"RSA", Const, 0, ""},
-		{"RevocationList", Type, 15, ""},
-		{"RevocationList.AuthorityKeyId", Field, 19, ""},
-		{"RevocationList.Extensions", Field, 19, ""},
-		{"RevocationList.ExtraExtensions", Field, 15, ""},
-		{"RevocationList.Issuer", Field, 19, ""},
-		{"RevocationList.NextUpdate", Field, 15, ""},
-		{"RevocationList.Number", Field, 15, ""},
-		{"RevocationList.Raw", Field, 19, ""},
-		{"RevocationList.RawIssuer", Field, 19, ""},
-		{"RevocationList.RawTBSRevocationList", Field, 19, ""},
-		{"RevocationList.RevokedCertificateEntries", Field, 21, ""},
-		{"RevocationList.RevokedCertificates", Field, 15, ""},
-		{"RevocationList.Signature", Field, 19, ""},
-		{"RevocationList.SignatureAlgorithm", Field, 15, ""},
-		{"RevocationList.ThisUpdate", Field, 15, ""},
-		{"RevocationListEntry", Type, 21, ""},
-		{"RevocationListEntry.Extensions", Field, 21, ""},
-		{"RevocationListEntry.ExtraExtensions", Field, 21, ""},
-		{"RevocationListEntry.Raw", Field, 21, ""},
-		{"RevocationListEntry.ReasonCode", Field, 21, ""},
-		{"RevocationListEntry.RevocationTime", Field, 21, ""},
-		{"RevocationListEntry.SerialNumber", Field, 21, ""},
-		{"SHA1WithRSA", Const, 0, ""},
-		{"SHA256WithRSA", Const, 0, ""},
-		{"SHA256WithRSAPSS", Const, 8, ""},
-		{"SHA384WithRSA", Const, 0, ""},
-		{"SHA384WithRSAPSS", Const, 8, ""},
-		{"SHA512WithRSA", Const, 0, ""},
-		{"SHA512WithRSAPSS", Const, 8, ""},
-		{"SetFallbackRoots", Func, 20, "func(roots *CertPool)"},
-		{"SignatureAlgorithm", Type, 0, ""},
-		{"SystemCertPool", Func, 7, "func() (*CertPool, error)"},
-		{"SystemRootsError", Type, 1, ""},
-		{"SystemRootsError.Err", Field, 7, ""},
-		{"TooManyConstraints", Const, 10, ""},
-		{"TooManyIntermediates", Const, 0, ""},
-		{"UnconstrainedName", Const, 10, ""},
-		{"UnhandledCriticalExtension", Type, 0, ""},
-		{"UnknownAuthorityError", Type, 0, ""},
-		{"UnknownAuthorityError.Cert", Field, 8, ""},
-		{"UnknownPublicKeyAlgorithm", Const, 0, ""},
-		{"UnknownSignatureAlgorithm", Const, 0, ""},
-		{"VerifyOptions", Type, 0, ""},
-		{"VerifyOptions.CertificatePolicies", Field, 24, ""},
-		{"VerifyOptions.CurrentTime", Field, 0, ""},
-		{"VerifyOptions.DNSName", Field, 0, ""},
-		{"VerifyOptions.Intermediates", Field, 0, ""},
-		{"VerifyOptions.KeyUsages", Field, 1, ""},
-		{"VerifyOptions.MaxConstraintComparisions", Field, 10, ""},
-		{"VerifyOptions.Roots", Field, 0, ""},
-	},
-	"crypto/x509/pkix": {
-		{"(*CertificateList).HasExpired", Method, 0, ""},
-		{"(*Name).FillFromRDNSequence", Method, 0, ""},
-		{"(Name).String", Method, 10, ""},
-		{"(Name).ToRDNSequence", Method, 0, ""},
-		{"(RDNSequence).String", Method, 10, ""},
-		{"AlgorithmIdentifier", Type, 0, ""},
-		{"AlgorithmIdentifier.Algorithm", Field, 0, ""},
-		{"AlgorithmIdentifier.Parameters", Field, 0, ""},
-		{"AttributeTypeAndValue", Type, 0, ""},
-		{"AttributeTypeAndValue.Type", Field, 0, ""},
-		{"AttributeTypeAndValue.Value", Field, 0, ""},
-		{"AttributeTypeAndValueSET", Type, 3, ""},
-		{"AttributeTypeAndValueSET.Type", Field, 3, ""},
-		{"AttributeTypeAndValueSET.Value", Field, 3, ""},
-		{"CertificateList", Type, 0, ""},
-		{"CertificateList.SignatureAlgorithm", Field, 0, ""},
-		{"CertificateList.SignatureValue", Field, 0, ""},
-		{"CertificateList.TBSCertList", Field, 0, ""},
-		{"Extension", Type, 0, ""},
-		{"Extension.Critical", Field, 0, ""},
-		{"Extension.Id", Field, 0, ""},
-		{"Extension.Value", Field, 0, ""},
-		{"Name", Type, 0, ""},
-		{"Name.CommonName", Field, 0, ""},
-		{"Name.Country", Field, 0, ""},
-		{"Name.ExtraNames", Field, 5, ""},
-		{"Name.Locality", Field, 0, ""},
-		{"Name.Names", Field, 0, ""},
-		{"Name.Organization", Field, 0, ""},
-		{"Name.OrganizationalUnit", Field, 0, ""},
-		{"Name.PostalCode", Field, 0, ""},
-		{"Name.Province", Field, 0, ""},
-		{"Name.SerialNumber", Field, 0, ""},
-		{"Name.StreetAddress", Field, 0, ""},
-		{"RDNSequence", Type, 0, ""},
-		{"RelativeDistinguishedNameSET", Type, 0, ""},
-		{"RevokedCertificate", Type, 0, ""},
-		{"RevokedCertificate.Extensions", Field, 0, ""},
-		{"RevokedCertificate.RevocationTime", Field, 0, ""},
-		{"RevokedCertificate.SerialNumber", Field, 0, ""},
-		{"TBSCertificateList", Type, 0, ""},
-		{"TBSCertificateList.Extensions", Field, 0, ""},
-		{"TBSCertificateList.Issuer", Field, 0, ""},
-		{"TBSCertificateList.NextUpdate", Field, 0, ""},
-		{"TBSCertificateList.Raw", Field, 0, ""},
-		{"TBSCertificateList.RevokedCertificates", Field, 0, ""},
-		{"TBSCertificateList.Signature", Field, 0, ""},
-		{"TBSCertificateList.ThisUpdate", Field, 0, ""},
-		{"TBSCertificateList.Version", Field, 0, ""},
-	},
-	"database/sql": {
-		{"(*ColumnType).DatabaseTypeName", Method, 8, ""},
-		{"(*ColumnType).DecimalSize", Method, 8, ""},
-		{"(*ColumnType).Length", Method, 8, ""},
-		{"(*ColumnType).Name", Method, 8, ""},
-		{"(*ColumnType).Nullable", Method, 8, ""},
-		{"(*ColumnType).ScanType", Method, 8, ""},
-		{"(*Conn).BeginTx", Method, 9, ""},
-		{"(*Conn).Close", Method, 9, ""},
-		{"(*Conn).ExecContext", Method, 9, ""},
-		{"(*Conn).PingContext", Method, 9, ""},
-		{"(*Conn).PrepareContext", Method, 9, ""},
-		{"(*Conn).QueryContext", Method, 9, ""},
-		{"(*Conn).QueryRowContext", Method, 9, ""},
-		{"(*Conn).Raw", Method, 13, ""},
-		{"(*DB).Begin", Method, 0, ""},
-		{"(*DB).BeginTx", Method, 8, ""},
-		{"(*DB).Close", Method, 0, ""},
-		{"(*DB).Conn", Method, 9, ""},
-		{"(*DB).Driver", Method, 0, ""},
-		{"(*DB).Exec", Method, 0, ""},
-		{"(*DB).ExecContext", Method, 8, ""},
-		{"(*DB).Ping", Method, 1, ""},
-		{"(*DB).PingContext", Method, 8, ""},
-		{"(*DB).Prepare", Method, 0, ""},
-		{"(*DB).PrepareContext", Method, 8, ""},
-		{"(*DB).Query", Method, 0, ""},
-		{"(*DB).QueryContext", Method, 8, ""},
-		{"(*DB).QueryRow", Method, 0, ""},
-		{"(*DB).QueryRowContext", Method, 8, ""},
-		{"(*DB).SetConnMaxIdleTime", Method, 15, ""},
-		{"(*DB).SetConnMaxLifetime", Method, 6, ""},
-		{"(*DB).SetMaxIdleConns", Method, 1, ""},
-		{"(*DB).SetMaxOpenConns", Method, 2, ""},
-		{"(*DB).Stats", Method, 5, ""},
-		{"(*Null).Scan", Method, 22, ""},
-		{"(*NullBool).Scan", Method, 0, ""},
-		{"(*NullByte).Scan", Method, 17, ""},
-		{"(*NullFloat64).Scan", Method, 0, ""},
-		{"(*NullInt16).Scan", Method, 17, ""},
-		{"(*NullInt32).Scan", Method, 13, ""},
-		{"(*NullInt64).Scan", Method, 0, ""},
-		{"(*NullString).Scan", Method, 0, ""},
-		{"(*NullTime).Scan", Method, 13, ""},
-		{"(*Row).Err", Method, 15, ""},
-		{"(*Row).Scan", Method, 0, ""},
-		{"(*Rows).Close", Method, 0, ""},
-		{"(*Rows).ColumnTypes", Method, 8, ""},
-		{"(*Rows).Columns", Method, 0, ""},
-		{"(*Rows).Err", Method, 0, ""},
-		{"(*Rows).Next", Method, 0, ""},
-		{"(*Rows).NextResultSet", Method, 8, ""},
-		{"(*Rows).Scan", Method, 0, ""},
-		{"(*Stmt).Close", Method, 0, ""},
-		{"(*Stmt).Exec", Method, 0, ""},
-		{"(*Stmt).ExecContext", Method, 8, ""},
-		{"(*Stmt).Query", Method, 0, ""},
-		{"(*Stmt).QueryContext", Method, 8, ""},
-		{"(*Stmt).QueryRow", Method, 0, ""},
-		{"(*Stmt).QueryRowContext", Method, 8, ""},
-		{"(*Tx).Commit", Method, 0, ""},
-		{"(*Tx).Exec", Method, 0, ""},
-		{"(*Tx).ExecContext", Method, 8, ""},
-		{"(*Tx).Prepare", Method, 0, ""},
-		{"(*Tx).PrepareContext", Method, 8, ""},
-		{"(*Tx).Query", Method, 0, ""},
-		{"(*Tx).QueryContext", Method, 8, ""},
-		{"(*Tx).QueryRow", Method, 0, ""},
-		{"(*Tx).QueryRowContext", Method, 8, ""},
-		{"(*Tx).Rollback", Method, 0, ""},
-		{"(*Tx).Stmt", Method, 0, ""},
-		{"(*Tx).StmtContext", Method, 8, ""},
-		{"(IsolationLevel).String", Method, 11, ""},
-		{"(Null).Value", Method, 22, ""},
-		{"(NullBool).Value", Method, 0, ""},
-		{"(NullByte).Value", Method, 17, ""},
-		{"(NullFloat64).Value", Method, 0, ""},
-		{"(NullInt16).Value", Method, 17, ""},
-		{"(NullInt32).Value", Method, 13, ""},
-		{"(NullInt64).Value", Method, 0, ""},
-		{"(NullString).Value", Method, 0, ""},
-		{"(NullTime).Value", Method, 13, ""},
-		{"(Result).LastInsertId", Method, 0, ""},
-		{"(Result).RowsAffected", Method, 0, ""},
-		{"(Scanner).Scan", Method, 0, ""},
-		{"ColumnType", Type, 8, ""},
-		{"Conn", Type, 9, ""},
-		{"DB", Type, 0, ""},
-		{"DBStats", Type, 5, ""},
-		{"DBStats.Idle", Field, 11, ""},
-		{"DBStats.InUse", Field, 11, ""},
-		{"DBStats.MaxIdleClosed", Field, 11, ""},
-		{"DBStats.MaxIdleTimeClosed", Field, 15, ""},
-		{"DBStats.MaxLifetimeClosed", Field, 11, ""},
-		{"DBStats.MaxOpenConnections", Field, 11, ""},
-		{"DBStats.OpenConnections", Field, 5, ""},
-		{"DBStats.WaitCount", Field, 11, ""},
-		{"DBStats.WaitDuration", Field, 11, ""},
-		{"Drivers", Func, 4, "func() []string"},
-		{"ErrConnDone", Var, 9, ""},
-		{"ErrNoRows", Var, 0, ""},
-		{"ErrTxDone", Var, 0, ""},
-		{"IsolationLevel", Type, 8, ""},
-		{"LevelDefault", Const, 8, ""},
-		{"LevelLinearizable", Const, 8, ""},
-		{"LevelReadCommitted", Const, 8, ""},
-		{"LevelReadUncommitted", Const, 8, ""},
-		{"LevelRepeatableRead", Const, 8, ""},
-		{"LevelSerializable", Const, 8, ""},
-		{"LevelSnapshot", Const, 8, ""},
-		{"LevelWriteCommitted", Const, 8, ""},
-		{"Named", Func, 8, "func(name string, value any) NamedArg"},
-		{"NamedArg", Type, 8, ""},
-		{"NamedArg.Name", Field, 8, ""},
-		{"NamedArg.Value", Field, 8, ""},
-		{"Null", Type, 22, ""},
-		{"NullBool", Type, 0, ""},
-		{"NullBool.Bool", Field, 0, ""},
-		{"NullBool.Valid", Field, 0, ""},
-		{"NullByte", Type, 17, ""},
-		{"NullByte.Byte", Field, 17, ""},
-		{"NullByte.Valid", Field, 17, ""},
-		{"NullFloat64", Type, 0, ""},
-		{"NullFloat64.Float64", Field, 0, ""},
-		{"NullFloat64.Valid", Field, 0, ""},
-		{"NullInt16", Type, 17, ""},
-		{"NullInt16.Int16", Field, 17, ""},
-		{"NullInt16.Valid", Field, 17, ""},
-		{"NullInt32", Type, 13, ""},
-		{"NullInt32.Int32", Field, 13, ""},
-		{"NullInt32.Valid", Field, 13, ""},
-		{"NullInt64", Type, 0, ""},
-		{"NullInt64.Int64", Field, 0, ""},
-		{"NullInt64.Valid", Field, 0, ""},
-		{"NullString", Type, 0, ""},
-		{"NullString.String", Field, 0, ""},
-		{"NullString.Valid", Field, 0, ""},
-		{"NullTime", Type, 13, ""},
-		{"NullTime.Time", Field, 13, ""},
-		{"NullTime.Valid", Field, 13, ""},
-		{"Open", Func, 0, "func(driverName string, dataSourceName string) (*DB, error)"},
-		{"OpenDB", Func, 10, "func(c driver.Connector) *DB"},
-		{"Out", Type, 9, ""},
-		{"Out.Dest", Field, 9, ""},
-		{"Out.In", Field, 9, ""},
-		{"RawBytes", Type, 0, ""},
-		{"Register", Func, 0, "func(name string, driver driver.Driver)"},
-		{"Result", Type, 0, ""},
-		{"Row", Type, 0, ""},
-		{"Rows", Type, 0, ""},
-		{"Scanner", Type, 0, ""},
-		{"Stmt", Type, 0, ""},
-		{"Tx", Type, 0, ""},
-		{"TxOptions", Type, 8, ""},
-		{"TxOptions.Isolation", Field, 8, ""},
-		{"TxOptions.ReadOnly", Field, 8, ""},
-	},
-	"database/sql/driver": {
-		{"(ColumnConverter).ColumnConverter", Method, 0, ""},
-		{"(Conn).Begin", Method, 0, ""},
-		{"(Conn).Close", Method, 0, ""},
-		{"(Conn).Prepare", Method, 0, ""},
-		{"(ConnBeginTx).BeginTx", Method, 8, ""},
-		{"(ConnPrepareContext).PrepareContext", Method, 8, ""},
-		{"(Connector).Connect", Method, 10, ""},
-		{"(Connector).Driver", Method, 10, ""},
-		{"(Driver).Open", Method, 0, ""},
-		{"(DriverContext).OpenConnector", Method, 10, ""},
-		{"(Execer).Exec", Method, 0, ""},
-		{"(ExecerContext).ExecContext", Method, 8, ""},
-		{"(NamedValueChecker).CheckNamedValue", Method, 9, ""},
-		{"(NotNull).ConvertValue", Method, 0, ""},
-		{"(Null).ConvertValue", Method, 0, ""},
-		{"(Pinger).Ping", Method, 8, ""},
-		{"(Queryer).Query", Method, 1, ""},
-		{"(QueryerContext).QueryContext", Method, 8, ""},
-		{"(Result).LastInsertId", Method, 0, ""},
-		{"(Result).RowsAffected", Method, 0, ""},
-		{"(Rows).Close", Method, 0, ""},
-		{"(Rows).Columns", Method, 0, ""},
-		{"(Rows).Next", Method, 0, ""},
-		{"(RowsAffected).LastInsertId", Method, 0, ""},
-		{"(RowsAffected).RowsAffected", Method, 0, ""},
-		{"(RowsColumnTypeDatabaseTypeName).Close", Method, 8, ""},
-		{"(RowsColumnTypeDatabaseTypeName).ColumnTypeDatabaseTypeName", Method, 8, ""},
-		{"(RowsColumnTypeDatabaseTypeName).Columns", Method, 8, ""},
-		{"(RowsColumnTypeDatabaseTypeName).Next", Method, 8, ""},
-		{"(RowsColumnTypeLength).Close", Method, 8, ""},
-		{"(RowsColumnTypeLength).ColumnTypeLength", Method, 8, ""},
-		{"(RowsColumnTypeLength).Columns", Method, 8, ""},
-		{"(RowsColumnTypeLength).Next", Method, 8, ""},
-		{"(RowsColumnTypeNullable).Close", Method, 8, ""},
-		{"(RowsColumnTypeNullable).ColumnTypeNullable", Method, 8, ""},
-		{"(RowsColumnTypeNullable).Columns", Method, 8, ""},
-		{"(RowsColumnTypeNullable).Next", Method, 8, ""},
-		{"(RowsColumnTypePrecisionScale).Close", Method, 8, ""},
-		{"(RowsColumnTypePrecisionScale).ColumnTypePrecisionScale", Method, 8, ""},
-		{"(RowsColumnTypePrecisionScale).Columns", Method, 8, ""},
-		{"(RowsColumnTypePrecisionScale).Next", Method, 8, ""},
-		{"(RowsColumnTypeScanType).Close", Method, 8, ""},
-		{"(RowsColumnTypeScanType).ColumnTypeScanType", Method, 8, ""},
-		{"(RowsColumnTypeScanType).Columns", Method, 8, ""},
-		{"(RowsColumnTypeScanType).Next", Method, 8, ""},
-		{"(RowsNextResultSet).Close", Method, 8, ""},
-		{"(RowsNextResultSet).Columns", Method, 8, ""},
-		{"(RowsNextResultSet).HasNextResultSet", Method, 8, ""},
-		{"(RowsNextResultSet).Next", Method, 8, ""},
-		{"(RowsNextResultSet).NextResultSet", Method, 8, ""},
-		{"(SessionResetter).ResetSession", Method, 10, ""},
-		{"(Stmt).Close", Method, 0, ""},
-		{"(Stmt).Exec", Method, 0, ""},
-		{"(Stmt).NumInput", Method, 0, ""},
-		{"(Stmt).Query", Method, 0, ""},
-		{"(StmtExecContext).ExecContext", Method, 8, ""},
-		{"(StmtQueryContext).QueryContext", Method, 8, ""},
-		{"(Tx).Commit", Method, 0, ""},
-		{"(Tx).Rollback", Method, 0, ""},
-		{"(Validator).IsValid", Method, 15, ""},
-		{"(ValueConverter).ConvertValue", Method, 0, ""},
-		{"(Valuer).Value", Method, 0, ""},
-		{"Bool", Var, 0, ""},
-		{"ColumnConverter", Type, 0, ""},
-		{"Conn", Type, 0, ""},
-		{"ConnBeginTx", Type, 8, ""},
-		{"ConnPrepareContext", Type, 8, ""},
-		{"Connector", Type, 10, ""},
-		{"DefaultParameterConverter", Var, 0, ""},
-		{"Driver", Type, 0, ""},
-		{"DriverContext", Type, 10, ""},
-		{"ErrBadConn", Var, 0, ""},
-		{"ErrRemoveArgument", Var, 9, ""},
-		{"ErrSkip", Var, 0, ""},
-		{"Execer", Type, 0, ""},
-		{"ExecerContext", Type, 8, ""},
-		{"Int32", Var, 0, ""},
-		{"IsScanValue", Func, 0, "func(v any) bool"},
-		{"IsValue", Func, 0, "func(v any) bool"},
-		{"IsolationLevel", Type, 8, ""},
-		{"NamedValue", Type, 8, ""},
-		{"NamedValue.Name", Field, 8, ""},
-		{"NamedValue.Ordinal", Field, 8, ""},
-		{"NamedValue.Value", Field, 8, ""},
-		{"NamedValueChecker", Type, 9, ""},
-		{"NotNull", Type, 0, ""},
-		{"NotNull.Converter", Field, 0, ""},
-		{"Null", Type, 0, ""},
-		{"Null.Converter", Field, 0, ""},
-		{"Pinger", Type, 8, ""},
-		{"Queryer", Type, 1, ""},
-		{"QueryerContext", Type, 8, ""},
-		{"Result", Type, 0, ""},
-		{"ResultNoRows", Var, 0, ""},
-		{"Rows", Type, 0, ""},
-		{"RowsAffected", Type, 0, ""},
-		{"RowsColumnTypeDatabaseTypeName", Type, 8, ""},
-		{"RowsColumnTypeLength", Type, 8, ""},
-		{"RowsColumnTypeNullable", Type, 8, ""},
-		{"RowsColumnTypePrecisionScale", Type, 8, ""},
-		{"RowsColumnTypeScanType", Type, 8, ""},
-		{"RowsNextResultSet", Type, 8, ""},
-		{"SessionResetter", Type, 10, ""},
-		{"Stmt", Type, 0, ""},
-		{"StmtExecContext", Type, 8, ""},
-		{"StmtQueryContext", Type, 8, ""},
-		{"String", Var, 0, ""},
-		{"Tx", Type, 0, ""},
-		{"TxOptions", Type, 8, ""},
-		{"TxOptions.Isolation", Field, 8, ""},
-		{"TxOptions.ReadOnly", Field, 8, ""},
-		{"Validator", Type, 15, ""},
-		{"Value", Type, 0, ""},
-		{"ValueConverter", Type, 0, ""},
-		{"Valuer", Type, 0, ""},
-	},
-	"debug/buildinfo": {
-		{"BuildInfo", Type, 18, ""},
-		{"Read", Func, 18, "func(r io.ReaderAt) (*BuildInfo, error)"},
-		{"ReadFile", Func, 18, "func(name string) (info *BuildInfo, err error)"},
-	},
-	"debug/dwarf": {
-		{"(*AddrType).Basic", Method, 0, ""},
-		{"(*AddrType).Common", Method, 0, ""},
-		{"(*AddrType).Size", Method, 0, ""},
-		{"(*AddrType).String", Method, 0, ""},
-		{"(*ArrayType).Common", Method, 0, ""},
-		{"(*ArrayType).Size", Method, 0, ""},
-		{"(*ArrayType).String", Method, 0, ""},
-		{"(*BasicType).Basic", Method, 0, ""},
-		{"(*BasicType).Common", Method, 0, ""},
-		{"(*BasicType).Size", Method, 0, ""},
-		{"(*BasicType).String", Method, 0, ""},
-		{"(*BoolType).Basic", Method, 0, ""},
-		{"(*BoolType).Common", Method, 0, ""},
-		{"(*BoolType).Size", Method, 0, ""},
-		{"(*BoolType).String", Method, 0, ""},
-		{"(*CharType).Basic", Method, 0, ""},
-		{"(*CharType).Common", Method, 0, ""},
-		{"(*CharType).Size", Method, 0, ""},
-		{"(*CharType).String", Method, 0, ""},
-		{"(*CommonType).Common", Method, 0, ""},
-		{"(*CommonType).Size", Method, 0, ""},
-		{"(*ComplexType).Basic", Method, 0, ""},
-		{"(*ComplexType).Common", Method, 0, ""},
-		{"(*ComplexType).Size", Method, 0, ""},
-		{"(*ComplexType).String", Method, 0, ""},
-		{"(*Data).AddSection", Method, 14, ""},
-		{"(*Data).AddTypes", Method, 3, ""},
-		{"(*Data).LineReader", Method, 5, ""},
-		{"(*Data).Ranges", Method, 7, ""},
-		{"(*Data).Reader", Method, 0, ""},
-		{"(*Data).Type", Method, 0, ""},
-		{"(*DotDotDotType).Common", Method, 0, ""},
-		{"(*DotDotDotType).Size", Method, 0, ""},
-		{"(*DotDotDotType).String", Method, 0, ""},
-		{"(*Entry).AttrField", Method, 5, ""},
-		{"(*Entry).Val", Method, 0, ""},
-		{"(*EnumType).Common", Method, 0, ""},
-		{"(*EnumType).Size", Method, 0, ""},
-		{"(*EnumType).String", Method, 0, ""},
-		{"(*FloatType).Basic", Method, 0, ""},
-		{"(*FloatType).Common", Method, 0, ""},
-		{"(*FloatType).Size", Method, 0, ""},
-		{"(*FloatType).String", Method, 0, ""},
-		{"(*FuncType).Common", Method, 0, ""},
-		{"(*FuncType).Size", Method, 0, ""},
-		{"(*FuncType).String", Method, 0, ""},
-		{"(*IntType).Basic", Method, 0, ""},
-		{"(*IntType).Common", Method, 0, ""},
-		{"(*IntType).Size", Method, 0, ""},
-		{"(*IntType).String", Method, 0, ""},
-		{"(*LineReader).Files", Method, 14, ""},
-		{"(*LineReader).Next", Method, 5, ""},
-		{"(*LineReader).Reset", Method, 5, ""},
-		{"(*LineReader).Seek", Method, 5, ""},
-		{"(*LineReader).SeekPC", Method, 5, ""},
-		{"(*LineReader).Tell", Method, 5, ""},
-		{"(*PtrType).Common", Method, 0, ""},
-		{"(*PtrType).Size", Method, 0, ""},
-		{"(*PtrType).String", Method, 0, ""},
-		{"(*QualType).Common", Method, 0, ""},
-		{"(*QualType).Size", Method, 0, ""},
-		{"(*QualType).String", Method, 0, ""},
-		{"(*Reader).AddressSize", Method, 5, ""},
-		{"(*Reader).ByteOrder", Method, 14, ""},
-		{"(*Reader).Next", Method, 0, ""},
-		{"(*Reader).Seek", Method, 0, ""},
-		{"(*Reader).SeekPC", Method, 7, ""},
-		{"(*Reader).SkipChildren", Method, 0, ""},
-		{"(*StructType).Common", Method, 0, ""},
-		{"(*StructType).Defn", Method, 0, ""},
-		{"(*StructType).Size", Method, 0, ""},
-		{"(*StructType).String", Method, 0, ""},
-		{"(*TypedefType).Common", Method, 0, ""},
-		{"(*TypedefType).Size", Method, 0, ""},
-		{"(*TypedefType).String", Method, 0, ""},
-		{"(*UcharType).Basic", Method, 0, ""},
-		{"(*UcharType).Common", Method, 0, ""},
-		{"(*UcharType).Size", Method, 0, ""},
-		{"(*UcharType).String", Method, 0, ""},
-		{"(*UintType).Basic", Method, 0, ""},
-		{"(*UintType).Common", Method, 0, ""},
-		{"(*UintType).Size", Method, 0, ""},
-		{"(*UintType).String", Method, 0, ""},
-		{"(*UnspecifiedType).Basic", Method, 4, ""},
-		{"(*UnspecifiedType).Common", Method, 4, ""},
-		{"(*UnspecifiedType).Size", Method, 4, ""},
-		{"(*UnspecifiedType).String", Method, 4, ""},
-		{"(*UnsupportedType).Common", Method, 13, ""},
-		{"(*UnsupportedType).Size", Method, 13, ""},
-		{"(*UnsupportedType).String", Method, 13, ""},
-		{"(*VoidType).Common", Method, 0, ""},
-		{"(*VoidType).Size", Method, 0, ""},
-		{"(*VoidType).String", Method, 0, ""},
-		{"(Attr).GoString", Method, 0, ""},
-		{"(Attr).String", Method, 0, ""},
-		{"(Class).GoString", Method, 5, ""},
-		{"(Class).String", Method, 5, ""},
-		{"(DecodeError).Error", Method, 0, ""},
-		{"(Tag).GoString", Method, 0, ""},
-		{"(Tag).String", Method, 0, ""},
-		{"(Type).Common", Method, 0, ""},
-		{"(Type).Size", Method, 0, ""},
-		{"(Type).String", Method, 0, ""},
-		{"AddrType", Type, 0, ""},
-		{"AddrType.BasicType", Field, 0, ""},
-		{"ArrayType", Type, 0, ""},
-		{"ArrayType.CommonType", Field, 0, ""},
-		{"ArrayType.Count", Field, 0, ""},
-		{"ArrayType.StrideBitSize", Field, 0, ""},
-		{"ArrayType.Type", Field, 0, ""},
-		{"Attr", Type, 0, ""},
-		{"AttrAbstractOrigin", Const, 0, ""},
-		{"AttrAccessibility", Const, 0, ""},
-		{"AttrAddrBase", Const, 14, ""},
-		{"AttrAddrClass", Const, 0, ""},
-		{"AttrAlignment", Const, 14, ""},
-		{"AttrAllocated", Const, 0, ""},
-		{"AttrArtificial", Const, 0, ""},
-		{"AttrAssociated", Const, 0, ""},
-		{"AttrBaseTypes", Const, 0, ""},
-		{"AttrBinaryScale", Const, 14, ""},
-		{"AttrBitOffset", Const, 0, ""},
-		{"AttrBitSize", Const, 0, ""},
-		{"AttrByteSize", Const, 0, ""},
-		{"AttrCallAllCalls", Const, 14, ""},
-		{"AttrCallAllSourceCalls", Const, 14, ""},
-		{"AttrCallAllTailCalls", Const, 14, ""},
-		{"AttrCallColumn", Const, 0, ""},
-		{"AttrCallDataLocation", Const, 14, ""},
-		{"AttrCallDataValue", Const, 14, ""},
-		{"AttrCallFile", Const, 0, ""},
-		{"AttrCallLine", Const, 0, ""},
-		{"AttrCallOrigin", Const, 14, ""},
-		{"AttrCallPC", Const, 14, ""},
-		{"AttrCallParameter", Const, 14, ""},
-		{"AttrCallReturnPC", Const, 14, ""},
-		{"AttrCallTailCall", Const, 14, ""},
-		{"AttrCallTarget", Const, 14, ""},
-		{"AttrCallTargetClobbered", Const, 14, ""},
-		{"AttrCallValue", Const, 14, ""},
-		{"AttrCalling", Const, 0, ""},
-		{"AttrCommonRef", Const, 0, ""},
-		{"AttrCompDir", Const, 0, ""},
-		{"AttrConstExpr", Const, 14, ""},
-		{"AttrConstValue", Const, 0, ""},
-		{"AttrContainingType", Const, 0, ""},
-		{"AttrCount", Const, 0, ""},
-		{"AttrDataBitOffset", Const, 14, ""},
-		{"AttrDataLocation", Const, 0, ""},
-		{"AttrDataMemberLoc", Const, 0, ""},
-		{"AttrDecimalScale", Const, 14, ""},
-		{"AttrDecimalSign", Const, 14, ""},
-		{"AttrDeclColumn", Const, 0, ""},
-		{"AttrDeclFile", Const, 0, ""},
-		{"AttrDeclLine", Const, 0, ""},
-		{"AttrDeclaration", Const, 0, ""},
-		{"AttrDefaultValue", Const, 0, ""},
-		{"AttrDefaulted", Const, 14, ""},
-		{"AttrDeleted", Const, 14, ""},
-		{"AttrDescription", Const, 0, ""},
-		{"AttrDigitCount", Const, 14, ""},
-		{"AttrDiscr", Const, 0, ""},
-		{"AttrDiscrList", Const, 0, ""},
-		{"AttrDiscrValue", Const, 0, ""},
-		{"AttrDwoName", Const, 14, ""},
-		{"AttrElemental", Const, 14, ""},
-		{"AttrEncoding", Const, 0, ""},
-		{"AttrEndianity", Const, 14, ""},
-		{"AttrEntrypc", Const, 0, ""},
-		{"AttrEnumClass", Const, 14, ""},
-		{"AttrExplicit", Const, 14, ""},
-		{"AttrExportSymbols", Const, 14, ""},
-		{"AttrExtension", Const, 0, ""},
-		{"AttrExternal", Const, 0, ""},
-		{"AttrFrameBase", Const, 0, ""},
-		{"AttrFriend", Const, 0, ""},
-		{"AttrHighpc", Const, 0, ""},
-		{"AttrIdentifierCase", Const, 0, ""},
-		{"AttrImport", Const, 0, ""},
-		{"AttrInline", Const, 0, ""},
-		{"AttrIsOptional", Const, 0, ""},
-		{"AttrLanguage", Const, 0, ""},
-		{"AttrLinkageName", Const, 14, ""},
-		{"AttrLocation", Const, 0, ""},
-		{"AttrLoclistsBase", Const, 14, ""},
-		{"AttrLowerBound", Const, 0, ""},
-		{"AttrLowpc", Const, 0, ""},
-		{"AttrMacroInfo", Const, 0, ""},
-		{"AttrMacros", Const, 14, ""},
-		{"AttrMainSubprogram", Const, 14, ""},
-		{"AttrMutable", Const, 14, ""},
-		{"AttrName", Const, 0, ""},
-		{"AttrNamelistItem", Const, 0, ""},
-		{"AttrNoreturn", Const, 14, ""},
-		{"AttrObjectPointer", Const, 14, ""},
-		{"AttrOrdering", Const, 0, ""},
-		{"AttrPictureString", Const, 14, ""},
-		{"AttrPriority", Const, 0, ""},
-		{"AttrProducer", Const, 0, ""},
-		{"AttrPrototyped", Const, 0, ""},
-		{"AttrPure", Const, 14, ""},
-		{"AttrRanges", Const, 0, ""},
-		{"AttrRank", Const, 14, ""},
-		{"AttrRecursive", Const, 14, ""},
-		{"AttrReference", Const, 14, ""},
-		{"AttrReturnAddr", Const, 0, ""},
-		{"AttrRnglistsBase", Const, 14, ""},
-		{"AttrRvalueReference", Const, 14, ""},
-		{"AttrSegment", Const, 0, ""},
-		{"AttrSibling", Const, 0, ""},
-		{"AttrSignature", Const, 14, ""},
-		{"AttrSmall", Const, 14, ""},
-		{"AttrSpecification", Const, 0, ""},
-		{"AttrStartScope", Const, 0, ""},
-		{"AttrStaticLink", Const, 0, ""},
-		{"AttrStmtList", Const, 0, ""},
-		{"AttrStrOffsetsBase", Const, 14, ""},
-		{"AttrStride", Const, 0, ""},
-		{"AttrStrideSize", Const, 0, ""},
-		{"AttrStringLength", Const, 0, ""},
-		{"AttrStringLengthBitSize", Const, 14, ""},
-		{"AttrStringLengthByteSize", Const, 14, ""},
-		{"AttrThreadsScaled", Const, 14, ""},
-		{"AttrTrampoline", Const, 0, ""},
-		{"AttrType", Const, 0, ""},
-		{"AttrUpperBound", Const, 0, ""},
-		{"AttrUseLocation", Const, 0, ""},
-		{"AttrUseUTF8", Const, 0, ""},
-		{"AttrVarParam", Const, 0, ""},
-		{"AttrVirtuality", Const, 0, ""},
-		{"AttrVisibility", Const, 0, ""},
-		{"AttrVtableElemLoc", Const, 0, ""},
-		{"BasicType", Type, 0, ""},
-		{"BasicType.BitOffset", Field, 0, ""},
-		{"BasicType.BitSize", Field, 0, ""},
-		{"BasicType.CommonType", Field, 0, ""},
-		{"BasicType.DataBitOffset", Field, 18, ""},
-		{"BoolType", Type, 0, ""},
-		{"BoolType.BasicType", Field, 0, ""},
-		{"CharType", Type, 0, ""},
-		{"CharType.BasicType", Field, 0, ""},
-		{"Class", Type, 5, ""},
-		{"ClassAddrPtr", Const, 14, ""},
-		{"ClassAddress", Const, 5, ""},
-		{"ClassBlock", Const, 5, ""},
-		{"ClassConstant", Const, 5, ""},
-		{"ClassExprLoc", Const, 5, ""},
-		{"ClassFlag", Const, 5, ""},
-		{"ClassLinePtr", Const, 5, ""},
-		{"ClassLocList", Const, 14, ""},
-		{"ClassLocListPtr", Const, 5, ""},
-		{"ClassMacPtr", Const, 5, ""},
-		{"ClassRangeListPtr", Const, 5, ""},
-		{"ClassReference", Const, 5, ""},
-		{"ClassReferenceAlt", Const, 5, ""},
-		{"ClassReferenceSig", Const, 5, ""},
-		{"ClassRngList", Const, 14, ""},
-		{"ClassRngListsPtr", Const, 14, ""},
-		{"ClassStrOffsetsPtr", Const, 14, ""},
-		{"ClassString", Const, 5, ""},
-		{"ClassStringAlt", Const, 5, ""},
-		{"ClassUnknown", Const, 6, ""},
-		{"CommonType", Type, 0, ""},
-		{"CommonType.ByteSize", Field, 0, ""},
-		{"CommonType.Name", Field, 0, ""},
-		{"ComplexType", Type, 0, ""},
-		{"ComplexType.BasicType", Field, 0, ""},
-		{"Data", Type, 0, ""},
-		{"DecodeError", Type, 0, ""},
-		{"DecodeError.Err", Field, 0, ""},
-		{"DecodeError.Name", Field, 0, ""},
-		{"DecodeError.Offset", Field, 0, ""},
-		{"DotDotDotType", Type, 0, ""},
-		{"DotDotDotType.CommonType", Field, 0, ""},
-		{"Entry", Type, 0, ""},
-		{"Entry.Children", Field, 0, ""},
-		{"Entry.Field", Field, 0, ""},
-		{"Entry.Offset", Field, 0, ""},
-		{"Entry.Tag", Field, 0, ""},
-		{"EnumType", Type, 0, ""},
-		{"EnumType.CommonType", Field, 0, ""},
-		{"EnumType.EnumName", Field, 0, ""},
-		{"EnumType.Val", Field, 0, ""},
-		{"EnumValue", Type, 0, ""},
-		{"EnumValue.Name", Field, 0, ""},
-		{"EnumValue.Val", Field, 0, ""},
-		{"ErrUnknownPC", Var, 5, ""},
-		{"Field", Type, 0, ""},
-		{"Field.Attr", Field, 0, ""},
-		{"Field.Class", Field, 5, ""},
-		{"Field.Val", Field, 0, ""},
-		{"FloatType", Type, 0, ""},
-		{"FloatType.BasicType", Field, 0, ""},
-		{"FuncType", Type, 0, ""},
-		{"FuncType.CommonType", Field, 0, ""},
-		{"FuncType.ParamType", Field, 0, ""},
-		{"FuncType.ReturnType", Field, 0, ""},
-		{"IntType", Type, 0, ""},
-		{"IntType.BasicType", Field, 0, ""},
-		{"LineEntry", Type, 5, ""},
-		{"LineEntry.Address", Field, 5, ""},
-		{"LineEntry.BasicBlock", Field, 5, ""},
-		{"LineEntry.Column", Field, 5, ""},
-		{"LineEntry.Discriminator", Field, 5, ""},
-		{"LineEntry.EndSequence", Field, 5, ""},
-		{"LineEntry.EpilogueBegin", Field, 5, ""},
-		{"LineEntry.File", Field, 5, ""},
-		{"LineEntry.ISA", Field, 5, ""},
-		{"LineEntry.IsStmt", Field, 5, ""},
-		{"LineEntry.Line", Field, 5, ""},
-		{"LineEntry.OpIndex", Field, 5, ""},
-		{"LineEntry.PrologueEnd", Field, 5, ""},
-		{"LineFile", Type, 5, ""},
-		{"LineFile.Length", Field, 5, ""},
-		{"LineFile.Mtime", Field, 5, ""},
-		{"LineFile.Name", Field, 5, ""},
-		{"LineReader", Type, 5, ""},
-		{"LineReaderPos", Type, 5, ""},
-		{"New", Func, 0, "func(abbrev []byte, aranges []byte, frame []byte, info []byte, line []byte, pubnames []byte, ranges []byte, str []byte) (*Data, error)"},
-		{"Offset", Type, 0, ""},
-		{"PtrType", Type, 0, ""},
-		{"PtrType.CommonType", Field, 0, ""},
-		{"PtrType.Type", Field, 0, ""},
-		{"QualType", Type, 0, ""},
-		{"QualType.CommonType", Field, 0, ""},
-		{"QualType.Qual", Field, 0, ""},
-		{"QualType.Type", Field, 0, ""},
-		{"Reader", Type, 0, ""},
-		{"StructField", Type, 0, ""},
-		{"StructField.BitOffset", Field, 0, ""},
-		{"StructField.BitSize", Field, 0, ""},
-		{"StructField.ByteOffset", Field, 0, ""},
-		{"StructField.ByteSize", Field, 0, ""},
-		{"StructField.DataBitOffset", Field, 18, ""},
-		{"StructField.Name", Field, 0, ""},
-		{"StructField.Type", Field, 0, ""},
-		{"StructType", Type, 0, ""},
-		{"StructType.CommonType", Field, 0, ""},
-		{"StructType.Field", Field, 0, ""},
-		{"StructType.Incomplete", Field, 0, ""},
-		{"StructType.Kind", Field, 0, ""},
-		{"StructType.StructName", Field, 0, ""},
-		{"Tag", Type, 0, ""},
-		{"TagAccessDeclaration", Const, 0, ""},
-		{"TagArrayType", Const, 0, ""},
-		{"TagAtomicType", Const, 14, ""},
-		{"TagBaseType", Const, 0, ""},
-		{"TagCallSite", Const, 14, ""},
-		{"TagCallSiteParameter", Const, 14, ""},
-		{"TagCatchDwarfBlock", Const, 0, ""},
-		{"TagClassType", Const, 0, ""},
-		{"TagCoarrayType", Const, 14, ""},
-		{"TagCommonDwarfBlock", Const, 0, ""},
-		{"TagCommonInclusion", Const, 0, ""},
-		{"TagCompileUnit", Const, 0, ""},
-		{"TagCondition", Const, 3, ""},
-		{"TagConstType", Const, 0, ""},
-		{"TagConstant", Const, 0, ""},
-		{"TagDwarfProcedure", Const, 0, ""},
-		{"TagDynamicType", Const, 14, ""},
-		{"TagEntryPoint", Const, 0, ""},
-		{"TagEnumerationType", Const, 0, ""},
-		{"TagEnumerator", Const, 0, ""},
-		{"TagFileType", Const, 0, ""},
-		{"TagFormalParameter", Const, 0, ""},
-		{"TagFriend", Const, 0, ""},
-		{"TagGenericSubrange", Const, 14, ""},
-		{"TagImmutableType", Const, 14, ""},
-		{"TagImportedDeclaration", Const, 0, ""},
-		{"TagImportedModule", Const, 0, ""},
-		{"TagImportedUnit", Const, 0, ""},
-		{"TagInheritance", Const, 0, ""},
-		{"TagInlinedSubroutine", Const, 0, ""},
-		{"TagInterfaceType", Const, 0, ""},
-		{"TagLabel", Const, 0, ""},
-		{"TagLexDwarfBlock", Const, 0, ""},
-		{"TagMember", Const, 0, ""},
-		{"TagModule", Const, 0, ""},
-		{"TagMutableType", Const, 0, ""},
-		{"TagNamelist", Const, 0, ""},
-		{"TagNamelistItem", Const, 0, ""},
-		{"TagNamespace", Const, 0, ""},
-		{"TagPackedType", Const, 0, ""},
-		{"TagPartialUnit", Const, 0, ""},
-		{"TagPointerType", Const, 0, ""},
-		{"TagPtrToMemberType", Const, 0, ""},
-		{"TagReferenceType", Const, 0, ""},
-		{"TagRestrictType", Const, 0, ""},
-		{"TagRvalueReferenceType", Const, 3, ""},
-		{"TagSetType", Const, 0, ""},
-		{"TagSharedType", Const, 3, ""},
-		{"TagSkeletonUnit", Const, 14, ""},
-		{"TagStringType", Const, 0, ""},
-		{"TagStructType", Const, 0, ""},
-		{"TagSubprogram", Const, 0, ""},
-		{"TagSubrangeType", Const, 0, ""},
-		{"TagSubroutineType", Const, 0, ""},
-		{"TagTemplateAlias", Const, 3, ""},
-		{"TagTemplateTypeParameter", Const, 0, ""},
-		{"TagTemplateValueParameter", Const, 0, ""},
-		{"TagThrownType", Const, 0, ""},
-		{"TagTryDwarfBlock", Const, 0, ""},
-		{"TagTypeUnit", Const, 3, ""},
-		{"TagTypedef", Const, 0, ""},
-		{"TagUnionType", Const, 0, ""},
-		{"TagUnspecifiedParameters", Const, 0, ""},
-		{"TagUnspecifiedType", Const, 0, ""},
-		{"TagVariable", Const, 0, ""},
-		{"TagVariant", Const, 0, ""},
-		{"TagVariantPart", Const, 0, ""},
-		{"TagVolatileType", Const, 0, ""},
-		{"TagWithStmt", Const, 0, ""},
-		{"Type", Type, 0, ""},
-		{"TypedefType", Type, 0, ""},
-		{"TypedefType.CommonType", Field, 0, ""},
-		{"TypedefType.Type", Field, 0, ""},
-		{"UcharType", Type, 0, ""},
-		{"UcharType.BasicType", Field, 0, ""},
-		{"UintType", Type, 0, ""},
-		{"UintType.BasicType", Field, 0, ""},
-		{"UnspecifiedType", Type, 4, ""},
-		{"UnspecifiedType.BasicType", Field, 4, ""},
-		{"UnsupportedType", Type, 13, ""},
-		{"UnsupportedType.CommonType", Field, 13, ""},
-		{"UnsupportedType.Tag", Field, 13, ""},
-		{"VoidType", Type, 0, ""},
-		{"VoidType.CommonType", Field, 0, ""},
-	},
-	"debug/elf": {
-		{"(*File).Close", Method, 0, ""},
-		{"(*File).DWARF", Method, 0, ""},
-		{"(*File).DynString", Method, 1, ""},
-		{"(*File).DynValue", Method, 21, ""},
-		{"(*File).DynamicSymbols", Method, 4, ""},
-		{"(*File).DynamicVersionNeeds", Method, 24, ""},
-		{"(*File).DynamicVersions", Method, 24, ""},
-		{"(*File).ImportedLibraries", Method, 0, ""},
-		{"(*File).ImportedSymbols", Method, 0, ""},
-		{"(*File).Section", Method, 0, ""},
-		{"(*File).SectionByType", Method, 0, ""},
-		{"(*File).Symbols", Method, 0, ""},
-		{"(*FormatError).Error", Method, 0, ""},
-		{"(*Prog).Open", Method, 0, ""},
-		{"(*Section).Data", Method, 0, ""},
-		{"(*Section).Open", Method, 0, ""},
-		{"(Class).GoString", Method, 0, ""},
-		{"(Class).String", Method, 0, ""},
-		{"(CompressionType).GoString", Method, 6, ""},
-		{"(CompressionType).String", Method, 6, ""},
-		{"(Data).GoString", Method, 0, ""},
-		{"(Data).String", Method, 0, ""},
-		{"(DynFlag).GoString", Method, 0, ""},
-		{"(DynFlag).String", Method, 0, ""},
-		{"(DynFlag1).GoString", Method, 21, ""},
-		{"(DynFlag1).String", Method, 21, ""},
-		{"(DynTag).GoString", Method, 0, ""},
-		{"(DynTag).String", Method, 0, ""},
-		{"(Machine).GoString", Method, 0, ""},
-		{"(Machine).String", Method, 0, ""},
-		{"(NType).GoString", Method, 0, ""},
-		{"(NType).String", Method, 0, ""},
-		{"(OSABI).GoString", Method, 0, ""},
-		{"(OSABI).String", Method, 0, ""},
-		{"(Prog).ReadAt", Method, 0, ""},
-		{"(ProgFlag).GoString", Method, 0, ""},
-		{"(ProgFlag).String", Method, 0, ""},
-		{"(ProgType).GoString", Method, 0, ""},
-		{"(ProgType).String", Method, 0, ""},
-		{"(R_386).GoString", Method, 0, ""},
-		{"(R_386).String", Method, 0, ""},
-		{"(R_390).GoString", Method, 7, ""},
-		{"(R_390).String", Method, 7, ""},
-		{"(R_AARCH64).GoString", Method, 4, ""},
-		{"(R_AARCH64).String", Method, 4, ""},
-		{"(R_ALPHA).GoString", Method, 0, ""},
-		{"(R_ALPHA).String", Method, 0, ""},
-		{"(R_ARM).GoString", Method, 0, ""},
-		{"(R_ARM).String", Method, 0, ""},
-		{"(R_LARCH).GoString", Method, 19, ""},
-		{"(R_LARCH).String", Method, 19, ""},
-		{"(R_MIPS).GoString", Method, 6, ""},
-		{"(R_MIPS).String", Method, 6, ""},
-		{"(R_PPC).GoString", Method, 0, ""},
-		{"(R_PPC).String", Method, 0, ""},
-		{"(R_PPC64).GoString", Method, 5, ""},
-		{"(R_PPC64).String", Method, 5, ""},
-		{"(R_RISCV).GoString", Method, 11, ""},
-		{"(R_RISCV).String", Method, 11, ""},
-		{"(R_SPARC).GoString", Method, 0, ""},
-		{"(R_SPARC).String", Method, 0, ""},
-		{"(R_X86_64).GoString", Method, 0, ""},
-		{"(R_X86_64).String", Method, 0, ""},
-		{"(Section).ReadAt", Method, 0, ""},
-		{"(SectionFlag).GoString", Method, 0, ""},
-		{"(SectionFlag).String", Method, 0, ""},
-		{"(SectionIndex).GoString", Method, 0, ""},
-		{"(SectionIndex).String", Method, 0, ""},
-		{"(SectionType).GoString", Method, 0, ""},
-		{"(SectionType).String", Method, 0, ""},
-		{"(SymBind).GoString", Method, 0, ""},
-		{"(SymBind).String", Method, 0, ""},
-		{"(SymType).GoString", Method, 0, ""},
-		{"(SymType).String", Method, 0, ""},
-		{"(SymVis).GoString", Method, 0, ""},
-		{"(SymVis).String", Method, 0, ""},
-		{"(Type).GoString", Method, 0, ""},
-		{"(Type).String", Method, 0, ""},
-		{"(Version).GoString", Method, 0, ""},
-		{"(Version).String", Method, 0, ""},
-		{"(VersionIndex).Index", Method, 24, ""},
-		{"(VersionIndex).IsHidden", Method, 24, ""},
-		{"ARM_MAGIC_TRAMP_NUMBER", Const, 0, ""},
-		{"COMPRESS_HIOS", Const, 6, ""},
-		{"COMPRESS_HIPROC", Const, 6, ""},
-		{"COMPRESS_LOOS", Const, 6, ""},
-		{"COMPRESS_LOPROC", Const, 6, ""},
-		{"COMPRESS_ZLIB", Const, 6, ""},
-		{"COMPRESS_ZSTD", Const, 21, ""},
-		{"Chdr32", Type, 6, ""},
-		{"Chdr32.Addralign", Field, 6, ""},
-		{"Chdr32.Size", Field, 6, ""},
-		{"Chdr32.Type", Field, 6, ""},
-		{"Chdr64", Type, 6, ""},
-		{"Chdr64.Addralign", Field, 6, ""},
-		{"Chdr64.Size", Field, 6, ""},
-		{"Chdr64.Type", Field, 6, ""},
-		{"Class", Type, 0, ""},
-		{"CompressionType", Type, 6, ""},
-		{"DF_1_CONFALT", Const, 21, ""},
-		{"DF_1_DIRECT", Const, 21, ""},
-		{"DF_1_DISPRELDNE", Const, 21, ""},
-		{"DF_1_DISPRELPND", Const, 21, ""},
-		{"DF_1_EDITED", Const, 21, ""},
-		{"DF_1_ENDFILTEE", Const, 21, ""},
-		{"DF_1_GLOBAL", Const, 21, ""},
-		{"DF_1_GLOBAUDIT", Const, 21, ""},
-		{"DF_1_GROUP", Const, 21, ""},
-		{"DF_1_IGNMULDEF", Const, 21, ""},
-		{"DF_1_INITFIRST", Const, 21, ""},
-		{"DF_1_INTERPOSE", Const, 21, ""},
-		{"DF_1_KMOD", Const, 21, ""},
-		{"DF_1_LOADFLTR", Const, 21, ""},
-		{"DF_1_NOCOMMON", Const, 21, ""},
-		{"DF_1_NODEFLIB", Const, 21, ""},
-		{"DF_1_NODELETE", Const, 21, ""},
-		{"DF_1_NODIRECT", Const, 21, ""},
-		{"DF_1_NODUMP", Const, 21, ""},
-		{"DF_1_NOHDR", Const, 21, ""},
-		{"DF_1_NOKSYMS", Const, 21, ""},
-		{"DF_1_NOOPEN", Const, 21, ""},
-		{"DF_1_NORELOC", Const, 21, ""},
-		{"DF_1_NOW", Const, 21, ""},
-		{"DF_1_ORIGIN", Const, 21, ""},
-		{"DF_1_PIE", Const, 21, ""},
-		{"DF_1_SINGLETON", Const, 21, ""},
-		{"DF_1_STUB", Const, 21, ""},
-		{"DF_1_SYMINTPOSE", Const, 21, ""},
-		{"DF_1_TRANS", Const, 21, ""},
-		{"DF_1_WEAKFILTER", Const, 21, ""},
-		{"DF_BIND_NOW", Const, 0, ""},
-		{"DF_ORIGIN", Const, 0, ""},
-		{"DF_STATIC_TLS", Const, 0, ""},
-		{"DF_SYMBOLIC", Const, 0, ""},
-		{"DF_TEXTREL", Const, 0, ""},
-		{"DT_ADDRRNGHI", Const, 16, ""},
-		{"DT_ADDRRNGLO", Const, 16, ""},
-		{"DT_AUDIT", Const, 16, ""},
-		{"DT_AUXILIARY", Const, 16, ""},
-		{"DT_BIND_NOW", Const, 0, ""},
-		{"DT_CHECKSUM", Const, 16, ""},
-		{"DT_CONFIG", Const, 16, ""},
-		{"DT_DEBUG", Const, 0, ""},
-		{"DT_DEPAUDIT", Const, 16, ""},
-		{"DT_ENCODING", Const, 0, ""},
-		{"DT_FEATURE", Const, 16, ""},
-		{"DT_FILTER", Const, 16, ""},
-		{"DT_FINI", Const, 0, ""},
-		{"DT_FINI_ARRAY", Const, 0, ""},
-		{"DT_FINI_ARRAYSZ", Const, 0, ""},
-		{"DT_FLAGS", Const, 0, ""},
-		{"DT_FLAGS_1", Const, 16, ""},
-		{"DT_GNU_CONFLICT", Const, 16, ""},
-		{"DT_GNU_CONFLICTSZ", Const, 16, ""},
-		{"DT_GNU_HASH", Const, 16, ""},
-		{"DT_GNU_LIBLIST", Const, 16, ""},
-		{"DT_GNU_LIBLISTSZ", Const, 16, ""},
-		{"DT_GNU_PRELINKED", Const, 16, ""},
-		{"DT_HASH", Const, 0, ""},
-		{"DT_HIOS", Const, 0, ""},
-		{"DT_HIPROC", Const, 0, ""},
-		{"DT_INIT", Const, 0, ""},
-		{"DT_INIT_ARRAY", Const, 0, ""},
-		{"DT_INIT_ARRAYSZ", Const, 0, ""},
-		{"DT_JMPREL", Const, 0, ""},
-		{"DT_LOOS", Const, 0, ""},
-		{"DT_LOPROC", Const, 0, ""},
-		{"DT_MIPS_AUX_DYNAMIC", Const, 16, ""},
-		{"DT_MIPS_BASE_ADDRESS", Const, 16, ""},
-		{"DT_MIPS_COMPACT_SIZE", Const, 16, ""},
-		{"DT_MIPS_CONFLICT", Const, 16, ""},
-		{"DT_MIPS_CONFLICTNO", Const, 16, ""},
-		{"DT_MIPS_CXX_FLAGS", Const, 16, ""},
-		{"DT_MIPS_DELTA_CLASS", Const, 16, ""},
-		{"DT_MIPS_DELTA_CLASSSYM", Const, 16, ""},
-		{"DT_MIPS_DELTA_CLASSSYM_NO", Const, 16, ""},
-		{"DT_MIPS_DELTA_CLASS_NO", Const, 16, ""},
-		{"DT_MIPS_DELTA_INSTANCE", Const, 16, ""},
-		{"DT_MIPS_DELTA_INSTANCE_NO", Const, 16, ""},
-		{"DT_MIPS_DELTA_RELOC", Const, 16, ""},
-		{"DT_MIPS_DELTA_RELOC_NO", Const, 16, ""},
-		{"DT_MIPS_DELTA_SYM", Const, 16, ""},
-		{"DT_MIPS_DELTA_SYM_NO", Const, 16, ""},
-		{"DT_MIPS_DYNSTR_ALIGN", Const, 16, ""},
-		{"DT_MIPS_FLAGS", Const, 16, ""},
-		{"DT_MIPS_GOTSYM", Const, 16, ""},
-		{"DT_MIPS_GP_VALUE", Const, 16, ""},
-		{"DT_MIPS_HIDDEN_GOTIDX", Const, 16, ""},
-		{"DT_MIPS_HIPAGENO", Const, 16, ""},
-		{"DT_MIPS_ICHECKSUM", Const, 16, ""},
-		{"DT_MIPS_INTERFACE", Const, 16, ""},
-		{"DT_MIPS_INTERFACE_SIZE", Const, 16, ""},
-		{"DT_MIPS_IVERSION", Const, 16, ""},
-		{"DT_MIPS_LIBLIST", Const, 16, ""},
-		{"DT_MIPS_LIBLISTNO", Const, 16, ""},
-		{"DT_MIPS_LOCALPAGE_GOTIDX", Const, 16, ""},
-		{"DT_MIPS_LOCAL_GOTIDX", Const, 16, ""},
-		{"DT_MIPS_LOCAL_GOTNO", Const, 16, ""},
-		{"DT_MIPS_MSYM", Const, 16, ""},
-		{"DT_MIPS_OPTIONS", Const, 16, ""},
-		{"DT_MIPS_PERF_SUFFIX", Const, 16, ""},
-		{"DT_MIPS_PIXIE_INIT", Const, 16, ""},
-		{"DT_MIPS_PLTGOT", Const, 16, ""},
-		{"DT_MIPS_PROTECTED_GOTIDX", Const, 16, ""},
-		{"DT_MIPS_RLD_MAP", Const, 16, ""},
-		{"DT_MIPS_RLD_MAP_REL", Const, 16, ""},
-		{"DT_MIPS_RLD_TEXT_RESOLVE_ADDR", Const, 16, ""},
-		{"DT_MIPS_RLD_VERSION", Const, 16, ""},
-		{"DT_MIPS_RWPLT", Const, 16, ""},
-		{"DT_MIPS_SYMBOL_LIB", Const, 16, ""},
-		{"DT_MIPS_SYMTABNO", Const, 16, ""},
-		{"DT_MIPS_TIME_STAMP", Const, 16, ""},
-		{"DT_MIPS_UNREFEXTNO", Const, 16, ""},
-		{"DT_MOVEENT", Const, 16, ""},
-		{"DT_MOVESZ", Const, 16, ""},
-		{"DT_MOVETAB", Const, 16, ""},
-		{"DT_NEEDED", Const, 0, ""},
-		{"DT_NULL", Const, 0, ""},
-		{"DT_PLTGOT", Const, 0, ""},
-		{"DT_PLTPAD", Const, 16, ""},
-		{"DT_PLTPADSZ", Const, 16, ""},
-		{"DT_PLTREL", Const, 0, ""},
-		{"DT_PLTRELSZ", Const, 0, ""},
-		{"DT_POSFLAG_1", Const, 16, ""},
-		{"DT_PPC64_GLINK", Const, 16, ""},
-		{"DT_PPC64_OPD", Const, 16, ""},
-		{"DT_PPC64_OPDSZ", Const, 16, ""},
-		{"DT_PPC64_OPT", Const, 16, ""},
-		{"DT_PPC_GOT", Const, 16, ""},
-		{"DT_PPC_OPT", Const, 16, ""},
-		{"DT_PREINIT_ARRAY", Const, 0, ""},
-		{"DT_PREINIT_ARRAYSZ", Const, 0, ""},
-		{"DT_REL", Const, 0, ""},
-		{"DT_RELA", Const, 0, ""},
-		{"DT_RELACOUNT", Const, 16, ""},
-		{"DT_RELAENT", Const, 0, ""},
-		{"DT_RELASZ", Const, 0, ""},
-		{"DT_RELCOUNT", Const, 16, ""},
-		{"DT_RELENT", Const, 0, ""},
-		{"DT_RELSZ", Const, 0, ""},
-		{"DT_RPATH", Const, 0, ""},
-		{"DT_RUNPATH", Const, 0, ""},
-		{"DT_SONAME", Const, 0, ""},
-		{"DT_SPARC_REGISTER", Const, 16, ""},
-		{"DT_STRSZ", Const, 0, ""},
-		{"DT_STRTAB", Const, 0, ""},
-		{"DT_SYMBOLIC", Const, 0, ""},
-		{"DT_SYMENT", Const, 0, ""},
-		{"DT_SYMINENT", Const, 16, ""},
-		{"DT_SYMINFO", Const, 16, ""},
-		{"DT_SYMINSZ", Const, 16, ""},
-		{"DT_SYMTAB", Const, 0, ""},
-		{"DT_SYMTAB_SHNDX", Const, 16, ""},
-		{"DT_TEXTREL", Const, 0, ""},
-		{"DT_TLSDESC_GOT", Const, 16, ""},
-		{"DT_TLSDESC_PLT", Const, 16, ""},
-		{"DT_USED", Const, 16, ""},
-		{"DT_VALRNGHI", Const, 16, ""},
-		{"DT_VALRNGLO", Const, 16, ""},
-		{"DT_VERDEF", Const, 16, ""},
-		{"DT_VERDEFNUM", Const, 16, ""},
-		{"DT_VERNEED", Const, 0, ""},
-		{"DT_VERNEEDNUM", Const, 0, ""},
-		{"DT_VERSYM", Const, 0, ""},
-		{"Data", Type, 0, ""},
-		{"Dyn32", Type, 0, ""},
-		{"Dyn32.Tag", Field, 0, ""},
-		{"Dyn32.Val", Field, 0, ""},
-		{"Dyn64", Type, 0, ""},
-		{"Dyn64.Tag", Field, 0, ""},
-		{"Dyn64.Val", Field, 0, ""},
-		{"DynFlag", Type, 0, ""},
-		{"DynFlag1", Type, 21, ""},
-		{"DynTag", Type, 0, ""},
-		{"DynamicVersion", Type, 24, ""},
-		{"DynamicVersion.Deps", Field, 24, ""},
-		{"DynamicVersion.Flags", Field, 24, ""},
-		{"DynamicVersion.Index", Field, 24, ""},
-		{"DynamicVersion.Name", Field, 24, ""},
-		{"DynamicVersionDep", Type, 24, ""},
-		{"DynamicVersionDep.Dep", Field, 24, ""},
-		{"DynamicVersionDep.Flags", Field, 24, ""},
-		{"DynamicVersionDep.Index", Field, 24, ""},
-		{"DynamicVersionFlag", Type, 24, ""},
-		{"DynamicVersionNeed", Type, 24, ""},
-		{"DynamicVersionNeed.Name", Field, 24, ""},
-		{"DynamicVersionNeed.Needs", Field, 24, ""},
-		{"EI_ABIVERSION", Const, 0, ""},
-		{"EI_CLASS", Const, 0, ""},
-		{"EI_DATA", Const, 0, ""},
-		{"EI_NIDENT", Const, 0, ""},
-		{"EI_OSABI", Const, 0, ""},
-		{"EI_PAD", Const, 0, ""},
-		{"EI_VERSION", Const, 0, ""},
-		{"ELFCLASS32", Const, 0, ""},
-		{"ELFCLASS64", Const, 0, ""},
-		{"ELFCLASSNONE", Const, 0, ""},
-		{"ELFDATA2LSB", Const, 0, ""},
-		{"ELFDATA2MSB", Const, 0, ""},
-		{"ELFDATANONE", Const, 0, ""},
-		{"ELFMAG", Const, 0, ""},
-		{"ELFOSABI_86OPEN", Const, 0, ""},
-		{"ELFOSABI_AIX", Const, 0, ""},
-		{"ELFOSABI_ARM", Const, 0, ""},
-		{"ELFOSABI_AROS", Const, 11, ""},
-		{"ELFOSABI_CLOUDABI", Const, 11, ""},
-		{"ELFOSABI_FENIXOS", Const, 11, ""},
-		{"ELFOSABI_FREEBSD", Const, 0, ""},
-		{"ELFOSABI_HPUX", Const, 0, ""},
-		{"ELFOSABI_HURD", Const, 0, ""},
-		{"ELFOSABI_IRIX", Const, 0, ""},
-		{"ELFOSABI_LINUX", Const, 0, ""},
-		{"ELFOSABI_MODESTO", Const, 0, ""},
-		{"ELFOSABI_NETBSD", Const, 0, ""},
-		{"ELFOSABI_NONE", Const, 0, ""},
-		{"ELFOSABI_NSK", Const, 0, ""},
-		{"ELFOSABI_OPENBSD", Const, 0, ""},
-		{"ELFOSABI_OPENVMS", Const, 0, ""},
-		{"ELFOSABI_SOLARIS", Const, 0, ""},
-		{"ELFOSABI_STANDALONE", Const, 0, ""},
-		{"ELFOSABI_TRU64", Const, 0, ""},
-		{"EM_386", Const, 0, ""},
-		{"EM_486", Const, 0, ""},
-		{"EM_56800EX", Const, 11, ""},
-		{"EM_68HC05", Const, 11, ""},
-		{"EM_68HC08", Const, 11, ""},
-		{"EM_68HC11", Const, 11, ""},
-		{"EM_68HC12", Const, 0, ""},
-		{"EM_68HC16", Const, 11, ""},
-		{"EM_68K", Const, 0, ""},
-		{"EM_78KOR", Const, 11, ""},
-		{"EM_8051", Const, 11, ""},
-		{"EM_860", Const, 0, ""},
-		{"EM_88K", Const, 0, ""},
-		{"EM_960", Const, 0, ""},
-		{"EM_AARCH64", Const, 4, ""},
-		{"EM_ALPHA", Const, 0, ""},
-		{"EM_ALPHA_STD", Const, 0, ""},
-		{"EM_ALTERA_NIOS2", Const, 11, ""},
-		{"EM_AMDGPU", Const, 11, ""},
-		{"EM_ARC", Const, 0, ""},
-		{"EM_ARCA", Const, 11, ""},
-		{"EM_ARC_COMPACT", Const, 11, ""},
-		{"EM_ARC_COMPACT2", Const, 11, ""},
-		{"EM_ARM", Const, 0, ""},
-		{"EM_AVR", Const, 11, ""},
-		{"EM_AVR32", Const, 11, ""},
-		{"EM_BA1", Const, 11, ""},
-		{"EM_BA2", Const, 11, ""},
-		{"EM_BLACKFIN", Const, 11, ""},
-		{"EM_BPF", Const, 11, ""},
-		{"EM_C166", Const, 11, ""},
-		{"EM_CDP", Const, 11, ""},
-		{"EM_CE", Const, 11, ""},
-		{"EM_CLOUDSHIELD", Const, 11, ""},
-		{"EM_COGE", Const, 11, ""},
-		{"EM_COLDFIRE", Const, 0, ""},
-		{"EM_COOL", Const, 11, ""},
-		{"EM_COREA_1ST", Const, 11, ""},
-		{"EM_COREA_2ND", Const, 11, ""},
-		{"EM_CR", Const, 11, ""},
-		{"EM_CR16", Const, 11, ""},
-		{"EM_CRAYNV2", Const, 11, ""},
-		{"EM_CRIS", Const, 11, ""},
-		{"EM_CRX", Const, 11, ""},
-		{"EM_CSR_KALIMBA", Const, 11, ""},
-		{"EM_CUDA", Const, 11, ""},
-		{"EM_CYPRESS_M8C", Const, 11, ""},
-		{"EM_D10V", Const, 11, ""},
-		{"EM_D30V", Const, 11, ""},
-		{"EM_DSP24", Const, 11, ""},
-		{"EM_DSPIC30F", Const, 11, ""},
-		{"EM_DXP", Const, 11, ""},
-		{"EM_ECOG1", Const, 11, ""},
-		{"EM_ECOG16", Const, 11, ""},
-		{"EM_ECOG1X", Const, 11, ""},
-		{"EM_ECOG2", Const, 11, ""},
-		{"EM_ETPU", Const, 11, ""},
-		{"EM_EXCESS", Const, 11, ""},
-		{"EM_F2MC16", Const, 11, ""},
-		{"EM_FIREPATH", Const, 11, ""},
-		{"EM_FR20", Const, 0, ""},
-		{"EM_FR30", Const, 11, ""},
-		{"EM_FT32", Const, 11, ""},
-		{"EM_FX66", Const, 11, ""},
-		{"EM_H8S", Const, 0, ""},
-		{"EM_H8_300", Const, 0, ""},
-		{"EM_H8_300H", Const, 0, ""},
-		{"EM_H8_500", Const, 0, ""},
-		{"EM_HUANY", Const, 11, ""},
-		{"EM_IA_64", Const, 0, ""},
-		{"EM_INTEL205", Const, 11, ""},
-		{"EM_INTEL206", Const, 11, ""},
-		{"EM_INTEL207", Const, 11, ""},
-		{"EM_INTEL208", Const, 11, ""},
-		{"EM_INTEL209", Const, 11, ""},
-		{"EM_IP2K", Const, 11, ""},
-		{"EM_JAVELIN", Const, 11, ""},
-		{"EM_K10M", Const, 11, ""},
-		{"EM_KM32", Const, 11, ""},
-		{"EM_KMX16", Const, 11, ""},
-		{"EM_KMX32", Const, 11, ""},
-		{"EM_KMX8", Const, 11, ""},
-		{"EM_KVARC", Const, 11, ""},
-		{"EM_L10M", Const, 11, ""},
-		{"EM_LANAI", Const, 11, ""},
-		{"EM_LATTICEMICO32", Const, 11, ""},
-		{"EM_LOONGARCH", Const, 19, ""},
-		{"EM_M16C", Const, 11, ""},
-		{"EM_M32", Const, 0, ""},
-		{"EM_M32C", Const, 11, ""},
-		{"EM_M32R", Const, 11, ""},
-		{"EM_MANIK", Const, 11, ""},
-		{"EM_MAX", Const, 11, ""},
-		{"EM_MAXQ30", Const, 11, ""},
-		{"EM_MCHP_PIC", Const, 11, ""},
-		{"EM_MCST_ELBRUS", Const, 11, ""},
-		{"EM_ME16", Const, 0, ""},
-		{"EM_METAG", Const, 11, ""},
-		{"EM_MICROBLAZE", Const, 11, ""},
-		{"EM_MIPS", Const, 0, ""},
-		{"EM_MIPS_RS3_LE", Const, 0, ""},
-		{"EM_MIPS_RS4_BE", Const, 0, ""},
-		{"EM_MIPS_X", Const, 0, ""},
-		{"EM_MMA", Const, 0, ""},
-		{"EM_MMDSP_PLUS", Const, 11, ""},
-		{"EM_MMIX", Const, 11, ""},
-		{"EM_MN10200", Const, 11, ""},
-		{"EM_MN10300", Const, 11, ""},
-		{"EM_MOXIE", Const, 11, ""},
-		{"EM_MSP430", Const, 11, ""},
-		{"EM_NCPU", Const, 0, ""},
-		{"EM_NDR1", Const, 0, ""},
-		{"EM_NDS32", Const, 11, ""},
-		{"EM_NONE", Const, 0, ""},
-		{"EM_NORC", Const, 11, ""},
-		{"EM_NS32K", Const, 11, ""},
-		{"EM_OPEN8", Const, 11, ""},
-		{"EM_OPENRISC", Const, 11, ""},
-		{"EM_PARISC", Const, 0, ""},
-		{"EM_PCP", Const, 0, ""},
-		{"EM_PDP10", Const, 11, ""},
-		{"EM_PDP11", Const, 11, ""},
-		{"EM_PDSP", Const, 11, ""},
-		{"EM_PJ", Const, 11, ""},
-		{"EM_PPC", Const, 0, ""},
-		{"EM_PPC64", Const, 0, ""},
-		{"EM_PRISM", Const, 11, ""},
-		{"EM_QDSP6", Const, 11, ""},
-		{"EM_R32C", Const, 11, ""},
-		{"EM_RCE", Const, 0, ""},
-		{"EM_RH32", Const, 0, ""},
-		{"EM_RISCV", Const, 11, ""},
-		{"EM_RL78", Const, 11, ""},
-		{"EM_RS08", Const, 11, ""},
-		{"EM_RX", Const, 11, ""},
-		{"EM_S370", Const, 0, ""},
-		{"EM_S390", Const, 0, ""},
-		{"EM_SCORE7", Const, 11, ""},
-		{"EM_SEP", Const, 11, ""},
-		{"EM_SE_C17", Const, 11, ""},
-		{"EM_SE_C33", Const, 11, ""},
-		{"EM_SH", Const, 0, ""},
-		{"EM_SHARC", Const, 11, ""},
-		{"EM_SLE9X", Const, 11, ""},
-		{"EM_SNP1K", Const, 11, ""},
-		{"EM_SPARC", Const, 0, ""},
-		{"EM_SPARC32PLUS", Const, 0, ""},
-		{"EM_SPARCV9", Const, 0, ""},
-		{"EM_ST100", Const, 0, ""},
-		{"EM_ST19", Const, 11, ""},
-		{"EM_ST200", Const, 11, ""},
-		{"EM_ST7", Const, 11, ""},
-		{"EM_ST9PLUS", Const, 11, ""},
-		{"EM_STARCORE", Const, 0, ""},
-		{"EM_STM8", Const, 11, ""},
-		{"EM_STXP7X", Const, 11, ""},
-		{"EM_SVX", Const, 11, ""},
-		{"EM_TILE64", Const, 11, ""},
-		{"EM_TILEGX", Const, 11, ""},
-		{"EM_TILEPRO", Const, 11, ""},
-		{"EM_TINYJ", Const, 0, ""},
-		{"EM_TI_ARP32", Const, 11, ""},
-		{"EM_TI_C2000", Const, 11, ""},
-		{"EM_TI_C5500", Const, 11, ""},
-		{"EM_TI_C6000", Const, 11, ""},
-		{"EM_TI_PRU", Const, 11, ""},
-		{"EM_TMM_GPP", Const, 11, ""},
-		{"EM_TPC", Const, 11, ""},
-		{"EM_TRICORE", Const, 0, ""},
-		{"EM_TRIMEDIA", Const, 11, ""},
-		{"EM_TSK3000", Const, 11, ""},
-		{"EM_UNICORE", Const, 11, ""},
-		{"EM_V800", Const, 0, ""},
-		{"EM_V850", Const, 11, ""},
-		{"EM_VAX", Const, 11, ""},
-		{"EM_VIDEOCORE", Const, 11, ""},
-		{"EM_VIDEOCORE3", Const, 11, ""},
-		{"EM_VIDEOCORE5", Const, 11, ""},
-		{"EM_VISIUM", Const, 11, ""},
-		{"EM_VPP500", Const, 0, ""},
-		{"EM_X86_64", Const, 0, ""},
-		{"EM_XCORE", Const, 11, ""},
-		{"EM_XGATE", Const, 11, ""},
-		{"EM_XIMO16", Const, 11, ""},
-		{"EM_XTENSA", Const, 11, ""},
-		{"EM_Z80", Const, 11, ""},
-		{"EM_ZSP", Const, 11, ""},
-		{"ET_CORE", Const, 0, ""},
-		{"ET_DYN", Const, 0, ""},
-		{"ET_EXEC", Const, 0, ""},
-		{"ET_HIOS", Const, 0, ""},
-		{"ET_HIPROC", Const, 0, ""},
-		{"ET_LOOS", Const, 0, ""},
-		{"ET_LOPROC", Const, 0, ""},
-		{"ET_NONE", Const, 0, ""},
-		{"ET_REL", Const, 0, ""},
-		{"EV_CURRENT", Const, 0, ""},
-		{"EV_NONE", Const, 0, ""},
-		{"ErrNoSymbols", Var, 4, ""},
-		{"File", Type, 0, ""},
-		{"File.FileHeader", Field, 0, ""},
-		{"File.Progs", Field, 0, ""},
-		{"File.Sections", Field, 0, ""},
-		{"FileHeader", Type, 0, ""},
-		{"FileHeader.ABIVersion", Field, 0, ""},
-		{"FileHeader.ByteOrder", Field, 0, ""},
-		{"FileHeader.Class", Field, 0, ""},
-		{"FileHeader.Data", Field, 0, ""},
-		{"FileHeader.Entry", Field, 1, ""},
-		{"FileHeader.Machine", Field, 0, ""},
-		{"FileHeader.OSABI", Field, 0, ""},
-		{"FileHeader.Type", Field, 0, ""},
-		{"FileHeader.Version", Field, 0, ""},
-		{"FormatError", Type, 0, ""},
-		{"Header32", Type, 0, ""},
-		{"Header32.Ehsize", Field, 0, ""},
-		{"Header32.Entry", Field, 0, ""},
-		{"Header32.Flags", Field, 0, ""},
-		{"Header32.Ident", Field, 0, ""},
-		{"Header32.Machine", Field, 0, ""},
-		{"Header32.Phentsize", Field, 0, ""},
-		{"Header32.Phnum", Field, 0, ""},
-		{"Header32.Phoff", Field, 0, ""},
-		{"Header32.Shentsize", Field, 0, ""},
-		{"Header32.Shnum", Field, 0, ""},
-		{"Header32.Shoff", Field, 0, ""},
-		{"Header32.Shstrndx", Field, 0, ""},
-		{"Header32.Type", Field, 0, ""},
-		{"Header32.Version", Field, 0, ""},
-		{"Header64", Type, 0, ""},
-		{"Header64.Ehsize", Field, 0, ""},
-		{"Header64.Entry", Field, 0, ""},
-		{"Header64.Flags", Field, 0, ""},
-		{"Header64.Ident", Field, 0, ""},
-		{"Header64.Machine", Field, 0, ""},
-		{"Header64.Phentsize", Field, 0, ""},
-		{"Header64.Phnum", Field, 0, ""},
-		{"Header64.Phoff", Field, 0, ""},
-		{"Header64.Shentsize", Field, 0, ""},
-		{"Header64.Shnum", Field, 0, ""},
-		{"Header64.Shoff", Field, 0, ""},
-		{"Header64.Shstrndx", Field, 0, ""},
-		{"Header64.Type", Field, 0, ""},
-		{"Header64.Version", Field, 0, ""},
-		{"ImportedSymbol", Type, 0, ""},
-		{"ImportedSymbol.Library", Field, 0, ""},
-		{"ImportedSymbol.Name", Field, 0, ""},
-		{"ImportedSymbol.Version", Field, 0, ""},
-		{"Machine", Type, 0, ""},
-		{"NT_FPREGSET", Const, 0, ""},
-		{"NT_PRPSINFO", Const, 0, ""},
-		{"NT_PRSTATUS", Const, 0, ""},
-		{"NType", Type, 0, ""},
-		{"NewFile", Func, 0, "func(r io.ReaderAt) (*File, error)"},
-		{"OSABI", Type, 0, ""},
-		{"Open", Func, 0, "func(name string) (*File, error)"},
-		{"PF_MASKOS", Const, 0, ""},
-		{"PF_MASKPROC", Const, 0, ""},
-		{"PF_R", Const, 0, ""},
-		{"PF_W", Const, 0, ""},
-		{"PF_X", Const, 0, ""},
-		{"PT_AARCH64_ARCHEXT", Const, 16, ""},
-		{"PT_AARCH64_UNWIND", Const, 16, ""},
-		{"PT_ARM_ARCHEXT", Const, 16, ""},
-		{"PT_ARM_EXIDX", Const, 16, ""},
-		{"PT_DYNAMIC", Const, 0, ""},
-		{"PT_GNU_EH_FRAME", Const, 16, ""},
-		{"PT_GNU_MBIND_HI", Const, 16, ""},
-		{"PT_GNU_MBIND_LO", Const, 16, ""},
-		{"PT_GNU_PROPERTY", Const, 16, ""},
-		{"PT_GNU_RELRO", Const, 16, ""},
-		{"PT_GNU_STACK", Const, 16, ""},
-		{"PT_HIOS", Const, 0, ""},
-		{"PT_HIPROC", Const, 0, ""},
-		{"PT_INTERP", Const, 0, ""},
-		{"PT_LOAD", Const, 0, ""},
-		{"PT_LOOS", Const, 0, ""},
-		{"PT_LOPROC", Const, 0, ""},
-		{"PT_MIPS_ABIFLAGS", Const, 16, ""},
-		{"PT_MIPS_OPTIONS", Const, 16, ""},
-		{"PT_MIPS_REGINFO", Const, 16, ""},
-		{"PT_MIPS_RTPROC", Const, 16, ""},
-		{"PT_NOTE", Const, 0, ""},
-		{"PT_NULL", Const, 0, ""},
-		{"PT_OPENBSD_BOOTDATA", Const, 16, ""},
-		{"PT_OPENBSD_NOBTCFI", Const, 23, ""},
-		{"PT_OPENBSD_RANDOMIZE", Const, 16, ""},
-		{"PT_OPENBSD_WXNEEDED", Const, 16, ""},
-		{"PT_PAX_FLAGS", Const, 16, ""},
-		{"PT_PHDR", Const, 0, ""},
-		{"PT_RISCV_ATTRIBUTES", Const, 25, ""},
-		{"PT_S390_PGSTE", Const, 16, ""},
-		{"PT_SHLIB", Const, 0, ""},
-		{"PT_SUNWSTACK", Const, 16, ""},
-		{"PT_SUNW_EH_FRAME", Const, 16, ""},
-		{"PT_TLS", Const, 0, ""},
-		{"Prog", Type, 0, ""},
-		{"Prog.ProgHeader", Field, 0, ""},
-		{"Prog.ReaderAt", Field, 0, ""},
-		{"Prog32", Type, 0, ""},
-		{"Prog32.Align", Field, 0, ""},
-		{"Prog32.Filesz", Field, 0, ""},
-		{"Prog32.Flags", Field, 0, ""},
-		{"Prog32.Memsz", Field, 0, ""},
-		{"Prog32.Off", Field, 0, ""},
-		{"Prog32.Paddr", Field, 0, ""},
-		{"Prog32.Type", Field, 0, ""},
-		{"Prog32.Vaddr", Field, 0, ""},
-		{"Prog64", Type, 0, ""},
-		{"Prog64.Align", Field, 0, ""},
-		{"Prog64.Filesz", Field, 0, ""},
-		{"Prog64.Flags", Field, 0, ""},
-		{"Prog64.Memsz", Field, 0, ""},
-		{"Prog64.Off", Field, 0, ""},
-		{"Prog64.Paddr", Field, 0, ""},
-		{"Prog64.Type", Field, 0, ""},
-		{"Prog64.Vaddr", Field, 0, ""},
-		{"ProgFlag", Type, 0, ""},
-		{"ProgHeader", Type, 0, ""},
-		{"ProgHeader.Align", Field, 0, ""},
-		{"ProgHeader.Filesz", Field, 0, ""},
-		{"ProgHeader.Flags", Field, 0, ""},
-		{"ProgHeader.Memsz", Field, 0, ""},
-		{"ProgHeader.Off", Field, 0, ""},
-		{"ProgHeader.Paddr", Field, 0, ""},
-		{"ProgHeader.Type", Field, 0, ""},
-		{"ProgHeader.Vaddr", Field, 0, ""},
-		{"ProgType", Type, 0, ""},
-		{"R_386", Type, 0, ""},
-		{"R_386_16", Const, 10, ""},
-		{"R_386_32", Const, 0, ""},
-		{"R_386_32PLT", Const, 10, ""},
-		{"R_386_8", Const, 10, ""},
-		{"R_386_COPY", Const, 0, ""},
-		{"R_386_GLOB_DAT", Const, 0, ""},
-		{"R_386_GOT32", Const, 0, ""},
-		{"R_386_GOT32X", Const, 10, ""},
-		{"R_386_GOTOFF", Const, 0, ""},
-		{"R_386_GOTPC", Const, 0, ""},
-		{"R_386_IRELATIVE", Const, 10, ""},
-		{"R_386_JMP_SLOT", Const, 0, ""},
-		{"R_386_NONE", Const, 0, ""},
-		{"R_386_PC16", Const, 10, ""},
-		{"R_386_PC32", Const, 0, ""},
-		{"R_386_PC8", Const, 10, ""},
-		{"R_386_PLT32", Const, 0, ""},
-		{"R_386_RELATIVE", Const, 0, ""},
-		{"R_386_SIZE32", Const, 10, ""},
-		{"R_386_TLS_DESC", Const, 10, ""},
-		{"R_386_TLS_DESC_CALL", Const, 10, ""},
-		{"R_386_TLS_DTPMOD32", Const, 0, ""},
-		{"R_386_TLS_DTPOFF32", Const, 0, ""},
-		{"R_386_TLS_GD", Const, 0, ""},
-		{"R_386_TLS_GD_32", Const, 0, ""},
-		{"R_386_TLS_GD_CALL", Const, 0, ""},
-		{"R_386_TLS_GD_POP", Const, 0, ""},
-		{"R_386_TLS_GD_PUSH", Const, 0, ""},
-		{"R_386_TLS_GOTDESC", Const, 10, ""},
-		{"R_386_TLS_GOTIE", Const, 0, ""},
-		{"R_386_TLS_IE", Const, 0, ""},
-		{"R_386_TLS_IE_32", Const, 0, ""},
-		{"R_386_TLS_LDM", Const, 0, ""},
-		{"R_386_TLS_LDM_32", Const, 0, ""},
-		{"R_386_TLS_LDM_CALL", Const, 0, ""},
-		{"R_386_TLS_LDM_POP", Const, 0, ""},
-		{"R_386_TLS_LDM_PUSH", Const, 0, ""},
-		{"R_386_TLS_LDO_32", Const, 0, ""},
-		{"R_386_TLS_LE", Const, 0, ""},
-		{"R_386_TLS_LE_32", Const, 0, ""},
-		{"R_386_TLS_TPOFF", Const, 0, ""},
-		{"R_386_TLS_TPOFF32", Const, 0, ""},
-		{"R_390", Type, 7, ""},
-		{"R_390_12", Const, 7, ""},
-		{"R_390_16", Const, 7, ""},
-		{"R_390_20", Const, 7, ""},
-		{"R_390_32", Const, 7, ""},
-		{"R_390_64", Const, 7, ""},
-		{"R_390_8", Const, 7, ""},
-		{"R_390_COPY", Const, 7, ""},
-		{"R_390_GLOB_DAT", Const, 7, ""},
-		{"R_390_GOT12", Const, 7, ""},
-		{"R_390_GOT16", Const, 7, ""},
-		{"R_390_GOT20", Const, 7, ""},
-		{"R_390_GOT32", Const, 7, ""},
-		{"R_390_GOT64", Const, 7, ""},
-		{"R_390_GOTENT", Const, 7, ""},
-		{"R_390_GOTOFF", Const, 7, ""},
-		{"R_390_GOTOFF16", Const, 7, ""},
-		{"R_390_GOTOFF64", Const, 7, ""},
-		{"R_390_GOTPC", Const, 7, ""},
-		{"R_390_GOTPCDBL", Const, 7, ""},
-		{"R_390_GOTPLT12", Const, 7, ""},
-		{"R_390_GOTPLT16", Const, 7, ""},
-		{"R_390_GOTPLT20", Const, 7, ""},
-		{"R_390_GOTPLT32", Const, 7, ""},
-		{"R_390_GOTPLT64", Const, 7, ""},
-		{"R_390_GOTPLTENT", Const, 7, ""},
-		{"R_390_GOTPLTOFF16", Const, 7, ""},
-		{"R_390_GOTPLTOFF32", Const, 7, ""},
-		{"R_390_GOTPLTOFF64", Const, 7, ""},
-		{"R_390_JMP_SLOT", Const, 7, ""},
-		{"R_390_NONE", Const, 7, ""},
-		{"R_390_PC16", Const, 7, ""},
-		{"R_390_PC16DBL", Const, 7, ""},
-		{"R_390_PC32", Const, 7, ""},
-		{"R_390_PC32DBL", Const, 7, ""},
-		{"R_390_PC64", Const, 7, ""},
-		{"R_390_PLT16DBL", Const, 7, ""},
-		{"R_390_PLT32", Const, 7, ""},
-		{"R_390_PLT32DBL", Const, 7, ""},
-		{"R_390_PLT64", Const, 7, ""},
-		{"R_390_RELATIVE", Const, 7, ""},
-		{"R_390_TLS_DTPMOD", Const, 7, ""},
-		{"R_390_TLS_DTPOFF", Const, 7, ""},
-		{"R_390_TLS_GD32", Const, 7, ""},
-		{"R_390_TLS_GD64", Const, 7, ""},
-		{"R_390_TLS_GDCALL", Const, 7, ""},
-		{"R_390_TLS_GOTIE12", Const, 7, ""},
-		{"R_390_TLS_GOTIE20", Const, 7, ""},
-		{"R_390_TLS_GOTIE32", Const, 7, ""},
-		{"R_390_TLS_GOTIE64", Const, 7, ""},
-		{"R_390_TLS_IE32", Const, 7, ""},
-		{"R_390_TLS_IE64", Const, 7, ""},
-		{"R_390_TLS_IEENT", Const, 7, ""},
-		{"R_390_TLS_LDCALL", Const, 7, ""},
-		{"R_390_TLS_LDM32", Const, 7, ""},
-		{"R_390_TLS_LDM64", Const, 7, ""},
-		{"R_390_TLS_LDO32", Const, 7, ""},
-		{"R_390_TLS_LDO64", Const, 7, ""},
-		{"R_390_TLS_LE32", Const, 7, ""},
-		{"R_390_TLS_LE64", Const, 7, ""},
-		{"R_390_TLS_LOAD", Const, 7, ""},
-		{"R_390_TLS_TPOFF", Const, 7, ""},
-		{"R_AARCH64", Type, 4, ""},
-		{"R_AARCH64_ABS16", Const, 4, ""},
-		{"R_AARCH64_ABS32", Const, 4, ""},
-		{"R_AARCH64_ABS64", Const, 4, ""},
-		{"R_AARCH64_ADD_ABS_LO12_NC", Const, 4, ""},
-		{"R_AARCH64_ADR_GOT_PAGE", Const, 4, ""},
-		{"R_AARCH64_ADR_PREL_LO21", Const, 4, ""},
-		{"R_AARCH64_ADR_PREL_PG_HI21", Const, 4, ""},
-		{"R_AARCH64_ADR_PREL_PG_HI21_NC", Const, 4, ""},
-		{"R_AARCH64_CALL26", Const, 4, ""},
-		{"R_AARCH64_CONDBR19", Const, 4, ""},
-		{"R_AARCH64_COPY", Const, 4, ""},
-		{"R_AARCH64_GLOB_DAT", Const, 4, ""},
-		{"R_AARCH64_GOT_LD_PREL19", Const, 4, ""},
-		{"R_AARCH64_IRELATIVE", Const, 4, ""},
-		{"R_AARCH64_JUMP26", Const, 4, ""},
-		{"R_AARCH64_JUMP_SLOT", Const, 4, ""},
-		{"R_AARCH64_LD64_GOTOFF_LO15", Const, 10, ""},
-		{"R_AARCH64_LD64_GOTPAGE_LO15", Const, 10, ""},
-		{"R_AARCH64_LD64_GOT_LO12_NC", Const, 4, ""},
-		{"R_AARCH64_LDST128_ABS_LO12_NC", Const, 4, ""},
-		{"R_AARCH64_LDST16_ABS_LO12_NC", Const, 4, ""},
-		{"R_AARCH64_LDST32_ABS_LO12_NC", Const, 4, ""},
-		{"R_AARCH64_LDST64_ABS_LO12_NC", Const, 4, ""},
-		{"R_AARCH64_LDST8_ABS_LO12_NC", Const, 4, ""},
-		{"R_AARCH64_LD_PREL_LO19", Const, 4, ""},
-		{"R_AARCH64_MOVW_SABS_G0", Const, 4, ""},
-		{"R_AARCH64_MOVW_SABS_G1", Const, 4, ""},
-		{"R_AARCH64_MOVW_SABS_G2", Const, 4, ""},
-		{"R_AARCH64_MOVW_UABS_G0", Const, 4, ""},
-		{"R_AARCH64_MOVW_UABS_G0_NC", Const, 4, ""},
-		{"R_AARCH64_MOVW_UABS_G1", Const, 4, ""},
-		{"R_AARCH64_MOVW_UABS_G1_NC", Const, 4, ""},
-		{"R_AARCH64_MOVW_UABS_G2", Const, 4, ""},
-		{"R_AARCH64_MOVW_UABS_G2_NC", Const, 4, ""},
-		{"R_AARCH64_MOVW_UABS_G3", Const, 4, ""},
-		{"R_AARCH64_NONE", Const, 4, ""},
-		{"R_AARCH64_NULL", Const, 4, ""},
-		{"R_AARCH64_P32_ABS16", Const, 4, ""},
-		{"R_AARCH64_P32_ABS32", Const, 4, ""},
-		{"R_AARCH64_P32_ADD_ABS_LO12_NC", Const, 4, ""},
-		{"R_AARCH64_P32_ADR_GOT_PAGE", Const, 4, ""},
-		{"R_AARCH64_P32_ADR_PREL_LO21", Const, 4, ""},
-		{"R_AARCH64_P32_ADR_PREL_PG_HI21", Const, 4, ""},
-		{"R_AARCH64_P32_CALL26", Const, 4, ""},
-		{"R_AARCH64_P32_CONDBR19", Const, 4, ""},
-		{"R_AARCH64_P32_COPY", Const, 4, ""},
-		{"R_AARCH64_P32_GLOB_DAT", Const, 4, ""},
-		{"R_AARCH64_P32_GOT_LD_PREL19", Const, 4, ""},
-		{"R_AARCH64_P32_IRELATIVE", Const, 4, ""},
-		{"R_AARCH64_P32_JUMP26", Const, 4, ""},
-		{"R_AARCH64_P32_JUMP_SLOT", Const, 4, ""},
-		{"R_AARCH64_P32_LD32_GOT_LO12_NC", Const, 4, ""},
-		{"R_AARCH64_P32_LDST128_ABS_LO12_NC", Const, 4, ""},
-		{"R_AARCH64_P32_LDST16_ABS_LO12_NC", Const, 4, ""},
-		{"R_AARCH64_P32_LDST32_ABS_LO12_NC", Const, 4, ""},
-		{"R_AARCH64_P32_LDST64_ABS_LO12_NC", Const, 4, ""},
-		{"R_AARCH64_P32_LDST8_ABS_LO12_NC", Const, 4, ""},
-		{"R_AARCH64_P32_LD_PREL_LO19", Const, 4, ""},
-		{"R_AARCH64_P32_MOVW_SABS_G0", Const, 4, ""},
-		{"R_AARCH64_P32_MOVW_UABS_G0", Const, 4, ""},
-		{"R_AARCH64_P32_MOVW_UABS_G0_NC", Const, 4, ""},
-		{"R_AARCH64_P32_MOVW_UABS_G1", Const, 4, ""},
-		{"R_AARCH64_P32_PREL16", Const, 4, ""},
-		{"R_AARCH64_P32_PREL32", Const, 4, ""},
-		{"R_AARCH64_P32_RELATIVE", Const, 4, ""},
-		{"R_AARCH64_P32_TLSDESC", Const, 4, ""},
-		{"R_AARCH64_P32_TLSDESC_ADD_LO12_NC", Const, 4, ""},
-		{"R_AARCH64_P32_TLSDESC_ADR_PAGE21", Const, 4, ""},
-		{"R_AARCH64_P32_TLSDESC_ADR_PREL21", Const, 4, ""},
-		{"R_AARCH64_P32_TLSDESC_CALL", Const, 4, ""},
-		{"R_AARCH64_P32_TLSDESC_LD32_LO12_NC", Const, 4, ""},
-		{"R_AARCH64_P32_TLSDESC_LD_PREL19", Const, 4, ""},
-		{"R_AARCH64_P32_TLSGD_ADD_LO12_NC", Const, 4, ""},
-		{"R_AARCH64_P32_TLSGD_ADR_PAGE21", Const, 4, ""},
-		{"R_AARCH64_P32_TLSIE_ADR_GOTTPREL_PAGE21", Const, 4, ""},
-		{"R_AARCH64_P32_TLSIE_LD32_GOTTPREL_LO12_NC", Const, 4, ""},
-		{"R_AARCH64_P32_TLSIE_LD_GOTTPREL_PREL19", Const, 4, ""},
-		{"R_AARCH64_P32_TLSLE_ADD_TPREL_HI12", Const, 4, ""},
-		{"R_AARCH64_P32_TLSLE_ADD_TPREL_LO12", Const, 4, ""},
-		{"R_AARCH64_P32_TLSLE_ADD_TPREL_LO12_NC", Const, 4, ""},
-		{"R_AARCH64_P32_TLSLE_MOVW_TPREL_G0", Const, 4, ""},
-		{"R_AARCH64_P32_TLSLE_MOVW_TPREL_G0_NC", Const, 4, ""},
-		{"R_AARCH64_P32_TLSLE_MOVW_TPREL_G1", Const, 4, ""},
-		{"R_AARCH64_P32_TLS_DTPMOD", Const, 4, ""},
-		{"R_AARCH64_P32_TLS_DTPREL", Const, 4, ""},
-		{"R_AARCH64_P32_TLS_TPREL", Const, 4, ""},
-		{"R_AARCH64_P32_TSTBR14", Const, 4, ""},
-		{"R_AARCH64_PREL16", Const, 4, ""},
-		{"R_AARCH64_PREL32", Const, 4, ""},
-		{"R_AARCH64_PREL64", Const, 4, ""},
-		{"R_AARCH64_RELATIVE", Const, 4, ""},
-		{"R_AARCH64_TLSDESC", Const, 4, ""},
-		{"R_AARCH64_TLSDESC_ADD", Const, 4, ""},
-		{"R_AARCH64_TLSDESC_ADD_LO12_NC", Const, 4, ""},
-		{"R_AARCH64_TLSDESC_ADR_PAGE21", Const, 4, ""},
-		{"R_AARCH64_TLSDESC_ADR_PREL21", Const, 4, ""},
-		{"R_AARCH64_TLSDESC_CALL", Const, 4, ""},
-		{"R_AARCH64_TLSDESC_LD64_LO12_NC", Const, 4, ""},
-		{"R_AARCH64_TLSDESC_LDR", Const, 4, ""},
-		{"R_AARCH64_TLSDESC_LD_PREL19", Const, 4, ""},
-		{"R_AARCH64_TLSDESC_OFF_G0_NC", Const, 4, ""},
-		{"R_AARCH64_TLSDESC_OFF_G1", Const, 4, ""},
-		{"R_AARCH64_TLSGD_ADD_LO12_NC", Const, 4, ""},
-		{"R_AARCH64_TLSGD_ADR_PAGE21", Const, 4, ""},
-		{"R_AARCH64_TLSGD_ADR_PREL21", Const, 10, ""},
-		{"R_AARCH64_TLSGD_MOVW_G0_NC", Const, 10, ""},
-		{"R_AARCH64_TLSGD_MOVW_G1", Const, 10, ""},
-		{"R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21", Const, 4, ""},
-		{"R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC", Const, 4, ""},
-		{"R_AARCH64_TLSIE_LD_GOTTPREL_PREL19", Const, 4, ""},
-		{"R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC", Const, 4, ""},
-		{"R_AARCH64_TLSIE_MOVW_GOTTPREL_G1", Const, 4, ""},
-		{"R_AARCH64_TLSLD_ADR_PAGE21", Const, 10, ""},
-		{"R_AARCH64_TLSLD_ADR_PREL21", Const, 10, ""},
-		{"R_AARCH64_TLSLD_LDST128_DTPREL_LO12", Const, 10, ""},
-		{"R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC", Const, 10, ""},
-		{"R_AARCH64_TLSLE_ADD_TPREL_HI12", Const, 4, ""},
-		{"R_AARCH64_TLSLE_ADD_TPREL_LO12", Const, 4, ""},
-		{"R_AARCH64_TLSLE_ADD_TPREL_LO12_NC", Const, 4, ""},
-		{"R_AARCH64_TLSLE_LDST128_TPREL_LO12", Const, 10, ""},
-		{"R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC", Const, 10, ""},
-		{"R_AARCH64_TLSLE_MOVW_TPREL_G0", Const, 4, ""},
-		{"R_AARCH64_TLSLE_MOVW_TPREL_G0_NC", Const, 4, ""},
-		{"R_AARCH64_TLSLE_MOVW_TPREL_G1", Const, 4, ""},
-		{"R_AARCH64_TLSLE_MOVW_TPREL_G1_NC", Const, 4, ""},
-		{"R_AARCH64_TLSLE_MOVW_TPREL_G2", Const, 4, ""},
-		{"R_AARCH64_TLS_DTPMOD64", Const, 4, ""},
-		{"R_AARCH64_TLS_DTPREL64", Const, 4, ""},
-		{"R_AARCH64_TLS_TPREL64", Const, 4, ""},
-		{"R_AARCH64_TSTBR14", Const, 4, ""},
-		{"R_ALPHA", Type, 0, ""},
-		{"R_ALPHA_BRADDR", Const, 0, ""},
-		{"R_ALPHA_COPY", Const, 0, ""},
-		{"R_ALPHA_GLOB_DAT", Const, 0, ""},
-		{"R_ALPHA_GPDISP", Const, 0, ""},
-		{"R_ALPHA_GPREL32", Const, 0, ""},
-		{"R_ALPHA_GPRELHIGH", Const, 0, ""},
-		{"R_ALPHA_GPRELLOW", Const, 0, ""},
-		{"R_ALPHA_GPVALUE", Const, 0, ""},
-		{"R_ALPHA_HINT", Const, 0, ""},
-		{"R_ALPHA_IMMED_BR_HI32", Const, 0, ""},
-		{"R_ALPHA_IMMED_GP_16", Const, 0, ""},
-		{"R_ALPHA_IMMED_GP_HI32", Const, 0, ""},
-		{"R_ALPHA_IMMED_LO32", Const, 0, ""},
-		{"R_ALPHA_IMMED_SCN_HI32", Const, 0, ""},
-		{"R_ALPHA_JMP_SLOT", Const, 0, ""},
-		{"R_ALPHA_LITERAL", Const, 0, ""},
-		{"R_ALPHA_LITUSE", Const, 0, ""},
-		{"R_ALPHA_NONE", Const, 0, ""},
-		{"R_ALPHA_OP_PRSHIFT", Const, 0, ""},
-		{"R_ALPHA_OP_PSUB", Const, 0, ""},
-		{"R_ALPHA_OP_PUSH", Const, 0, ""},
-		{"R_ALPHA_OP_STORE", Const, 0, ""},
-		{"R_ALPHA_REFLONG", Const, 0, ""},
-		{"R_ALPHA_REFQUAD", Const, 0, ""},
-		{"R_ALPHA_RELATIVE", Const, 0, ""},
-		{"R_ALPHA_SREL16", Const, 0, ""},
-		{"R_ALPHA_SREL32", Const, 0, ""},
-		{"R_ALPHA_SREL64", Const, 0, ""},
-		{"R_ARM", Type, 0, ""},
-		{"R_ARM_ABS12", Const, 0, ""},
-		{"R_ARM_ABS16", Const, 0, ""},
-		{"R_ARM_ABS32", Const, 0, ""},
-		{"R_ARM_ABS32_NOI", Const, 10, ""},
-		{"R_ARM_ABS8", Const, 0, ""},
-		{"R_ARM_ALU_PCREL_15_8", Const, 10, ""},
-		{"R_ARM_ALU_PCREL_23_15", Const, 10, ""},
-		{"R_ARM_ALU_PCREL_7_0", Const, 10, ""},
-		{"R_ARM_ALU_PC_G0", Const, 10, ""},
-		{"R_ARM_ALU_PC_G0_NC", Const, 10, ""},
-		{"R_ARM_ALU_PC_G1", Const, 10, ""},
-		{"R_ARM_ALU_PC_G1_NC", Const, 10, ""},
-		{"R_ARM_ALU_PC_G2", Const, 10, ""},
-		{"R_ARM_ALU_SBREL_19_12_NC", Const, 10, ""},
-		{"R_ARM_ALU_SBREL_27_20_CK", Const, 10, ""},
-		{"R_ARM_ALU_SB_G0", Const, 10, ""},
-		{"R_ARM_ALU_SB_G0_NC", Const, 10, ""},
-		{"R_ARM_ALU_SB_G1", Const, 10, ""},
-		{"R_ARM_ALU_SB_G1_NC", Const, 10, ""},
-		{"R_ARM_ALU_SB_G2", Const, 10, ""},
-		{"R_ARM_AMP_VCALL9", Const, 0, ""},
-		{"R_ARM_BASE_ABS", Const, 10, ""},
-		{"R_ARM_CALL", Const, 10, ""},
-		{"R_ARM_COPY", Const, 0, ""},
-		{"R_ARM_GLOB_DAT", Const, 0, ""},
-		{"R_ARM_GNU_VTENTRY", Const, 0, ""},
-		{"R_ARM_GNU_VTINHERIT", Const, 0, ""},
-		{"R_ARM_GOT32", Const, 0, ""},
-		{"R_ARM_GOTOFF", Const, 0, ""},
-		{"R_ARM_GOTOFF12", Const, 10, ""},
-		{"R_ARM_GOTPC", Const, 0, ""},
-		{"R_ARM_GOTRELAX", Const, 10, ""},
-		{"R_ARM_GOT_ABS", Const, 10, ""},
-		{"R_ARM_GOT_BREL12", Const, 10, ""},
-		{"R_ARM_GOT_PREL", Const, 10, ""},
-		{"R_ARM_IRELATIVE", Const, 10, ""},
-		{"R_ARM_JUMP24", Const, 10, ""},
-		{"R_ARM_JUMP_SLOT", Const, 0, ""},
-		{"R_ARM_LDC_PC_G0", Const, 10, ""},
-		{"R_ARM_LDC_PC_G1", Const, 10, ""},
-		{"R_ARM_LDC_PC_G2", Const, 10, ""},
-		{"R_ARM_LDC_SB_G0", Const, 10, ""},
-		{"R_ARM_LDC_SB_G1", Const, 10, ""},
-		{"R_ARM_LDC_SB_G2", Const, 10, ""},
-		{"R_ARM_LDRS_PC_G0", Const, 10, ""},
-		{"R_ARM_LDRS_PC_G1", Const, 10, ""},
-		{"R_ARM_LDRS_PC_G2", Const, 10, ""},
-		{"R_ARM_LDRS_SB_G0", Const, 10, ""},
-		{"R_ARM_LDRS_SB_G1", Const, 10, ""},
-		{"R_ARM_LDRS_SB_G2", Const, 10, ""},
-		{"R_ARM_LDR_PC_G1", Const, 10, ""},
-		{"R_ARM_LDR_PC_G2", Const, 10, ""},
-		{"R_ARM_LDR_SBREL_11_10_NC", Const, 10, ""},
-		{"R_ARM_LDR_SB_G0", Const, 10, ""},
-		{"R_ARM_LDR_SB_G1", Const, 10, ""},
-		{"R_ARM_LDR_SB_G2", Const, 10, ""},
-		{"R_ARM_ME_TOO", Const, 10, ""},
-		{"R_ARM_MOVT_ABS", Const, 10, ""},
-		{"R_ARM_MOVT_BREL", Const, 10, ""},
-		{"R_ARM_MOVT_PREL", Const, 10, ""},
-		{"R_ARM_MOVW_ABS_NC", Const, 10, ""},
-		{"R_ARM_MOVW_BREL", Const, 10, ""},
-		{"R_ARM_MOVW_BREL_NC", Const, 10, ""},
-		{"R_ARM_MOVW_PREL_NC", Const, 10, ""},
-		{"R_ARM_NONE", Const, 0, ""},
-		{"R_ARM_PC13", Const, 0, ""},
-		{"R_ARM_PC24", Const, 0, ""},
-		{"R_ARM_PLT32", Const, 0, ""},
-		{"R_ARM_PLT32_ABS", Const, 10, ""},
-		{"R_ARM_PREL31", Const, 10, ""},
-		{"R_ARM_PRIVATE_0", Const, 10, ""},
-		{"R_ARM_PRIVATE_1", Const, 10, ""},
-		{"R_ARM_PRIVATE_10", Const, 10, ""},
-		{"R_ARM_PRIVATE_11", Const, 10, ""},
-		{"R_ARM_PRIVATE_12", Const, 10, ""},
-		{"R_ARM_PRIVATE_13", Const, 10, ""},
-		{"R_ARM_PRIVATE_14", Const, 10, ""},
-		{"R_ARM_PRIVATE_15", Const, 10, ""},
-		{"R_ARM_PRIVATE_2", Const, 10, ""},
-		{"R_ARM_PRIVATE_3", Const, 10, ""},
-		{"R_ARM_PRIVATE_4", Const, 10, ""},
-		{"R_ARM_PRIVATE_5", Const, 10, ""},
-		{"R_ARM_PRIVATE_6", Const, 10, ""},
-		{"R_ARM_PRIVATE_7", Const, 10, ""},
-		{"R_ARM_PRIVATE_8", Const, 10, ""},
-		{"R_ARM_PRIVATE_9", Const, 10, ""},
-		{"R_ARM_RABS32", Const, 0, ""},
-		{"R_ARM_RBASE", Const, 0, ""},
-		{"R_ARM_REL32", Const, 0, ""},
-		{"R_ARM_REL32_NOI", Const, 10, ""},
-		{"R_ARM_RELATIVE", Const, 0, ""},
-		{"R_ARM_RPC24", Const, 0, ""},
-		{"R_ARM_RREL32", Const, 0, ""},
-		{"R_ARM_RSBREL32", Const, 0, ""},
-		{"R_ARM_RXPC25", Const, 10, ""},
-		{"R_ARM_SBREL31", Const, 10, ""},
-		{"R_ARM_SBREL32", Const, 0, ""},
-		{"R_ARM_SWI24", Const, 0, ""},
-		{"R_ARM_TARGET1", Const, 10, ""},
-		{"R_ARM_TARGET2", Const, 10, ""},
-		{"R_ARM_THM_ABS5", Const, 0, ""},
-		{"R_ARM_THM_ALU_ABS_G0_NC", Const, 10, ""},
-		{"R_ARM_THM_ALU_ABS_G1_NC", Const, 10, ""},
-		{"R_ARM_THM_ALU_ABS_G2_NC", Const, 10, ""},
-		{"R_ARM_THM_ALU_ABS_G3", Const, 10, ""},
-		{"R_ARM_THM_ALU_PREL_11_0", Const, 10, ""},
-		{"R_ARM_THM_GOT_BREL12", Const, 10, ""},
-		{"R_ARM_THM_JUMP11", Const, 10, ""},
-		{"R_ARM_THM_JUMP19", Const, 10, ""},
-		{"R_ARM_THM_JUMP24", Const, 10, ""},
-		{"R_ARM_THM_JUMP6", Const, 10, ""},
-		{"R_ARM_THM_JUMP8", Const, 10, ""},
-		{"R_ARM_THM_MOVT_ABS", Const, 10, ""},
-		{"R_ARM_THM_MOVT_BREL", Const, 10, ""},
-		{"R_ARM_THM_MOVT_PREL", Const, 10, ""},
-		{"R_ARM_THM_MOVW_ABS_NC", Const, 10, ""},
-		{"R_ARM_THM_MOVW_BREL", Const, 10, ""},
-		{"R_ARM_THM_MOVW_BREL_NC", Const, 10, ""},
-		{"R_ARM_THM_MOVW_PREL_NC", Const, 10, ""},
-		{"R_ARM_THM_PC12", Const, 10, ""},
-		{"R_ARM_THM_PC22", Const, 0, ""},
-		{"R_ARM_THM_PC8", Const, 0, ""},
-		{"R_ARM_THM_RPC22", Const, 0, ""},
-		{"R_ARM_THM_SWI8", Const, 0, ""},
-		{"R_ARM_THM_TLS_CALL", Const, 10, ""},
-		{"R_ARM_THM_TLS_DESCSEQ16", Const, 10, ""},
-		{"R_ARM_THM_TLS_DESCSEQ32", Const, 10, ""},
-		{"R_ARM_THM_XPC22", Const, 0, ""},
-		{"R_ARM_TLS_CALL", Const, 10, ""},
-		{"R_ARM_TLS_DESCSEQ", Const, 10, ""},
-		{"R_ARM_TLS_DTPMOD32", Const, 10, ""},
-		{"R_ARM_TLS_DTPOFF32", Const, 10, ""},
-		{"R_ARM_TLS_GD32", Const, 10, ""},
-		{"R_ARM_TLS_GOTDESC", Const, 10, ""},
-		{"R_ARM_TLS_IE12GP", Const, 10, ""},
-		{"R_ARM_TLS_IE32", Const, 10, ""},
-		{"R_ARM_TLS_LDM32", Const, 10, ""},
-		{"R_ARM_TLS_LDO12", Const, 10, ""},
-		{"R_ARM_TLS_LDO32", Const, 10, ""},
-		{"R_ARM_TLS_LE12", Const, 10, ""},
-		{"R_ARM_TLS_LE32", Const, 10, ""},
-		{"R_ARM_TLS_TPOFF32", Const, 10, ""},
-		{"R_ARM_V4BX", Const, 10, ""},
-		{"R_ARM_XPC25", Const, 0, ""},
-		{"R_INFO", Func, 0, "func(sym uint32, typ uint32) uint64"},
-		{"R_INFO32", Func, 0, "func(sym uint32, typ uint32) uint32"},
-		{"R_LARCH", Type, 19, ""},
-		{"R_LARCH_32", Const, 19, ""},
-		{"R_LARCH_32_PCREL", Const, 20, ""},
-		{"R_LARCH_64", Const, 19, ""},
-		{"R_LARCH_64_PCREL", Const, 22, ""},
-		{"R_LARCH_ABS64_HI12", Const, 20, ""},
-		{"R_LARCH_ABS64_LO20", Const, 20, ""},
-		{"R_LARCH_ABS_HI20", Const, 20, ""},
-		{"R_LARCH_ABS_LO12", Const, 20, ""},
-		{"R_LARCH_ADD16", Const, 19, ""},
-		{"R_LARCH_ADD24", Const, 19, ""},
-		{"R_LARCH_ADD32", Const, 19, ""},
-		{"R_LARCH_ADD6", Const, 22, ""},
-		{"R_LARCH_ADD64", Const, 19, ""},
-		{"R_LARCH_ADD8", Const, 19, ""},
-		{"R_LARCH_ADD_ULEB128", Const, 22, ""},
-		{"R_LARCH_ALIGN", Const, 22, ""},
-		{"R_LARCH_B16", Const, 20, ""},
-		{"R_LARCH_B21", Const, 20, ""},
-		{"R_LARCH_B26", Const, 20, ""},
-		{"R_LARCH_CALL36", Const, 26, ""},
-		{"R_LARCH_CFA", Const, 22, ""},
-		{"R_LARCH_COPY", Const, 19, ""},
-		{"R_LARCH_DELETE", Const, 22, ""},
-		{"R_LARCH_GNU_VTENTRY", Const, 20, ""},
-		{"R_LARCH_GNU_VTINHERIT", Const, 20, ""},
-		{"R_LARCH_GOT64_HI12", Const, 20, ""},
-		{"R_LARCH_GOT64_LO20", Const, 20, ""},
-		{"R_LARCH_GOT64_PC_HI12", Const, 20, ""},
-		{"R_LARCH_GOT64_PC_LO20", Const, 20, ""},
-		{"R_LARCH_GOT_HI20", Const, 20, ""},
-		{"R_LARCH_GOT_LO12", Const, 20, ""},
-		{"R_LARCH_GOT_PC_HI20", Const, 20, ""},
-		{"R_LARCH_GOT_PC_LO12", Const, 20, ""},
-		{"R_LARCH_IRELATIVE", Const, 19, ""},
-		{"R_LARCH_JUMP_SLOT", Const, 19, ""},
-		{"R_LARCH_MARK_LA", Const, 19, ""},
-		{"R_LARCH_MARK_PCREL", Const, 19, ""},
-		{"R_LARCH_NONE", Const, 19, ""},
-		{"R_LARCH_PCALA64_HI12", Const, 20, ""},
-		{"R_LARCH_PCALA64_LO20", Const, 20, ""},
-		{"R_LARCH_PCALA_HI20", Const, 20, ""},
-		{"R_LARCH_PCALA_LO12", Const, 20, ""},
-		{"R_LARCH_PCREL20_S2", Const, 22, ""},
-		{"R_LARCH_RELATIVE", Const, 19, ""},
-		{"R_LARCH_RELAX", Const, 20, ""},
-		{"R_LARCH_SOP_ADD", Const, 19, ""},
-		{"R_LARCH_SOP_AND", Const, 19, ""},
-		{"R_LARCH_SOP_ASSERT", Const, 19, ""},
-		{"R_LARCH_SOP_IF_ELSE", Const, 19, ""},
-		{"R_LARCH_SOP_NOT", Const, 19, ""},
-		{"R_LARCH_SOP_POP_32_S_0_10_10_16_S2", Const, 19, ""},
-		{"R_LARCH_SOP_POP_32_S_0_5_10_16_S2", Const, 19, ""},
-		{"R_LARCH_SOP_POP_32_S_10_12", Const, 19, ""},
-		{"R_LARCH_SOP_POP_32_S_10_16", Const, 19, ""},
-		{"R_LARCH_SOP_POP_32_S_10_16_S2", Const, 19, ""},
-		{"R_LARCH_SOP_POP_32_S_10_5", Const, 19, ""},
-		{"R_LARCH_SOP_POP_32_S_5_20", Const, 19, ""},
-		{"R_LARCH_SOP_POP_32_U", Const, 19, ""},
-		{"R_LARCH_SOP_POP_32_U_10_12", Const, 19, ""},
-		{"R_LARCH_SOP_PUSH_ABSOLUTE", Const, 19, ""},
-		{"R_LARCH_SOP_PUSH_DUP", Const, 19, ""},
-		{"R_LARCH_SOP_PUSH_GPREL", Const, 19, ""},
-		{"R_LARCH_SOP_PUSH_PCREL", Const, 19, ""},
-		{"R_LARCH_SOP_PUSH_PLT_PCREL", Const, 19, ""},
-		{"R_LARCH_SOP_PUSH_TLS_GD", Const, 19, ""},
-		{"R_LARCH_SOP_PUSH_TLS_GOT", Const, 19, ""},
-		{"R_LARCH_SOP_PUSH_TLS_TPREL", Const, 19, ""},
-		{"R_LARCH_SOP_SL", Const, 19, ""},
-		{"R_LARCH_SOP_SR", Const, 19, ""},
-		{"R_LARCH_SOP_SUB", Const, 19, ""},
-		{"R_LARCH_SUB16", Const, 19, ""},
-		{"R_LARCH_SUB24", Const, 19, ""},
-		{"R_LARCH_SUB32", Const, 19, ""},
-		{"R_LARCH_SUB6", Const, 22, ""},
-		{"R_LARCH_SUB64", Const, 19, ""},
-		{"R_LARCH_SUB8", Const, 19, ""},
-		{"R_LARCH_SUB_ULEB128", Const, 22, ""},
-		{"R_LARCH_TLS_DESC32", Const, 26, ""},
-		{"R_LARCH_TLS_DESC64", Const, 26, ""},
-		{"R_LARCH_TLS_DESC64_HI12", Const, 26, ""},
-		{"R_LARCH_TLS_DESC64_LO20", Const, 26, ""},
-		{"R_LARCH_TLS_DESC64_PC_HI12", Const, 26, ""},
-		{"R_LARCH_TLS_DESC64_PC_LO20", Const, 26, ""},
-		{"R_LARCH_TLS_DESC_CALL", Const, 26, ""},
-		{"R_LARCH_TLS_DESC_HI20", Const, 26, ""},
-		{"R_LARCH_TLS_DESC_LD", Const, 26, ""},
-		{"R_LARCH_TLS_DESC_LO12", Const, 26, ""},
-		{"R_LARCH_TLS_DESC_PCREL20_S2", Const, 26, ""},
-		{"R_LARCH_TLS_DESC_PC_HI20", Const, 26, ""},
-		{"R_LARCH_TLS_DESC_PC_LO12", Const, 26, ""},
-		{"R_LARCH_TLS_DTPMOD32", Const, 19, ""},
-		{"R_LARCH_TLS_DTPMOD64", Const, 19, ""},
-		{"R_LARCH_TLS_DTPREL32", Const, 19, ""},
-		{"R_LARCH_TLS_DTPREL64", Const, 19, ""},
-		{"R_LARCH_TLS_GD_HI20", Const, 20, ""},
-		{"R_LARCH_TLS_GD_PCREL20_S2", Const, 26, ""},
-		{"R_LARCH_TLS_GD_PC_HI20", Const, 20, ""},
-		{"R_LARCH_TLS_IE64_HI12", Const, 20, ""},
-		{"R_LARCH_TLS_IE64_LO20", Const, 20, ""},
-		{"R_LARCH_TLS_IE64_PC_HI12", Const, 20, ""},
-		{"R_LARCH_TLS_IE64_PC_LO20", Const, 20, ""},
-		{"R_LARCH_TLS_IE_HI20", Const, 20, ""},
-		{"R_LARCH_TLS_IE_LO12", Const, 20, ""},
-		{"R_LARCH_TLS_IE_PC_HI20", Const, 20, ""},
-		{"R_LARCH_TLS_IE_PC_LO12", Const, 20, ""},
-		{"R_LARCH_TLS_LD_HI20", Const, 20, ""},
-		{"R_LARCH_TLS_LD_PCREL20_S2", Const, 26, ""},
-		{"R_LARCH_TLS_LD_PC_HI20", Const, 20, ""},
-		{"R_LARCH_TLS_LE64_HI12", Const, 20, ""},
-		{"R_LARCH_TLS_LE64_LO20", Const, 20, ""},
-		{"R_LARCH_TLS_LE_ADD_R", Const, 26, ""},
-		{"R_LARCH_TLS_LE_HI20", Const, 20, ""},
-		{"R_LARCH_TLS_LE_HI20_R", Const, 26, ""},
-		{"R_LARCH_TLS_LE_LO12", Const, 20, ""},
-		{"R_LARCH_TLS_LE_LO12_R", Const, 26, ""},
-		{"R_LARCH_TLS_TPREL32", Const, 19, ""},
-		{"R_LARCH_TLS_TPREL64", Const, 19, ""},
-		{"R_MIPS", Type, 6, ""},
-		{"R_MIPS_16", Const, 6, ""},
-		{"R_MIPS_26", Const, 6, ""},
-		{"R_MIPS_32", Const, 6, ""},
-		{"R_MIPS_64", Const, 6, ""},
-		{"R_MIPS_ADD_IMMEDIATE", Const, 6, ""},
-		{"R_MIPS_CALL16", Const, 6, ""},
-		{"R_MIPS_CALL_HI16", Const, 6, ""},
-		{"R_MIPS_CALL_LO16", Const, 6, ""},
-		{"R_MIPS_DELETE", Const, 6, ""},
-		{"R_MIPS_GOT16", Const, 6, ""},
-		{"R_MIPS_GOT_DISP", Const, 6, ""},
-		{"R_MIPS_GOT_HI16", Const, 6, ""},
-		{"R_MIPS_GOT_LO16", Const, 6, ""},
-		{"R_MIPS_GOT_OFST", Const, 6, ""},
-		{"R_MIPS_GOT_PAGE", Const, 6, ""},
-		{"R_MIPS_GPREL16", Const, 6, ""},
-		{"R_MIPS_GPREL32", Const, 6, ""},
-		{"R_MIPS_HI16", Const, 6, ""},
-		{"R_MIPS_HIGHER", Const, 6, ""},
-		{"R_MIPS_HIGHEST", Const, 6, ""},
-		{"R_MIPS_INSERT_A", Const, 6, ""},
-		{"R_MIPS_INSERT_B", Const, 6, ""},
-		{"R_MIPS_JALR", Const, 6, ""},
-		{"R_MIPS_LITERAL", Const, 6, ""},
-		{"R_MIPS_LO16", Const, 6, ""},
-		{"R_MIPS_NONE", Const, 6, ""},
-		{"R_MIPS_PC16", Const, 6, ""},
-		{"R_MIPS_PC32", Const, 22, ""},
-		{"R_MIPS_PJUMP", Const, 6, ""},
-		{"R_MIPS_REL16", Const, 6, ""},
-		{"R_MIPS_REL32", Const, 6, ""},
-		{"R_MIPS_RELGOT", Const, 6, ""},
-		{"R_MIPS_SCN_DISP", Const, 6, ""},
-		{"R_MIPS_SHIFT5", Const, 6, ""},
-		{"R_MIPS_SHIFT6", Const, 6, ""},
-		{"R_MIPS_SUB", Const, 6, ""},
-		{"R_MIPS_TLS_DTPMOD32", Const, 6, ""},
-		{"R_MIPS_TLS_DTPMOD64", Const, 6, ""},
-		{"R_MIPS_TLS_DTPREL32", Const, 6, ""},
-		{"R_MIPS_TLS_DTPREL64", Const, 6, ""},
-		{"R_MIPS_TLS_DTPREL_HI16", Const, 6, ""},
-		{"R_MIPS_TLS_DTPREL_LO16", Const, 6, ""},
-		{"R_MIPS_TLS_GD", Const, 6, ""},
-		{"R_MIPS_TLS_GOTTPREL", Const, 6, ""},
-		{"R_MIPS_TLS_LDM", Const, 6, ""},
-		{"R_MIPS_TLS_TPREL32", Const, 6, ""},
-		{"R_MIPS_TLS_TPREL64", Const, 6, ""},
-		{"R_MIPS_TLS_TPREL_HI16", Const, 6, ""},
-		{"R_MIPS_TLS_TPREL_LO16", Const, 6, ""},
-		{"R_PPC", Type, 0, ""},
-		{"R_PPC64", Type, 5, ""},
-		{"R_PPC64_ADDR14", Const, 5, ""},
-		{"R_PPC64_ADDR14_BRNTAKEN", Const, 5, ""},
-		{"R_PPC64_ADDR14_BRTAKEN", Const, 5, ""},
-		{"R_PPC64_ADDR16", Const, 5, ""},
-		{"R_PPC64_ADDR16_DS", Const, 5, ""},
-		{"R_PPC64_ADDR16_HA", Const, 5, ""},
-		{"R_PPC64_ADDR16_HI", Const, 5, ""},
-		{"R_PPC64_ADDR16_HIGH", Const, 10, ""},
-		{"R_PPC64_ADDR16_HIGHA", Const, 10, ""},
-		{"R_PPC64_ADDR16_HIGHER", Const, 5, ""},
-		{"R_PPC64_ADDR16_HIGHER34", Const, 20, ""},
-		{"R_PPC64_ADDR16_HIGHERA", Const, 5, ""},
-		{"R_PPC64_ADDR16_HIGHERA34", Const, 20, ""},
-		{"R_PPC64_ADDR16_HIGHEST", Const, 5, ""},
-		{"R_PPC64_ADDR16_HIGHEST34", Const, 20, ""},
-		{"R_PPC64_ADDR16_HIGHESTA", Const, 5, ""},
-		{"R_PPC64_ADDR16_HIGHESTA34", Const, 20, ""},
-		{"R_PPC64_ADDR16_LO", Const, 5, ""},
-		{"R_PPC64_ADDR16_LO_DS", Const, 5, ""},
-		{"R_PPC64_ADDR24", Const, 5, ""},
-		{"R_PPC64_ADDR32", Const, 5, ""},
-		{"R_PPC64_ADDR64", Const, 5, ""},
-		{"R_PPC64_ADDR64_LOCAL", Const, 10, ""},
-		{"R_PPC64_COPY", Const, 20, ""},
-		{"R_PPC64_D28", Const, 20, ""},
-		{"R_PPC64_D34", Const, 20, ""},
-		{"R_PPC64_D34_HA30", Const, 20, ""},
-		{"R_PPC64_D34_HI30", Const, 20, ""},
-		{"R_PPC64_D34_LO", Const, 20, ""},
-		{"R_PPC64_DTPMOD64", Const, 5, ""},
-		{"R_PPC64_DTPREL16", Const, 5, ""},
-		{"R_PPC64_DTPREL16_DS", Const, 5, ""},
-		{"R_PPC64_DTPREL16_HA", Const, 5, ""},
-		{"R_PPC64_DTPREL16_HI", Const, 5, ""},
-		{"R_PPC64_DTPREL16_HIGH", Const, 10, ""},
-		{"R_PPC64_DTPREL16_HIGHA", Const, 10, ""},
-		{"R_PPC64_DTPREL16_HIGHER", Const, 5, ""},
-		{"R_PPC64_DTPREL16_HIGHERA", Const, 5, ""},
-		{"R_PPC64_DTPREL16_HIGHEST", Const, 5, ""},
-		{"R_PPC64_DTPREL16_HIGHESTA", Const, 5, ""},
-		{"R_PPC64_DTPREL16_LO", Const, 5, ""},
-		{"R_PPC64_DTPREL16_LO_DS", Const, 5, ""},
-		{"R_PPC64_DTPREL34", Const, 20, ""},
-		{"R_PPC64_DTPREL64", Const, 5, ""},
-		{"R_PPC64_ENTRY", Const, 10, ""},
-		{"R_PPC64_GLOB_DAT", Const, 20, ""},
-		{"R_PPC64_GNU_VTENTRY", Const, 20, ""},
-		{"R_PPC64_GNU_VTINHERIT", Const, 20, ""},
-		{"R_PPC64_GOT16", Const, 5, ""},
-		{"R_PPC64_GOT16_DS", Const, 5, ""},
-		{"R_PPC64_GOT16_HA", Const, 5, ""},
-		{"R_PPC64_GOT16_HI", Const, 5, ""},
-		{"R_PPC64_GOT16_LO", Const, 5, ""},
-		{"R_PPC64_GOT16_LO_DS", Const, 5, ""},
-		{"R_PPC64_GOT_DTPREL16_DS", Const, 5, ""},
-		{"R_PPC64_GOT_DTPREL16_HA", Const, 5, ""},
-		{"R_PPC64_GOT_DTPREL16_HI", Const, 5, ""},
-		{"R_PPC64_GOT_DTPREL16_LO_DS", Const, 5, ""},
-		{"R_PPC64_GOT_DTPREL_PCREL34", Const, 20, ""},
-		{"R_PPC64_GOT_PCREL34", Const, 20, ""},
-		{"R_PPC64_GOT_TLSGD16", Const, 5, ""},
-		{"R_PPC64_GOT_TLSGD16_HA", Const, 5, ""},
-		{"R_PPC64_GOT_TLSGD16_HI", Const, 5, ""},
-		{"R_PPC64_GOT_TLSGD16_LO", Const, 5, ""},
-		{"R_PPC64_GOT_TLSGD_PCREL34", Const, 20, ""},
-		{"R_PPC64_GOT_TLSLD16", Const, 5, ""},
-		{"R_PPC64_GOT_TLSLD16_HA", Const, 5, ""},
-		{"R_PPC64_GOT_TLSLD16_HI", Const, 5, ""},
-		{"R_PPC64_GOT_TLSLD16_LO", Const, 5, ""},
-		{"R_PPC64_GOT_TLSLD_PCREL34", Const, 20, ""},
-		{"R_PPC64_GOT_TPREL16_DS", Const, 5, ""},
-		{"R_PPC64_GOT_TPREL16_HA", Const, 5, ""},
-		{"R_PPC64_GOT_TPREL16_HI", Const, 5, ""},
-		{"R_PPC64_GOT_TPREL16_LO_DS", Const, 5, ""},
-		{"R_PPC64_GOT_TPREL_PCREL34", Const, 20, ""},
-		{"R_PPC64_IRELATIVE", Const, 10, ""},
-		{"R_PPC64_JMP_IREL", Const, 10, ""},
-		{"R_PPC64_JMP_SLOT", Const, 5, ""},
-		{"R_PPC64_NONE", Const, 5, ""},
-		{"R_PPC64_PCREL28", Const, 20, ""},
-		{"R_PPC64_PCREL34", Const, 20, ""},
-		{"R_PPC64_PCREL_OPT", Const, 20, ""},
-		{"R_PPC64_PLT16_HA", Const, 20, ""},
-		{"R_PPC64_PLT16_HI", Const, 20, ""},
-		{"R_PPC64_PLT16_LO", Const, 20, ""},
-		{"R_PPC64_PLT16_LO_DS", Const, 10, ""},
-		{"R_PPC64_PLT32", Const, 20, ""},
-		{"R_PPC64_PLT64", Const, 20, ""},
-		{"R_PPC64_PLTCALL", Const, 20, ""},
-		{"R_PPC64_PLTCALL_NOTOC", Const, 20, ""},
-		{"R_PPC64_PLTGOT16", Const, 10, ""},
-		{"R_PPC64_PLTGOT16_DS", Const, 10, ""},
-		{"R_PPC64_PLTGOT16_HA", Const, 10, ""},
-		{"R_PPC64_PLTGOT16_HI", Const, 10, ""},
-		{"R_PPC64_PLTGOT16_LO", Const, 10, ""},
-		{"R_PPC64_PLTGOT_LO_DS", Const, 10, ""},
-		{"R_PPC64_PLTREL32", Const, 20, ""},
-		{"R_PPC64_PLTREL64", Const, 20, ""},
-		{"R_PPC64_PLTSEQ", Const, 20, ""},
-		{"R_PPC64_PLTSEQ_NOTOC", Const, 20, ""},
-		{"R_PPC64_PLT_PCREL34", Const, 20, ""},
-		{"R_PPC64_PLT_PCREL34_NOTOC", Const, 20, ""},
-		{"R_PPC64_REL14", Const, 5, ""},
-		{"R_PPC64_REL14_BRNTAKEN", Const, 5, ""},
-		{"R_PPC64_REL14_BRTAKEN", Const, 5, ""},
-		{"R_PPC64_REL16", Const, 5, ""},
-		{"R_PPC64_REL16DX_HA", Const, 10, ""},
-		{"R_PPC64_REL16_HA", Const, 5, ""},
-		{"R_PPC64_REL16_HI", Const, 5, ""},
-		{"R_PPC64_REL16_HIGH", Const, 20, ""},
-		{"R_PPC64_REL16_HIGHA", Const, 20, ""},
-		{"R_PPC64_REL16_HIGHER", Const, 20, ""},
-		{"R_PPC64_REL16_HIGHER34", Const, 20, ""},
-		{"R_PPC64_REL16_HIGHERA", Const, 20, ""},
-		{"R_PPC64_REL16_HIGHERA34", Const, 20, ""},
-		{"R_PPC64_REL16_HIGHEST", Const, 20, ""},
-		{"R_PPC64_REL16_HIGHEST34", Const, 20, ""},
-		{"R_PPC64_REL16_HIGHESTA", Const, 20, ""},
-		{"R_PPC64_REL16_HIGHESTA34", Const, 20, ""},
-		{"R_PPC64_REL16_LO", Const, 5, ""},
-		{"R_PPC64_REL24", Const, 5, ""},
-		{"R_PPC64_REL24_NOTOC", Const, 10, ""},
-		{"R_PPC64_REL24_P9NOTOC", Const, 21, ""},
-		{"R_PPC64_REL30", Const, 20, ""},
-		{"R_PPC64_REL32", Const, 5, ""},
-		{"R_PPC64_REL64", Const, 5, ""},
-		{"R_PPC64_RELATIVE", Const, 18, ""},
-		{"R_PPC64_SECTOFF", Const, 20, ""},
-		{"R_PPC64_SECTOFF_DS", Const, 10, ""},
-		{"R_PPC64_SECTOFF_HA", Const, 20, ""},
-		{"R_PPC64_SECTOFF_HI", Const, 20, ""},
-		{"R_PPC64_SECTOFF_LO", Const, 20, ""},
-		{"R_PPC64_SECTOFF_LO_DS", Const, 10, ""},
-		{"R_PPC64_TLS", Const, 5, ""},
-		{"R_PPC64_TLSGD", Const, 5, ""},
-		{"R_PPC64_TLSLD", Const, 5, ""},
-		{"R_PPC64_TOC", Const, 5, ""},
-		{"R_PPC64_TOC16", Const, 5, ""},
-		{"R_PPC64_TOC16_DS", Const, 5, ""},
-		{"R_PPC64_TOC16_HA", Const, 5, ""},
-		{"R_PPC64_TOC16_HI", Const, 5, ""},
-		{"R_PPC64_TOC16_LO", Const, 5, ""},
-		{"R_PPC64_TOC16_LO_DS", Const, 5, ""},
-		{"R_PPC64_TOCSAVE", Const, 10, ""},
-		{"R_PPC64_TPREL16", Const, 5, ""},
-		{"R_PPC64_TPREL16_DS", Const, 5, ""},
-		{"R_PPC64_TPREL16_HA", Const, 5, ""},
-		{"R_PPC64_TPREL16_HI", Const, 5, ""},
-		{"R_PPC64_TPREL16_HIGH", Const, 10, ""},
-		{"R_PPC64_TPREL16_HIGHA", Const, 10, ""},
-		{"R_PPC64_TPREL16_HIGHER", Const, 5, ""},
-		{"R_PPC64_TPREL16_HIGHERA", Const, 5, ""},
-		{"R_PPC64_TPREL16_HIGHEST", Const, 5, ""},
-		{"R_PPC64_TPREL16_HIGHESTA", Const, 5, ""},
-		{"R_PPC64_TPREL16_LO", Const, 5, ""},
-		{"R_PPC64_TPREL16_LO_DS", Const, 5, ""},
-		{"R_PPC64_TPREL34", Const, 20, ""},
-		{"R_PPC64_TPREL64", Const, 5, ""},
-		{"R_PPC64_UADDR16", Const, 20, ""},
-		{"R_PPC64_UADDR32", Const, 20, ""},
-		{"R_PPC64_UADDR64", Const, 20, ""},
-		{"R_PPC_ADDR14", Const, 0, ""},
-		{"R_PPC_ADDR14_BRNTAKEN", Const, 0, ""},
-		{"R_PPC_ADDR14_BRTAKEN", Const, 0, ""},
-		{"R_PPC_ADDR16", Const, 0, ""},
-		{"R_PPC_ADDR16_HA", Const, 0, ""},
-		{"R_PPC_ADDR16_HI", Const, 0, ""},
-		{"R_PPC_ADDR16_LO", Const, 0, ""},
-		{"R_PPC_ADDR24", Const, 0, ""},
-		{"R_PPC_ADDR32", Const, 0, ""},
-		{"R_PPC_COPY", Const, 0, ""},
-		{"R_PPC_DTPMOD32", Const, 0, ""},
-		{"R_PPC_DTPREL16", Const, 0, ""},
-		{"R_PPC_DTPREL16_HA", Const, 0, ""},
-		{"R_PPC_DTPREL16_HI", Const, 0, ""},
-		{"R_PPC_DTPREL16_LO", Const, 0, ""},
-		{"R_PPC_DTPREL32", Const, 0, ""},
-		{"R_PPC_EMB_BIT_FLD", Const, 0, ""},
-		{"R_PPC_EMB_MRKREF", Const, 0, ""},
-		{"R_PPC_EMB_NADDR16", Const, 0, ""},
-		{"R_PPC_EMB_NADDR16_HA", Const, 0, ""},
-		{"R_PPC_EMB_NADDR16_HI", Const, 0, ""},
-		{"R_PPC_EMB_NADDR16_LO", Const, 0, ""},
-		{"R_PPC_EMB_NADDR32", Const, 0, ""},
-		{"R_PPC_EMB_RELSDA", Const, 0, ""},
-		{"R_PPC_EMB_RELSEC16", Const, 0, ""},
-		{"R_PPC_EMB_RELST_HA", Const, 0, ""},
-		{"R_PPC_EMB_RELST_HI", Const, 0, ""},
-		{"R_PPC_EMB_RELST_LO", Const, 0, ""},
-		{"R_PPC_EMB_SDA21", Const, 0, ""},
-		{"R_PPC_EMB_SDA2I16", Const, 0, ""},
-		{"R_PPC_EMB_SDA2REL", Const, 0, ""},
-		{"R_PPC_EMB_SDAI16", Const, 0, ""},
-		{"R_PPC_GLOB_DAT", Const, 0, ""},
-		{"R_PPC_GOT16", Const, 0, ""},
-		{"R_PPC_GOT16_HA", Const, 0, ""},
-		{"R_PPC_GOT16_HI", Const, 0, ""},
-		{"R_PPC_GOT16_LO", Const, 0, ""},
-		{"R_PPC_GOT_TLSGD16", Const, 0, ""},
-		{"R_PPC_GOT_TLSGD16_HA", Const, 0, ""},
-		{"R_PPC_GOT_TLSGD16_HI", Const, 0, ""},
-		{"R_PPC_GOT_TLSGD16_LO", Const, 0, ""},
-		{"R_PPC_GOT_TLSLD16", Const, 0, ""},
-		{"R_PPC_GOT_TLSLD16_HA", Const, 0, ""},
-		{"R_PPC_GOT_TLSLD16_HI", Const, 0, ""},
-		{"R_PPC_GOT_TLSLD16_LO", Const, 0, ""},
-		{"R_PPC_GOT_TPREL16", Const, 0, ""},
-		{"R_PPC_GOT_TPREL16_HA", Const, 0, ""},
-		{"R_PPC_GOT_TPREL16_HI", Const, 0, ""},
-		{"R_PPC_GOT_TPREL16_LO", Const, 0, ""},
-		{"R_PPC_JMP_SLOT", Const, 0, ""},
-		{"R_PPC_LOCAL24PC", Const, 0, ""},
-		{"R_PPC_NONE", Const, 0, ""},
-		{"R_PPC_PLT16_HA", Const, 0, ""},
-		{"R_PPC_PLT16_HI", Const, 0, ""},
-		{"R_PPC_PLT16_LO", Const, 0, ""},
-		{"R_PPC_PLT32", Const, 0, ""},
-		{"R_PPC_PLTREL24", Const, 0, ""},
-		{"R_PPC_PLTREL32", Const, 0, ""},
-		{"R_PPC_REL14", Const, 0, ""},
-		{"R_PPC_REL14_BRNTAKEN", Const, 0, ""},
-		{"R_PPC_REL14_BRTAKEN", Const, 0, ""},
-		{"R_PPC_REL24", Const, 0, ""},
-		{"R_PPC_REL32", Const, 0, ""},
-		{"R_PPC_RELATIVE", Const, 0, ""},
-		{"R_PPC_SDAREL16", Const, 0, ""},
-		{"R_PPC_SECTOFF", Const, 0, ""},
-		{"R_PPC_SECTOFF_HA", Const, 0, ""},
-		{"R_PPC_SECTOFF_HI", Const, 0, ""},
-		{"R_PPC_SECTOFF_LO", Const, 0, ""},
-		{"R_PPC_TLS", Const, 0, ""},
-		{"R_PPC_TPREL16", Const, 0, ""},
-		{"R_PPC_TPREL16_HA", Const, 0, ""},
-		{"R_PPC_TPREL16_HI", Const, 0, ""},
-		{"R_PPC_TPREL16_LO", Const, 0, ""},
-		{"R_PPC_TPREL32", Const, 0, ""},
-		{"R_PPC_UADDR16", Const, 0, ""},
-		{"R_PPC_UADDR32", Const, 0, ""},
-		{"R_RISCV", Type, 11, ""},
-		{"R_RISCV_32", Const, 11, ""},
-		{"R_RISCV_32_PCREL", Const, 12, ""},
-		{"R_RISCV_64", Const, 11, ""},
-		{"R_RISCV_ADD16", Const, 11, ""},
-		{"R_RISCV_ADD32", Const, 11, ""},
-		{"R_RISCV_ADD64", Const, 11, ""},
-		{"R_RISCV_ADD8", Const, 11, ""},
-		{"R_RISCV_ALIGN", Const, 11, ""},
-		{"R_RISCV_BRANCH", Const, 11, ""},
-		{"R_RISCV_CALL", Const, 11, ""},
-		{"R_RISCV_CALL_PLT", Const, 11, ""},
-		{"R_RISCV_COPY", Const, 11, ""},
-		{"R_RISCV_GNU_VTENTRY", Const, 11, ""},
-		{"R_RISCV_GNU_VTINHERIT", Const, 11, ""},
-		{"R_RISCV_GOT_HI20", Const, 11, ""},
-		{"R_RISCV_GPREL_I", Const, 11, ""},
-		{"R_RISCV_GPREL_S", Const, 11, ""},
-		{"R_RISCV_HI20", Const, 11, ""},
-		{"R_RISCV_JAL", Const, 11, ""},
-		{"R_RISCV_JUMP_SLOT", Const, 11, ""},
-		{"R_RISCV_LO12_I", Const, 11, ""},
-		{"R_RISCV_LO12_S", Const, 11, ""},
-		{"R_RISCV_NONE", Const, 11, ""},
-		{"R_RISCV_PCREL_HI20", Const, 11, ""},
-		{"R_RISCV_PCREL_LO12_I", Const, 11, ""},
-		{"R_RISCV_PCREL_LO12_S", Const, 11, ""},
-		{"R_RISCV_RELATIVE", Const, 11, ""},
-		{"R_RISCV_RELAX", Const, 11, ""},
-		{"R_RISCV_RVC_BRANCH", Const, 11, ""},
-		{"R_RISCV_RVC_JUMP", Const, 11, ""},
-		{"R_RISCV_RVC_LUI", Const, 11, ""},
-		{"R_RISCV_SET16", Const, 11, ""},
-		{"R_RISCV_SET32", Const, 11, ""},
-		{"R_RISCV_SET6", Const, 11, ""},
-		{"R_RISCV_SET8", Const, 11, ""},
-		{"R_RISCV_SUB16", Const, 11, ""},
-		{"R_RISCV_SUB32", Const, 11, ""},
-		{"R_RISCV_SUB6", Const, 11, ""},
-		{"R_RISCV_SUB64", Const, 11, ""},
-		{"R_RISCV_SUB8", Const, 11, ""},
-		{"R_RISCV_TLS_DTPMOD32", Const, 11, ""},
-		{"R_RISCV_TLS_DTPMOD64", Const, 11, ""},
-		{"R_RISCV_TLS_DTPREL32", Const, 11, ""},
-		{"R_RISCV_TLS_DTPREL64", Const, 11, ""},
-		{"R_RISCV_TLS_GD_HI20", Const, 11, ""},
-		{"R_RISCV_TLS_GOT_HI20", Const, 11, ""},
-		{"R_RISCV_TLS_TPREL32", Const, 11, ""},
-		{"R_RISCV_TLS_TPREL64", Const, 11, ""},
-		{"R_RISCV_TPREL_ADD", Const, 11, ""},
-		{"R_RISCV_TPREL_HI20", Const, 11, ""},
-		{"R_RISCV_TPREL_I", Const, 11, ""},
-		{"R_RISCV_TPREL_LO12_I", Const, 11, ""},
-		{"R_RISCV_TPREL_LO12_S", Const, 11, ""},
-		{"R_RISCV_TPREL_S", Const, 11, ""},
-		{"R_SPARC", Type, 0, ""},
-		{"R_SPARC_10", Const, 0, ""},
-		{"R_SPARC_11", Const, 0, ""},
-		{"R_SPARC_13", Const, 0, ""},
-		{"R_SPARC_16", Const, 0, ""},
-		{"R_SPARC_22", Const, 0, ""},
-		{"R_SPARC_32", Const, 0, ""},
-		{"R_SPARC_5", Const, 0, ""},
-		{"R_SPARC_6", Const, 0, ""},
-		{"R_SPARC_64", Const, 0, ""},
-		{"R_SPARC_7", Const, 0, ""},
-		{"R_SPARC_8", Const, 0, ""},
-		{"R_SPARC_COPY", Const, 0, ""},
-		{"R_SPARC_DISP16", Const, 0, ""},
-		{"R_SPARC_DISP32", Const, 0, ""},
-		{"R_SPARC_DISP64", Const, 0, ""},
-		{"R_SPARC_DISP8", Const, 0, ""},
-		{"R_SPARC_GLOB_DAT", Const, 0, ""},
-		{"R_SPARC_GLOB_JMP", Const, 0, ""},
-		{"R_SPARC_GOT10", Const, 0, ""},
-		{"R_SPARC_GOT13", Const, 0, ""},
-		{"R_SPARC_GOT22", Const, 0, ""},
-		{"R_SPARC_H44", Const, 0, ""},
-		{"R_SPARC_HH22", Const, 0, ""},
-		{"R_SPARC_HI22", Const, 0, ""},
-		{"R_SPARC_HIPLT22", Const, 0, ""},
-		{"R_SPARC_HIX22", Const, 0, ""},
-		{"R_SPARC_HM10", Const, 0, ""},
-		{"R_SPARC_JMP_SLOT", Const, 0, ""},
-		{"R_SPARC_L44", Const, 0, ""},
-		{"R_SPARC_LM22", Const, 0, ""},
-		{"R_SPARC_LO10", Const, 0, ""},
-		{"R_SPARC_LOPLT10", Const, 0, ""},
-		{"R_SPARC_LOX10", Const, 0, ""},
-		{"R_SPARC_M44", Const, 0, ""},
-		{"R_SPARC_NONE", Const, 0, ""},
-		{"R_SPARC_OLO10", Const, 0, ""},
-		{"R_SPARC_PC10", Const, 0, ""},
-		{"R_SPARC_PC22", Const, 0, ""},
-		{"R_SPARC_PCPLT10", Const, 0, ""},
-		{"R_SPARC_PCPLT22", Const, 0, ""},
-		{"R_SPARC_PCPLT32", Const, 0, ""},
-		{"R_SPARC_PC_HH22", Const, 0, ""},
-		{"R_SPARC_PC_HM10", Const, 0, ""},
-		{"R_SPARC_PC_LM22", Const, 0, ""},
-		{"R_SPARC_PLT32", Const, 0, ""},
-		{"R_SPARC_PLT64", Const, 0, ""},
-		{"R_SPARC_REGISTER", Const, 0, ""},
-		{"R_SPARC_RELATIVE", Const, 0, ""},
-		{"R_SPARC_UA16", Const, 0, ""},
-		{"R_SPARC_UA32", Const, 0, ""},
-		{"R_SPARC_UA64", Const, 0, ""},
-		{"R_SPARC_WDISP16", Const, 0, ""},
-		{"R_SPARC_WDISP19", Const, 0, ""},
-		{"R_SPARC_WDISP22", Const, 0, ""},
-		{"R_SPARC_WDISP30", Const, 0, ""},
-		{"R_SPARC_WPLT30", Const, 0, ""},
-		{"R_SYM32", Func, 0, "func(info uint32) uint32"},
-		{"R_SYM64", Func, 0, "func(info uint64) uint32"},
-		{"R_TYPE32", Func, 0, "func(info uint32) uint32"},
-		{"R_TYPE64", Func, 0, "func(info uint64) uint32"},
-		{"R_X86_64", Type, 0, ""},
-		{"R_X86_64_16", Const, 0, ""},
-		{"R_X86_64_32", Const, 0, ""},
-		{"R_X86_64_32S", Const, 0, ""},
-		{"R_X86_64_64", Const, 0, ""},
-		{"R_X86_64_8", Const, 0, ""},
-		{"R_X86_64_COPY", Const, 0, ""},
-		{"R_X86_64_DTPMOD64", Const, 0, ""},
-		{"R_X86_64_DTPOFF32", Const, 0, ""},
-		{"R_X86_64_DTPOFF64", Const, 0, ""},
-		{"R_X86_64_GLOB_DAT", Const, 0, ""},
-		{"R_X86_64_GOT32", Const, 0, ""},
-		{"R_X86_64_GOT64", Const, 10, ""},
-		{"R_X86_64_GOTOFF64", Const, 10, ""},
-		{"R_X86_64_GOTPC32", Const, 10, ""},
-		{"R_X86_64_GOTPC32_TLSDESC", Const, 10, ""},
-		{"R_X86_64_GOTPC64", Const, 10, ""},
-		{"R_X86_64_GOTPCREL", Const, 0, ""},
-		{"R_X86_64_GOTPCREL64", Const, 10, ""},
-		{"R_X86_64_GOTPCRELX", Const, 10, ""},
-		{"R_X86_64_GOTPLT64", Const, 10, ""},
-		{"R_X86_64_GOTTPOFF", Const, 0, ""},
-		{"R_X86_64_IRELATIVE", Const, 10, ""},
-		{"R_X86_64_JMP_SLOT", Const, 0, ""},
-		{"R_X86_64_NONE", Const, 0, ""},
-		{"R_X86_64_PC16", Const, 0, ""},
-		{"R_X86_64_PC32", Const, 0, ""},
-		{"R_X86_64_PC32_BND", Const, 10, ""},
-		{"R_X86_64_PC64", Const, 10, ""},
-		{"R_X86_64_PC8", Const, 0, ""},
-		{"R_X86_64_PLT32", Const, 0, ""},
-		{"R_X86_64_PLT32_BND", Const, 10, ""},
-		{"R_X86_64_PLTOFF64", Const, 10, ""},
-		{"R_X86_64_RELATIVE", Const, 0, ""},
-		{"R_X86_64_RELATIVE64", Const, 10, ""},
-		{"R_X86_64_REX_GOTPCRELX", Const, 10, ""},
-		{"R_X86_64_SIZE32", Const, 10, ""},
-		{"R_X86_64_SIZE64", Const, 10, ""},
-		{"R_X86_64_TLSDESC", Const, 10, ""},
-		{"R_X86_64_TLSDESC_CALL", Const, 10, ""},
-		{"R_X86_64_TLSGD", Const, 0, ""},
-		{"R_X86_64_TLSLD", Const, 0, ""},
-		{"R_X86_64_TPOFF32", Const, 0, ""},
-		{"R_X86_64_TPOFF64", Const, 0, ""},
-		{"Rel32", Type, 0, ""},
-		{"Rel32.Info", Field, 0, ""},
-		{"Rel32.Off", Field, 0, ""},
-		{"Rel64", Type, 0, ""},
-		{"Rel64.Info", Field, 0, ""},
-		{"Rel64.Off", Field, 0, ""},
-		{"Rela32", Type, 0, ""},
-		{"Rela32.Addend", Field, 0, ""},
-		{"Rela32.Info", Field, 0, ""},
-		{"Rela32.Off", Field, 0, ""},
-		{"Rela64", Type, 0, ""},
-		{"Rela64.Addend", Field, 0, ""},
-		{"Rela64.Info", Field, 0, ""},
-		{"Rela64.Off", Field, 0, ""},
-		{"SHF_ALLOC", Const, 0, ""},
-		{"SHF_COMPRESSED", Const, 6, ""},
-		{"SHF_EXECINSTR", Const, 0, ""},
-		{"SHF_GROUP", Const, 0, ""},
-		{"SHF_INFO_LINK", Const, 0, ""},
-		{"SHF_LINK_ORDER", Const, 0, ""},
-		{"SHF_MASKOS", Const, 0, ""},
-		{"SHF_MASKPROC", Const, 0, ""},
-		{"SHF_MERGE", Const, 0, ""},
-		{"SHF_OS_NONCONFORMING", Const, 0, ""},
-		{"SHF_STRINGS", Const, 0, ""},
-		{"SHF_TLS", Const, 0, ""},
-		{"SHF_WRITE", Const, 0, ""},
-		{"SHN_ABS", Const, 0, ""},
-		{"SHN_COMMON", Const, 0, ""},
-		{"SHN_HIOS", Const, 0, ""},
-		{"SHN_HIPROC", Const, 0, ""},
-		{"SHN_HIRESERVE", Const, 0, ""},
-		{"SHN_LOOS", Const, 0, ""},
-		{"SHN_LOPROC", Const, 0, ""},
-		{"SHN_LORESERVE", Const, 0, ""},
-		{"SHN_UNDEF", Const, 0, ""},
-		{"SHN_XINDEX", Const, 0, ""},
-		{"SHT_DYNAMIC", Const, 0, ""},
-		{"SHT_DYNSYM", Const, 0, ""},
-		{"SHT_FINI_ARRAY", Const, 0, ""},
-		{"SHT_GNU_ATTRIBUTES", Const, 0, ""},
-		{"SHT_GNU_HASH", Const, 0, ""},
-		{"SHT_GNU_LIBLIST", Const, 0, ""},
-		{"SHT_GNU_VERDEF", Const, 0, ""},
-		{"SHT_GNU_VERNEED", Const, 0, ""},
-		{"SHT_GNU_VERSYM", Const, 0, ""},
-		{"SHT_GROUP", Const, 0, ""},
-		{"SHT_HASH", Const, 0, ""},
-		{"SHT_HIOS", Const, 0, ""},
-		{"SHT_HIPROC", Const, 0, ""},
-		{"SHT_HIUSER", Const, 0, ""},
-		{"SHT_INIT_ARRAY", Const, 0, ""},
-		{"SHT_LOOS", Const, 0, ""},
-		{"SHT_LOPROC", Const, 0, ""},
-		{"SHT_LOUSER", Const, 0, ""},
-		{"SHT_MIPS_ABIFLAGS", Const, 17, ""},
-		{"SHT_NOBITS", Const, 0, ""},
-		{"SHT_NOTE", Const, 0, ""},
-		{"SHT_NULL", Const, 0, ""},
-		{"SHT_PREINIT_ARRAY", Const, 0, ""},
-		{"SHT_PROGBITS", Const, 0, ""},
-		{"SHT_REL", Const, 0, ""},
-		{"SHT_RELA", Const, 0, ""},
-		{"SHT_RISCV_ATTRIBUTES", Const, 25, ""},
-		{"SHT_SHLIB", Const, 0, ""},
-		{"SHT_STRTAB", Const, 0, ""},
-		{"SHT_SYMTAB", Const, 0, ""},
-		{"SHT_SYMTAB_SHNDX", Const, 0, ""},
-		{"STB_GLOBAL", Const, 0, ""},
-		{"STB_HIOS", Const, 0, ""},
-		{"STB_HIPROC", Const, 0, ""},
-		{"STB_LOCAL", Const, 0, ""},
-		{"STB_LOOS", Const, 0, ""},
-		{"STB_LOPROC", Const, 0, ""},
-		{"STB_WEAK", Const, 0, ""},
-		{"STT_COMMON", Const, 0, ""},
-		{"STT_FILE", Const, 0, ""},
-		{"STT_FUNC", Const, 0, ""},
-		{"STT_GNU_IFUNC", Const, 23, ""},
-		{"STT_HIOS", Const, 0, ""},
-		{"STT_HIPROC", Const, 0, ""},
-		{"STT_LOOS", Const, 0, ""},
-		{"STT_LOPROC", Const, 0, ""},
-		{"STT_NOTYPE", Const, 0, ""},
-		{"STT_OBJECT", Const, 0, ""},
-		{"STT_RELC", Const, 23, ""},
-		{"STT_SECTION", Const, 0, ""},
-		{"STT_SRELC", Const, 23, ""},
-		{"STT_TLS", Const, 0, ""},
-		{"STV_DEFAULT", Const, 0, ""},
-		{"STV_HIDDEN", Const, 0, ""},
-		{"STV_INTERNAL", Const, 0, ""},
-		{"STV_PROTECTED", Const, 0, ""},
-		{"ST_BIND", Func, 0, "func(info uint8) SymBind"},
-		{"ST_INFO", Func, 0, "func(bind SymBind, typ SymType) uint8"},
-		{"ST_TYPE", Func, 0, "func(info uint8) SymType"},
-		{"ST_VISIBILITY", Func, 0, "func(other uint8) SymVis"},
-		{"Section", Type, 0, ""},
-		{"Section.ReaderAt", Field, 0, ""},
-		{"Section.SectionHeader", Field, 0, ""},
-		{"Section32", Type, 0, ""},
-		{"Section32.Addr", Field, 0, ""},
-		{"Section32.Addralign", Field, 0, ""},
-		{"Section32.Entsize", Field, 0, ""},
-		{"Section32.Flags", Field, 0, ""},
-		{"Section32.Info", Field, 0, ""},
-		{"Section32.Link", Field, 0, ""},
-		{"Section32.Name", Field, 0, ""},
-		{"Section32.Off", Field, 0, ""},
-		{"Section32.Size", Field, 0, ""},
-		{"Section32.Type", Field, 0, ""},
-		{"Section64", Type, 0, ""},
-		{"Section64.Addr", Field, 0, ""},
-		{"Section64.Addralign", Field, 0, ""},
-		{"Section64.Entsize", Field, 0, ""},
-		{"Section64.Flags", Field, 0, ""},
-		{"Section64.Info", Field, 0, ""},
-		{"Section64.Link", Field, 0, ""},
-		{"Section64.Name", Field, 0, ""},
-		{"Section64.Off", Field, 0, ""},
-		{"Section64.Size", Field, 0, ""},
-		{"Section64.Type", Field, 0, ""},
-		{"SectionFlag", Type, 0, ""},
-		{"SectionHeader", Type, 0, ""},
-		{"SectionHeader.Addr", Field, 0, ""},
-		{"SectionHeader.Addralign", Field, 0, ""},
-		{"SectionHeader.Entsize", Field, 0, ""},
-		{"SectionHeader.FileSize", Field, 6, ""},
-		{"SectionHeader.Flags", Field, 0, ""},
-		{"SectionHeader.Info", Field, 0, ""},
-		{"SectionHeader.Link", Field, 0, ""},
-		{"SectionHeader.Name", Field, 0, ""},
-		{"SectionHeader.Offset", Field, 0, ""},
-		{"SectionHeader.Size", Field, 0, ""},
-		{"SectionHeader.Type", Field, 0, ""},
-		{"SectionIndex", Type, 0, ""},
-		{"SectionType", Type, 0, ""},
-		{"Sym32", Type, 0, ""},
-		{"Sym32.Info", Field, 0, ""},
-		{"Sym32.Name", Field, 0, ""},
-		{"Sym32.Other", Field, 0, ""},
-		{"Sym32.Shndx", Field, 0, ""},
-		{"Sym32.Size", Field, 0, ""},
-		{"Sym32.Value", Field, 0, ""},
-		{"Sym32Size", Const, 0, ""},
-		{"Sym64", Type, 0, ""},
-		{"Sym64.Info", Field, 0, ""},
-		{"Sym64.Name", Field, 0, ""},
-		{"Sym64.Other", Field, 0, ""},
-		{"Sym64.Shndx", Field, 0, ""},
-		{"Sym64.Size", Field, 0, ""},
-		{"Sym64.Value", Field, 0, ""},
-		{"Sym64Size", Const, 0, ""},
-		{"SymBind", Type, 0, ""},
-		{"SymType", Type, 0, ""},
-		{"SymVis", Type, 0, ""},
-		{"Symbol", Type, 0, ""},
-		{"Symbol.HasVersion", Field, 24, ""},
-		{"Symbol.Info", Field, 0, ""},
-		{"Symbol.Library", Field, 13, ""},
-		{"Symbol.Name", Field, 0, ""},
-		{"Symbol.Other", Field, 0, ""},
-		{"Symbol.Section", Field, 0, ""},
-		{"Symbol.Size", Field, 0, ""},
-		{"Symbol.Value", Field, 0, ""},
-		{"Symbol.Version", Field, 13, ""},
-		{"Symbol.VersionIndex", Field, 24, ""},
-		{"Type", Type, 0, ""},
-		{"VER_FLG_BASE", Const, 24, ""},
-		{"VER_FLG_INFO", Const, 24, ""},
-		{"VER_FLG_WEAK", Const, 24, ""},
-		{"Version", Type, 0, ""},
-		{"VersionIndex", Type, 24, ""},
-	},
-	"debug/gosym": {
-		{"(*DecodingError).Error", Method, 0, ""},
-		{"(*LineTable).LineToPC", Method, 0, ""},
-		{"(*LineTable).PCToLine", Method, 0, ""},
-		{"(*Sym).BaseName", Method, 0, ""},
-		{"(*Sym).PackageName", Method, 0, ""},
-		{"(*Sym).ReceiverName", Method, 0, ""},
-		{"(*Sym).Static", Method, 0, ""},
-		{"(*Table).LineToPC", Method, 0, ""},
-		{"(*Table).LookupFunc", Method, 0, ""},
-		{"(*Table).LookupSym", Method, 0, ""},
-		{"(*Table).PCToFunc", Method, 0, ""},
-		{"(*Table).PCToLine", Method, 0, ""},
-		{"(*Table).SymByAddr", Method, 0, ""},
-		{"(*UnknownLineError).Error", Method, 0, ""},
-		{"(Func).BaseName", Method, 0, ""},
-		{"(Func).PackageName", Method, 0, ""},
-		{"(Func).ReceiverName", Method, 0, ""},
-		{"(Func).Static", Method, 0, ""},
-		{"(UnknownFileError).Error", Method, 0, ""},
-		{"DecodingError", Type, 0, ""},
-		{"Func", Type, 0, ""},
-		{"Func.End", Field, 0, ""},
-		{"Func.Entry", Field, 0, ""},
-		{"Func.FrameSize", Field, 0, ""},
-		{"Func.LineTable", Field, 0, ""},
-		{"Func.Locals", Field, 0, ""},
-		{"Func.Obj", Field, 0, ""},
-		{"Func.Params", Field, 0, ""},
-		{"Func.Sym", Field, 0, ""},
-		{"LineTable", Type, 0, ""},
-		{"LineTable.Data", Field, 0, ""},
-		{"LineTable.Line", Field, 0, ""},
-		{"LineTable.PC", Field, 0, ""},
-		{"NewLineTable", Func, 0, "func(data []byte, text uint64) *LineTable"},
-		{"NewTable", Func, 0, "func(symtab []byte, pcln *LineTable) (*Table, error)"},
-		{"Obj", Type, 0, ""},
-		{"Obj.Funcs", Field, 0, ""},
-		{"Obj.Paths", Field, 0, ""},
-		{"Sym", Type, 0, ""},
-		{"Sym.Func", Field, 0, ""},
-		{"Sym.GoType", Field, 0, ""},
-		{"Sym.Name", Field, 0, ""},
-		{"Sym.Type", Field, 0, ""},
-		{"Sym.Value", Field, 0, ""},
-		{"Table", Type, 0, ""},
-		{"Table.Files", Field, 0, ""},
-		{"Table.Funcs", Field, 0, ""},
-		{"Table.Objs", Field, 0, ""},
-		{"Table.Syms", Field, 0, ""},
-		{"UnknownFileError", Type, 0, ""},
-		{"UnknownLineError", Type, 0, ""},
-		{"UnknownLineError.File", Field, 0, ""},
-		{"UnknownLineError.Line", Field, 0, ""},
-	},
-	"debug/macho": {
-		{"(*FatFile).Close", Method, 3, ""},
-		{"(*File).Close", Method, 0, ""},
-		{"(*File).DWARF", Method, 0, ""},
-		{"(*File).ImportedLibraries", Method, 0, ""},
-		{"(*File).ImportedSymbols", Method, 0, ""},
-		{"(*File).Section", Method, 0, ""},
-		{"(*File).Segment", Method, 0, ""},
-		{"(*FormatError).Error", Method, 0, ""},
-		{"(*Section).Data", Method, 0, ""},
-		{"(*Section).Open", Method, 0, ""},
-		{"(*Segment).Data", Method, 0, ""},
-		{"(*Segment).Open", Method, 0, ""},
-		{"(Cpu).GoString", Method, 0, ""},
-		{"(Cpu).String", Method, 0, ""},
-		{"(Dylib).Raw", Method, 0, ""},
-		{"(Dysymtab).Raw", Method, 0, ""},
-		{"(FatArch).Close", Method, 3, ""},
-		{"(FatArch).DWARF", Method, 3, ""},
-		{"(FatArch).ImportedLibraries", Method, 3, ""},
-		{"(FatArch).ImportedSymbols", Method, 3, ""},
-		{"(FatArch).Section", Method, 3, ""},
-		{"(FatArch).Segment", Method, 3, ""},
-		{"(Load).Raw", Method, 0, ""},
-		{"(LoadBytes).Raw", Method, 0, ""},
-		{"(LoadCmd).GoString", Method, 0, ""},
-		{"(LoadCmd).String", Method, 0, ""},
-		{"(RelocTypeARM).GoString", Method, 10, ""},
-		{"(RelocTypeARM).String", Method, 10, ""},
-		{"(RelocTypeARM64).GoString", Method, 10, ""},
-		{"(RelocTypeARM64).String", Method, 10, ""},
-		{"(RelocTypeGeneric).GoString", Method, 10, ""},
-		{"(RelocTypeGeneric).String", Method, 10, ""},
-		{"(RelocTypeX86_64).GoString", Method, 10, ""},
-		{"(RelocTypeX86_64).String", Method, 10, ""},
-		{"(Rpath).Raw", Method, 10, ""},
-		{"(Section).ReadAt", Method, 0, ""},
-		{"(Segment).Raw", Method, 0, ""},
-		{"(Segment).ReadAt", Method, 0, ""},
-		{"(Symtab).Raw", Method, 0, ""},
-		{"(Type).GoString", Method, 10, ""},
-		{"(Type).String", Method, 10, ""},
-		{"ARM64_RELOC_ADDEND", Const, 10, ""},
-		{"ARM64_RELOC_BRANCH26", Const, 10, ""},
-		{"ARM64_RELOC_GOT_LOAD_PAGE21", Const, 10, ""},
-		{"ARM64_RELOC_GOT_LOAD_PAGEOFF12", Const, 10, ""},
-		{"ARM64_RELOC_PAGE21", Const, 10, ""},
-		{"ARM64_RELOC_PAGEOFF12", Const, 10, ""},
-		{"ARM64_RELOC_POINTER_TO_GOT", Const, 10, ""},
-		{"ARM64_RELOC_SUBTRACTOR", Const, 10, ""},
-		{"ARM64_RELOC_TLVP_LOAD_PAGE21", Const, 10, ""},
-		{"ARM64_RELOC_TLVP_LOAD_PAGEOFF12", Const, 10, ""},
-		{"ARM64_RELOC_UNSIGNED", Const, 10, ""},
-		{"ARM_RELOC_BR24", Const, 10, ""},
-		{"ARM_RELOC_HALF", Const, 10, ""},
-		{"ARM_RELOC_HALF_SECTDIFF", Const, 10, ""},
-		{"ARM_RELOC_LOCAL_SECTDIFF", Const, 10, ""},
-		{"ARM_RELOC_PAIR", Const, 10, ""},
-		{"ARM_RELOC_PB_LA_PTR", Const, 10, ""},
-		{"ARM_RELOC_SECTDIFF", Const, 10, ""},
-		{"ARM_RELOC_VANILLA", Const, 10, ""},
-		{"ARM_THUMB_32BIT_BRANCH", Const, 10, ""},
-		{"ARM_THUMB_RELOC_BR22", Const, 10, ""},
-		{"Cpu", Type, 0, ""},
-		{"Cpu386", Const, 0, ""},
-		{"CpuAmd64", Const, 0, ""},
-		{"CpuArm", Const, 3, ""},
-		{"CpuArm64", Const, 11, ""},
-		{"CpuPpc", Const, 3, ""},
-		{"CpuPpc64", Const, 3, ""},
-		{"Dylib", Type, 0, ""},
-		{"Dylib.CompatVersion", Field, 0, ""},
-		{"Dylib.CurrentVersion", Field, 0, ""},
-		{"Dylib.LoadBytes", Field, 0, ""},
-		{"Dylib.Name", Field, 0, ""},
-		{"Dylib.Time", Field, 0, ""},
-		{"DylibCmd", Type, 0, ""},
-		{"DylibCmd.Cmd", Field, 0, ""},
-		{"DylibCmd.CompatVersion", Field, 0, ""},
-		{"DylibCmd.CurrentVersion", Field, 0, ""},
-		{"DylibCmd.Len", Field, 0, ""},
-		{"DylibCmd.Name", Field, 0, ""},
-		{"DylibCmd.Time", Field, 0, ""},
-		{"Dysymtab", Type, 0, ""},
-		{"Dysymtab.DysymtabCmd", Field, 0, ""},
-		{"Dysymtab.IndirectSyms", Field, 0, ""},
-		{"Dysymtab.LoadBytes", Field, 0, ""},
-		{"DysymtabCmd", Type, 0, ""},
-		{"DysymtabCmd.Cmd", Field, 0, ""},
-		{"DysymtabCmd.Extrefsymoff", Field, 0, ""},
-		{"DysymtabCmd.Extreloff", Field, 0, ""},
-		{"DysymtabCmd.Iextdefsym", Field, 0, ""},
-		{"DysymtabCmd.Ilocalsym", Field, 0, ""},
-		{"DysymtabCmd.Indirectsymoff", Field, 0, ""},
-		{"DysymtabCmd.Iundefsym", Field, 0, ""},
-		{"DysymtabCmd.Len", Field, 0, ""},
-		{"DysymtabCmd.Locreloff", Field, 0, ""},
-		{"DysymtabCmd.Modtaboff", Field, 0, ""},
-		{"DysymtabCmd.Nextdefsym", Field, 0, ""},
-		{"DysymtabCmd.Nextrefsyms", Field, 0, ""},
-		{"DysymtabCmd.Nextrel", Field, 0, ""},
-		{"DysymtabCmd.Nindirectsyms", Field, 0, ""},
-		{"DysymtabCmd.Nlocalsym", Field, 0, ""},
-		{"DysymtabCmd.Nlocrel", Field, 0, ""},
-		{"DysymtabCmd.Nmodtab", Field, 0, ""},
-		{"DysymtabCmd.Ntoc", Field, 0, ""},
-		{"DysymtabCmd.Nundefsym", Field, 0, ""},
-		{"DysymtabCmd.Tocoffset", Field, 0, ""},
-		{"ErrNotFat", Var, 3, ""},
-		{"FatArch", Type, 3, ""},
-		{"FatArch.FatArchHeader", Field, 3, ""},
-		{"FatArch.File", Field, 3, ""},
-		{"FatArchHeader", Type, 3, ""},
-		{"FatArchHeader.Align", Field, 3, ""},
-		{"FatArchHeader.Cpu", Field, 3, ""},
-		{"FatArchHeader.Offset", Field, 3, ""},
-		{"FatArchHeader.Size", Field, 3, ""},
-		{"FatArchHeader.SubCpu", Field, 3, ""},
-		{"FatFile", Type, 3, ""},
-		{"FatFile.Arches", Field, 3, ""},
-		{"FatFile.Magic", Field, 3, ""},
-		{"File", Type, 0, ""},
-		{"File.ByteOrder", Field, 0, ""},
-		{"File.Dysymtab", Field, 0, ""},
-		{"File.FileHeader", Field, 0, ""},
-		{"File.Loads", Field, 0, ""},
-		{"File.Sections", Field, 0, ""},
-		{"File.Symtab", Field, 0, ""},
-		{"FileHeader", Type, 0, ""},
-		{"FileHeader.Cmdsz", Field, 0, ""},
-		{"FileHeader.Cpu", Field, 0, ""},
-		{"FileHeader.Flags", Field, 0, ""},
-		{"FileHeader.Magic", Field, 0, ""},
-		{"FileHeader.Ncmd", Field, 0, ""},
-		{"FileHeader.SubCpu", Field, 0, ""},
-		{"FileHeader.Type", Field, 0, ""},
-		{"FlagAllModsBound", Const, 10, ""},
-		{"FlagAllowStackExecution", Const, 10, ""},
-		{"FlagAppExtensionSafe", Const, 10, ""},
-		{"FlagBindAtLoad", Const, 10, ""},
-		{"FlagBindsToWeak", Const, 10, ""},
-		{"FlagCanonical", Const, 10, ""},
-		{"FlagDeadStrippableDylib", Const, 10, ""},
-		{"FlagDyldLink", Const, 10, ""},
-		{"FlagForceFlat", Const, 10, ""},
-		{"FlagHasTLVDescriptors", Const, 10, ""},
-		{"FlagIncrLink", Const, 10, ""},
-		{"FlagLazyInit", Const, 10, ""},
-		{"FlagNoFixPrebinding", Const, 10, ""},
-		{"FlagNoHeapExecution", Const, 10, ""},
-		{"FlagNoMultiDefs", Const, 10, ""},
-		{"FlagNoReexportedDylibs", Const, 10, ""},
-		{"FlagNoUndefs", Const, 10, ""},
-		{"FlagPIE", Const, 10, ""},
-		{"FlagPrebindable", Const, 10, ""},
-		{"FlagPrebound", Const, 10, ""},
-		{"FlagRootSafe", Const, 10, ""},
-		{"FlagSetuidSafe", Const, 10, ""},
-		{"FlagSplitSegs", Const, 10, ""},
-		{"FlagSubsectionsViaSymbols", Const, 10, ""},
-		{"FlagTwoLevel", Const, 10, ""},
-		{"FlagWeakDefines", Const, 10, ""},
-		{"FormatError", Type, 0, ""},
-		{"GENERIC_RELOC_LOCAL_SECTDIFF", Const, 10, ""},
-		{"GENERIC_RELOC_PAIR", Const, 10, ""},
-		{"GENERIC_RELOC_PB_LA_PTR", Const, 10, ""},
-		{"GENERIC_RELOC_SECTDIFF", Const, 10, ""},
-		{"GENERIC_RELOC_TLV", Const, 10, ""},
-		{"GENERIC_RELOC_VANILLA", Const, 10, ""},
-		{"Load", Type, 0, ""},
-		{"LoadBytes", Type, 0, ""},
-		{"LoadCmd", Type, 0, ""},
-		{"LoadCmdDylib", Const, 0, ""},
-		{"LoadCmdDylinker", Const, 0, ""},
-		{"LoadCmdDysymtab", Const, 0, ""},
-		{"LoadCmdRpath", Const, 10, ""},
-		{"LoadCmdSegment", Const, 0, ""},
-		{"LoadCmdSegment64", Const, 0, ""},
-		{"LoadCmdSymtab", Const, 0, ""},
-		{"LoadCmdThread", Const, 0, ""},
-		{"LoadCmdUnixThread", Const, 0, ""},
-		{"Magic32", Const, 0, ""},
-		{"Magic64", Const, 0, ""},
-		{"MagicFat", Const, 3, ""},
-		{"NewFatFile", Func, 3, "func(r io.ReaderAt) (*FatFile, error)"},
-		{"NewFile", Func, 0, "func(r io.ReaderAt) (*File, error)"},
-		{"Nlist32", Type, 0, ""},
-		{"Nlist32.Desc", Field, 0, ""},
-		{"Nlist32.Name", Field, 0, ""},
-		{"Nlist32.Sect", Field, 0, ""},
-		{"Nlist32.Type", Field, 0, ""},
-		{"Nlist32.Value", Field, 0, ""},
-		{"Nlist64", Type, 0, ""},
-		{"Nlist64.Desc", Field, 0, ""},
-		{"Nlist64.Name", Field, 0, ""},
-		{"Nlist64.Sect", Field, 0, ""},
-		{"Nlist64.Type", Field, 0, ""},
-		{"Nlist64.Value", Field, 0, ""},
-		{"Open", Func, 0, "func(name string) (*File, error)"},
-		{"OpenFat", Func, 3, "func(name string) (*FatFile, error)"},
-		{"Regs386", Type, 0, ""},
-		{"Regs386.AX", Field, 0, ""},
-		{"Regs386.BP", Field, 0, ""},
-		{"Regs386.BX", Field, 0, ""},
-		{"Regs386.CS", Field, 0, ""},
-		{"Regs386.CX", Field, 0, ""},
-		{"Regs386.DI", Field, 0, ""},
-		{"Regs386.DS", Field, 0, ""},
-		{"Regs386.DX", Field, 0, ""},
-		{"Regs386.ES", Field, 0, ""},
-		{"Regs386.FLAGS", Field, 0, ""},
-		{"Regs386.FS", Field, 0, ""},
-		{"Regs386.GS", Field, 0, ""},
-		{"Regs386.IP", Field, 0, ""},
-		{"Regs386.SI", Field, 0, ""},
-		{"Regs386.SP", Field, 0, ""},
-		{"Regs386.SS", Field, 0, ""},
-		{"RegsAMD64", Type, 0, ""},
-		{"RegsAMD64.AX", Field, 0, ""},
-		{"RegsAMD64.BP", Field, 0, ""},
-		{"RegsAMD64.BX", Field, 0, ""},
-		{"RegsAMD64.CS", Field, 0, ""},
-		{"RegsAMD64.CX", Field, 0, ""},
-		{"RegsAMD64.DI", Field, 0, ""},
-		{"RegsAMD64.DX", Field, 0, ""},
-		{"RegsAMD64.FLAGS", Field, 0, ""},
-		{"RegsAMD64.FS", Field, 0, ""},
-		{"RegsAMD64.GS", Field, 0, ""},
-		{"RegsAMD64.IP", Field, 0, ""},
-		{"RegsAMD64.R10", Field, 0, ""},
-		{"RegsAMD64.R11", Field, 0, ""},
-		{"RegsAMD64.R12", Field, 0, ""},
-		{"RegsAMD64.R13", Field, 0, ""},
-		{"RegsAMD64.R14", Field, 0, ""},
-		{"RegsAMD64.R15", Field, 0, ""},
-		{"RegsAMD64.R8", Field, 0, ""},
-		{"RegsAMD64.R9", Field, 0, ""},
-		{"RegsAMD64.SI", Field, 0, ""},
-		{"RegsAMD64.SP", Field, 0, ""},
-		{"Reloc", Type, 10, ""},
-		{"Reloc.Addr", Field, 10, ""},
-		{"Reloc.Extern", Field, 10, ""},
-		{"Reloc.Len", Field, 10, ""},
-		{"Reloc.Pcrel", Field, 10, ""},
-		{"Reloc.Scattered", Field, 10, ""},
-		{"Reloc.Type", Field, 10, ""},
-		{"Reloc.Value", Field, 10, ""},
-		{"RelocTypeARM", Type, 10, ""},
-		{"RelocTypeARM64", Type, 10, ""},
-		{"RelocTypeGeneric", Type, 10, ""},
-		{"RelocTypeX86_64", Type, 10, ""},
-		{"Rpath", Type, 10, ""},
-		{"Rpath.LoadBytes", Field, 10, ""},
-		{"Rpath.Path", Field, 10, ""},
-		{"RpathCmd", Type, 10, ""},
-		{"RpathCmd.Cmd", Field, 10, ""},
-		{"RpathCmd.Len", Field, 10, ""},
-		{"RpathCmd.Path", Field, 10, ""},
-		{"Section", Type, 0, ""},
-		{"Section.ReaderAt", Field, 0, ""},
-		{"Section.Relocs", Field, 10, ""},
-		{"Section.SectionHeader", Field, 0, ""},
-		{"Section32", Type, 0, ""},
-		{"Section32.Addr", Field, 0, ""},
-		{"Section32.Align", Field, 0, ""},
-		{"Section32.Flags", Field, 0, ""},
-		{"Section32.Name", Field, 0, ""},
-		{"Section32.Nreloc", Field, 0, ""},
-		{"Section32.Offset", Field, 0, ""},
-		{"Section32.Reloff", Field, 0, ""},
-		{"Section32.Reserve1", Field, 0, ""},
-		{"Section32.Reserve2", Field, 0, ""},
-		{"Section32.Seg", Field, 0, ""},
-		{"Section32.Size", Field, 0, ""},
-		{"Section64", Type, 0, ""},
-		{"Section64.Addr", Field, 0, ""},
-		{"Section64.Align", Field, 0, ""},
-		{"Section64.Flags", Field, 0, ""},
-		{"Section64.Name", Field, 0, ""},
-		{"Section64.Nreloc", Field, 0, ""},
-		{"Section64.Offset", Field, 0, ""},
-		{"Section64.Reloff", Field, 0, ""},
-		{"Section64.Reserve1", Field, 0, ""},
-		{"Section64.Reserve2", Field, 0, ""},
-		{"Section64.Reserve3", Field, 0, ""},
-		{"Section64.Seg", Field, 0, ""},
-		{"Section64.Size", Field, 0, ""},
-		{"SectionHeader", Type, 0, ""},
-		{"SectionHeader.Addr", Field, 0, ""},
-		{"SectionHeader.Align", Field, 0, ""},
-		{"SectionHeader.Flags", Field, 0, ""},
-		{"SectionHeader.Name", Field, 0, ""},
-		{"SectionHeader.Nreloc", Field, 0, ""},
-		{"SectionHeader.Offset", Field, 0, ""},
-		{"SectionHeader.Reloff", Field, 0, ""},
-		{"SectionHeader.Seg", Field, 0, ""},
-		{"SectionHeader.Size", Field, 0, ""},
-		{"Segment", Type, 0, ""},
-		{"Segment.LoadBytes", Field, 0, ""},
-		{"Segment.ReaderAt", Field, 0, ""},
-		{"Segment.SegmentHeader", Field, 0, ""},
-		{"Segment32", Type, 0, ""},
-		{"Segment32.Addr", Field, 0, ""},
-		{"Segment32.Cmd", Field, 0, ""},
-		{"Segment32.Filesz", Field, 0, ""},
-		{"Segment32.Flag", Field, 0, ""},
-		{"Segment32.Len", Field, 0, ""},
-		{"Segment32.Maxprot", Field, 0, ""},
-		{"Segment32.Memsz", Field, 0, ""},
-		{"Segment32.Name", Field, 0, ""},
-		{"Segment32.Nsect", Field, 0, ""},
-		{"Segment32.Offset", Field, 0, ""},
-		{"Segment32.Prot", Field, 0, ""},
-		{"Segment64", Type, 0, ""},
-		{"Segment64.Addr", Field, 0, ""},
-		{"Segment64.Cmd", Field, 0, ""},
-		{"Segment64.Filesz", Field, 0, ""},
-		{"Segment64.Flag", Field, 0, ""},
-		{"Segment64.Len", Field, 0, ""},
-		{"Segment64.Maxprot", Field, 0, ""},
-		{"Segment64.Memsz", Field, 0, ""},
-		{"Segment64.Name", Field, 0, ""},
-		{"Segment64.Nsect", Field, 0, ""},
-		{"Segment64.Offset", Field, 0, ""},
-		{"Segment64.Prot", Field, 0, ""},
-		{"SegmentHeader", Type, 0, ""},
-		{"SegmentHeader.Addr", Field, 0, ""},
-		{"SegmentHeader.Cmd", Field, 0, ""},
-		{"SegmentHeader.Filesz", Field, 0, ""},
-		{"SegmentHeader.Flag", Field, 0, ""},
-		{"SegmentHeader.Len", Field, 0, ""},
-		{"SegmentHeader.Maxprot", Field, 0, ""},
-		{"SegmentHeader.Memsz", Field, 0, ""},
-		{"SegmentHeader.Name", Field, 0, ""},
-		{"SegmentHeader.Nsect", Field, 0, ""},
-		{"SegmentHeader.Offset", Field, 0, ""},
-		{"SegmentHeader.Prot", Field, 0, ""},
-		{"Symbol", Type, 0, ""},
-		{"Symbol.Desc", Field, 0, ""},
-		{"Symbol.Name", Field, 0, ""},
-		{"Symbol.Sect", Field, 0, ""},
-		{"Symbol.Type", Field, 0, ""},
-		{"Symbol.Value", Field, 0, ""},
-		{"Symtab", Type, 0, ""},
-		{"Symtab.LoadBytes", Field, 0, ""},
-		{"Symtab.Syms", Field, 0, ""},
-		{"Symtab.SymtabCmd", Field, 0, ""},
-		{"SymtabCmd", Type, 0, ""},
-		{"SymtabCmd.Cmd", Field, 0, ""},
-		{"SymtabCmd.Len", Field, 0, ""},
-		{"SymtabCmd.Nsyms", Field, 0, ""},
-		{"SymtabCmd.Stroff", Field, 0, ""},
-		{"SymtabCmd.Strsize", Field, 0, ""},
-		{"SymtabCmd.Symoff", Field, 0, ""},
-		{"Thread", Type, 0, ""},
-		{"Thread.Cmd", Field, 0, ""},
-		{"Thread.Data", Field, 0, ""},
-		{"Thread.Len", Field, 0, ""},
-		{"Thread.Type", Field, 0, ""},
-		{"Type", Type, 0, ""},
-		{"TypeBundle", Const, 3, ""},
-		{"TypeDylib", Const, 3, ""},
-		{"TypeExec", Const, 0, ""},
-		{"TypeObj", Const, 0, ""},
-		{"X86_64_RELOC_BRANCH", Const, 10, ""},
-		{"X86_64_RELOC_GOT", Const, 10, ""},
-		{"X86_64_RELOC_GOT_LOAD", Const, 10, ""},
-		{"X86_64_RELOC_SIGNED", Const, 10, ""},
-		{"X86_64_RELOC_SIGNED_1", Const, 10, ""},
-		{"X86_64_RELOC_SIGNED_2", Const, 10, ""},
-		{"X86_64_RELOC_SIGNED_4", Const, 10, ""},
-		{"X86_64_RELOC_SUBTRACTOR", Const, 10, ""},
-		{"X86_64_RELOC_TLV", Const, 10, ""},
-		{"X86_64_RELOC_UNSIGNED", Const, 10, ""},
-	},
-	"debug/pe": {
-		{"(*COFFSymbol).FullName", Method, 8, ""},
-		{"(*File).COFFSymbolReadSectionDefAux", Method, 19, ""},
-		{"(*File).Close", Method, 0, ""},
-		{"(*File).DWARF", Method, 0, ""},
-		{"(*File).ImportedLibraries", Method, 0, ""},
-		{"(*File).ImportedSymbols", Method, 0, ""},
-		{"(*File).Section", Method, 0, ""},
-		{"(*FormatError).Error", Method, 0, ""},
-		{"(*Section).Data", Method, 0, ""},
-		{"(*Section).Open", Method, 0, ""},
-		{"(Section).ReadAt", Method, 0, ""},
-		{"(StringTable).String", Method, 8, ""},
-		{"COFFSymbol", Type, 1, ""},
-		{"COFFSymbol.Name", Field, 1, ""},
-		{"COFFSymbol.NumberOfAuxSymbols", Field, 1, ""},
-		{"COFFSymbol.SectionNumber", Field, 1, ""},
-		{"COFFSymbol.StorageClass", Field, 1, ""},
-		{"COFFSymbol.Type", Field, 1, ""},
-		{"COFFSymbol.Value", Field, 1, ""},
-		{"COFFSymbolAuxFormat5", Type, 19, ""},
-		{"COFFSymbolAuxFormat5.Checksum", Field, 19, ""},
-		{"COFFSymbolAuxFormat5.NumLineNumbers", Field, 19, ""},
-		{"COFFSymbolAuxFormat5.NumRelocs", Field, 19, ""},
-		{"COFFSymbolAuxFormat5.SecNum", Field, 19, ""},
-		{"COFFSymbolAuxFormat5.Selection", Field, 19, ""},
-		{"COFFSymbolAuxFormat5.Size", Field, 19, ""},
-		{"COFFSymbolSize", Const, 1, ""},
-		{"DataDirectory", Type, 3, ""},
-		{"DataDirectory.Size", Field, 3, ""},
-		{"DataDirectory.VirtualAddress", Field, 3, ""},
-		{"File", Type, 0, ""},
-		{"File.COFFSymbols", Field, 8, ""},
-		{"File.FileHeader", Field, 0, ""},
-		{"File.OptionalHeader", Field, 3, ""},
-		{"File.Sections", Field, 0, ""},
-		{"File.StringTable", Field, 8, ""},
-		{"File.Symbols", Field, 1, ""},
-		{"FileHeader", Type, 0, ""},
-		{"FileHeader.Characteristics", Field, 0, ""},
-		{"FileHeader.Machine", Field, 0, ""},
-		{"FileHeader.NumberOfSections", Field, 0, ""},
-		{"FileHeader.NumberOfSymbols", Field, 0, ""},
-		{"FileHeader.PointerToSymbolTable", Field, 0, ""},
-		{"FileHeader.SizeOfOptionalHeader", Field, 0, ""},
-		{"FileHeader.TimeDateStamp", Field, 0, ""},
-		{"FormatError", Type, 0, ""},
-		{"IMAGE_COMDAT_SELECT_ANY", Const, 19, ""},
-		{"IMAGE_COMDAT_SELECT_ASSOCIATIVE", Const, 19, ""},
-		{"IMAGE_COMDAT_SELECT_EXACT_MATCH", Const, 19, ""},
-		{"IMAGE_COMDAT_SELECT_LARGEST", Const, 19, ""},
-		{"IMAGE_COMDAT_SELECT_NODUPLICATES", Const, 19, ""},
-		{"IMAGE_COMDAT_SELECT_SAME_SIZE", Const, 19, ""},
-		{"IMAGE_DIRECTORY_ENTRY_ARCHITECTURE", Const, 11, ""},
-		{"IMAGE_DIRECTORY_ENTRY_BASERELOC", Const, 11, ""},
-		{"IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT", Const, 11, ""},
-		{"IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR", Const, 11, ""},
-		{"IMAGE_DIRECTORY_ENTRY_DEBUG", Const, 11, ""},
-		{"IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT", Const, 11, ""},
-		{"IMAGE_DIRECTORY_ENTRY_EXCEPTION", Const, 11, ""},
-		{"IMAGE_DIRECTORY_ENTRY_EXPORT", Const, 11, ""},
-		{"IMAGE_DIRECTORY_ENTRY_GLOBALPTR", Const, 11, ""},
-		{"IMAGE_DIRECTORY_ENTRY_IAT", Const, 11, ""},
-		{"IMAGE_DIRECTORY_ENTRY_IMPORT", Const, 11, ""},
-		{"IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG", Const, 11, ""},
-		{"IMAGE_DIRECTORY_ENTRY_RESOURCE", Const, 11, ""},
-		{"IMAGE_DIRECTORY_ENTRY_SECURITY", Const, 11, ""},
-		{"IMAGE_DIRECTORY_ENTRY_TLS", Const, 11, ""},
-		{"IMAGE_DLLCHARACTERISTICS_APPCONTAINER", Const, 15, ""},
-		{"IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE", Const, 15, ""},
-		{"IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY", Const, 15, ""},
-		{"IMAGE_DLLCHARACTERISTICS_GUARD_CF", Const, 15, ""},
-		{"IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA", Const, 15, ""},
-		{"IMAGE_DLLCHARACTERISTICS_NO_BIND", Const, 15, ""},
-		{"IMAGE_DLLCHARACTERISTICS_NO_ISOLATION", Const, 15, ""},
-		{"IMAGE_DLLCHARACTERISTICS_NO_SEH", Const, 15, ""},
-		{"IMAGE_DLLCHARACTERISTICS_NX_COMPAT", Const, 15, ""},
-		{"IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE", Const, 15, ""},
-		{"IMAGE_DLLCHARACTERISTICS_WDM_DRIVER", Const, 15, ""},
-		{"IMAGE_FILE_32BIT_MACHINE", Const, 15, ""},
-		{"IMAGE_FILE_AGGRESIVE_WS_TRIM", Const, 15, ""},
-		{"IMAGE_FILE_BYTES_REVERSED_HI", Const, 15, ""},
-		{"IMAGE_FILE_BYTES_REVERSED_LO", Const, 15, ""},
-		{"IMAGE_FILE_DEBUG_STRIPPED", Const, 15, ""},
-		{"IMAGE_FILE_DLL", Const, 15, ""},
-		{"IMAGE_FILE_EXECUTABLE_IMAGE", Const, 15, ""},
-		{"IMAGE_FILE_LARGE_ADDRESS_AWARE", Const, 15, ""},
-		{"IMAGE_FILE_LINE_NUMS_STRIPPED", Const, 15, ""},
-		{"IMAGE_FILE_LOCAL_SYMS_STRIPPED", Const, 15, ""},
-		{"IMAGE_FILE_MACHINE_AM33", Const, 0, ""},
-		{"IMAGE_FILE_MACHINE_AMD64", Const, 0, ""},
-		{"IMAGE_FILE_MACHINE_ARM", Const, 0, ""},
-		{"IMAGE_FILE_MACHINE_ARM64", Const, 11, ""},
-		{"IMAGE_FILE_MACHINE_ARMNT", Const, 12, ""},
-		{"IMAGE_FILE_MACHINE_EBC", Const, 0, ""},
-		{"IMAGE_FILE_MACHINE_I386", Const, 0, ""},
-		{"IMAGE_FILE_MACHINE_IA64", Const, 0, ""},
-		{"IMAGE_FILE_MACHINE_LOONGARCH32", Const, 19, ""},
-		{"IMAGE_FILE_MACHINE_LOONGARCH64", Const, 19, ""},
-		{"IMAGE_FILE_MACHINE_M32R", Const, 0, ""},
-		{"IMAGE_FILE_MACHINE_MIPS16", Const, 0, ""},
-		{"IMAGE_FILE_MACHINE_MIPSFPU", Const, 0, ""},
-		{"IMAGE_FILE_MACHINE_MIPSFPU16", Const, 0, ""},
-		{"IMAGE_FILE_MACHINE_POWERPC", Const, 0, ""},
-		{"IMAGE_FILE_MACHINE_POWERPCFP", Const, 0, ""},
-		{"IMAGE_FILE_MACHINE_R4000", Const, 0, ""},
-		{"IMAGE_FILE_MACHINE_RISCV128", Const, 20, ""},
-		{"IMAGE_FILE_MACHINE_RISCV32", Const, 20, ""},
-		{"IMAGE_FILE_MACHINE_RISCV64", Const, 20, ""},
-		{"IMAGE_FILE_MACHINE_SH3", Const, 0, ""},
-		{"IMAGE_FILE_MACHINE_SH3DSP", Const, 0, ""},
-		{"IMAGE_FILE_MACHINE_SH4", Const, 0, ""},
-		{"IMAGE_FILE_MACHINE_SH5", Const, 0, ""},
-		{"IMAGE_FILE_MACHINE_THUMB", Const, 0, ""},
-		{"IMAGE_FILE_MACHINE_UNKNOWN", Const, 0, ""},
-		{"IMAGE_FILE_MACHINE_WCEMIPSV2", Const, 0, ""},
-		{"IMAGE_FILE_NET_RUN_FROM_SWAP", Const, 15, ""},
-		{"IMAGE_FILE_RELOCS_STRIPPED", Const, 15, ""},
-		{"IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP", Const, 15, ""},
-		{"IMAGE_FILE_SYSTEM", Const, 15, ""},
-		{"IMAGE_FILE_UP_SYSTEM_ONLY", Const, 15, ""},
-		{"IMAGE_SCN_CNT_CODE", Const, 19, ""},
-		{"IMAGE_SCN_CNT_INITIALIZED_DATA", Const, 19, ""},
-		{"IMAGE_SCN_CNT_UNINITIALIZED_DATA", Const, 19, ""},
-		{"IMAGE_SCN_LNK_COMDAT", Const, 19, ""},
-		{"IMAGE_SCN_MEM_DISCARDABLE", Const, 19, ""},
-		{"IMAGE_SCN_MEM_EXECUTE", Const, 19, ""},
-		{"IMAGE_SCN_MEM_READ", Const, 19, ""},
-		{"IMAGE_SCN_MEM_WRITE", Const, 19, ""},
-		{"IMAGE_SUBSYSTEM_EFI_APPLICATION", Const, 15, ""},
-		{"IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER", Const, 15, ""},
-		{"IMAGE_SUBSYSTEM_EFI_ROM", Const, 15, ""},
-		{"IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER", Const, 15, ""},
-		{"IMAGE_SUBSYSTEM_NATIVE", Const, 15, ""},
-		{"IMAGE_SUBSYSTEM_NATIVE_WINDOWS", Const, 15, ""},
-		{"IMAGE_SUBSYSTEM_OS2_CUI", Const, 15, ""},
-		{"IMAGE_SUBSYSTEM_POSIX_CUI", Const, 15, ""},
-		{"IMAGE_SUBSYSTEM_UNKNOWN", Const, 15, ""},
-		{"IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION", Const, 15, ""},
-		{"IMAGE_SUBSYSTEM_WINDOWS_CE_GUI", Const, 15, ""},
-		{"IMAGE_SUBSYSTEM_WINDOWS_CUI", Const, 15, ""},
-		{"IMAGE_SUBSYSTEM_WINDOWS_GUI", Const, 15, ""},
-		{"IMAGE_SUBSYSTEM_XBOX", Const, 15, ""},
-		{"ImportDirectory", Type, 0, ""},
-		{"ImportDirectory.FirstThunk", Field, 0, ""},
-		{"ImportDirectory.ForwarderChain", Field, 0, ""},
-		{"ImportDirectory.Name", Field, 0, ""},
-		{"ImportDirectory.OriginalFirstThunk", Field, 0, ""},
-		{"ImportDirectory.TimeDateStamp", Field, 0, ""},
-		{"NewFile", Func, 0, "func(r io.ReaderAt) (*File, error)"},
-		{"Open", Func, 0, "func(name string) (*File, error)"},
-		{"OptionalHeader32", Type, 3, ""},
-		{"OptionalHeader32.AddressOfEntryPoint", Field, 3, ""},
-		{"OptionalHeader32.BaseOfCode", Field, 3, ""},
-		{"OptionalHeader32.BaseOfData", Field, 3, ""},
-		{"OptionalHeader32.CheckSum", Field, 3, ""},
-		{"OptionalHeader32.DataDirectory", Field, 3, ""},
-		{"OptionalHeader32.DllCharacteristics", Field, 3, ""},
-		{"OptionalHeader32.FileAlignment", Field, 3, ""},
-		{"OptionalHeader32.ImageBase", Field, 3, ""},
-		{"OptionalHeader32.LoaderFlags", Field, 3, ""},
-		{"OptionalHeader32.Magic", Field, 3, ""},
-		{"OptionalHeader32.MajorImageVersion", Field, 3, ""},
-		{"OptionalHeader32.MajorLinkerVersion", Field, 3, ""},
-		{"OptionalHeader32.MajorOperatingSystemVersion", Field, 3, ""},
-		{"OptionalHeader32.MajorSubsystemVersion", Field, 3, ""},
-		{"OptionalHeader32.MinorImageVersion", Field, 3, ""},
-		{"OptionalHeader32.MinorLinkerVersion", Field, 3, ""},
-		{"OptionalHeader32.MinorOperatingSystemVersion", Field, 3, ""},
-		{"OptionalHeader32.MinorSubsystemVersion", Field, 3, ""},
-		{"OptionalHeader32.NumberOfRvaAndSizes", Field, 3, ""},
-		{"OptionalHeader32.SectionAlignment", Field, 3, ""},
-		{"OptionalHeader32.SizeOfCode", Field, 3, ""},
-		{"OptionalHeader32.SizeOfHeaders", Field, 3, ""},
-		{"OptionalHeader32.SizeOfHeapCommit", Field, 3, ""},
-		{"OptionalHeader32.SizeOfHeapReserve", Field, 3, ""},
-		{"OptionalHeader32.SizeOfImage", Field, 3, ""},
-		{"OptionalHeader32.SizeOfInitializedData", Field, 3, ""},
-		{"OptionalHeader32.SizeOfStackCommit", Field, 3, ""},
-		{"OptionalHeader32.SizeOfStackReserve", Field, 3, ""},
-		{"OptionalHeader32.SizeOfUninitializedData", Field, 3, ""},
-		{"OptionalHeader32.Subsystem", Field, 3, ""},
-		{"OptionalHeader32.Win32VersionValue", Field, 3, ""},
-		{"OptionalHeader64", Type, 3, ""},
-		{"OptionalHeader64.AddressOfEntryPoint", Field, 3, ""},
-		{"OptionalHeader64.BaseOfCode", Field, 3, ""},
-		{"OptionalHeader64.CheckSum", Field, 3, ""},
-		{"OptionalHeader64.DataDirectory", Field, 3, ""},
-		{"OptionalHeader64.DllCharacteristics", Field, 3, ""},
-		{"OptionalHeader64.FileAlignment", Field, 3, ""},
-		{"OptionalHeader64.ImageBase", Field, 3, ""},
-		{"OptionalHeader64.LoaderFlags", Field, 3, ""},
-		{"OptionalHeader64.Magic", Field, 3, ""},
-		{"OptionalHeader64.MajorImageVersion", Field, 3, ""},
-		{"OptionalHeader64.MajorLinkerVersion", Field, 3, ""},
-		{"OptionalHeader64.MajorOperatingSystemVersion", Field, 3, ""},
-		{"OptionalHeader64.MajorSubsystemVersion", Field, 3, ""},
-		{"OptionalHeader64.MinorImageVersion", Field, 3, ""},
-		{"OptionalHeader64.MinorLinkerVersion", Field, 3, ""},
-		{"OptionalHeader64.MinorOperatingSystemVersion", Field, 3, ""},
-		{"OptionalHeader64.MinorSubsystemVersion", Field, 3, ""},
-		{"OptionalHeader64.NumberOfRvaAndSizes", Field, 3, ""},
-		{"OptionalHeader64.SectionAlignment", Field, 3, ""},
-		{"OptionalHeader64.SizeOfCode", Field, 3, ""},
-		{"OptionalHeader64.SizeOfHeaders", Field, 3, ""},
-		{"OptionalHeader64.SizeOfHeapCommit", Field, 3, ""},
-		{"OptionalHeader64.SizeOfHeapReserve", Field, 3, ""},
-		{"OptionalHeader64.SizeOfImage", Field, 3, ""},
-		{"OptionalHeader64.SizeOfInitializedData", Field, 3, ""},
-		{"OptionalHeader64.SizeOfStackCommit", Field, 3, ""},
-		{"OptionalHeader64.SizeOfStackReserve", Field, 3, ""},
-		{"OptionalHeader64.SizeOfUninitializedData", Field, 3, ""},
-		{"OptionalHeader64.Subsystem", Field, 3, ""},
-		{"OptionalHeader64.Win32VersionValue", Field, 3, ""},
-		{"Reloc", Type, 8, ""},
-		{"Reloc.SymbolTableIndex", Field, 8, ""},
-		{"Reloc.Type", Field, 8, ""},
-		{"Reloc.VirtualAddress", Field, 8, ""},
-		{"Section", Type, 0, ""},
-		{"Section.ReaderAt", Field, 0, ""},
-		{"Section.Relocs", Field, 8, ""},
-		{"Section.SectionHeader", Field, 0, ""},
-		{"SectionHeader", Type, 0, ""},
-		{"SectionHeader.Characteristics", Field, 0, ""},
-		{"SectionHeader.Name", Field, 0, ""},
-		{"SectionHeader.NumberOfLineNumbers", Field, 0, ""},
-		{"SectionHeader.NumberOfRelocations", Field, 0, ""},
-		{"SectionHeader.Offset", Field, 0, ""},
-		{"SectionHeader.PointerToLineNumbers", Field, 0, ""},
-		{"SectionHeader.PointerToRelocations", Field, 0, ""},
-		{"SectionHeader.Size", Field, 0, ""},
-		{"SectionHeader.VirtualAddress", Field, 0, ""},
-		{"SectionHeader.VirtualSize", Field, 0, ""},
-		{"SectionHeader32", Type, 0, ""},
-		{"SectionHeader32.Characteristics", Field, 0, ""},
-		{"SectionHeader32.Name", Field, 0, ""},
-		{"SectionHeader32.NumberOfLineNumbers", Field, 0, ""},
-		{"SectionHeader32.NumberOfRelocations", Field, 0, ""},
-		{"SectionHeader32.PointerToLineNumbers", Field, 0, ""},
-		{"SectionHeader32.PointerToRawData", Field, 0, ""},
-		{"SectionHeader32.PointerToRelocations", Field, 0, ""},
-		{"SectionHeader32.SizeOfRawData", Field, 0, ""},
-		{"SectionHeader32.VirtualAddress", Field, 0, ""},
-		{"SectionHeader32.VirtualSize", Field, 0, ""},
-		{"StringTable", Type, 8, ""},
-		{"Symbol", Type, 1, ""},
-		{"Symbol.Name", Field, 1, ""},
-		{"Symbol.SectionNumber", Field, 1, ""},
-		{"Symbol.StorageClass", Field, 1, ""},
-		{"Symbol.Type", Field, 1, ""},
-		{"Symbol.Value", Field, 1, ""},
-	},
-	"debug/plan9obj": {
-		{"(*File).Close", Method, 3, ""},
-		{"(*File).Section", Method, 3, ""},
-		{"(*File).Symbols", Method, 3, ""},
-		{"(*Section).Data", Method, 3, ""},
-		{"(*Section).Open", Method, 3, ""},
-		{"(Section).ReadAt", Method, 3, ""},
-		{"ErrNoSymbols", Var, 18, ""},
-		{"File", Type, 3, ""},
-		{"File.FileHeader", Field, 3, ""},
-		{"File.Sections", Field, 3, ""},
-		{"FileHeader", Type, 3, ""},
-		{"FileHeader.Bss", Field, 3, ""},
-		{"FileHeader.Entry", Field, 3, ""},
-		{"FileHeader.HdrSize", Field, 4, ""},
-		{"FileHeader.LoadAddress", Field, 4, ""},
-		{"FileHeader.Magic", Field, 3, ""},
-		{"FileHeader.PtrSize", Field, 3, ""},
-		{"Magic386", Const, 3, ""},
-		{"Magic64", Const, 3, ""},
-		{"MagicAMD64", Const, 3, ""},
-		{"MagicARM", Const, 3, ""},
-		{"NewFile", Func, 3, "func(r io.ReaderAt) (*File, error)"},
-		{"Open", Func, 3, "func(name string) (*File, error)"},
-		{"Section", Type, 3, ""},
-		{"Section.ReaderAt", Field, 3, ""},
-		{"Section.SectionHeader", Field, 3, ""},
-		{"SectionHeader", Type, 3, ""},
-		{"SectionHeader.Name", Field, 3, ""},
-		{"SectionHeader.Offset", Field, 3, ""},
-		{"SectionHeader.Size", Field, 3, ""},
-		{"Sym", Type, 3, ""},
-		{"Sym.Name", Field, 3, ""},
-		{"Sym.Type", Field, 3, ""},
-		{"Sym.Value", Field, 3, ""},
-	},
-	"embed": {
-		{"(FS).Open", Method, 16, ""},
-		{"(FS).ReadDir", Method, 16, ""},
-		{"(FS).ReadFile", Method, 16, ""},
-		{"FS", Type, 16, ""},
-	},
-	"encoding": {
-		{"(BinaryAppender).AppendBinary", Method, 24, ""},
-		{"(BinaryMarshaler).MarshalBinary", Method, 2, ""},
-		{"(BinaryUnmarshaler).UnmarshalBinary", Method, 2, ""},
-		{"(TextAppender).AppendText", Method, 24, ""},
-		{"(TextMarshaler).MarshalText", Method, 2, ""},
-		{"(TextUnmarshaler).UnmarshalText", Method, 2, ""},
-		{"BinaryAppender", Type, 24, ""},
-		{"BinaryMarshaler", Type, 2, ""},
-		{"BinaryUnmarshaler", Type, 2, ""},
-		{"TextAppender", Type, 24, ""},
-		{"TextMarshaler", Type, 2, ""},
-		{"TextUnmarshaler", Type, 2, ""},
-	},
-	"encoding/ascii85": {
-		{"(CorruptInputError).Error", Method, 0, ""},
-		{"CorruptInputError", Type, 0, ""},
-		{"Decode", Func, 0, "func(dst []byte, src []byte, flush bool) (ndst int, nsrc int, err error)"},
-		{"Encode", Func, 0, "func(dst []byte, src []byte) int"},
-		{"MaxEncodedLen", Func, 0, "func(n int) int"},
-		{"NewDecoder", Func, 0, "func(r io.Reader) io.Reader"},
-		{"NewEncoder", Func, 0, "func(w io.Writer) io.WriteCloser"},
-	},
-	"encoding/asn1": {
-		{"(BitString).At", Method, 0, ""},
-		{"(BitString).RightAlign", Method, 0, ""},
-		{"(ObjectIdentifier).Equal", Method, 0, ""},
-		{"(ObjectIdentifier).String", Method, 3, ""},
-		{"(StructuralError).Error", Method, 0, ""},
-		{"(SyntaxError).Error", Method, 0, ""},
-		{"BitString", Type, 0, ""},
-		{"BitString.BitLength", Field, 0, ""},
-		{"BitString.Bytes", Field, 0, ""},
-		{"ClassApplication", Const, 6, ""},
-		{"ClassContextSpecific", Const, 6, ""},
-		{"ClassPrivate", Const, 6, ""},
-		{"ClassUniversal", Const, 6, ""},
-		{"Enumerated", Type, 0, ""},
-		{"Flag", Type, 0, ""},
-		{"Marshal", Func, 0, "func(val any) ([]byte, error)"},
-		{"MarshalWithParams", Func, 10, "func(val any, params string) ([]byte, error)"},
-		{"NullBytes", Var, 9, ""},
-		{"NullRawValue", Var, 9, ""},
-		{"ObjectIdentifier", Type, 0, ""},
-		{"RawContent", Type, 0, ""},
-		{"RawValue", Type, 0, ""},
-		{"RawValue.Bytes", Field, 0, ""},
-		{"RawValue.Class", Field, 0, ""},
-		{"RawValue.FullBytes", Field, 0, ""},
-		{"RawValue.IsCompound", Field, 0, ""},
-		{"RawValue.Tag", Field, 0, ""},
-		{"StructuralError", Type, 0, ""},
-		{"StructuralError.Msg", Field, 0, ""},
-		{"SyntaxError", Type, 0, ""},
-		{"SyntaxError.Msg", Field, 0, ""},
-		{"TagBMPString", Const, 14, ""},
-		{"TagBitString", Const, 6, ""},
-		{"TagBoolean", Const, 6, ""},
-		{"TagEnum", Const, 6, ""},
-		{"TagGeneralString", Const, 6, ""},
-		{"TagGeneralizedTime", Const, 6, ""},
-		{"TagIA5String", Const, 6, ""},
-		{"TagInteger", Const, 6, ""},
-		{"TagNull", Const, 9, ""},
-		{"TagNumericString", Const, 10, ""},
-		{"TagOID", Const, 6, ""},
-		{"TagOctetString", Const, 6, ""},
-		{"TagPrintableString", Const, 6, ""},
-		{"TagSequence", Const, 6, ""},
-		{"TagSet", Const, 6, ""},
-		{"TagT61String", Const, 6, ""},
-		{"TagUTCTime", Const, 6, ""},
-		{"TagUTF8String", Const, 6, ""},
-		{"Unmarshal", Func, 0, "func(b []byte, val any) (rest []byte, err error)"},
-		{"UnmarshalWithParams", Func, 0, "func(b []byte, val any, params string) (rest []byte, err error)"},
-	},
-	"encoding/base32": {
-		{"(*Encoding).AppendDecode", Method, 22, ""},
-		{"(*Encoding).AppendEncode", Method, 22, ""},
-		{"(*Encoding).Decode", Method, 0, ""},
-		{"(*Encoding).DecodeString", Method, 0, ""},
-		{"(*Encoding).DecodedLen", Method, 0, ""},
-		{"(*Encoding).Encode", Method, 0, ""},
-		{"(*Encoding).EncodeToString", Method, 0, ""},
-		{"(*Encoding).EncodedLen", Method, 0, ""},
-		{"(CorruptInputError).Error", Method, 0, ""},
-		{"(Encoding).WithPadding", Method, 9, ""},
-		{"CorruptInputError", Type, 0, ""},
-		{"Encoding", Type, 0, ""},
-		{"HexEncoding", Var, 0, ""},
-		{"NewDecoder", Func, 0, "func(enc *Encoding, r io.Reader) io.Reader"},
-		{"NewEncoder", Func, 0, "func(enc *Encoding, w io.Writer) io.WriteCloser"},
-		{"NewEncoding", Func, 0, "func(encoder string) *Encoding"},
-		{"NoPadding", Const, 9, ""},
-		{"StdEncoding", Var, 0, ""},
-		{"StdPadding", Const, 9, ""},
-	},
-	"encoding/base64": {
-		{"(*Encoding).AppendDecode", Method, 22, ""},
-		{"(*Encoding).AppendEncode", Method, 22, ""},
-		{"(*Encoding).Decode", Method, 0, ""},
-		{"(*Encoding).DecodeString", Method, 0, ""},
-		{"(*Encoding).DecodedLen", Method, 0, ""},
-		{"(*Encoding).Encode", Method, 0, ""},
-		{"(*Encoding).EncodeToString", Method, 0, ""},
-		{"(*Encoding).EncodedLen", Method, 0, ""},
-		{"(CorruptInputError).Error", Method, 0, ""},
-		{"(Encoding).Strict", Method, 8, ""},
-		{"(Encoding).WithPadding", Method, 5, ""},
-		{"CorruptInputError", Type, 0, ""},
-		{"Encoding", Type, 0, ""},
-		{"NewDecoder", Func, 0, "func(enc *Encoding, r io.Reader) io.Reader"},
-		{"NewEncoder", Func, 0, "func(enc *Encoding, w io.Writer) io.WriteCloser"},
-		{"NewEncoding", Func, 0, "func(encoder string) *Encoding"},
-		{"NoPadding", Const, 5, ""},
-		{"RawStdEncoding", Var, 5, ""},
-		{"RawURLEncoding", Var, 5, ""},
-		{"StdEncoding", Var, 0, ""},
-		{"StdPadding", Const, 5, ""},
-		{"URLEncoding", Var, 0, ""},
-	},
-	"encoding/binary": {
-		{"(AppendByteOrder).AppendUint16", Method, 19, ""},
-		{"(AppendByteOrder).AppendUint32", Method, 19, ""},
-		{"(AppendByteOrder).AppendUint64", Method, 19, ""},
-		{"(AppendByteOrder).String", Method, 19, ""},
-		{"(ByteOrder).PutUint16", Method, 0, ""},
-		{"(ByteOrder).PutUint32", Method, 0, ""},
-		{"(ByteOrder).PutUint64", Method, 0, ""},
-		{"(ByteOrder).String", Method, 0, ""},
-		{"(ByteOrder).Uint16", Method, 0, ""},
-		{"(ByteOrder).Uint32", Method, 0, ""},
-		{"(ByteOrder).Uint64", Method, 0, ""},
-		{"Append", Func, 23, "func(buf []byte, order ByteOrder, data any) ([]byte, error)"},
-		{"AppendByteOrder", Type, 19, ""},
-		{"AppendUvarint", Func, 19, "func(buf []byte, x uint64) []byte"},
-		{"AppendVarint", Func, 19, "func(buf []byte, x int64) []byte"},
-		{"BigEndian", Var, 0, ""},
-		{"ByteOrder", Type, 0, ""},
-		{"Decode", Func, 23, "func(buf []byte, order ByteOrder, data any) (int, error)"},
-		{"Encode", Func, 23, "func(buf []byte, order ByteOrder, data any) (int, error)"},
-		{"LittleEndian", Var, 0, ""},
-		{"MaxVarintLen16", Const, 0, ""},
-		{"MaxVarintLen32", Const, 0, ""},
-		{"MaxVarintLen64", Const, 0, ""},
-		{"NativeEndian", Var, 21, ""},
-		{"PutUvarint", Func, 0, "func(buf []byte, x uint64) int"},
-		{"PutVarint", Func, 0, "func(buf []byte, x int64) int"},
-		{"Read", Func, 0, "func(r io.Reader, order ByteOrder, data any) error"},
-		{"ReadUvarint", Func, 0, "func(r io.ByteReader) (uint64, error)"},
-		{"ReadVarint", Func, 0, "func(r io.ByteReader) (int64, error)"},
-		{"Size", Func, 0, "func(v any) int"},
-		{"Uvarint", Func, 0, "func(buf []byte) (uint64, int)"},
-		{"Varint", Func, 0, "func(buf []byte) (int64, int)"},
-		{"Write", Func, 0, "func(w io.Writer, order ByteOrder, data any) error"},
-	},
-	"encoding/csv": {
-		{"(*ParseError).Error", Method, 0, ""},
-		{"(*ParseError).Unwrap", Method, 13, ""},
-		{"(*Reader).FieldPos", Method, 17, ""},
-		{"(*Reader).InputOffset", Method, 19, ""},
-		{"(*Reader).Read", Method, 0, ""},
-		{"(*Reader).ReadAll", Method, 0, ""},
-		{"(*Writer).Error", Method, 1, ""},
-		{"(*Writer).Flush", Method, 0, ""},
-		{"(*Writer).Write", Method, 0, ""},
-		{"(*Writer).WriteAll", Method, 0, ""},
-		{"ErrBareQuote", Var, 0, ""},
-		{"ErrFieldCount", Var, 0, ""},
-		{"ErrQuote", Var, 0, ""},
-		{"ErrTrailingComma", Var, 0, ""},
-		{"NewReader", Func, 0, "func(r io.Reader) *Reader"},
-		{"NewWriter", Func, 0, "func(w io.Writer) *Writer"},
-		{"ParseError", Type, 0, ""},
-		{"ParseError.Column", Field, 0, ""},
-		{"ParseError.Err", Field, 0, ""},
-		{"ParseError.Line", Field, 0, ""},
-		{"ParseError.StartLine", Field, 10, ""},
-		{"Reader", Type, 0, ""},
-		{"Reader.Comma", Field, 0, ""},
-		{"Reader.Comment", Field, 0, ""},
-		{"Reader.FieldsPerRecord", Field, 0, ""},
-		{"Reader.LazyQuotes", Field, 0, ""},
-		{"Reader.ReuseRecord", Field, 9, ""},
-		{"Reader.TrailingComma", Field, 0, ""},
-		{"Reader.TrimLeadingSpace", Field, 0, ""},
-		{"Writer", Type, 0, ""},
-		{"Writer.Comma", Field, 0, ""},
-		{"Writer.UseCRLF", Field, 0, ""},
-	},
-	"encoding/gob": {
-		{"(*Decoder).Decode", Method, 0, ""},
-		{"(*Decoder).DecodeValue", Method, 0, ""},
-		{"(*Encoder).Encode", Method, 0, ""},
-		{"(*Encoder).EncodeValue", Method, 0, ""},
-		{"(GobDecoder).GobDecode", Method, 0, ""},
-		{"(GobEncoder).GobEncode", Method, 0, ""},
-		{"CommonType", Type, 0, ""},
-		{"CommonType.Id", Field, 0, ""},
-		{"CommonType.Name", Field, 0, ""},
-		{"Decoder", Type, 0, ""},
-		{"Encoder", Type, 0, ""},
-		{"GobDecoder", Type, 0, ""},
-		{"GobEncoder", Type, 0, ""},
-		{"NewDecoder", Func, 0, "func(r io.Reader) *Decoder"},
-		{"NewEncoder", Func, 0, "func(w io.Writer) *Encoder"},
-		{"Register", Func, 0, "func(value any)"},
-		{"RegisterName", Func, 0, "func(name string, value any)"},
-	},
-	"encoding/hex": {
-		{"(InvalidByteError).Error", Method, 0, ""},
-		{"AppendDecode", Func, 22, "func(dst []byte, src []byte) ([]byte, error)"},
-		{"AppendEncode", Func, 22, "func(dst []byte, src []byte) []byte"},
-		{"Decode", Func, 0, "func(dst []byte, src []byte) (int, error)"},
-		{"DecodeString", Func, 0, "func(s string) ([]byte, error)"},
-		{"DecodedLen", Func, 0, "func(x int) int"},
-		{"Dump", Func, 0, "func(data []byte) string"},
-		{"Dumper", Func, 0, "func(w io.Writer) io.WriteCloser"},
-		{"Encode", Func, 0, "func(dst []byte, src []byte) int"},
-		{"EncodeToString", Func, 0, "func(src []byte) string"},
-		{"EncodedLen", Func, 0, "func(n int) int"},
-		{"ErrLength", Var, 0, ""},
-		{"InvalidByteError", Type, 0, ""},
-		{"NewDecoder", Func, 10, "func(r io.Reader) io.Reader"},
-		{"NewEncoder", Func, 10, "func(w io.Writer) io.Writer"},
-	},
-	"encoding/json": {
-		{"(*Decoder).Buffered", Method, 1, ""},
-		{"(*Decoder).Decode", Method, 0, ""},
-		{"(*Decoder).DisallowUnknownFields", Method, 10, ""},
-		{"(*Decoder).InputOffset", Method, 14, ""},
-		{"(*Decoder).More", Method, 5, ""},
-		{"(*Decoder).Token", Method, 5, ""},
-		{"(*Decoder).UseNumber", Method, 1, ""},
-		{"(*Encoder).Encode", Method, 0, ""},
-		{"(*Encoder).SetEscapeHTML", Method, 7, ""},
-		{"(*Encoder).SetIndent", Method, 7, ""},
-		{"(*InvalidUTF8Error).Error", Method, 0, ""},
-		{"(*InvalidUnmarshalError).Error", Method, 0, ""},
-		{"(*MarshalerError).Error", Method, 0, ""},
-		{"(*MarshalerError).Unwrap", Method, 13, ""},
-		{"(*RawMessage).MarshalJSON", Method, 0, ""},
-		{"(*RawMessage).UnmarshalJSON", Method, 0, ""},
-		{"(*SyntaxError).Error", Method, 0, ""},
-		{"(*UnmarshalFieldError).Error", Method, 0, ""},
-		{"(*UnmarshalTypeError).Error", Method, 0, ""},
-		{"(*UnsupportedTypeError).Error", Method, 0, ""},
-		{"(*UnsupportedValueError).Error", Method, 0, ""},
-		{"(Delim).String", Method, 5, ""},
-		{"(Marshaler).MarshalJSON", Method, 0, ""},
-		{"(Number).Float64", Method, 1, ""},
-		{"(Number).Int64", Method, 1, ""},
-		{"(Number).String", Method, 1, ""},
-		{"(RawMessage).MarshalJSON", Method, 8, ""},
-		{"(Unmarshaler).UnmarshalJSON", Method, 0, ""},
-		{"Compact", Func, 0, "func(dst *bytes.Buffer, src []byte) error"},
-		{"Decoder", Type, 0, ""},
-		{"Delim", Type, 5, ""},
-		{"Encoder", Type, 0, ""},
-		{"HTMLEscape", Func, 0, "func(dst *bytes.Buffer, src []byte)"},
-		{"Indent", Func, 0, "func(dst *bytes.Buffer, src []byte, prefix string, indent string) error"},
-		{"InvalidUTF8Error", Type, 0, ""},
-		{"InvalidUTF8Error.S", Field, 0, ""},
-		{"InvalidUnmarshalError", Type, 0, ""},
-		{"InvalidUnmarshalError.Type", Field, 0, ""},
-		{"Marshal", Func, 0, "func(v any) ([]byte, error)"},
-		{"MarshalIndent", Func, 0, "func(v any, prefix string, indent string) ([]byte, error)"},
-		{"Marshaler", Type, 0, ""},
-		{"MarshalerError", Type, 0, ""},
-		{"MarshalerError.Err", Field, 0, ""},
-		{"MarshalerError.Type", Field, 0, ""},
-		{"NewDecoder", Func, 0, "func(r io.Reader) *Decoder"},
-		{"NewEncoder", Func, 0, "func(w io.Writer) *Encoder"},
-		{"Number", Type, 1, ""},
-		{"RawMessage", Type, 0, ""},
-		{"SyntaxError", Type, 0, ""},
-		{"SyntaxError.Offset", Field, 0, ""},
-		{"Token", Type, 5, ""},
-		{"Unmarshal", Func, 0, "func(data []byte, v any) error"},
-		{"UnmarshalFieldError", Type, 0, ""},
-		{"UnmarshalFieldError.Field", Field, 0, ""},
-		{"UnmarshalFieldError.Key", Field, 0, ""},
-		{"UnmarshalFieldError.Type", Field, 0, ""},
-		{"UnmarshalTypeError", Type, 0, ""},
-		{"UnmarshalTypeError.Field", Field, 8, ""},
-		{"UnmarshalTypeError.Offset", Field, 5, ""},
-		{"UnmarshalTypeError.Struct", Field, 8, ""},
-		{"UnmarshalTypeError.Type", Field, 0, ""},
-		{"UnmarshalTypeError.Value", Field, 0, ""},
-		{"Unmarshaler", Type, 0, ""},
-		{"UnsupportedTypeError", Type, 0, ""},
-		{"UnsupportedTypeError.Type", Field, 0, ""},
-		{"UnsupportedValueError", Type, 0, ""},
-		{"UnsupportedValueError.Str", Field, 0, ""},
-		{"UnsupportedValueError.Value", Field, 0, ""},
-		{"Valid", Func, 9, "func(data []byte) bool"},
-	},
-	"encoding/pem": {
-		{"Block", Type, 0, ""},
-		{"Block.Bytes", Field, 0, ""},
-		{"Block.Headers", Field, 0, ""},
-		{"Block.Type", Field, 0, ""},
-		{"Decode", Func, 0, "func(data []byte) (p *Block, rest []byte)"},
-		{"Encode", Func, 0, "func(out io.Writer, b *Block) error"},
-		{"EncodeToMemory", Func, 0, "func(b *Block) []byte"},
-	},
-	"encoding/xml": {
-		{"(*Decoder).Decode", Method, 0, ""},
-		{"(*Decoder).DecodeElement", Method, 0, ""},
-		{"(*Decoder).InputOffset", Method, 4, ""},
-		{"(*Decoder).InputPos", Method, 19, ""},
-		{"(*Decoder).RawToken", Method, 0, ""},
-		{"(*Decoder).Skip", Method, 0, ""},
-		{"(*Decoder).Token", Method, 0, ""},
-		{"(*Encoder).Close", Method, 20, ""},
-		{"(*Encoder).Encode", Method, 0, ""},
-		{"(*Encoder).EncodeElement", Method, 2, ""},
-		{"(*Encoder).EncodeToken", Method, 2, ""},
-		{"(*Encoder).Flush", Method, 2, ""},
-		{"(*Encoder).Indent", Method, 1, ""},
-		{"(*SyntaxError).Error", Method, 0, ""},
-		{"(*TagPathError).Error", Method, 0, ""},
-		{"(*UnsupportedTypeError).Error", Method, 0, ""},
-		{"(CharData).Copy", Method, 0, ""},
-		{"(Comment).Copy", Method, 0, ""},
-		{"(Directive).Copy", Method, 0, ""},
-		{"(Marshaler).MarshalXML", Method, 2, ""},
-		{"(MarshalerAttr).MarshalXMLAttr", Method, 2, ""},
-		{"(ProcInst).Copy", Method, 0, ""},
-		{"(StartElement).Copy", Method, 0, ""},
-		{"(StartElement).End", Method, 2, ""},
-		{"(TokenReader).Token", Method, 10, ""},
-		{"(UnmarshalError).Error", Method, 0, ""},
-		{"(Unmarshaler).UnmarshalXML", Method, 2, ""},
-		{"(UnmarshalerAttr).UnmarshalXMLAttr", Method, 2, ""},
-		{"Attr", Type, 0, ""},
-		{"Attr.Name", Field, 0, ""},
-		{"Attr.Value", Field, 0, ""},
-		{"CharData", Type, 0, ""},
-		{"Comment", Type, 0, ""},
-		{"CopyToken", Func, 0, "func(t Token) Token"},
-		{"Decoder", Type, 0, ""},
-		{"Decoder.AutoClose", Field, 0, ""},
-		{"Decoder.CharsetReader", Field, 0, ""},
-		{"Decoder.DefaultSpace", Field, 1, ""},
-		{"Decoder.Entity", Field, 0, ""},
-		{"Decoder.Strict", Field, 0, ""},
-		{"Directive", Type, 0, ""},
-		{"Encoder", Type, 0, ""},
-		{"EndElement", Type, 0, ""},
-		{"EndElement.Name", Field, 0, ""},
-		{"Escape", Func, 0, "func(w io.Writer, s []byte)"},
-		{"EscapeText", Func, 1, "func(w io.Writer, s []byte) error"},
-		{"HTMLAutoClose", Var, 0, ""},
-		{"HTMLEntity", Var, 0, ""},
-		{"Header", Const, 0, ""},
-		{"Marshal", Func, 0, "func(v any) ([]byte, error)"},
-		{"MarshalIndent", Func, 0, "func(v any, prefix string, indent string) ([]byte, error)"},
-		{"Marshaler", Type, 2, ""},
-		{"MarshalerAttr", Type, 2, ""},
-		{"Name", Type, 0, ""},
-		{"Name.Local", Field, 0, ""},
-		{"Name.Space", Field, 0, ""},
-		{"NewDecoder", Func, 0, "func(r io.Reader) *Decoder"},
-		{"NewEncoder", Func, 0, "func(w io.Writer) *Encoder"},
-		{"NewTokenDecoder", Func, 10, "func(t TokenReader) *Decoder"},
-		{"ProcInst", Type, 0, ""},
-		{"ProcInst.Inst", Field, 0, ""},
-		{"ProcInst.Target", Field, 0, ""},
-		{"StartElement", Type, 0, ""},
-		{"StartElement.Attr", Field, 0, ""},
-		{"StartElement.Name", Field, 0, ""},
-		{"SyntaxError", Type, 0, ""},
-		{"SyntaxError.Line", Field, 0, ""},
-		{"SyntaxError.Msg", Field, 0, ""},
-		{"TagPathError", Type, 0, ""},
-		{"TagPathError.Field1", Field, 0, ""},
-		{"TagPathError.Field2", Field, 0, ""},
-		{"TagPathError.Struct", Field, 0, ""},
-		{"TagPathError.Tag1", Field, 0, ""},
-		{"TagPathError.Tag2", Field, 0, ""},
-		{"Token", Type, 0, ""},
-		{"TokenReader", Type, 10, ""},
-		{"Unmarshal", Func, 0, "func(data []byte, v any) error"},
-		{"UnmarshalError", Type, 0, ""},
-		{"Unmarshaler", Type, 2, ""},
-		{"UnmarshalerAttr", Type, 2, ""},
-		{"UnsupportedTypeError", Type, 0, ""},
-		{"UnsupportedTypeError.Type", Field, 0, ""},
-	},
-	"errors": {
-		{"As", Func, 13, "func(err error, target any) bool"},
-		{"AsType", Func, 26, "func[E error](err error) (E, bool)"},
-		{"ErrUnsupported", Var, 21, ""},
-		{"Is", Func, 13, "func(err error, target error) bool"},
-		{"Join", Func, 20, "func(errs ...error) error"},
-		{"New", Func, 0, "func(text string) error"},
-		{"Unwrap", Func, 13, "func(err error) error"},
-	},
-	"expvar": {
-		{"(*Float).Add", Method, 0, ""},
-		{"(*Float).Set", Method, 0, ""},
-		{"(*Float).String", Method, 0, ""},
-		{"(*Float).Value", Method, 8, ""},
-		{"(*Int).Add", Method, 0, ""},
-		{"(*Int).Set", Method, 0, ""},
-		{"(*Int).String", Method, 0, ""},
-		{"(*Int).Value", Method, 8, ""},
-		{"(*Map).Add", Method, 0, ""},
-		{"(*Map).AddFloat", Method, 0, ""},
-		{"(*Map).Delete", Method, 12, ""},
-		{"(*Map).Do", Method, 0, ""},
-		{"(*Map).Get", Method, 0, ""},
-		{"(*Map).Init", Method, 0, ""},
-		{"(*Map).Set", Method, 0, ""},
-		{"(*Map).String", Method, 0, ""},
-		{"(*String).Set", Method, 0, ""},
-		{"(*String).String", Method, 0, ""},
-		{"(*String).Value", Method, 8, ""},
-		{"(Func).String", Method, 0, ""},
-		{"(Func).Value", Method, 8, ""},
-		{"(Var).String", Method, 0, ""},
-		{"Do", Func, 0, "func(f func(KeyValue))"},
-		{"Float", Type, 0, ""},
-		{"Func", Type, 0, ""},
-		{"Get", Func, 0, "func(name string) Var"},
-		{"Handler", Func, 8, "func() http.Handler"},
-		{"Int", Type, 0, ""},
-		{"KeyValue", Type, 0, ""},
-		{"KeyValue.Key", Field, 0, ""},
-		{"KeyValue.Value", Field, 0, ""},
-		{"Map", Type, 0, ""},
-		{"NewFloat", Func, 0, "func(name string) *Float"},
-		{"NewInt", Func, 0, "func(name string) *Int"},
-		{"NewMap", Func, 0, "func(name string) *Map"},
-		{"NewString", Func, 0, "func(name string) *String"},
-		{"Publish", Func, 0, "func(name string, v Var)"},
-		{"String", Type, 0, ""},
-		{"Var", Type, 0, ""},
-	},
-	"flag": {
-		{"(*FlagSet).Arg", Method, 0, ""},
-		{"(*FlagSet).Args", Method, 0, ""},
-		{"(*FlagSet).Bool", Method, 0, ""},
-		{"(*FlagSet).BoolFunc", Method, 21, ""},
-		{"(*FlagSet).BoolVar", Method, 0, ""},
-		{"(*FlagSet).Duration", Method, 0, ""},
-		{"(*FlagSet).DurationVar", Method, 0, ""},
-		{"(*FlagSet).ErrorHandling", Method, 10, ""},
-		{"(*FlagSet).Float64", Method, 0, ""},
-		{"(*FlagSet).Float64Var", Method, 0, ""},
-		{"(*FlagSet).Func", Method, 16, ""},
-		{"(*FlagSet).Init", Method, 0, ""},
-		{"(*FlagSet).Int", Method, 0, ""},
-		{"(*FlagSet).Int64", Method, 0, ""},
-		{"(*FlagSet).Int64Var", Method, 0, ""},
-		{"(*FlagSet).IntVar", Method, 0, ""},
-		{"(*FlagSet).Lookup", Method, 0, ""},
-		{"(*FlagSet).NArg", Method, 0, ""},
-		{"(*FlagSet).NFlag", Method, 0, ""},
-		{"(*FlagSet).Name", Method, 10, ""},
-		{"(*FlagSet).Output", Method, 10, ""},
-		{"(*FlagSet).Parse", Method, 0, ""},
-		{"(*FlagSet).Parsed", Method, 0, ""},
-		{"(*FlagSet).PrintDefaults", Method, 0, ""},
-		{"(*FlagSet).Set", Method, 0, ""},
-		{"(*FlagSet).SetOutput", Method, 0, ""},
-		{"(*FlagSet).String", Method, 0, ""},
-		{"(*FlagSet).StringVar", Method, 0, ""},
-		{"(*FlagSet).TextVar", Method, 19, ""},
-		{"(*FlagSet).Uint", Method, 0, ""},
-		{"(*FlagSet).Uint64", Method, 0, ""},
-		{"(*FlagSet).Uint64Var", Method, 0, ""},
-		{"(*FlagSet).UintVar", Method, 0, ""},
-		{"(*FlagSet).Var", Method, 0, ""},
-		{"(*FlagSet).Visit", Method, 0, ""},
-		{"(*FlagSet).VisitAll", Method, 0, ""},
-		{"(Getter).Get", Method, 2, ""},
-		{"(Getter).Set", Method, 2, ""},
-		{"(Getter).String", Method, 2, ""},
-		{"(Value).Set", Method, 0, ""},
-		{"(Value).String", Method, 0, ""},
-		{"Arg", Func, 0, "func(i int) string"},
-		{"Args", Func, 0, "func() []string"},
-		{"Bool", Func, 0, "func(name string, value bool, usage string) *bool"},
-		{"BoolFunc", Func, 21, "func(name string, usage string, fn func(string) error)"},
-		{"BoolVar", Func, 0, "func(p *bool, name string, value bool, usage string)"},
-		{"CommandLine", Var, 2, ""},
-		{"ContinueOnError", Const, 0, ""},
-		{"Duration", Func, 0, "func(name string, value time.Duration, usage string) *time.Duration"},
-		{"DurationVar", Func, 0, "func(p *time.Duration, name string, value time.Duration, usage string)"},
-		{"ErrHelp", Var, 0, ""},
-		{"ErrorHandling", Type, 0, ""},
-		{"ExitOnError", Const, 0, ""},
-		{"Flag", Type, 0, ""},
-		{"Flag.DefValue", Field, 0, ""},
-		{"Flag.Name", Field, 0, ""},
-		{"Flag.Usage", Field, 0, ""},
-		{"Flag.Value", Field, 0, ""},
-		{"FlagSet", Type, 0, ""},
-		{"FlagSet.Usage", Field, 0, ""},
-		{"Float64", Func, 0, "func(name string, value float64, usage string) *float64"},
-		{"Float64Var", Func, 0, "func(p *float64, name string, value float64, usage string)"},
-		{"Func", Func, 16, "func(name string, usage string, fn func(string) error)"},
-		{"Getter", Type, 2, ""},
-		{"Int", Func, 0, "func(name string, value int, usage string) *int"},
-		{"Int64", Func, 0, "func(name string, value int64, usage string) *int64"},
-		{"Int64Var", Func, 0, "func(p *int64, name string, value int64, usage string)"},
-		{"IntVar", Func, 0, "func(p *int, name string, value int, usage string)"},
-		{"Lookup", Func, 0, "func(name string) *Flag"},
-		{"NArg", Func, 0, "func() int"},
-		{"NFlag", Func, 0, "func() int"},
-		{"NewFlagSet", Func, 0, "func(name string, errorHandling ErrorHandling) *FlagSet"},
-		{"PanicOnError", Const, 0, ""},
-		{"Parse", Func, 0, "func()"},
-		{"Parsed", Func, 0, "func() bool"},
-		{"PrintDefaults", Func, 0, "func()"},
-		{"Set", Func, 0, "func(name string, value string) error"},
-		{"String", Func, 0, "func(name string, value string, usage string) *string"},
-		{"StringVar", Func, 0, "func(p *string, name string, value string, usage string)"},
-		{"TextVar", Func, 19, "func(p encoding.TextUnmarshaler, name string, value encoding.TextMarshaler, usage string)"},
-		{"Uint", Func, 0, "func(name string, value uint, usage string) *uint"},
-		{"Uint64", Func, 0, "func(name string, value uint64, usage string) *uint64"},
-		{"Uint64Var", Func, 0, "func(p *uint64, name string, value uint64, usage string)"},
-		{"UintVar", Func, 0, "func(p *uint, name string, value uint, usage string)"},
-		{"UnquoteUsage", Func, 5, "func(flag *Flag) (name string, usage string)"},
-		{"Usage", Var, 0, ""},
-		{"Value", Type, 0, ""},
-		{"Var", Func, 0, "func(value Value, name string, usage string)"},
-		{"Visit", Func, 0, "func(fn func(*Flag))"},
-		{"VisitAll", Func, 0, "func(fn func(*Flag))"},
-	},
-	"fmt": {
-		{"(Formatter).Format", Method, 0, ""},
-		{"(GoStringer).GoString", Method, 0, ""},
-		{"(ScanState).Read", Method, 0, ""},
-		{"(ScanState).ReadRune", Method, 0, ""},
-		{"(ScanState).SkipSpace", Method, 0, ""},
-		{"(ScanState).Token", Method, 0, ""},
-		{"(ScanState).UnreadRune", Method, 0, ""},
-		{"(ScanState).Width", Method, 0, ""},
-		{"(Scanner).Scan", Method, 0, ""},
-		{"(State).Flag", Method, 0, ""},
-		{"(State).Precision", Method, 0, ""},
-		{"(State).Width", Method, 0, ""},
-		{"(State).Write", Method, 0, ""},
-		{"(Stringer).String", Method, 0, ""},
-		{"Append", Func, 19, "func(b []byte, a ...any) []byte"},
-		{"Appendf", Func, 19, "func(b []byte, format string, a ...any) []byte"},
-		{"Appendln", Func, 19, "func(b []byte, a ...any) []byte"},
-		{"Errorf", Func, 0, "func(format string, a ...any) (err error)"},
-		{"FormatString", Func, 20, "func(state State, verb rune) string"},
-		{"Formatter", Type, 0, ""},
-		{"Fprint", Func, 0, "func(w io.Writer, a ...any) (n int, err error)"},
-		{"Fprintf", Func, 0, "func(w io.Writer, format string, a ...any) (n int, err error)"},
-		{"Fprintln", Func, 0, "func(w io.Writer, a ...any) (n int, err error)"},
-		{"Fscan", Func, 0, "func(r io.Reader, a ...any) (n int, err error)"},
-		{"Fscanf", Func, 0, "func(r io.Reader, format string, a ...any) (n int, err error)"},
-		{"Fscanln", Func, 0, "func(r io.Reader, a ...any) (n int, err error)"},
-		{"GoStringer", Type, 0, ""},
-		{"Print", Func, 0, "func(a ...any) (n int, err error)"},
-		{"Printf", Func, 0, "func(format string, a ...any) (n int, err error)"},
-		{"Println", Func, 0, "func(a ...any) (n int, err error)"},
-		{"Scan", Func, 0, "func(a ...any) (n int, err error)"},
-		{"ScanState", Type, 0, ""},
-		{"Scanf", Func, 0, "func(format string, a ...any) (n int, err error)"},
-		{"Scanln", Func, 0, "func(a ...any) (n int, err error)"},
-		{"Scanner", Type, 0, ""},
-		{"Sprint", Func, 0, "func(a ...any) string"},
-		{"Sprintf", Func, 0, "func(format string, a ...any) string"},
-		{"Sprintln", Func, 0, "func(a ...any) string"},
-		{"Sscan", Func, 0, "func(str string, a ...any) (n int, err error)"},
-		{"Sscanf", Func, 0, "func(str string, format string, a ...any) (n int, err error)"},
-		{"Sscanln", Func, 0, "func(str string, a ...any) (n int, err error)"},
-		{"State", Type, 0, ""},
-		{"Stringer", Type, 0, ""},
-	},
-	"go/ast": {
-		{"(*ArrayType).End", Method, 0, ""},
-		{"(*ArrayType).Pos", Method, 0, ""},
-		{"(*AssignStmt).End", Method, 0, ""},
-		{"(*AssignStmt).Pos", Method, 0, ""},
-		{"(*BadDecl).End", Method, 0, ""},
-		{"(*BadDecl).Pos", Method, 0, ""},
-		{"(*BadExpr).End", Method, 0, ""},
-		{"(*BadExpr).Pos", Method, 0, ""},
-		{"(*BadStmt).End", Method, 0, ""},
-		{"(*BadStmt).Pos", Method, 0, ""},
-		{"(*BasicLit).End", Method, 0, ""},
-		{"(*BasicLit).Pos", Method, 0, ""},
-		{"(*BinaryExpr).End", Method, 0, ""},
-		{"(*BinaryExpr).Pos", Method, 0, ""},
-		{"(*BlockStmt).End", Method, 0, ""},
-		{"(*BlockStmt).Pos", Method, 0, ""},
-		{"(*BranchStmt).End", Method, 0, ""},
-		{"(*BranchStmt).Pos", Method, 0, ""},
-		{"(*CallExpr).End", Method, 0, ""},
-		{"(*CallExpr).Pos", Method, 0, ""},
-		{"(*CaseClause).End", Method, 0, ""},
-		{"(*CaseClause).Pos", Method, 0, ""},
-		{"(*ChanType).End", Method, 0, ""},
-		{"(*ChanType).Pos", Method, 0, ""},
-		{"(*CommClause).End", Method, 0, ""},
-		{"(*CommClause).Pos", Method, 0, ""},
-		{"(*Comment).End", Method, 0, ""},
-		{"(*Comment).Pos", Method, 0, ""},
-		{"(*CommentGroup).End", Method, 0, ""},
-		{"(*CommentGroup).Pos", Method, 0, ""},
-		{"(*CommentGroup).Text", Method, 0, ""},
-		{"(*CompositeLit).End", Method, 0, ""},
-		{"(*CompositeLit).Pos", Method, 0, ""},
-		{"(*DeclStmt).End", Method, 0, ""},
-		{"(*DeclStmt).Pos", Method, 0, ""},
-		{"(*DeferStmt).End", Method, 0, ""},
-		{"(*DeferStmt).Pos", Method, 0, ""},
-		{"(*Directive).End", Method, 26, ""},
-		{"(*Directive).ParseArgs", Method, 26, ""},
-		{"(*Directive).Pos", Method, 26, ""},
-		{"(*Ellipsis).End", Method, 0, ""},
-		{"(*Ellipsis).Pos", Method, 0, ""},
-		{"(*EmptyStmt).End", Method, 0, ""},
-		{"(*EmptyStmt).Pos", Method, 0, ""},
-		{"(*ExprStmt).End", Method, 0, ""},
-		{"(*ExprStmt).Pos", Method, 0, ""},
-		{"(*Field).End", Method, 0, ""},
-		{"(*Field).Pos", Method, 0, ""},
-		{"(*FieldList).End", Method, 0, ""},
-		{"(*FieldList).NumFields", Method, 0, ""},
-		{"(*FieldList).Pos", Method, 0, ""},
-		{"(*File).End", Method, 0, ""},
-		{"(*File).Pos", Method, 0, ""},
-		{"(*ForStmt).End", Method, 0, ""},
-		{"(*ForStmt).Pos", Method, 0, ""},
-		{"(*FuncDecl).End", Method, 0, ""},
-		{"(*FuncDecl).Pos", Method, 0, ""},
-		{"(*FuncLit).End", Method, 0, ""},
-		{"(*FuncLit).Pos", Method, 0, ""},
-		{"(*FuncType).End", Method, 0, ""},
-		{"(*FuncType).Pos", Method, 0, ""},
-		{"(*GenDecl).End", Method, 0, ""},
-		{"(*GenDecl).Pos", Method, 0, ""},
-		{"(*GoStmt).End", Method, 0, ""},
-		{"(*GoStmt).Pos", Method, 0, ""},
-		{"(*Ident).End", Method, 0, ""},
-		{"(*Ident).IsExported", Method, 0, ""},
-		{"(*Ident).Pos", Method, 0, ""},
-		{"(*Ident).String", Method, 0, ""},
-		{"(*IfStmt).End", Method, 0, ""},
-		{"(*IfStmt).Pos", Method, 0, ""},
-		{"(*ImportSpec).End", Method, 0, ""},
-		{"(*ImportSpec).Pos", Method, 0, ""},
-		{"(*IncDecStmt).End", Method, 0, ""},
-		{"(*IncDecStmt).Pos", Method, 0, ""},
-		{"(*IndexExpr).End", Method, 0, ""},
-		{"(*IndexExpr).Pos", Method, 0, ""},
-		{"(*IndexListExpr).End", Method, 18, ""},
-		{"(*IndexListExpr).Pos", Method, 18, ""},
-		{"(*InterfaceType).End", Method, 0, ""},
-		{"(*InterfaceType).Pos", Method, 0, ""},
-		{"(*KeyValueExpr).End", Method, 0, ""},
-		{"(*KeyValueExpr).Pos", Method, 0, ""},
-		{"(*LabeledStmt).End", Method, 0, ""},
-		{"(*LabeledStmt).Pos", Method, 0, ""},
-		{"(*MapType).End", Method, 0, ""},
-		{"(*MapType).Pos", Method, 0, ""},
-		{"(*Object).Pos", Method, 0, ""},
-		{"(*Package).End", Method, 0, ""},
-		{"(*Package).Pos", Method, 0, ""},
-		{"(*ParenExpr).End", Method, 0, ""},
-		{"(*ParenExpr).Pos", Method, 0, ""},
-		{"(*RangeStmt).End", Method, 0, ""},
-		{"(*RangeStmt).Pos", Method, 0, ""},
-		{"(*ReturnStmt).End", Method, 0, ""},
-		{"(*ReturnStmt).Pos", Method, 0, ""},
-		{"(*Scope).Insert", Method, 0, ""},
-		{"(*Scope).Lookup", Method, 0, ""},
-		{"(*Scope).String", Method, 0, ""},
-		{"(*SelectStmt).End", Method, 0, ""},
-		{"(*SelectStmt).Pos", Method, 0, ""},
-		{"(*SelectorExpr).End", Method, 0, ""},
-		{"(*SelectorExpr).Pos", Method, 0, ""},
-		{"(*SendStmt).End", Method, 0, ""},
-		{"(*SendStmt).Pos", Method, 0, ""},
-		{"(*SliceExpr).End", Method, 0, ""},
-		{"(*SliceExpr).Pos", Method, 0, ""},
-		{"(*StarExpr).End", Method, 0, ""},
-		{"(*StarExpr).Pos", Method, 0, ""},
-		{"(*StructType).End", Method, 0, ""},
-		{"(*StructType).Pos", Method, 0, ""},
-		{"(*SwitchStmt).End", Method, 0, ""},
-		{"(*SwitchStmt).Pos", Method, 0, ""},
-		{"(*TypeAssertExpr).End", Method, 0, ""},
-		{"(*TypeAssertExpr).Pos", Method, 0, ""},
-		{"(*TypeSpec).End", Method, 0, ""},
-		{"(*TypeSpec).Pos", Method, 0, ""},
-		{"(*TypeSwitchStmt).End", Method, 0, ""},
-		{"(*TypeSwitchStmt).Pos", Method, 0, ""},
-		{"(*UnaryExpr).End", Method, 0, ""},
-		{"(*UnaryExpr).Pos", Method, 0, ""},
-		{"(*ValueSpec).End", Method, 0, ""},
-		{"(*ValueSpec).Pos", Method, 0, ""},
-		{"(CommentMap).Comments", Method, 1, ""},
-		{"(CommentMap).Filter", Method, 1, ""},
-		{"(CommentMap).String", Method, 1, ""},
-		{"(CommentMap).Update", Method, 1, ""},
-		{"(Decl).End", Method, 0, ""},
-		{"(Decl).Pos", Method, 0, ""},
-		{"(Expr).End", Method, 0, ""},
-		{"(Expr).Pos", Method, 0, ""},
-		{"(Node).End", Method, 0, ""},
-		{"(Node).Pos", Method, 0, ""},
-		{"(ObjKind).String", Method, 0, ""},
-		{"(Spec).End", Method, 0, ""},
-		{"(Spec).Pos", Method, 0, ""},
-		{"(Stmt).End", Method, 0, ""},
-		{"(Stmt).Pos", Method, 0, ""},
-		{"(Visitor).Visit", Method, 0, ""},
-		{"ArrayType", Type, 0, ""},
-		{"ArrayType.Elt", Field, 0, ""},
-		{"ArrayType.Lbrack", Field, 0, ""},
-		{"ArrayType.Len", Field, 0, ""},
-		{"AssignStmt", Type, 0, ""},
-		{"AssignStmt.Lhs", Field, 0, ""},
-		{"AssignStmt.Rhs", Field, 0, ""},
-		{"AssignStmt.Tok", Field, 0, ""},
-		{"AssignStmt.TokPos", Field, 0, ""},
-		{"Bad", Const, 0, ""},
-		{"BadDecl", Type, 0, ""},
-		{"BadDecl.From", Field, 0, ""},
-		{"BadDecl.To", Field, 0, ""},
-		{"BadExpr", Type, 0, ""},
-		{"BadExpr.From", Field, 0, ""},
-		{"BadExpr.To", Field, 0, ""},
-		{"BadStmt", Type, 0, ""},
-		{"BadStmt.From", Field, 0, ""},
-		{"BadStmt.To", Field, 0, ""},
-		{"BasicLit", Type, 0, ""},
-		{"BasicLit.Kind", Field, 0, ""},
-		{"BasicLit.Value", Field, 0, ""},
-		{"BasicLit.ValueEnd", Field, 26, ""},
-		{"BasicLit.ValuePos", Field, 0, ""},
-		{"BinaryExpr", Type, 0, ""},
-		{"BinaryExpr.Op", Field, 0, ""},
-		{"BinaryExpr.OpPos", Field, 0, ""},
-		{"BinaryExpr.X", Field, 0, ""},
-		{"BinaryExpr.Y", Field, 0, ""},
-		{"BlockStmt", Type, 0, ""},
-		{"BlockStmt.Lbrace", Field, 0, ""},
-		{"BlockStmt.List", Field, 0, ""},
-		{"BlockStmt.Rbrace", Field, 0, ""},
-		{"BranchStmt", Type, 0, ""},
-		{"BranchStmt.Label", Field, 0, ""},
-		{"BranchStmt.Tok", Field, 0, ""},
-		{"BranchStmt.TokPos", Field, 0, ""},
-		{"CallExpr", Type, 0, ""},
-		{"CallExpr.Args", Field, 0, ""},
-		{"CallExpr.Ellipsis", Field, 0, ""},
-		{"CallExpr.Fun", Field, 0, ""},
-		{"CallExpr.Lparen", Field, 0, ""},
-		{"CallExpr.Rparen", Field, 0, ""},
-		{"CaseClause", Type, 0, ""},
-		{"CaseClause.Body", Field, 0, ""},
-		{"CaseClause.Case", Field, 0, ""},
-		{"CaseClause.Colon", Field, 0, ""},
-		{"CaseClause.List", Field, 0, ""},
-		{"ChanDir", Type, 0, ""},
-		{"ChanType", Type, 0, ""},
-		{"ChanType.Arrow", Field, 1, ""},
-		{"ChanType.Begin", Field, 0, ""},
-		{"ChanType.Dir", Field, 0, ""},
-		{"ChanType.Value", Field, 0, ""},
-		{"CommClause", Type, 0, ""},
-		{"CommClause.Body", Field, 0, ""},
-		{"CommClause.Case", Field, 0, ""},
-		{"CommClause.Colon", Field, 0, ""},
-		{"CommClause.Comm", Field, 0, ""},
-		{"Comment", Type, 0, ""},
-		{"Comment.Slash", Field, 0, ""},
-		{"Comment.Text", Field, 0, ""},
-		{"CommentGroup", Type, 0, ""},
-		{"CommentGroup.List", Field, 0, ""},
-		{"CommentMap", Type, 1, ""},
-		{"CompositeLit", Type, 0, ""},
-		{"CompositeLit.Elts", Field, 0, ""},
-		{"CompositeLit.Incomplete", Field, 11, ""},
-		{"CompositeLit.Lbrace", Field, 0, ""},
-		{"CompositeLit.Rbrace", Field, 0, ""},
-		{"CompositeLit.Type", Field, 0, ""},
-		{"Con", Const, 0, ""},
-		{"DeclStmt", Type, 0, ""},
-		{"DeclStmt.Decl", Field, 0, ""},
-		{"DeferStmt", Type, 0, ""},
-		{"DeferStmt.Call", Field, 0, ""},
-		{"DeferStmt.Defer", Field, 0, ""},
-		{"Directive", Type, 26, ""},
-		{"Directive.Args", Field, 26, ""},
-		{"Directive.ArgsPos", Field, 26, ""},
-		{"Directive.Name", Field, 26, ""},
-		{"Directive.Slash", Field, 26, ""},
-		{"Directive.Tool", Field, 26, ""},
-		{"DirectiveArg", Type, 26, ""},
-		{"DirectiveArg.Arg", Field, 26, ""},
-		{"DirectiveArg.Pos", Field, 26, ""},
-		{"Ellipsis", Type, 0, ""},
-		{"Ellipsis.Ellipsis", Field, 0, ""},
-		{"Ellipsis.Elt", Field, 0, ""},
-		{"EmptyStmt", Type, 0, ""},
-		{"EmptyStmt.Implicit", Field, 5, ""},
-		{"EmptyStmt.Semicolon", Field, 0, ""},
-		{"ExprStmt", Type, 0, ""},
-		{"ExprStmt.X", Field, 0, ""},
-		{"Field", Type, 0, ""},
-		{"Field.Comment", Field, 0, ""},
-		{"Field.Doc", Field, 0, ""},
-		{"Field.Names", Field, 0, ""},
-		{"Field.Tag", Field, 0, ""},
-		{"Field.Type", Field, 0, ""},
-		{"FieldFilter", Type, 0, ""},
-		{"FieldList", Type, 0, ""},
-		{"FieldList.Closing", Field, 0, ""},
-		{"FieldList.List", Field, 0, ""},
-		{"FieldList.Opening", Field, 0, ""},
-		{"File", Type, 0, ""},
-		{"File.Comments", Field, 0, ""},
-		{"File.Decls", Field, 0, ""},
-		{"File.Doc", Field, 0, ""},
-		{"File.FileEnd", Field, 20, ""},
-		{"File.FileStart", Field, 20, ""},
-		{"File.GoVersion", Field, 21, ""},
-		{"File.Imports", Field, 0, ""},
-		{"File.Name", Field, 0, ""},
-		{"File.Package", Field, 0, ""},
-		{"File.Scope", Field, 0, ""},
-		{"File.Unresolved", Field, 0, ""},
-		{"FileExports", Func, 0, "func(src *File) bool"},
-		{"Filter", Type, 0, ""},
-		{"FilterDecl", Func, 0, "func(decl Decl, f Filter) bool"},
-		{"FilterFile", Func, 0, "func(src *File, f Filter) bool"},
-		{"FilterFuncDuplicates", Const, 0, ""},
-		{"FilterImportDuplicates", Const, 0, ""},
-		{"FilterPackage", Func, 0, "func(pkg *Package, f Filter) bool"},
-		{"FilterUnassociatedComments", Const, 0, ""},
-		{"ForStmt", Type, 0, ""},
-		{"ForStmt.Body", Field, 0, ""},
-		{"ForStmt.Cond", Field, 0, ""},
-		{"ForStmt.For", Field, 0, ""},
-		{"ForStmt.Init", Field, 0, ""},
-		{"ForStmt.Post", Field, 0, ""},
-		{"Fprint", Func, 0, "func(w io.Writer, fset *token.FileSet, x any, f FieldFilter) error"},
-		{"Fun", Const, 0, ""},
-		{"FuncDecl", Type, 0, ""},
-		{"FuncDecl.Body", Field, 0, ""},
-		{"FuncDecl.Doc", Field, 0, ""},
-		{"FuncDecl.Name", Field, 0, ""},
-		{"FuncDecl.Recv", Field, 0, ""},
-		{"FuncDecl.Type", Field, 0, ""},
-		{"FuncLit", Type, 0, ""},
-		{"FuncLit.Body", Field, 0, ""},
-		{"FuncLit.Type", Field, 0, ""},
-		{"FuncType", Type, 0, ""},
-		{"FuncType.Func", Field, 0, ""},
-		{"FuncType.Params", Field, 0, ""},
-		{"FuncType.Results", Field, 0, ""},
-		{"FuncType.TypeParams", Field, 18, ""},
-		{"GenDecl", Type, 0, ""},
-		{"GenDecl.Doc", Field, 0, ""},
-		{"GenDecl.Lparen", Field, 0, ""},
-		{"GenDecl.Rparen", Field, 0, ""},
-		{"GenDecl.Specs", Field, 0, ""},
-		{"GenDecl.Tok", Field, 0, ""},
-		{"GenDecl.TokPos", Field, 0, ""},
-		{"GoStmt", Type, 0, ""},
-		{"GoStmt.Call", Field, 0, ""},
-		{"GoStmt.Go", Field, 0, ""},
-		{"Ident", Type, 0, ""},
-		{"Ident.Name", Field, 0, ""},
-		{"Ident.NamePos", Field, 0, ""},
-		{"Ident.Obj", Field, 0, ""},
-		{"IfStmt", Type, 0, ""},
-		{"IfStmt.Body", Field, 0, ""},
-		{"IfStmt.Cond", Field, 0, ""},
-		{"IfStmt.Else", Field, 0, ""},
-		{"IfStmt.If", Field, 0, ""},
-		{"IfStmt.Init", Field, 0, ""},
-		{"ImportSpec", Type, 0, ""},
-		{"ImportSpec.Comment", Field, 0, ""},
-		{"ImportSpec.Doc", Field, 0, ""},
-		{"ImportSpec.EndPos", Field, 0, ""},
-		{"ImportSpec.Name", Field, 0, ""},
-		{"ImportSpec.Path", Field, 0, ""},
-		{"Importer", Type, 0, ""},
-		{"IncDecStmt", Type, 0, ""},
-		{"IncDecStmt.Tok", Field, 0, ""},
-		{"IncDecStmt.TokPos", Field, 0, ""},
-		{"IncDecStmt.X", Field, 0, ""},
-		{"IndexExpr", Type, 0, ""},
-		{"IndexExpr.Index", Field, 0, ""},
-		{"IndexExpr.Lbrack", Field, 0, ""},
-		{"IndexExpr.Rbrack", Field, 0, ""},
-		{"IndexExpr.X", Field, 0, ""},
-		{"IndexListExpr", Type, 18, ""},
-		{"IndexListExpr.Indices", Field, 18, ""},
-		{"IndexListExpr.Lbrack", Field, 18, ""},
-		{"IndexListExpr.Rbrack", Field, 18, ""},
-		{"IndexListExpr.X", Field, 18, ""},
-		{"Inspect", Func, 0, "func(node Node, f func(Node) bool)"},
-		{"InterfaceType", Type, 0, ""},
-		{"InterfaceType.Incomplete", Field, 0, ""},
-		{"InterfaceType.Interface", Field, 0, ""},
-		{"InterfaceType.Methods", Field, 0, ""},
-		{"IsExported", Func, 0, "func(name string) bool"},
-		{"IsGenerated", Func, 21, "func(file *File) bool"},
-		{"KeyValueExpr", Type, 0, ""},
-		{"KeyValueExpr.Colon", Field, 0, ""},
-		{"KeyValueExpr.Key", Field, 0, ""},
-		{"KeyValueExpr.Value", Field, 0, ""},
-		{"LabeledStmt", Type, 0, ""},
-		{"LabeledStmt.Colon", Field, 0, ""},
-		{"LabeledStmt.Label", Field, 0, ""},
-		{"LabeledStmt.Stmt", Field, 0, ""},
-		{"Lbl", Const, 0, ""},
-		{"MapType", Type, 0, ""},
-		{"MapType.Key", Field, 0, ""},
-		{"MapType.Map", Field, 0, ""},
-		{"MapType.Value", Field, 0, ""},
-		{"MergeMode", Type, 0, ""},
-		{"MergePackageFiles", Func, 0, "func(pkg *Package, mode MergeMode) *File"},
-		{"NewCommentMap", Func, 1, "func(fset *token.FileSet, node Node, comments []*CommentGroup) CommentMap"},
-		{"NewIdent", Func, 0, "func(name string) *Ident"},
-		{"NewObj", Func, 0, "func(kind ObjKind, name string) *Object"},
-		{"NewPackage", Func, 0, "func(fset *token.FileSet, files map[string]*File, importer Importer, universe *Scope) (*Package, error)"},
-		{"NewScope", Func, 0, "func(outer *Scope) *Scope"},
-		{"Node", Type, 0, ""},
-		{"NotNilFilter", Func, 0, "func(_ string, v reflect.Value) bool"},
-		{"ObjKind", Type, 0, ""},
-		{"Object", Type, 0, ""},
-		{"Object.Data", Field, 0, ""},
-		{"Object.Decl", Field, 0, ""},
-		{"Object.Kind", Field, 0, ""},
-		{"Object.Name", Field, 0, ""},
-		{"Object.Type", Field, 0, ""},
-		{"Package", Type, 0, ""},
-		{"Package.Files", Field, 0, ""},
-		{"Package.Imports", Field, 0, ""},
-		{"Package.Name", Field, 0, ""},
-		{"Package.Scope", Field, 0, ""},
-		{"PackageExports", Func, 0, "func(pkg *Package) bool"},
-		{"ParenExpr", Type, 0, ""},
-		{"ParenExpr.Lparen", Field, 0, ""},
-		{"ParenExpr.Rparen", Field, 0, ""},
-		{"ParenExpr.X", Field, 0, ""},
-		{"ParseDirective", Func, 26, "func(pos token.Pos, c string) (Directive, bool)"},
-		{"Pkg", Const, 0, ""},
-		{"Preorder", Func, 23, "func(root Node) iter.Seq[Node]"},
-		{"PreorderStack", Func, 25, "func(root Node, stack []Node, f func(n Node, stack []Node) bool)"},
-		{"Print", Func, 0, "func(fset *token.FileSet, x any) error"},
-		{"RECV", Const, 0, ""},
-		{"RangeStmt", Type, 0, ""},
-		{"RangeStmt.Body", Field, 0, ""},
-		{"RangeStmt.For", Field, 0, ""},
-		{"RangeStmt.Key", Field, 0, ""},
-		{"RangeStmt.Range", Field, 20, ""},
-		{"RangeStmt.Tok", Field, 0, ""},
-		{"RangeStmt.TokPos", Field, 0, ""},
-		{"RangeStmt.Value", Field, 0, ""},
-		{"RangeStmt.X", Field, 0, ""},
-		{"ReturnStmt", Type, 0, ""},
-		{"ReturnStmt.Results", Field, 0, ""},
-		{"ReturnStmt.Return", Field, 0, ""},
-		{"SEND", Const, 0, ""},
-		{"Scope", Type, 0, ""},
-		{"Scope.Objects", Field, 0, ""},
-		{"Scope.Outer", Field, 0, ""},
-		{"SelectStmt", Type, 0, ""},
-		{"SelectStmt.Body", Field, 0, ""},
-		{"SelectStmt.Select", Field, 0, ""},
-		{"SelectorExpr", Type, 0, ""},
-		{"SelectorExpr.Sel", Field, 0, ""},
-		{"SelectorExpr.X", Field, 0, ""},
-		{"SendStmt", Type, 0, ""},
-		{"SendStmt.Arrow", Field, 0, ""},
-		{"SendStmt.Chan", Field, 0, ""},
-		{"SendStmt.Value", Field, 0, ""},
-		{"SliceExpr", Type, 0, ""},
-		{"SliceExpr.High", Field, 0, ""},
-		{"SliceExpr.Lbrack", Field, 0, ""},
-		{"SliceExpr.Low", Field, 0, ""},
-		{"SliceExpr.Max", Field, 2, ""},
-		{"SliceExpr.Rbrack", Field, 0, ""},
-		{"SliceExpr.Slice3", Field, 2, ""},
-		{"SliceExpr.X", Field, 0, ""},
-		{"SortImports", Func, 0, "func(fset *token.FileSet, f *File)"},
-		{"StarExpr", Type, 0, ""},
-		{"StarExpr.Star", Field, 0, ""},
-		{"StarExpr.X", Field, 0, ""},
-		{"StructType", Type, 0, ""},
-		{"StructType.Fields", Field, 0, ""},
-		{"StructType.Incomplete", Field, 0, ""},
-		{"StructType.Struct", Field, 0, ""},
-		{"SwitchStmt", Type, 0, ""},
-		{"SwitchStmt.Body", Field, 0, ""},
-		{"SwitchStmt.Init", Field, 0, ""},
-		{"SwitchStmt.Switch", Field, 0, ""},
-		{"SwitchStmt.Tag", Field, 0, ""},
-		{"Typ", Const, 0, ""},
-		{"TypeAssertExpr", Type, 0, ""},
-		{"TypeAssertExpr.Lparen", Field, 2, ""},
-		{"TypeAssertExpr.Rparen", Field, 2, ""},
-		{"TypeAssertExpr.Type", Field, 0, ""},
-		{"TypeAssertExpr.X", Field, 0, ""},
-		{"TypeSpec", Type, 0, ""},
-		{"TypeSpec.Assign", Field, 9, ""},
-		{"TypeSpec.Comment", Field, 0, ""},
-		{"TypeSpec.Doc", Field, 0, ""},
-		{"TypeSpec.Name", Field, 0, ""},
-		{"TypeSpec.Type", Field, 0, ""},
-		{"TypeSpec.TypeParams", Field, 18, ""},
-		{"TypeSwitchStmt", Type, 0, ""},
-		{"TypeSwitchStmt.Assign", Field, 0, ""},
-		{"TypeSwitchStmt.Body", Field, 0, ""},
-		{"TypeSwitchStmt.Init", Field, 0, ""},
-		{"TypeSwitchStmt.Switch", Field, 0, ""},
-		{"UnaryExpr", Type, 0, ""},
-		{"UnaryExpr.Op", Field, 0, ""},
-		{"UnaryExpr.OpPos", Field, 0, ""},
-		{"UnaryExpr.X", Field, 0, ""},
-		{"Unparen", Func, 22, "func(e Expr) Expr"},
-		{"ValueSpec", Type, 0, ""},
-		{"ValueSpec.Comment", Field, 0, ""},
-		{"ValueSpec.Doc", Field, 0, ""},
-		{"ValueSpec.Names", Field, 0, ""},
-		{"ValueSpec.Type", Field, 0, ""},
-		{"ValueSpec.Values", Field, 0, ""},
-		{"Var", Const, 0, ""},
-		{"Visitor", Type, 0, ""},
-		{"Walk", Func, 0, "func(v Visitor, node Node)"},
-	},
-	"go/build": {
-		{"(*Context).Import", Method, 0, ""},
-		{"(*Context).ImportDir", Method, 0, ""},
-		{"(*Context).MatchFile", Method, 2, ""},
-		{"(*Context).SrcDirs", Method, 0, ""},
-		{"(*MultiplePackageError).Error", Method, 4, ""},
-		{"(*NoGoError).Error", Method, 0, ""},
-		{"(*Package).IsCommand", Method, 0, ""},
-		{"AllowBinary", Const, 0, ""},
-		{"ArchChar", Func, 0, "func(goarch string) (string, error)"},
-		{"Context", Type, 0, ""},
-		{"Context.BuildTags", Field, 0, ""},
-		{"Context.CgoEnabled", Field, 0, ""},
-		{"Context.Compiler", Field, 0, ""},
-		{"Context.Dir", Field, 14, ""},
-		{"Context.GOARCH", Field, 0, ""},
-		{"Context.GOOS", Field, 0, ""},
-		{"Context.GOPATH", Field, 0, ""},
-		{"Context.GOROOT", Field, 0, ""},
-		{"Context.HasSubdir", Field, 0, ""},
-		{"Context.InstallSuffix", Field, 1, ""},
-		{"Context.IsAbsPath", Field, 0, ""},
-		{"Context.IsDir", Field, 0, ""},
-		{"Context.JoinPath", Field, 0, ""},
-		{"Context.OpenFile", Field, 0, ""},
-		{"Context.ReadDir", Field, 0, ""},
-		{"Context.ReleaseTags", Field, 1, ""},
-		{"Context.SplitPathList", Field, 0, ""},
-		{"Context.ToolTags", Field, 17, ""},
-		{"Context.UseAllFiles", Field, 0, ""},
-		{"Default", Var, 0, ""},
-		{"Directive", Type, 21, ""},
-		{"Directive.Pos", Field, 21, ""},
-		{"Directive.Text", Field, 21, ""},
-		{"FindOnly", Const, 0, ""},
-		{"IgnoreVendor", Const, 6, ""},
-		{"Import", Func, 0, "func(path string, srcDir string, mode ImportMode) (*Package, error)"},
-		{"ImportComment", Const, 4, ""},
-		{"ImportDir", Func, 0, "func(dir string, mode ImportMode) (*Package, error)"},
-		{"ImportMode", Type, 0, ""},
-		{"IsLocalImport", Func, 0, "func(path string) bool"},
-		{"MultiplePackageError", Type, 4, ""},
-		{"MultiplePackageError.Dir", Field, 4, ""},
-		{"MultiplePackageError.Files", Field, 4, ""},
-		{"MultiplePackageError.Packages", Field, 4, ""},
-		{"NoGoError", Type, 0, ""},
-		{"NoGoError.Dir", Field, 0, ""},
-		{"Package", Type, 0, ""},
-		{"Package.AllTags", Field, 2, ""},
-		{"Package.BinDir", Field, 0, ""},
-		{"Package.BinaryOnly", Field, 7, ""},
-		{"Package.CFiles", Field, 0, ""},
-		{"Package.CXXFiles", Field, 2, ""},
-		{"Package.CgoCFLAGS", Field, 0, ""},
-		{"Package.CgoCPPFLAGS", Field, 2, ""},
-		{"Package.CgoCXXFLAGS", Field, 2, ""},
-		{"Package.CgoFFLAGS", Field, 7, ""},
-		{"Package.CgoFiles", Field, 0, ""},
-		{"Package.CgoLDFLAGS", Field, 0, ""},
-		{"Package.CgoPkgConfig", Field, 0, ""},
-		{"Package.ConflictDir", Field, 2, ""},
-		{"Package.Dir", Field, 0, ""},
-		{"Package.Directives", Field, 21, ""},
-		{"Package.Doc", Field, 0, ""},
-		{"Package.EmbedPatternPos", Field, 16, ""},
-		{"Package.EmbedPatterns", Field, 16, ""},
-		{"Package.FFiles", Field, 7, ""},
-		{"Package.GoFiles", Field, 0, ""},
-		{"Package.Goroot", Field, 0, ""},
-		{"Package.HFiles", Field, 0, ""},
-		{"Package.IgnoredGoFiles", Field, 1, ""},
-		{"Package.IgnoredOtherFiles", Field, 16, ""},
-		{"Package.ImportComment", Field, 4, ""},
-		{"Package.ImportPath", Field, 0, ""},
-		{"Package.ImportPos", Field, 0, ""},
-		{"Package.Imports", Field, 0, ""},
-		{"Package.InvalidGoFiles", Field, 6, ""},
-		{"Package.MFiles", Field, 3, ""},
-		{"Package.Name", Field, 0, ""},
-		{"Package.PkgObj", Field, 0, ""},
-		{"Package.PkgRoot", Field, 0, ""},
-		{"Package.PkgTargetRoot", Field, 5, ""},
-		{"Package.Root", Field, 0, ""},
-		{"Package.SFiles", Field, 0, ""},
-		{"Package.SrcRoot", Field, 0, ""},
-		{"Package.SwigCXXFiles", Field, 1, ""},
-		{"Package.SwigFiles", Field, 1, ""},
-		{"Package.SysoFiles", Field, 0, ""},
-		{"Package.TestDirectives", Field, 21, ""},
-		{"Package.TestEmbedPatternPos", Field, 16, ""},
-		{"Package.TestEmbedPatterns", Field, 16, ""},
-		{"Package.TestGoFiles", Field, 0, ""},
-		{"Package.TestImportPos", Field, 0, ""},
-		{"Package.TestImports", Field, 0, ""},
-		{"Package.XTestDirectives", Field, 21, ""},
-		{"Package.XTestEmbedPatternPos", Field, 16, ""},
-		{"Package.XTestEmbedPatterns", Field, 16, ""},
-		{"Package.XTestGoFiles", Field, 0, ""},
-		{"Package.XTestImportPos", Field, 0, ""},
-		{"Package.XTestImports", Field, 0, ""},
-		{"ToolDir", Var, 0, ""},
-	},
-	"go/build/constraint": {
-		{"(*AndExpr).Eval", Method, 16, ""},
-		{"(*AndExpr).String", Method, 16, ""},
-		{"(*NotExpr).Eval", Method, 16, ""},
-		{"(*NotExpr).String", Method, 16, ""},
-		{"(*OrExpr).Eval", Method, 16, ""},
-		{"(*OrExpr).String", Method, 16, ""},
-		{"(*SyntaxError).Error", Method, 16, ""},
-		{"(*TagExpr).Eval", Method, 16, ""},
-		{"(*TagExpr).String", Method, 16, ""},
-		{"(Expr).Eval", Method, 16, ""},
-		{"(Expr).String", Method, 16, ""},
-		{"AndExpr", Type, 16, ""},
-		{"AndExpr.X", Field, 16, ""},
-		{"AndExpr.Y", Field, 16, ""},
-		{"GoVersion", Func, 21, "func(x Expr) string"},
-		{"IsGoBuild", Func, 16, "func(line string) bool"},
-		{"IsPlusBuild", Func, 16, "func(line string) bool"},
-		{"NotExpr", Type, 16, ""},
-		{"NotExpr.X", Field, 16, ""},
-		{"OrExpr", Type, 16, ""},
-		{"OrExpr.X", Field, 16, ""},
-		{"OrExpr.Y", Field, 16, ""},
-		{"Parse", Func, 16, "func(line string) (Expr, error)"},
-		{"PlusBuildLines", Func, 16, "func(x Expr) ([]string, error)"},
-		{"SyntaxError", Type, 16, ""},
-		{"SyntaxError.Err", Field, 16, ""},
-		{"SyntaxError.Offset", Field, 16, ""},
-		{"TagExpr", Type, 16, ""},
-		{"TagExpr.Tag", Field, 16, ""},
-	},
-	"go/constant": {
-		{"(Kind).String", Method, 18, ""},
-		{"(Value).ExactString", Method, 6, ""},
-		{"(Value).Kind", Method, 5, ""},
-		{"(Value).String", Method, 5, ""},
-		{"BinaryOp", Func, 5, "func(x_ Value, op token.Token, y_ Value) Value"},
-		{"BitLen", Func, 5, "func(x Value) int"},
-		{"Bool", Const, 5, ""},
-		{"BoolVal", Func, 5, "func(x Value) bool"},
-		{"Bytes", Func, 5, "func(x Value) []byte"},
-		{"Compare", Func, 5, "func(x_ Value, op token.Token, y_ Value) bool"},
-		{"Complex", Const, 5, ""},
-		{"Denom", Func, 5, "func(x Value) Value"},
-		{"Float", Const, 5, ""},
-		{"Float32Val", Func, 5, "func(x Value) (float32, bool)"},
-		{"Float64Val", Func, 5, "func(x Value) (float64, bool)"},
-		{"Imag", Func, 5, "func(x Value) Value"},
-		{"Int", Const, 5, ""},
-		{"Int64Val", Func, 5, "func(x Value) (int64, bool)"},
-		{"Kind", Type, 5, ""},
-		{"Make", Func, 13, "func(x any) Value"},
-		{"MakeBool", Func, 5, "func(b bool) Value"},
-		{"MakeFloat64", Func, 5, "func(x float64) Value"},
-		{"MakeFromBytes", Func, 5, "func(bytes []byte) Value"},
-		{"MakeFromLiteral", Func, 5, "func(lit string, tok token.Token, zero uint) Value"},
-		{"MakeImag", Func, 5, "func(x Value) Value"},
-		{"MakeInt64", Func, 5, "func(x int64) Value"},
-		{"MakeString", Func, 5, "func(s string) Value"},
-		{"MakeUint64", Func, 5, "func(x uint64) Value"},
-		{"MakeUnknown", Func, 5, "func() Value"},
-		{"Num", Func, 5, "func(x Value) Value"},
-		{"Real", Func, 5, "func(x Value) Value"},
-		{"Shift", Func, 5, "func(x Value, op token.Token, s uint) Value"},
-		{"Sign", Func, 5, "func(x Value) int"},
-		{"String", Const, 5, ""},
-		{"StringVal", Func, 5, "func(x Value) string"},
-		{"ToComplex", Func, 6, "func(x Value) Value"},
-		{"ToFloat", Func, 6, "func(x Value) Value"},
-		{"ToInt", Func, 6, "func(x Value) Value"},
-		{"Uint64Val", Func, 5, "func(x Value) (uint64, bool)"},
-		{"UnaryOp", Func, 5, "func(op token.Token, y Value, prec uint) Value"},
-		{"Unknown", Const, 5, ""},
-		{"Val", Func, 13, "func(x Value) any"},
-	},
-	"go/doc": {
-		{"(*Package).Filter", Method, 0, ""},
-		{"(*Package).HTML", Method, 19, ""},
-		{"(*Package).Markdown", Method, 19, ""},
-		{"(*Package).Parser", Method, 19, ""},
-		{"(*Package).Printer", Method, 19, ""},
-		{"(*Package).Synopsis", Method, 19, ""},
-		{"(*Package).Text", Method, 19, ""},
-		{"AllDecls", Const, 0, ""},
-		{"AllMethods", Const, 0, ""},
-		{"Example", Type, 0, ""},
-		{"Example.Code", Field, 0, ""},
-		{"Example.Comments", Field, 0, ""},
-		{"Example.Doc", Field, 0, ""},
-		{"Example.EmptyOutput", Field, 1, ""},
-		{"Example.Name", Field, 0, ""},
-		{"Example.Order", Field, 1, ""},
-		{"Example.Output", Field, 0, ""},
-		{"Example.Play", Field, 1, ""},
-		{"Example.Suffix", Field, 14, ""},
-		{"Example.Unordered", Field, 7, ""},
-		{"Examples", Func, 0, "func(testFiles ...*ast.File) []*Example"},
-		{"Filter", Type, 0, ""},
-		{"Func", Type, 0, ""},
-		{"Func.Decl", Field, 0, ""},
-		{"Func.Doc", Field, 0, ""},
-		{"Func.Examples", Field, 14, ""},
-		{"Func.Level", Field, 0, ""},
-		{"Func.Name", Field, 0, ""},
-		{"Func.Orig", Field, 0, ""},
-		{"Func.Recv", Field, 0, ""},
-		{"IllegalPrefixes", Var, 1, ""},
-		{"IsPredeclared", Func, 8, "func(s string) bool"},
-		{"Mode", Type, 0, ""},
-		{"New", Func, 0, "func(pkg *ast.Package, importPath string, mode Mode) *Package"},
-		{"NewFromFiles", Func, 14, "func(fset *token.FileSet, files []*ast.File, importPath string, opts ...any) (*Package, error)"},
-		{"Note", Type, 1, ""},
-		{"Note.Body", Field, 1, ""},
-		{"Note.End", Field, 1, ""},
-		{"Note.Pos", Field, 1, ""},
-		{"Note.UID", Field, 1, ""},
-		{"Package", Type, 0, ""},
-		{"Package.Bugs", Field, 0, ""},
-		{"Package.Consts", Field, 0, ""},
-		{"Package.Doc", Field, 0, ""},
-		{"Package.Examples", Field, 14, ""},
-		{"Package.Filenames", Field, 0, ""},
-		{"Package.Funcs", Field, 0, ""},
-		{"Package.ImportPath", Field, 0, ""},
-		{"Package.Imports", Field, 0, ""},
-		{"Package.Name", Field, 0, ""},
-		{"Package.Notes", Field, 1, ""},
-		{"Package.Types", Field, 0, ""},
-		{"Package.Vars", Field, 0, ""},
-		{"PreserveAST", Const, 12, ""},
-		{"Synopsis", Func, 0, "func(text string) string"},
-		{"ToHTML", Func, 0, "func(w io.Writer, text string, words map[string]string)"},
-		{"ToText", Func, 0, "func(w io.Writer, text string, prefix string, codePrefix string, width int)"},
-		{"Type", Type, 0, ""},
-		{"Type.Consts", Field, 0, ""},
-		{"Type.Decl", Field, 0, ""},
-		{"Type.Doc", Field, 0, ""},
-		{"Type.Examples", Field, 14, ""},
-		{"Type.Funcs", Field, 0, ""},
-		{"Type.Methods", Field, 0, ""},
-		{"Type.Name", Field, 0, ""},
-		{"Type.Vars", Field, 0, ""},
-		{"Value", Type, 0, ""},
-		{"Value.Decl", Field, 0, ""},
-		{"Value.Doc", Field, 0, ""},
-		{"Value.Names", Field, 0, ""},
-	},
-	"go/doc/comment": {
-		{"(*DocLink).DefaultURL", Method, 19, ""},
-		{"(*Heading).DefaultID", Method, 19, ""},
-		{"(*List).BlankBefore", Method, 19, ""},
-		{"(*List).BlankBetween", Method, 19, ""},
-		{"(*Parser).Parse", Method, 19, ""},
-		{"(*Printer).Comment", Method, 19, ""},
-		{"(*Printer).HTML", Method, 19, ""},
-		{"(*Printer).Markdown", Method, 19, ""},
-		{"(*Printer).Text", Method, 19, ""},
-		{"Code", Type, 19, ""},
-		{"Code.Text", Field, 19, ""},
-		{"DefaultLookupPackage", Func, 19, "func(name string) (importPath string, ok bool)"},
-		{"Doc", Type, 19, ""},
-		{"Doc.Content", Field, 19, ""},
-		{"Doc.Links", Field, 19, ""},
-		{"DocLink", Type, 19, ""},
-		{"DocLink.ImportPath", Field, 19, ""},
-		{"DocLink.Name", Field, 19, ""},
-		{"DocLink.Recv", Field, 19, ""},
-		{"DocLink.Text", Field, 19, ""},
-		{"Heading", Type, 19, ""},
-		{"Heading.Text", Field, 19, ""},
-		{"Italic", Type, 19, ""},
-		{"Link", Type, 19, ""},
-		{"Link.Auto", Field, 19, ""},
-		{"Link.Text", Field, 19, ""},
-		{"Link.URL", Field, 19, ""},
-		{"LinkDef", Type, 19, ""},
-		{"LinkDef.Text", Field, 19, ""},
-		{"LinkDef.URL", Field, 19, ""},
-		{"LinkDef.Used", Field, 19, ""},
-		{"List", Type, 19, ""},
-		{"List.ForceBlankBefore", Field, 19, ""},
-		{"List.ForceBlankBetween", Field, 19, ""},
-		{"List.Items", Field, 19, ""},
-		{"ListItem", Type, 19, ""},
-		{"ListItem.Content", Field, 19, ""},
-		{"ListItem.Number", Field, 19, ""},
-		{"Paragraph", Type, 19, ""},
-		{"Paragraph.Text", Field, 19, ""},
-		{"Parser", Type, 19, ""},
-		{"Parser.LookupPackage", Field, 19, ""},
-		{"Parser.LookupSym", Field, 19, ""},
-		{"Parser.Words", Field, 19, ""},
-		{"Plain", Type, 19, ""},
-		{"Printer", Type, 19, ""},
-		{"Printer.DocLinkBaseURL", Field, 19, ""},
-		{"Printer.DocLinkURL", Field, 19, ""},
-		{"Printer.HeadingID", Field, 19, ""},
-		{"Printer.HeadingLevel", Field, 19, ""},
-		{"Printer.TextCodePrefix", Field, 19, ""},
-		{"Printer.TextPrefix", Field, 19, ""},
-		{"Printer.TextWidth", Field, 19, ""},
-	},
-	"go/format": {
-		{"Node", Func, 1, "func(dst io.Writer, fset *token.FileSet, node any) error"},
-		{"Source", Func, 1, "func(src []byte) ([]byte, error)"},
-	},
-	"go/importer": {
-		{"Default", Func, 5, "func() types.Importer"},
-		{"For", Func, 5, "func(compiler string, lookup Lookup) types.Importer"},
-		{"ForCompiler", Func, 12, "func(fset *token.FileSet, compiler string, lookup Lookup) types.Importer"},
-		{"Lookup", Type, 5, ""},
-	},
-	"go/parser": {
-		{"AllErrors", Const, 1, ""},
-		{"DeclarationErrors", Const, 0, ""},
-		{"ImportsOnly", Const, 0, ""},
-		{"Mode", Type, 0, ""},
-		{"PackageClauseOnly", Const, 0, ""},
-		{"ParseComments", Const, 0, ""},
-		{"ParseDir", Func, 0, "func(fset *token.FileSet, path string, filter func(fs.FileInfo) bool, mode Mode) (pkgs map[string]*ast.Package, first error)"},
-		{"ParseExpr", Func, 0, "func(x string) (ast.Expr, error)"},
-		{"ParseExprFrom", Func, 5, "func(fset *token.FileSet, filename string, src any, mode Mode) (expr ast.Expr, err error)"},
-		{"ParseFile", Func, 0, "func(fset *token.FileSet, filename string, src any, mode Mode) (f *ast.File, err error)"},
-		{"SkipObjectResolution", Const, 17, ""},
-		{"SpuriousErrors", Const, 0, ""},
-		{"Trace", Const, 0, ""},
-	},
-	"go/printer": {
-		{"(*Config).Fprint", Method, 0, ""},
-		{"CommentedNode", Type, 0, ""},
-		{"CommentedNode.Comments", Field, 0, ""},
-		{"CommentedNode.Node", Field, 0, ""},
-		{"Config", Type, 0, ""},
-		{"Config.Indent", Field, 1, ""},
-		{"Config.Mode", Field, 0, ""},
-		{"Config.Tabwidth", Field, 0, ""},
-		{"Fprint", Func, 0, "func(output io.Writer, fset *token.FileSet, node any) error"},
-		{"Mode", Type, 0, ""},
-		{"RawFormat", Const, 0, ""},
-		{"SourcePos", Const, 0, ""},
-		{"TabIndent", Const, 0, ""},
-		{"UseSpaces", Const, 0, ""},
-	},
-	"go/scanner": {
-		{"(*ErrorList).Add", Method, 0, ""},
-		{"(*ErrorList).RemoveMultiples", Method, 0, ""},
-		{"(*ErrorList).Reset", Method, 0, ""},
-		{"(*Scanner).Init", Method, 0, ""},
-		{"(*Scanner).Scan", Method, 0, ""},
-		{"(Error).Error", Method, 0, ""},
-		{"(ErrorList).Err", Method, 0, ""},
-		{"(ErrorList).Error", Method, 0, ""},
-		{"(ErrorList).Len", Method, 0, ""},
-		{"(ErrorList).Less", Method, 0, ""},
-		{"(ErrorList).Sort", Method, 0, ""},
-		{"(ErrorList).Swap", Method, 0, ""},
-		{"Error", Type, 0, ""},
-		{"Error.Msg", Field, 0, ""},
-		{"Error.Pos", Field, 0, ""},
-		{"ErrorHandler", Type, 0, ""},
-		{"ErrorList", Type, 0, ""},
-		{"Mode", Type, 0, ""},
-		{"PrintError", Func, 0, "func(w io.Writer, err error)"},
-		{"ScanComments", Const, 0, ""},
-		{"Scanner", Type, 0, ""},
-		{"Scanner.ErrorCount", Field, 0, ""},
-	},
-	"go/token": {
-		{"(*File).AddLine", Method, 0, ""},
-		{"(*File).AddLineColumnInfo", Method, 11, ""},
-		{"(*File).AddLineInfo", Method, 0, ""},
-		{"(*File).Base", Method, 0, ""},
-		{"(*File).End", Method, 26, ""},
-		{"(*File).Line", Method, 0, ""},
-		{"(*File).LineCount", Method, 0, ""},
-		{"(*File).LineStart", Method, 12, ""},
-		{"(*File).Lines", Method, 21, ""},
-		{"(*File).MergeLine", Method, 2, ""},
-		{"(*File).Name", Method, 0, ""},
-		{"(*File).Offset", Method, 0, ""},
-		{"(*File).Pos", Method, 0, ""},
-		{"(*File).Position", Method, 0, ""},
-		{"(*File).PositionFor", Method, 4, ""},
-		{"(*File).SetLines", Method, 0, ""},
-		{"(*File).SetLinesForContent", Method, 0, ""},
-		{"(*File).Size", Method, 0, ""},
-		{"(*FileSet).AddExistingFiles", Method, 25, ""},
-		{"(*FileSet).AddFile", Method, 0, ""},
-		{"(*FileSet).Base", Method, 0, ""},
-		{"(*FileSet).File", Method, 0, ""},
-		{"(*FileSet).Iterate", Method, 0, ""},
-		{"(*FileSet).Position", Method, 0, ""},
-		{"(*FileSet).PositionFor", Method, 4, ""},
-		{"(*FileSet).Read", Method, 0, ""},
-		{"(*FileSet).RemoveFile", Method, 20, ""},
-		{"(*FileSet).Write", Method, 0, ""},
-		{"(*Position).IsValid", Method, 0, ""},
-		{"(Pos).IsValid", Method, 0, ""},
-		{"(Position).String", Method, 0, ""},
-		{"(Token).IsKeyword", Method, 0, ""},
-		{"(Token).IsLiteral", Method, 0, ""},
-		{"(Token).IsOperator", Method, 0, ""},
-		{"(Token).Precedence", Method, 0, ""},
-		{"(Token).String", Method, 0, ""},
-		{"ADD", Const, 0, ""},
-		{"ADD_ASSIGN", Const, 0, ""},
-		{"AND", Const, 0, ""},
-		{"AND_ASSIGN", Const, 0, ""},
-		{"AND_NOT", Const, 0, ""},
-		{"AND_NOT_ASSIGN", Const, 0, ""},
-		{"ARROW", Const, 0, ""},
-		{"ASSIGN", Const, 0, ""},
-		{"BREAK", Const, 0, ""},
-		{"CASE", Const, 0, ""},
-		{"CHAN", Const, 0, ""},
-		{"CHAR", Const, 0, ""},
-		{"COLON", Const, 0, ""},
-		{"COMMA", Const, 0, ""},
-		{"COMMENT", Const, 0, ""},
-		{"CONST", Const, 0, ""},
-		{"CONTINUE", Const, 0, ""},
-		{"DEC", Const, 0, ""},
-		{"DEFAULT", Const, 0, ""},
-		{"DEFER", Const, 0, ""},
-		{"DEFINE", Const, 0, ""},
-		{"ELLIPSIS", Const, 0, ""},
-		{"ELSE", Const, 0, ""},
-		{"EOF", Const, 0, ""},
-		{"EQL", Const, 0, ""},
-		{"FALLTHROUGH", Const, 0, ""},
-		{"FLOAT", Const, 0, ""},
-		{"FOR", Const, 0, ""},
-		{"FUNC", Const, 0, ""},
-		{"File", Type, 0, ""},
-		{"FileSet", Type, 0, ""},
-		{"GEQ", Const, 0, ""},
-		{"GO", Const, 0, ""},
-		{"GOTO", Const, 0, ""},
-		{"GTR", Const, 0, ""},
-		{"HighestPrec", Const, 0, ""},
-		{"IDENT", Const, 0, ""},
-		{"IF", Const, 0, ""},
-		{"ILLEGAL", Const, 0, ""},
-		{"IMAG", Const, 0, ""},
-		{"IMPORT", Const, 0, ""},
-		{"INC", Const, 0, ""},
-		{"INT", Const, 0, ""},
-		{"INTERFACE", Const, 0, ""},
-		{"IsExported", Func, 13, "func(name string) bool"},
-		{"IsIdentifier", Func, 13, "func(name string) bool"},
-		{"IsKeyword", Func, 13, "func(name string) bool"},
-		{"LAND", Const, 0, ""},
-		{"LBRACE", Const, 0, ""},
-		{"LBRACK", Const, 0, ""},
-		{"LEQ", Const, 0, ""},
-		{"LOR", Const, 0, ""},
-		{"LPAREN", Const, 0, ""},
-		{"LSS", Const, 0, ""},
-		{"Lookup", Func, 0, "func(ident string) Token"},
-		{"LowestPrec", Const, 0, ""},
-		{"MAP", Const, 0, ""},
-		{"MUL", Const, 0, ""},
-		{"MUL_ASSIGN", Const, 0, ""},
-		{"NEQ", Const, 0, ""},
-		{"NOT", Const, 0, ""},
-		{"NewFileSet", Func, 0, "func() *FileSet"},
-		{"NoPos", Const, 0, ""},
-		{"OR", Const, 0, ""},
-		{"OR_ASSIGN", Const, 0, ""},
-		{"PACKAGE", Const, 0, ""},
-		{"PERIOD", Const, 0, ""},
-		{"Pos", Type, 0, ""},
-		{"Position", Type, 0, ""},
-		{"Position.Column", Field, 0, ""},
-		{"Position.Filename", Field, 0, ""},
-		{"Position.Line", Field, 0, ""},
-		{"Position.Offset", Field, 0, ""},
-		{"QUO", Const, 0, ""},
-		{"QUO_ASSIGN", Const, 0, ""},
-		{"RANGE", Const, 0, ""},
-		{"RBRACE", Const, 0, ""},
-		{"RBRACK", Const, 0, ""},
-		{"REM", Const, 0, ""},
-		{"REM_ASSIGN", Const, 0, ""},
-		{"RETURN", Const, 0, ""},
-		{"RPAREN", Const, 0, ""},
-		{"SELECT", Const, 0, ""},
-		{"SEMICOLON", Const, 0, ""},
-		{"SHL", Const, 0, ""},
-		{"SHL_ASSIGN", Const, 0, ""},
-		{"SHR", Const, 0, ""},
-		{"SHR_ASSIGN", Const, 0, ""},
-		{"STRING", Const, 0, ""},
-		{"STRUCT", Const, 0, ""},
-		{"SUB", Const, 0, ""},
-		{"SUB_ASSIGN", Const, 0, ""},
-		{"SWITCH", Const, 0, ""},
-		{"TILDE", Const, 18, ""},
-		{"TYPE", Const, 0, ""},
-		{"Token", Type, 0, ""},
-		{"UnaryPrec", Const, 0, ""},
-		{"VAR", Const, 0, ""},
-		{"XOR", Const, 0, ""},
-		{"XOR_ASSIGN", Const, 0, ""},
-	},
-	"go/types": {
-		{"(*Alias).Obj", Method, 22, ""},
-		{"(*Alias).Origin", Method, 23, ""},
-		{"(*Alias).Rhs", Method, 23, ""},
-		{"(*Alias).SetTypeParams", Method, 23, ""},
-		{"(*Alias).String", Method, 22, ""},
-		{"(*Alias).TypeArgs", Method, 23, ""},
-		{"(*Alias).TypeParams", Method, 23, ""},
-		{"(*Alias).Underlying", Method, 22, ""},
-		{"(*ArgumentError).Error", Method, 18, ""},
-		{"(*ArgumentError).Unwrap", Method, 18, ""},
-		{"(*Array).Elem", Method, 5, ""},
-		{"(*Array).Len", Method, 5, ""},
-		{"(*Array).String", Method, 5, ""},
-		{"(*Array).Underlying", Method, 5, ""},
-		{"(*Basic).Info", Method, 5, ""},
-		{"(*Basic).Kind", Method, 5, ""},
-		{"(*Basic).Name", Method, 5, ""},
-		{"(*Basic).String", Method, 5, ""},
-		{"(*Basic).Underlying", Method, 5, ""},
-		{"(*Builtin).Exported", Method, 5, ""},
-		{"(*Builtin).Id", Method, 5, ""},
-		{"(*Builtin).Name", Method, 5, ""},
-		{"(*Builtin).Parent", Method, 5, ""},
-		{"(*Builtin).Pkg", Method, 5, ""},
-		{"(*Builtin).Pos", Method, 5, ""},
-		{"(*Builtin).String", Method, 5, ""},
-		{"(*Builtin).Type", Method, 5, ""},
-		{"(*Chan).Dir", Method, 5, ""},
-		{"(*Chan).Elem", Method, 5, ""},
-		{"(*Chan).String", Method, 5, ""},
-		{"(*Chan).Underlying", Method, 5, ""},
-		{"(*Checker).Files", Method, 5, ""},
-		{"(*Config).Check", Method, 5, ""},
-		{"(*Const).Exported", Method, 5, ""},
-		{"(*Const).Id", Method, 5, ""},
-		{"(*Const).Name", Method, 5, ""},
-		{"(*Const).Parent", Method, 5, ""},
-		{"(*Const).Pkg", Method, 5, ""},
-		{"(*Const).Pos", Method, 5, ""},
-		{"(*Const).String", Method, 5, ""},
-		{"(*Const).Type", Method, 5, ""},
-		{"(*Const).Val", Method, 5, ""},
-		{"(*Func).Exported", Method, 5, ""},
-		{"(*Func).FullName", Method, 5, ""},
-		{"(*Func).Id", Method, 5, ""},
-		{"(*Func).Name", Method, 5, ""},
-		{"(*Func).Origin", Method, 19, ""},
-		{"(*Func).Parent", Method, 5, ""},
-		{"(*Func).Pkg", Method, 5, ""},
-		{"(*Func).Pos", Method, 5, ""},
-		{"(*Func).Scope", Method, 5, ""},
-		{"(*Func).Signature", Method, 23, ""},
-		{"(*Func).String", Method, 5, ""},
-		{"(*Func).Type", Method, 5, ""},
-		{"(*Info).ObjectOf", Method, 5, ""},
-		{"(*Info).PkgNameOf", Method, 22, ""},
-		{"(*Info).TypeOf", Method, 5, ""},
-		{"(*Initializer).String", Method, 5, ""},
-		{"(*Interface).Complete", Method, 5, ""},
-		{"(*Interface).Embedded", Method, 5, ""},
-		{"(*Interface).EmbeddedType", Method, 11, ""},
-		{"(*Interface).EmbeddedTypes", Method, 24, ""},
-		{"(*Interface).Empty", Method, 5, ""},
-		{"(*Interface).ExplicitMethod", Method, 5, ""},
-		{"(*Interface).ExplicitMethods", Method, 24, ""},
-		{"(*Interface).IsComparable", Method, 18, ""},
-		{"(*Interface).IsImplicit", Method, 18, ""},
-		{"(*Interface).IsMethodSet", Method, 18, ""},
-		{"(*Interface).MarkImplicit", Method, 18, ""},
-		{"(*Interface).Method", Method, 5, ""},
-		{"(*Interface).Methods", Method, 24, ""},
-		{"(*Interface).NumEmbeddeds", Method, 5, ""},
-		{"(*Interface).NumExplicitMethods", Method, 5, ""},
-		{"(*Interface).NumMethods", Method, 5, ""},
-		{"(*Interface).String", Method, 5, ""},
-		{"(*Interface).Underlying", Method, 5, ""},
-		{"(*Label).Exported", Method, 5, ""},
-		{"(*Label).Id", Method, 5, ""},
-		{"(*Label).Name", Method, 5, ""},
-		{"(*Label).Parent", Method, 5, ""},
-		{"(*Label).Pkg", Method, 5, ""},
-		{"(*Label).Pos", Method, 5, ""},
-		{"(*Label).String", Method, 5, ""},
-		{"(*Label).Type", Method, 5, ""},
-		{"(*Map).Elem", Method, 5, ""},
-		{"(*Map).Key", Method, 5, ""},
-		{"(*Map).String", Method, 5, ""},
-		{"(*Map).Underlying", Method, 5, ""},
-		{"(*MethodSet).At", Method, 5, ""},
-		{"(*MethodSet).Len", Method, 5, ""},
-		{"(*MethodSet).Lookup", Method, 5, ""},
-		{"(*MethodSet).Methods", Method, 24, ""},
-		{"(*MethodSet).String", Method, 5, ""},
-		{"(*Named).AddMethod", Method, 5, ""},
-		{"(*Named).Method", Method, 5, ""},
-		{"(*Named).Methods", Method, 24, ""},
-		{"(*Named).NumMethods", Method, 5, ""},
-		{"(*Named).Obj", Method, 5, ""},
-		{"(*Named).Origin", Method, 18, ""},
-		{"(*Named).SetTypeParams", Method, 18, ""},
-		{"(*Named).SetUnderlying", Method, 5, ""},
-		{"(*Named).String", Method, 5, ""},
-		{"(*Named).TypeArgs", Method, 18, ""},
-		{"(*Named).TypeParams", Method, 18, ""},
-		{"(*Named).Underlying", Method, 5, ""},
-		{"(*Nil).Exported", Method, 5, ""},
-		{"(*Nil).Id", Method, 5, ""},
-		{"(*Nil).Name", Method, 5, ""},
-		{"(*Nil).Parent", Method, 5, ""},
-		{"(*Nil).Pkg", Method, 5, ""},
-		{"(*Nil).Pos", Method, 5, ""},
-		{"(*Nil).String", Method, 5, ""},
-		{"(*Nil).Type", Method, 5, ""},
-		{"(*Package).Complete", Method, 5, ""},
-		{"(*Package).GoVersion", Method, 21, ""},
-		{"(*Package).Imports", Method, 5, ""},
-		{"(*Package).MarkComplete", Method, 5, ""},
-		{"(*Package).Name", Method, 5, ""},
-		{"(*Package).Path", Method, 5, ""},
-		{"(*Package).Scope", Method, 5, ""},
-		{"(*Package).SetImports", Method, 5, ""},
-		{"(*Package).SetName", Method, 6, ""},
-		{"(*Package).String", Method, 5, ""},
-		{"(*PkgName).Exported", Method, 5, ""},
-		{"(*PkgName).Id", Method, 5, ""},
-		{"(*PkgName).Imported", Method, 5, ""},
-		{"(*PkgName).Name", Method, 5, ""},
-		{"(*PkgName).Parent", Method, 5, ""},
-		{"(*PkgName).Pkg", Method, 5, ""},
-		{"(*PkgName).Pos", Method, 5, ""},
-		{"(*PkgName).String", Method, 5, ""},
-		{"(*PkgName).Type", Method, 5, ""},
-		{"(*Pointer).Elem", Method, 5, ""},
-		{"(*Pointer).String", Method, 5, ""},
-		{"(*Pointer).Underlying", Method, 5, ""},
-		{"(*Scope).Child", Method, 5, ""},
-		{"(*Scope).Children", Method, 24, ""},
-		{"(*Scope).Contains", Method, 5, ""},
-		{"(*Scope).End", Method, 5, ""},
-		{"(*Scope).Innermost", Method, 5, ""},
-		{"(*Scope).Insert", Method, 5, ""},
-		{"(*Scope).Len", Method, 5, ""},
-		{"(*Scope).Lookup", Method, 5, ""},
-		{"(*Scope).LookupParent", Method, 5, ""},
-		{"(*Scope).Names", Method, 5, ""},
-		{"(*Scope).NumChildren", Method, 5, ""},
-		{"(*Scope).Parent", Method, 5, ""},
-		{"(*Scope).Pos", Method, 5, ""},
-		{"(*Scope).String", Method, 5, ""},
-		{"(*Scope).WriteTo", Method, 5, ""},
-		{"(*Selection).Index", Method, 5, ""},
-		{"(*Selection).Indirect", Method, 5, ""},
-		{"(*Selection).Kind", Method, 5, ""},
-		{"(*Selection).Obj", Method, 5, ""},
-		{"(*Selection).Recv", Method, 5, ""},
-		{"(*Selection).String", Method, 5, ""},
-		{"(*Selection).Type", Method, 5, ""},
-		{"(*Signature).Params", Method, 5, ""},
-		{"(*Signature).Recv", Method, 5, ""},
-		{"(*Signature).RecvTypeParams", Method, 18, ""},
-		{"(*Signature).Results", Method, 5, ""},
-		{"(*Signature).String", Method, 5, ""},
-		{"(*Signature).TypeParams", Method, 18, ""},
-		{"(*Signature).Underlying", Method, 5, ""},
-		{"(*Signature).Variadic", Method, 5, ""},
-		{"(*Slice).Elem", Method, 5, ""},
-		{"(*Slice).String", Method, 5, ""},
-		{"(*Slice).Underlying", Method, 5, ""},
-		{"(*StdSizes).Alignof", Method, 5, ""},
-		{"(*StdSizes).Offsetsof", Method, 5, ""},
-		{"(*StdSizes).Sizeof", Method, 5, ""},
-		{"(*Struct).Field", Method, 5, ""},
-		{"(*Struct).Fields", Method, 24, ""},
-		{"(*Struct).NumFields", Method, 5, ""},
-		{"(*Struct).String", Method, 5, ""},
-		{"(*Struct).Tag", Method, 5, ""},
-		{"(*Struct).Underlying", Method, 5, ""},
-		{"(*Term).String", Method, 18, ""},
-		{"(*Term).Tilde", Method, 18, ""},
-		{"(*Term).Type", Method, 18, ""},
-		{"(*Tuple).At", Method, 5, ""},
-		{"(*Tuple).Len", Method, 5, ""},
-		{"(*Tuple).String", Method, 5, ""},
-		{"(*Tuple).Underlying", Method, 5, ""},
-		{"(*Tuple).Variables", Method, 24, ""},
-		{"(*TypeList).At", Method, 18, ""},
-		{"(*TypeList).Len", Method, 18, ""},
-		{"(*TypeList).Types", Method, 24, ""},
-		{"(*TypeName).Exported", Method, 5, ""},
-		{"(*TypeName).Id", Method, 5, ""},
-		{"(*TypeName).IsAlias", Method, 9, ""},
-		{"(*TypeName).Name", Method, 5, ""},
-		{"(*TypeName).Parent", Method, 5, ""},
-		{"(*TypeName).Pkg", Method, 5, ""},
-		{"(*TypeName).Pos", Method, 5, ""},
-		{"(*TypeName).String", Method, 5, ""},
-		{"(*TypeName).Type", Method, 5, ""},
-		{"(*TypeParam).Constraint", Method, 18, ""},
-		{"(*TypeParam).Index", Method, 18, ""},
-		{"(*TypeParam).Obj", Method, 18, ""},
-		{"(*TypeParam).SetConstraint", Method, 18, ""},
-		{"(*TypeParam).String", Method, 18, ""},
-		{"(*TypeParam).Underlying", Method, 18, ""},
-		{"(*TypeParamList).At", Method, 18, ""},
-		{"(*TypeParamList).Len", Method, 18, ""},
-		{"(*TypeParamList).TypeParams", Method, 24, ""},
-		{"(*Union).Len", Method, 18, ""},
-		{"(*Union).String", Method, 18, ""},
-		{"(*Union).Term", Method, 18, ""},
-		{"(*Union).Terms", Method, 24, ""},
-		{"(*Union).Underlying", Method, 18, ""},
-		{"(*Var).Anonymous", Method, 5, ""},
-		{"(*Var).Embedded", Method, 11, ""},
-		{"(*Var).Exported", Method, 5, ""},
-		{"(*Var).Id", Method, 5, ""},
-		{"(*Var).IsField", Method, 5, ""},
-		{"(*Var).Kind", Method, 25, ""},
-		{"(*Var).Name", Method, 5, ""},
-		{"(*Var).Origin", Method, 19, ""},
-		{"(*Var).Parent", Method, 5, ""},
-		{"(*Var).Pkg", Method, 5, ""},
-		{"(*Var).Pos", Method, 5, ""},
-		{"(*Var).SetKind", Method, 25, ""},
-		{"(*Var).String", Method, 5, ""},
-		{"(*Var).Type", Method, 5, ""},
-		{"(Checker).ObjectOf", Method, 5, ""},
-		{"(Checker).PkgNameOf", Method, 22, ""},
-		{"(Checker).TypeOf", Method, 5, ""},
-		{"(Error).Error", Method, 5, ""},
-		{"(Importer).Import", Method, 5, ""},
-		{"(ImporterFrom).Import", Method, 6, ""},
-		{"(ImporterFrom).ImportFrom", Method, 6, ""},
-		{"(Object).Exported", Method, 5, ""},
-		{"(Object).Id", Method, 5, ""},
-		{"(Object).Name", Method, 5, ""},
-		{"(Object).Parent", Method, 5, ""},
-		{"(Object).Pkg", Method, 5, ""},
-		{"(Object).Pos", Method, 5, ""},
-		{"(Object).String", Method, 5, ""},
-		{"(Object).Type", Method, 5, ""},
-		{"(Sizes).Alignof", Method, 5, ""},
-		{"(Sizes).Offsetsof", Method, 5, ""},
-		{"(Sizes).Sizeof", Method, 5, ""},
-		{"(Type).String", Method, 5, ""},
-		{"(Type).Underlying", Method, 5, ""},
-		{"(TypeAndValue).Addressable", Method, 5, ""},
-		{"(TypeAndValue).Assignable", Method, 5, ""},
-		{"(TypeAndValue).HasOk", Method, 5, ""},
-		{"(TypeAndValue).IsBuiltin", Method, 5, ""},
-		{"(TypeAndValue).IsNil", Method, 5, ""},
-		{"(TypeAndValue).IsType", Method, 5, ""},
-		{"(TypeAndValue).IsValue", Method, 5, ""},
-		{"(TypeAndValue).IsVoid", Method, 5, ""},
-		{"(VarKind).String", Method, 25, ""},
-		{"Alias", Type, 22, ""},
-		{"ArgumentError", Type, 18, ""},
-		{"ArgumentError.Err", Field, 18, ""},
-		{"ArgumentError.Index", Field, 18, ""},
-		{"Array", Type, 5, ""},
-		{"AssertableTo", Func, 5, "func(V *Interface, T Type) bool"},
-		{"AssignableTo", Func, 5, "func(V Type, T Type) bool"},
-		{"Basic", Type, 5, ""},
-		{"BasicInfo", Type, 5, ""},
-		{"BasicKind", Type, 5, ""},
-		{"Bool", Const, 5, ""},
-		{"Builtin", Type, 5, ""},
-		{"Byte", Const, 5, ""},
-		{"Chan", Type, 5, ""},
-		{"ChanDir", Type, 5, ""},
-		{"CheckExpr", Func, 13, "func(fset *token.FileSet, pkg *Package, pos token.Pos, expr ast.Expr, info *Info) (err error)"},
-		{"Checker", Type, 5, ""},
-		{"Checker.Info", Field, 5, ""},
-		{"Comparable", Func, 5, "func(T Type) bool"},
-		{"Complex128", Const, 5, ""},
-		{"Complex64", Const, 5, ""},
-		{"Config", Type, 5, ""},
-		{"Config.Context", Field, 18, ""},
-		{"Config.DisableUnusedImportCheck", Field, 5, ""},
-		{"Config.Error", Field, 5, ""},
-		{"Config.FakeImportC", Field, 5, ""},
-		{"Config.GoVersion", Field, 18, ""},
-		{"Config.IgnoreFuncBodies", Field, 5, ""},
-		{"Config.Importer", Field, 5, ""},
-		{"Config.Sizes", Field, 5, ""},
-		{"Const", Type, 5, ""},
-		{"Context", Type, 18, ""},
-		{"ConvertibleTo", Func, 5, "func(V Type, T Type) bool"},
-		{"DefPredeclaredTestFuncs", Func, 5, "func()"},
-		{"Default", Func, 8, "func(t Type) Type"},
-		{"Error", Type, 5, ""},
-		{"Error.Fset", Field, 5, ""},
-		{"Error.Msg", Field, 5, ""},
-		{"Error.Pos", Field, 5, ""},
-		{"Error.Soft", Field, 5, ""},
-		{"Eval", Func, 5, "func(fset *token.FileSet, pkg *Package, pos token.Pos, expr string) (_ TypeAndValue, err error)"},
-		{"ExprString", Func, 5, "func(x ast.Expr) string"},
-		{"FieldVal", Const, 5, ""},
-		{"FieldVar", Const, 25, ""},
-		{"Float32", Const, 5, ""},
-		{"Float64", Const, 5, ""},
-		{"Func", Type, 5, ""},
-		{"Id", Func, 5, "func(pkg *Package, name string) string"},
-		{"Identical", Func, 5, "func(x Type, y Type) bool"},
-		{"IdenticalIgnoreTags", Func, 8, "func(x Type, y Type) bool"},
-		{"Implements", Func, 5, "func(V Type, T *Interface) bool"},
-		{"ImportMode", Type, 6, ""},
-		{"Importer", Type, 5, ""},
-		{"ImporterFrom", Type, 6, ""},
-		{"Info", Type, 5, ""},
-		{"Info.Defs", Field, 5, ""},
-		{"Info.FileVersions", Field, 22, ""},
-		{"Info.Implicits", Field, 5, ""},
-		{"Info.InitOrder", Field, 5, ""},
-		{"Info.Instances", Field, 18, ""},
-		{"Info.Scopes", Field, 5, ""},
-		{"Info.Selections", Field, 5, ""},
-		{"Info.Types", Field, 5, ""},
-		{"Info.Uses", Field, 5, ""},
-		{"Initializer", Type, 5, ""},
-		{"Initializer.Lhs", Field, 5, ""},
-		{"Initializer.Rhs", Field, 5, ""},
-		{"Instance", Type, 18, ""},
-		{"Instance.Type", Field, 18, ""},
-		{"Instance.TypeArgs", Field, 18, ""},
-		{"Instantiate", Func, 18, "func(ctxt *Context, orig Type, targs []Type, validate bool) (Type, error)"},
-		{"Int", Const, 5, ""},
-		{"Int16", Const, 5, ""},
-		{"Int32", Const, 5, ""},
-		{"Int64", Const, 5, ""},
-		{"Int8", Const, 5, ""},
-		{"Interface", Type, 5, ""},
-		{"Invalid", Const, 5, ""},
-		{"IsBoolean", Const, 5, ""},
-		{"IsComplex", Const, 5, ""},
-		{"IsConstType", Const, 5, ""},
-		{"IsFloat", Const, 5, ""},
-		{"IsInteger", Const, 5, ""},
-		{"IsInterface", Func, 5, "func(t Type) bool"},
-		{"IsNumeric", Const, 5, ""},
-		{"IsOrdered", Const, 5, ""},
-		{"IsString", Const, 5, ""},
-		{"IsUnsigned", Const, 5, ""},
-		{"IsUntyped", Const, 5, ""},
-		{"Label", Type, 5, ""},
-		{"LocalVar", Const, 25, ""},
-		{"LookupFieldOrMethod", Func, 5, "func(T Type, addressable bool, pkg *Package, name string) (obj Object, index []int, indirect bool)"},
-		{"LookupSelection", Func, 25, "func(T Type, addressable bool, pkg *Package, name string) (Selection, bool)"},
-		{"Map", Type, 5, ""},
-		{"MethodExpr", Const, 5, ""},
-		{"MethodSet", Type, 5, ""},
-		{"MethodVal", Const, 5, ""},
-		{"MissingMethod", Func, 5, "func(V Type, T *Interface, static bool) (method *Func, wrongType bool)"},
-		{"Named", Type, 5, ""},
-		{"NewAlias", Func, 22, "func(obj *TypeName, rhs Type) *Alias"},
-		{"NewArray", Func, 5, "func(elem Type, len int64) *Array"},
-		{"NewChan", Func, 5, "func(dir ChanDir, elem Type) *Chan"},
-		{"NewChecker", Func, 5, "func(conf *Config, fset *token.FileSet, pkg *Package, info *Info) *Checker"},
-		{"NewConst", Func, 5, "func(pos token.Pos, pkg *Package, name string, typ Type, val constant.Value) *Const"},
-		{"NewContext", Func, 18, "func() *Context"},
-		{"NewField", Func, 5, "func(pos token.Pos, pkg *Package, name string, typ Type, embedded bool) *Var"},
-		{"NewFunc", Func, 5, "func(pos token.Pos, pkg *Package, name string, sig *Signature) *Func"},
-		{"NewInterface", Func, 5, "func(methods []*Func, embeddeds []*Named) *Interface"},
-		{"NewInterfaceType", Func, 11, "func(methods []*Func, embeddeds []Type) *Interface"},
-		{"NewLabel", Func, 5, "func(pos token.Pos, pkg *Package, name string) *Label"},
-		{"NewMap", Func, 5, "func(key Type, elem Type) *Map"},
-		{"NewMethodSet", Func, 5, "func(T Type) *MethodSet"},
-		{"NewNamed", Func, 5, "func(obj *TypeName, underlying Type, methods []*Func) *Named"},
-		{"NewPackage", Func, 5, "func(path string, name string) *Package"},
-		{"NewParam", Func, 5, "func(pos token.Pos, pkg *Package, name string, typ Type) *Var"},
-		{"NewPkgName", Func, 5, "func(pos token.Pos, pkg *Package, name string, imported *Package) *PkgName"},
-		{"NewPointer", Func, 5, "func(elem Type) *Pointer"},
-		{"NewScope", Func, 5, "func(parent *Scope, pos token.Pos, end token.Pos, comment string) *Scope"},
-		{"NewSignature", Func, 5, "func(recv *Var, params *Tuple, results *Tuple, variadic bool) *Signature"},
-		{"NewSignatureType", Func, 18, "func(recv *Var, recvTypeParams []*TypeParam, typeParams []*TypeParam, params *Tuple, results *Tuple, variadic bool) *Signature"},
-		{"NewSlice", Func, 5, "func(elem Type) *Slice"},
-		{"NewStruct", Func, 5, "func(fields []*Var, tags []string) *Struct"},
-		{"NewTerm", Func, 18, "func(tilde bool, typ Type) *Term"},
-		{"NewTuple", Func, 5, "func(x ...*Var) *Tuple"},
-		{"NewTypeName", Func, 5, "func(pos token.Pos, pkg *Package, name string, typ Type) *TypeName"},
-		{"NewTypeParam", Func, 18, "func(obj *TypeName, constraint Type) *TypeParam"},
-		{"NewUnion", Func, 18, "func(terms []*Term) *Union"},
-		{"NewVar", Func, 5, "func(pos token.Pos, pkg *Package, name string, typ Type) *Var"},
-		{"Nil", Type, 5, ""},
-		{"ObjectString", Func, 5, "func(obj Object, qf Qualifier) string"},
-		{"Package", Type, 5, ""},
-		{"PackageVar", Const, 25, ""},
-		{"ParamVar", Const, 25, ""},
-		{"PkgName", Type, 5, ""},
-		{"Pointer", Type, 5, ""},
-		{"Qualifier", Type, 5, ""},
-		{"RecvOnly", Const, 5, ""},
-		{"RecvVar", Const, 25, ""},
-		{"RelativeTo", Func, 5, "func(pkg *Package) Qualifier"},
-		{"ResultVar", Const, 25, ""},
-		{"Rune", Const, 5, ""},
-		{"Satisfies", Func, 20, "func(V Type, T *Interface) bool"},
-		{"Scope", Type, 5, ""},
-		{"Selection", Type, 5, ""},
-		{"SelectionKind", Type, 5, ""},
-		{"SelectionString", Func, 5, "func(s *Selection, qf Qualifier) string"},
-		{"SendOnly", Const, 5, ""},
-		{"SendRecv", Const, 5, ""},
-		{"Signature", Type, 5, ""},
-		{"Sizes", Type, 5, ""},
-		{"SizesFor", Func, 9, "func(compiler string, arch string) Sizes"},
-		{"Slice", Type, 5, ""},
-		{"StdSizes", Type, 5, ""},
-		{"StdSizes.MaxAlign", Field, 5, ""},
-		{"StdSizes.WordSize", Field, 5, ""},
-		{"String", Const, 5, ""},
-		{"Struct", Type, 5, ""},
-		{"Term", Type, 18, ""},
-		{"Tuple", Type, 5, ""},
-		{"Typ", Var, 5, ""},
-		{"Type", Type, 5, ""},
-		{"TypeAndValue", Type, 5, ""},
-		{"TypeAndValue.Type", Field, 5, ""},
-		{"TypeAndValue.Value", Field, 5, ""},
-		{"TypeList", Type, 18, ""},
-		{"TypeName", Type, 5, ""},
-		{"TypeParam", Type, 18, ""},
-		{"TypeParamList", Type, 18, ""},
-		{"TypeString", Func, 5, "func(typ Type, qf Qualifier) string"},
-		{"Uint", Const, 5, ""},
-		{"Uint16", Const, 5, ""},
-		{"Uint32", Const, 5, ""},
-		{"Uint64", Const, 5, ""},
-		{"Uint8", Const, 5, ""},
-		{"Uintptr", Const, 5, ""},
-		{"Unalias", Func, 22, "func(t Type) Type"},
-		{"Union", Type, 18, ""},
-		{"Universe", Var, 5, ""},
-		{"Unsafe", Var, 5, ""},
-		{"UnsafePointer", Const, 5, ""},
-		{"UntypedBool", Const, 5, ""},
-		{"UntypedComplex", Const, 5, ""},
-		{"UntypedFloat", Const, 5, ""},
-		{"UntypedInt", Const, 5, ""},
-		{"UntypedNil", Const, 5, ""},
-		{"UntypedRune", Const, 5, ""},
-		{"UntypedString", Const, 5, ""},
-		{"Var", Type, 5, ""},
-		{"VarKind", Type, 25, ""},
-		{"WriteExpr", Func, 5, "func(buf *bytes.Buffer, x ast.Expr)"},
-		{"WriteSignature", Func, 5, "func(buf *bytes.Buffer, sig *Signature, qf Qualifier)"},
-		{"WriteType", Func, 5, "func(buf *bytes.Buffer, typ Type, qf Qualifier)"},
-	},
-	"go/version": {
-		{"Compare", Func, 22, "func(x string, y string) int"},
-		{"IsValid", Func, 22, "func(x string) bool"},
-		{"Lang", Func, 22, "func(x string) string"},
-	},
-	"hash": {
-		{"(Cloner).BlockSize", Method, 25, ""},
-		{"(Cloner).Clone", Method, 25, ""},
-		{"(Cloner).Reset", Method, 25, ""},
-		{"(Cloner).Size", Method, 25, ""},
-		{"(Cloner).Sum", Method, 25, ""},
-		{"(Cloner).Write", Method, 25, ""},
-		{"(Hash).BlockSize", Method, 0, ""},
-		{"(Hash).Reset", Method, 0, ""},
-		{"(Hash).Size", Method, 0, ""},
-		{"(Hash).Sum", Method, 0, ""},
-		{"(Hash).Write", Method, 0, ""},
-		{"(Hash32).BlockSize", Method, 0, ""},
-		{"(Hash32).Reset", Method, 0, ""},
-		{"(Hash32).Size", Method, 0, ""},
-		{"(Hash32).Sum", Method, 0, ""},
-		{"(Hash32).Sum32", Method, 0, ""},
-		{"(Hash32).Write", Method, 0, ""},
-		{"(Hash64).BlockSize", Method, 0, ""},
-		{"(Hash64).Reset", Method, 0, ""},
-		{"(Hash64).Size", Method, 0, ""},
-		{"(Hash64).Sum", Method, 0, ""},
-		{"(Hash64).Sum64", Method, 0, ""},
-		{"(Hash64).Write", Method, 0, ""},
-		{"(XOF).BlockSize", Method, 25, ""},
-		{"(XOF).Read", Method, 25, ""},
-		{"(XOF).Reset", Method, 25, ""},
-		{"(XOF).Write", Method, 25, ""},
-		{"Cloner", Type, 25, ""},
-		{"Hash", Type, 0, ""},
-		{"Hash32", Type, 0, ""},
-		{"Hash64", Type, 0, ""},
-		{"XOF", Type, 25, ""},
-	},
-	"hash/adler32": {
-		{"Checksum", Func, 0, "func(data []byte) uint32"},
-		{"New", Func, 0, "func() hash.Hash32"},
-		{"Size", Const, 0, ""},
-	},
-	"hash/crc32": {
-		{"Castagnoli", Const, 0, ""},
-		{"Checksum", Func, 0, "func(data []byte, tab *Table) uint32"},
-		{"ChecksumIEEE", Func, 0, "func(data []byte) uint32"},
-		{"IEEE", Const, 0, ""},
-		{"IEEETable", Var, 0, ""},
-		{"Koopman", Const, 0, ""},
-		{"MakeTable", Func, 0, "func(poly uint32) *Table"},
-		{"New", Func, 0, "func(tab *Table) hash.Hash32"},
-		{"NewIEEE", Func, 0, "func() hash.Hash32"},
-		{"Size", Const, 0, ""},
-		{"Table", Type, 0, ""},
-		{"Update", Func, 0, "func(crc uint32, tab *Table, p []byte) uint32"},
-	},
-	"hash/crc64": {
-		{"Checksum", Func, 0, "func(data []byte, tab *Table) uint64"},
-		{"ECMA", Const, 0, ""},
-		{"ISO", Const, 0, ""},
-		{"MakeTable", Func, 0, "func(poly uint64) *Table"},
-		{"New", Func, 0, "func(tab *Table) hash.Hash64"},
-		{"Size", Const, 0, ""},
-		{"Table", Type, 0, ""},
-		{"Update", Func, 0, "func(crc uint64, tab *Table, p []byte) uint64"},
-	},
-	"hash/fnv": {
-		{"New128", Func, 9, "func() hash.Hash"},
-		{"New128a", Func, 9, "func() hash.Hash"},
-		{"New32", Func, 0, "func() hash.Hash32"},
-		{"New32a", Func, 0, "func() hash.Hash32"},
-		{"New64", Func, 0, "func() hash.Hash64"},
-		{"New64a", Func, 0, "func() hash.Hash64"},
-	},
-	"hash/maphash": {
-		{"(*Hash).BlockSize", Method, 14, ""},
-		{"(*Hash).Clone", Method, 25, ""},
-		{"(*Hash).Reset", Method, 14, ""},
-		{"(*Hash).Seed", Method, 14, ""},
-		{"(*Hash).SetSeed", Method, 14, ""},
-		{"(*Hash).Size", Method, 14, ""},
-		{"(*Hash).Sum", Method, 14, ""},
-		{"(*Hash).Sum64", Method, 14, ""},
-		{"(*Hash).Write", Method, 14, ""},
-		{"(*Hash).WriteByte", Method, 14, ""},
-		{"(*Hash).WriteString", Method, 14, ""},
-		{"Bytes", Func, 19, "func(seed Seed, b []byte) uint64"},
-		{"Comparable", Func, 24, "func[T comparable](seed Seed, v T) uint64"},
-		{"Hash", Type, 14, ""},
-		{"MakeSeed", Func, 14, "func() Seed"},
-		{"Seed", Type, 14, ""},
-		{"String", Func, 19, "func(seed Seed, s string) uint64"},
-		{"WriteComparable", Func, 24, "func[T comparable](h *Hash, x T)"},
-	},
-	"html": {
-		{"EscapeString", Func, 0, "func(s string) string"},
-		{"UnescapeString", Func, 0, "func(s string) string"},
-	},
-	"html/template": {
-		{"(*Error).Error", Method, 0, ""},
-		{"(*Template).AddParseTree", Method, 0, ""},
-		{"(*Template).Clone", Method, 0, ""},
-		{"(*Template).DefinedTemplates", Method, 6, ""},
-		{"(*Template).Delims", Method, 0, ""},
-		{"(*Template).Execute", Method, 0, ""},
-		{"(*Template).ExecuteTemplate", Method, 0, ""},
-		{"(*Template).Funcs", Method, 0, ""},
-		{"(*Template).Lookup", Method, 0, ""},
-		{"(*Template).Name", Method, 0, ""},
-		{"(*Template).New", Method, 0, ""},
-		{"(*Template).Option", Method, 5, ""},
-		{"(*Template).Parse", Method, 0, ""},
-		{"(*Template).ParseFS", Method, 16, ""},
-		{"(*Template).ParseFiles", Method, 0, ""},
-		{"(*Template).ParseGlob", Method, 0, ""},
-		{"(*Template).Templates", Method, 0, ""},
-		{"CSS", Type, 0, ""},
-		{"ErrAmbigContext", Const, 0, ""},
-		{"ErrBadHTML", Const, 0, ""},
-		{"ErrBranchEnd", Const, 0, ""},
-		{"ErrEndContext", Const, 0, ""},
-		{"ErrJSTemplate", Const, 21, ""},
-		{"ErrNoSuchTemplate", Const, 0, ""},
-		{"ErrOutputContext", Const, 0, ""},
-		{"ErrPartialCharset", Const, 0, ""},
-		{"ErrPartialEscape", Const, 0, ""},
-		{"ErrPredefinedEscaper", Const, 9, ""},
-		{"ErrRangeLoopReentry", Const, 0, ""},
-		{"ErrSlashAmbig", Const, 0, ""},
-		{"Error", Type, 0, ""},
-		{"Error.Description", Field, 0, ""},
-		{"Error.ErrorCode", Field, 0, ""},
-		{"Error.Line", Field, 0, ""},
-		{"Error.Name", Field, 0, ""},
-		{"Error.Node", Field, 4, ""},
-		{"ErrorCode", Type, 0, ""},
-		{"FuncMap", Type, 0, ""},
-		{"HTML", Type, 0, ""},
-		{"HTMLAttr", Type, 0, ""},
-		{"HTMLEscape", Func, 0, "func(w io.Writer, b []byte)"},
-		{"HTMLEscapeString", Func, 0, "func(s string) string"},
-		{"HTMLEscaper", Func, 0, "func(args ...any) string"},
-		{"IsTrue", Func, 6, "func(val any) (truth bool, ok bool)"},
-		{"JS", Type, 0, ""},
-		{"JSEscape", Func, 0, "func(w io.Writer, b []byte)"},
-		{"JSEscapeString", Func, 0, "func(s string) string"},
-		{"JSEscaper", Func, 0, "func(args ...any) string"},
-		{"JSStr", Type, 0, ""},
-		{"Must", Func, 0, "func(t *Template, err error) *Template"},
-		{"New", Func, 0, "func(name string) *Template"},
-		{"OK", Const, 0, ""},
-		{"ParseFS", Func, 16, "func(fs fs.FS, patterns ...string) (*Template, error)"},
-		{"ParseFiles", Func, 0, "func(filenames ...string) (*Template, error)"},
-		{"ParseGlob", Func, 0, "func(pattern string) (*Template, error)"},
-		{"Srcset", Type, 10, ""},
-		{"Template", Type, 0, ""},
-		{"Template.Tree", Field, 2, ""},
-		{"URL", Type, 0, ""},
-		{"URLQueryEscaper", Func, 0, "func(args ...any) string"},
-	},
-	"image": {
-		{"(*Alpha).AlphaAt", Method, 4, ""},
-		{"(*Alpha).At", Method, 0, ""},
-		{"(*Alpha).Bounds", Method, 0, ""},
-		{"(*Alpha).ColorModel", Method, 0, ""},
-		{"(*Alpha).Opaque", Method, 0, ""},
-		{"(*Alpha).PixOffset", Method, 0, ""},
-		{"(*Alpha).RGBA64At", Method, 17, ""},
-		{"(*Alpha).Set", Method, 0, ""},
-		{"(*Alpha).SetAlpha", Method, 0, ""},
-		{"(*Alpha).SetRGBA64", Method, 17, ""},
-		{"(*Alpha).SubImage", Method, 0, ""},
-		{"(*Alpha16).Alpha16At", Method, 4, ""},
-		{"(*Alpha16).At", Method, 0, ""},
-		{"(*Alpha16).Bounds", Method, 0, ""},
-		{"(*Alpha16).ColorModel", Method, 0, ""},
-		{"(*Alpha16).Opaque", Method, 0, ""},
-		{"(*Alpha16).PixOffset", Method, 0, ""},
-		{"(*Alpha16).RGBA64At", Method, 17, ""},
-		{"(*Alpha16).Set", Method, 0, ""},
-		{"(*Alpha16).SetAlpha16", Method, 0, ""},
-		{"(*Alpha16).SetRGBA64", Method, 17, ""},
-		{"(*Alpha16).SubImage", Method, 0, ""},
-		{"(*CMYK).At", Method, 5, ""},
-		{"(*CMYK).Bounds", Method, 5, ""},
-		{"(*CMYK).CMYKAt", Method, 5, ""},
-		{"(*CMYK).ColorModel", Method, 5, ""},
-		{"(*CMYK).Opaque", Method, 5, ""},
-		{"(*CMYK).PixOffset", Method, 5, ""},
-		{"(*CMYK).RGBA64At", Method, 17, ""},
-		{"(*CMYK).Set", Method, 5, ""},
-		{"(*CMYK).SetCMYK", Method, 5, ""},
-		{"(*CMYK).SetRGBA64", Method, 17, ""},
-		{"(*CMYK).SubImage", Method, 5, ""},
-		{"(*Gray).At", Method, 0, ""},
-		{"(*Gray).Bounds", Method, 0, ""},
-		{"(*Gray).ColorModel", Method, 0, ""},
-		{"(*Gray).GrayAt", Method, 4, ""},
-		{"(*Gray).Opaque", Method, 0, ""},
-		{"(*Gray).PixOffset", Method, 0, ""},
-		{"(*Gray).RGBA64At", Method, 17, ""},
-		{"(*Gray).Set", Method, 0, ""},
-		{"(*Gray).SetGray", Method, 0, ""},
-		{"(*Gray).SetRGBA64", Method, 17, ""},
-		{"(*Gray).SubImage", Method, 0, ""},
-		{"(*Gray16).At", Method, 0, ""},
-		{"(*Gray16).Bounds", Method, 0, ""},
-		{"(*Gray16).ColorModel", Method, 0, ""},
-		{"(*Gray16).Gray16At", Method, 4, ""},
-		{"(*Gray16).Opaque", Method, 0, ""},
-		{"(*Gray16).PixOffset", Method, 0, ""},
-		{"(*Gray16).RGBA64At", Method, 17, ""},
-		{"(*Gray16).Set", Method, 0, ""},
-		{"(*Gray16).SetGray16", Method, 0, ""},
-		{"(*Gray16).SetRGBA64", Method, 17, ""},
-		{"(*Gray16).SubImage", Method, 0, ""},
-		{"(*NRGBA).At", Method, 0, ""},
-		{"(*NRGBA).Bounds", Method, 0, ""},
-		{"(*NRGBA).ColorModel", Method, 0, ""},
-		{"(*NRGBA).NRGBAAt", Method, 4, ""},
-		{"(*NRGBA).Opaque", Method, 0, ""},
-		{"(*NRGBA).PixOffset", Method, 0, ""},
-		{"(*NRGBA).RGBA64At", Method, 17, ""},
-		{"(*NRGBA).Set", Method, 0, ""},
-		{"(*NRGBA).SetNRGBA", Method, 0, ""},
-		{"(*NRGBA).SetRGBA64", Method, 17, ""},
-		{"(*NRGBA).SubImage", Method, 0, ""},
-		{"(*NRGBA64).At", Method, 0, ""},
-		{"(*NRGBA64).Bounds", Method, 0, ""},
-		{"(*NRGBA64).ColorModel", Method, 0, ""},
-		{"(*NRGBA64).NRGBA64At", Method, 4, ""},
-		{"(*NRGBA64).Opaque", Method, 0, ""},
-		{"(*NRGBA64).PixOffset", Method, 0, ""},
-		{"(*NRGBA64).RGBA64At", Method, 17, ""},
-		{"(*NRGBA64).Set", Method, 0, ""},
-		{"(*NRGBA64).SetNRGBA64", Method, 0, ""},
-		{"(*NRGBA64).SetRGBA64", Method, 17, ""},
-		{"(*NRGBA64).SubImage", Method, 0, ""},
-		{"(*NYCbCrA).AOffset", Method, 6, ""},
-		{"(*NYCbCrA).At", Method, 6, ""},
-		{"(*NYCbCrA).Bounds", Method, 6, ""},
-		{"(*NYCbCrA).COffset", Method, 6, ""},
-		{"(*NYCbCrA).ColorModel", Method, 6, ""},
-		{"(*NYCbCrA).NYCbCrAAt", Method, 6, ""},
-		{"(*NYCbCrA).Opaque", Method, 6, ""},
-		{"(*NYCbCrA).RGBA64At", Method, 17, ""},
-		{"(*NYCbCrA).SubImage", Method, 6, ""},
-		{"(*NYCbCrA).YCbCrAt", Method, 6, ""},
-		{"(*NYCbCrA).YOffset", Method, 6, ""},
-		{"(*Paletted).At", Method, 0, ""},
-		{"(*Paletted).Bounds", Method, 0, ""},
-		{"(*Paletted).ColorIndexAt", Method, 0, ""},
-		{"(*Paletted).ColorModel", Method, 0, ""},
-		{"(*Paletted).Opaque", Method, 0, ""},
-		{"(*Paletted).PixOffset", Method, 0, ""},
-		{"(*Paletted).RGBA64At", Method, 17, ""},
-		{"(*Paletted).Set", Method, 0, ""},
-		{"(*Paletted).SetColorIndex", Method, 0, ""},
-		{"(*Paletted).SetRGBA64", Method, 17, ""},
-		{"(*Paletted).SubImage", Method, 0, ""},
-		{"(*RGBA).At", Method, 0, ""},
-		{"(*RGBA).Bounds", Method, 0, ""},
-		{"(*RGBA).ColorModel", Method, 0, ""},
-		{"(*RGBA).Opaque", Method, 0, ""},
-		{"(*RGBA).PixOffset", Method, 0, ""},
-		{"(*RGBA).RGBA64At", Method, 17, ""},
-		{"(*RGBA).RGBAAt", Method, 4, ""},
-		{"(*RGBA).Set", Method, 0, ""},
-		{"(*RGBA).SetRGBA", Method, 0, ""},
-		{"(*RGBA).SetRGBA64", Method, 17, ""},
-		{"(*RGBA).SubImage", Method, 0, ""},
-		{"(*RGBA64).At", Method, 0, ""},
-		{"(*RGBA64).Bounds", Method, 0, ""},
-		{"(*RGBA64).ColorModel", Method, 0, ""},
-		{"(*RGBA64).Opaque", Method, 0, ""},
-		{"(*RGBA64).PixOffset", Method, 0, ""},
-		{"(*RGBA64).RGBA64At", Method, 4, ""},
-		{"(*RGBA64).Set", Method, 0, ""},
-		{"(*RGBA64).SetRGBA64", Method, 0, ""},
-		{"(*RGBA64).SubImage", Method, 0, ""},
-		{"(*Uniform).At", Method, 0, ""},
-		{"(*Uniform).Bounds", Method, 0, ""},
-		{"(*Uniform).ColorModel", Method, 0, ""},
-		{"(*Uniform).Convert", Method, 0, ""},
-		{"(*Uniform).Opaque", Method, 0, ""},
-		{"(*Uniform).RGBA", Method, 0, ""},
-		{"(*Uniform).RGBA64At", Method, 17, ""},
-		{"(*YCbCr).At", Method, 0, ""},
-		{"(*YCbCr).Bounds", Method, 0, ""},
-		{"(*YCbCr).COffset", Method, 0, ""},
-		{"(*YCbCr).ColorModel", Method, 0, ""},
-		{"(*YCbCr).Opaque", Method, 0, ""},
-		{"(*YCbCr).RGBA64At", Method, 17, ""},
-		{"(*YCbCr).SubImage", Method, 0, ""},
-		{"(*YCbCr).YCbCrAt", Method, 4, ""},
-		{"(*YCbCr).YOffset", Method, 0, ""},
-		{"(Image).At", Method, 0, ""},
-		{"(Image).Bounds", Method, 0, ""},
-		{"(Image).ColorModel", Method, 0, ""},
-		{"(PalettedImage).At", Method, 0, ""},
-		{"(PalettedImage).Bounds", Method, 0, ""},
-		{"(PalettedImage).ColorIndexAt", Method, 0, ""},
-		{"(PalettedImage).ColorModel", Method, 0, ""},
-		{"(Point).Add", Method, 0, ""},
-		{"(Point).Div", Method, 0, ""},
-		{"(Point).Eq", Method, 0, ""},
-		{"(Point).In", Method, 0, ""},
-		{"(Point).Mod", Method, 0, ""},
-		{"(Point).Mul", Method, 0, ""},
-		{"(Point).String", Method, 0, ""},
-		{"(Point).Sub", Method, 0, ""},
-		{"(RGBA64Image).At", Method, 17, ""},
-		{"(RGBA64Image).Bounds", Method, 17, ""},
-		{"(RGBA64Image).ColorModel", Method, 17, ""},
-		{"(RGBA64Image).RGBA64At", Method, 17, ""},
-		{"(Rectangle).Add", Method, 0, ""},
-		{"(Rectangle).At", Method, 5, ""},
-		{"(Rectangle).Bounds", Method, 5, ""},
-		{"(Rectangle).Canon", Method, 0, ""},
-		{"(Rectangle).ColorModel", Method, 5, ""},
-		{"(Rectangle).Dx", Method, 0, ""},
-		{"(Rectangle).Dy", Method, 0, ""},
-		{"(Rectangle).Empty", Method, 0, ""},
-		{"(Rectangle).Eq", Method, 0, ""},
-		{"(Rectangle).In", Method, 0, ""},
-		{"(Rectangle).Inset", Method, 0, ""},
-		{"(Rectangle).Intersect", Method, 0, ""},
-		{"(Rectangle).Overlaps", Method, 0, ""},
-		{"(Rectangle).RGBA64At", Method, 17, ""},
-		{"(Rectangle).Size", Method, 0, ""},
-		{"(Rectangle).String", Method, 0, ""},
-		{"(Rectangle).Sub", Method, 0, ""},
-		{"(Rectangle).Union", Method, 0, ""},
-		{"(YCbCrSubsampleRatio).String", Method, 0, ""},
-		{"Alpha", Type, 0, ""},
-		{"Alpha.Pix", Field, 0, ""},
-		{"Alpha.Rect", Field, 0, ""},
-		{"Alpha.Stride", Field, 0, ""},
-		{"Alpha16", Type, 0, ""},
-		{"Alpha16.Pix", Field, 0, ""},
-		{"Alpha16.Rect", Field, 0, ""},
-		{"Alpha16.Stride", Field, 0, ""},
-		{"Black", Var, 0, ""},
-		{"CMYK", Type, 5, ""},
-		{"CMYK.Pix", Field, 5, ""},
-		{"CMYK.Rect", Field, 5, ""},
-		{"CMYK.Stride", Field, 5, ""},
-		{"Config", Type, 0, ""},
-		{"Config.ColorModel", Field, 0, ""},
-		{"Config.Height", Field, 0, ""},
-		{"Config.Width", Field, 0, ""},
-		{"Decode", Func, 0, "func(r io.Reader) (Image, string, error)"},
-		{"DecodeConfig", Func, 0, "func(r io.Reader) (Config, string, error)"},
-		{"ErrFormat", Var, 0, ""},
-		{"Gray", Type, 0, ""},
-		{"Gray.Pix", Field, 0, ""},
-		{"Gray.Rect", Field, 0, ""},
-		{"Gray.Stride", Field, 0, ""},
-		{"Gray16", Type, 0, ""},
-		{"Gray16.Pix", Field, 0, ""},
-		{"Gray16.Rect", Field, 0, ""},
-		{"Gray16.Stride", Field, 0, ""},
-		{"Image", Type, 0, ""},
-		{"NRGBA", Type, 0, ""},
-		{"NRGBA.Pix", Field, 0, ""},
-		{"NRGBA.Rect", Field, 0, ""},
-		{"NRGBA.Stride", Field, 0, ""},
-		{"NRGBA64", Type, 0, ""},
-		{"NRGBA64.Pix", Field, 0, ""},
-		{"NRGBA64.Rect", Field, 0, ""},
-		{"NRGBA64.Stride", Field, 0, ""},
-		{"NYCbCrA", Type, 6, ""},
-		{"NYCbCrA.A", Field, 6, ""},
-		{"NYCbCrA.AStride", Field, 6, ""},
-		{"NYCbCrA.YCbCr", Field, 6, ""},
-		{"NewAlpha", Func, 0, "func(r Rectangle) *Alpha"},
-		{"NewAlpha16", Func, 0, "func(r Rectangle) *Alpha16"},
-		{"NewCMYK", Func, 5, "func(r Rectangle) *CMYK"},
-		{"NewGray", Func, 0, "func(r Rectangle) *Gray"},
-		{"NewGray16", Func, 0, "func(r Rectangle) *Gray16"},
-		{"NewNRGBA", Func, 0, "func(r Rectangle) *NRGBA"},
-		{"NewNRGBA64", Func, 0, "func(r Rectangle) *NRGBA64"},
-		{"NewNYCbCrA", Func, 6, "func(r Rectangle, subsampleRatio YCbCrSubsampleRatio) *NYCbCrA"},
-		{"NewPaletted", Func, 0, "func(r Rectangle, p color.Palette) *Paletted"},
-		{"NewRGBA", Func, 0, "func(r Rectangle) *RGBA"},
-		{"NewRGBA64", Func, 0, "func(r Rectangle) *RGBA64"},
-		{"NewUniform", Func, 0, "func(c color.Color) *Uniform"},
-		{"NewYCbCr", Func, 0, "func(r Rectangle, subsampleRatio YCbCrSubsampleRatio) *YCbCr"},
-		{"Opaque", Var, 0, ""},
-		{"Paletted", Type, 0, ""},
-		{"Paletted.Palette", Field, 0, ""},
-		{"Paletted.Pix", Field, 0, ""},
-		{"Paletted.Rect", Field, 0, ""},
-		{"Paletted.Stride", Field, 0, ""},
-		{"PalettedImage", Type, 0, ""},
-		{"Point", Type, 0, ""},
-		{"Point.X", Field, 0, ""},
-		{"Point.Y", Field, 0, ""},
-		{"Pt", Func, 0, "func(X int, Y int) Point"},
-		{"RGBA", Type, 0, ""},
-		{"RGBA.Pix", Field, 0, ""},
-		{"RGBA.Rect", Field, 0, ""},
-		{"RGBA.Stride", Field, 0, ""},
-		{"RGBA64", Type, 0, ""},
-		{"RGBA64.Pix", Field, 0, ""},
-		{"RGBA64.Rect", Field, 0, ""},
-		{"RGBA64.Stride", Field, 0, ""},
-		{"RGBA64Image", Type, 17, ""},
-		{"Rect", Func, 0, "func(x0 int, y0 int, x1 int, y1 int) Rectangle"},
-		{"Rectangle", Type, 0, ""},
-		{"Rectangle.Max", Field, 0, ""},
-		{"Rectangle.Min", Field, 0, ""},
-		{"RegisterFormat", Func, 0, "func(name string, magic string, decode func(io.Reader) (Image, error), decodeConfig func(io.Reader) (Config, error))"},
-		{"Transparent", Var, 0, ""},
-		{"Uniform", Type, 0, ""},
-		{"Uniform.C", Field, 0, ""},
-		{"White", Var, 0, ""},
-		{"YCbCr", Type, 0, ""},
-		{"YCbCr.CStride", Field, 0, ""},
-		{"YCbCr.Cb", Field, 0, ""},
-		{"YCbCr.Cr", Field, 0, ""},
-		{"YCbCr.Rect", Field, 0, ""},
-		{"YCbCr.SubsampleRatio", Field, 0, ""},
-		{"YCbCr.Y", Field, 0, ""},
-		{"YCbCr.YStride", Field, 0, ""},
-		{"YCbCrSubsampleRatio", Type, 0, ""},
-		{"YCbCrSubsampleRatio410", Const, 5, ""},
-		{"YCbCrSubsampleRatio411", Const, 5, ""},
-		{"YCbCrSubsampleRatio420", Const, 0, ""},
-		{"YCbCrSubsampleRatio422", Const, 0, ""},
-		{"YCbCrSubsampleRatio440", Const, 1, ""},
-		{"YCbCrSubsampleRatio444", Const, 0, ""},
-		{"ZP", Var, 0, ""},
-		{"ZR", Var, 0, ""},
-	},
-	"image/color": {
-		{"(Alpha).RGBA", Method, 0, ""},
-		{"(Alpha16).RGBA", Method, 0, ""},
-		{"(CMYK).RGBA", Method, 5, ""},
-		{"(Color).RGBA", Method, 0, ""},
-		{"(Gray).RGBA", Method, 0, ""},
-		{"(Gray16).RGBA", Method, 0, ""},
-		{"(Model).Convert", Method, 0, ""},
-		{"(NRGBA).RGBA", Method, 0, ""},
-		{"(NRGBA64).RGBA", Method, 0, ""},
-		{"(NYCbCrA).RGBA", Method, 6, ""},
-		{"(Palette).Convert", Method, 0, ""},
-		{"(Palette).Index", Method, 0, ""},
-		{"(RGBA).RGBA", Method, 0, ""},
-		{"(RGBA64).RGBA", Method, 0, ""},
-		{"(YCbCr).RGBA", Method, 0, ""},
-		{"Alpha", Type, 0, ""},
-		{"Alpha.A", Field, 0, ""},
-		{"Alpha16", Type, 0, ""},
-		{"Alpha16.A", Field, 0, ""},
-		{"Alpha16Model", Var, 0, ""},
-		{"AlphaModel", Var, 0, ""},
-		{"Black", Var, 0, ""},
-		{"CMYK", Type, 5, ""},
-		{"CMYK.C", Field, 5, ""},
-		{"CMYK.K", Field, 5, ""},
-		{"CMYK.M", Field, 5, ""},
-		{"CMYK.Y", Field, 5, ""},
-		{"CMYKModel", Var, 5, ""},
-		{"CMYKToRGB", Func, 5, "func(c uint8, m uint8, y uint8, k uint8) (uint8, uint8, uint8)"},
-		{"Color", Type, 0, ""},
-		{"Gray", Type, 0, ""},
-		{"Gray.Y", Field, 0, ""},
-		{"Gray16", Type, 0, ""},
-		{"Gray16.Y", Field, 0, ""},
-		{"Gray16Model", Var, 0, ""},
-		{"GrayModel", Var, 0, ""},
-		{"Model", Type, 0, ""},
-		{"ModelFunc", Func, 0, "func(f func(Color) Color) Model"},
-		{"NRGBA", Type, 0, ""},
-		{"NRGBA.A", Field, 0, ""},
-		{"NRGBA.B", Field, 0, ""},
-		{"NRGBA.G", Field, 0, ""},
-		{"NRGBA.R", Field, 0, ""},
-		{"NRGBA64", Type, 0, ""},
-		{"NRGBA64.A", Field, 0, ""},
-		{"NRGBA64.B", Field, 0, ""},
-		{"NRGBA64.G", Field, 0, ""},
-		{"NRGBA64.R", Field, 0, ""},
-		{"NRGBA64Model", Var, 0, ""},
-		{"NRGBAModel", Var, 0, ""},
-		{"NYCbCrA", Type, 6, ""},
-		{"NYCbCrA.A", Field, 6, ""},
-		{"NYCbCrA.YCbCr", Field, 6, ""},
-		{"NYCbCrAModel", Var, 6, ""},
-		{"Opaque", Var, 0, ""},
-		{"Palette", Type, 0, ""},
-		{"RGBA", Type, 0, ""},
-		{"RGBA.A", Field, 0, ""},
-		{"RGBA.B", Field, 0, ""},
-		{"RGBA.G", Field, 0, ""},
-		{"RGBA.R", Field, 0, ""},
-		{"RGBA64", Type, 0, ""},
-		{"RGBA64.A", Field, 0, ""},
-		{"RGBA64.B", Field, 0, ""},
-		{"RGBA64.G", Field, 0, ""},
-		{"RGBA64.R", Field, 0, ""},
-		{"RGBA64Model", Var, 0, ""},
-		{"RGBAModel", Var, 0, ""},
-		{"RGBToCMYK", Func, 5, "func(r uint8, g uint8, b uint8) (uint8, uint8, uint8, uint8)"},
-		{"RGBToYCbCr", Func, 0, "func(r uint8, g uint8, b uint8) (uint8, uint8, uint8)"},
-		{"Transparent", Var, 0, ""},
-		{"White", Var, 0, ""},
-		{"YCbCr", Type, 0, ""},
-		{"YCbCr.Cb", Field, 0, ""},
-		{"YCbCr.Cr", Field, 0, ""},
-		{"YCbCr.Y", Field, 0, ""},
-		{"YCbCrModel", Var, 0, ""},
-		{"YCbCrToRGB", Func, 0, "func(y uint8, cb uint8, cr uint8) (uint8, uint8, uint8)"},
-	},
-	"image/color/palette": {
-		{"Plan9", Var, 2, ""},
-		{"WebSafe", Var, 2, ""},
-	},
-	"image/draw": {
-		{"(Drawer).Draw", Method, 2, ""},
-		{"(Image).At", Method, 0, ""},
-		{"(Image).Bounds", Method, 0, ""},
-		{"(Image).ColorModel", Method, 0, ""},
-		{"(Image).Set", Method, 0, ""},
-		{"(Op).Draw", Method, 2, ""},
-		{"(Quantizer).Quantize", Method, 2, ""},
-		{"(RGBA64Image).At", Method, 17, ""},
-		{"(RGBA64Image).Bounds", Method, 17, ""},
-		{"(RGBA64Image).ColorModel", Method, 17, ""},
-		{"(RGBA64Image).RGBA64At", Method, 17, ""},
-		{"(RGBA64Image).Set", Method, 17, ""},
-		{"(RGBA64Image).SetRGBA64", Method, 17, ""},
-		{"Draw", Func, 0, "func(dst Image, r image.Rectangle, src image.Image, sp image.Point, op Op)"},
-		{"DrawMask", Func, 0, "func(dst Image, r image.Rectangle, src image.Image, sp image.Point, mask image.Image, mp image.Point, op Op)"},
-		{"Drawer", Type, 2, ""},
-		{"FloydSteinberg", Var, 2, ""},
-		{"Image", Type, 0, ""},
-		{"Op", Type, 0, ""},
-		{"Over", Const, 0, ""},
-		{"Quantizer", Type, 2, ""},
-		{"RGBA64Image", Type, 17, ""},
-		{"Src", Const, 0, ""},
-	},
-	"image/gif": {
-		{"Decode", Func, 0, "func(r io.Reader) (image.Image, error)"},
-		{"DecodeAll", Func, 0, "func(r io.Reader) (*GIF, error)"},
-		{"DecodeConfig", Func, 0, "func(r io.Reader) (image.Config, error)"},
-		{"DisposalBackground", Const, 5, ""},
-		{"DisposalNone", Const, 5, ""},
-		{"DisposalPrevious", Const, 5, ""},
-		{"Encode", Func, 2, "func(w io.Writer, m image.Image, o *Options) error"},
-		{"EncodeAll", Func, 2, "func(w io.Writer, g *GIF) error"},
-		{"GIF", Type, 0, ""},
-		{"GIF.BackgroundIndex", Field, 5, ""},
-		{"GIF.Config", Field, 5, ""},
-		{"GIF.Delay", Field, 0, ""},
-		{"GIF.Disposal", Field, 5, ""},
-		{"GIF.Image", Field, 0, ""},
-		{"GIF.LoopCount", Field, 0, ""},
-		{"Options", Type, 2, ""},
-		{"Options.Drawer", Field, 2, ""},
-		{"Options.NumColors", Field, 2, ""},
-		{"Options.Quantizer", Field, 2, ""},
-	},
-	"image/jpeg": {
-		{"(FormatError).Error", Method, 0, ""},
-		{"(Reader).Read", Method, 0, ""},
-		{"(Reader).ReadByte", Method, 0, ""},
-		{"(UnsupportedError).Error", Method, 0, ""},
-		{"Decode", Func, 0, "func(r io.Reader) (image.Image, error)"},
-		{"DecodeConfig", Func, 0, "func(r io.Reader) (image.Config, error)"},
-		{"DefaultQuality", Const, 0, ""},
-		{"Encode", Func, 0, "func(w io.Writer, m image.Image, o *Options) error"},
-		{"FormatError", Type, 0, ""},
-		{"Options", Type, 0, ""},
-		{"Options.Quality", Field, 0, ""},
-		{"Reader", Type, 0, ""},
-		{"UnsupportedError", Type, 0, ""},
-	},
-	"image/png": {
-		{"(*Encoder).Encode", Method, 4, ""},
-		{"(EncoderBufferPool).Get", Method, 9, ""},
-		{"(EncoderBufferPool).Put", Method, 9, ""},
-		{"(FormatError).Error", Method, 0, ""},
-		{"(UnsupportedError).Error", Method, 0, ""},
-		{"BestCompression", Const, 4, ""},
-		{"BestSpeed", Const, 4, ""},
-		{"CompressionLevel", Type, 4, ""},
-		{"Decode", Func, 0, "func(r io.Reader) (image.Image, error)"},
-		{"DecodeConfig", Func, 0, "func(r io.Reader) (image.Config, error)"},
-		{"DefaultCompression", Const, 4, ""},
-		{"Encode", Func, 0, "func(w io.Writer, m image.Image) error"},
-		{"Encoder", Type, 4, ""},
-		{"Encoder.BufferPool", Field, 9, ""},
-		{"Encoder.CompressionLevel", Field, 4, ""},
-		{"EncoderBuffer", Type, 9, ""},
-		{"EncoderBufferPool", Type, 9, ""},
-		{"FormatError", Type, 0, ""},
-		{"NoCompression", Const, 4, ""},
-		{"UnsupportedError", Type, 0, ""},
-	},
-	"index/suffixarray": {
-		{"(*Index).Bytes", Method, 0, ""},
-		{"(*Index).FindAllIndex", Method, 0, ""},
-		{"(*Index).Lookup", Method, 0, ""},
-		{"(*Index).Read", Method, 0, ""},
-		{"(*Index).Write", Method, 0, ""},
-		{"Index", Type, 0, ""},
-		{"New", Func, 0, "func(data []byte) *Index"},
-	},
-	"io": {
-		{"(*LimitedReader).Read", Method, 0, ""},
-		{"(*OffsetWriter).Seek", Method, 20, ""},
-		{"(*OffsetWriter).Write", Method, 20, ""},
-		{"(*OffsetWriter).WriteAt", Method, 20, ""},
-		{"(*PipeReader).Close", Method, 0, ""},
-		{"(*PipeReader).CloseWithError", Method, 0, ""},
-		{"(*PipeReader).Read", Method, 0, ""},
-		{"(*PipeWriter).Close", Method, 0, ""},
-		{"(*PipeWriter).CloseWithError", Method, 0, ""},
-		{"(*PipeWriter).Write", Method, 0, ""},
-		{"(*SectionReader).Outer", Method, 22, ""},
-		{"(*SectionReader).Read", Method, 0, ""},
-		{"(*SectionReader).ReadAt", Method, 0, ""},
-		{"(*SectionReader).Seek", Method, 0, ""},
-		{"(*SectionReader).Size", Method, 0, ""},
-		{"(ByteReader).ReadByte", Method, 0, ""},
-		{"(ByteScanner).ReadByte", Method, 0, ""},
-		{"(ByteScanner).UnreadByte", Method, 0, ""},
-		{"(ByteWriter).WriteByte", Method, 1, ""},
-		{"(Closer).Close", Method, 0, ""},
-		{"(ReadCloser).Close", Method, 0, ""},
-		{"(ReadCloser).Read", Method, 0, ""},
-		{"(ReadSeekCloser).Close", Method, 16, ""},
-		{"(ReadSeekCloser).Read", Method, 16, ""},
-		{"(ReadSeekCloser).Seek", Method, 16, ""},
-		{"(ReadSeeker).Read", Method, 0, ""},
-		{"(ReadSeeker).Seek", Method, 0, ""},
-		{"(ReadWriteCloser).Close", Method, 0, ""},
-		{"(ReadWriteCloser).Read", Method, 0, ""},
-		{"(ReadWriteCloser).Write", Method, 0, ""},
-		{"(ReadWriteSeeker).Read", Method, 0, ""},
-		{"(ReadWriteSeeker).Seek", Method, 0, ""},
-		{"(ReadWriteSeeker).Write", Method, 0, ""},
-		{"(ReadWriter).Read", Method, 0, ""},
-		{"(ReadWriter).Write", Method, 0, ""},
-		{"(Reader).Read", Method, 0, ""},
-		{"(ReaderAt).ReadAt", Method, 0, ""},
-		{"(ReaderFrom).ReadFrom", Method, 0, ""},
-		{"(RuneReader).ReadRune", Method, 0, ""},
-		{"(RuneScanner).ReadRune", Method, 0, ""},
-		{"(RuneScanner).UnreadRune", Method, 0, ""},
-		{"(Seeker).Seek", Method, 0, ""},
-		{"(StringWriter).WriteString", Method, 12, ""},
-		{"(WriteCloser).Close", Method, 0, ""},
-		{"(WriteCloser).Write", Method, 0, ""},
-		{"(WriteSeeker).Seek", Method, 0, ""},
-		{"(WriteSeeker).Write", Method, 0, ""},
-		{"(Writer).Write", Method, 0, ""},
-		{"(WriterAt).WriteAt", Method, 0, ""},
-		{"(WriterTo).WriteTo", Method, 0, ""},
-		{"ByteReader", Type, 0, ""},
-		{"ByteScanner", Type, 0, ""},
-		{"ByteWriter", Type, 1, ""},
-		{"Closer", Type, 0, ""},
-		{"Copy", Func, 0, "func(dst Writer, src Reader) (written int64, err error)"},
-		{"CopyBuffer", Func, 5, "func(dst Writer, src Reader, buf []byte) (written int64, err error)"},
-		{"CopyN", Func, 0, "func(dst Writer, src Reader, n int64) (written int64, err error)"},
-		{"Discard", Var, 16, ""},
-		{"EOF", Var, 0, ""},
-		{"ErrClosedPipe", Var, 0, ""},
-		{"ErrNoProgress", Var, 1, ""},
-		{"ErrShortBuffer", Var, 0, ""},
-		{"ErrShortWrite", Var, 0, ""},
-		{"ErrUnexpectedEOF", Var, 0, ""},
-		{"LimitReader", Func, 0, "func(r Reader, n int64) Reader"},
-		{"LimitedReader", Type, 0, ""},
-		{"LimitedReader.N", Field, 0, ""},
-		{"LimitedReader.R", Field, 0, ""},
-		{"MultiReader", Func, 0, "func(readers ...Reader) Reader"},
-		{"MultiWriter", Func, 0, "func(writers ...Writer) Writer"},
-		{"NewOffsetWriter", Func, 20, "func(w WriterAt, off int64) *OffsetWriter"},
-		{"NewSectionReader", Func, 0, "func(r ReaderAt, off int64, n int64) *SectionReader"},
-		{"NopCloser", Func, 16, "func(r Reader) ReadCloser"},
-		{"OffsetWriter", Type, 20, ""},
-		{"Pipe", Func, 0, "func() (*PipeReader, *PipeWriter)"},
-		{"PipeReader", Type, 0, ""},
-		{"PipeWriter", Type, 0, ""},
-		{"ReadAll", Func, 16, "func(r Reader) ([]byte, error)"},
-		{"ReadAtLeast", Func, 0, "func(r Reader, buf []byte, min int) (n int, err error)"},
-		{"ReadCloser", Type, 0, ""},
-		{"ReadFull", Func, 0, "func(r Reader, buf []byte) (n int, err error)"},
-		{"ReadSeekCloser", Type, 16, ""},
-		{"ReadSeeker", Type, 0, ""},
-		{"ReadWriteCloser", Type, 0, ""},
-		{"ReadWriteSeeker", Type, 0, ""},
-		{"ReadWriter", Type, 0, ""},
-		{"Reader", Type, 0, ""},
-		{"ReaderAt", Type, 0, ""},
-		{"ReaderFrom", Type, 0, ""},
-		{"RuneReader", Type, 0, ""},
-		{"RuneScanner", Type, 0, ""},
-		{"SectionReader", Type, 0, ""},
-		{"SeekCurrent", Const, 7, ""},
-		{"SeekEnd", Const, 7, ""},
-		{"SeekStart", Const, 7, ""},
-		{"Seeker", Type, 0, ""},
-		{"StringWriter", Type, 12, ""},
-		{"TeeReader", Func, 0, "func(r Reader, w Writer) Reader"},
-		{"WriteCloser", Type, 0, ""},
-		{"WriteSeeker", Type, 0, ""},
-		{"WriteString", Func, 0, "func(w Writer, s string) (n int, err error)"},
-		{"Writer", Type, 0, ""},
-		{"WriterAt", Type, 0, ""},
-		{"WriterTo", Type, 0, ""},
-	},
-	"io/fs": {
-		{"(*PathError).Error", Method, 16, ""},
-		{"(*PathError).Timeout", Method, 16, ""},
-		{"(*PathError).Unwrap", Method, 16, ""},
-		{"(DirEntry).Info", Method, 16, ""},
-		{"(DirEntry).IsDir", Method, 16, ""},
-		{"(DirEntry).Name", Method, 16, ""},
-		{"(DirEntry).Type", Method, 16, ""},
-		{"(FS).Open", Method, 16, ""},
-		{"(File).Close", Method, 16, ""},
-		{"(File).Read", Method, 16, ""},
-		{"(File).Stat", Method, 16, ""},
-		{"(FileInfo).IsDir", Method, 16, ""},
-		{"(FileInfo).ModTime", Method, 16, ""},
-		{"(FileInfo).Mode", Method, 16, ""},
-		{"(FileInfo).Name", Method, 16, ""},
-		{"(FileInfo).Size", Method, 16, ""},
-		{"(FileInfo).Sys", Method, 16, ""},
-		{"(FileMode).IsDir", Method, 16, ""},
-		{"(FileMode).IsRegular", Method, 16, ""},
-		{"(FileMode).Perm", Method, 16, ""},
-		{"(FileMode).String", Method, 16, ""},
-		{"(FileMode).Type", Method, 16, ""},
-		{"(GlobFS).Glob", Method, 16, ""},
-		{"(GlobFS).Open", Method, 16, ""},
-		{"(ReadDirFS).Open", Method, 16, ""},
-		{"(ReadDirFS).ReadDir", Method, 16, ""},
-		{"(ReadDirFile).Close", Method, 16, ""},
-		{"(ReadDirFile).Read", Method, 16, ""},
-		{"(ReadDirFile).ReadDir", Method, 16, ""},
-		{"(ReadDirFile).Stat", Method, 16, ""},
-		{"(ReadFileFS).Open", Method, 16, ""},
-		{"(ReadFileFS).ReadFile", Method, 16, ""},
-		{"(ReadLinkFS).Lstat", Method, 25, ""},
-		{"(ReadLinkFS).Open", Method, 25, ""},
-		{"(ReadLinkFS).ReadLink", Method, 25, ""},
-		{"(StatFS).Open", Method, 16, ""},
-		{"(StatFS).Stat", Method, 16, ""},
-		{"(SubFS).Open", Method, 16, ""},
-		{"(SubFS).Sub", Method, 16, ""},
-		{"DirEntry", Type, 16, ""},
-		{"ErrClosed", Var, 16, ""},
-		{"ErrExist", Var, 16, ""},
-		{"ErrInvalid", Var, 16, ""},
-		{"ErrNotExist", Var, 16, ""},
-		{"ErrPermission", Var, 16, ""},
-		{"FS", Type, 16, ""},
-		{"File", Type, 16, ""},
-		{"FileInfo", Type, 16, ""},
-		{"FileInfoToDirEntry", Func, 17, "func(info FileInfo) DirEntry"},
-		{"FileMode", Type, 16, ""},
-		{"FormatDirEntry", Func, 21, "func(dir DirEntry) string"},
-		{"FormatFileInfo", Func, 21, "func(info FileInfo) string"},
-		{"Glob", Func, 16, "func(fsys FS, pattern string) (matches []string, err error)"},
-		{"GlobFS", Type, 16, ""},
-		{"Lstat", Func, 25, "func(fsys FS, name string) (FileInfo, error)"},
-		{"ModeAppend", Const, 16, ""},
-		{"ModeCharDevice", Const, 16, ""},
-		{"ModeDevice", Const, 16, ""},
-		{"ModeDir", Const, 16, ""},
-		{"ModeExclusive", Const, 16, ""},
-		{"ModeIrregular", Const, 16, ""},
-		{"ModeNamedPipe", Const, 16, ""},
-		{"ModePerm", Const, 16, ""},
-		{"ModeSetgid", Const, 16, ""},
-		{"ModeSetuid", Const, 16, ""},
-		{"ModeSocket", Const, 16, ""},
-		{"ModeSticky", Const, 16, ""},
-		{"ModeSymlink", Const, 16, ""},
-		{"ModeTemporary", Const, 16, ""},
-		{"ModeType", Const, 16, ""},
-		{"PathError", Type, 16, ""},
-		{"PathError.Err", Field, 16, ""},
-		{"PathError.Op", Field, 16, ""},
-		{"PathError.Path", Field, 16, ""},
-		{"ReadDir", Func, 16, "func(fsys FS, name string) ([]DirEntry, error)"},
-		{"ReadDirFS", Type, 16, ""},
-		{"ReadDirFile", Type, 16, ""},
-		{"ReadFile", Func, 16, "func(fsys FS, name string) ([]byte, error)"},
-		{"ReadFileFS", Type, 16, ""},
-		{"ReadLink", Func, 25, "func(fsys FS, name string) (string, error)"},
-		{"ReadLinkFS", Type, 25, ""},
-		{"SkipAll", Var, 20, ""},
-		{"SkipDir", Var, 16, ""},
-		{"Stat", Func, 16, "func(fsys FS, name string) (FileInfo, error)"},
-		{"StatFS", Type, 16, ""},
-		{"Sub", Func, 16, "func(fsys FS, dir string) (FS, error)"},
-		{"SubFS", Type, 16, ""},
-		{"ValidPath", Func, 16, "func(name string) bool"},
-		{"WalkDir", Func, 16, "func(fsys FS, root string, fn WalkDirFunc) error"},
-		{"WalkDirFunc", Type, 16, ""},
-	},
-	"io/ioutil": {
-		{"Discard", Var, 0, ""},
-		{"NopCloser", Func, 0, "func(r io.Reader) io.ReadCloser"},
-		{"ReadAll", Func, 0, "func(r io.Reader) ([]byte, error)"},
-		{"ReadDir", Func, 0, "func(dirname string) ([]fs.FileInfo, error)"},
-		{"ReadFile", Func, 0, "func(filename string) ([]byte, error)"},
-		{"TempDir", Func, 0, "func(dir string, pattern string) (name string, err error)"},
-		{"TempFile", Func, 0, "func(dir string, pattern string) (f *os.File, err error)"},
-		{"WriteFile", Func, 0, "func(filename string, data []byte, perm fs.FileMode) error"},
-	},
-	"iter": {
-		{"Pull", Func, 23, "func[V any](seq Seq[V]) (next func() (V, bool), stop func())"},
-		{"Pull2", Func, 23, "func[K, V any](seq Seq2[K, V]) (next func() (K, V, bool), stop func())"},
-		{"Seq", Type, 23, ""},
-		{"Seq2", Type, 23, ""},
-	},
-	"log": {
-		{"(*Logger).Fatal", Method, 0, ""},
-		{"(*Logger).Fatalf", Method, 0, ""},
-		{"(*Logger).Fatalln", Method, 0, ""},
-		{"(*Logger).Flags", Method, 0, ""},
-		{"(*Logger).Output", Method, 0, ""},
-		{"(*Logger).Panic", Method, 0, ""},
-		{"(*Logger).Panicf", Method, 0, ""},
-		{"(*Logger).Panicln", Method, 0, ""},
-		{"(*Logger).Prefix", Method, 0, ""},
-		{"(*Logger).Print", Method, 0, ""},
-		{"(*Logger).Printf", Method, 0, ""},
-		{"(*Logger).Println", Method, 0, ""},
-		{"(*Logger).SetFlags", Method, 0, ""},
-		{"(*Logger).SetOutput", Method, 5, ""},
-		{"(*Logger).SetPrefix", Method, 0, ""},
-		{"(*Logger).Writer", Method, 12, ""},
-		{"Default", Func, 16, "func() *Logger"},
-		{"Fatal", Func, 0, "func(v ...any)"},
-		{"Fatalf", Func, 0, "func(format string, v ...any)"},
-		{"Fatalln", Func, 0, "func(v ...any)"},
-		{"Flags", Func, 0, "func() int"},
-		{"LUTC", Const, 5, ""},
-		{"Ldate", Const, 0, ""},
-		{"Llongfile", Const, 0, ""},
-		{"Lmicroseconds", Const, 0, ""},
-		{"Lmsgprefix", Const, 14, ""},
-		{"Logger", Type, 0, ""},
-		{"Lshortfile", Const, 0, ""},
-		{"LstdFlags", Const, 0, ""},
-		{"Ltime", Const, 0, ""},
-		{"New", Func, 0, "func(out io.Writer, prefix string, flag int) *Logger"},
-		{"Output", Func, 5, "func(calldepth int, s string) error"},
-		{"Panic", Func, 0, "func(v ...any)"},
-		{"Panicf", Func, 0, "func(format string, v ...any)"},
-		{"Panicln", Func, 0, "func(v ...any)"},
-		{"Prefix", Func, 0, "func() string"},
-		{"Print", Func, 0, "func(v ...any)"},
-		{"Printf", Func, 0, "func(format string, v ...any)"},
-		{"Println", Func, 0, "func(v ...any)"},
-		{"SetFlags", Func, 0, "func(flag int)"},
-		{"SetOutput", Func, 0, "func(w io.Writer)"},
-		{"SetPrefix", Func, 0, "func(prefix string)"},
-		{"Writer", Func, 13, "func() io.Writer"},
-	},
-	"log/slog": {
-		{"(*JSONHandler).Enabled", Method, 21, ""},
-		{"(*JSONHandler).Handle", Method, 21, ""},
-		{"(*JSONHandler).WithAttrs", Method, 21, ""},
-		{"(*JSONHandler).WithGroup", Method, 21, ""},
-		{"(*Level).UnmarshalJSON", Method, 21, ""},
-		{"(*Level).UnmarshalText", Method, 21, ""},
-		{"(*LevelVar).AppendText", Method, 24, ""},
-		{"(*LevelVar).Level", Method, 21, ""},
-		{"(*LevelVar).MarshalText", Method, 21, ""},
-		{"(*LevelVar).Set", Method, 21, ""},
-		{"(*LevelVar).String", Method, 21, ""},
-		{"(*LevelVar).UnmarshalText", Method, 21, ""},
-		{"(*Logger).Debug", Method, 21, ""},
-		{"(*Logger).DebugContext", Method, 21, ""},
-		{"(*Logger).Enabled", Method, 21, ""},
-		{"(*Logger).Error", Method, 21, ""},
-		{"(*Logger).ErrorContext", Method, 21, ""},
-		{"(*Logger).Handler", Method, 21, ""},
-		{"(*Logger).Info", Method, 21, ""},
-		{"(*Logger).InfoContext", Method, 21, ""},
-		{"(*Logger).Log", Method, 21, ""},
-		{"(*Logger).LogAttrs", Method, 21, ""},
-		{"(*Logger).Warn", Method, 21, ""},
-		{"(*Logger).WarnContext", Method, 21, ""},
-		{"(*Logger).With", Method, 21, ""},
-		{"(*Logger).WithGroup", Method, 21, ""},
-		{"(*MultiHandler).Enabled", Method, 26, ""},
-		{"(*MultiHandler).Handle", Method, 26, ""},
-		{"(*MultiHandler).WithAttrs", Method, 26, ""},
-		{"(*MultiHandler).WithGroup", Method, 26, ""},
-		{"(*Record).Add", Method, 21, ""},
-		{"(*Record).AddAttrs", Method, 21, ""},
-		{"(*TextHandler).Enabled", Method, 21, ""},
-		{"(*TextHandler).Handle", Method, 21, ""},
-		{"(*TextHandler).WithAttrs", Method, 21, ""},
-		{"(*TextHandler).WithGroup", Method, 21, ""},
-		{"(Attr).Equal", Method, 21, ""},
-		{"(Attr).String", Method, 21, ""},
-		{"(Handler).Enabled", Method, 21, ""},
-		{"(Handler).Handle", Method, 21, ""},
-		{"(Handler).WithAttrs", Method, 21, ""},
-		{"(Handler).WithGroup", Method, 21, ""},
-		{"(Kind).String", Method, 21, ""},
-		{"(Level).AppendText", Method, 24, ""},
-		{"(Level).Level", Method, 21, ""},
-		{"(Level).MarshalJSON", Method, 21, ""},
-		{"(Level).MarshalText", Method, 21, ""},
-		{"(Level).String", Method, 21, ""},
-		{"(Leveler).Level", Method, 21, ""},
-		{"(LogValuer).LogValue", Method, 21, ""},
-		{"(Record).Attrs", Method, 21, ""},
-		{"(Record).Clone", Method, 21, ""},
-		{"(Record).NumAttrs", Method, 21, ""},
-		{"(Record).Source", Method, 25, ""},
-		{"(Value).Any", Method, 21, ""},
-		{"(Value).Bool", Method, 21, ""},
-		{"(Value).Duration", Method, 21, ""},
-		{"(Value).Equal", Method, 21, ""},
-		{"(Value).Float64", Method, 21, ""},
-		{"(Value).Group", Method, 21, ""},
-		{"(Value).Int64", Method, 21, ""},
-		{"(Value).Kind", Method, 21, ""},
-		{"(Value).LogValuer", Method, 21, ""},
-		{"(Value).Resolve", Method, 21, ""},
-		{"(Value).String", Method, 21, ""},
-		{"(Value).Time", Method, 21, ""},
-		{"(Value).Uint64", Method, 21, ""},
-		{"Any", Func, 21, "func(key string, value any) Attr"},
-		{"AnyValue", Func, 21, "func(v any) Value"},
-		{"Attr", Type, 21, ""},
-		{"Attr.Key", Field, 21, ""},
-		{"Attr.Value", Field, 21, ""},
-		{"Bool", Func, 21, "func(key string, v bool) Attr"},
-		{"BoolValue", Func, 21, "func(v bool) Value"},
-		{"Debug", Func, 21, "func(msg string, args ...any)"},
-		{"DebugContext", Func, 21, "func(ctx context.Context, msg string, args ...any)"},
-		{"Default", Func, 21, "func() *Logger"},
-		{"DiscardHandler", Var, 24, ""},
-		{"Duration", Func, 21, "func(key string, v time.Duration) Attr"},
-		{"DurationValue", Func, 21, "func(v time.Duration) Value"},
-		{"Error", Func, 21, "func(msg string, args ...any)"},
-		{"ErrorContext", Func, 21, "func(ctx context.Context, msg string, args ...any)"},
-		{"Float64", Func, 21, "func(key string, v float64) Attr"},
-		{"Float64Value", Func, 21, "func(v float64) Value"},
-		{"Group", Func, 21, "func(key string, args ...any) Attr"},
-		{"GroupAttrs", Func, 25, "func(key string, attrs ...Attr) Attr"},
-		{"GroupValue", Func, 21, "func(as ...Attr) Value"},
-		{"Handler", Type, 21, ""},
-		{"HandlerOptions", Type, 21, ""},
-		{"HandlerOptions.AddSource", Field, 21, ""},
-		{"HandlerOptions.Level", Field, 21, ""},
-		{"HandlerOptions.ReplaceAttr", Field, 21, ""},
-		{"Info", Func, 21, "func(msg string, args ...any)"},
-		{"InfoContext", Func, 21, "func(ctx context.Context, msg string, args ...any)"},
-		{"Int", Func, 21, "func(key string, value int) Attr"},
-		{"Int64", Func, 21, "func(key string, value int64) Attr"},
-		{"Int64Value", Func, 21, "func(v int64) Value"},
-		{"IntValue", Func, 21, "func(v int) Value"},
-		{"JSONHandler", Type, 21, ""},
-		{"Kind", Type, 21, ""},
-		{"KindAny", Const, 21, ""},
-		{"KindBool", Const, 21, ""},
-		{"KindDuration", Const, 21, ""},
-		{"KindFloat64", Const, 21, ""},
-		{"KindGroup", Const, 21, ""},
-		{"KindInt64", Const, 21, ""},
-		{"KindLogValuer", Const, 21, ""},
-		{"KindString", Const, 21, ""},
-		{"KindTime", Const, 21, ""},
-		{"KindUint64", Const, 21, ""},
-		{"Level", Type, 21, ""},
-		{"LevelDebug", Const, 21, ""},
-		{"LevelError", Const, 21, ""},
-		{"LevelInfo", Const, 21, ""},
-		{"LevelKey", Const, 21, ""},
-		{"LevelVar", Type, 21, ""},
-		{"LevelWarn", Const, 21, ""},
-		{"Leveler", Type, 21, ""},
-		{"Log", Func, 21, "func(ctx context.Context, level Level, msg string, args ...any)"},
-		{"LogAttrs", Func, 21, "func(ctx context.Context, level Level, msg string, attrs ...Attr)"},
-		{"LogValuer", Type, 21, ""},
-		{"Logger", Type, 21, ""},
-		{"MessageKey", Const, 21, ""},
-		{"MultiHandler", Type, 26, ""},
-		{"New", Func, 21, "func(h Handler) *Logger"},
-		{"NewJSONHandler", Func, 21, "func(w io.Writer, opts *HandlerOptions) *JSONHandler"},
-		{"NewLogLogger", Func, 21, "func(h Handler, level Level) *log.Logger"},
-		{"NewMultiHandler", Func, 26, "func(handlers ...Handler) *MultiHandler"},
-		{"NewRecord", Func, 21, "func(t time.Time, level Level, msg string, pc uintptr) Record"},
-		{"NewTextHandler", Func, 21, "func(w io.Writer, opts *HandlerOptions) *TextHandler"},
-		{"Record", Type, 21, ""},
-		{"Record.Level", Field, 21, ""},
-		{"Record.Message", Field, 21, ""},
-		{"Record.PC", Field, 21, ""},
-		{"Record.Time", Field, 21, ""},
-		{"SetDefault", Func, 21, "func(l *Logger)"},
-		{"SetLogLoggerLevel", Func, 22, "func(level Level) (oldLevel Level)"},
-		{"Source", Type, 21, ""},
-		{"Source.File", Field, 21, ""},
-		{"Source.Function", Field, 21, ""},
-		{"Source.Line", Field, 21, ""},
-		{"SourceKey", Const, 21, ""},
-		{"String", Func, 21, "func(key string, value string) Attr"},
-		{"StringValue", Func, 21, "func(value string) Value"},
-		{"TextHandler", Type, 21, ""},
-		{"Time", Func, 21, "func(key string, v time.Time) Attr"},
-		{"TimeKey", Const, 21, ""},
-		{"TimeValue", Func, 21, "func(v time.Time) Value"},
-		{"Uint64", Func, 21, "func(key string, v uint64) Attr"},
-		{"Uint64Value", Func, 21, "func(v uint64) Value"},
-		{"Value", Type, 21, ""},
-		{"Warn", Func, 21, "func(msg string, args ...any)"},
-		{"WarnContext", Func, 21, "func(ctx context.Context, msg string, args ...any)"},
-		{"With", Func, 21, "func(args ...any) *Logger"},
-	},
-	"log/syslog": {
-		{"(*Writer).Alert", Method, 0, ""},
-		{"(*Writer).Close", Method, 0, ""},
-		{"(*Writer).Crit", Method, 0, ""},
-		{"(*Writer).Debug", Method, 0, ""},
-		{"(*Writer).Emerg", Method, 0, ""},
-		{"(*Writer).Err", Method, 0, ""},
-		{"(*Writer).Info", Method, 0, ""},
-		{"(*Writer).Notice", Method, 0, ""},
-		{"(*Writer).Warning", Method, 0, ""},
-		{"(*Writer).Write", Method, 0, ""},
-		{"Dial", Func, 0, "func(network string, raddr string, priority Priority, tag string) (*Writer, error)"},
-		{"LOG_ALERT", Const, 0, ""},
-		{"LOG_AUTH", Const, 1, ""},
-		{"LOG_AUTHPRIV", Const, 1, ""},
-		{"LOG_CRIT", Const, 0, ""},
-		{"LOG_CRON", Const, 1, ""},
-		{"LOG_DAEMON", Const, 1, ""},
-		{"LOG_DEBUG", Const, 0, ""},
-		{"LOG_EMERG", Const, 0, ""},
-		{"LOG_ERR", Const, 0, ""},
-		{"LOG_FTP", Const, 1, ""},
-		{"LOG_INFO", Const, 0, ""},
-		{"LOG_KERN", Const, 1, ""},
-		{"LOG_LOCAL0", Const, 1, ""},
-		{"LOG_LOCAL1", Const, 1, ""},
-		{"LOG_LOCAL2", Const, 1, ""},
-		{"LOG_LOCAL3", Const, 1, ""},
-		{"LOG_LOCAL4", Const, 1, ""},
-		{"LOG_LOCAL5", Const, 1, ""},
-		{"LOG_LOCAL6", Const, 1, ""},
-		{"LOG_LOCAL7", Const, 1, ""},
-		{"LOG_LPR", Const, 1, ""},
-		{"LOG_MAIL", Const, 1, ""},
-		{"LOG_NEWS", Const, 1, ""},
-		{"LOG_NOTICE", Const, 0, ""},
-		{"LOG_SYSLOG", Const, 1, ""},
-		{"LOG_USER", Const, 1, ""},
-		{"LOG_UUCP", Const, 1, ""},
-		{"LOG_WARNING", Const, 0, ""},
-		{"New", Func, 0, "func(priority Priority, tag string) (*Writer, error)"},
-		{"NewLogger", Func, 0, "func(p Priority, logFlag int) (*log.Logger, error)"},
-		{"Priority", Type, 0, ""},
-		{"Writer", Type, 0, ""},
-	},
-	"maps": {
-		{"All", Func, 23, "func[Map ~map[K]V, K comparable, V any](m Map) iter.Seq2[K, V]"},
-		{"Clone", Func, 21, "func[M ~map[K]V, K comparable, V any](m M) M"},
-		{"Collect", Func, 23, "func[K comparable, V any](seq iter.Seq2[K, V]) map[K]V"},
-		{"Copy", Func, 21, "func[M1 ~map[K]V, M2 ~map[K]V, K comparable, V any](dst M1, src M2)"},
-		{"DeleteFunc", Func, 21, "func[M ~map[K]V, K comparable, V any](m M, del func(K, V) bool)"},
-		{"Equal", Func, 21, "func[M1, M2 ~map[K]V, K, V comparable](m1 M1, m2 M2) bool"},
-		{"EqualFunc", Func, 21, "func[M1 ~map[K]V1, M2 ~map[K]V2, K comparable, V1, V2 any](m1 M1, m2 M2, eq func(V1, V2) bool) bool"},
-		{"Insert", Func, 23, "func[Map ~map[K]V, K comparable, V any](m Map, seq iter.Seq2[K, V])"},
-		{"Keys", Func, 23, "func[Map ~map[K]V, K comparable, V any](m Map) iter.Seq[K]"},
-		{"Values", Func, 23, "func[Map ~map[K]V, K comparable, V any](m Map) iter.Seq[V]"},
-	},
-	"math": {
-		{"Abs", Func, 0, "func(x float64) float64"},
-		{"Acos", Func, 0, "func(x float64) float64"},
-		{"Acosh", Func, 0, "func(x float64) float64"},
-		{"Asin", Func, 0, "func(x float64) float64"},
-		{"Asinh", Func, 0, "func(x float64) float64"},
-		{"Atan", Func, 0, "func(x float64) float64"},
-		{"Atan2", Func, 0, "func(y float64, x float64) float64"},
-		{"Atanh", Func, 0, "func(x float64) float64"},
-		{"Cbrt", Func, 0, "func(x float64) float64"},
-		{"Ceil", Func, 0, "func(x float64) float64"},
-		{"Copysign", Func, 0, "func(f float64, sign float64) float64"},
-		{"Cos", Func, 0, "func(x float64) float64"},
-		{"Cosh", Func, 0, "func(x float64) float64"},
-		{"Dim", Func, 0, "func(x float64, y float64) float64"},
-		{"E", Const, 0, ""},
-		{"Erf", Func, 0, "func(x float64) float64"},
-		{"Erfc", Func, 0, "func(x float64) float64"},
-		{"Erfcinv", Func, 10, "func(x float64) float64"},
-		{"Erfinv", Func, 10, "func(x float64) float64"},
-		{"Exp", Func, 0, "func(x float64) float64"},
-		{"Exp2", Func, 0, "func(x float64) float64"},
-		{"Expm1", Func, 0, "func(x float64) float64"},
-		{"FMA", Func, 14, "func(x float64, y float64, z float64) float64"},
-		{"Float32bits", Func, 0, "func(f float32) uint32"},
-		{"Float32frombits", Func, 0, "func(b uint32) float32"},
-		{"Float64bits", Func, 0, "func(f float64) uint64"},
-		{"Float64frombits", Func, 0, "func(b uint64) float64"},
-		{"Floor", Func, 0, "func(x float64) float64"},
-		{"Frexp", Func, 0, "func(f float64) (frac float64, exp int)"},
-		{"Gamma", Func, 0, "func(x float64) float64"},
-		{"Hypot", Func, 0, "func(p float64, q float64) float64"},
-		{"Ilogb", Func, 0, "func(x float64) int"},
-		{"Inf", Func, 0, "func(sign int) float64"},
-		{"IsInf", Func, 0, "func(f float64, sign int) bool"},
-		{"IsNaN", Func, 0, "func(f float64) (is bool)"},
-		{"J0", Func, 0, "func(x float64) float64"},
-		{"J1", Func, 0, "func(x float64) float64"},
-		{"Jn", Func, 0, "func(n int, x float64) float64"},
-		{"Ldexp", Func, 0, "func(frac float64, exp int) float64"},
-		{"Lgamma", Func, 0, "func(x float64) (lgamma float64, sign int)"},
-		{"Ln10", Const, 0, ""},
-		{"Ln2", Const, 0, ""},
-		{"Log", Func, 0, "func(x float64) float64"},
-		{"Log10", Func, 0, "func(x float64) float64"},
-		{"Log10E", Const, 0, ""},
-		{"Log1p", Func, 0, "func(x float64) float64"},
-		{"Log2", Func, 0, "func(x float64) float64"},
-		{"Log2E", Const, 0, ""},
-		{"Logb", Func, 0, "func(x float64) float64"},
-		{"Max", Func, 0, "func(x float64, y float64) float64"},
-		{"MaxFloat32", Const, 0, ""},
-		{"MaxFloat64", Const, 0, ""},
-		{"MaxInt", Const, 17, ""},
-		{"MaxInt16", Const, 0, ""},
-		{"MaxInt32", Const, 0, ""},
-		{"MaxInt64", Const, 0, ""},
-		{"MaxInt8", Const, 0, ""},
-		{"MaxUint", Const, 17, ""},
-		{"MaxUint16", Const, 0, ""},
-		{"MaxUint32", Const, 0, ""},
-		{"MaxUint64", Const, 0, ""},
-		{"MaxUint8", Const, 0, ""},
-		{"Min", Func, 0, "func(x float64, y float64) float64"},
-		{"MinInt", Const, 17, ""},
-		{"MinInt16", Const, 0, ""},
-		{"MinInt32", Const, 0, ""},
-		{"MinInt64", Const, 0, ""},
-		{"MinInt8", Const, 0, ""},
-		{"Mod", Func, 0, "func(x float64, y float64) float64"},
-		{"Modf", Func, 0, "func(f float64) (integer float64, fractional float64)"},
-		{"NaN", Func, 0, "func() float64"},
-		{"Nextafter", Func, 0, "func(x float64, y float64) (r float64)"},
-		{"Nextafter32", Func, 4, "func(x float32, y float32) (r float32)"},
-		{"Phi", Const, 0, ""},
-		{"Pi", Const, 0, ""},
-		{"Pow", Func, 0, "func(x float64, y float64) float64"},
-		{"Pow10", Func, 0, "func(n int) float64"},
-		{"Remainder", Func, 0, "func(x float64, y float64) float64"},
-		{"Round", Func, 10, "func(x float64) float64"},
-		{"RoundToEven", Func, 10, "func(x float64) float64"},
-		{"Signbit", Func, 0, "func(x float64) bool"},
-		{"Sin", Func, 0, "func(x float64) float64"},
-		{"Sincos", Func, 0, "func(x float64) (sin float64, cos float64)"},
-		{"Sinh", Func, 0, "func(x float64) float64"},
-		{"SmallestNonzeroFloat32", Const, 0, ""},
-		{"SmallestNonzeroFloat64", Const, 0, ""},
-		{"Sqrt", Func, 0, "func(x float64) float64"},
-		{"Sqrt2", Const, 0, ""},
-		{"SqrtE", Const, 0, ""},
-		{"SqrtPhi", Const, 0, ""},
-		{"SqrtPi", Const, 0, ""},
-		{"Tan", Func, 0, "func(x float64) float64"},
-		{"Tanh", Func, 0, "func(x float64) float64"},
-		{"Trunc", Func, 0, "func(x float64) float64"},
-		{"Y0", Func, 0, "func(x float64) float64"},
-		{"Y1", Func, 0, "func(x float64) float64"},
-		{"Yn", Func, 0, "func(n int, x float64) float64"},
-	},
-	"math/big": {
-		{"(*Float).Abs", Method, 5, ""},
-		{"(*Float).Acc", Method, 5, ""},
-		{"(*Float).Add", Method, 5, ""},
-		{"(*Float).Append", Method, 5, ""},
-		{"(*Float).AppendText", Method, 24, ""},
-		{"(*Float).Cmp", Method, 5, ""},
-		{"(*Float).Copy", Method, 5, ""},
-		{"(*Float).Float32", Method, 5, ""},
-		{"(*Float).Float64", Method, 5, ""},
-		{"(*Float).Format", Method, 5, ""},
-		{"(*Float).GobDecode", Method, 7, ""},
-		{"(*Float).GobEncode", Method, 7, ""},
-		{"(*Float).Int", Method, 5, ""},
-		{"(*Float).Int64", Method, 5, ""},
-		{"(*Float).IsInf", Method, 5, ""},
-		{"(*Float).IsInt", Method, 5, ""},
-		{"(*Float).MantExp", Method, 5, ""},
-		{"(*Float).MarshalText", Method, 6, ""},
-		{"(*Float).MinPrec", Method, 5, ""},
-		{"(*Float).Mode", Method, 5, ""},
-		{"(*Float).Mul", Method, 5, ""},
-		{"(*Float).Neg", Method, 5, ""},
-		{"(*Float).Parse", Method, 5, ""},
-		{"(*Float).Prec", Method, 5, ""},
-		{"(*Float).Quo", Method, 5, ""},
-		{"(*Float).Rat", Method, 5, ""},
-		{"(*Float).Scan", Method, 8, ""},
-		{"(*Float).Set", Method, 5, ""},
-		{"(*Float).SetFloat64", Method, 5, ""},
-		{"(*Float).SetInf", Method, 5, ""},
-		{"(*Float).SetInt", Method, 5, ""},
-		{"(*Float).SetInt64", Method, 5, ""},
-		{"(*Float).SetMantExp", Method, 5, ""},
-		{"(*Float).SetMode", Method, 5, ""},
-		{"(*Float).SetPrec", Method, 5, ""},
-		{"(*Float).SetRat", Method, 5, ""},
-		{"(*Float).SetString", Method, 5, ""},
-		{"(*Float).SetUint64", Method, 5, ""},
-		{"(*Float).Sign", Method, 5, ""},
-		{"(*Float).Signbit", Method, 5, ""},
-		{"(*Float).Sqrt", Method, 10, ""},
-		{"(*Float).String", Method, 5, ""},
-		{"(*Float).Sub", Method, 5, ""},
-		{"(*Float).Text", Method, 5, ""},
-		{"(*Float).Uint64", Method, 5, ""},
-		{"(*Float).UnmarshalText", Method, 6, ""},
-		{"(*Int).Abs", Method, 0, ""},
-		{"(*Int).Add", Method, 0, ""},
-		{"(*Int).And", Method, 0, ""},
-		{"(*Int).AndNot", Method, 0, ""},
-		{"(*Int).Append", Method, 6, ""},
-		{"(*Int).AppendText", Method, 24, ""},
-		{"(*Int).Binomial", Method, 0, ""},
-		{"(*Int).Bit", Method, 0, ""},
-		{"(*Int).BitLen", Method, 0, ""},
-		{"(*Int).Bits", Method, 0, ""},
-		{"(*Int).Bytes", Method, 0, ""},
-		{"(*Int).Cmp", Method, 0, ""},
-		{"(*Int).CmpAbs", Method, 10, ""},
-		{"(*Int).Div", Method, 0, ""},
-		{"(*Int).DivMod", Method, 0, ""},
-		{"(*Int).Exp", Method, 0, ""},
-		{"(*Int).FillBytes", Method, 15, ""},
-		{"(*Int).Float64", Method, 21, ""},
-		{"(*Int).Format", Method, 0, ""},
-		{"(*Int).GCD", Method, 0, ""},
-		{"(*Int).GobDecode", Method, 0, ""},
-		{"(*Int).GobEncode", Method, 0, ""},
-		{"(*Int).Int64", Method, 0, ""},
-		{"(*Int).IsInt64", Method, 9, ""},
-		{"(*Int).IsUint64", Method, 9, ""},
-		{"(*Int).Lsh", Method, 0, ""},
-		{"(*Int).MarshalJSON", Method, 1, ""},
-		{"(*Int).MarshalText", Method, 3, ""},
-		{"(*Int).Mod", Method, 0, ""},
-		{"(*Int).ModInverse", Method, 0, ""},
-		{"(*Int).ModSqrt", Method, 5, ""},
-		{"(*Int).Mul", Method, 0, ""},
-		{"(*Int).MulRange", Method, 0, ""},
-		{"(*Int).Neg", Method, 0, ""},
-		{"(*Int).Not", Method, 0, ""},
-		{"(*Int).Or", Method, 0, ""},
-		{"(*Int).ProbablyPrime", Method, 0, ""},
-		{"(*Int).Quo", Method, 0, ""},
-		{"(*Int).QuoRem", Method, 0, ""},
-		{"(*Int).Rand", Method, 0, ""},
-		{"(*Int).Rem", Method, 0, ""},
-		{"(*Int).Rsh", Method, 0, ""},
-		{"(*Int).Scan", Method, 0, ""},
-		{"(*Int).Set", Method, 0, ""},
-		{"(*Int).SetBit", Method, 0, ""},
-		{"(*Int).SetBits", Method, 0, ""},
-		{"(*Int).SetBytes", Method, 0, ""},
-		{"(*Int).SetInt64", Method, 0, ""},
-		{"(*Int).SetString", Method, 0, ""},
-		{"(*Int).SetUint64", Method, 1, ""},
-		{"(*Int).Sign", Method, 0, ""},
-		{"(*Int).Sqrt", Method, 8, ""},
-		{"(*Int).String", Method, 0, ""},
-		{"(*Int).Sub", Method, 0, ""},
-		{"(*Int).Text", Method, 6, ""},
-		{"(*Int).TrailingZeroBits", Method, 13, ""},
-		{"(*Int).Uint64", Method, 1, ""},
-		{"(*Int).UnmarshalJSON", Method, 1, ""},
-		{"(*Int).UnmarshalText", Method, 3, ""},
-		{"(*Int).Xor", Method, 0, ""},
-		{"(*Rat).Abs", Method, 0, ""},
-		{"(*Rat).Add", Method, 0, ""},
-		{"(*Rat).AppendText", Method, 24, ""},
-		{"(*Rat).Cmp", Method, 0, ""},
-		{"(*Rat).Denom", Method, 0, ""},
-		{"(*Rat).Float32", Method, 4, ""},
-		{"(*Rat).Float64", Method, 1, ""},
-		{"(*Rat).FloatPrec", Method, 22, ""},
-		{"(*Rat).FloatString", Method, 0, ""},
-		{"(*Rat).GobDecode", Method, 0, ""},
-		{"(*Rat).GobEncode", Method, 0, ""},
-		{"(*Rat).Inv", Method, 0, ""},
-		{"(*Rat).IsInt", Method, 0, ""},
-		{"(*Rat).MarshalText", Method, 3, ""},
-		{"(*Rat).Mul", Method, 0, ""},
-		{"(*Rat).Neg", Method, 0, ""},
-		{"(*Rat).Num", Method, 0, ""},
-		{"(*Rat).Quo", Method, 0, ""},
-		{"(*Rat).RatString", Method, 0, ""},
-		{"(*Rat).Scan", Method, 0, ""},
-		{"(*Rat).Set", Method, 0, ""},
-		{"(*Rat).SetFloat64", Method, 1, ""},
-		{"(*Rat).SetFrac", Method, 0, ""},
-		{"(*Rat).SetFrac64", Method, 0, ""},
-		{"(*Rat).SetInt", Method, 0, ""},
-		{"(*Rat).SetInt64", Method, 0, ""},
-		{"(*Rat).SetString", Method, 0, ""},
-		{"(*Rat).SetUint64", Method, 13, ""},
-		{"(*Rat).Sign", Method, 0, ""},
-		{"(*Rat).String", Method, 0, ""},
-		{"(*Rat).Sub", Method, 0, ""},
-		{"(*Rat).UnmarshalText", Method, 3, ""},
-		{"(Accuracy).String", Method, 5, ""},
-		{"(ErrNaN).Error", Method, 5, ""},
-		{"(RoundingMode).String", Method, 5, ""},
-		{"Above", Const, 5, ""},
-		{"Accuracy", Type, 5, ""},
-		{"AwayFromZero", Const, 5, ""},
-		{"Below", Const, 5, ""},
-		{"ErrNaN", Type, 5, ""},
-		{"Exact", Const, 5, ""},
-		{"Float", Type, 5, ""},
-		{"Int", Type, 0, ""},
-		{"Jacobi", Func, 5, "func(x *Int, y *Int) int"},
-		{"MaxBase", Const, 0, ""},
-		{"MaxExp", Const, 5, ""},
-		{"MaxPrec", Const, 5, ""},
-		{"MinExp", Const, 5, ""},
-		{"NewFloat", Func, 5, "func(x float64) *Float"},
-		{"NewInt", Func, 0, "func(x int64) *Int"},
-		{"NewRat", Func, 0, "func(a int64, b int64) *Rat"},
-		{"ParseFloat", Func, 5, "func(s string, base int, prec uint, mode RoundingMode) (f *Float, b int, err error)"},
-		{"Rat", Type, 0, ""},
-		{"RoundingMode", Type, 5, ""},
-		{"ToNearestAway", Const, 5, ""},
-		{"ToNearestEven", Const, 5, ""},
-		{"ToNegativeInf", Const, 5, ""},
-		{"ToPositiveInf", Const, 5, ""},
-		{"ToZero", Const, 5, ""},
-		{"Word", Type, 0, ""},
-	},
-	"math/bits": {
-		{"Add", Func, 12, "func(x uint, y uint, carry uint) (sum uint, carryOut uint)"},
-		{"Add32", Func, 12, "func(x uint32, y uint32, carry uint32) (sum uint32, carryOut uint32)"},
-		{"Add64", Func, 12, "func(x uint64, y uint64, carry uint64) (sum uint64, carryOut uint64)"},
-		{"Div", Func, 12, "func(hi uint, lo uint, y uint) (quo uint, rem uint)"},
-		{"Div32", Func, 12, "func(hi uint32, lo uint32, y uint32) (quo uint32, rem uint32)"},
-		{"Div64", Func, 12, "func(hi uint64, lo uint64, y uint64) (quo uint64, rem uint64)"},
-		{"LeadingZeros", Func, 9, "func(x uint) int"},
-		{"LeadingZeros16", Func, 9, "func(x uint16) int"},
-		{"LeadingZeros32", Func, 9, "func(x uint32) int"},
-		{"LeadingZeros64", Func, 9, "func(x uint64) int"},
-		{"LeadingZeros8", Func, 9, "func(x uint8) int"},
-		{"Len", Func, 9, "func(x uint) int"},
-		{"Len16", Func, 9, "func(x uint16) (n int)"},
-		{"Len32", Func, 9, "func(x uint32) (n int)"},
-		{"Len64", Func, 9, "func(x uint64) (n int)"},
-		{"Len8", Func, 9, "func(x uint8) int"},
-		{"Mul", Func, 12, "func(x uint, y uint) (hi uint, lo uint)"},
-		{"Mul32", Func, 12, "func(x uint32, y uint32) (hi uint32, lo uint32)"},
-		{"Mul64", Func, 12, "func(x uint64, y uint64) (hi uint64, lo uint64)"},
-		{"OnesCount", Func, 9, "func(x uint) int"},
-		{"OnesCount16", Func, 9, "func(x uint16) int"},
-		{"OnesCount32", Func, 9, "func(x uint32) int"},
-		{"OnesCount64", Func, 9, "func(x uint64) int"},
-		{"OnesCount8", Func, 9, "func(x uint8) int"},
-		{"Rem", Func, 14, "func(hi uint, lo uint, y uint) uint"},
-		{"Rem32", Func, 14, "func(hi uint32, lo uint32, y uint32) uint32"},
-		{"Rem64", Func, 14, "func(hi uint64, lo uint64, y uint64) uint64"},
-		{"Reverse", Func, 9, "func(x uint) uint"},
-		{"Reverse16", Func, 9, "func(x uint16) uint16"},
-		{"Reverse32", Func, 9, "func(x uint32) uint32"},
-		{"Reverse64", Func, 9, "func(x uint64) uint64"},
-		{"Reverse8", Func, 9, "func(x uint8) uint8"},
-		{"ReverseBytes", Func, 9, "func(x uint) uint"},
-		{"ReverseBytes16", Func, 9, "func(x uint16) uint16"},
-		{"ReverseBytes32", Func, 9, "func(x uint32) uint32"},
-		{"ReverseBytes64", Func, 9, "func(x uint64) uint64"},
-		{"RotateLeft", Func, 9, "func(x uint, k int) uint"},
-		{"RotateLeft16", Func, 9, "func(x uint16, k int) uint16"},
-		{"RotateLeft32", Func, 9, "func(x uint32, k int) uint32"},
-		{"RotateLeft64", Func, 9, "func(x uint64, k int) uint64"},
-		{"RotateLeft8", Func, 9, "func(x uint8, k int) uint8"},
-		{"Sub", Func, 12, "func(x uint, y uint, borrow uint) (diff uint, borrowOut uint)"},
-		{"Sub32", Func, 12, "func(x uint32, y uint32, borrow uint32) (diff uint32, borrowOut uint32)"},
-		{"Sub64", Func, 12, "func(x uint64, y uint64, borrow uint64) (diff uint64, borrowOut uint64)"},
-		{"TrailingZeros", Func, 9, "func(x uint) int"},
-		{"TrailingZeros16", Func, 9, "func(x uint16) int"},
-		{"TrailingZeros32", Func, 9, "func(x uint32) int"},
-		{"TrailingZeros64", Func, 9, "func(x uint64) int"},
-		{"TrailingZeros8", Func, 9, "func(x uint8) int"},
-		{"UintSize", Const, 9, ""},
-	},
-	"math/cmplx": {
-		{"Abs", Func, 0, "func(x complex128) float64"},
-		{"Acos", Func, 0, "func(x complex128) complex128"},
-		{"Acosh", Func, 0, "func(x complex128) complex128"},
-		{"Asin", Func, 0, "func(x complex128) complex128"},
-		{"Asinh", Func, 0, "func(x complex128) complex128"},
-		{"Atan", Func, 0, "func(x complex128) complex128"},
-		{"Atanh", Func, 0, "func(x complex128) complex128"},
-		{"Conj", Func, 0, "func(x complex128) complex128"},
-		{"Cos", Func, 0, "func(x complex128) complex128"},
-		{"Cosh", Func, 0, "func(x complex128) complex128"},
-		{"Cot", Func, 0, "func(x complex128) complex128"},
-		{"Exp", Func, 0, "func(x complex128) complex128"},
-		{"Inf", Func, 0, "func() complex128"},
-		{"IsInf", Func, 0, "func(x complex128) bool"},
-		{"IsNaN", Func, 0, "func(x complex128) bool"},
-		{"Log", Func, 0, "func(x complex128) complex128"},
-		{"Log10", Func, 0, "func(x complex128) complex128"},
-		{"NaN", Func, 0, "func() complex128"},
-		{"Phase", Func, 0, "func(x complex128) float64"},
-		{"Polar", Func, 0, "func(x complex128) (r float64, θ float64)"},
-		{"Pow", Func, 0, "func(x complex128, y complex128) complex128"},
-		{"Rect", Func, 0, "func(r float64, θ float64) complex128"},
-		{"Sin", Func, 0, "func(x complex128) complex128"},
-		{"Sinh", Func, 0, "func(x complex128) complex128"},
-		{"Sqrt", Func, 0, "func(x complex128) complex128"},
-		{"Tan", Func, 0, "func(x complex128) complex128"},
-		{"Tanh", Func, 0, "func(x complex128) complex128"},
-	},
-	"math/rand": {
-		{"(*Rand).ExpFloat64", Method, 0, ""},
-		{"(*Rand).Float32", Method, 0, ""},
-		{"(*Rand).Float64", Method, 0, ""},
-		{"(*Rand).Int", Method, 0, ""},
-		{"(*Rand).Int31", Method, 0, ""},
-		{"(*Rand).Int31n", Method, 0, ""},
-		{"(*Rand).Int63", Method, 0, ""},
-		{"(*Rand).Int63n", Method, 0, ""},
-		{"(*Rand).Intn", Method, 0, ""},
-		{"(*Rand).NormFloat64", Method, 0, ""},
-		{"(*Rand).Perm", Method, 0, ""},
-		{"(*Rand).Read", Method, 6, ""},
-		{"(*Rand).Seed", Method, 0, ""},
-		{"(*Rand).Shuffle", Method, 10, ""},
-		{"(*Rand).Uint32", Method, 0, ""},
-		{"(*Rand).Uint64", Method, 8, ""},
-		{"(*Zipf).Uint64", Method, 0, ""},
-		{"(Source).Int63", Method, 0, ""},
-		{"(Source).Seed", Method, 0, ""},
-		{"(Source64).Int63", Method, 8, ""},
-		{"(Source64).Seed", Method, 8, ""},
-		{"(Source64).Uint64", Method, 8, ""},
-		{"ExpFloat64", Func, 0, "func() float64"},
-		{"Float32", Func, 0, "func() float32"},
-		{"Float64", Func, 0, "func() float64"},
-		{"Int", Func, 0, "func() int"},
-		{"Int31", Func, 0, "func() int32"},
-		{"Int31n", Func, 0, "func(n int32) int32"},
-		{"Int63", Func, 0, "func() int64"},
-		{"Int63n", Func, 0, "func(n int64) int64"},
-		{"Intn", Func, 0, "func(n int) int"},
-		{"New", Func, 0, "func(src Source) *Rand"},
-		{"NewSource", Func, 0, "func(seed int64) Source"},
-		{"NewZipf", Func, 0, "func(r *Rand, s float64, v float64, imax uint64) *Zipf"},
-		{"NormFloat64", Func, 0, "func() float64"},
-		{"Perm", Func, 0, "func(n int) []int"},
-		{"Rand", Type, 0, ""},
-		{"Read", Func, 6, "func(p []byte) (n int, err error)"},
-		{"Seed", Func, 0, "func(seed int64)"},
-		{"Shuffle", Func, 10, "func(n int, swap func(i int, j int))"},
-		{"Source", Type, 0, ""},
-		{"Source64", Type, 8, ""},
-		{"Uint32", Func, 0, "func() uint32"},
-		{"Uint64", Func, 8, "func() uint64"},
-		{"Zipf", Type, 0, ""},
-	},
-	"math/rand/v2": {
-		{"(*ChaCha8).AppendBinary", Method, 24, ""},
-		{"(*ChaCha8).MarshalBinary", Method, 22, ""},
-		{"(*ChaCha8).Read", Method, 23, ""},
-		{"(*ChaCha8).Seed", Method, 22, ""},
-		{"(*ChaCha8).Uint64", Method, 22, ""},
-		{"(*ChaCha8).UnmarshalBinary", Method, 22, ""},
-		{"(*PCG).AppendBinary", Method, 24, ""},
-		{"(*PCG).MarshalBinary", Method, 22, ""},
-		{"(*PCG).Seed", Method, 22, ""},
-		{"(*PCG).Uint64", Method, 22, ""},
-		{"(*PCG).UnmarshalBinary", Method, 22, ""},
-		{"(*Rand).ExpFloat64", Method, 22, ""},
-		{"(*Rand).Float32", Method, 22, ""},
-		{"(*Rand).Float64", Method, 22, ""},
-		{"(*Rand).Int", Method, 22, ""},
-		{"(*Rand).Int32", Method, 22, ""},
-		{"(*Rand).Int32N", Method, 22, ""},
-		{"(*Rand).Int64", Method, 22, ""},
-		{"(*Rand).Int64N", Method, 22, ""},
-		{"(*Rand).IntN", Method, 22, ""},
-		{"(*Rand).NormFloat64", Method, 22, ""},
-		{"(*Rand).Perm", Method, 22, ""},
-		{"(*Rand).Shuffle", Method, 22, ""},
-		{"(*Rand).Uint", Method, 23, ""},
-		{"(*Rand).Uint32", Method, 22, ""},
-		{"(*Rand).Uint32N", Method, 22, ""},
-		{"(*Rand).Uint64", Method, 22, ""},
-		{"(*Rand).Uint64N", Method, 22, ""},
-		{"(*Rand).UintN", Method, 22, ""},
-		{"(*Zipf).Uint64", Method, 22, ""},
-		{"(Source).Uint64", Method, 22, ""},
-		{"ChaCha8", Type, 22, ""},
-		{"ExpFloat64", Func, 22, "func() float64"},
-		{"Float32", Func, 22, "func() float32"},
-		{"Float64", Func, 22, "func() float64"},
-		{"Int", Func, 22, "func() int"},
-		{"Int32", Func, 22, "func() int32"},
-		{"Int32N", Func, 22, "func(n int32) int32"},
-		{"Int64", Func, 22, "func() int64"},
-		{"Int64N", Func, 22, "func(n int64) int64"},
-		{"IntN", Func, 22, "func(n int) int"},
-		{"N", Func, 22, "func[Int intType](n Int) Int"},
-		{"New", Func, 22, "func(src Source) *Rand"},
-		{"NewChaCha8", Func, 22, "func(seed [32]byte) *ChaCha8"},
-		{"NewPCG", Func, 22, "func(seed1 uint64, seed2 uint64) *PCG"},
-		{"NewZipf", Func, 22, "func(r *Rand, s float64, v float64, imax uint64) *Zipf"},
-		{"NormFloat64", Func, 22, "func() float64"},
-		{"PCG", Type, 22, ""},
-		{"Perm", Func, 22, "func(n int) []int"},
-		{"Rand", Type, 22, ""},
-		{"Shuffle", Func, 22, "func(n int, swap func(i int, j int))"},
-		{"Source", Type, 22, ""},
-		{"Uint", Func, 23, "func() uint"},
-		{"Uint32", Func, 22, "func() uint32"},
-		{"Uint32N", Func, 22, "func(n uint32) uint32"},
-		{"Uint64", Func, 22, "func() uint64"},
-		{"Uint64N", Func, 22, "func(n uint64) uint64"},
-		{"UintN", Func, 22, "func(n uint) uint"},
-		{"Zipf", Type, 22, ""},
-	},
-	"mime": {
-		{"(*WordDecoder).Decode", Method, 5, ""},
-		{"(*WordDecoder).DecodeHeader", Method, 5, ""},
-		{"(WordEncoder).Encode", Method, 5, ""},
-		{"AddExtensionType", Func, 0, "func(ext string, typ string) error"},
-		{"BEncoding", Const, 5, ""},
-		{"ErrInvalidMediaParameter", Var, 9, ""},
-		{"ExtensionsByType", Func, 5, "func(typ string) ([]string, error)"},
-		{"FormatMediaType", Func, 0, "func(t string, param map[string]string) string"},
-		{"ParseMediaType", Func, 0, "func(v string) (mediatype string, params map[string]string, err error)"},
-		{"QEncoding", Const, 5, ""},
-		{"TypeByExtension", Func, 0, "func(ext string) string"},
-		{"WordDecoder", Type, 5, ""},
-		{"WordDecoder.CharsetReader", Field, 5, ""},
-		{"WordEncoder", Type, 5, ""},
-	},
-	"mime/multipart": {
-		{"(*FileHeader).Open", Method, 0, ""},
-		{"(*Form).RemoveAll", Method, 0, ""},
-		{"(*Part).Close", Method, 0, ""},
-		{"(*Part).FileName", Method, 0, ""},
-		{"(*Part).FormName", Method, 0, ""},
-		{"(*Part).Read", Method, 0, ""},
-		{"(*Reader).NextPart", Method, 0, ""},
-		{"(*Reader).NextRawPart", Method, 14, ""},
-		{"(*Reader).ReadForm", Method, 0, ""},
-		{"(*Writer).Boundary", Method, 0, ""},
-		{"(*Writer).Close", Method, 0, ""},
-		{"(*Writer).CreateFormField", Method, 0, ""},
-		{"(*Writer).CreateFormFile", Method, 0, ""},
-		{"(*Writer).CreatePart", Method, 0, ""},
-		{"(*Writer).FormDataContentType", Method, 0, ""},
-		{"(*Writer).SetBoundary", Method, 1, ""},
-		{"(*Writer).WriteField", Method, 0, ""},
-		{"(File).Close", Method, 0, ""},
-		{"(File).Read", Method, 0, ""},
-		{"(File).ReadAt", Method, 0, ""},
-		{"(File).Seek", Method, 0, ""},
-		{"ErrMessageTooLarge", Var, 9, ""},
-		{"File", Type, 0, ""},
-		{"FileContentDisposition", Func, 25, "func(fieldname string, filename string) string"},
-		{"FileHeader", Type, 0, ""},
-		{"FileHeader.Filename", Field, 0, ""},
-		{"FileHeader.Header", Field, 0, ""},
-		{"FileHeader.Size", Field, 9, ""},
-		{"Form", Type, 0, ""},
-		{"Form.File", Field, 0, ""},
-		{"Form.Value", Field, 0, ""},
-		{"NewReader", Func, 0, "func(r io.Reader, boundary string) *Reader"},
-		{"NewWriter", Func, 0, "func(w io.Writer) *Writer"},
-		{"Part", Type, 0, ""},
-		{"Part.Header", Field, 0, ""},
-		{"Reader", Type, 0, ""},
-		{"Writer", Type, 0, ""},
-	},
-	"mime/quotedprintable": {
-		{"(*Reader).Read", Method, 5, ""},
-		{"(*Writer).Close", Method, 5, ""},
-		{"(*Writer).Write", Method, 5, ""},
-		{"NewReader", Func, 5, "func(r io.Reader) *Reader"},
-		{"NewWriter", Func, 5, "func(w io.Writer) *Writer"},
-		{"Reader", Type, 5, ""},
-		{"Writer", Type, 5, ""},
-		{"Writer.Binary", Field, 5, ""},
-	},
-	"net": {
-		{"(*AddrError).Error", Method, 0, ""},
-		{"(*AddrError).Temporary", Method, 0, ""},
-		{"(*AddrError).Timeout", Method, 0, ""},
-		{"(*Buffers).Read", Method, 8, ""},
-		{"(*Buffers).WriteTo", Method, 8, ""},
-		{"(*DNSConfigError).Error", Method, 0, ""},
-		{"(*DNSConfigError).Temporary", Method, 0, ""},
-		{"(*DNSConfigError).Timeout", Method, 0, ""},
-		{"(*DNSConfigError).Unwrap", Method, 13, ""},
-		{"(*DNSError).Error", Method, 0, ""},
-		{"(*DNSError).Temporary", Method, 0, ""},
-		{"(*DNSError).Timeout", Method, 0, ""},
-		{"(*DNSError).Unwrap", Method, 23, ""},
-		{"(*Dialer).Dial", Method, 1, ""},
-		{"(*Dialer).DialContext", Method, 7, ""},
-		{"(*Dialer).DialIP", Method, 26, ""},
-		{"(*Dialer).DialTCP", Method, 26, ""},
-		{"(*Dialer).DialUDP", Method, 26, ""},
-		{"(*Dialer).DialUnix", Method, 26, ""},
-		{"(*Dialer).MultipathTCP", Method, 21, ""},
-		{"(*Dialer).SetMultipathTCP", Method, 21, ""},
-		{"(*IP).UnmarshalText", Method, 2, ""},
-		{"(*IPAddr).Network", Method, 0, ""},
-		{"(*IPAddr).String", Method, 0, ""},
-		{"(*IPConn).Close", Method, 0, ""},
-		{"(*IPConn).File", Method, 0, ""},
-		{"(*IPConn).LocalAddr", Method, 0, ""},
-		{"(*IPConn).Read", Method, 0, ""},
-		{"(*IPConn).ReadFrom", Method, 0, ""},
-		{"(*IPConn).ReadFromIP", Method, 0, ""},
-		{"(*IPConn).ReadMsgIP", Method, 1, ""},
-		{"(*IPConn).RemoteAddr", Method, 0, ""},
-		{"(*IPConn).SetDeadline", Method, 0, ""},
-		{"(*IPConn).SetReadBuffer", Method, 0, ""},
-		{"(*IPConn).SetReadDeadline", Method, 0, ""},
-		{"(*IPConn).SetWriteBuffer", Method, 0, ""},
-		{"(*IPConn).SetWriteDeadline", Method, 0, ""},
-		{"(*IPConn).SyscallConn", Method, 9, ""},
-		{"(*IPConn).Write", Method, 0, ""},
-		{"(*IPConn).WriteMsgIP", Method, 1, ""},
-		{"(*IPConn).WriteTo", Method, 0, ""},
-		{"(*IPConn).WriteToIP", Method, 0, ""},
-		{"(*IPNet).Contains", Method, 0, ""},
-		{"(*IPNet).Network", Method, 0, ""},
-		{"(*IPNet).String", Method, 0, ""},
-		{"(*Interface).Addrs", Method, 0, ""},
-		{"(*Interface).MulticastAddrs", Method, 0, ""},
-		{"(*ListenConfig).Listen", Method, 11, ""},
-		{"(*ListenConfig).ListenPacket", Method, 11, ""},
-		{"(*ListenConfig).MultipathTCP", Method, 21, ""},
-		{"(*ListenConfig).SetMultipathTCP", Method, 21, ""},
-		{"(*OpError).Error", Method, 0, ""},
-		{"(*OpError).Temporary", Method, 0, ""},
-		{"(*OpError).Timeout", Method, 0, ""},
-		{"(*OpError).Unwrap", Method, 13, ""},
-		{"(*ParseError).Error", Method, 0, ""},
-		{"(*ParseError).Temporary", Method, 17, ""},
-		{"(*ParseError).Timeout", Method, 17, ""},
-		{"(*Resolver).LookupAddr", Method, 8, ""},
-		{"(*Resolver).LookupCNAME", Method, 8, ""},
-		{"(*Resolver).LookupHost", Method, 8, ""},
-		{"(*Resolver).LookupIP", Method, 15, ""},
-		{"(*Resolver).LookupIPAddr", Method, 8, ""},
-		{"(*Resolver).LookupMX", Method, 8, ""},
-		{"(*Resolver).LookupNS", Method, 8, ""},
-		{"(*Resolver).LookupNetIP", Method, 18, ""},
-		{"(*Resolver).LookupPort", Method, 8, ""},
-		{"(*Resolver).LookupSRV", Method, 8, ""},
-		{"(*Resolver).LookupTXT", Method, 8, ""},
-		{"(*TCPAddr).AddrPort", Method, 18, ""},
-		{"(*TCPAddr).Network", Method, 0, ""},
-		{"(*TCPAddr).String", Method, 0, ""},
-		{"(*TCPConn).Close", Method, 0, ""},
-		{"(*TCPConn).CloseRead", Method, 0, ""},
-		{"(*TCPConn).CloseWrite", Method, 0, ""},
-		{"(*TCPConn).File", Method, 0, ""},
-		{"(*TCPConn).LocalAddr", Method, 0, ""},
-		{"(*TCPConn).MultipathTCP", Method, 21, ""},
-		{"(*TCPConn).Read", Method, 0, ""},
-		{"(*TCPConn).ReadFrom", Method, 0, ""},
-		{"(*TCPConn).RemoteAddr", Method, 0, ""},
-		{"(*TCPConn).SetDeadline", Method, 0, ""},
-		{"(*TCPConn).SetKeepAlive", Method, 0, ""},
-		{"(*TCPConn).SetKeepAliveConfig", Method, 23, ""},
-		{"(*TCPConn).SetKeepAlivePeriod", Method, 2, ""},
-		{"(*TCPConn).SetLinger", Method, 0, ""},
-		{"(*TCPConn).SetNoDelay", Method, 0, ""},
-		{"(*TCPConn).SetReadBuffer", Method, 0, ""},
-		{"(*TCPConn).SetReadDeadline", Method, 0, ""},
-		{"(*TCPConn).SetWriteBuffer", Method, 0, ""},
-		{"(*TCPConn).SetWriteDeadline", Method, 0, ""},
-		{"(*TCPConn).SyscallConn", Method, 9, ""},
-		{"(*TCPConn).Write", Method, 0, ""},
-		{"(*TCPConn).WriteTo", Method, 22, ""},
-		{"(*TCPListener).Accept", Method, 0, ""},
-		{"(*TCPListener).AcceptTCP", Method, 0, ""},
-		{"(*TCPListener).Addr", Method, 0, ""},
-		{"(*TCPListener).Close", Method, 0, ""},
-		{"(*TCPListener).File", Method, 0, ""},
-		{"(*TCPListener).SetDeadline", Method, 0, ""},
-		{"(*TCPListener).SyscallConn", Method, 10, ""},
-		{"(*UDPAddr).AddrPort", Method, 18, ""},
-		{"(*UDPAddr).Network", Method, 0, ""},
-		{"(*UDPAddr).String", Method, 0, ""},
-		{"(*UDPConn).Close", Method, 0, ""},
-		{"(*UDPConn).File", Method, 0, ""},
-		{"(*UDPConn).LocalAddr", Method, 0, ""},
-		{"(*UDPConn).Read", Method, 0, ""},
-		{"(*UDPConn).ReadFrom", Method, 0, ""},
-		{"(*UDPConn).ReadFromUDP", Method, 0, ""},
-		{"(*UDPConn).ReadFromUDPAddrPort", Method, 18, ""},
-		{"(*UDPConn).ReadMsgUDP", Method, 1, ""},
-		{"(*UDPConn).ReadMsgUDPAddrPort", Method, 18, ""},
-		{"(*UDPConn).RemoteAddr", Method, 0, ""},
-		{"(*UDPConn).SetDeadline", Method, 0, ""},
-		{"(*UDPConn).SetReadBuffer", Method, 0, ""},
-		{"(*UDPConn).SetReadDeadline", Method, 0, ""},
-		{"(*UDPConn).SetWriteBuffer", Method, 0, ""},
-		{"(*UDPConn).SetWriteDeadline", Method, 0, ""},
-		{"(*UDPConn).SyscallConn", Method, 9, ""},
-		{"(*UDPConn).Write", Method, 0, ""},
-		{"(*UDPConn).WriteMsgUDP", Method, 1, ""},
-		{"(*UDPConn).WriteMsgUDPAddrPort", Method, 18, ""},
-		{"(*UDPConn).WriteTo", Method, 0, ""},
-		{"(*UDPConn).WriteToUDP", Method, 0, ""},
-		{"(*UDPConn).WriteToUDPAddrPort", Method, 18, ""},
-		{"(*UnixAddr).Network", Method, 0, ""},
-		{"(*UnixAddr).String", Method, 0, ""},
-		{"(*UnixConn).Close", Method, 0, ""},
-		{"(*UnixConn).CloseRead", Method, 1, ""},
-		{"(*UnixConn).CloseWrite", Method, 1, ""},
-		{"(*UnixConn).File", Method, 0, ""},
-		{"(*UnixConn).LocalAddr", Method, 0, ""},
-		{"(*UnixConn).Read", Method, 0, ""},
-		{"(*UnixConn).ReadFrom", Method, 0, ""},
-		{"(*UnixConn).ReadFromUnix", Method, 0, ""},
-		{"(*UnixConn).ReadMsgUnix", Method, 0, ""},
-		{"(*UnixConn).RemoteAddr", Method, 0, ""},
-		{"(*UnixConn).SetDeadline", Method, 0, ""},
-		{"(*UnixConn).SetReadBuffer", Method, 0, ""},
-		{"(*UnixConn).SetReadDeadline", Method, 0, ""},
-		{"(*UnixConn).SetWriteBuffer", Method, 0, ""},
-		{"(*UnixConn).SetWriteDeadline", Method, 0, ""},
-		{"(*UnixConn).SyscallConn", Method, 9, ""},
-		{"(*UnixConn).Write", Method, 0, ""},
-		{"(*UnixConn).WriteMsgUnix", Method, 0, ""},
-		{"(*UnixConn).WriteTo", Method, 0, ""},
-		{"(*UnixConn).WriteToUnix", Method, 0, ""},
-		{"(*UnixListener).Accept", Method, 0, ""},
-		{"(*UnixListener).AcceptUnix", Method, 0, ""},
-		{"(*UnixListener).Addr", Method, 0, ""},
-		{"(*UnixListener).Close", Method, 0, ""},
-		{"(*UnixListener).File", Method, 0, ""},
-		{"(*UnixListener).SetDeadline", Method, 0, ""},
-		{"(*UnixListener).SetUnlinkOnClose", Method, 8, ""},
-		{"(*UnixListener).SyscallConn", Method, 10, ""},
-		{"(Addr).Network", Method, 0, ""},
-		{"(Addr).String", Method, 0, ""},
-		{"(Conn).Close", Method, 0, ""},
-		{"(Conn).LocalAddr", Method, 0, ""},
-		{"(Conn).Read", Method, 0, ""},
-		{"(Conn).RemoteAddr", Method, 0, ""},
-		{"(Conn).SetDeadline", Method, 0, ""},
-		{"(Conn).SetReadDeadline", Method, 0, ""},
-		{"(Conn).SetWriteDeadline", Method, 0, ""},
-		{"(Conn).Write", Method, 0, ""},
-		{"(Error).Error", Method, 0, ""},
-		{"(Error).Temporary", Method, 0, ""},
-		{"(Error).Timeout", Method, 0, ""},
-		{"(Flags).String", Method, 0, ""},
-		{"(HardwareAddr).String", Method, 0, ""},
-		{"(IP).AppendText", Method, 24, ""},
-		{"(IP).DefaultMask", Method, 0, ""},
-		{"(IP).Equal", Method, 0, ""},
-		{"(IP).IsGlobalUnicast", Method, 0, ""},
-		{"(IP).IsInterfaceLocalMulticast", Method, 0, ""},
-		{"(IP).IsLinkLocalMulticast", Method, 0, ""},
-		{"(IP).IsLinkLocalUnicast", Method, 0, ""},
-		{"(IP).IsLoopback", Method, 0, ""},
-		{"(IP).IsMulticast", Method, 0, ""},
-		{"(IP).IsPrivate", Method, 17, ""},
-		{"(IP).IsUnspecified", Method, 0, ""},
-		{"(IP).MarshalText", Method, 2, ""},
-		{"(IP).Mask", Method, 0, ""},
-		{"(IP).String", Method, 0, ""},
-		{"(IP).To16", Method, 0, ""},
-		{"(IP).To4", Method, 0, ""},
-		{"(IPMask).Size", Method, 0, ""},
-		{"(IPMask).String", Method, 0, ""},
-		{"(InvalidAddrError).Error", Method, 0, ""},
-		{"(InvalidAddrError).Temporary", Method, 0, ""},
-		{"(InvalidAddrError).Timeout", Method, 0, ""},
-		{"(Listener).Accept", Method, 0, ""},
-		{"(Listener).Addr", Method, 0, ""},
-		{"(Listener).Close", Method, 0, ""},
-		{"(PacketConn).Close", Method, 0, ""},
-		{"(PacketConn).LocalAddr", Method, 0, ""},
-		{"(PacketConn).ReadFrom", Method, 0, ""},
-		{"(PacketConn).SetDeadline", Method, 0, ""},
-		{"(PacketConn).SetReadDeadline", Method, 0, ""},
-		{"(PacketConn).SetWriteDeadline", Method, 0, ""},
-		{"(PacketConn).WriteTo", Method, 0, ""},
-		{"(UnknownNetworkError).Error", Method, 0, ""},
-		{"(UnknownNetworkError).Temporary", Method, 0, ""},
-		{"(UnknownNetworkError).Timeout", Method, 0, ""},
-		{"Addr", Type, 0, ""},
-		{"AddrError", Type, 0, ""},
-		{"AddrError.Addr", Field, 0, ""},
-		{"AddrError.Err", Field, 0, ""},
-		{"Buffers", Type, 8, ""},
-		{"CIDRMask", Func, 0, "func(ones int, bits int) IPMask"},
-		{"Conn", Type, 0, ""},
-		{"DNSConfigError", Type, 0, ""},
-		{"DNSConfigError.Err", Field, 0, ""},
-		{"DNSError", Type, 0, ""},
-		{"DNSError.Err", Field, 0, ""},
-		{"DNSError.IsNotFound", Field, 13, ""},
-		{"DNSError.IsTemporary", Field, 6, ""},
-		{"DNSError.IsTimeout", Field, 0, ""},
-		{"DNSError.Name", Field, 0, ""},
-		{"DNSError.Server", Field, 0, ""},
-		{"DNSError.UnwrapErr", Field, 23, ""},
-		{"DefaultResolver", Var, 8, ""},
-		{"Dial", Func, 0, "func(network string, address string) (Conn, error)"},
-		{"DialIP", Func, 0, "func(network string, laddr *IPAddr, raddr *IPAddr) (*IPConn, error)"},
-		{"DialTCP", Func, 0, "func(network string, laddr *TCPAddr, raddr *TCPAddr) (*TCPConn, error)"},
-		{"DialTimeout", Func, 0, "func(network string, address string, timeout time.Duration) (Conn, error)"},
-		{"DialUDP", Func, 0, "func(network string, laddr *UDPAddr, raddr *UDPAddr) (*UDPConn, error)"},
-		{"DialUnix", Func, 0, "func(network string, laddr *UnixAddr, raddr *UnixAddr) (*UnixConn, error)"},
-		{"Dialer", Type, 1, ""},
-		{"Dialer.Cancel", Field, 6, ""},
-		{"Dialer.Control", Field, 11, ""},
-		{"Dialer.ControlContext", Field, 20, ""},
-		{"Dialer.Deadline", Field, 1, ""},
-		{"Dialer.DualStack", Field, 2, ""},
-		{"Dialer.FallbackDelay", Field, 5, ""},
-		{"Dialer.KeepAlive", Field, 3, ""},
-		{"Dialer.KeepAliveConfig", Field, 23, ""},
-		{"Dialer.LocalAddr", Field, 1, ""},
-		{"Dialer.Resolver", Field, 8, ""},
-		{"Dialer.Timeout", Field, 1, ""},
-		{"ErrClosed", Var, 16, ""},
-		{"ErrWriteToConnected", Var, 0, ""},
-		{"Error", Type, 0, ""},
-		{"FileConn", Func, 0, "func(f *os.File) (c Conn, err error)"},
-		{"FileListener", Func, 0, "func(f *os.File) (ln Listener, err error)"},
-		{"FilePacketConn", Func, 0, "func(f *os.File) (c PacketConn, err error)"},
-		{"FlagBroadcast", Const, 0, ""},
-		{"FlagLoopback", Const, 0, ""},
-		{"FlagMulticast", Const, 0, ""},
-		{"FlagPointToPoint", Const, 0, ""},
-		{"FlagRunning", Const, 20, ""},
-		{"FlagUp", Const, 0, ""},
-		{"Flags", Type, 0, ""},
-		{"HardwareAddr", Type, 0, ""},
-		{"IP", Type, 0, ""},
-		{"IPAddr", Type, 0, ""},
-		{"IPAddr.IP", Field, 0, ""},
-		{"IPAddr.Zone", Field, 1, ""},
-		{"IPConn", Type, 0, ""},
-		{"IPMask", Type, 0, ""},
-		{"IPNet", Type, 0, ""},
-		{"IPNet.IP", Field, 0, ""},
-		{"IPNet.Mask", Field, 0, ""},
-		{"IPv4", Func, 0, "func(a byte, b byte, c byte, d byte) IP"},
-		{"IPv4Mask", Func, 0, "func(a byte, b byte, c byte, d byte) IPMask"},
-		{"IPv4allrouter", Var, 0, ""},
-		{"IPv4allsys", Var, 0, ""},
-		{"IPv4bcast", Var, 0, ""},
-		{"IPv4len", Const, 0, ""},
-		{"IPv4zero", Var, 0, ""},
-		{"IPv6interfacelocalallnodes", Var, 0, ""},
-		{"IPv6len", Const, 0, ""},
-		{"IPv6linklocalallnodes", Var, 0, ""},
-		{"IPv6linklocalallrouters", Var, 0, ""},
-		{"IPv6loopback", Var, 0, ""},
-		{"IPv6unspecified", Var, 0, ""},
-		{"IPv6zero", Var, 0, ""},
-		{"Interface", Type, 0, ""},
-		{"Interface.Flags", Field, 0, ""},
-		{"Interface.HardwareAddr", Field, 0, ""},
-		{"Interface.Index", Field, 0, ""},
-		{"Interface.MTU", Field, 0, ""},
-		{"Interface.Name", Field, 0, ""},
-		{"InterfaceAddrs", Func, 0, "func() ([]Addr, error)"},
-		{"InterfaceByIndex", Func, 0, "func(index int) (*Interface, error)"},
-		{"InterfaceByName", Func, 0, "func(name string) (*Interface, error)"},
-		{"Interfaces", Func, 0, "func() ([]Interface, error)"},
-		{"InvalidAddrError", Type, 0, ""},
-		{"JoinHostPort", Func, 0, "func(host string, port string) string"},
-		{"KeepAliveConfig", Type, 23, ""},
-		{"KeepAliveConfig.Count", Field, 23, ""},
-		{"KeepAliveConfig.Enable", Field, 23, ""},
-		{"KeepAliveConfig.Idle", Field, 23, ""},
-		{"KeepAliveConfig.Interval", Field, 23, ""},
-		{"Listen", Func, 0, "func(network string, address string) (Listener, error)"},
-		{"ListenConfig", Type, 11, ""},
-		{"ListenConfig.Control", Field, 11, ""},
-		{"ListenConfig.KeepAlive", Field, 13, ""},
-		{"ListenConfig.KeepAliveConfig", Field, 23, ""},
-		{"ListenIP", Func, 0, "func(network string, laddr *IPAddr) (*IPConn, error)"},
-		{"ListenMulticastUDP", Func, 0, "func(network string, ifi *Interface, gaddr *UDPAddr) (*UDPConn, error)"},
-		{"ListenPacket", Func, 0, "func(network string, address string) (PacketConn, error)"},
-		{"ListenTCP", Func, 0, "func(network string, laddr *TCPAddr) (*TCPListener, error)"},
-		{"ListenUDP", Func, 0, "func(network string, laddr *UDPAddr) (*UDPConn, error)"},
-		{"ListenUnix", Func, 0, "func(network string, laddr *UnixAddr) (*UnixListener, error)"},
-		{"ListenUnixgram", Func, 0, "func(network string, laddr *UnixAddr) (*UnixConn, error)"},
-		{"Listener", Type, 0, ""},
-		{"LookupAddr", Func, 0, "func(addr string) (names []string, err error)"},
-		{"LookupCNAME", Func, 0, "func(host string) (cname string, err error)"},
-		{"LookupHost", Func, 0, "func(host string) (addrs []string, err error)"},
-		{"LookupIP", Func, 0, "func(host string) ([]IP, error)"},
-		{"LookupMX", Func, 0, "func(name string) ([]*MX, error)"},
-		{"LookupNS", Func, 1, "func(name string) ([]*NS, error)"},
-		{"LookupPort", Func, 0, "func(network string, service string) (port int, err error)"},
-		{"LookupSRV", Func, 0, "func(service string, proto string, name string) (cname string, addrs []*SRV, err error)"},
-		{"LookupTXT", Func, 0, "func(name string) ([]string, error)"},
-		{"MX", Type, 0, ""},
-		{"MX.Host", Field, 0, ""},
-		{"MX.Pref", Field, 0, ""},
-		{"NS", Type, 1, ""},
-		{"NS.Host", Field, 1, ""},
-		{"OpError", Type, 0, ""},
-		{"OpError.Addr", Field, 0, ""},
-		{"OpError.Err", Field, 0, ""},
-		{"OpError.Net", Field, 0, ""},
-		{"OpError.Op", Field, 0, ""},
-		{"OpError.Source", Field, 5, ""},
-		{"PacketConn", Type, 0, ""},
-		{"ParseCIDR", Func, 0, "func(s string) (IP, *IPNet, error)"},
-		{"ParseError", Type, 0, ""},
-		{"ParseError.Text", Field, 0, ""},
-		{"ParseError.Type", Field, 0, ""},
-		{"ParseIP", Func, 0, "func(s string) IP"},
-		{"ParseMAC", Func, 0, "func(s string) (hw HardwareAddr, err error)"},
-		{"Pipe", Func, 0, "func() (Conn, Conn)"},
-		{"ResolveIPAddr", Func, 0, "func(network string, address string) (*IPAddr, error)"},
-		{"ResolveTCPAddr", Func, 0, "func(network string, address string) (*TCPAddr, error)"},
-		{"ResolveUDPAddr", Func, 0, "func(network string, address string) (*UDPAddr, error)"},
-		{"ResolveUnixAddr", Func, 0, "func(network string, address string) (*UnixAddr, error)"},
-		{"Resolver", Type, 8, ""},
-		{"Resolver.Dial", Field, 9, ""},
-		{"Resolver.PreferGo", Field, 8, ""},
-		{"Resolver.StrictErrors", Field, 9, ""},
-		{"SRV", Type, 0, ""},
-		{"SRV.Port", Field, 0, ""},
-		{"SRV.Priority", Field, 0, ""},
-		{"SRV.Target", Field, 0, ""},
-		{"SRV.Weight", Field, 0, ""},
-		{"SplitHostPort", Func, 0, "func(hostport string) (host string, port string, err error)"},
-		{"TCPAddr", Type, 0, ""},
-		{"TCPAddr.IP", Field, 0, ""},
-		{"TCPAddr.Port", Field, 0, ""},
-		{"TCPAddr.Zone", Field, 1, ""},
-		{"TCPAddrFromAddrPort", Func, 18, "func(addr netip.AddrPort) *TCPAddr"},
-		{"TCPConn", Type, 0, ""},
-		{"TCPListener", Type, 0, ""},
-		{"UDPAddr", Type, 0, ""},
-		{"UDPAddr.IP", Field, 0, ""},
-		{"UDPAddr.Port", Field, 0, ""},
-		{"UDPAddr.Zone", Field, 1, ""},
-		{"UDPAddrFromAddrPort", Func, 18, "func(addr netip.AddrPort) *UDPAddr"},
-		{"UDPConn", Type, 0, ""},
-		{"UnixAddr", Type, 0, ""},
-		{"UnixAddr.Name", Field, 0, ""},
-		{"UnixAddr.Net", Field, 0, ""},
-		{"UnixConn", Type, 0, ""},
-		{"UnixListener", Type, 0, ""},
-		{"UnknownNetworkError", Type, 0, ""},
-	},
-	"net/http": {
-		{"(*Client).CloseIdleConnections", Method, 12, ""},
-		{"(*Client).Do", Method, 0, ""},
-		{"(*Client).Get", Method, 0, ""},
-		{"(*Client).Head", Method, 0, ""},
-		{"(*Client).Post", Method, 0, ""},
-		{"(*Client).PostForm", Method, 0, ""},
-		{"(*ClientConn).Available", Method, 26, ""},
-		{"(*ClientConn).Close", Method, 26, ""},
-		{"(*ClientConn).Err", Method, 26, ""},
-		{"(*ClientConn).InFlight", Method, 26, ""},
-		{"(*ClientConn).Release", Method, 26, ""},
-		{"(*ClientConn).Reserve", Method, 26, ""},
-		{"(*ClientConn).RoundTrip", Method, 26, ""},
-		{"(*ClientConn).SetStateHook", Method, 26, ""},
-		{"(*Cookie).String", Method, 0, ""},
-		{"(*Cookie).Valid", Method, 18, ""},
-		{"(*CrossOriginProtection).AddInsecureBypassPattern", Method, 25, ""},
-		{"(*CrossOriginProtection).AddTrustedOrigin", Method, 25, ""},
-		{"(*CrossOriginProtection).Check", Method, 25, ""},
-		{"(*CrossOriginProtection).Handler", Method, 25, ""},
-		{"(*CrossOriginProtection).SetDenyHandler", Method, 25, ""},
-		{"(*MaxBytesError).Error", Method, 19, ""},
-		{"(*ProtocolError).Error", Method, 0, ""},
-		{"(*ProtocolError).Is", Method, 21, ""},
-		{"(*Protocols).SetHTTP1", Method, 24, ""},
-		{"(*Protocols).SetHTTP2", Method, 24, ""},
-		{"(*Protocols).SetUnencryptedHTTP2", Method, 24, ""},
-		{"(*Request).AddCookie", Method, 0, ""},
-		{"(*Request).BasicAuth", Method, 4, ""},
-		{"(*Request).Clone", Method, 13, ""},
-		{"(*Request).Context", Method, 7, ""},
-		{"(*Request).Cookie", Method, 0, ""},
-		{"(*Request).Cookies", Method, 0, ""},
-		{"(*Request).CookiesNamed", Method, 23, ""},
-		{"(*Request).FormFile", Method, 0, ""},
-		{"(*Request).FormValue", Method, 0, ""},
-		{"(*Request).MultipartReader", Method, 0, ""},
-		{"(*Request).ParseForm", Method, 0, ""},
-		{"(*Request).ParseMultipartForm", Method, 0, ""},
-		{"(*Request).PathValue", Method, 22, ""},
-		{"(*Request).PostFormValue", Method, 1, ""},
-		{"(*Request).ProtoAtLeast", Method, 0, ""},
-		{"(*Request).Referer", Method, 0, ""},
-		{"(*Request).SetBasicAuth", Method, 0, ""},
-		{"(*Request).SetPathValue", Method, 22, ""},
-		{"(*Request).UserAgent", Method, 0, ""},
-		{"(*Request).WithContext", Method, 7, ""},
-		{"(*Request).Write", Method, 0, ""},
-		{"(*Request).WriteProxy", Method, 0, ""},
-		{"(*Response).Cookies", Method, 0, ""},
-		{"(*Response).Location", Method, 0, ""},
-		{"(*Response).ProtoAtLeast", Method, 0, ""},
-		{"(*Response).Write", Method, 0, ""},
-		{"(*ResponseController).EnableFullDuplex", Method, 21, ""},
-		{"(*ResponseController).Flush", Method, 20, ""},
-		{"(*ResponseController).Hijack", Method, 20, ""},
-		{"(*ResponseController).SetReadDeadline", Method, 20, ""},
-		{"(*ResponseController).SetWriteDeadline", Method, 20, ""},
-		{"(*ServeMux).Handle", Method, 0, ""},
-		{"(*ServeMux).HandleFunc", Method, 0, ""},
-		{"(*ServeMux).Handler", Method, 1, ""},
-		{"(*ServeMux).ServeHTTP", Method, 0, ""},
-		{"(*Server).Close", Method, 8, ""},
-		{"(*Server).ListenAndServe", Method, 0, ""},
-		{"(*Server).ListenAndServeTLS", Method, 0, ""},
-		{"(*Server).RegisterOnShutdown", Method, 9, ""},
-		{"(*Server).Serve", Method, 0, ""},
-		{"(*Server).ServeTLS", Method, 9, ""},
-		{"(*Server).SetKeepAlivesEnabled", Method, 3, ""},
-		{"(*Server).Shutdown", Method, 8, ""},
-		{"(*Transport).CancelRequest", Method, 1, ""},
-		{"(*Transport).Clone", Method, 13, ""},
-		{"(*Transport).CloseIdleConnections", Method, 0, ""},
-		{"(*Transport).NewClientConn", Method, 26, ""},
-		{"(*Transport).RegisterProtocol", Method, 0, ""},
-		{"(*Transport).RoundTrip", Method, 0, ""},
-		{"(CloseNotifier).CloseNotify", Method, 1, ""},
-		{"(ConnState).String", Method, 3, ""},
-		{"(CookieJar).Cookies", Method, 0, ""},
-		{"(CookieJar).SetCookies", Method, 0, ""},
-		{"(Dir).Open", Method, 0, ""},
-		{"(File).Close", Method, 0, ""},
-		{"(File).Read", Method, 0, ""},
-		{"(File).Readdir", Method, 0, ""},
-		{"(File).Seek", Method, 0, ""},
-		{"(File).Stat", Method, 0, ""},
-		{"(FileSystem).Open", Method, 0, ""},
-		{"(Flusher).Flush", Method, 0, ""},
-		{"(Handler).ServeHTTP", Method, 0, ""},
-		{"(HandlerFunc).ServeHTTP", Method, 0, ""},
-		{"(Header).Add", Method, 0, ""},
-		{"(Header).Clone", Method, 13, ""},
-		{"(Header).Del", Method, 0, ""},
-		{"(Header).Get", Method, 0, ""},
-		{"(Header).Set", Method, 0, ""},
-		{"(Header).Values", Method, 14, ""},
-		{"(Header).Write", Method, 0, ""},
-		{"(Header).WriteSubset", Method, 0, ""},
-		{"(Hijacker).Hijack", Method, 0, ""},
-		{"(Protocols).HTTP1", Method, 24, ""},
-		{"(Protocols).HTTP2", Method, 24, ""},
-		{"(Protocols).String", Method, 24, ""},
-		{"(Protocols).UnencryptedHTTP2", Method, 24, ""},
-		{"(Pusher).Push", Method, 8, ""},
-		{"(ResponseWriter).Header", Method, 0, ""},
-		{"(ResponseWriter).Write", Method, 0, ""},
-		{"(ResponseWriter).WriteHeader", Method, 0, ""},
-		{"(RoundTripper).RoundTrip", Method, 0, ""},
-		{"AllowQuerySemicolons", Func, 17, "func(h Handler) Handler"},
-		{"CanonicalHeaderKey", Func, 0, "func(s string) string"},
-		{"Client", Type, 0, ""},
-		{"Client.CheckRedirect", Field, 0, ""},
-		{"Client.Jar", Field, 0, ""},
-		{"Client.Timeout", Field, 3, ""},
-		{"Client.Transport", Field, 0, ""},
-		{"ClientConn", Type, 26, ""},
-		{"CloseNotifier", Type, 1, ""},
-		{"ConnState", Type, 3, ""},
-		{"Cookie", Type, 0, ""},
-		{"Cookie.Domain", Field, 0, ""},
-		{"Cookie.Expires", Field, 0, ""},
-		{"Cookie.HttpOnly", Field, 0, ""},
-		{"Cookie.MaxAge", Field, 0, ""},
-		{"Cookie.Name", Field, 0, ""},
-		{"Cookie.Partitioned", Field, 23, ""},
-		{"Cookie.Path", Field, 0, ""},
-		{"Cookie.Quoted", Field, 23, ""},
-		{"Cookie.Raw", Field, 0, ""},
-		{"Cookie.RawExpires", Field, 0, ""},
-		{"Cookie.SameSite", Field, 11, ""},
-		{"Cookie.Secure", Field, 0, ""},
-		{"Cookie.Unparsed", Field, 0, ""},
-		{"Cookie.Value", Field, 0, ""},
-		{"CookieJar", Type, 0, ""},
-		{"CrossOriginProtection", Type, 25, ""},
-		{"DefaultClient", Var, 0, ""},
-		{"DefaultMaxHeaderBytes", Const, 0, ""},
-		{"DefaultMaxIdleConnsPerHost", Const, 0, ""},
-		{"DefaultServeMux", Var, 0, ""},
-		{"DefaultTransport", Var, 0, ""},
-		{"DetectContentType", Func, 0, "func(data []byte) string"},
-		{"Dir", Type, 0, ""},
-		{"ErrAbortHandler", Var, 8, ""},
-		{"ErrBodyNotAllowed", Var, 0, ""},
-		{"ErrBodyReadAfterClose", Var, 0, ""},
-		{"ErrContentLength", Var, 0, ""},
-		{"ErrHandlerTimeout", Var, 0, ""},
-		{"ErrHeaderTooLong", Var, 0, ""},
-		{"ErrHijacked", Var, 0, ""},
-		{"ErrLineTooLong", Var, 0, ""},
-		{"ErrMissingBoundary", Var, 0, ""},
-		{"ErrMissingContentLength", Var, 0, ""},
-		{"ErrMissingFile", Var, 0, ""},
-		{"ErrNoCookie", Var, 0, ""},
-		{"ErrNoLocation", Var, 0, ""},
-		{"ErrNotMultipart", Var, 0, ""},
-		{"ErrNotSupported", Var, 0, ""},
-		{"ErrSchemeMismatch", Var, 21, ""},
-		{"ErrServerClosed", Var, 8, ""},
-		{"ErrShortBody", Var, 0, ""},
-		{"ErrSkipAltProtocol", Var, 6, ""},
-		{"ErrUnexpectedTrailer", Var, 0, ""},
-		{"ErrUseLastResponse", Var, 7, ""},
-		{"ErrWriteAfterFlush", Var, 0, ""},
-		{"Error", Func, 0, "func(w ResponseWriter, error string, code int)"},
-		{"FS", Func, 16, "func(fsys fs.FS) FileSystem"},
-		{"File", Type, 0, ""},
-		{"FileServer", Func, 0, "func(root FileSystem) Handler"},
-		{"FileServerFS", Func, 22, "func(root fs.FS) Handler"},
-		{"FileSystem", Type, 0, ""},
-		{"Flusher", Type, 0, ""},
-		{"Get", Func, 0, "func(url string) (resp *Response, err error)"},
-		{"HTTP2Config", Type, 24, ""},
-		{"HTTP2Config.CountError", Field, 24, ""},
-		{"HTTP2Config.MaxConcurrentStreams", Field, 24, ""},
-		{"HTTP2Config.MaxDecoderHeaderTableSize", Field, 24, ""},
-		{"HTTP2Config.MaxEncoderHeaderTableSize", Field, 24, ""},
-		{"HTTP2Config.MaxReadFrameSize", Field, 24, ""},
-		{"HTTP2Config.MaxReceiveBufferPerConnection", Field, 24, ""},
-		{"HTTP2Config.MaxReceiveBufferPerStream", Field, 24, ""},
-		{"HTTP2Config.PermitProhibitedCipherSuites", Field, 24, ""},
-		{"HTTP2Config.PingTimeout", Field, 24, ""},
-		{"HTTP2Config.SendPingTimeout", Field, 24, ""},
-		{"HTTP2Config.StrictMaxConcurrentRequests", Field, 26, ""},
-		{"HTTP2Config.WriteByteTimeout", Field, 24, ""},
-		{"Handle", Func, 0, "func(pattern string, handler Handler)"},
-		{"HandleFunc", Func, 0, "func(pattern string, handler func(ResponseWriter, *Request))"},
-		{"Handler", Type, 0, ""},
-		{"HandlerFunc", Type, 0, ""},
-		{"Head", Func, 0, "func(url string) (resp *Response, err error)"},
-		{"Header", Type, 0, ""},
-		{"Hijacker", Type, 0, ""},
-		{"ListenAndServe", Func, 0, "func(addr string, handler Handler) error"},
-		{"ListenAndServeTLS", Func, 0, "func(addr string, certFile string, keyFile string, handler Handler) error"},
-		{"LocalAddrContextKey", Var, 7, ""},
-		{"MaxBytesError", Type, 19, ""},
-		{"MaxBytesError.Limit", Field, 19, ""},
-		{"MaxBytesHandler", Func, 18, "func(h Handler, n int64) Handler"},
-		{"MaxBytesReader", Func, 0, "func(w ResponseWriter, r io.ReadCloser, n int64) io.ReadCloser"},
-		{"MethodConnect", Const, 6, ""},
-		{"MethodDelete", Const, 6, ""},
-		{"MethodGet", Const, 6, ""},
-		{"MethodHead", Const, 6, ""},
-		{"MethodOptions", Const, 6, ""},
-		{"MethodPatch", Const, 6, ""},
-		{"MethodPost", Const, 6, ""},
-		{"MethodPut", Const, 6, ""},
-		{"MethodTrace", Const, 6, ""},
-		{"NewCrossOriginProtection", Func, 25, "func() *CrossOriginProtection"},
-		{"NewFileTransport", Func, 0, "func(fs FileSystem) RoundTripper"},
-		{"NewFileTransportFS", Func, 22, "func(fsys fs.FS) RoundTripper"},
-		{"NewRequest", Func, 0, "func(method string, url string, body io.Reader) (*Request, error)"},
-		{"NewRequestWithContext", Func, 13, "func(ctx context.Context, method string, url string, body io.Reader) (*Request, error)"},
-		{"NewResponseController", Func, 20, "func(rw ResponseWriter) *ResponseController"},
-		{"NewServeMux", Func, 0, "func() *ServeMux"},
-		{"NoBody", Var, 8, ""},
-		{"NotFound", Func, 0, "func(w ResponseWriter, r *Request)"},
-		{"NotFoundHandler", Func, 0, "func() Handler"},
-		{"ParseCookie", Func, 23, "func(line string) ([]*Cookie, error)"},
-		{"ParseHTTPVersion", Func, 0, "func(vers string) (major int, minor int, ok bool)"},
-		{"ParseSetCookie", Func, 23, "func(line string) (*Cookie, error)"},
-		{"ParseTime", Func, 1, "func(text string) (t time.Time, err error)"},
-		{"Post", Func, 0, "func(url string, contentType string, body io.Reader) (resp *Response, err error)"},
-		{"PostForm", Func, 0, "func(url string, data url.Values) (resp *Response, err error)"},
-		{"ProtocolError", Type, 0, ""},
-		{"ProtocolError.ErrorString", Field, 0, ""},
-		{"Protocols", Type, 24, ""},
-		{"ProxyFromEnvironment", Func, 0, "func(req *Request) (*url.URL, error)"},
-		{"ProxyURL", Func, 0, "func(fixedURL *url.URL) func(*Request) (*url.URL, error)"},
-		{"PushOptions", Type, 8, ""},
-		{"PushOptions.Header", Field, 8, ""},
-		{"PushOptions.Method", Field, 8, ""},
-		{"Pusher", Type, 8, ""},
-		{"ReadRequest", Func, 0, "func(b *bufio.Reader) (*Request, error)"},
-		{"ReadResponse", Func, 0, "func(r *bufio.Reader, req *Request) (*Response, error)"},
-		{"Redirect", Func, 0, "func(w ResponseWriter, r *Request, url string, code int)"},
-		{"RedirectHandler", Func, 0, "func(url string, code int) Handler"},
-		{"Request", Type, 0, ""},
-		{"Request.Body", Field, 0, ""},
-		{"Request.Cancel", Field, 5, ""},
-		{"Request.Close", Field, 0, ""},
-		{"Request.ContentLength", Field, 0, ""},
-		{"Request.Form", Field, 0, ""},
-		{"Request.GetBody", Field, 8, ""},
-		{"Request.Header", Field, 0, ""},
-		{"Request.Host", Field, 0, ""},
-		{"Request.Method", Field, 0, ""},
-		{"Request.MultipartForm", Field, 0, ""},
-		{"Request.Pattern", Field, 23, ""},
-		{"Request.PostForm", Field, 1, ""},
-		{"Request.Proto", Field, 0, ""},
-		{"Request.ProtoMajor", Field, 0, ""},
-		{"Request.ProtoMinor", Field, 0, ""},
-		{"Request.RemoteAddr", Field, 0, ""},
-		{"Request.RequestURI", Field, 0, ""},
-		{"Request.Response", Field, 7, ""},
-		{"Request.TLS", Field, 0, ""},
-		{"Request.Trailer", Field, 0, ""},
-		{"Request.TransferEncoding", Field, 0, ""},
-		{"Request.URL", Field, 0, ""},
-		{"Response", Type, 0, ""},
-		{"Response.Body", Field, 0, ""},
-		{"Response.Close", Field, 0, ""},
-		{"Response.ContentLength", Field, 0, ""},
-		{"Response.Header", Field, 0, ""},
-		{"Response.Proto", Field, 0, ""},
-		{"Response.ProtoMajor", Field, 0, ""},
-		{"Response.ProtoMinor", Field, 0, ""},
-		{"Response.Request", Field, 0, ""},
-		{"Response.Status", Field, 0, ""},
-		{"Response.StatusCode", Field, 0, ""},
-		{"Response.TLS", Field, 3, ""},
-		{"Response.Trailer", Field, 0, ""},
-		{"Response.TransferEncoding", Field, 0, ""},
-		{"Response.Uncompressed", Field, 7, ""},
-		{"ResponseController", Type, 20, ""},
-		{"ResponseWriter", Type, 0, ""},
-		{"RoundTripper", Type, 0, ""},
-		{"SameSite", Type, 11, ""},
-		{"SameSiteDefaultMode", Const, 11, ""},
-		{"SameSiteLaxMode", Const, 11, ""},
-		{"SameSiteNoneMode", Const, 13, ""},
-		{"SameSiteStrictMode", Const, 11, ""},
-		{"Serve", Func, 0, "func(l net.Listener, handler Handler) error"},
-		{"ServeContent", Func, 0, "func(w ResponseWriter, req *Request, name string, modtime time.Time, content io.ReadSeeker)"},
-		{"ServeFile", Func, 0, "func(w ResponseWriter, r *Request, name string)"},
-		{"ServeFileFS", Func, 22, "func(w ResponseWriter, r *Request, fsys fs.FS, name string)"},
-		{"ServeMux", Type, 0, ""},
-		{"ServeTLS", Func, 9, "func(l net.Listener, handler Handler, certFile string, keyFile string) error"},
-		{"Server", Type, 0, ""},
-		{"Server.Addr", Field, 0, ""},
-		{"Server.BaseContext", Field, 13, ""},
-		{"Server.ConnContext", Field, 13, ""},
-		{"Server.ConnState", Field, 3, ""},
-		{"Server.DisableGeneralOptionsHandler", Field, 20, ""},
-		{"Server.ErrorLog", Field, 3, ""},
-		{"Server.HTTP2", Field, 24, ""},
-		{"Server.Handler", Field, 0, ""},
-		{"Server.IdleTimeout", Field, 8, ""},
-		{"Server.MaxHeaderBytes", Field, 0, ""},
-		{"Server.Protocols", Field, 24, ""},
-		{"Server.ReadHeaderTimeout", Field, 8, ""},
-		{"Server.ReadTimeout", Field, 0, ""},
-		{"Server.TLSConfig", Field, 0, ""},
-		{"Server.TLSNextProto", Field, 1, ""},
-		{"Server.WriteTimeout", Field, 0, ""},
-		{"ServerContextKey", Var, 7, ""},
-		{"SetCookie", Func, 0, "func(w ResponseWriter, cookie *Cookie)"},
-		{"StateActive", Const, 3, ""},
-		{"StateClosed", Const, 3, ""},
-		{"StateHijacked", Const, 3, ""},
-		{"StateIdle", Const, 3, ""},
-		{"StateNew", Const, 3, ""},
-		{"StatusAccepted", Const, 0, ""},
-		{"StatusAlreadyReported", Const, 7, ""},
-		{"StatusBadGateway", Const, 0, ""},
-		{"StatusBadRequest", Const, 0, ""},
-		{"StatusConflict", Const, 0, ""},
-		{"StatusContinue", Const, 0, ""},
-		{"StatusCreated", Const, 0, ""},
-		{"StatusEarlyHints", Const, 13, ""},
-		{"StatusExpectationFailed", Const, 0, ""},
-		{"StatusFailedDependency", Const, 7, ""},
-		{"StatusForbidden", Const, 0, ""},
-		{"StatusFound", Const, 0, ""},
-		{"StatusGatewayTimeout", Const, 0, ""},
-		{"StatusGone", Const, 0, ""},
-		{"StatusHTTPVersionNotSupported", Const, 0, ""},
-		{"StatusIMUsed", Const, 7, ""},
-		{"StatusInsufficientStorage", Const, 7, ""},
-		{"StatusInternalServerError", Const, 0, ""},
-		{"StatusLengthRequired", Const, 0, ""},
-		{"StatusLocked", Const, 7, ""},
-		{"StatusLoopDetected", Const, 7, ""},
-		{"StatusMethodNotAllowed", Const, 0, ""},
-		{"StatusMisdirectedRequest", Const, 11, ""},
-		{"StatusMovedPermanently", Const, 0, ""},
-		{"StatusMultiStatus", Const, 7, ""},
-		{"StatusMultipleChoices", Const, 0, ""},
-		{"StatusNetworkAuthenticationRequired", Const, 6, ""},
-		{"StatusNoContent", Const, 0, ""},
-		{"StatusNonAuthoritativeInfo", Const, 0, ""},
-		{"StatusNotAcceptable", Const, 0, ""},
-		{"StatusNotExtended", Const, 7, ""},
-		{"StatusNotFound", Const, 0, ""},
-		{"StatusNotImplemented", Const, 0, ""},
-		{"StatusNotModified", Const, 0, ""},
-		{"StatusOK", Const, 0, ""},
-		{"StatusPartialContent", Const, 0, ""},
-		{"StatusPaymentRequired", Const, 0, ""},
-		{"StatusPermanentRedirect", Const, 7, ""},
-		{"StatusPreconditionFailed", Const, 0, ""},
-		{"StatusPreconditionRequired", Const, 6, ""},
-		{"StatusProcessing", Const, 7, ""},
-		{"StatusProxyAuthRequired", Const, 0, ""},
-		{"StatusRequestEntityTooLarge", Const, 0, ""},
-		{"StatusRequestHeaderFieldsTooLarge", Const, 6, ""},
-		{"StatusRequestTimeout", Const, 0, ""},
-		{"StatusRequestURITooLong", Const, 0, ""},
-		{"StatusRequestedRangeNotSatisfiable", Const, 0, ""},
-		{"StatusResetContent", Const, 0, ""},
-		{"StatusSeeOther", Const, 0, ""},
-		{"StatusServiceUnavailable", Const, 0, ""},
-		{"StatusSwitchingProtocols", Const, 0, ""},
-		{"StatusTeapot", Const, 0, ""},
-		{"StatusTemporaryRedirect", Const, 0, ""},
-		{"StatusText", Func, 0, "func(code int) string"},
-		{"StatusTooEarly", Const, 12, ""},
-		{"StatusTooManyRequests", Const, 6, ""},
-		{"StatusUnauthorized", Const, 0, ""},
-		{"StatusUnavailableForLegalReasons", Const, 6, ""},
-		{"StatusUnprocessableEntity", Const, 7, ""},
-		{"StatusUnsupportedMediaType", Const, 0, ""},
-		{"StatusUpgradeRequired", Const, 7, ""},
-		{"StatusUseProxy", Const, 0, ""},
-		{"StatusVariantAlsoNegotiates", Const, 7, ""},
-		{"StripPrefix", Func, 0, "func(prefix string, h Handler) Handler"},
-		{"TimeFormat", Const, 0, ""},
-		{"TimeoutHandler", Func, 0, "func(h Handler, dt time.Duration, msg string) Handler"},
-		{"TrailerPrefix", Const, 8, ""},
-		{"Transport", Type, 0, ""},
-		{"Transport.Dial", Field, 0, ""},
-		{"Transport.DialContext", Field, 7, ""},
-		{"Transport.DialTLS", Field, 4, ""},
-		{"Transport.DialTLSContext", Field, 14, ""},
-		{"Transport.DisableCompression", Field, 0, ""},
-		{"Transport.DisableKeepAlives", Field, 0, ""},
-		{"Transport.ExpectContinueTimeout", Field, 6, ""},
-		{"Transport.ForceAttemptHTTP2", Field, 13, ""},
-		{"Transport.GetProxyConnectHeader", Field, 16, ""},
-		{"Transport.HTTP2", Field, 24, ""},
-		{"Transport.IdleConnTimeout", Field, 7, ""},
-		{"Transport.MaxConnsPerHost", Field, 11, ""},
-		{"Transport.MaxIdleConns", Field, 7, ""},
-		{"Transport.MaxIdleConnsPerHost", Field, 0, ""},
-		{"Transport.MaxResponseHeaderBytes", Field, 7, ""},
-		{"Transport.OnProxyConnectResponse", Field, 20, ""},
-		{"Transport.Protocols", Field, 24, ""},
-		{"Transport.Proxy", Field, 0, ""},
-		{"Transport.ProxyConnectHeader", Field, 8, ""},
-		{"Transport.ReadBufferSize", Field, 13, ""},
-		{"Transport.ResponseHeaderTimeout", Field, 1, ""},
-		{"Transport.TLSClientConfig", Field, 0, ""},
-		{"Transport.TLSHandshakeTimeout", Field, 3, ""},
-		{"Transport.TLSNextProto", Field, 6, ""},
-		{"Transport.WriteBufferSize", Field, 13, ""},
-	},
-	"net/http/cgi": {
-		{"(*Handler).ServeHTTP", Method, 0, ""},
-		{"Handler", Type, 0, ""},
-		{"Handler.Args", Field, 0, ""},
-		{"Handler.Dir", Field, 0, ""},
-		{"Handler.Env", Field, 0, ""},
-		{"Handler.InheritEnv", Field, 0, ""},
-		{"Handler.Logger", Field, 0, ""},
-		{"Handler.Path", Field, 0, ""},
-		{"Handler.PathLocationHandler", Field, 0, ""},
-		{"Handler.Root", Field, 0, ""},
-		{"Handler.Stderr", Field, 7, ""},
-		{"Request", Func, 0, "func() (*http.Request, error)"},
-		{"RequestFromMap", Func, 0, "func(params map[string]string) (*http.Request, error)"},
-		{"Serve", Func, 0, "func(handler http.Handler) error"},
-	},
-	"net/http/cookiejar": {
-		{"(*Jar).Cookies", Method, 1, ""},
-		{"(*Jar).SetCookies", Method, 1, ""},
-		{"(PublicSuffixList).PublicSuffix", Method, 1, ""},
-		{"(PublicSuffixList).String", Method, 1, ""},
-		{"Jar", Type, 1, ""},
-		{"New", Func, 1, "func(o *Options) (*Jar, error)"},
-		{"Options", Type, 1, ""},
-		{"Options.PublicSuffixList", Field, 1, ""},
-		{"PublicSuffixList", Type, 1, ""},
-	},
-	"net/http/fcgi": {
-		{"ErrConnClosed", Var, 5, ""},
-		{"ErrRequestAborted", Var, 5, ""},
-		{"ProcessEnv", Func, 9, "func(r *http.Request) map[string]string"},
-		{"Serve", Func, 0, "func(l net.Listener, handler http.Handler) error"},
-	},
-	"net/http/httptest": {
-		{"(*ResponseRecorder).Flush", Method, 0, ""},
-		{"(*ResponseRecorder).Header", Method, 0, ""},
-		{"(*ResponseRecorder).Result", Method, 7, ""},
-		{"(*ResponseRecorder).Write", Method, 0, ""},
-		{"(*ResponseRecorder).WriteHeader", Method, 0, ""},
-		{"(*ResponseRecorder).WriteString", Method, 6, ""},
-		{"(*Server).Certificate", Method, 9, ""},
-		{"(*Server).Client", Method, 9, ""},
-		{"(*Server).Close", Method, 0, ""},
-		{"(*Server).CloseClientConnections", Method, 0, ""},
-		{"(*Server).Start", Method, 0, ""},
-		{"(*Server).StartTLS", Method, 0, ""},
-		{"DefaultRemoteAddr", Const, 0, ""},
-		{"NewRecorder", Func, 0, "func() *ResponseRecorder"},
-		{"NewRequest", Func, 7, "func(method string, target string, body io.Reader) *http.Request"},
-		{"NewRequestWithContext", Func, 23, "func(ctx context.Context, method string, target string, body io.Reader) *http.Request"},
-		{"NewServer", Func, 0, "func(handler http.Handler) *Server"},
-		{"NewTLSServer", Func, 0, "func(handler http.Handler) *Server"},
-		{"NewUnstartedServer", Func, 0, "func(handler http.Handler) *Server"},
-		{"ResponseRecorder", Type, 0, ""},
-		{"ResponseRecorder.Body", Field, 0, ""},
-		{"ResponseRecorder.Code", Field, 0, ""},
-		{"ResponseRecorder.Flushed", Field, 0, ""},
-		{"ResponseRecorder.HeaderMap", Field, 0, ""},
-		{"Server", Type, 0, ""},
-		{"Server.Config", Field, 0, ""},
-		{"Server.EnableHTTP2", Field, 14, ""},
-		{"Server.Listener", Field, 0, ""},
-		{"Server.TLS", Field, 0, ""},
-		{"Server.URL", Field, 0, ""},
-	},
-	"net/http/httptrace": {
-		{"ClientTrace", Type, 7, ""},
-		{"ClientTrace.ConnectDone", Field, 7, ""},
-		{"ClientTrace.ConnectStart", Field, 7, ""},
-		{"ClientTrace.DNSDone", Field, 7, ""},
-		{"ClientTrace.DNSStart", Field, 7, ""},
-		{"ClientTrace.GetConn", Field, 7, ""},
-		{"ClientTrace.Got100Continue", Field, 7, ""},
-		{"ClientTrace.Got1xxResponse", Field, 11, ""},
-		{"ClientTrace.GotConn", Field, 7, ""},
-		{"ClientTrace.GotFirstResponseByte", Field, 7, ""},
-		{"ClientTrace.PutIdleConn", Field, 7, ""},
-		{"ClientTrace.TLSHandshakeDone", Field, 8, ""},
-		{"ClientTrace.TLSHandshakeStart", Field, 8, ""},
-		{"ClientTrace.Wait100Continue", Field, 7, ""},
-		{"ClientTrace.WroteHeaderField", Field, 11, ""},
-		{"ClientTrace.WroteHeaders", Field, 7, ""},
-		{"ClientTrace.WroteRequest", Field, 7, ""},
-		{"ContextClientTrace", Func, 7, "func(ctx context.Context) *ClientTrace"},
-		{"DNSDoneInfo", Type, 7, ""},
-		{"DNSDoneInfo.Addrs", Field, 7, ""},
-		{"DNSDoneInfo.Coalesced", Field, 7, ""},
-		{"DNSDoneInfo.Err", Field, 7, ""},
-		{"DNSStartInfo", Type, 7, ""},
-		{"DNSStartInfo.Host", Field, 7, ""},
-		{"GotConnInfo", Type, 7, ""},
-		{"GotConnInfo.Conn", Field, 7, ""},
-		{"GotConnInfo.IdleTime", Field, 7, ""},
-		{"GotConnInfo.Reused", Field, 7, ""},
-		{"GotConnInfo.WasIdle", Field, 7, ""},
-		{"WithClientTrace", Func, 7, "func(ctx context.Context, trace *ClientTrace) context.Context"},
-		{"WroteRequestInfo", Type, 7, ""},
-		{"WroteRequestInfo.Err", Field, 7, ""},
-	},
-	"net/http/httputil": {
-		{"(*ClientConn).Close", Method, 0, ""},
-		{"(*ClientConn).Do", Method, 0, ""},
-		{"(*ClientConn).Hijack", Method, 0, ""},
-		{"(*ClientConn).Pending", Method, 0, ""},
-		{"(*ClientConn).Read", Method, 0, ""},
-		{"(*ClientConn).Write", Method, 0, ""},
-		{"(*ProxyRequest).SetURL", Method, 20, ""},
-		{"(*ProxyRequest).SetXForwarded", Method, 20, ""},
-		{"(*ReverseProxy).ServeHTTP", Method, 0, ""},
-		{"(*ServerConn).Close", Method, 0, ""},
-		{"(*ServerConn).Hijack", Method, 0, ""},
-		{"(*ServerConn).Pending", Method, 0, ""},
-		{"(*ServerConn).Read", Method, 0, ""},
-		{"(*ServerConn).Write", Method, 0, ""},
-		{"(BufferPool).Get", Method, 6, ""},
-		{"(BufferPool).Put", Method, 6, ""},
-		{"BufferPool", Type, 6, ""},
-		{"ClientConn", Type, 0, ""},
-		{"DumpRequest", Func, 0, "func(req *http.Request, body bool) ([]byte, error)"},
-		{"DumpRequestOut", Func, 0, "func(req *http.Request, body bool) ([]byte, error)"},
-		{"DumpResponse", Func, 0, "func(resp *http.Response, body bool) ([]byte, error)"},
-		{"ErrClosed", Var, 0, ""},
-		{"ErrLineTooLong", Var, 0, ""},
-		{"ErrPersistEOF", Var, 0, ""},
-		{"ErrPipeline", Var, 0, ""},
-		{"NewChunkedReader", Func, 0, "func(r io.Reader) io.Reader"},
-		{"NewChunkedWriter", Func, 0, "func(w io.Writer) io.WriteCloser"},
-		{"NewClientConn", Func, 0, "func(c net.Conn, r *bufio.Reader) *ClientConn"},
-		{"NewProxyClientConn", Func, 0, "func(c net.Conn, r *bufio.Reader) *ClientConn"},
-		{"NewServerConn", Func, 0, "func(c net.Conn, r *bufio.Reader) *ServerConn"},
-		{"NewSingleHostReverseProxy", Func, 0, "func(target *url.URL) *ReverseProxy"},
-		{"ProxyRequest", Type, 20, ""},
-		{"ProxyRequest.In", Field, 20, ""},
-		{"ProxyRequest.Out", Field, 20, ""},
-		{"ReverseProxy", Type, 0, ""},
-		{"ReverseProxy.BufferPool", Field, 6, ""},
-		{"ReverseProxy.Director", Field, 0, ""},
-		{"ReverseProxy.ErrorHandler", Field, 11, ""},
-		{"ReverseProxy.ErrorLog", Field, 4, ""},
-		{"ReverseProxy.FlushInterval", Field, 0, ""},
-		{"ReverseProxy.ModifyResponse", Field, 8, ""},
-		{"ReverseProxy.Rewrite", Field, 20, ""},
-		{"ReverseProxy.Transport", Field, 0, ""},
-		{"ServerConn", Type, 0, ""},
-	},
-	"net/http/pprof": {
-		{"Cmdline", Func, 0, "func(w http.ResponseWriter, r *http.Request)"},
-		{"Handler", Func, 0, "func(name string) http.Handler"},
-		{"Index", Func, 0, "func(w http.ResponseWriter, r *http.Request)"},
-		{"Profile", Func, 0, "func(w http.ResponseWriter, r *http.Request)"},
-		{"Symbol", Func, 0, "func(w http.ResponseWriter, r *http.Request)"},
-		{"Trace", Func, 5, "func(w http.ResponseWriter, r *http.Request)"},
-	},
-	"net/mail": {
-		{"(*Address).String", Method, 0, ""},
-		{"(*AddressParser).Parse", Method, 5, ""},
-		{"(*AddressParser).ParseList", Method, 5, ""},
-		{"(Header).AddressList", Method, 0, ""},
-		{"(Header).Date", Method, 0, ""},
-		{"(Header).Get", Method, 0, ""},
-		{"Address", Type, 0, ""},
-		{"Address.Address", Field, 0, ""},
-		{"Address.Name", Field, 0, ""},
-		{"AddressParser", Type, 5, ""},
-		{"AddressParser.WordDecoder", Field, 5, ""},
-		{"ErrHeaderNotPresent", Var, 0, ""},
-		{"Header", Type, 0, ""},
-		{"Message", Type, 0, ""},
-		{"Message.Body", Field, 0, ""},
-		{"Message.Header", Field, 0, ""},
-		{"ParseAddress", Func, 1, "func(address string) (*Address, error)"},
-		{"ParseAddressList", Func, 1, "func(list string) ([]*Address, error)"},
-		{"ParseDate", Func, 8, "func(date string) (time.Time, error)"},
-		{"ReadMessage", Func, 0, "func(r io.Reader) (msg *Message, err error)"},
-	},
-	"net/netip": {
-		{"(*Addr).UnmarshalBinary", Method, 18, ""},
-		{"(*Addr).UnmarshalText", Method, 18, ""},
-		{"(*AddrPort).UnmarshalBinary", Method, 18, ""},
-		{"(*AddrPort).UnmarshalText", Method, 18, ""},
-		{"(*Prefix).UnmarshalBinary", Method, 18, ""},
-		{"(*Prefix).UnmarshalText", Method, 18, ""},
-		{"(Addr).AppendBinary", Method, 24, ""},
-		{"(Addr).AppendText", Method, 24, ""},
-		{"(Addr).AppendTo", Method, 18, ""},
-		{"(Addr).As16", Method, 18, ""},
-		{"(Addr).As4", Method, 18, ""},
-		{"(Addr).AsSlice", Method, 18, ""},
-		{"(Addr).BitLen", Method, 18, ""},
-		{"(Addr).Compare", Method, 18, ""},
-		{"(Addr).Is4", Method, 18, ""},
-		{"(Addr).Is4In6", Method, 18, ""},
-		{"(Addr).Is6", Method, 18, ""},
-		{"(Addr).IsGlobalUnicast", Method, 18, ""},
-		{"(Addr).IsInterfaceLocalMulticast", Method, 18, ""},
-		{"(Addr).IsLinkLocalMulticast", Method, 18, ""},
-		{"(Addr).IsLinkLocalUnicast", Method, 18, ""},
-		{"(Addr).IsLoopback", Method, 18, ""},
-		{"(Addr).IsMulticast", Method, 18, ""},
-		{"(Addr).IsPrivate", Method, 18, ""},
-		{"(Addr).IsUnspecified", Method, 18, ""},
-		{"(Addr).IsValid", Method, 18, ""},
-		{"(Addr).Less", Method, 18, ""},
-		{"(Addr).MarshalBinary", Method, 18, ""},
-		{"(Addr).MarshalText", Method, 18, ""},
-		{"(Addr).Next", Method, 18, ""},
-		{"(Addr).Prefix", Method, 18, ""},
-		{"(Addr).Prev", Method, 18, ""},
-		{"(Addr).String", Method, 18, ""},
-		{"(Addr).StringExpanded", Method, 18, ""},
-		{"(Addr).Unmap", Method, 18, ""},
-		{"(Addr).WithZone", Method, 18, ""},
-		{"(Addr).Zone", Method, 18, ""},
-		{"(AddrPort).Addr", Method, 18, ""},
-		{"(AddrPort).AppendBinary", Method, 24, ""},
-		{"(AddrPort).AppendText", Method, 24, ""},
-		{"(AddrPort).AppendTo", Method, 18, ""},
-		{"(AddrPort).Compare", Method, 22, ""},
-		{"(AddrPort).IsValid", Method, 18, ""},
-		{"(AddrPort).MarshalBinary", Method, 18, ""},
-		{"(AddrPort).MarshalText", Method, 18, ""},
-		{"(AddrPort).Port", Method, 18, ""},
-		{"(AddrPort).String", Method, 18, ""},
-		{"(Prefix).Addr", Method, 18, ""},
-		{"(Prefix).AppendBinary", Method, 24, ""},
-		{"(Prefix).AppendText", Method, 24, ""},
-		{"(Prefix).AppendTo", Method, 18, ""},
-		{"(Prefix).Bits", Method, 18, ""},
-		{"(Prefix).Compare", Method, 26, ""},
-		{"(Prefix).Contains", Method, 18, ""},
-		{"(Prefix).IsSingleIP", Method, 18, ""},
-		{"(Prefix).IsValid", Method, 18, ""},
-		{"(Prefix).MarshalBinary", Method, 18, ""},
-		{"(Prefix).MarshalText", Method, 18, ""},
-		{"(Prefix).Masked", Method, 18, ""},
-		{"(Prefix).Overlaps", Method, 18, ""},
-		{"(Prefix).String", Method, 18, ""},
-		{"Addr", Type, 18, ""},
-		{"AddrFrom16", Func, 18, "func(addr [16]byte) Addr"},
-		{"AddrFrom4", Func, 18, "func(addr [4]byte) Addr"},
-		{"AddrFromSlice", Func, 18, "func(slice []byte) (ip Addr, ok bool)"},
-		{"AddrPort", Type, 18, ""},
-		{"AddrPortFrom", Func, 18, "func(ip Addr, port uint16) AddrPort"},
-		{"IPv4Unspecified", Func, 18, "func() Addr"},
-		{"IPv6LinkLocalAllNodes", Func, 18, "func() Addr"},
-		{"IPv6LinkLocalAllRouters", Func, 20, "func() Addr"},
-		{"IPv6Loopback", Func, 20, "func() Addr"},
-		{"IPv6Unspecified", Func, 18, "func() Addr"},
-		{"MustParseAddr", Func, 18, "func(s string) Addr"},
-		{"MustParseAddrPort", Func, 18, "func(s string) AddrPort"},
-		{"MustParsePrefix", Func, 18, "func(s string) Prefix"},
-		{"ParseAddr", Func, 18, "func(s string) (Addr, error)"},
-		{"ParseAddrPort", Func, 18, "func(s string) (AddrPort, error)"},
-		{"ParsePrefix", Func, 18, "func(s string) (Prefix, error)"},
-		{"Prefix", Type, 18, ""},
-		{"PrefixFrom", Func, 18, "func(ip Addr, bits int) Prefix"},
-	},
-	"net/rpc": {
-		{"(*Client).Call", Method, 0, ""},
-		{"(*Client).Close", Method, 0, ""},
-		{"(*Client).Go", Method, 0, ""},
-		{"(*Server).Accept", Method, 0, ""},
-		{"(*Server).HandleHTTP", Method, 0, ""},
-		{"(*Server).Register", Method, 0, ""},
-		{"(*Server).RegisterName", Method, 0, ""},
-		{"(*Server).ServeCodec", Method, 0, ""},
-		{"(*Server).ServeConn", Method, 0, ""},
-		{"(*Server).ServeHTTP", Method, 0, ""},
-		{"(*Server).ServeRequest", Method, 0, ""},
-		{"(ClientCodec).Close", Method, 0, ""},
-		{"(ClientCodec).ReadResponseBody", Method, 0, ""},
-		{"(ClientCodec).ReadResponseHeader", Method, 0, ""},
-		{"(ClientCodec).WriteRequest", Method, 0, ""},
-		{"(ServerCodec).Close", Method, 0, ""},
-		{"(ServerCodec).ReadRequestBody", Method, 0, ""},
-		{"(ServerCodec).ReadRequestHeader", Method, 0, ""},
-		{"(ServerCodec).WriteResponse", Method, 0, ""},
-		{"(ServerError).Error", Method, 0, ""},
-		{"Accept", Func, 0, "func(lis net.Listener)"},
-		{"Call", Type, 0, ""},
-		{"Call.Args", Field, 0, ""},
-		{"Call.Done", Field, 0, ""},
-		{"Call.Error", Field, 0, ""},
-		{"Call.Reply", Field, 0, ""},
-		{"Call.ServiceMethod", Field, 0, ""},
-		{"Client", Type, 0, ""},
-		{"ClientCodec", Type, 0, ""},
-		{"DefaultDebugPath", Const, 0, ""},
-		{"DefaultRPCPath", Const, 0, ""},
-		{"DefaultServer", Var, 0, ""},
-		{"Dial", Func, 0, "func(network string, address string) (*Client, error)"},
-		{"DialHTTP", Func, 0, "func(network string, address string) (*Client, error)"},
-		{"DialHTTPPath", Func, 0, "func(network string, address string, path string) (*Client, error)"},
-		{"ErrShutdown", Var, 0, ""},
-		{"HandleHTTP", Func, 0, "func()"},
-		{"NewClient", Func, 0, "func(conn io.ReadWriteCloser) *Client"},
-		{"NewClientWithCodec", Func, 0, "func(codec ClientCodec) *Client"},
-		{"NewServer", Func, 0, "func() *Server"},
-		{"Register", Func, 0, "func(rcvr any) error"},
-		{"RegisterName", Func, 0, "func(name string, rcvr any) error"},
-		{"Request", Type, 0, ""},
-		{"Request.Seq", Field, 0, ""},
-		{"Request.ServiceMethod", Field, 0, ""},
-		{"Response", Type, 0, ""},
-		{"Response.Error", Field, 0, ""},
-		{"Response.Seq", Field, 0, ""},
-		{"Response.ServiceMethod", Field, 0, ""},
-		{"ServeCodec", Func, 0, "func(codec ServerCodec)"},
-		{"ServeConn", Func, 0, "func(conn io.ReadWriteCloser)"},
-		{"ServeRequest", Func, 0, "func(codec ServerCodec) error"},
-		{"Server", Type, 0, ""},
-		{"ServerCodec", Type, 0, ""},
-		{"ServerError", Type, 0, ""},
-	},
-	"net/rpc/jsonrpc": {
-		{"Dial", Func, 0, "func(network string, address string) (*rpc.Client, error)"},
-		{"NewClient", Func, 0, "func(conn io.ReadWriteCloser) *rpc.Client"},
-		{"NewClientCodec", Func, 0, "func(conn io.ReadWriteCloser) rpc.ClientCodec"},
-		{"NewServerCodec", Func, 0, "func(conn io.ReadWriteCloser) rpc.ServerCodec"},
-		{"ServeConn", Func, 0, "func(conn io.ReadWriteCloser)"},
-	},
-	"net/smtp": {
-		{"(*Client).Auth", Method, 0, ""},
-		{"(*Client).Close", Method, 2, ""},
-		{"(*Client).Data", Method, 0, ""},
-		{"(*Client).Extension", Method, 0, ""},
-		{"(*Client).Hello", Method, 1, ""},
-		{"(*Client).Mail", Method, 0, ""},
-		{"(*Client).Noop", Method, 10, ""},
-		{"(*Client).Quit", Method, 0, ""},
-		{"(*Client).Rcpt", Method, 0, ""},
-		{"(*Client).Reset", Method, 0, ""},
-		{"(*Client).StartTLS", Method, 0, ""},
-		{"(*Client).TLSConnectionState", Method, 5, ""},
-		{"(*Client).Verify", Method, 0, ""},
-		{"(Auth).Next", Method, 0, ""},
-		{"(Auth).Start", Method, 0, ""},
-		{"Auth", Type, 0, ""},
-		{"CRAMMD5Auth", Func, 0, "func(username string, secret string) Auth"},
-		{"Client", Type, 0, ""},
-		{"Client.Text", Field, 0, ""},
-		{"Dial", Func, 0, "func(addr string) (*Client, error)"},
-		{"NewClient", Func, 0, "func(conn net.Conn, host string) (*Client, error)"},
-		{"PlainAuth", Func, 0, "func(identity string, username string, password string, host string) Auth"},
-		{"SendMail", Func, 0, "func(addr string, a Auth, from string, to []string, msg []byte) error"},
-		{"ServerInfo", Type, 0, ""},
-		{"ServerInfo.Auth", Field, 0, ""},
-		{"ServerInfo.Name", Field, 0, ""},
-		{"ServerInfo.TLS", Field, 0, ""},
-	},
-	"net/textproto": {
-		{"(*Conn).Close", Method, 0, ""},
-		{"(*Conn).Cmd", Method, 0, ""},
-		{"(*Conn).DotReader", Method, 0, ""},
-		{"(*Conn).DotWriter", Method, 0, ""},
-		{"(*Conn).EndRequest", Method, 0, ""},
-		{"(*Conn).EndResponse", Method, 0, ""},
-		{"(*Conn).Next", Method, 0, ""},
-		{"(*Conn).PrintfLine", Method, 0, ""},
-		{"(*Conn).ReadCodeLine", Method, 0, ""},
-		{"(*Conn).ReadContinuedLine", Method, 0, ""},
-		{"(*Conn).ReadContinuedLineBytes", Method, 0, ""},
-		{"(*Conn).ReadDotBytes", Method, 0, ""},
-		{"(*Conn).ReadDotLines", Method, 0, ""},
-		{"(*Conn).ReadLine", Method, 0, ""},
-		{"(*Conn).ReadLineBytes", Method, 0, ""},
-		{"(*Conn).ReadMIMEHeader", Method, 0, ""},
-		{"(*Conn).ReadResponse", Method, 0, ""},
-		{"(*Conn).StartRequest", Method, 0, ""},
-		{"(*Conn).StartResponse", Method, 0, ""},
-		{"(*Error).Error", Method, 0, ""},
-		{"(*Pipeline).EndRequest", Method, 0, ""},
-		{"(*Pipeline).EndResponse", Method, 0, ""},
-		{"(*Pipeline).Next", Method, 0, ""},
-		{"(*Pipeline).StartRequest", Method, 0, ""},
-		{"(*Pipeline).StartResponse", Method, 0, ""},
-		{"(*Reader).DotReader", Method, 0, ""},
-		{"(*Reader).ReadCodeLine", Method, 0, ""},
-		{"(*Reader).ReadContinuedLine", Method, 0, ""},
-		{"(*Reader).ReadContinuedLineBytes", Method, 0, ""},
-		{"(*Reader).ReadDotBytes", Method, 0, ""},
-		{"(*Reader).ReadDotLines", Method, 0, ""},
-		{"(*Reader).ReadLine", Method, 0, ""},
-		{"(*Reader).ReadLineBytes", Method, 0, ""},
-		{"(*Reader).ReadMIMEHeader", Method, 0, ""},
-		{"(*Reader).ReadResponse", Method, 0, ""},
-		{"(*Writer).DotWriter", Method, 0, ""},
-		{"(*Writer).PrintfLine", Method, 0, ""},
-		{"(MIMEHeader).Add", Method, 0, ""},
-		{"(MIMEHeader).Del", Method, 0, ""},
-		{"(MIMEHeader).Get", Method, 0, ""},
-		{"(MIMEHeader).Set", Method, 0, ""},
-		{"(MIMEHeader).Values", Method, 14, ""},
-		{"(ProtocolError).Error", Method, 0, ""},
-		{"CanonicalMIMEHeaderKey", Func, 0, "func(s string) string"},
-		{"Conn", Type, 0, ""},
-		{"Conn.Pipeline", Field, 0, ""},
-		{"Conn.Reader", Field, 0, ""},
-		{"Conn.Writer", Field, 0, ""},
-		{"Dial", Func, 0, "func(network string, addr string) (*Conn, error)"},
-		{"Error", Type, 0, ""},
-		{"Error.Code", Field, 0, ""},
-		{"Error.Msg", Field, 0, ""},
-		{"MIMEHeader", Type, 0, ""},
-		{"NewConn", Func, 0, "func(conn io.ReadWriteCloser) *Conn"},
-		{"NewReader", Func, 0, "func(r *bufio.Reader) *Reader"},
-		{"NewWriter", Func, 0, "func(w *bufio.Writer) *Writer"},
-		{"Pipeline", Type, 0, ""},
-		{"ProtocolError", Type, 0, ""},
-		{"Reader", Type, 0, ""},
-		{"Reader.R", Field, 0, ""},
-		{"TrimBytes", Func, 1, "func(b []byte) []byte"},
-		{"TrimString", Func, 1, "func(s string) string"},
-		{"Writer", Type, 0, ""},
-		{"Writer.W", Field, 0, ""},
-	},
-	"net/url": {
-		{"(*Error).Error", Method, 0, ""},
-		{"(*Error).Temporary", Method, 6, ""},
-		{"(*Error).Timeout", Method, 6, ""},
-		{"(*Error).Unwrap", Method, 13, ""},
-		{"(*URL).AppendBinary", Method, 24, ""},
-		{"(*URL).EscapedFragment", Method, 15, ""},
-		{"(*URL).EscapedPath", Method, 5, ""},
-		{"(*URL).Hostname", Method, 8, ""},
-		{"(*URL).IsAbs", Method, 0, ""},
-		{"(*URL).JoinPath", Method, 19, ""},
-		{"(*URL).MarshalBinary", Method, 8, ""},
-		{"(*URL).Parse", Method, 0, ""},
-		{"(*URL).Port", Method, 8, ""},
-		{"(*URL).Query", Method, 0, ""},
-		{"(*URL).Redacted", Method, 15, ""},
-		{"(*URL).RequestURI", Method, 0, ""},
-		{"(*URL).ResolveReference", Method, 0, ""},
-		{"(*URL).String", Method, 0, ""},
-		{"(*URL).UnmarshalBinary", Method, 8, ""},
-		{"(*Userinfo).Password", Method, 0, ""},
-		{"(*Userinfo).String", Method, 0, ""},
-		{"(*Userinfo).Username", Method, 0, ""},
-		{"(EscapeError).Error", Method, 0, ""},
-		{"(InvalidHostError).Error", Method, 6, ""},
-		{"(Values).Add", Method, 0, ""},
-		{"(Values).Del", Method, 0, ""},
-		{"(Values).Encode", Method, 0, ""},
-		{"(Values).Get", Method, 0, ""},
-		{"(Values).Has", Method, 17, ""},
-		{"(Values).Set", Method, 0, ""},
-		{"Error", Type, 0, ""},
-		{"Error.Err", Field, 0, ""},
-		{"Error.Op", Field, 0, ""},
-		{"Error.URL", Field, 0, ""},
-		{"EscapeError", Type, 0, ""},
-		{"InvalidHostError", Type, 6, ""},
-		{"JoinPath", Func, 19, "func(base string, elem ...string) (result string, err error)"},
-		{"Parse", Func, 0, "func(rawURL string) (*URL, error)"},
-		{"ParseQuery", Func, 0, "func(query string) (Values, error)"},
-		{"ParseRequestURI", Func, 0, "func(rawURL string) (*URL, error)"},
-		{"PathEscape", Func, 8, "func(s string) string"},
-		{"PathUnescape", Func, 8, "func(s string) (string, error)"},
-		{"QueryEscape", Func, 0, "func(s string) string"},
-		{"QueryUnescape", Func, 0, "func(s string) (string, error)"},
-		{"URL", Type, 0, ""},
-		{"URL.ForceQuery", Field, 7, ""},
-		{"URL.Fragment", Field, 0, ""},
-		{"URL.Host", Field, 0, ""},
-		{"URL.OmitHost", Field, 19, ""},
-		{"URL.Opaque", Field, 0, ""},
-		{"URL.Path", Field, 0, ""},
-		{"URL.RawFragment", Field, 15, ""},
-		{"URL.RawPath", Field, 5, ""},
-		{"URL.RawQuery", Field, 0, ""},
-		{"URL.Scheme", Field, 0, ""},
-		{"URL.User", Field, 0, ""},
-		{"User", Func, 0, "func(username string) *Userinfo"},
-		{"UserPassword", Func, 0, "func(username string, password string) *Userinfo"},
-		{"Userinfo", Type, 0, ""},
-		{"Values", Type, 0, ""},
-	},
-	"os": {
-		{"(*File).Chdir", Method, 0, ""},
-		{"(*File).Chmod", Method, 0, ""},
-		{"(*File).Chown", Method, 0, ""},
-		{"(*File).Close", Method, 0, ""},
-		{"(*File).Fd", Method, 0, ""},
-		{"(*File).Name", Method, 0, ""},
-		{"(*File).Read", Method, 0, ""},
-		{"(*File).ReadAt", Method, 0, ""},
-		{"(*File).ReadDir", Method, 16, ""},
-		{"(*File).ReadFrom", Method, 15, ""},
-		{"(*File).Readdir", Method, 0, ""},
-		{"(*File).Readdirnames", Method, 0, ""},
-		{"(*File).Seek", Method, 0, ""},
-		{"(*File).SetDeadline", Method, 10, ""},
-		{"(*File).SetReadDeadline", Method, 10, ""},
-		{"(*File).SetWriteDeadline", Method, 10, ""},
-		{"(*File).Stat", Method, 0, ""},
-		{"(*File).Sync", Method, 0, ""},
-		{"(*File).SyscallConn", Method, 12, ""},
-		{"(*File).Truncate", Method, 0, ""},
-		{"(*File).Write", Method, 0, ""},
-		{"(*File).WriteAt", Method, 0, ""},
-		{"(*File).WriteString", Method, 0, ""},
-		{"(*File).WriteTo", Method, 22, ""},
-		{"(*LinkError).Error", Method, 0, ""},
-		{"(*LinkError).Unwrap", Method, 13, ""},
-		{"(*PathError).Error", Method, 0, ""},
-		{"(*PathError).Timeout", Method, 10, ""},
-		{"(*PathError).Unwrap", Method, 13, ""},
-		{"(*Process).Kill", Method, 0, ""},
-		{"(*Process).Release", Method, 0, ""},
-		{"(*Process).Signal", Method, 0, ""},
-		{"(*Process).Wait", Method, 0, ""},
-		{"(*Process).WithHandle", Method, 26, ""},
-		{"(*ProcessState).ExitCode", Method, 12, ""},
-		{"(*ProcessState).Exited", Method, 0, ""},
-		{"(*ProcessState).Pid", Method, 0, ""},
-		{"(*ProcessState).String", Method, 0, ""},
-		{"(*ProcessState).Success", Method, 0, ""},
-		{"(*ProcessState).Sys", Method, 0, ""},
-		{"(*ProcessState).SysUsage", Method, 0, ""},
-		{"(*ProcessState).SystemTime", Method, 0, ""},
-		{"(*ProcessState).UserTime", Method, 0, ""},
-		{"(*Root).Chmod", Method, 25, ""},
-		{"(*Root).Chown", Method, 25, ""},
-		{"(*Root).Chtimes", Method, 25, ""},
-		{"(*Root).Close", Method, 24, ""},
-		{"(*Root).Create", Method, 24, ""},
-		{"(*Root).FS", Method, 24, ""},
-		{"(*Root).Lchown", Method, 25, ""},
-		{"(*Root).Link", Method, 25, ""},
-		{"(*Root).Lstat", Method, 24, ""},
-		{"(*Root).Mkdir", Method, 24, ""},
-		{"(*Root).MkdirAll", Method, 25, ""},
-		{"(*Root).Name", Method, 24, ""},
-		{"(*Root).Open", Method, 24, ""},
-		{"(*Root).OpenFile", Method, 24, ""},
-		{"(*Root).OpenRoot", Method, 24, ""},
-		{"(*Root).ReadFile", Method, 25, ""},
-		{"(*Root).Readlink", Method, 25, ""},
-		{"(*Root).Remove", Method, 24, ""},
-		{"(*Root).RemoveAll", Method, 25, ""},
-		{"(*Root).Rename", Method, 25, ""},
-		{"(*Root).Stat", Method, 24, ""},
-		{"(*Root).Symlink", Method, 25, ""},
-		{"(*Root).WriteFile", Method, 25, ""},
-		{"(*SyscallError).Error", Method, 0, ""},
-		{"(*SyscallError).Timeout", Method, 10, ""},
-		{"(*SyscallError).Unwrap", Method, 13, ""},
-		{"(FileInfo).IsDir", Method, 0, ""},
-		{"(FileInfo).ModTime", Method, 0, ""},
-		{"(FileInfo).Mode", Method, 0, ""},
-		{"(FileInfo).Name", Method, 0, ""},
-		{"(FileInfo).Size", Method, 0, ""},
-		{"(FileInfo).Sys", Method, 0, ""},
-		{"(FileMode).IsDir", Method, 0, ""},
-		{"(FileMode).IsRegular", Method, 1, ""},
-		{"(FileMode).Perm", Method, 0, ""},
-		{"(FileMode).String", Method, 0, ""},
-		{"(Signal).Signal", Method, 0, ""},
-		{"(Signal).String", Method, 0, ""},
-		{"Args", Var, 0, ""},
-		{"Chdir", Func, 0, "func(dir string) error"},
-		{"Chmod", Func, 0, "func(name string, mode FileMode) error"},
-		{"Chown", Func, 0, "func(name string, uid int, gid int) error"},
-		{"Chtimes", Func, 0, "func(name string, atime time.Time, mtime time.Time) error"},
-		{"Clearenv", Func, 0, "func()"},
-		{"CopyFS", Func, 23, "func(dir string, fsys fs.FS) error"},
-		{"Create", Func, 0, "func(name string) (*File, error)"},
-		{"CreateTemp", Func, 16, "func(dir string, pattern string) (*File, error)"},
-		{"DevNull", Const, 0, ""},
-		{"DirEntry", Type, 16, ""},
-		{"DirFS", Func, 16, "func(dir string) fs.FS"},
-		{"Environ", Func, 0, "func() []string"},
-		{"ErrClosed", Var, 8, ""},
-		{"ErrDeadlineExceeded", Var, 15, ""},
-		{"ErrExist", Var, 0, ""},
-		{"ErrInvalid", Var, 0, ""},
-		{"ErrNoDeadline", Var, 10, ""},
-		{"ErrNoHandle", Var, 26, ""},
-		{"ErrNotExist", Var, 0, ""},
-		{"ErrPermission", Var, 0, ""},
-		{"ErrProcessDone", Var, 16, ""},
-		{"Executable", Func, 8, "func() (string, error)"},
-		{"Exit", Func, 0, "func(code int)"},
-		{"Expand", Func, 0, "func(s string, mapping func(string) string) string"},
-		{"ExpandEnv", Func, 0, "func(s string) string"},
-		{"File", Type, 0, ""},
-		{"FileInfo", Type, 0, ""},
-		{"FileMode", Type, 0, ""},
-		{"FindProcess", Func, 0, "func(pid int) (*Process, error)"},
-		{"Getegid", Func, 0, "func() int"},
-		{"Getenv", Func, 0, "func(key string) string"},
-		{"Geteuid", Func, 0, "func() int"},
-		{"Getgid", Func, 0, "func() int"},
-		{"Getgroups", Func, 0, "func() ([]int, error)"},
-		{"Getpagesize", Func, 0, "func() int"},
-		{"Getpid", Func, 0, "func() int"},
-		{"Getppid", Func, 0, "func() int"},
-		{"Getuid", Func, 0, "func() int"},
-		{"Getwd", Func, 0, "func() (dir string, err error)"},
-		{"Hostname", Func, 0, "func() (name string, err error)"},
-		{"Interrupt", Var, 0, ""},
-		{"IsExist", Func, 0, "func(err error) bool"},
-		{"IsNotExist", Func, 0, "func(err error) bool"},
-		{"IsPathSeparator", Func, 0, "func(c uint8) bool"},
-		{"IsPermission", Func, 0, "func(err error) bool"},
-		{"IsTimeout", Func, 10, "func(err error) bool"},
-		{"Kill", Var, 0, ""},
-		{"Lchown", Func, 0, "func(name string, uid int, gid int) error"},
-		{"Link", Func, 0, "func(oldname string, newname string) error"},
-		{"LinkError", Type, 0, ""},
-		{"LinkError.Err", Field, 0, ""},
-		{"LinkError.New", Field, 0, ""},
-		{"LinkError.Old", Field, 0, ""},
-		{"LinkError.Op", Field, 0, ""},
-		{"LookupEnv", Func, 5, "func(key string) (string, bool)"},
-		{"Lstat", Func, 0, "func(name string) (FileInfo, error)"},
-		{"Mkdir", Func, 0, "func(name string, perm FileMode) error"},
-		{"MkdirAll", Func, 0, "func(path string, perm FileMode) error"},
-		{"MkdirTemp", Func, 16, "func(dir string, pattern string) (string, error)"},
-		{"ModeAppend", Const, 0, ""},
-		{"ModeCharDevice", Const, 0, ""},
-		{"ModeDevice", Const, 0, ""},
-		{"ModeDir", Const, 0, ""},
-		{"ModeExclusive", Const, 0, ""},
-		{"ModeIrregular", Const, 11, ""},
-		{"ModeNamedPipe", Const, 0, ""},
-		{"ModePerm", Const, 0, ""},
-		{"ModeSetgid", Const, 0, ""},
-		{"ModeSetuid", Const, 0, ""},
-		{"ModeSocket", Const, 0, ""},
-		{"ModeSticky", Const, 0, ""},
-		{"ModeSymlink", Const, 0, ""},
-		{"ModeTemporary", Const, 0, ""},
-		{"ModeType", Const, 0, ""},
-		{"NewFile", Func, 0, "func(fd uintptr, name string) *File"},
-		{"NewSyscallError", Func, 0, "func(syscall string, err error) error"},
-		{"O_APPEND", Const, 0, ""},
-		{"O_CREATE", Const, 0, ""},
-		{"O_EXCL", Const, 0, ""},
-		{"O_RDONLY", Const, 0, ""},
-		{"O_RDWR", Const, 0, ""},
-		{"O_SYNC", Const, 0, ""},
-		{"O_TRUNC", Const, 0, ""},
-		{"O_WRONLY", Const, 0, ""},
-		{"Open", Func, 0, "func(name string) (*File, error)"},
-		{"OpenFile", Func, 0, "func(name string, flag int, perm FileMode) (*File, error)"},
-		{"OpenInRoot", Func, 24, "func(dir string, name string) (*File, error)"},
-		{"OpenRoot", Func, 24, "func(name string) (*Root, error)"},
-		{"PathError", Type, 0, ""},
-		{"PathError.Err", Field, 0, ""},
-		{"PathError.Op", Field, 0, ""},
-		{"PathError.Path", Field, 0, ""},
-		{"PathListSeparator", Const, 0, ""},
-		{"PathSeparator", Const, 0, ""},
-		{"Pipe", Func, 0, "func() (r *File, w *File, err error)"},
-		{"ProcAttr", Type, 0, ""},
-		{"ProcAttr.Dir", Field, 0, ""},
-		{"ProcAttr.Env", Field, 0, ""},
-		{"ProcAttr.Files", Field, 0, ""},
-		{"ProcAttr.Sys", Field, 0, ""},
-		{"Process", Type, 0, ""},
-		{"Process.Pid", Field, 0, ""},
-		{"ProcessState", Type, 0, ""},
-		{"ReadDir", Func, 16, "func(name string) ([]DirEntry, error)"},
-		{"ReadFile", Func, 16, "func(name string) ([]byte, error)"},
-		{"Readlink", Func, 0, "func(name string) (string, error)"},
-		{"Remove", Func, 0, "func(name string) error"},
-		{"RemoveAll", Func, 0, "func(path string) error"},
-		{"Rename", Func, 0, "func(oldpath string, newpath string) error"},
-		{"Root", Type, 24, ""},
-		{"SEEK_CUR", Const, 0, ""},
-		{"SEEK_END", Const, 0, ""},
-		{"SEEK_SET", Const, 0, ""},
-		{"SameFile", Func, 0, "func(fi1 FileInfo, fi2 FileInfo) bool"},
-		{"Setenv", Func, 0, "func(key string, value string) error"},
-		{"Signal", Type, 0, ""},
-		{"StartProcess", Func, 0, "func(name string, argv []string, attr *ProcAttr) (*Process, error)"},
-		{"Stat", Func, 0, "func(name string) (FileInfo, error)"},
-		{"Stderr", Var, 0, ""},
-		{"Stdin", Var, 0, ""},
-		{"Stdout", Var, 0, ""},
-		{"Symlink", Func, 0, "func(oldname string, newname string) error"},
-		{"SyscallError", Type, 0, ""},
-		{"SyscallError.Err", Field, 0, ""},
-		{"SyscallError.Syscall", Field, 0, ""},
-		{"TempDir", Func, 0, "func() string"},
-		{"Truncate", Func, 0, "func(name string, size int64) error"},
-		{"Unsetenv", Func, 4, "func(key string) error"},
-		{"UserCacheDir", Func, 11, "func() (string, error)"},
-		{"UserConfigDir", Func, 13, "func() (string, error)"},
-		{"UserHomeDir", Func, 12, "func() (string, error)"},
-		{"WriteFile", Func, 16, "func(name string, data []byte, perm FileMode) error"},
-	},
-	"os/exec": {
-		{"(*Cmd).CombinedOutput", Method, 0, ""},
-		{"(*Cmd).Environ", Method, 19, ""},
-		{"(*Cmd).Output", Method, 0, ""},
-		{"(*Cmd).Run", Method, 0, ""},
-		{"(*Cmd).Start", Method, 0, ""},
-		{"(*Cmd).StderrPipe", Method, 0, ""},
-		{"(*Cmd).StdinPipe", Method, 0, ""},
-		{"(*Cmd).StdoutPipe", Method, 0, ""},
-		{"(*Cmd).String", Method, 13, ""},
-		{"(*Cmd).Wait", Method, 0, ""},
-		{"(*Error).Error", Method, 0, ""},
-		{"(*Error).Unwrap", Method, 13, ""},
-		{"(*ExitError).Error", Method, 0, ""},
-		{"(ExitError).ExitCode", Method, 12, ""},
-		{"(ExitError).Exited", Method, 0, ""},
-		{"(ExitError).Pid", Method, 0, ""},
-		{"(ExitError).String", Method, 0, ""},
-		{"(ExitError).Success", Method, 0, ""},
-		{"(ExitError).Sys", Method, 0, ""},
-		{"(ExitError).SysUsage", Method, 0, ""},
-		{"(ExitError).SystemTime", Method, 0, ""},
-		{"(ExitError).UserTime", Method, 0, ""},
-		{"Cmd", Type, 0, ""},
-		{"Cmd.Args", Field, 0, ""},
-		{"Cmd.Cancel", Field, 20, ""},
-		{"Cmd.Dir", Field, 0, ""},
-		{"Cmd.Env", Field, 0, ""},
-		{"Cmd.Err", Field, 19, ""},
-		{"Cmd.ExtraFiles", Field, 0, ""},
-		{"Cmd.Path", Field, 0, ""},
-		{"Cmd.Process", Field, 0, ""},
-		{"Cmd.ProcessState", Field, 0, ""},
-		{"Cmd.Stderr", Field, 0, ""},
-		{"Cmd.Stdin", Field, 0, ""},
-		{"Cmd.Stdout", Field, 0, ""},
-		{"Cmd.SysProcAttr", Field, 0, ""},
-		{"Cmd.WaitDelay", Field, 20, ""},
-		{"Command", Func, 0, "func(name string, arg ...string) *Cmd"},
-		{"CommandContext", Func, 7, "func(ctx context.Context, name string, arg ...string) *Cmd"},
-		{"ErrDot", Var, 19, ""},
-		{"ErrNotFound", Var, 0, ""},
-		{"ErrWaitDelay", Var, 20, ""},
-		{"Error", Type, 0, ""},
-		{"Error.Err", Field, 0, ""},
-		{"Error.Name", Field, 0, ""},
-		{"ExitError", Type, 0, ""},
-		{"ExitError.ProcessState", Field, 0, ""},
-		{"ExitError.Stderr", Field, 6, ""},
-		{"LookPath", Func, 0, "func(file string) (string, error)"},
-	},
-	"os/signal": {
-		{"Ignore", Func, 5, "func(sig ...os.Signal)"},
-		{"Ignored", Func, 11, "func(sig os.Signal) bool"},
-		{"Notify", Func, 0, "func(c chan<- os.Signal, sig ...os.Signal)"},
-		{"NotifyContext", Func, 16, "func(parent context.Context, signals ...os.Signal) (ctx context.Context, stop context.CancelFunc)"},
-		{"Reset", Func, 5, "func(sig ...os.Signal)"},
-		{"Stop", Func, 1, "func(c chan<- os.Signal)"},
-	},
-	"os/user": {
-		{"(*User).GroupIds", Method, 7, ""},
-		{"(UnknownGroupError).Error", Method, 7, ""},
-		{"(UnknownGroupIdError).Error", Method, 7, ""},
-		{"(UnknownUserError).Error", Method, 0, ""},
-		{"(UnknownUserIdError).Error", Method, 0, ""},
-		{"Current", Func, 0, "func() (*User, error)"},
-		{"Group", Type, 7, ""},
-		{"Group.Gid", Field, 7, ""},
-		{"Group.Name", Field, 7, ""},
-		{"Lookup", Func, 0, "func(username string) (*User, error)"},
-		{"LookupGroup", Func, 7, "func(name string) (*Group, error)"},
-		{"LookupGroupId", Func, 7, "func(gid string) (*Group, error)"},
-		{"LookupId", Func, 0, "func(uid string) (*User, error)"},
-		{"UnknownGroupError", Type, 7, ""},
-		{"UnknownGroupIdError", Type, 7, ""},
-		{"UnknownUserError", Type, 0, ""},
-		{"UnknownUserIdError", Type, 0, ""},
-		{"User", Type, 0, ""},
-		{"User.Gid", Field, 0, ""},
-		{"User.HomeDir", Field, 0, ""},
-		{"User.Name", Field, 0, ""},
-		{"User.Uid", Field, 0, ""},
-		{"User.Username", Field, 0, ""},
-	},
-	"path": {
-		{"Base", Func, 0, "func(path string) string"},
-		{"Clean", Func, 0, "func(path string) string"},
-		{"Dir", Func, 0, "func(path string) string"},
-		{"ErrBadPattern", Var, 0, ""},
-		{"Ext", Func, 0, "func(path string) string"},
-		{"IsAbs", Func, 0, "func(path string) bool"},
-		{"Join", Func, 0, "func(elem ...string) string"},
-		{"Match", Func, 0, "func(pattern string, name string) (matched bool, err error)"},
-		{"Split", Func, 0, "func(path string) (dir string, file string)"},
-	},
-	"path/filepath": {
-		{"Abs", Func, 0, "func(path string) (string, error)"},
-		{"Base", Func, 0, "func(path string) string"},
-		{"Clean", Func, 0, "func(path string) string"},
-		{"Dir", Func, 0, "func(path string) string"},
-		{"ErrBadPattern", Var, 0, ""},
-		{"EvalSymlinks", Func, 0, "func(path string) (string, error)"},
-		{"Ext", Func, 0, "func(path string) string"},
-		{"FromSlash", Func, 0, "func(path string) string"},
-		{"Glob", Func, 0, "func(pattern string) (matches []string, err error)"},
-		{"HasPrefix", Func, 0, "func(p string, prefix string) bool"},
-		{"IsAbs", Func, 0, "func(path string) bool"},
-		{"IsLocal", Func, 20, "func(path string) bool"},
-		{"Join", Func, 0, "func(elem ...string) string"},
-		{"ListSeparator", Const, 0, ""},
-		{"Localize", Func, 23, "func(path string) (string, error)"},
-		{"Match", Func, 0, "func(pattern string, name string) (matched bool, err error)"},
-		{"Rel", Func, 0, "func(basePath string, targPath string) (string, error)"},
-		{"Separator", Const, 0, ""},
-		{"SkipAll", Var, 20, ""},
-		{"SkipDir", Var, 0, ""},
-		{"Split", Func, 0, "func(path string) (dir string, file string)"},
-		{"SplitList", Func, 0, "func(path string) []string"},
-		{"ToSlash", Func, 0, "func(path string) string"},
-		{"VolumeName", Func, 0, "func(path string) string"},
-		{"Walk", Func, 0, "func(root string, fn WalkFunc) error"},
-		{"WalkDir", Func, 16, "func(root string, fn fs.WalkDirFunc) error"},
-		{"WalkFunc", Type, 0, ""},
-	},
-	"plugin": {
-		{"(*Plugin).Lookup", Method, 8, ""},
-		{"Open", Func, 8, "func(path string) (*Plugin, error)"},
-		{"Plugin", Type, 8, ""},
-		{"Symbol", Type, 8, ""},
-	},
-	"reflect": {
-		{"(*MapIter).Key", Method, 12, ""},
-		{"(*MapIter).Next", Method, 12, ""},
-		{"(*MapIter).Reset", Method, 18, ""},
-		{"(*MapIter).Value", Method, 12, ""},
-		{"(*ValueError).Error", Method, 0, ""},
-		{"(ChanDir).String", Method, 0, ""},
-		{"(Kind).String", Method, 0, ""},
-		{"(Method).IsExported", Method, 17, ""},
-		{"(StructField).IsExported", Method, 17, ""},
-		{"(StructTag).Get", Method, 0, ""},
-		{"(StructTag).Lookup", Method, 7, ""},
-		{"(Type).Align", Method, 0, ""},
-		{"(Type).AssignableTo", Method, 0, ""},
-		{"(Type).Bits", Method, 0, ""},
-		{"(Type).CanSeq", Method, 23, ""},
-		{"(Type).CanSeq2", Method, 23, ""},
-		{"(Type).ChanDir", Method, 0, ""},
-		{"(Type).Comparable", Method, 4, ""},
-		{"(Type).ConvertibleTo", Method, 1, ""},
-		{"(Type).Elem", Method, 0, ""},
-		{"(Type).Field", Method, 0, ""},
-		{"(Type).FieldAlign", Method, 0, ""},
-		{"(Type).FieldByIndex", Method, 0, ""},
-		{"(Type).FieldByName", Method, 0, ""},
-		{"(Type).FieldByNameFunc", Method, 0, ""},
-		{"(Type).Fields", Method, 26, ""},
-		{"(Type).Implements", Method, 0, ""},
-		{"(Type).In", Method, 0, ""},
-		{"(Type).Ins", Method, 26, ""},
-		{"(Type).IsVariadic", Method, 0, ""},
-		{"(Type).Key", Method, 0, ""},
-		{"(Type).Kind", Method, 0, ""},
-		{"(Type).Len", Method, 0, ""},
-		{"(Type).Method", Method, 0, ""},
-		{"(Type).MethodByName", Method, 0, ""},
-		{"(Type).Methods", Method, 26, ""},
-		{"(Type).Name", Method, 0, ""},
-		{"(Type).NumField", Method, 0, ""},
-		{"(Type).NumIn", Method, 0, ""},
-		{"(Type).NumMethod", Method, 0, ""},
-		{"(Type).NumOut", Method, 0, ""},
-		{"(Type).Out", Method, 0, ""},
-		{"(Type).Outs", Method, 26, ""},
-		{"(Type).OverflowComplex", Method, 23, ""},
-		{"(Type).OverflowFloat", Method, 23, ""},
-		{"(Type).OverflowInt", Method, 23, ""},
-		{"(Type).OverflowUint", Method, 23, ""},
-		{"(Type).PkgPath", Method, 0, ""},
-		{"(Type).Size", Method, 0, ""},
-		{"(Type).String", Method, 0, ""},
-		{"(Value).Addr", Method, 0, ""},
-		{"(Value).Bool", Method, 0, ""},
-		{"(Value).Bytes", Method, 0, ""},
-		{"(Value).Call", Method, 0, ""},
-		{"(Value).CallSlice", Method, 0, ""},
-		{"(Value).CanAddr", Method, 0, ""},
-		{"(Value).CanComplex", Method, 18, ""},
-		{"(Value).CanConvert", Method, 17, ""},
-		{"(Value).CanFloat", Method, 18, ""},
-		{"(Value).CanInt", Method, 18, ""},
-		{"(Value).CanInterface", Method, 0, ""},
-		{"(Value).CanSet", Method, 0, ""},
-		{"(Value).CanUint", Method, 18, ""},
-		{"(Value).Cap", Method, 0, ""},
-		{"(Value).Clear", Method, 21, ""},
-		{"(Value).Close", Method, 0, ""},
-		{"(Value).Comparable", Method, 20, ""},
-		{"(Value).Complex", Method, 0, ""},
-		{"(Value).Convert", Method, 1, ""},
-		{"(Value).Elem", Method, 0, ""},
-		{"(Value).Equal", Method, 20, ""},
-		{"(Value).Field", Method, 0, ""},
-		{"(Value).FieldByIndex", Method, 0, ""},
-		{"(Value).FieldByIndexErr", Method, 18, ""},
-		{"(Value).FieldByName", Method, 0, ""},
-		{"(Value).FieldByNameFunc", Method, 0, ""},
-		{"(Value).Fields", Method, 26, ""},
-		{"(Value).Float", Method, 0, ""},
-		{"(Value).Grow", Method, 20, ""},
-		{"(Value).Index", Method, 0, ""},
-		{"(Value).Int", Method, 0, ""},
-		{"(Value).Interface", Method, 0, ""},
-		{"(Value).InterfaceData", Method, 0, ""},
-		{"(Value).IsNil", Method, 0, ""},
-		{"(Value).IsValid", Method, 0, ""},
-		{"(Value).IsZero", Method, 13, ""},
-		{"(Value).Kind", Method, 0, ""},
-		{"(Value).Len", Method, 0, ""},
-		{"(Value).MapIndex", Method, 0, ""},
-		{"(Value).MapKeys", Method, 0, ""},
-		{"(Value).MapRange", Method, 12, ""},
-		{"(Value).Method", Method, 0, ""},
-		{"(Value).MethodByName", Method, 0, ""},
-		{"(Value).Methods", Method, 26, ""},
-		{"(Value).NumField", Method, 0, ""},
-		{"(Value).NumMethod", Method, 0, ""},
-		{"(Value).OverflowComplex", Method, 0, ""},
-		{"(Value).OverflowFloat", Method, 0, ""},
-		{"(Value).OverflowInt", Method, 0, ""},
-		{"(Value).OverflowUint", Method, 0, ""},
-		{"(Value).Pointer", Method, 0, ""},
-		{"(Value).Recv", Method, 0, ""},
-		{"(Value).Send", Method, 0, ""},
-		{"(Value).Seq", Method, 23, ""},
-		{"(Value).Seq2", Method, 23, ""},
-		{"(Value).Set", Method, 0, ""},
-		{"(Value).SetBool", Method, 0, ""},
-		{"(Value).SetBytes", Method, 0, ""},
-		{"(Value).SetCap", Method, 2, ""},
-		{"(Value).SetComplex", Method, 0, ""},
-		{"(Value).SetFloat", Method, 0, ""},
-		{"(Value).SetInt", Method, 0, ""},
-		{"(Value).SetIterKey", Method, 18, ""},
-		{"(Value).SetIterValue", Method, 18, ""},
-		{"(Value).SetLen", Method, 0, ""},
-		{"(Value).SetMapIndex", Method, 0, ""},
-		{"(Value).SetPointer", Method, 0, ""},
-		{"(Value).SetString", Method, 0, ""},
-		{"(Value).SetUint", Method, 0, ""},
-		{"(Value).SetZero", Method, 20, ""},
-		{"(Value).Slice", Method, 0, ""},
-		{"(Value).Slice3", Method, 2, ""},
-		{"(Value).String", Method, 0, ""},
-		{"(Value).TryRecv", Method, 0, ""},
-		{"(Value).TrySend", Method, 0, ""},
-		{"(Value).Type", Method, 0, ""},
-		{"(Value).Uint", Method, 0, ""},
-		{"(Value).UnsafeAddr", Method, 0, ""},
-		{"(Value).UnsafePointer", Method, 18, ""},
-		{"Append", Func, 0, "func(s Value, x ...Value) Value"},
-		{"AppendSlice", Func, 0, "func(s Value, t Value) Value"},
-		{"Array", Const, 0, ""},
-		{"ArrayOf", Func, 5, "func(length int, elem Type) Type"},
-		{"Bool", Const, 0, ""},
-		{"BothDir", Const, 0, ""},
-		{"Chan", Const, 0, ""},
-		{"ChanDir", Type, 0, ""},
-		{"ChanOf", Func, 1, "func(dir ChanDir, t Type) Type"},
-		{"Complex128", Const, 0, ""},
-		{"Complex64", Const, 0, ""},
-		{"Copy", Func, 0, "func(dst Value, src Value) int"},
-		{"DeepEqual", Func, 0, "func(x any, y any) bool"},
-		{"Float32", Const, 0, ""},
-		{"Float64", Const, 0, ""},
-		{"Func", Const, 0, ""},
-		{"FuncOf", Func, 5, "func(in []Type, out []Type, variadic bool) Type"},
-		{"Indirect", Func, 0, "func(v Value) Value"},
-		{"Int", Const, 0, ""},
-		{"Int16", Const, 0, ""},
-		{"Int32", Const, 0, ""},
-		{"Int64", Const, 0, ""},
-		{"Int8", Const, 0, ""},
-		{"Interface", Const, 0, ""},
-		{"Invalid", Const, 0, ""},
-		{"Kind", Type, 0, ""},
-		{"MakeChan", Func, 0, "func(typ Type, buffer int) Value"},
-		{"MakeFunc", Func, 1, "func(typ Type, fn func(args []Value) (results []Value)) Value"},
-		{"MakeMap", Func, 0, "func(typ Type) Value"},
-		{"MakeMapWithSize", Func, 9, "func(typ Type, n int) Value"},
-		{"MakeSlice", Func, 0, "func(typ Type, len int, cap int) Value"},
-		{"Map", Const, 0, ""},
-		{"MapIter", Type, 12, ""},
-		{"MapOf", Func, 1, "func(key Type, elem Type) Type"},
-		{"Method", Type, 0, ""},
-		{"Method.Func", Field, 0, ""},
-		{"Method.Index", Field, 0, ""},
-		{"Method.Name", Field, 0, ""},
-		{"Method.PkgPath", Field, 0, ""},
-		{"Method.Type", Field, 0, ""},
-		{"New", Func, 0, "func(typ Type) Value"},
-		{"NewAt", Func, 0, "func(typ Type, p unsafe.Pointer) Value"},
-		{"Pointer", Const, 18, ""},
-		{"PointerTo", Func, 18, "func(t Type) Type"},
-		{"Ptr", Const, 0, ""},
-		{"PtrTo", Func, 0, "func(t Type) Type"},
-		{"RecvDir", Const, 0, ""},
-		{"Select", Func, 1, "func(cases []SelectCase) (chosen int, recv Value, recvOK bool)"},
-		{"SelectCase", Type, 1, ""},
-		{"SelectCase.Chan", Field, 1, ""},
-		{"SelectCase.Dir", Field, 1, ""},
-		{"SelectCase.Send", Field, 1, ""},
-		{"SelectDefault", Const, 1, ""},
-		{"SelectDir", Type, 1, ""},
-		{"SelectRecv", Const, 1, ""},
-		{"SelectSend", Const, 1, ""},
-		{"SendDir", Const, 0, ""},
-		{"Slice", Const, 0, ""},
-		{"SliceAt", Func, 23, "func(typ Type, p unsafe.Pointer, n int) Value"},
-		{"SliceHeader", Type, 0, ""},
-		{"SliceHeader.Cap", Field, 0, ""},
-		{"SliceHeader.Data", Field, 0, ""},
-		{"SliceHeader.Len", Field, 0, ""},
-		{"SliceOf", Func, 1, "func(t Type) Type"},
-		{"String", Const, 0, ""},
-		{"StringHeader", Type, 0, ""},
-		{"StringHeader.Data", Field, 0, ""},
-		{"StringHeader.Len", Field, 0, ""},
-		{"Struct", Const, 0, ""},
-		{"StructField", Type, 0, ""},
-		{"StructField.Anonymous", Field, 0, ""},
-		{"StructField.Index", Field, 0, ""},
-		{"StructField.Name", Field, 0, ""},
-		{"StructField.Offset", Field, 0, ""},
-		{"StructField.PkgPath", Field, 0, ""},
-		{"StructField.Tag", Field, 0, ""},
-		{"StructField.Type", Field, 0, ""},
-		{"StructOf", Func, 7, "func(fields []StructField) Type"},
-		{"StructTag", Type, 0, ""},
-		{"Swapper", Func, 8, "func(slice any) func(i int, j int)"},
-		{"TypeAssert", Func, 25, "func[T any](v Value) (T, bool)"},
-		{"TypeFor", Func, 22, "func[T any]() Type"},
-		{"TypeOf", Func, 0, "func(i any) Type"},
-		{"Uint", Const, 0, ""},
-		{"Uint16", Const, 0, ""},
-		{"Uint32", Const, 0, ""},
-		{"Uint64", Const, 0, ""},
-		{"Uint8", Const, 0, ""},
-		{"Uintptr", Const, 0, ""},
-		{"UnsafePointer", Const, 0, ""},
-		{"Value", Type, 0, ""},
-		{"ValueError", Type, 0, ""},
-		{"ValueError.Kind", Field, 0, ""},
-		{"ValueError.Method", Field, 0, ""},
-		{"ValueOf", Func, 0, "func(i any) Value"},
-		{"VisibleFields", Func, 17, "func(t Type) []StructField"},
-		{"Zero", Func, 0, "func(typ Type) Value"},
-	},
-	"regexp": {
-		{"(*Regexp).AppendText", Method, 24, ""},
-		{"(*Regexp).Copy", Method, 6, ""},
-		{"(*Regexp).Expand", Method, 0, ""},
-		{"(*Regexp).ExpandString", Method, 0, ""},
-		{"(*Regexp).Find", Method, 0, ""},
-		{"(*Regexp).FindAll", Method, 0, ""},
-		{"(*Regexp).FindAllIndex", Method, 0, ""},
-		{"(*Regexp).FindAllString", Method, 0, ""},
-		{"(*Regexp).FindAllStringIndex", Method, 0, ""},
-		{"(*Regexp).FindAllStringSubmatch", Method, 0, ""},
-		{"(*Regexp).FindAllStringSubmatchIndex", Method, 0, ""},
-		{"(*Regexp).FindAllSubmatch", Method, 0, ""},
-		{"(*Regexp).FindAllSubmatchIndex", Method, 0, ""},
-		{"(*Regexp).FindIndex", Method, 0, ""},
-		{"(*Regexp).FindReaderIndex", Method, 0, ""},
-		{"(*Regexp).FindReaderSubmatchIndex", Method, 0, ""},
-		{"(*Regexp).FindString", Method, 0, ""},
-		{"(*Regexp).FindStringIndex", Method, 0, ""},
-		{"(*Regexp).FindStringSubmatch", Method, 0, ""},
-		{"(*Regexp).FindStringSubmatchIndex", Method, 0, ""},
-		{"(*Regexp).FindSubmatch", Method, 0, ""},
-		{"(*Regexp).FindSubmatchIndex", Method, 0, ""},
-		{"(*Regexp).LiteralPrefix", Method, 0, ""},
-		{"(*Regexp).Longest", Method, 1, ""},
-		{"(*Regexp).MarshalText", Method, 21, ""},
-		{"(*Regexp).Match", Method, 0, ""},
-		{"(*Regexp).MatchReader", Method, 0, ""},
-		{"(*Regexp).MatchString", Method, 0, ""},
-		{"(*Regexp).NumSubexp", Method, 0, ""},
-		{"(*Regexp).ReplaceAll", Method, 0, ""},
-		{"(*Regexp).ReplaceAllFunc", Method, 0, ""},
-		{"(*Regexp).ReplaceAllLiteral", Method, 0, ""},
-		{"(*Regexp).ReplaceAllLiteralString", Method, 0, ""},
-		{"(*Regexp).ReplaceAllString", Method, 0, ""},
-		{"(*Regexp).ReplaceAllStringFunc", Method, 0, ""},
-		{"(*Regexp).Split", Method, 1, ""},
-		{"(*Regexp).String", Method, 0, ""},
-		{"(*Regexp).SubexpIndex", Method, 15, ""},
-		{"(*Regexp).SubexpNames", Method, 0, ""},
-		{"(*Regexp).UnmarshalText", Method, 21, ""},
-		{"Compile", Func, 0, "func(expr string) (*Regexp, error)"},
-		{"CompilePOSIX", Func, 0, "func(expr string) (*Regexp, error)"},
-		{"Match", Func, 0, "func(pattern string, b []byte) (matched bool, err error)"},
-		{"MatchReader", Func, 0, "func(pattern string, r io.RuneReader) (matched bool, err error)"},
-		{"MatchString", Func, 0, "func(pattern string, s string) (matched bool, err error)"},
-		{"MustCompile", Func, 0, "func(str string) *Regexp"},
-		{"MustCompilePOSIX", Func, 0, "func(str string) *Regexp"},
-		{"QuoteMeta", Func, 0, "func(s string) string"},
-		{"Regexp", Type, 0, ""},
-	},
-	"regexp/syntax": {
-		{"(*Error).Error", Method, 0, ""},
-		{"(*Inst).MatchEmptyWidth", Method, 0, ""},
-		{"(*Inst).MatchRune", Method, 0, ""},
-		{"(*Inst).MatchRunePos", Method, 3, ""},
-		{"(*Inst).String", Method, 0, ""},
-		{"(*Prog).Prefix", Method, 0, ""},
-		{"(*Prog).StartCond", Method, 0, ""},
-		{"(*Prog).String", Method, 0, ""},
-		{"(*Regexp).CapNames", Method, 0, ""},
-		{"(*Regexp).Equal", Method, 0, ""},
-		{"(*Regexp).MaxCap", Method, 0, ""},
-		{"(*Regexp).Simplify", Method, 0, ""},
-		{"(*Regexp).String", Method, 0, ""},
-		{"(ErrorCode).String", Method, 0, ""},
-		{"(InstOp).String", Method, 3, ""},
-		{"(Op).String", Method, 11, ""},
-		{"ClassNL", Const, 0, ""},
-		{"Compile", Func, 0, "func(re *Regexp) (*Prog, error)"},
-		{"DotNL", Const, 0, ""},
-		{"EmptyBeginLine", Const, 0, ""},
-		{"EmptyBeginText", Const, 0, ""},
-		{"EmptyEndLine", Const, 0, ""},
-		{"EmptyEndText", Const, 0, ""},
-		{"EmptyNoWordBoundary", Const, 0, ""},
-		{"EmptyOp", Type, 0, ""},
-		{"EmptyOpContext", Func, 0, "func(r1 rune, r2 rune) EmptyOp"},
-		{"EmptyWordBoundary", Const, 0, ""},
-		{"ErrInternalError", Const, 0, ""},
-		{"ErrInvalidCharClass", Const, 0, ""},
-		{"ErrInvalidCharRange", Const, 0, ""},
-		{"ErrInvalidEscape", Const, 0, ""},
-		{"ErrInvalidNamedCapture", Const, 0, ""},
-		{"ErrInvalidPerlOp", Const, 0, ""},
-		{"ErrInvalidRepeatOp", Const, 0, ""},
-		{"ErrInvalidRepeatSize", Const, 0, ""},
-		{"ErrInvalidUTF8", Const, 0, ""},
-		{"ErrLarge", Const, 20, ""},
-		{"ErrMissingBracket", Const, 0, ""},
-		{"ErrMissingParen", Const, 0, ""},
-		{"ErrMissingRepeatArgument", Const, 0, ""},
-		{"ErrNestingDepth", Const, 19, ""},
-		{"ErrTrailingBackslash", Const, 0, ""},
-		{"ErrUnexpectedParen", Const, 1, ""},
-		{"Error", Type, 0, ""},
-		{"Error.Code", Field, 0, ""},
-		{"Error.Expr", Field, 0, ""},
-		{"ErrorCode", Type, 0, ""},
-		{"Flags", Type, 0, ""},
-		{"FoldCase", Const, 0, ""},
-		{"Inst", Type, 0, ""},
-		{"Inst.Arg", Field, 0, ""},
-		{"Inst.Op", Field, 0, ""},
-		{"Inst.Out", Field, 0, ""},
-		{"Inst.Rune", Field, 0, ""},
-		{"InstAlt", Const, 0, ""},
-		{"InstAltMatch", Const, 0, ""},
-		{"InstCapture", Const, 0, ""},
-		{"InstEmptyWidth", Const, 0, ""},
-		{"InstFail", Const, 0, ""},
-		{"InstMatch", Const, 0, ""},
-		{"InstNop", Const, 0, ""},
-		{"InstOp", Type, 0, ""},
-		{"InstRune", Const, 0, ""},
-		{"InstRune1", Const, 0, ""},
-		{"InstRuneAny", Const, 0, ""},
-		{"InstRuneAnyNotNL", Const, 0, ""},
-		{"IsWordChar", Func, 0, "func(r rune) bool"},
-		{"Literal", Const, 0, ""},
-		{"MatchNL", Const, 0, ""},
-		{"NonGreedy", Const, 0, ""},
-		{"OneLine", Const, 0, ""},
-		{"Op", Type, 0, ""},
-		{"OpAlternate", Const, 0, ""},
-		{"OpAnyChar", Const, 0, ""},
-		{"OpAnyCharNotNL", Const, 0, ""},
-		{"OpBeginLine", Const, 0, ""},
-		{"OpBeginText", Const, 0, ""},
-		{"OpCapture", Const, 0, ""},
-		{"OpCharClass", Const, 0, ""},
-		{"OpConcat", Const, 0, ""},
-		{"OpEmptyMatch", Const, 0, ""},
-		{"OpEndLine", Const, 0, ""},
-		{"OpEndText", Const, 0, ""},
-		{"OpLiteral", Const, 0, ""},
-		{"OpNoMatch", Const, 0, ""},
-		{"OpNoWordBoundary", Const, 0, ""},
-		{"OpPlus", Const, 0, ""},
-		{"OpQuest", Const, 0, ""},
-		{"OpRepeat", Const, 0, ""},
-		{"OpStar", Const, 0, ""},
-		{"OpWordBoundary", Const, 0, ""},
-		{"POSIX", Const, 0, ""},
-		{"Parse", Func, 0, "func(s string, flags Flags) (*Regexp, error)"},
-		{"Perl", Const, 0, ""},
-		{"PerlX", Const, 0, ""},
-		{"Prog", Type, 0, ""},
-		{"Prog.Inst", Field, 0, ""},
-		{"Prog.NumCap", Field, 0, ""},
-		{"Prog.Start", Field, 0, ""},
-		{"Regexp", Type, 0, ""},
-		{"Regexp.Cap", Field, 0, ""},
-		{"Regexp.Flags", Field, 0, ""},
-		{"Regexp.Max", Field, 0, ""},
-		{"Regexp.Min", Field, 0, ""},
-		{"Regexp.Name", Field, 0, ""},
-		{"Regexp.Op", Field, 0, ""},
-		{"Regexp.Rune", Field, 0, ""},
-		{"Regexp.Rune0", Field, 0, ""},
-		{"Regexp.Sub", Field, 0, ""},
-		{"Regexp.Sub0", Field, 0, ""},
-		{"Simple", Const, 0, ""},
-		{"UnicodeGroups", Const, 0, ""},
-		{"WasDollar", Const, 0, ""},
-	},
-	"runtime": {
-		{"(*BlockProfileRecord).Stack", Method, 1, ""},
-		{"(*Frames).Next", Method, 7, ""},
-		{"(*Func).Entry", Method, 0, ""},
-		{"(*Func).FileLine", Method, 0, ""},
-		{"(*Func).Name", Method, 0, ""},
-		{"(*MemProfileRecord).InUseBytes", Method, 0, ""},
-		{"(*MemProfileRecord).InUseObjects", Method, 0, ""},
-		{"(*MemProfileRecord).Stack", Method, 0, ""},
-		{"(*PanicNilError).Error", Method, 21, ""},
-		{"(*PanicNilError).RuntimeError", Method, 21, ""},
-		{"(*Pinner).Pin", Method, 21, ""},
-		{"(*Pinner).Unpin", Method, 21, ""},
-		{"(*StackRecord).Stack", Method, 0, ""},
-		{"(*TypeAssertionError).Error", Method, 0, ""},
-		{"(*TypeAssertionError).RuntimeError", Method, 0, ""},
-		{"(Cleanup).Stop", Method, 24, ""},
-		{"(Error).Error", Method, 0, ""},
-		{"(Error).RuntimeError", Method, 0, ""},
-		{"AddCleanup", Func, 24, "func[T, S any](ptr *T, cleanup func(S), arg S) Cleanup"},
-		{"BlockProfile", Func, 1, "func(p []BlockProfileRecord) (n int, ok bool)"},
-		{"BlockProfileRecord", Type, 1, ""},
-		{"BlockProfileRecord.Count", Field, 1, ""},
-		{"BlockProfileRecord.Cycles", Field, 1, ""},
-		{"BlockProfileRecord.StackRecord", Field, 1, ""},
-		{"Breakpoint", Func, 0, "func()"},
-		{"CPUProfile", Func, 0, "func() []byte"},
-		{"Caller", Func, 0, "func(skip int) (pc uintptr, file string, line int, ok bool)"},
-		{"Callers", Func, 0, "func(skip int, pc []uintptr) int"},
-		{"CallersFrames", Func, 7, "func(callers []uintptr) *Frames"},
-		{"Cleanup", Type, 24, ""},
-		{"Compiler", Const, 0, ""},
-		{"Error", Type, 0, ""},
-		{"Frame", Type, 7, ""},
-		{"Frame.Entry", Field, 7, ""},
-		{"Frame.File", Field, 7, ""},
-		{"Frame.Func", Field, 7, ""},
-		{"Frame.Function", Field, 7, ""},
-		{"Frame.Line", Field, 7, ""},
-		{"Frame.PC", Field, 7, ""},
-		{"Frames", Type, 7, ""},
-		{"Func", Type, 0, ""},
-		{"FuncForPC", Func, 0, "func(pc uintptr) *Func"},
-		{"GC", Func, 0, "func()"},
-		{"GOARCH", Const, 0, ""},
-		{"GOMAXPROCS", Func, 0, "func(n int) int"},
-		{"GOOS", Const, 0, ""},
-		{"GOROOT", Func, 0, "func() string"},
-		{"Goexit", Func, 0, "func()"},
-		{"GoroutineProfile", Func, 0, "func(p []StackRecord) (n int, ok bool)"},
-		{"Gosched", Func, 0, "func()"},
-		{"KeepAlive", Func, 7, "func(x any)"},
-		{"LockOSThread", Func, 0, "func()"},
-		{"MemProfile", Func, 0, "func(p []MemProfileRecord, inuseZero bool) (n int, ok bool)"},
-		{"MemProfileRate", Var, 0, ""},
-		{"MemProfileRecord", Type, 0, ""},
-		{"MemProfileRecord.AllocBytes", Field, 0, ""},
-		{"MemProfileRecord.AllocObjects", Field, 0, ""},
-		{"MemProfileRecord.FreeBytes", Field, 0, ""},
-		{"MemProfileRecord.FreeObjects", Field, 0, ""},
-		{"MemProfileRecord.Stack0", Field, 0, ""},
-		{"MemStats", Type, 0, ""},
-		{"MemStats.Alloc", Field, 0, ""},
-		{"MemStats.BuckHashSys", Field, 0, ""},
-		{"MemStats.BySize", Field, 0, ""},
-		{"MemStats.DebugGC", Field, 0, ""},
-		{"MemStats.EnableGC", Field, 0, ""},
-		{"MemStats.Frees", Field, 0, ""},
-		{"MemStats.GCCPUFraction", Field, 5, ""},
-		{"MemStats.GCSys", Field, 2, ""},
-		{"MemStats.HeapAlloc", Field, 0, ""},
-		{"MemStats.HeapIdle", Field, 0, ""},
-		{"MemStats.HeapInuse", Field, 0, ""},
-		{"MemStats.HeapObjects", Field, 0, ""},
-		{"MemStats.HeapReleased", Field, 0, ""},
-		{"MemStats.HeapSys", Field, 0, ""},
-		{"MemStats.LastGC", Field, 0, ""},
-		{"MemStats.Lookups", Field, 0, ""},
-		{"MemStats.MCacheInuse", Field, 0, ""},
-		{"MemStats.MCacheSys", Field, 0, ""},
-		{"MemStats.MSpanInuse", Field, 0, ""},
-		{"MemStats.MSpanSys", Field, 0, ""},
-		{"MemStats.Mallocs", Field, 0, ""},
-		{"MemStats.NextGC", Field, 0, ""},
-		{"MemStats.NumForcedGC", Field, 8, ""},
-		{"MemStats.NumGC", Field, 0, ""},
-		{"MemStats.OtherSys", Field, 2, ""},
-		{"MemStats.PauseEnd", Field, 4, ""},
-		{"MemStats.PauseNs", Field, 0, ""},
-		{"MemStats.PauseTotalNs", Field, 0, ""},
-		{"MemStats.StackInuse", Field, 0, ""},
-		{"MemStats.StackSys", Field, 0, ""},
-		{"MemStats.Sys", Field, 0, ""},
-		{"MemStats.TotalAlloc", Field, 0, ""},
-		{"MutexProfile", Func, 8, "func(p []BlockProfileRecord) (n int, ok bool)"},
-		{"NumCPU", Func, 0, "func() int"},
-		{"NumCgoCall", Func, 0, "func() int64"},
-		{"NumGoroutine", Func, 0, "func() int"},
-		{"PanicNilError", Type, 21, ""},
-		{"Pinner", Type, 21, ""},
-		{"ReadMemStats", Func, 0, "func(m *MemStats)"},
-		{"ReadTrace", Func, 5, "func() (buf []byte)"},
-		{"SetBlockProfileRate", Func, 1, "func(rate int)"},
-		{"SetCPUProfileRate", Func, 0, "func(hz int)"},
-		{"SetCgoTraceback", Func, 7, "func(version int, traceback unsafe.Pointer, context unsafe.Pointer, symbolizer unsafe.Pointer)"},
-		{"SetDefaultGOMAXPROCS", Func, 25, "func()"},
-		{"SetFinalizer", Func, 0, "func(obj any, finalizer any)"},
-		{"SetMutexProfileFraction", Func, 8, "func(rate int) int"},
-		{"Stack", Func, 0, "func(buf []byte, all bool) int"},
-		{"StackRecord", Type, 0, ""},
-		{"StackRecord.Stack0", Field, 0, ""},
-		{"StartTrace", Func, 5, "func() error"},
-		{"StopTrace", Func, 5, "func()"},
-		{"ThreadCreateProfile", Func, 0, "func(p []StackRecord) (n int, ok bool)"},
-		{"TypeAssertionError", Type, 0, ""},
-		{"UnlockOSThread", Func, 0, "func()"},
-		{"Version", Func, 0, "func() string"},
-	},
-	"runtime/cgo": {
-		{"(Handle).Delete", Method, 17, ""},
-		{"(Handle).Value", Method, 17, ""},
-		{"Handle", Type, 17, ""},
-		{"Incomplete", Type, 20, ""},
-		{"NewHandle", Func, 17, ""},
-	},
-	"runtime/coverage": {
-		{"ClearCounters", Func, 20, "func() error"},
-		{"WriteCounters", Func, 20, "func(w io.Writer) error"},
-		{"WriteCountersDir", Func, 20, "func(dir string) error"},
-		{"WriteMeta", Func, 20, "func(w io.Writer) error"},
-		{"WriteMetaDir", Func, 20, "func(dir string) error"},
-	},
-	"runtime/debug": {
-		{"(*BuildInfo).String", Method, 18, ""},
-		{"BuildInfo", Type, 12, ""},
-		{"BuildInfo.Deps", Field, 12, ""},
-		{"BuildInfo.GoVersion", Field, 18, ""},
-		{"BuildInfo.Main", Field, 12, ""},
-		{"BuildInfo.Path", Field, 12, ""},
-		{"BuildInfo.Settings", Field, 18, ""},
-		{"BuildSetting", Type, 18, ""},
-		{"BuildSetting.Key", Field, 18, ""},
-		{"BuildSetting.Value", Field, 18, ""},
-		{"CrashOptions", Type, 23, ""},
-		{"FreeOSMemory", Func, 1, "func()"},
-		{"GCStats", Type, 1, ""},
-		{"GCStats.LastGC", Field, 1, ""},
-		{"GCStats.NumGC", Field, 1, ""},
-		{"GCStats.Pause", Field, 1, ""},
-		{"GCStats.PauseEnd", Field, 4, ""},
-		{"GCStats.PauseQuantiles", Field, 1, ""},
-		{"GCStats.PauseTotal", Field, 1, ""},
-		{"Module", Type, 12, ""},
-		{"Module.Path", Field, 12, ""},
-		{"Module.Replace", Field, 12, ""},
-		{"Module.Sum", Field, 12, ""},
-		{"Module.Version", Field, 12, ""},
-		{"ParseBuildInfo", Func, 18, "func(data string) (bi *BuildInfo, err error)"},
-		{"PrintStack", Func, 0, "func()"},
-		{"ReadBuildInfo", Func, 12, "func() (info *BuildInfo, ok bool)"},
-		{"ReadGCStats", Func, 1, "func(stats *GCStats)"},
-		{"SetCrashOutput", Func, 23, "func(f *os.File, opts CrashOptions) error"},
-		{"SetGCPercent", Func, 1, "func(percent int) int"},
-		{"SetMaxStack", Func, 2, "func(bytes int) int"},
-		{"SetMaxThreads", Func, 2, "func(threads int) int"},
-		{"SetMemoryLimit", Func, 19, "func(limit int64) int64"},
-		{"SetPanicOnFault", Func, 3, "func(enabled bool) bool"},
-		{"SetTraceback", Func, 6, "func(level string)"},
-		{"Stack", Func, 0, "func() []byte"},
-		{"WriteHeapDump", Func, 3, "func(fd uintptr)"},
-	},
-	"runtime/metrics": {
-		{"(Value).Float64", Method, 16, ""},
-		{"(Value).Float64Histogram", Method, 16, ""},
-		{"(Value).Kind", Method, 16, ""},
-		{"(Value).Uint64", Method, 16, ""},
-		{"All", Func, 16, "func() []Description"},
-		{"Description", Type, 16, ""},
-		{"Description.Cumulative", Field, 16, ""},
-		{"Description.Description", Field, 16, ""},
-		{"Description.Kind", Field, 16, ""},
-		{"Description.Name", Field, 16, ""},
-		{"Float64Histogram", Type, 16, ""},
-		{"Float64Histogram.Buckets", Field, 16, ""},
-		{"Float64Histogram.Counts", Field, 16, ""},
-		{"KindBad", Const, 16, ""},
-		{"KindFloat64", Const, 16, ""},
-		{"KindFloat64Histogram", Const, 16, ""},
-		{"KindUint64", Const, 16, ""},
-		{"Read", Func, 16, "func(m []Sample)"},
-		{"Sample", Type, 16, ""},
-		{"Sample.Name", Field, 16, ""},
-		{"Sample.Value", Field, 16, ""},
-		{"Value", Type, 16, ""},
-		{"ValueKind", Type, 16, ""},
-	},
-	"runtime/pprof": {
-		{"(*Profile).Add", Method, 0, ""},
-		{"(*Profile).Count", Method, 0, ""},
-		{"(*Profile).Name", Method, 0, ""},
-		{"(*Profile).Remove", Method, 0, ""},
-		{"(*Profile).WriteTo", Method, 0, ""},
-		{"Do", Func, 9, "func(ctx context.Context, labels LabelSet, f func(context.Context))"},
-		{"ForLabels", Func, 9, "func(ctx context.Context, f func(key string, value string) bool)"},
-		{"Label", Func, 9, "func(ctx context.Context, key string) (string, bool)"},
-		{"LabelSet", Type, 9, ""},
-		{"Labels", Func, 9, "func(args ...string) LabelSet"},
-		{"Lookup", Func, 0, "func(name string) *Profile"},
-		{"NewProfile", Func, 0, "func(name string) *Profile"},
-		{"Profile", Type, 0, ""},
-		{"Profiles", Func, 0, "func() []*Profile"},
-		{"SetGoroutineLabels", Func, 9, "func(ctx context.Context)"},
-		{"StartCPUProfile", Func, 0, "func(w io.Writer) error"},
-		{"StopCPUProfile", Func, 0, "func()"},
-		{"WithLabels", Func, 9, "func(ctx context.Context, labels LabelSet) context.Context"},
-		{"WriteHeapProfile", Func, 0, "func(w io.Writer) error"},
-	},
-	"runtime/trace": {
-		{"(*FlightRecorder).Enabled", Method, 25, ""},
-		{"(*FlightRecorder).Start", Method, 25, ""},
-		{"(*FlightRecorder).Stop", Method, 25, ""},
-		{"(*FlightRecorder).WriteTo", Method, 25, ""},
-		{"(*Region).End", Method, 11, ""},
-		{"(*Task).End", Method, 11, ""},
-		{"FlightRecorder", Type, 25, ""},
-		{"FlightRecorderConfig", Type, 25, ""},
-		{"FlightRecorderConfig.MaxBytes", Field, 25, ""},
-		{"FlightRecorderConfig.MinAge", Field, 25, ""},
-		{"IsEnabled", Func, 11, "func() bool"},
-		{"Log", Func, 11, "func(ctx context.Context, category string, message string)"},
-		{"Logf", Func, 11, "func(ctx context.Context, category string, format string, args ...any)"},
-		{"NewFlightRecorder", Func, 25, "func(cfg FlightRecorderConfig) *FlightRecorder"},
-		{"NewTask", Func, 11, "func(pctx context.Context, taskType string) (ctx context.Context, task *Task)"},
-		{"Region", Type, 11, ""},
-		{"Start", Func, 5, "func(w io.Writer) error"},
-		{"StartRegion", Func, 11, "func(ctx context.Context, regionType string) *Region"},
-		{"Stop", Func, 5, "func()"},
-		{"Task", Type, 11, ""},
-		{"WithRegion", Func, 11, "func(ctx context.Context, regionType string, fn func())"},
-	},
-	"slices": {
-		{"All", Func, 23, "func[Slice ~[]E, E any](s Slice) iter.Seq2[int, E]"},
-		{"AppendSeq", Func, 23, "func[Slice ~[]E, E any](s Slice, seq iter.Seq[E]) Slice"},
-		{"Backward", Func, 23, "func[Slice ~[]E, E any](s Slice) iter.Seq2[int, E]"},
-		{"BinarySearch", Func, 21, "func[S ~[]E, E cmp.Ordered](x S, target E) (int, bool)"},
-		{"BinarySearchFunc", Func, 21, "func[S ~[]E, E, T any](x S, target T, cmp func(E, T) int) (int, bool)"},
-		{"Chunk", Func, 23, "func[Slice ~[]E, E any](s Slice, n int) iter.Seq[Slice]"},
-		{"Clip", Func, 21, "func[S ~[]E, E any](s S) S"},
-		{"Clone", Func, 21, "func[S ~[]E, E any](s S) S"},
-		{"Collect", Func, 23, "func[E any](seq iter.Seq[E]) []E"},
-		{"Compact", Func, 21, "func[S ~[]E, E comparable](s S) S"},
-		{"CompactFunc", Func, 21, "func[S ~[]E, E any](s S, eq func(E, E) bool) S"},
-		{"Compare", Func, 21, "func[S ~[]E, E cmp.Ordered](s1 S, s2 S) int"},
-		{"CompareFunc", Func, 21, "func[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, cmp func(E1, E2) int) int"},
-		{"Concat", Func, 22, "func[S ~[]E, E any](slices ...S) S"},
-		{"Contains", Func, 21, "func[S ~[]E, E comparable](s S, v E) bool"},
-		{"ContainsFunc", Func, 21, "func[S ~[]E, E any](s S, f func(E) bool) bool"},
-		{"Delete", Func, 21, "func[S ~[]E, E any](s S, i int, j int) S"},
-		{"DeleteFunc", Func, 21, "func[S ~[]E, E any](s S, del func(E) bool) S"},
-		{"Equal", Func, 21, "func[S ~[]E, E comparable](s1 S, s2 S) bool"},
-		{"EqualFunc", Func, 21, "func[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, eq func(E1, E2) bool) bool"},
-		{"Grow", Func, 21, "func[S ~[]E, E any](s S, n int) S"},
-		{"Index", Func, 21, "func[S ~[]E, E comparable](s S, v E) int"},
-		{"IndexFunc", Func, 21, "func[S ~[]E, E any](s S, f func(E) bool) int"},
-		{"Insert", Func, 21, "func[S ~[]E, E any](s S, i int, v ...E) S"},
-		{"IsSorted", Func, 21, "func[S ~[]E, E cmp.Ordered](x S) bool"},
-		{"IsSortedFunc", Func, 21, "func[S ~[]E, E any](x S, cmp func(a E, b E) int) bool"},
-		{"Max", Func, 21, "func[S ~[]E, E cmp.Ordered](x S) E"},
-		{"MaxFunc", Func, 21, "func[S ~[]E, E any](x S, cmp func(a E, b E) int) E"},
-		{"Min", Func, 21, "func[S ~[]E, E cmp.Ordered](x S) E"},
-		{"MinFunc", Func, 21, "func[S ~[]E, E any](x S, cmp func(a E, b E) int) E"},
-		{"Repeat", Func, 23, "func[S ~[]E, E any](x S, count int) S"},
-		{"Replace", Func, 21, "func[S ~[]E, E any](s S, i int, j int, v ...E) S"},
-		{"Reverse", Func, 21, "func[S ~[]E, E any](s S)"},
-		{"Sort", Func, 21, "func[S ~[]E, E cmp.Ordered](x S)"},
-		{"SortFunc", Func, 21, "func[S ~[]E, E any](x S, cmp func(a E, b E) int)"},
-		{"SortStableFunc", Func, 21, "func[S ~[]E, E any](x S, cmp func(a E, b E) int)"},
-		{"Sorted", Func, 23, "func[E cmp.Ordered](seq iter.Seq[E]) []E"},
-		{"SortedFunc", Func, 23, "func[E any](seq iter.Seq[E], cmp func(E, E) int) []E"},
-		{"SortedStableFunc", Func, 23, "func[E any](seq iter.Seq[E], cmp func(E, E) int) []E"},
-		{"Values", Func, 23, "func[Slice ~[]E, E any](s Slice) iter.Seq[E]"},
-	},
-	"sort": {
-		{"(Float64Slice).Len", Method, 0, ""},
-		{"(Float64Slice).Less", Method, 0, ""},
-		{"(Float64Slice).Search", Method, 0, ""},
-		{"(Float64Slice).Sort", Method, 0, ""},
-		{"(Float64Slice).Swap", Method, 0, ""},
-		{"(IntSlice).Len", Method, 0, ""},
-		{"(IntSlice).Less", Method, 0, ""},
-		{"(IntSlice).Search", Method, 0, ""},
-		{"(IntSlice).Sort", Method, 0, ""},
-		{"(IntSlice).Swap", Method, 0, ""},
-		{"(Interface).Len", Method, 0, ""},
-		{"(Interface).Less", Method, 0, ""},
-		{"(Interface).Swap", Method, 0, ""},
-		{"(StringSlice).Len", Method, 0, ""},
-		{"(StringSlice).Less", Method, 0, ""},
-		{"(StringSlice).Search", Method, 0, ""},
-		{"(StringSlice).Sort", Method, 0, ""},
-		{"(StringSlice).Swap", Method, 0, ""},
-		{"Find", Func, 19, "func(n int, cmp func(int) int) (i int, found bool)"},
-		{"Float64Slice", Type, 0, ""},
-		{"Float64s", Func, 0, "func(x []float64)"},
-		{"Float64sAreSorted", Func, 0, "func(x []float64) bool"},
-		{"IntSlice", Type, 0, ""},
-		{"Interface", Type, 0, ""},
-		{"Ints", Func, 0, "func(x []int)"},
-		{"IntsAreSorted", Func, 0, "func(x []int) bool"},
-		{"IsSorted", Func, 0, "func(data Interface) bool"},
-		{"Reverse", Func, 1, "func(data Interface) Interface"},
-		{"Search", Func, 0, "func(n int, f func(int) bool) int"},
-		{"SearchFloat64s", Func, 0, "func(a []float64, x float64) int"},
-		{"SearchInts", Func, 0, "func(a []int, x int) int"},
-		{"SearchStrings", Func, 0, "func(a []string, x string) int"},
-		{"Slice", Func, 8, "func(x any, less func(i int, j int) bool)"},
-		{"SliceIsSorted", Func, 8, "func(x any, less func(i int, j int) bool) bool"},
-		{"SliceStable", Func, 8, "func(x any, less func(i int, j int) bool)"},
-		{"Sort", Func, 0, "func(data Interface)"},
-		{"Stable", Func, 2, "func(data Interface)"},
-		{"StringSlice", Type, 0, ""},
-		{"Strings", Func, 0, "func(x []string)"},
-		{"StringsAreSorted", Func, 0, "func(x []string) bool"},
-	},
-	"strconv": {
-		{"(*NumError).Error", Method, 0, ""},
-		{"(*NumError).Unwrap", Method, 14, ""},
-		{"AppendBool", Func, 0, "func(dst []byte, b bool) []byte"},
-		{"AppendFloat", Func, 0, "func(dst []byte, f float64, fmt byte, prec int, bitSize int) []byte"},
-		{"AppendInt", Func, 0, "func(dst []byte, i int64, base int) []byte"},
-		{"AppendQuote", Func, 0, "func(dst []byte, s string) []byte"},
-		{"AppendQuoteRune", Func, 0, "func(dst []byte, r rune) []byte"},
-		{"AppendQuoteRuneToASCII", Func, 0, "func(dst []byte, r rune) []byte"},
-		{"AppendQuoteRuneToGraphic", Func, 6, "func(dst []byte, r rune) []byte"},
-		{"AppendQuoteToASCII", Func, 0, "func(dst []byte, s string) []byte"},
-		{"AppendQuoteToGraphic", Func, 6, "func(dst []byte, s string) []byte"},
-		{"AppendUint", Func, 0, "func(dst []byte, i uint64, base int) []byte"},
-		{"Atoi", Func, 0, "func(s string) (int, error)"},
-		{"CanBackquote", Func, 0, "func(s string) bool"},
-		{"ErrRange", Var, 0, ""},
-		{"ErrSyntax", Var, 0, ""},
-		{"FormatBool", Func, 0, "func(b bool) string"},
-		{"FormatComplex", Func, 15, "func(c complex128, fmt byte, prec int, bitSize int) string"},
-		{"FormatFloat", Func, 0, "func(f float64, fmt byte, prec int, bitSize int) string"},
-		{"FormatInt", Func, 0, "func(i int64, base int) string"},
-		{"FormatUint", Func, 0, "func(i uint64, base int) string"},
-		{"IntSize", Const, 0, ""},
-		{"IsGraphic", Func, 6, "func(r rune) bool"},
-		{"IsPrint", Func, 0, "func(r rune) bool"},
-		{"Itoa", Func, 0, "func(i int) string"},
-		{"NumError", Type, 0, ""},
-		{"NumError.Err", Field, 0, ""},
-		{"NumError.Func", Field, 0, ""},
-		{"NumError.Num", Field, 0, ""},
-		{"ParseBool", Func, 0, "func(str string) (bool, error)"},
-		{"ParseComplex", Func, 15, "func(s string, bitSize int) (complex128, error)"},
-		{"ParseFloat", Func, 0, "func(s string, bitSize int) (float64, error)"},
-		{"ParseInt", Func, 0, "func(s string, base int, bitSize int) (i int64, err error)"},
-		{"ParseUint", Func, 0, "func(s string, base int, bitSize int) (uint64, error)"},
-		{"Quote", Func, 0, "func(s string) string"},
-		{"QuoteRune", Func, 0, "func(r rune) string"},
-		{"QuoteRuneToASCII", Func, 0, "func(r rune) string"},
-		{"QuoteRuneToGraphic", Func, 6, "func(r rune) string"},
-		{"QuoteToASCII", Func, 0, "func(s string) string"},
-		{"QuoteToGraphic", Func, 6, "func(s string) string"},
-		{"QuotedPrefix", Func, 17, "func(s string) (string, error)"},
-		{"Unquote", Func, 0, "func(s string) (string, error)"},
-		{"UnquoteChar", Func, 0, "func(s string, quote byte) (value rune, multibyte bool, tail string, err error)"},
-	},
-	"strings": {
-		{"(*Builder).Cap", Method, 12, ""},
-		{"(*Builder).Grow", Method, 10, ""},
-		{"(*Builder).Len", Method, 10, ""},
-		{"(*Builder).Reset", Method, 10, ""},
-		{"(*Builder).String", Method, 10, ""},
-		{"(*Builder).Write", Method, 10, ""},
-		{"(*Builder).WriteByte", Method, 10, ""},
-		{"(*Builder).WriteRune", Method, 10, ""},
-		{"(*Builder).WriteString", Method, 10, ""},
-		{"(*Reader).Len", Method, 0, ""},
-		{"(*Reader).Read", Method, 0, ""},
-		{"(*Reader).ReadAt", Method, 0, ""},
-		{"(*Reader).ReadByte", Method, 0, ""},
-		{"(*Reader).ReadRune", Method, 0, ""},
-		{"(*Reader).Reset", Method, 7, ""},
-		{"(*Reader).Seek", Method, 0, ""},
-		{"(*Reader).Size", Method, 5, ""},
-		{"(*Reader).UnreadByte", Method, 0, ""},
-		{"(*Reader).UnreadRune", Method, 0, ""},
-		{"(*Reader).WriteTo", Method, 1, ""},
-		{"(*Replacer).Replace", Method, 0, ""},
-		{"(*Replacer).WriteString", Method, 0, ""},
-		{"Builder", Type, 10, ""},
-		{"Clone", Func, 18, "func(s string) string"},
-		{"Compare", Func, 5, "func(a string, b string) int"},
-		{"Contains", Func, 0, "func(s string, substr string) bool"},
-		{"ContainsAny", Func, 0, "func(s string, chars string) bool"},
-		{"ContainsFunc", Func, 21, "func(s string, f func(rune) bool) bool"},
-		{"ContainsRune", Func, 0, "func(s string, r rune) bool"},
-		{"Count", Func, 0, "func(s string, substr string) int"},
-		{"Cut", Func, 18, "func(s string, sep string) (before string, after string, found bool)"},
-		{"CutPrefix", Func, 20, "func(s string, prefix string) (after string, found bool)"},
-		{"CutSuffix", Func, 20, "func(s string, suffix string) (before string, found bool)"},
-		{"EqualFold", Func, 0, "func(s string, t string) bool"},
-		{"Fields", Func, 0, "func(s string) []string"},
-		{"FieldsFunc", Func, 0, "func(s string, f func(rune) bool) []string"},
-		{"FieldsFuncSeq", Func, 24, "func(s string, f func(rune) bool) iter.Seq[string]"},
-		{"FieldsSeq", Func, 24, "func(s string) iter.Seq[string]"},
-		{"HasPrefix", Func, 0, "func(s string, prefix string) bool"},
-		{"HasSuffix", Func, 0, "func(s string, suffix string) bool"},
-		{"Index", Func, 0, "func(s string, substr string) int"},
-		{"IndexAny", Func, 0, "func(s string, chars string) int"},
-		{"IndexByte", Func, 2, "func(s string, c byte) int"},
-		{"IndexFunc", Func, 0, "func(s string, f func(rune) bool) int"},
-		{"IndexRune", Func, 0, "func(s string, r rune) int"},
-		{"Join", Func, 0, "func(elems []string, sep string) string"},
-		{"LastIndex", Func, 0, "func(s string, substr string) int"},
-		{"LastIndexAny", Func, 0, "func(s string, chars string) int"},
-		{"LastIndexByte", Func, 5, "func(s string, c byte) int"},
-		{"LastIndexFunc", Func, 0, "func(s string, f func(rune) bool) int"},
-		{"Lines", Func, 24, "func(s string) iter.Seq[string]"},
-		{"Map", Func, 0, "func(mapping func(rune) rune, s string) string"},
-		{"NewReader", Func, 0, "func(s string) *Reader"},
-		{"NewReplacer", Func, 0, "func(oldnew ...string) *Replacer"},
-		{"Reader", Type, 0, ""},
-		{"Repeat", Func, 0, "func(s string, count int) string"},
-		{"Replace", Func, 0, "func(s string, old string, new string, n int) string"},
-		{"ReplaceAll", Func, 12, "func(s string, old string, new string) string"},
-		{"Replacer", Type, 0, ""},
-		{"Split", Func, 0, "func(s string, sep string) []string"},
-		{"SplitAfter", Func, 0, "func(s string, sep string) []string"},
-		{"SplitAfterN", Func, 0, "func(s string, sep string, n int) []string"},
-		{"SplitAfterSeq", Func, 24, "func(s string, sep string) iter.Seq[string]"},
-		{"SplitN", Func, 0, "func(s string, sep string, n int) []string"},
-		{"SplitSeq", Func, 24, "func(s string, sep string) iter.Seq[string]"},
-		{"Title", Func, 0, "func(s string) string"},
-		{"ToLower", Func, 0, "func(s string) string"},
-		{"ToLowerSpecial", Func, 0, "func(c unicode.SpecialCase, s string) string"},
-		{"ToTitle", Func, 0, "func(s string) string"},
-		{"ToTitleSpecial", Func, 0, "func(c unicode.SpecialCase, s string) string"},
-		{"ToUpper", Func, 0, "func(s string) string"},
-		{"ToUpperSpecial", Func, 0, "func(c unicode.SpecialCase, s string) string"},
-		{"ToValidUTF8", Func, 13, "func(s string, replacement string) string"},
-		{"Trim", Func, 0, "func(s string, cutset string) string"},
-		{"TrimFunc", Func, 0, "func(s string, f func(rune) bool) string"},
-		{"TrimLeft", Func, 0, "func(s string, cutset string) string"},
-		{"TrimLeftFunc", Func, 0, "func(s string, f func(rune) bool) string"},
-		{"TrimPrefix", Func, 1, "func(s string, prefix string) string"},
-		{"TrimRight", Func, 0, "func(s string, cutset string) string"},
-		{"TrimRightFunc", Func, 0, "func(s string, f func(rune) bool) string"},
-		{"TrimSpace", Func, 0, "func(s string) string"},
-		{"TrimSuffix", Func, 1, "func(s string, suffix string) string"},
-	},
-	"structs": {
-		{"HostLayout", Type, 23, ""},
-	},
-	"sync": {
-		{"(*Cond).Broadcast", Method, 0, ""},
-		{"(*Cond).Signal", Method, 0, ""},
-		{"(*Cond).Wait", Method, 0, ""},
-		{"(*Map).Clear", Method, 23, ""},
-		{"(*Map).CompareAndDelete", Method, 20, ""},
-		{"(*Map).CompareAndSwap", Method, 20, ""},
-		{"(*Map).Delete", Method, 9, ""},
-		{"(*Map).Load", Method, 9, ""},
-		{"(*Map).LoadAndDelete", Method, 15, ""},
-		{"(*Map).LoadOrStore", Method, 9, ""},
-		{"(*Map).Range", Method, 9, ""},
-		{"(*Map).Store", Method, 9, ""},
-		{"(*Map).Swap", Method, 20, ""},
-		{"(*Mutex).Lock", Method, 0, ""},
-		{"(*Mutex).TryLock", Method, 18, ""},
-		{"(*Mutex).Unlock", Method, 0, ""},
-		{"(*Once).Do", Method, 0, ""},
-		{"(*Pool).Get", Method, 3, ""},
-		{"(*Pool).Put", Method, 3, ""},
-		{"(*RWMutex).Lock", Method, 0, ""},
-		{"(*RWMutex).RLock", Method, 0, ""},
-		{"(*RWMutex).RLocker", Method, 0, ""},
-		{"(*RWMutex).RUnlock", Method, 0, ""},
-		{"(*RWMutex).TryLock", Method, 18, ""},
-		{"(*RWMutex).TryRLock", Method, 18, ""},
-		{"(*RWMutex).Unlock", Method, 0, ""},
-		{"(*WaitGroup).Add", Method, 0, ""},
-		{"(*WaitGroup).Done", Method, 0, ""},
-		{"(*WaitGroup).Go", Method, 25, ""},
-		{"(*WaitGroup).Wait", Method, 0, ""},
-		{"(Locker).Lock", Method, 0, ""},
-		{"(Locker).Unlock", Method, 0, ""},
-		{"Cond", Type, 0, ""},
-		{"Cond.L", Field, 0, ""},
-		{"Locker", Type, 0, ""},
-		{"Map", Type, 9, ""},
-		{"Mutex", Type, 0, ""},
-		{"NewCond", Func, 0, "func(l Locker) *Cond"},
-		{"Once", Type, 0, ""},
-		{"OnceFunc", Func, 21, "func(f func()) func()"},
-		{"OnceValue", Func, 21, "func[T any](f func() T) func() T"},
-		{"OnceValues", Func, 21, "func[T1, T2 any](f func() (T1, T2)) func() (T1, T2)"},
-		{"Pool", Type, 3, ""},
-		{"Pool.New", Field, 3, ""},
-		{"RWMutex", Type, 0, ""},
-		{"WaitGroup", Type, 0, ""},
-	},
-	"sync/atomic": {
-		{"(*Bool).CompareAndSwap", Method, 19, ""},
-		{"(*Bool).Load", Method, 19, ""},
-		{"(*Bool).Store", Method, 19, ""},
-		{"(*Bool).Swap", Method, 19, ""},
-		{"(*Int32).Add", Method, 19, ""},
-		{"(*Int32).And", Method, 23, ""},
-		{"(*Int32).CompareAndSwap", Method, 19, ""},
-		{"(*Int32).Load", Method, 19, ""},
-		{"(*Int32).Or", Method, 23, ""},
-		{"(*Int32).Store", Method, 19, ""},
-		{"(*Int32).Swap", Method, 19, ""},
-		{"(*Int64).Add", Method, 19, ""},
-		{"(*Int64).And", Method, 23, ""},
-		{"(*Int64).CompareAndSwap", Method, 19, ""},
-		{"(*Int64).Load", Method, 19, ""},
-		{"(*Int64).Or", Method, 23, ""},
-		{"(*Int64).Store", Method, 19, ""},
-		{"(*Int64).Swap", Method, 19, ""},
-		{"(*Pointer).CompareAndSwap", Method, 19, ""},
-		{"(*Pointer).Load", Method, 19, ""},
-		{"(*Pointer).Store", Method, 19, ""},
-		{"(*Pointer).Swap", Method, 19, ""},
-		{"(*Uint32).Add", Method, 19, ""},
-		{"(*Uint32).And", Method, 23, ""},
-		{"(*Uint32).CompareAndSwap", Method, 19, ""},
-		{"(*Uint32).Load", Method, 19, ""},
-		{"(*Uint32).Or", Method, 23, ""},
-		{"(*Uint32).Store", Method, 19, ""},
-		{"(*Uint32).Swap", Method, 19, ""},
-		{"(*Uint64).Add", Method, 19, ""},
-		{"(*Uint64).And", Method, 23, ""},
-		{"(*Uint64).CompareAndSwap", Method, 19, ""},
-		{"(*Uint64).Load", Method, 19, ""},
-		{"(*Uint64).Or", Method, 23, ""},
-		{"(*Uint64).Store", Method, 19, ""},
-		{"(*Uint64).Swap", Method, 19, ""},
-		{"(*Uintptr).Add", Method, 19, ""},
-		{"(*Uintptr).And", Method, 23, ""},
-		{"(*Uintptr).CompareAndSwap", Method, 19, ""},
-		{"(*Uintptr).Load", Method, 19, ""},
-		{"(*Uintptr).Or", Method, 23, ""},
-		{"(*Uintptr).Store", Method, 19, ""},
-		{"(*Uintptr).Swap", Method, 19, ""},
-		{"(*Value).CompareAndSwap", Method, 17, ""},
-		{"(*Value).Load", Method, 4, ""},
-		{"(*Value).Store", Method, 4, ""},
-		{"(*Value).Swap", Method, 17, ""},
-		{"AddInt32", Func, 0, "func(addr *int32, delta int32) (new int32)"},
-		{"AddInt64", Func, 0, "func(addr *int64, delta int64) (new int64)"},
-		{"AddUint32", Func, 0, "func(addr *uint32, delta uint32) (new uint32)"},
-		{"AddUint64", Func, 0, "func(addr *uint64, delta uint64) (new uint64)"},
-		{"AddUintptr", Func, 0, "func(addr *uintptr, delta uintptr) (new uintptr)"},
-		{"AndInt32", Func, 23, "func(addr *int32, mask int32) (old int32)"},
-		{"AndInt64", Func, 23, "func(addr *int64, mask int64) (old int64)"},
-		{"AndUint32", Func, 23, "func(addr *uint32, mask uint32) (old uint32)"},
-		{"AndUint64", Func, 23, "func(addr *uint64, mask uint64) (old uint64)"},
-		{"AndUintptr", Func, 23, "func(addr *uintptr, mask uintptr) (old uintptr)"},
-		{"Bool", Type, 19, ""},
-		{"CompareAndSwapInt32", Func, 0, "func(addr *int32, old int32, new int32) (swapped bool)"},
-		{"CompareAndSwapInt64", Func, 0, "func(addr *int64, old int64, new int64) (swapped bool)"},
-		{"CompareAndSwapPointer", Func, 0, "func(addr *unsafe.Pointer, old unsafe.Pointer, new unsafe.Pointer) (swapped bool)"},
-		{"CompareAndSwapUint32", Func, 0, "func(addr *uint32, old uint32, new uint32) (swapped bool)"},
-		{"CompareAndSwapUint64", Func, 0, "func(addr *uint64, old uint64, new uint64) (swapped bool)"},
-		{"CompareAndSwapUintptr", Func, 0, "func(addr *uintptr, old uintptr, new uintptr) (swapped bool)"},
-		{"Int32", Type, 19, ""},
-		{"Int64", Type, 19, ""},
-		{"LoadInt32", Func, 0, "func(addr *int32) (val int32)"},
-		{"LoadInt64", Func, 0, "func(addr *int64) (val int64)"},
-		{"LoadPointer", Func, 0, "func(addr *unsafe.Pointer) (val unsafe.Pointer)"},
-		{"LoadUint32", Func, 0, "func(addr *uint32) (val uint32)"},
-		{"LoadUint64", Func, 0, "func(addr *uint64) (val uint64)"},
-		{"LoadUintptr", Func, 0, "func(addr *uintptr) (val uintptr)"},
-		{"OrInt32", Func, 23, "func(addr *int32, mask int32) (old int32)"},
-		{"OrInt64", Func, 23, "func(addr *int64, mask int64) (old int64)"},
-		{"OrUint32", Func, 23, "func(addr *uint32, mask uint32) (old uint32)"},
-		{"OrUint64", Func, 23, "func(addr *uint64, mask uint64) (old uint64)"},
-		{"OrUintptr", Func, 23, "func(addr *uintptr, mask uintptr) (old uintptr)"},
-		{"Pointer", Type, 19, ""},
-		{"StoreInt32", Func, 0, "func(addr *int32, val int32)"},
-		{"StoreInt64", Func, 0, "func(addr *int64, val int64)"},
-		{"StorePointer", Func, 0, "func(addr *unsafe.Pointer, val unsafe.Pointer)"},
-		{"StoreUint32", Func, 0, "func(addr *uint32, val uint32)"},
-		{"StoreUint64", Func, 0, "func(addr *uint64, val uint64)"},
-		{"StoreUintptr", Func, 0, "func(addr *uintptr, val uintptr)"},
-		{"SwapInt32", Func, 2, "func(addr *int32, new int32) (old int32)"},
-		{"SwapInt64", Func, 2, "func(addr *int64, new int64) (old int64)"},
-		{"SwapPointer", Func, 2, "func(addr *unsafe.Pointer, new unsafe.Pointer) (old unsafe.Pointer)"},
-		{"SwapUint32", Func, 2, "func(addr *uint32, new uint32) (old uint32)"},
-		{"SwapUint64", Func, 2, "func(addr *uint64, new uint64) (old uint64)"},
-		{"SwapUintptr", Func, 2, "func(addr *uintptr, new uintptr) (old uintptr)"},
-		{"Uint32", Type, 19, ""},
-		{"Uint64", Type, 19, ""},
-		{"Uintptr", Type, 19, ""},
-		{"Value", Type, 4, ""},
-	},
-	"syscall": {
-		{"(*Cmsghdr).SetLen", Method, 0, ""},
-		{"(*DLL).FindProc", Method, 0, ""},
-		{"(*DLL).MustFindProc", Method, 0, ""},
-		{"(*DLL).Release", Method, 0, ""},
-		{"(*DLLError).Error", Method, 0, ""},
-		{"(*DLLError).Unwrap", Method, 16, ""},
-		{"(*Filetime).Nanoseconds", Method, 0, ""},
-		{"(*Iovec).SetLen", Method, 0, ""},
-		{"(*LazyDLL).Handle", Method, 0, ""},
-		{"(*LazyDLL).Load", Method, 0, ""},
-		{"(*LazyDLL).NewProc", Method, 0, ""},
-		{"(*LazyProc).Addr", Method, 0, ""},
-		{"(*LazyProc).Call", Method, 0, ""},
-		{"(*LazyProc).Find", Method, 0, ""},
-		{"(*Msghdr).SetControllen", Method, 0, ""},
-		{"(*Proc).Addr", Method, 0, ""},
-		{"(*Proc).Call", Method, 0, ""},
-		{"(*PtraceRegs).PC", Method, 0, ""},
-		{"(*PtraceRegs).SetPC", Method, 0, ""},
-		{"(*RawSockaddrAny).Sockaddr", Method, 0, ""},
-		{"(*SID).Copy", Method, 0, ""},
-		{"(*SID).Len", Method, 0, ""},
-		{"(*SID).LookupAccount", Method, 0, ""},
-		{"(*SID).String", Method, 0, ""},
-		{"(*Timespec).Nano", Method, 0, ""},
-		{"(*Timespec).Unix", Method, 0, ""},
-		{"(*Timeval).Nano", Method, 0, ""},
-		{"(*Timeval).Nanoseconds", Method, 0, ""},
-		{"(*Timeval).Unix", Method, 0, ""},
-		{"(Conn).SyscallConn", Method, 9, ""},
-		{"(Errno).Error", Method, 0, ""},
-		{"(Errno).Is", Method, 13, ""},
-		{"(Errno).Temporary", Method, 0, ""},
-		{"(Errno).Timeout", Method, 0, ""},
-		{"(RawConn).Control", Method, 9, ""},
-		{"(RawConn).Read", Method, 9, ""},
-		{"(RawConn).Write", Method, 9, ""},
-		{"(Signal).Signal", Method, 0, ""},
-		{"(Signal).String", Method, 0, ""},
-		{"(Token).Close", Method, 0, ""},
-		{"(Token).GetTokenPrimaryGroup", Method, 0, ""},
-		{"(Token).GetTokenUser", Method, 0, ""},
-		{"(Token).GetUserProfileDirectory", Method, 0, ""},
-		{"(WaitStatus).Continued", Method, 0, ""},
-		{"(WaitStatus).CoreDump", Method, 0, ""},
-		{"(WaitStatus).ExitStatus", Method, 0, ""},
-		{"(WaitStatus).Exited", Method, 0, ""},
-		{"(WaitStatus).Signal", Method, 0, ""},
-		{"(WaitStatus).Signaled", Method, 0, ""},
-		{"(WaitStatus).StopSignal", Method, 0, ""},
-		{"(WaitStatus).Stopped", Method, 0, ""},
-		{"(WaitStatus).TrapCause", Method, 0, ""},
-		{"AF_ALG", Const, 0, ""},
-		{"AF_APPLETALK", Const, 0, ""},
-		{"AF_ARP", Const, 0, ""},
-		{"AF_ASH", Const, 0, ""},
-		{"AF_ATM", Const, 0, ""},
-		{"AF_ATMPVC", Const, 0, ""},
-		{"AF_ATMSVC", Const, 0, ""},
-		{"AF_AX25", Const, 0, ""},
-		{"AF_BLUETOOTH", Const, 0, ""},
-		{"AF_BRIDGE", Const, 0, ""},
-		{"AF_CAIF", Const, 0, ""},
-		{"AF_CAN", Const, 0, ""},
-		{"AF_CCITT", Const, 0, ""},
-		{"AF_CHAOS", Const, 0, ""},
-		{"AF_CNT", Const, 0, ""},
-		{"AF_COIP", Const, 0, ""},
-		{"AF_DATAKIT", Const, 0, ""},
-		{"AF_DECnet", Const, 0, ""},
-		{"AF_DLI", Const, 0, ""},
-		{"AF_E164", Const, 0, ""},
-		{"AF_ECMA", Const, 0, ""},
-		{"AF_ECONET", Const, 0, ""},
-		{"AF_ENCAP", Const, 1, ""},
-		{"AF_FILE", Const, 0, ""},
-		{"AF_HYLINK", Const, 0, ""},
-		{"AF_IEEE80211", Const, 0, ""},
-		{"AF_IEEE802154", Const, 0, ""},
-		{"AF_IMPLINK", Const, 0, ""},
-		{"AF_INET", Const, 0, ""},
-		{"AF_INET6", Const, 0, ""},
-		{"AF_INET6_SDP", Const, 3, ""},
-		{"AF_INET_SDP", Const, 3, ""},
-		{"AF_IPX", Const, 0, ""},
-		{"AF_IRDA", Const, 0, ""},
-		{"AF_ISDN", Const, 0, ""},
-		{"AF_ISO", Const, 0, ""},
-		{"AF_IUCV", Const, 0, ""},
-		{"AF_KEY", Const, 0, ""},
-		{"AF_LAT", Const, 0, ""},
-		{"AF_LINK", Const, 0, ""},
-		{"AF_LLC", Const, 0, ""},
-		{"AF_LOCAL", Const, 0, ""},
-		{"AF_MAX", Const, 0, ""},
-		{"AF_MPLS", Const, 1, ""},
-		{"AF_NATM", Const, 0, ""},
-		{"AF_NDRV", Const, 0, ""},
-		{"AF_NETBEUI", Const, 0, ""},
-		{"AF_NETBIOS", Const, 0, ""},
-		{"AF_NETGRAPH", Const, 0, ""},
-		{"AF_NETLINK", Const, 0, ""},
-		{"AF_NETROM", Const, 0, ""},
-		{"AF_NS", Const, 0, ""},
-		{"AF_OROUTE", Const, 1, ""},
-		{"AF_OSI", Const, 0, ""},
-		{"AF_PACKET", Const, 0, ""},
-		{"AF_PHONET", Const, 0, ""},
-		{"AF_PPP", Const, 0, ""},
-		{"AF_PPPOX", Const, 0, ""},
-		{"AF_PUP", Const, 0, ""},
-		{"AF_RDS", Const, 0, ""},
-		{"AF_RESERVED_36", Const, 0, ""},
-		{"AF_ROSE", Const, 0, ""},
-		{"AF_ROUTE", Const, 0, ""},
-		{"AF_RXRPC", Const, 0, ""},
-		{"AF_SCLUSTER", Const, 0, ""},
-		{"AF_SECURITY", Const, 0, ""},
-		{"AF_SIP", Const, 0, ""},
-		{"AF_SLOW", Const, 0, ""},
-		{"AF_SNA", Const, 0, ""},
-		{"AF_SYSTEM", Const, 0, ""},
-		{"AF_TIPC", Const, 0, ""},
-		{"AF_UNIX", Const, 0, ""},
-		{"AF_UNSPEC", Const, 0, ""},
-		{"AF_UTUN", Const, 16, ""},
-		{"AF_VENDOR00", Const, 0, ""},
-		{"AF_VENDOR01", Const, 0, ""},
-		{"AF_VENDOR02", Const, 0, ""},
-		{"AF_VENDOR03", Const, 0, ""},
-		{"AF_VENDOR04", Const, 0, ""},
-		{"AF_VENDOR05", Const, 0, ""},
-		{"AF_VENDOR06", Const, 0, ""},
-		{"AF_VENDOR07", Const, 0, ""},
-		{"AF_VENDOR08", Const, 0, ""},
-		{"AF_VENDOR09", Const, 0, ""},
-		{"AF_VENDOR10", Const, 0, ""},
-		{"AF_VENDOR11", Const, 0, ""},
-		{"AF_VENDOR12", Const, 0, ""},
-		{"AF_VENDOR13", Const, 0, ""},
-		{"AF_VENDOR14", Const, 0, ""},
-		{"AF_VENDOR15", Const, 0, ""},
-		{"AF_VENDOR16", Const, 0, ""},
-		{"AF_VENDOR17", Const, 0, ""},
-		{"AF_VENDOR18", Const, 0, ""},
-		{"AF_VENDOR19", Const, 0, ""},
-		{"AF_VENDOR20", Const, 0, ""},
-		{"AF_VENDOR21", Const, 0, ""},
-		{"AF_VENDOR22", Const, 0, ""},
-		{"AF_VENDOR23", Const, 0, ""},
-		{"AF_VENDOR24", Const, 0, ""},
-		{"AF_VENDOR25", Const, 0, ""},
-		{"AF_VENDOR26", Const, 0, ""},
-		{"AF_VENDOR27", Const, 0, ""},
-		{"AF_VENDOR28", Const, 0, ""},
-		{"AF_VENDOR29", Const, 0, ""},
-		{"AF_VENDOR30", Const, 0, ""},
-		{"AF_VENDOR31", Const, 0, ""},
-		{"AF_VENDOR32", Const, 0, ""},
-		{"AF_VENDOR33", Const, 0, ""},
-		{"AF_VENDOR34", Const, 0, ""},
-		{"AF_VENDOR35", Const, 0, ""},
-		{"AF_VENDOR36", Const, 0, ""},
-		{"AF_VENDOR37", Const, 0, ""},
-		{"AF_VENDOR38", Const, 0, ""},
-		{"AF_VENDOR39", Const, 0, ""},
-		{"AF_VENDOR40", Const, 0, ""},
-		{"AF_VENDOR41", Const, 0, ""},
-		{"AF_VENDOR42", Const, 0, ""},
-		{"AF_VENDOR43", Const, 0, ""},
-		{"AF_VENDOR44", Const, 0, ""},
-		{"AF_VENDOR45", Const, 0, ""},
-		{"AF_VENDOR46", Const, 0, ""},
-		{"AF_VENDOR47", Const, 0, ""},
-		{"AF_WANPIPE", Const, 0, ""},
-		{"AF_X25", Const, 0, ""},
-		{"AI_CANONNAME", Const, 1, ""},
-		{"AI_NUMERICHOST", Const, 1, ""},
-		{"AI_PASSIVE", Const, 1, ""},
-		{"APPLICATION_ERROR", Const, 0, ""},
-		{"ARPHRD_ADAPT", Const, 0, ""},
-		{"ARPHRD_APPLETLK", Const, 0, ""},
-		{"ARPHRD_ARCNET", Const, 0, ""},
-		{"ARPHRD_ASH", Const, 0, ""},
-		{"ARPHRD_ATM", Const, 0, ""},
-		{"ARPHRD_AX25", Const, 0, ""},
-		{"ARPHRD_BIF", Const, 0, ""},
-		{"ARPHRD_CHAOS", Const, 0, ""},
-		{"ARPHRD_CISCO", Const, 0, ""},
-		{"ARPHRD_CSLIP", Const, 0, ""},
-		{"ARPHRD_CSLIP6", Const, 0, ""},
-		{"ARPHRD_DDCMP", Const, 0, ""},
-		{"ARPHRD_DLCI", Const, 0, ""},
-		{"ARPHRD_ECONET", Const, 0, ""},
-		{"ARPHRD_EETHER", Const, 0, ""},
-		{"ARPHRD_ETHER", Const, 0, ""},
-		{"ARPHRD_EUI64", Const, 0, ""},
-		{"ARPHRD_FCAL", Const, 0, ""},
-		{"ARPHRD_FCFABRIC", Const, 0, ""},
-		{"ARPHRD_FCPL", Const, 0, ""},
-		{"ARPHRD_FCPP", Const, 0, ""},
-		{"ARPHRD_FDDI", Const, 0, ""},
-		{"ARPHRD_FRAD", Const, 0, ""},
-		{"ARPHRD_FRELAY", Const, 1, ""},
-		{"ARPHRD_HDLC", Const, 0, ""},
-		{"ARPHRD_HIPPI", Const, 0, ""},
-		{"ARPHRD_HWX25", Const, 0, ""},
-		{"ARPHRD_IEEE1394", Const, 0, ""},
-		{"ARPHRD_IEEE802", Const, 0, ""},
-		{"ARPHRD_IEEE80211", Const, 0, ""},
-		{"ARPHRD_IEEE80211_PRISM", Const, 0, ""},
-		{"ARPHRD_IEEE80211_RADIOTAP", Const, 0, ""},
-		{"ARPHRD_IEEE802154", Const, 0, ""},
-		{"ARPHRD_IEEE802154_PHY", Const, 0, ""},
-		{"ARPHRD_IEEE802_TR", Const, 0, ""},
-		{"ARPHRD_INFINIBAND", Const, 0, ""},
-		{"ARPHRD_IPDDP", Const, 0, ""},
-		{"ARPHRD_IPGRE", Const, 0, ""},
-		{"ARPHRD_IRDA", Const, 0, ""},
-		{"ARPHRD_LAPB", Const, 0, ""},
-		{"ARPHRD_LOCALTLK", Const, 0, ""},
-		{"ARPHRD_LOOPBACK", Const, 0, ""},
-		{"ARPHRD_METRICOM", Const, 0, ""},
-		{"ARPHRD_NETROM", Const, 0, ""},
-		{"ARPHRD_NONE", Const, 0, ""},
-		{"ARPHRD_PIMREG", Const, 0, ""},
-		{"ARPHRD_PPP", Const, 0, ""},
-		{"ARPHRD_PRONET", Const, 0, ""},
-		{"ARPHRD_RAWHDLC", Const, 0, ""},
-		{"ARPHRD_ROSE", Const, 0, ""},
-		{"ARPHRD_RSRVD", Const, 0, ""},
-		{"ARPHRD_SIT", Const, 0, ""},
-		{"ARPHRD_SKIP", Const, 0, ""},
-		{"ARPHRD_SLIP", Const, 0, ""},
-		{"ARPHRD_SLIP6", Const, 0, ""},
-		{"ARPHRD_STRIP", Const, 1, ""},
-		{"ARPHRD_TUNNEL", Const, 0, ""},
-		{"ARPHRD_TUNNEL6", Const, 0, ""},
-		{"ARPHRD_VOID", Const, 0, ""},
-		{"ARPHRD_X25", Const, 0, ""},
-		{"AUTHTYPE_CLIENT", Const, 0, ""},
-		{"AUTHTYPE_SERVER", Const, 0, ""},
-		{"Accept", Func, 0, "func(fd int) (nfd int, sa Sockaddr, err error)"},
-		{"Accept4", Func, 1, "func(fd int, flags int) (nfd int, sa Sockaddr, err error)"},
-		{"AcceptEx", Func, 0, ""},
-		{"Access", Func, 0, "func(path string, mode uint32) (err error)"},
-		{"Acct", Func, 0, "func(path string) (err error)"},
-		{"AddrinfoW", Type, 1, ""},
-		{"AddrinfoW.Addr", Field, 1, ""},
-		{"AddrinfoW.Addrlen", Field, 1, ""},
-		{"AddrinfoW.Canonname", Field, 1, ""},
-		{"AddrinfoW.Family", Field, 1, ""},
-		{"AddrinfoW.Flags", Field, 1, ""},
-		{"AddrinfoW.Next", Field, 1, ""},
-		{"AddrinfoW.Protocol", Field, 1, ""},
-		{"AddrinfoW.Socktype", Field, 1, ""},
-		{"Adjtime", Func, 0, ""},
-		{"Adjtimex", Func, 0, "func(buf *Timex) (state int, err error)"},
-		{"AllThreadsSyscall", Func, 16, "func(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr) (r1 uintptr, r2 uintptr, err Errno)"},
-		{"AllThreadsSyscall6", Func, 16, "func(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr, a6 uintptr) (r1 uintptr, r2 uintptr, err Errno)"},
-		{"AttachLsf", Func, 0, "func(fd int, i []SockFilter) error"},
-		{"B0", Const, 0, ""},
-		{"B1000000", Const, 0, ""},
-		{"B110", Const, 0, ""},
-		{"B115200", Const, 0, ""},
-		{"B1152000", Const, 0, ""},
-		{"B1200", Const, 0, ""},
-		{"B134", Const, 0, ""},
-		{"B14400", Const, 1, ""},
-		{"B150", Const, 0, ""},
-		{"B1500000", Const, 0, ""},
-		{"B1800", Const, 0, ""},
-		{"B19200", Const, 0, ""},
-		{"B200", Const, 0, ""},
-		{"B2000000", Const, 0, ""},
-		{"B230400", Const, 0, ""},
-		{"B2400", Const, 0, ""},
-		{"B2500000", Const, 0, ""},
-		{"B28800", Const, 1, ""},
-		{"B300", Const, 0, ""},
-		{"B3000000", Const, 0, ""},
-		{"B3500000", Const, 0, ""},
-		{"B38400", Const, 0, ""},
-		{"B4000000", Const, 0, ""},
-		{"B460800", Const, 0, ""},
-		{"B4800", Const, 0, ""},
-		{"B50", Const, 0, ""},
-		{"B500000", Const, 0, ""},
-		{"B57600", Const, 0, ""},
-		{"B576000", Const, 0, ""},
-		{"B600", Const, 0, ""},
-		{"B7200", Const, 1, ""},
-		{"B75", Const, 0, ""},
-		{"B76800", Const, 1, ""},
-		{"B921600", Const, 0, ""},
-		{"B9600", Const, 0, ""},
-		{"BASE_PROTOCOL", Const, 2, ""},
-		{"BIOCFEEDBACK", Const, 0, ""},
-		{"BIOCFLUSH", Const, 0, ""},
-		{"BIOCGBLEN", Const, 0, ""},
-		{"BIOCGDIRECTION", Const, 0, ""},
-		{"BIOCGDIRFILT", Const, 1, ""},
-		{"BIOCGDLT", Const, 0, ""},
-		{"BIOCGDLTLIST", Const, 0, ""},
-		{"BIOCGETBUFMODE", Const, 0, ""},
-		{"BIOCGETIF", Const, 0, ""},
-		{"BIOCGETZMAX", Const, 0, ""},
-		{"BIOCGFEEDBACK", Const, 1, ""},
-		{"BIOCGFILDROP", Const, 1, ""},
-		{"BIOCGHDRCMPLT", Const, 0, ""},
-		{"BIOCGRSIG", Const, 0, ""},
-		{"BIOCGRTIMEOUT", Const, 0, ""},
-		{"BIOCGSEESENT", Const, 0, ""},
-		{"BIOCGSTATS", Const, 0, ""},
-		{"BIOCGSTATSOLD", Const, 1, ""},
-		{"BIOCGTSTAMP", Const, 1, ""},
-		{"BIOCIMMEDIATE", Const, 0, ""},
-		{"BIOCLOCK", Const, 0, ""},
-		{"BIOCPROMISC", Const, 0, ""},
-		{"BIOCROTZBUF", Const, 0, ""},
-		{"BIOCSBLEN", Const, 0, ""},
-		{"BIOCSDIRECTION", Const, 0, ""},
-		{"BIOCSDIRFILT", Const, 1, ""},
-		{"BIOCSDLT", Const, 0, ""},
-		{"BIOCSETBUFMODE", Const, 0, ""},
-		{"BIOCSETF", Const, 0, ""},
-		{"BIOCSETFNR", Const, 0, ""},
-		{"BIOCSETIF", Const, 0, ""},
-		{"BIOCSETWF", Const, 0, ""},
-		{"BIOCSETZBUF", Const, 0, ""},
-		{"BIOCSFEEDBACK", Const, 1, ""},
-		{"BIOCSFILDROP", Const, 1, ""},
-		{"BIOCSHDRCMPLT", Const, 0, ""},
-		{"BIOCSRSIG", Const, 0, ""},
-		{"BIOCSRTIMEOUT", Const, 0, ""},
-		{"BIOCSSEESENT", Const, 0, ""},
-		{"BIOCSTCPF", Const, 1, ""},
-		{"BIOCSTSTAMP", Const, 1, ""},
-		{"BIOCSUDPF", Const, 1, ""},
-		{"BIOCVERSION", Const, 0, ""},
-		{"BPF_A", Const, 0, ""},
-		{"BPF_ABS", Const, 0, ""},
-		{"BPF_ADD", Const, 0, ""},
-		{"BPF_ALIGNMENT", Const, 0, ""},
-		{"BPF_ALIGNMENT32", Const, 1, ""},
-		{"BPF_ALU", Const, 0, ""},
-		{"BPF_AND", Const, 0, ""},
-		{"BPF_B", Const, 0, ""},
-		{"BPF_BUFMODE_BUFFER", Const, 0, ""},
-		{"BPF_BUFMODE_ZBUF", Const, 0, ""},
-		{"BPF_DFLTBUFSIZE", Const, 1, ""},
-		{"BPF_DIRECTION_IN", Const, 1, ""},
-		{"BPF_DIRECTION_OUT", Const, 1, ""},
-		{"BPF_DIV", Const, 0, ""},
-		{"BPF_H", Const, 0, ""},
-		{"BPF_IMM", Const, 0, ""},
-		{"BPF_IND", Const, 0, ""},
-		{"BPF_JA", Const, 0, ""},
-		{"BPF_JEQ", Const, 0, ""},
-		{"BPF_JGE", Const, 0, ""},
-		{"BPF_JGT", Const, 0, ""},
-		{"BPF_JMP", Const, 0, ""},
-		{"BPF_JSET", Const, 0, ""},
-		{"BPF_K", Const, 0, ""},
-		{"BPF_LD", Const, 0, ""},
-		{"BPF_LDX", Const, 0, ""},
-		{"BPF_LEN", Const, 0, ""},
-		{"BPF_LSH", Const, 0, ""},
-		{"BPF_MAJOR_VERSION", Const, 0, ""},
-		{"BPF_MAXBUFSIZE", Const, 0, ""},
-		{"BPF_MAXINSNS", Const, 0, ""},
-		{"BPF_MEM", Const, 0, ""},
-		{"BPF_MEMWORDS", Const, 0, ""},
-		{"BPF_MINBUFSIZE", Const, 0, ""},
-		{"BPF_MINOR_VERSION", Const, 0, ""},
-		{"BPF_MISC", Const, 0, ""},
-		{"BPF_MSH", Const, 0, ""},
-		{"BPF_MUL", Const, 0, ""},
-		{"BPF_NEG", Const, 0, ""},
-		{"BPF_OR", Const, 0, ""},
-		{"BPF_RELEASE", Const, 0, ""},
-		{"BPF_RET", Const, 0, ""},
-		{"BPF_RSH", Const, 0, ""},
-		{"BPF_ST", Const, 0, ""},
-		{"BPF_STX", Const, 0, ""},
-		{"BPF_SUB", Const, 0, ""},
-		{"BPF_TAX", Const, 0, ""},
-		{"BPF_TXA", Const, 0, ""},
-		{"BPF_T_BINTIME", Const, 1, ""},
-		{"BPF_T_BINTIME_FAST", Const, 1, ""},
-		{"BPF_T_BINTIME_MONOTONIC", Const, 1, ""},
-		{"BPF_T_BINTIME_MONOTONIC_FAST", Const, 1, ""},
-		{"BPF_T_FAST", Const, 1, ""},
-		{"BPF_T_FLAG_MASK", Const, 1, ""},
-		{"BPF_T_FORMAT_MASK", Const, 1, ""},
-		{"BPF_T_MICROTIME", Const, 1, ""},
-		{"BPF_T_MICROTIME_FAST", Const, 1, ""},
-		{"BPF_T_MICROTIME_MONOTONIC", Const, 1, ""},
-		{"BPF_T_MICROTIME_MONOTONIC_FAST", Const, 1, ""},
-		{"BPF_T_MONOTONIC", Const, 1, ""},
-		{"BPF_T_MONOTONIC_FAST", Const, 1, ""},
-		{"BPF_T_NANOTIME", Const, 1, ""},
-		{"BPF_T_NANOTIME_FAST", Const, 1, ""},
-		{"BPF_T_NANOTIME_MONOTONIC", Const, 1, ""},
-		{"BPF_T_NANOTIME_MONOTONIC_FAST", Const, 1, ""},
-		{"BPF_T_NONE", Const, 1, ""},
-		{"BPF_T_NORMAL", Const, 1, ""},
-		{"BPF_W", Const, 0, ""},
-		{"BPF_X", Const, 0, ""},
-		{"BRKINT", Const, 0, ""},
-		{"Bind", Func, 0, "func(fd int, sa Sockaddr) (err error)"},
-		{"BindToDevice", Func, 0, "func(fd int, device string) (err error)"},
-		{"BpfBuflen", Func, 0, ""},
-		{"BpfDatalink", Func, 0, ""},
-		{"BpfHdr", Type, 0, ""},
-		{"BpfHdr.Caplen", Field, 0, ""},
-		{"BpfHdr.Datalen", Field, 0, ""},
-		{"BpfHdr.Hdrlen", Field, 0, ""},
-		{"BpfHdr.Pad_cgo_0", Field, 0, ""},
-		{"BpfHdr.Tstamp", Field, 0, ""},
-		{"BpfHeadercmpl", Func, 0, ""},
-		{"BpfInsn", Type, 0, ""},
-		{"BpfInsn.Code", Field, 0, ""},
-		{"BpfInsn.Jf", Field, 0, ""},
-		{"BpfInsn.Jt", Field, 0, ""},
-		{"BpfInsn.K", Field, 0, ""},
-		{"BpfInterface", Func, 0, ""},
-		{"BpfJump", Func, 0, ""},
-		{"BpfProgram", Type, 0, ""},
-		{"BpfProgram.Insns", Field, 0, ""},
-		{"BpfProgram.Len", Field, 0, ""},
-		{"BpfProgram.Pad_cgo_0", Field, 0, ""},
-		{"BpfStat", Type, 0, ""},
-		{"BpfStat.Capt", Field, 2, ""},
-		{"BpfStat.Drop", Field, 0, ""},
-		{"BpfStat.Padding", Field, 2, ""},
-		{"BpfStat.Recv", Field, 0, ""},
-		{"BpfStats", Func, 0, ""},
-		{"BpfStmt", Func, 0, ""},
-		{"BpfTimeout", Func, 0, ""},
-		{"BpfTimeval", Type, 2, ""},
-		{"BpfTimeval.Sec", Field, 2, ""},
-		{"BpfTimeval.Usec", Field, 2, ""},
-		{"BpfVersion", Type, 0, ""},
-		{"BpfVersion.Major", Field, 0, ""},
-		{"BpfVersion.Minor", Field, 0, ""},
-		{"BpfZbuf", Type, 0, ""},
-		{"BpfZbuf.Bufa", Field, 0, ""},
-		{"BpfZbuf.Bufb", Field, 0, ""},
-		{"BpfZbuf.Buflen", Field, 0, ""},
-		{"BpfZbufHeader", Type, 0, ""},
-		{"BpfZbufHeader.Kernel_gen", Field, 0, ""},
-		{"BpfZbufHeader.Kernel_len", Field, 0, ""},
-		{"BpfZbufHeader.User_gen", Field, 0, ""},
-		{"BpfZbufHeader.X_bzh_pad", Field, 0, ""},
-		{"ByHandleFileInformation", Type, 0, ""},
-		{"ByHandleFileInformation.CreationTime", Field, 0, ""},
-		{"ByHandleFileInformation.FileAttributes", Field, 0, ""},
-		{"ByHandleFileInformation.FileIndexHigh", Field, 0, ""},
-		{"ByHandleFileInformation.FileIndexLow", Field, 0, ""},
-		{"ByHandleFileInformation.FileSizeHigh", Field, 0, ""},
-		{"ByHandleFileInformation.FileSizeLow", Field, 0, ""},
-		{"ByHandleFileInformation.LastAccessTime", Field, 0, ""},
-		{"ByHandleFileInformation.LastWriteTime", Field, 0, ""},
-		{"ByHandleFileInformation.NumberOfLinks", Field, 0, ""},
-		{"ByHandleFileInformation.VolumeSerialNumber", Field, 0, ""},
-		{"BytePtrFromString", Func, 1, "func(s string) (*byte, error)"},
-		{"ByteSliceFromString", Func, 1, "func(s string) ([]byte, error)"},
-		{"CCR0_FLUSH", Const, 1, ""},
-		{"CERT_CHAIN_POLICY_AUTHENTICODE", Const, 0, ""},
-		{"CERT_CHAIN_POLICY_AUTHENTICODE_TS", Const, 0, ""},
-		{"CERT_CHAIN_POLICY_BASE", Const, 0, ""},
-		{"CERT_CHAIN_POLICY_BASIC_CONSTRAINTS", Const, 0, ""},
-		{"CERT_CHAIN_POLICY_EV", Const, 0, ""},
-		{"CERT_CHAIN_POLICY_MICROSOFT_ROOT", Const, 0, ""},
-		{"CERT_CHAIN_POLICY_NT_AUTH", Const, 0, ""},
-		{"CERT_CHAIN_POLICY_SSL", Const, 0, ""},
-		{"CERT_E_CN_NO_MATCH", Const, 0, ""},
-		{"CERT_E_EXPIRED", Const, 0, ""},
-		{"CERT_E_PURPOSE", Const, 0, ""},
-		{"CERT_E_ROLE", Const, 0, ""},
-		{"CERT_E_UNTRUSTEDROOT", Const, 0, ""},
-		{"CERT_STORE_ADD_ALWAYS", Const, 0, ""},
-		{"CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG", Const, 0, ""},
-		{"CERT_STORE_PROV_MEMORY", Const, 0, ""},
-		{"CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT", Const, 0, ""},
-		{"CERT_TRUST_HAS_NOT_DEFINED_NAME_CONSTRAINT", Const, 0, ""},
-		{"CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT", Const, 0, ""},
-		{"CERT_TRUST_HAS_NOT_SUPPORTED_CRITICAL_EXT", Const, 0, ""},
-		{"CERT_TRUST_HAS_NOT_SUPPORTED_NAME_CONSTRAINT", Const, 0, ""},
-		{"CERT_TRUST_INVALID_BASIC_CONSTRAINTS", Const, 0, ""},
-		{"CERT_TRUST_INVALID_EXTENSION", Const, 0, ""},
-		{"CERT_TRUST_INVALID_NAME_CONSTRAINTS", Const, 0, ""},
-		{"CERT_TRUST_INVALID_POLICY_CONSTRAINTS", Const, 0, ""},
-		{"CERT_TRUST_IS_CYCLIC", Const, 0, ""},
-		{"CERT_TRUST_IS_EXPLICIT_DISTRUST", Const, 0, ""},
-		{"CERT_TRUST_IS_NOT_SIGNATURE_VALID", Const, 0, ""},
-		{"CERT_TRUST_IS_NOT_TIME_VALID", Const, 0, ""},
-		{"CERT_TRUST_IS_NOT_VALID_FOR_USAGE", Const, 0, ""},
-		{"CERT_TRUST_IS_OFFLINE_REVOCATION", Const, 0, ""},
-		{"CERT_TRUST_IS_REVOKED", Const, 0, ""},
-		{"CERT_TRUST_IS_UNTRUSTED_ROOT", Const, 0, ""},
-		{"CERT_TRUST_NO_ERROR", Const, 0, ""},
-		{"CERT_TRUST_NO_ISSUANCE_CHAIN_POLICY", Const, 0, ""},
-		{"CERT_TRUST_REVOCATION_STATUS_UNKNOWN", Const, 0, ""},
-		{"CFLUSH", Const, 1, ""},
-		{"CLOCAL", Const, 0, ""},
-		{"CLONE_CHILD_CLEARTID", Const, 2, ""},
-		{"CLONE_CHILD_SETTID", Const, 2, ""},
-		{"CLONE_CLEAR_SIGHAND", Const, 20, ""},
-		{"CLONE_CSIGNAL", Const, 3, ""},
-		{"CLONE_DETACHED", Const, 2, ""},
-		{"CLONE_FILES", Const, 2, ""},
-		{"CLONE_FS", Const, 2, ""},
-		{"CLONE_INTO_CGROUP", Const, 20, ""},
-		{"CLONE_IO", Const, 2, ""},
-		{"CLONE_NEWCGROUP", Const, 20, ""},
-		{"CLONE_NEWIPC", Const, 2, ""},
-		{"CLONE_NEWNET", Const, 2, ""},
-		{"CLONE_NEWNS", Const, 2, ""},
-		{"CLONE_NEWPID", Const, 2, ""},
-		{"CLONE_NEWTIME", Const, 20, ""},
-		{"CLONE_NEWUSER", Const, 2, ""},
-		{"CLONE_NEWUTS", Const, 2, ""},
-		{"CLONE_PARENT", Const, 2, ""},
-		{"CLONE_PARENT_SETTID", Const, 2, ""},
-		{"CLONE_PID", Const, 3, ""},
-		{"CLONE_PIDFD", Const, 20, ""},
-		{"CLONE_PTRACE", Const, 2, ""},
-		{"CLONE_SETTLS", Const, 2, ""},
-		{"CLONE_SIGHAND", Const, 2, ""},
-		{"CLONE_SYSVSEM", Const, 2, ""},
-		{"CLONE_THREAD", Const, 2, ""},
-		{"CLONE_UNTRACED", Const, 2, ""},
-		{"CLONE_VFORK", Const, 2, ""},
-		{"CLONE_VM", Const, 2, ""},
-		{"CPUID_CFLUSH", Const, 1, ""},
-		{"CREAD", Const, 0, ""},
-		{"CREATE_ALWAYS", Const, 0, ""},
-		{"CREATE_NEW", Const, 0, ""},
-		{"CREATE_NEW_PROCESS_GROUP", Const, 1, ""},
-		{"CREATE_UNICODE_ENVIRONMENT", Const, 0, ""},
-		{"CRYPT_DEFAULT_CONTAINER_OPTIONAL", Const, 0, ""},
-		{"CRYPT_DELETEKEYSET", Const, 0, ""},
-		{"CRYPT_MACHINE_KEYSET", Const, 0, ""},
-		{"CRYPT_NEWKEYSET", Const, 0, ""},
-		{"CRYPT_SILENT", Const, 0, ""},
-		{"CRYPT_VERIFYCONTEXT", Const, 0, ""},
-		{"CS5", Const, 0, ""},
-		{"CS6", Const, 0, ""},
-		{"CS7", Const, 0, ""},
-		{"CS8", Const, 0, ""},
-		{"CSIZE", Const, 0, ""},
-		{"CSTART", Const, 1, ""},
-		{"CSTATUS", Const, 1, ""},
-		{"CSTOP", Const, 1, ""},
-		{"CSTOPB", Const, 0, ""},
-		{"CSUSP", Const, 1, ""},
-		{"CTL_MAXNAME", Const, 0, ""},
-		{"CTL_NET", Const, 0, ""},
-		{"CTL_QUERY", Const, 1, ""},
-		{"CTRL_BREAK_EVENT", Const, 1, ""},
-		{"CTRL_CLOSE_EVENT", Const, 14, ""},
-		{"CTRL_C_EVENT", Const, 1, ""},
-		{"CTRL_LOGOFF_EVENT", Const, 14, ""},
-		{"CTRL_SHUTDOWN_EVENT", Const, 14, ""},
-		{"CancelIo", Func, 0, ""},
-		{"CancelIoEx", Func, 1, ""},
-		{"CertAddCertificateContextToStore", Func, 0, ""},
-		{"CertChainContext", Type, 0, ""},
-		{"CertChainContext.ChainCount", Field, 0, ""},
-		{"CertChainContext.Chains", Field, 0, ""},
-		{"CertChainContext.HasRevocationFreshnessTime", Field, 0, ""},
-		{"CertChainContext.LowerQualityChainCount", Field, 0, ""},
-		{"CertChainContext.LowerQualityChains", Field, 0, ""},
-		{"CertChainContext.RevocationFreshnessTime", Field, 0, ""},
-		{"CertChainContext.Size", Field, 0, ""},
-		{"CertChainContext.TrustStatus", Field, 0, ""},
-		{"CertChainElement", Type, 0, ""},
-		{"CertChainElement.ApplicationUsage", Field, 0, ""},
-		{"CertChainElement.CertContext", Field, 0, ""},
-		{"CertChainElement.ExtendedErrorInfo", Field, 0, ""},
-		{"CertChainElement.IssuanceUsage", Field, 0, ""},
-		{"CertChainElement.RevocationInfo", Field, 0, ""},
-		{"CertChainElement.Size", Field, 0, ""},
-		{"CertChainElement.TrustStatus", Field, 0, ""},
-		{"CertChainPara", Type, 0, ""},
-		{"CertChainPara.CacheResync", Field, 0, ""},
-		{"CertChainPara.CheckRevocationFreshnessTime", Field, 0, ""},
-		{"CertChainPara.RequestedUsage", Field, 0, ""},
-		{"CertChainPara.RequstedIssuancePolicy", Field, 0, ""},
-		{"CertChainPara.RevocationFreshnessTime", Field, 0, ""},
-		{"CertChainPara.Size", Field, 0, ""},
-		{"CertChainPara.URLRetrievalTimeout", Field, 0, ""},
-		{"CertChainPolicyPara", Type, 0, ""},
-		{"CertChainPolicyPara.ExtraPolicyPara", Field, 0, ""},
-		{"CertChainPolicyPara.Flags", Field, 0, ""},
-		{"CertChainPolicyPara.Size", Field, 0, ""},
-		{"CertChainPolicyStatus", Type, 0, ""},
-		{"CertChainPolicyStatus.ChainIndex", Field, 0, ""},
-		{"CertChainPolicyStatus.ElementIndex", Field, 0, ""},
-		{"CertChainPolicyStatus.Error", Field, 0, ""},
-		{"CertChainPolicyStatus.ExtraPolicyStatus", Field, 0, ""},
-		{"CertChainPolicyStatus.Size", Field, 0, ""},
-		{"CertCloseStore", Func, 0, ""},
-		{"CertContext", Type, 0, ""},
-		{"CertContext.CertInfo", Field, 0, ""},
-		{"CertContext.EncodedCert", Field, 0, ""},
-		{"CertContext.EncodingType", Field, 0, ""},
-		{"CertContext.Length", Field, 0, ""},
-		{"CertContext.Store", Field, 0, ""},
-		{"CertCreateCertificateContext", Func, 0, ""},
-		{"CertEnhKeyUsage", Type, 0, ""},
-		{"CertEnhKeyUsage.Length", Field, 0, ""},
-		{"CertEnhKeyUsage.UsageIdentifiers", Field, 0, ""},
-		{"CertEnumCertificatesInStore", Func, 0, ""},
-		{"CertFreeCertificateChain", Func, 0, ""},
-		{"CertFreeCertificateContext", Func, 0, ""},
-		{"CertGetCertificateChain", Func, 0, ""},
-		{"CertInfo", Type, 11, ""},
-		{"CertOpenStore", Func, 0, ""},
-		{"CertOpenSystemStore", Func, 0, ""},
-		{"CertRevocationCrlInfo", Type, 11, ""},
-		{"CertRevocationInfo", Type, 0, ""},
-		{"CertRevocationInfo.CrlInfo", Field, 0, ""},
-		{"CertRevocationInfo.FreshnessTime", Field, 0, ""},
-		{"CertRevocationInfo.HasFreshnessTime", Field, 0, ""},
-		{"CertRevocationInfo.OidSpecificInfo", Field, 0, ""},
-		{"CertRevocationInfo.RevocationOid", Field, 0, ""},
-		{"CertRevocationInfo.RevocationResult", Field, 0, ""},
-		{"CertRevocationInfo.Size", Field, 0, ""},
-		{"CertSimpleChain", Type, 0, ""},
-		{"CertSimpleChain.Elements", Field, 0, ""},
-		{"CertSimpleChain.HasRevocationFreshnessTime", Field, 0, ""},
-		{"CertSimpleChain.NumElements", Field, 0, ""},
-		{"CertSimpleChain.RevocationFreshnessTime", Field, 0, ""},
-		{"CertSimpleChain.Size", Field, 0, ""},
-		{"CertSimpleChain.TrustListInfo", Field, 0, ""},
-		{"CertSimpleChain.TrustStatus", Field, 0, ""},
-		{"CertTrustListInfo", Type, 11, ""},
-		{"CertTrustStatus", Type, 0, ""},
-		{"CertTrustStatus.ErrorStatus", Field, 0, ""},
-		{"CertTrustStatus.InfoStatus", Field, 0, ""},
-		{"CertUsageMatch", Type, 0, ""},
-		{"CertUsageMatch.Type", Field, 0, ""},
-		{"CertUsageMatch.Usage", Field, 0, ""},
-		{"CertVerifyCertificateChainPolicy", Func, 0, ""},
-		{"Chdir", Func, 0, "func(path string) (err error)"},
-		{"CheckBpfVersion", Func, 0, ""},
-		{"Chflags", Func, 0, ""},
-		{"Chmod", Func, 0, "func(path string, mode uint32) (err error)"},
-		{"Chown", Func, 0, "func(path string, uid int, gid int) (err error)"},
-		{"Chroot", Func, 0, "func(path string) (err error)"},
-		{"Clearenv", Func, 0, "func()"},
-		{"Close", Func, 0, "func(fd int) (err error)"},
-		{"CloseHandle", Func, 0, ""},
-		{"CloseOnExec", Func, 0, "func(fd int)"},
-		{"Closesocket", Func, 0, ""},
-		{"CmsgLen", Func, 0, "func(datalen int) int"},
-		{"CmsgSpace", Func, 0, "func(datalen int) int"},
-		{"Cmsghdr", Type, 0, ""},
-		{"Cmsghdr.Len", Field, 0, ""},
-		{"Cmsghdr.Level", Field, 0, ""},
-		{"Cmsghdr.Type", Field, 0, ""},
-		{"Cmsghdr.X__cmsg_data", Field, 0, ""},
-		{"CommandLineToArgv", Func, 0, ""},
-		{"ComputerName", Func, 0, ""},
-		{"Conn", Type, 9, ""},
-		{"Connect", Func, 0, "func(fd int, sa Sockaddr) (err error)"},
-		{"ConnectEx", Func, 1, ""},
-		{"ConvertSidToStringSid", Func, 0, ""},
-		{"ConvertStringSidToSid", Func, 0, ""},
-		{"CopySid", Func, 0, ""},
-		{"Creat", Func, 0, "func(path string, mode uint32) (fd int, err error)"},
-		{"CreateDirectory", Func, 0, ""},
-		{"CreateFile", Func, 0, ""},
-		{"CreateFileMapping", Func, 0, ""},
-		{"CreateHardLink", Func, 4, ""},
-		{"CreateIoCompletionPort", Func, 0, ""},
-		{"CreatePipe", Func, 0, ""},
-		{"CreateProcess", Func, 0, ""},
-		{"CreateProcessAsUser", Func, 10, ""},
-		{"CreateSymbolicLink", Func, 4, ""},
-		{"CreateToolhelp32Snapshot", Func, 4, ""},
-		{"Credential", Type, 0, ""},
-		{"Credential.Gid", Field, 0, ""},
-		{"Credential.Groups", Field, 0, ""},
-		{"Credential.NoSetGroups", Field, 9, ""},
-		{"Credential.Uid", Field, 0, ""},
-		{"CryptAcquireContext", Func, 0, ""},
-		{"CryptGenRandom", Func, 0, ""},
-		{"CryptReleaseContext", Func, 0, ""},
-		{"DIOCBSFLUSH", Const, 1, ""},
-		{"DIOCOSFPFLUSH", Const, 1, ""},
-		{"DLL", Type, 0, ""},
-		{"DLL.Handle", Field, 0, ""},
-		{"DLL.Name", Field, 0, ""},
-		{"DLLError", Type, 0, ""},
-		{"DLLError.Err", Field, 0, ""},
-		{"DLLError.Msg", Field, 0, ""},
-		{"DLLError.ObjName", Field, 0, ""},
-		{"DLT_A429", Const, 0, ""},
-		{"DLT_A653_ICM", Const, 0, ""},
-		{"DLT_AIRONET_HEADER", Const, 0, ""},
-		{"DLT_AOS", Const, 1, ""},
-		{"DLT_APPLE_IP_OVER_IEEE1394", Const, 0, ""},
-		{"DLT_ARCNET", Const, 0, ""},
-		{"DLT_ARCNET_LINUX", Const, 0, ""},
-		{"DLT_ATM_CLIP", Const, 0, ""},
-		{"DLT_ATM_RFC1483", Const, 0, ""},
-		{"DLT_AURORA", Const, 0, ""},
-		{"DLT_AX25", Const, 0, ""},
-		{"DLT_AX25_KISS", Const, 0, ""},
-		{"DLT_BACNET_MS_TP", Const, 0, ""},
-		{"DLT_BLUETOOTH_HCI_H4", Const, 0, ""},
-		{"DLT_BLUETOOTH_HCI_H4_WITH_PHDR", Const, 0, ""},
-		{"DLT_CAN20B", Const, 0, ""},
-		{"DLT_CAN_SOCKETCAN", Const, 1, ""},
-		{"DLT_CHAOS", Const, 0, ""},
-		{"DLT_CHDLC", Const, 0, ""},
-		{"DLT_CISCO_IOS", Const, 0, ""},
-		{"DLT_C_HDLC", Const, 0, ""},
-		{"DLT_C_HDLC_WITH_DIR", Const, 0, ""},
-		{"DLT_DBUS", Const, 1, ""},
-		{"DLT_DECT", Const, 1, ""},
-		{"DLT_DOCSIS", Const, 0, ""},
-		{"DLT_DVB_CI", Const, 1, ""},
-		{"DLT_ECONET", Const, 0, ""},
-		{"DLT_EN10MB", Const, 0, ""},
-		{"DLT_EN3MB", Const, 0, ""},
-		{"DLT_ENC", Const, 0, ""},
-		{"DLT_ERF", Const, 0, ""},
-		{"DLT_ERF_ETH", Const, 0, ""},
-		{"DLT_ERF_POS", Const, 0, ""},
-		{"DLT_FC_2", Const, 1, ""},
-		{"DLT_FC_2_WITH_FRAME_DELIMS", Const, 1, ""},
-		{"DLT_FDDI", Const, 0, ""},
-		{"DLT_FLEXRAY", Const, 0, ""},
-		{"DLT_FRELAY", Const, 0, ""},
-		{"DLT_FRELAY_WITH_DIR", Const, 0, ""},
-		{"DLT_GCOM_SERIAL", Const, 0, ""},
-		{"DLT_GCOM_T1E1", Const, 0, ""},
-		{"DLT_GPF_F", Const, 0, ""},
-		{"DLT_GPF_T", Const, 0, ""},
-		{"DLT_GPRS_LLC", Const, 0, ""},
-		{"DLT_GSMTAP_ABIS", Const, 1, ""},
-		{"DLT_GSMTAP_UM", Const, 1, ""},
-		{"DLT_HDLC", Const, 1, ""},
-		{"DLT_HHDLC", Const, 0, ""},
-		{"DLT_HIPPI", Const, 1, ""},
-		{"DLT_IBM_SN", Const, 0, ""},
-		{"DLT_IBM_SP", Const, 0, ""},
-		{"DLT_IEEE802", Const, 0, ""},
-		{"DLT_IEEE802_11", Const, 0, ""},
-		{"DLT_IEEE802_11_RADIO", Const, 0, ""},
-		{"DLT_IEEE802_11_RADIO_AVS", Const, 0, ""},
-		{"DLT_IEEE802_15_4", Const, 0, ""},
-		{"DLT_IEEE802_15_4_LINUX", Const, 0, ""},
-		{"DLT_IEEE802_15_4_NOFCS", Const, 1, ""},
-		{"DLT_IEEE802_15_4_NONASK_PHY", Const, 0, ""},
-		{"DLT_IEEE802_16_MAC_CPS", Const, 0, ""},
-		{"DLT_IEEE802_16_MAC_CPS_RADIO", Const, 0, ""},
-		{"DLT_IPFILTER", Const, 0, ""},
-		{"DLT_IPMB", Const, 0, ""},
-		{"DLT_IPMB_LINUX", Const, 0, ""},
-		{"DLT_IPNET", Const, 1, ""},
-		{"DLT_IPOIB", Const, 1, ""},
-		{"DLT_IPV4", Const, 1, ""},
-		{"DLT_IPV6", Const, 1, ""},
-		{"DLT_IP_OVER_FC", Const, 0, ""},
-		{"DLT_JUNIPER_ATM1", Const, 0, ""},
-		{"DLT_JUNIPER_ATM2", Const, 0, ""},
-		{"DLT_JUNIPER_ATM_CEMIC", Const, 1, ""},
-		{"DLT_JUNIPER_CHDLC", Const, 0, ""},
-		{"DLT_JUNIPER_ES", Const, 0, ""},
-		{"DLT_JUNIPER_ETHER", Const, 0, ""},
-		{"DLT_JUNIPER_FIBRECHANNEL", Const, 1, ""},
-		{"DLT_JUNIPER_FRELAY", Const, 0, ""},
-		{"DLT_JUNIPER_GGSN", Const, 0, ""},
-		{"DLT_JUNIPER_ISM", Const, 0, ""},
-		{"DLT_JUNIPER_MFR", Const, 0, ""},
-		{"DLT_JUNIPER_MLFR", Const, 0, ""},
-		{"DLT_JUNIPER_MLPPP", Const, 0, ""},
-		{"DLT_JUNIPER_MONITOR", Const, 0, ""},
-		{"DLT_JUNIPER_PIC_PEER", Const, 0, ""},
-		{"DLT_JUNIPER_PPP", Const, 0, ""},
-		{"DLT_JUNIPER_PPPOE", Const, 0, ""},
-		{"DLT_JUNIPER_PPPOE_ATM", Const, 0, ""},
-		{"DLT_JUNIPER_SERVICES", Const, 0, ""},
-		{"DLT_JUNIPER_SRX_E2E", Const, 1, ""},
-		{"DLT_JUNIPER_ST", Const, 0, ""},
-		{"DLT_JUNIPER_VP", Const, 0, ""},
-		{"DLT_JUNIPER_VS", Const, 1, ""},
-		{"DLT_LAPB_WITH_DIR", Const, 0, ""},
-		{"DLT_LAPD", Const, 0, ""},
-		{"DLT_LIN", Const, 0, ""},
-		{"DLT_LINUX_EVDEV", Const, 1, ""},
-		{"DLT_LINUX_IRDA", Const, 0, ""},
-		{"DLT_LINUX_LAPD", Const, 0, ""},
-		{"DLT_LINUX_PPP_WITHDIRECTION", Const, 0, ""},
-		{"DLT_LINUX_SLL", Const, 0, ""},
-		{"DLT_LOOP", Const, 0, ""},
-		{"DLT_LTALK", Const, 0, ""},
-		{"DLT_MATCHING_MAX", Const, 1, ""},
-		{"DLT_MATCHING_MIN", Const, 1, ""},
-		{"DLT_MFR", Const, 0, ""},
-		{"DLT_MOST", Const, 0, ""},
-		{"DLT_MPEG_2_TS", Const, 1, ""},
-		{"DLT_MPLS", Const, 1, ""},
-		{"DLT_MTP2", Const, 0, ""},
-		{"DLT_MTP2_WITH_PHDR", Const, 0, ""},
-		{"DLT_MTP3", Const, 0, ""},
-		{"DLT_MUX27010", Const, 1, ""},
-		{"DLT_NETANALYZER", Const, 1, ""},
-		{"DLT_NETANALYZER_TRANSPARENT", Const, 1, ""},
-		{"DLT_NFC_LLCP", Const, 1, ""},
-		{"DLT_NFLOG", Const, 1, ""},
-		{"DLT_NG40", Const, 1, ""},
-		{"DLT_NULL", Const, 0, ""},
-		{"DLT_PCI_EXP", Const, 0, ""},
-		{"DLT_PFLOG", Const, 0, ""},
-		{"DLT_PFSYNC", Const, 0, ""},
-		{"DLT_PPI", Const, 0, ""},
-		{"DLT_PPP", Const, 0, ""},
-		{"DLT_PPP_BSDOS", Const, 0, ""},
-		{"DLT_PPP_ETHER", Const, 0, ""},
-		{"DLT_PPP_PPPD", Const, 0, ""},
-		{"DLT_PPP_SERIAL", Const, 0, ""},
-		{"DLT_PPP_WITH_DIR", Const, 0, ""},
-		{"DLT_PPP_WITH_DIRECTION", Const, 0, ""},
-		{"DLT_PRISM_HEADER", Const, 0, ""},
-		{"DLT_PRONET", Const, 0, ""},
-		{"DLT_RAIF1", Const, 0, ""},
-		{"DLT_RAW", Const, 0, ""},
-		{"DLT_RAWAF_MASK", Const, 1, ""},
-		{"DLT_RIO", Const, 0, ""},
-		{"DLT_SCCP", Const, 0, ""},
-		{"DLT_SITA", Const, 0, ""},
-		{"DLT_SLIP", Const, 0, ""},
-		{"DLT_SLIP_BSDOS", Const, 0, ""},
-		{"DLT_STANAG_5066_D_PDU", Const, 1, ""},
-		{"DLT_SUNATM", Const, 0, ""},
-		{"DLT_SYMANTEC_FIREWALL", Const, 0, ""},
-		{"DLT_TZSP", Const, 0, ""},
-		{"DLT_USB", Const, 0, ""},
-		{"DLT_USB_LINUX", Const, 0, ""},
-		{"DLT_USB_LINUX_MMAPPED", Const, 1, ""},
-		{"DLT_USER0", Const, 0, ""},
-		{"DLT_USER1", Const, 0, ""},
-		{"DLT_USER10", Const, 0, ""},
-		{"DLT_USER11", Const, 0, ""},
-		{"DLT_USER12", Const, 0, ""},
-		{"DLT_USER13", Const, 0, ""},
-		{"DLT_USER14", Const, 0, ""},
-		{"DLT_USER15", Const, 0, ""},
-		{"DLT_USER2", Const, 0, ""},
-		{"DLT_USER3", Const, 0, ""},
-		{"DLT_USER4", Const, 0, ""},
-		{"DLT_USER5", Const, 0, ""},
-		{"DLT_USER6", Const, 0, ""},
-		{"DLT_USER7", Const, 0, ""},
-		{"DLT_USER8", Const, 0, ""},
-		{"DLT_USER9", Const, 0, ""},
-		{"DLT_WIHART", Const, 1, ""},
-		{"DLT_X2E_SERIAL", Const, 0, ""},
-		{"DLT_X2E_XORAYA", Const, 0, ""},
-		{"DNSMXData", Type, 0, ""},
-		{"DNSMXData.NameExchange", Field, 0, ""},
-		{"DNSMXData.Pad", Field, 0, ""},
-		{"DNSMXData.Preference", Field, 0, ""},
-		{"DNSPTRData", Type, 0, ""},
-		{"DNSPTRData.Host", Field, 0, ""},
-		{"DNSRecord", Type, 0, ""},
-		{"DNSRecord.Data", Field, 0, ""},
-		{"DNSRecord.Dw", Field, 0, ""},
-		{"DNSRecord.Length", Field, 0, ""},
-		{"DNSRecord.Name", Field, 0, ""},
-		{"DNSRecord.Next", Field, 0, ""},
-		{"DNSRecord.Reserved", Field, 0, ""},
-		{"DNSRecord.Ttl", Field, 0, ""},
-		{"DNSRecord.Type", Field, 0, ""},
-		{"DNSSRVData", Type, 0, ""},
-		{"DNSSRVData.Pad", Field, 0, ""},
-		{"DNSSRVData.Port", Field, 0, ""},
-		{"DNSSRVData.Priority", Field, 0, ""},
-		{"DNSSRVData.Target", Field, 0, ""},
-		{"DNSSRVData.Weight", Field, 0, ""},
-		{"DNSTXTData", Type, 0, ""},
-		{"DNSTXTData.StringArray", Field, 0, ""},
-		{"DNSTXTData.StringCount", Field, 0, ""},
-		{"DNS_INFO_NO_RECORDS", Const, 4, ""},
-		{"DNS_TYPE_A", Const, 0, ""},
-		{"DNS_TYPE_A6", Const, 0, ""},
-		{"DNS_TYPE_AAAA", Const, 0, ""},
-		{"DNS_TYPE_ADDRS", Const, 0, ""},
-		{"DNS_TYPE_AFSDB", Const, 0, ""},
-		{"DNS_TYPE_ALL", Const, 0, ""},
-		{"DNS_TYPE_ANY", Const, 0, ""},
-		{"DNS_TYPE_ATMA", Const, 0, ""},
-		{"DNS_TYPE_AXFR", Const, 0, ""},
-		{"DNS_TYPE_CERT", Const, 0, ""},
-		{"DNS_TYPE_CNAME", Const, 0, ""},
-		{"DNS_TYPE_DHCID", Const, 0, ""},
-		{"DNS_TYPE_DNAME", Const, 0, ""},
-		{"DNS_TYPE_DNSKEY", Const, 0, ""},
-		{"DNS_TYPE_DS", Const, 0, ""},
-		{"DNS_TYPE_EID", Const, 0, ""},
-		{"DNS_TYPE_GID", Const, 0, ""},
-		{"DNS_TYPE_GPOS", Const, 0, ""},
-		{"DNS_TYPE_HINFO", Const, 0, ""},
-		{"DNS_TYPE_ISDN", Const, 0, ""},
-		{"DNS_TYPE_IXFR", Const, 0, ""},
-		{"DNS_TYPE_KEY", Const, 0, ""},
-		{"DNS_TYPE_KX", Const, 0, ""},
-		{"DNS_TYPE_LOC", Const, 0, ""},
-		{"DNS_TYPE_MAILA", Const, 0, ""},
-		{"DNS_TYPE_MAILB", Const, 0, ""},
-		{"DNS_TYPE_MB", Const, 0, ""},
-		{"DNS_TYPE_MD", Const, 0, ""},
-		{"DNS_TYPE_MF", Const, 0, ""},
-		{"DNS_TYPE_MG", Const, 0, ""},
-		{"DNS_TYPE_MINFO", Const, 0, ""},
-		{"DNS_TYPE_MR", Const, 0, ""},
-		{"DNS_TYPE_MX", Const, 0, ""},
-		{"DNS_TYPE_NAPTR", Const, 0, ""},
-		{"DNS_TYPE_NBSTAT", Const, 0, ""},
-		{"DNS_TYPE_NIMLOC", Const, 0, ""},
-		{"DNS_TYPE_NS", Const, 0, ""},
-		{"DNS_TYPE_NSAP", Const, 0, ""},
-		{"DNS_TYPE_NSAPPTR", Const, 0, ""},
-		{"DNS_TYPE_NSEC", Const, 0, ""},
-		{"DNS_TYPE_NULL", Const, 0, ""},
-		{"DNS_TYPE_NXT", Const, 0, ""},
-		{"DNS_TYPE_OPT", Const, 0, ""},
-		{"DNS_TYPE_PTR", Const, 0, ""},
-		{"DNS_TYPE_PX", Const, 0, ""},
-		{"DNS_TYPE_RP", Const, 0, ""},
-		{"DNS_TYPE_RRSIG", Const, 0, ""},
-		{"DNS_TYPE_RT", Const, 0, ""},
-		{"DNS_TYPE_SIG", Const, 0, ""},
-		{"DNS_TYPE_SINK", Const, 0, ""},
-		{"DNS_TYPE_SOA", Const, 0, ""},
-		{"DNS_TYPE_SRV", Const, 0, ""},
-		{"DNS_TYPE_TEXT", Const, 0, ""},
-		{"DNS_TYPE_TKEY", Const, 0, ""},
-		{"DNS_TYPE_TSIG", Const, 0, ""},
-		{"DNS_TYPE_UID", Const, 0, ""},
-		{"DNS_TYPE_UINFO", Const, 0, ""},
-		{"DNS_TYPE_UNSPEC", Const, 0, ""},
-		{"DNS_TYPE_WINS", Const, 0, ""},
-		{"DNS_TYPE_WINSR", Const, 0, ""},
-		{"DNS_TYPE_WKS", Const, 0, ""},
-		{"DNS_TYPE_X25", Const, 0, ""},
-		{"DT_BLK", Const, 0, ""},
-		{"DT_CHR", Const, 0, ""},
-		{"DT_DIR", Const, 0, ""},
-		{"DT_FIFO", Const, 0, ""},
-		{"DT_LNK", Const, 0, ""},
-		{"DT_REG", Const, 0, ""},
-		{"DT_SOCK", Const, 0, ""},
-		{"DT_UNKNOWN", Const, 0, ""},
-		{"DT_WHT", Const, 0, ""},
-		{"DUPLICATE_CLOSE_SOURCE", Const, 0, ""},
-		{"DUPLICATE_SAME_ACCESS", Const, 0, ""},
-		{"DeleteFile", Func, 0, ""},
-		{"DetachLsf", Func, 0, "func(fd int) error"},
-		{"DeviceIoControl", Func, 4, ""},
-		{"Dirent", Type, 0, ""},
-		{"Dirent.Fileno", Field, 0, ""},
-		{"Dirent.Ino", Field, 0, ""},
-		{"Dirent.Name", Field, 0, ""},
-		{"Dirent.Namlen", Field, 0, ""},
-		{"Dirent.Off", Field, 0, ""},
-		{"Dirent.Pad0", Field, 12, ""},
-		{"Dirent.Pad1", Field, 12, ""},
-		{"Dirent.Pad_cgo_0", Field, 0, ""},
-		{"Dirent.Reclen", Field, 0, ""},
-		{"Dirent.Seekoff", Field, 0, ""},
-		{"Dirent.Type", Field, 0, ""},
-		{"Dirent.X__d_padding", Field, 3, ""},
-		{"DnsNameCompare", Func, 4, ""},
-		{"DnsQuery", Func, 0, ""},
-		{"DnsRecordListFree", Func, 0, ""},
-		{"DnsSectionAdditional", Const, 4, ""},
-		{"DnsSectionAnswer", Const, 4, ""},
-		{"DnsSectionAuthority", Const, 4, ""},
-		{"DnsSectionQuestion", Const, 4, ""},
-		{"Dup", Func, 0, "func(oldfd int) (fd int, err error)"},
-		{"Dup2", Func, 0, "func(oldfd int, newfd int) (err error)"},
-		{"Dup3", Func, 2, "func(oldfd int, newfd int, flags int) (err error)"},
-		{"DuplicateHandle", Func, 0, ""},
-		{"E2BIG", Const, 0, ""},
-		{"EACCES", Const, 0, ""},
-		{"EADDRINUSE", Const, 0, ""},
-		{"EADDRNOTAVAIL", Const, 0, ""},
-		{"EADV", Const, 0, ""},
-		{"EAFNOSUPPORT", Const, 0, ""},
-		{"EAGAIN", Const, 0, ""},
-		{"EALREADY", Const, 0, ""},
-		{"EAUTH", Const, 0, ""},
-		{"EBADARCH", Const, 0, ""},
-		{"EBADE", Const, 0, ""},
-		{"EBADEXEC", Const, 0, ""},
-		{"EBADF", Const, 0, ""},
-		{"EBADFD", Const, 0, ""},
-		{"EBADMACHO", Const, 0, ""},
-		{"EBADMSG", Const, 0, ""},
-		{"EBADR", Const, 0, ""},
-		{"EBADRPC", Const, 0, ""},
-		{"EBADRQC", Const, 0, ""},
-		{"EBADSLT", Const, 0, ""},
-		{"EBFONT", Const, 0, ""},
-		{"EBUSY", Const, 0, ""},
-		{"ECANCELED", Const, 0, ""},
-		{"ECAPMODE", Const, 1, ""},
-		{"ECHILD", Const, 0, ""},
-		{"ECHO", Const, 0, ""},
-		{"ECHOCTL", Const, 0, ""},
-		{"ECHOE", Const, 0, ""},
-		{"ECHOK", Const, 0, ""},
-		{"ECHOKE", Const, 0, ""},
-		{"ECHONL", Const, 0, ""},
-		{"ECHOPRT", Const, 0, ""},
-		{"ECHRNG", Const, 0, ""},
-		{"ECOMM", Const, 0, ""},
-		{"ECONNABORTED", Const, 0, ""},
-		{"ECONNREFUSED", Const, 0, ""},
-		{"ECONNRESET", Const, 0, ""},
-		{"EDEADLK", Const, 0, ""},
-		{"EDEADLOCK", Const, 0, ""},
-		{"EDESTADDRREQ", Const, 0, ""},
-		{"EDEVERR", Const, 0, ""},
-		{"EDOM", Const, 0, ""},
-		{"EDOOFUS", Const, 0, ""},
-		{"EDOTDOT", Const, 0, ""},
-		{"EDQUOT", Const, 0, ""},
-		{"EEXIST", Const, 0, ""},
-		{"EFAULT", Const, 0, ""},
-		{"EFBIG", Const, 0, ""},
-		{"EFER_LMA", Const, 1, ""},
-		{"EFER_LME", Const, 1, ""},
-		{"EFER_NXE", Const, 1, ""},
-		{"EFER_SCE", Const, 1, ""},
-		{"EFTYPE", Const, 0, ""},
-		{"EHOSTDOWN", Const, 0, ""},
-		{"EHOSTUNREACH", Const, 0, ""},
-		{"EHWPOISON", Const, 0, ""},
-		{"EIDRM", Const, 0, ""},
-		{"EILSEQ", Const, 0, ""},
-		{"EINPROGRESS", Const, 0, ""},
-		{"EINTR", Const, 0, ""},
-		{"EINVAL", Const, 0, ""},
-		{"EIO", Const, 0, ""},
-		{"EIPSEC", Const, 1, ""},
-		{"EISCONN", Const, 0, ""},
-		{"EISDIR", Const, 0, ""},
-		{"EISNAM", Const, 0, ""},
-		{"EKEYEXPIRED", Const, 0, ""},
-		{"EKEYREJECTED", Const, 0, ""},
-		{"EKEYREVOKED", Const, 0, ""},
-		{"EL2HLT", Const, 0, ""},
-		{"EL2NSYNC", Const, 0, ""},
-		{"EL3HLT", Const, 0, ""},
-		{"EL3RST", Const, 0, ""},
-		{"ELAST", Const, 0, ""},
-		{"ELF_NGREG", Const, 0, ""},
-		{"ELF_PRARGSZ", Const, 0, ""},
-		{"ELIBACC", Const, 0, ""},
-		{"ELIBBAD", Const, 0, ""},
-		{"ELIBEXEC", Const, 0, ""},
-		{"ELIBMAX", Const, 0, ""},
-		{"ELIBSCN", Const, 0, ""},
-		{"ELNRNG", Const, 0, ""},
-		{"ELOOP", Const, 0, ""},
-		{"EMEDIUMTYPE", Const, 0, ""},
-		{"EMFILE", Const, 0, ""},
-		{"EMLINK", Const, 0, ""},
-		{"EMSGSIZE", Const, 0, ""},
-		{"EMT_TAGOVF", Const, 1, ""},
-		{"EMULTIHOP", Const, 0, ""},
-		{"EMUL_ENABLED", Const, 1, ""},
-		{"EMUL_LINUX", Const, 1, ""},
-		{"EMUL_LINUX32", Const, 1, ""},
-		{"EMUL_MAXID", Const, 1, ""},
-		{"EMUL_NATIVE", Const, 1, ""},
-		{"ENAMETOOLONG", Const, 0, ""},
-		{"ENAVAIL", Const, 0, ""},
-		{"ENDRUNDISC", Const, 1, ""},
-		{"ENEEDAUTH", Const, 0, ""},
-		{"ENETDOWN", Const, 0, ""},
-		{"ENETRESET", Const, 0, ""},
-		{"ENETUNREACH", Const, 0, ""},
-		{"ENFILE", Const, 0, ""},
-		{"ENOANO", Const, 0, ""},
-		{"ENOATTR", Const, 0, ""},
-		{"ENOBUFS", Const, 0, ""},
-		{"ENOCSI", Const, 0, ""},
-		{"ENODATA", Const, 0, ""},
-		{"ENODEV", Const, 0, ""},
-		{"ENOENT", Const, 0, ""},
-		{"ENOEXEC", Const, 0, ""},
-		{"ENOKEY", Const, 0, ""},
-		{"ENOLCK", Const, 0, ""},
-		{"ENOLINK", Const, 0, ""},
-		{"ENOMEDIUM", Const, 0, ""},
-		{"ENOMEM", Const, 0, ""},
-		{"ENOMSG", Const, 0, ""},
-		{"ENONET", Const, 0, ""},
-		{"ENOPKG", Const, 0, ""},
-		{"ENOPOLICY", Const, 0, ""},
-		{"ENOPROTOOPT", Const, 0, ""},
-		{"ENOSPC", Const, 0, ""},
-		{"ENOSR", Const, 0, ""},
-		{"ENOSTR", Const, 0, ""},
-		{"ENOSYS", Const, 0, ""},
-		{"ENOTBLK", Const, 0, ""},
-		{"ENOTCAPABLE", Const, 0, ""},
-		{"ENOTCONN", Const, 0, ""},
-		{"ENOTDIR", Const, 0, ""},
-		{"ENOTEMPTY", Const, 0, ""},
-		{"ENOTNAM", Const, 0, ""},
-		{"ENOTRECOVERABLE", Const, 0, ""},
-		{"ENOTSOCK", Const, 0, ""},
-		{"ENOTSUP", Const, 0, ""},
-		{"ENOTTY", Const, 0, ""},
-		{"ENOTUNIQ", Const, 0, ""},
-		{"ENXIO", Const, 0, ""},
-		{"EN_SW_CTL_INF", Const, 1, ""},
-		{"EN_SW_CTL_PREC", Const, 1, ""},
-		{"EN_SW_CTL_ROUND", Const, 1, ""},
-		{"EN_SW_DATACHAIN", Const, 1, ""},
-		{"EN_SW_DENORM", Const, 1, ""},
-		{"EN_SW_INVOP", Const, 1, ""},
-		{"EN_SW_OVERFLOW", Const, 1, ""},
-		{"EN_SW_PRECLOSS", Const, 1, ""},
-		{"EN_SW_UNDERFLOW", Const, 1, ""},
-		{"EN_SW_ZERODIV", Const, 1, ""},
-		{"EOPNOTSUPP", Const, 0, ""},
-		{"EOVERFLOW", Const, 0, ""},
-		{"EOWNERDEAD", Const, 0, ""},
-		{"EPERM", Const, 0, ""},
-		{"EPFNOSUPPORT", Const, 0, ""},
-		{"EPIPE", Const, 0, ""},
-		{"EPOLLERR", Const, 0, ""},
-		{"EPOLLET", Const, 0, ""},
-		{"EPOLLHUP", Const, 0, ""},
-		{"EPOLLIN", Const, 0, ""},
-		{"EPOLLMSG", Const, 0, ""},
-		{"EPOLLONESHOT", Const, 0, ""},
-		{"EPOLLOUT", Const, 0, ""},
-		{"EPOLLPRI", Const, 0, ""},
-		{"EPOLLRDBAND", Const, 0, ""},
-		{"EPOLLRDHUP", Const, 0, ""},
-		{"EPOLLRDNORM", Const, 0, ""},
-		{"EPOLLWRBAND", Const, 0, ""},
-		{"EPOLLWRNORM", Const, 0, ""},
-		{"EPOLL_CLOEXEC", Const, 0, ""},
-		{"EPOLL_CTL_ADD", Const, 0, ""},
-		{"EPOLL_CTL_DEL", Const, 0, ""},
-		{"EPOLL_CTL_MOD", Const, 0, ""},
-		{"EPOLL_NONBLOCK", Const, 0, ""},
-		{"EPROCLIM", Const, 0, ""},
-		{"EPROCUNAVAIL", Const, 0, ""},
-		{"EPROGMISMATCH", Const, 0, ""},
-		{"EPROGUNAVAIL", Const, 0, ""},
-		{"EPROTO", Const, 0, ""},
-		{"EPROTONOSUPPORT", Const, 0, ""},
-		{"EPROTOTYPE", Const, 0, ""},
-		{"EPWROFF", Const, 0, ""},
-		{"EQFULL", Const, 16, ""},
-		{"ERANGE", Const, 0, ""},
-		{"EREMCHG", Const, 0, ""},
-		{"EREMOTE", Const, 0, ""},
-		{"EREMOTEIO", Const, 0, ""},
-		{"ERESTART", Const, 0, ""},
-		{"ERFKILL", Const, 0, ""},
-		{"EROFS", Const, 0, ""},
-		{"ERPCMISMATCH", Const, 0, ""},
-		{"ERROR_ACCESS_DENIED", Const, 0, ""},
-		{"ERROR_ALREADY_EXISTS", Const, 0, ""},
-		{"ERROR_BROKEN_PIPE", Const, 0, ""},
-		{"ERROR_BUFFER_OVERFLOW", Const, 0, ""},
-		{"ERROR_DIR_NOT_EMPTY", Const, 8, ""},
-		{"ERROR_ENVVAR_NOT_FOUND", Const, 0, ""},
-		{"ERROR_FILE_EXISTS", Const, 0, ""},
-		{"ERROR_FILE_NOT_FOUND", Const, 0, ""},
-		{"ERROR_HANDLE_EOF", Const, 2, ""},
-		{"ERROR_INSUFFICIENT_BUFFER", Const, 0, ""},
-		{"ERROR_IO_PENDING", Const, 0, ""},
-		{"ERROR_MOD_NOT_FOUND", Const, 0, ""},
-		{"ERROR_MORE_DATA", Const, 3, ""},
-		{"ERROR_NETNAME_DELETED", Const, 3, ""},
-		{"ERROR_NOT_FOUND", Const, 1, ""},
-		{"ERROR_NO_MORE_FILES", Const, 0, ""},
-		{"ERROR_OPERATION_ABORTED", Const, 0, ""},
-		{"ERROR_PATH_NOT_FOUND", Const, 0, ""},
-		{"ERROR_PRIVILEGE_NOT_HELD", Const, 4, ""},
-		{"ERROR_PROC_NOT_FOUND", Const, 0, ""},
-		{"ESHLIBVERS", Const, 0, ""},
-		{"ESHUTDOWN", Const, 0, ""},
-		{"ESOCKTNOSUPPORT", Const, 0, ""},
-		{"ESPIPE", Const, 0, ""},
-		{"ESRCH", Const, 0, ""},
-		{"ESRMNT", Const, 0, ""},
-		{"ESTALE", Const, 0, ""},
-		{"ESTRPIPE", Const, 0, ""},
-		{"ETHERCAP_JUMBO_MTU", Const, 1, ""},
-		{"ETHERCAP_VLAN_HWTAGGING", Const, 1, ""},
-		{"ETHERCAP_VLAN_MTU", Const, 1, ""},
-		{"ETHERMIN", Const, 1, ""},
-		{"ETHERMTU", Const, 1, ""},
-		{"ETHERMTU_JUMBO", Const, 1, ""},
-		{"ETHERTYPE_8023", Const, 1, ""},
-		{"ETHERTYPE_AARP", Const, 1, ""},
-		{"ETHERTYPE_ACCTON", Const, 1, ""},
-		{"ETHERTYPE_AEONIC", Const, 1, ""},
-		{"ETHERTYPE_ALPHA", Const, 1, ""},
-		{"ETHERTYPE_AMBER", Const, 1, ""},
-		{"ETHERTYPE_AMOEBA", Const, 1, ""},
-		{"ETHERTYPE_AOE", Const, 1, ""},
-		{"ETHERTYPE_APOLLO", Const, 1, ""},
-		{"ETHERTYPE_APOLLODOMAIN", Const, 1, ""},
-		{"ETHERTYPE_APPLETALK", Const, 1, ""},
-		{"ETHERTYPE_APPLITEK", Const, 1, ""},
-		{"ETHERTYPE_ARGONAUT", Const, 1, ""},
-		{"ETHERTYPE_ARP", Const, 1, ""},
-		{"ETHERTYPE_AT", Const, 1, ""},
-		{"ETHERTYPE_ATALK", Const, 1, ""},
-		{"ETHERTYPE_ATOMIC", Const, 1, ""},
-		{"ETHERTYPE_ATT", Const, 1, ""},
-		{"ETHERTYPE_ATTSTANFORD", Const, 1, ""},
-		{"ETHERTYPE_AUTOPHON", Const, 1, ""},
-		{"ETHERTYPE_AXIS", Const, 1, ""},
-		{"ETHERTYPE_BCLOOP", Const, 1, ""},
-		{"ETHERTYPE_BOFL", Const, 1, ""},
-		{"ETHERTYPE_CABLETRON", Const, 1, ""},
-		{"ETHERTYPE_CHAOS", Const, 1, ""},
-		{"ETHERTYPE_COMDESIGN", Const, 1, ""},
-		{"ETHERTYPE_COMPUGRAPHIC", Const, 1, ""},
-		{"ETHERTYPE_COUNTERPOINT", Const, 1, ""},
-		{"ETHERTYPE_CRONUS", Const, 1, ""},
-		{"ETHERTYPE_CRONUSVLN", Const, 1, ""},
-		{"ETHERTYPE_DCA", Const, 1, ""},
-		{"ETHERTYPE_DDE", Const, 1, ""},
-		{"ETHERTYPE_DEBNI", Const, 1, ""},
-		{"ETHERTYPE_DECAM", Const, 1, ""},
-		{"ETHERTYPE_DECCUST", Const, 1, ""},
-		{"ETHERTYPE_DECDIAG", Const, 1, ""},
-		{"ETHERTYPE_DECDNS", Const, 1, ""},
-		{"ETHERTYPE_DECDTS", Const, 1, ""},
-		{"ETHERTYPE_DECEXPER", Const, 1, ""},
-		{"ETHERTYPE_DECLAST", Const, 1, ""},
-		{"ETHERTYPE_DECLTM", Const, 1, ""},
-		{"ETHERTYPE_DECMUMPS", Const, 1, ""},
-		{"ETHERTYPE_DECNETBIOS", Const, 1, ""},
-		{"ETHERTYPE_DELTACON", Const, 1, ""},
-		{"ETHERTYPE_DIDDLE", Const, 1, ""},
-		{"ETHERTYPE_DLOG1", Const, 1, ""},
-		{"ETHERTYPE_DLOG2", Const, 1, ""},
-		{"ETHERTYPE_DN", Const, 1, ""},
-		{"ETHERTYPE_DOGFIGHT", Const, 1, ""},
-		{"ETHERTYPE_DSMD", Const, 1, ""},
-		{"ETHERTYPE_ECMA", Const, 1, ""},
-		{"ETHERTYPE_ENCRYPT", Const, 1, ""},
-		{"ETHERTYPE_ES", Const, 1, ""},
-		{"ETHERTYPE_EXCELAN", Const, 1, ""},
-		{"ETHERTYPE_EXPERDATA", Const, 1, ""},
-		{"ETHERTYPE_FLIP", Const, 1, ""},
-		{"ETHERTYPE_FLOWCONTROL", Const, 1, ""},
-		{"ETHERTYPE_FRARP", Const, 1, ""},
-		{"ETHERTYPE_GENDYN", Const, 1, ""},
-		{"ETHERTYPE_HAYES", Const, 1, ""},
-		{"ETHERTYPE_HIPPI_FP", Const, 1, ""},
-		{"ETHERTYPE_HITACHI", Const, 1, ""},
-		{"ETHERTYPE_HP", Const, 1, ""},
-		{"ETHERTYPE_IEEEPUP", Const, 1, ""},
-		{"ETHERTYPE_IEEEPUPAT", Const, 1, ""},
-		{"ETHERTYPE_IMLBL", Const, 1, ""},
-		{"ETHERTYPE_IMLBLDIAG", Const, 1, ""},
-		{"ETHERTYPE_IP", Const, 1, ""},
-		{"ETHERTYPE_IPAS", Const, 1, ""},
-		{"ETHERTYPE_IPV6", Const, 1, ""},
-		{"ETHERTYPE_IPX", Const, 1, ""},
-		{"ETHERTYPE_IPXNEW", Const, 1, ""},
-		{"ETHERTYPE_KALPANA", Const, 1, ""},
-		{"ETHERTYPE_LANBRIDGE", Const, 1, ""},
-		{"ETHERTYPE_LANPROBE", Const, 1, ""},
-		{"ETHERTYPE_LAT", Const, 1, ""},
-		{"ETHERTYPE_LBACK", Const, 1, ""},
-		{"ETHERTYPE_LITTLE", Const, 1, ""},
-		{"ETHERTYPE_LLDP", Const, 1, ""},
-		{"ETHERTYPE_LOGICRAFT", Const, 1, ""},
-		{"ETHERTYPE_LOOPBACK", Const, 1, ""},
-		{"ETHERTYPE_MATRA", Const, 1, ""},
-		{"ETHERTYPE_MAX", Const, 1, ""},
-		{"ETHERTYPE_MERIT", Const, 1, ""},
-		{"ETHERTYPE_MICP", Const, 1, ""},
-		{"ETHERTYPE_MOPDL", Const, 1, ""},
-		{"ETHERTYPE_MOPRC", Const, 1, ""},
-		{"ETHERTYPE_MOTOROLA", Const, 1, ""},
-		{"ETHERTYPE_MPLS", Const, 1, ""},
-		{"ETHERTYPE_MPLS_MCAST", Const, 1, ""},
-		{"ETHERTYPE_MUMPS", Const, 1, ""},
-		{"ETHERTYPE_NBPCC", Const, 1, ""},
-		{"ETHERTYPE_NBPCLAIM", Const, 1, ""},
-		{"ETHERTYPE_NBPCLREQ", Const, 1, ""},
-		{"ETHERTYPE_NBPCLRSP", Const, 1, ""},
-		{"ETHERTYPE_NBPCREQ", Const, 1, ""},
-		{"ETHERTYPE_NBPCRSP", Const, 1, ""},
-		{"ETHERTYPE_NBPDG", Const, 1, ""},
-		{"ETHERTYPE_NBPDGB", Const, 1, ""},
-		{"ETHERTYPE_NBPDLTE", Const, 1, ""},
-		{"ETHERTYPE_NBPRAR", Const, 1, ""},
-		{"ETHERTYPE_NBPRAS", Const, 1, ""},
-		{"ETHERTYPE_NBPRST", Const, 1, ""},
-		{"ETHERTYPE_NBPSCD", Const, 1, ""},
-		{"ETHERTYPE_NBPVCD", Const, 1, ""},
-		{"ETHERTYPE_NBS", Const, 1, ""},
-		{"ETHERTYPE_NCD", Const, 1, ""},
-		{"ETHERTYPE_NESTAR", Const, 1, ""},
-		{"ETHERTYPE_NETBEUI", Const, 1, ""},
-		{"ETHERTYPE_NOVELL", Const, 1, ""},
-		{"ETHERTYPE_NS", Const, 1, ""},
-		{"ETHERTYPE_NSAT", Const, 1, ""},
-		{"ETHERTYPE_NSCOMPAT", Const, 1, ""},
-		{"ETHERTYPE_NTRAILER", Const, 1, ""},
-		{"ETHERTYPE_OS9", Const, 1, ""},
-		{"ETHERTYPE_OS9NET", Const, 1, ""},
-		{"ETHERTYPE_PACER", Const, 1, ""},
-		{"ETHERTYPE_PAE", Const, 1, ""},
-		{"ETHERTYPE_PCS", Const, 1, ""},
-		{"ETHERTYPE_PLANNING", Const, 1, ""},
-		{"ETHERTYPE_PPP", Const, 1, ""},
-		{"ETHERTYPE_PPPOE", Const, 1, ""},
-		{"ETHERTYPE_PPPOEDISC", Const, 1, ""},
-		{"ETHERTYPE_PRIMENTS", Const, 1, ""},
-		{"ETHERTYPE_PUP", Const, 1, ""},
-		{"ETHERTYPE_PUPAT", Const, 1, ""},
-		{"ETHERTYPE_QINQ", Const, 1, ""},
-		{"ETHERTYPE_RACAL", Const, 1, ""},
-		{"ETHERTYPE_RATIONAL", Const, 1, ""},
-		{"ETHERTYPE_RAWFR", Const, 1, ""},
-		{"ETHERTYPE_RCL", Const, 1, ""},
-		{"ETHERTYPE_RDP", Const, 1, ""},
-		{"ETHERTYPE_RETIX", Const, 1, ""},
-		{"ETHERTYPE_REVARP", Const, 1, ""},
-		{"ETHERTYPE_SCA", Const, 1, ""},
-		{"ETHERTYPE_SECTRA", Const, 1, ""},
-		{"ETHERTYPE_SECUREDATA", Const, 1, ""},
-		{"ETHERTYPE_SGITW", Const, 1, ""},
-		{"ETHERTYPE_SG_BOUNCE", Const, 1, ""},
-		{"ETHERTYPE_SG_DIAG", Const, 1, ""},
-		{"ETHERTYPE_SG_NETGAMES", Const, 1, ""},
-		{"ETHERTYPE_SG_RESV", Const, 1, ""},
-		{"ETHERTYPE_SIMNET", Const, 1, ""},
-		{"ETHERTYPE_SLOW", Const, 1, ""},
-		{"ETHERTYPE_SLOWPROTOCOLS", Const, 1, ""},
-		{"ETHERTYPE_SNA", Const, 1, ""},
-		{"ETHERTYPE_SNMP", Const, 1, ""},
-		{"ETHERTYPE_SONIX", Const, 1, ""},
-		{"ETHERTYPE_SPIDER", Const, 1, ""},
-		{"ETHERTYPE_SPRITE", Const, 1, ""},
-		{"ETHERTYPE_STP", Const, 1, ""},
-		{"ETHERTYPE_TALARIS", Const, 1, ""},
-		{"ETHERTYPE_TALARISMC", Const, 1, ""},
-		{"ETHERTYPE_TCPCOMP", Const, 1, ""},
-		{"ETHERTYPE_TCPSM", Const, 1, ""},
-		{"ETHERTYPE_TEC", Const, 1, ""},
-		{"ETHERTYPE_TIGAN", Const, 1, ""},
-		{"ETHERTYPE_TRAIL", Const, 1, ""},
-		{"ETHERTYPE_TRANSETHER", Const, 1, ""},
-		{"ETHERTYPE_TYMSHARE", Const, 1, ""},
-		{"ETHERTYPE_UBBST", Const, 1, ""},
-		{"ETHERTYPE_UBDEBUG", Const, 1, ""},
-		{"ETHERTYPE_UBDIAGLOOP", Const, 1, ""},
-		{"ETHERTYPE_UBDL", Const, 1, ""},
-		{"ETHERTYPE_UBNIU", Const, 1, ""},
-		{"ETHERTYPE_UBNMC", Const, 1, ""},
-		{"ETHERTYPE_VALID", Const, 1, ""},
-		{"ETHERTYPE_VARIAN", Const, 1, ""},
-		{"ETHERTYPE_VAXELN", Const, 1, ""},
-		{"ETHERTYPE_VEECO", Const, 1, ""},
-		{"ETHERTYPE_VEXP", Const, 1, ""},
-		{"ETHERTYPE_VGLAB", Const, 1, ""},
-		{"ETHERTYPE_VINES", Const, 1, ""},
-		{"ETHERTYPE_VINESECHO", Const, 1, ""},
-		{"ETHERTYPE_VINESLOOP", Const, 1, ""},
-		{"ETHERTYPE_VITAL", Const, 1, ""},
-		{"ETHERTYPE_VLAN", Const, 1, ""},
-		{"ETHERTYPE_VLTLMAN", Const, 1, ""},
-		{"ETHERTYPE_VPROD", Const, 1, ""},
-		{"ETHERTYPE_VURESERVED", Const, 1, ""},
-		{"ETHERTYPE_WATERLOO", Const, 1, ""},
-		{"ETHERTYPE_WELLFLEET", Const, 1, ""},
-		{"ETHERTYPE_X25", Const, 1, ""},
-		{"ETHERTYPE_X75", Const, 1, ""},
-		{"ETHERTYPE_XNSSM", Const, 1, ""},
-		{"ETHERTYPE_XTP", Const, 1, ""},
-		{"ETHER_ADDR_LEN", Const, 1, ""},
-		{"ETHER_ALIGN", Const, 1, ""},
-		{"ETHER_CRC_LEN", Const, 1, ""},
-		{"ETHER_CRC_POLY_BE", Const, 1, ""},
-		{"ETHER_CRC_POLY_LE", Const, 1, ""},
-		{"ETHER_HDR_LEN", Const, 1, ""},
-		{"ETHER_MAX_DIX_LEN", Const, 1, ""},
-		{"ETHER_MAX_LEN", Const, 1, ""},
-		{"ETHER_MAX_LEN_JUMBO", Const, 1, ""},
-		{"ETHER_MIN_LEN", Const, 1, ""},
-		{"ETHER_PPPOE_ENCAP_LEN", Const, 1, ""},
-		{"ETHER_TYPE_LEN", Const, 1, ""},
-		{"ETHER_VLAN_ENCAP_LEN", Const, 1, ""},
-		{"ETH_P_1588", Const, 0, ""},
-		{"ETH_P_8021Q", Const, 0, ""},
-		{"ETH_P_802_2", Const, 0, ""},
-		{"ETH_P_802_3", Const, 0, ""},
-		{"ETH_P_AARP", Const, 0, ""},
-		{"ETH_P_ALL", Const, 0, ""},
-		{"ETH_P_AOE", Const, 0, ""},
-		{"ETH_P_ARCNET", Const, 0, ""},
-		{"ETH_P_ARP", Const, 0, ""},
-		{"ETH_P_ATALK", Const, 0, ""},
-		{"ETH_P_ATMFATE", Const, 0, ""},
-		{"ETH_P_ATMMPOA", Const, 0, ""},
-		{"ETH_P_AX25", Const, 0, ""},
-		{"ETH_P_BPQ", Const, 0, ""},
-		{"ETH_P_CAIF", Const, 0, ""},
-		{"ETH_P_CAN", Const, 0, ""},
-		{"ETH_P_CONTROL", Const, 0, ""},
-		{"ETH_P_CUST", Const, 0, ""},
-		{"ETH_P_DDCMP", Const, 0, ""},
-		{"ETH_P_DEC", Const, 0, ""},
-		{"ETH_P_DIAG", Const, 0, ""},
-		{"ETH_P_DNA_DL", Const, 0, ""},
-		{"ETH_P_DNA_RC", Const, 0, ""},
-		{"ETH_P_DNA_RT", Const, 0, ""},
-		{"ETH_P_DSA", Const, 0, ""},
-		{"ETH_P_ECONET", Const, 0, ""},
-		{"ETH_P_EDSA", Const, 0, ""},
-		{"ETH_P_FCOE", Const, 0, ""},
-		{"ETH_P_FIP", Const, 0, ""},
-		{"ETH_P_HDLC", Const, 0, ""},
-		{"ETH_P_IEEE802154", Const, 0, ""},
-		{"ETH_P_IEEEPUP", Const, 0, ""},
-		{"ETH_P_IEEEPUPAT", Const, 0, ""},
-		{"ETH_P_IP", Const, 0, ""},
-		{"ETH_P_IPV6", Const, 0, ""},
-		{"ETH_P_IPX", Const, 0, ""},
-		{"ETH_P_IRDA", Const, 0, ""},
-		{"ETH_P_LAT", Const, 0, ""},
-		{"ETH_P_LINK_CTL", Const, 0, ""},
-		{"ETH_P_LOCALTALK", Const, 0, ""},
-		{"ETH_P_LOOP", Const, 0, ""},
-		{"ETH_P_MOBITEX", Const, 0, ""},
-		{"ETH_P_MPLS_MC", Const, 0, ""},
-		{"ETH_P_MPLS_UC", Const, 0, ""},
-		{"ETH_P_PAE", Const, 0, ""},
-		{"ETH_P_PAUSE", Const, 0, ""},
-		{"ETH_P_PHONET", Const, 0, ""},
-		{"ETH_P_PPPTALK", Const, 0, ""},
-		{"ETH_P_PPP_DISC", Const, 0, ""},
-		{"ETH_P_PPP_MP", Const, 0, ""},
-		{"ETH_P_PPP_SES", Const, 0, ""},
-		{"ETH_P_PUP", Const, 0, ""},
-		{"ETH_P_PUPAT", Const, 0, ""},
-		{"ETH_P_RARP", Const, 0, ""},
-		{"ETH_P_SCA", Const, 0, ""},
-		{"ETH_P_SLOW", Const, 0, ""},
-		{"ETH_P_SNAP", Const, 0, ""},
-		{"ETH_P_TEB", Const, 0, ""},
-		{"ETH_P_TIPC", Const, 0, ""},
-		{"ETH_P_TRAILER", Const, 0, ""},
-		{"ETH_P_TR_802_2", Const, 0, ""},
-		{"ETH_P_WAN_PPP", Const, 0, ""},
-		{"ETH_P_WCCP", Const, 0, ""},
-		{"ETH_P_X25", Const, 0, ""},
-		{"ETIME", Const, 0, ""},
-		{"ETIMEDOUT", Const, 0, ""},
-		{"ETOOMANYREFS", Const, 0, ""},
-		{"ETXTBSY", Const, 0, ""},
-		{"EUCLEAN", Const, 0, ""},
-		{"EUNATCH", Const, 0, ""},
-		{"EUSERS", Const, 0, ""},
-		{"EVFILT_AIO", Const, 0, ""},
-		{"EVFILT_FS", Const, 0, ""},
-		{"EVFILT_LIO", Const, 0, ""},
-		{"EVFILT_MACHPORT", Const, 0, ""},
-		{"EVFILT_PROC", Const, 0, ""},
-		{"EVFILT_READ", Const, 0, ""},
-		{"EVFILT_SIGNAL", Const, 0, ""},
-		{"EVFILT_SYSCOUNT", Const, 0, ""},
-		{"EVFILT_THREADMARKER", Const, 0, ""},
-		{"EVFILT_TIMER", Const, 0, ""},
-		{"EVFILT_USER", Const, 0, ""},
-		{"EVFILT_VM", Const, 0, ""},
-		{"EVFILT_VNODE", Const, 0, ""},
-		{"EVFILT_WRITE", Const, 0, ""},
-		{"EV_ADD", Const, 0, ""},
-		{"EV_CLEAR", Const, 0, ""},
-		{"EV_DELETE", Const, 0, ""},
-		{"EV_DISABLE", Const, 0, ""},
-		{"EV_DISPATCH", Const, 0, ""},
-		{"EV_DROP", Const, 3, ""},
-		{"EV_ENABLE", Const, 0, ""},
-		{"EV_EOF", Const, 0, ""},
-		{"EV_ERROR", Const, 0, ""},
-		{"EV_FLAG0", Const, 0, ""},
-		{"EV_FLAG1", Const, 0, ""},
-		{"EV_ONESHOT", Const, 0, ""},
-		{"EV_OOBAND", Const, 0, ""},
-		{"EV_POLL", Const, 0, ""},
-		{"EV_RECEIPT", Const, 0, ""},
-		{"EV_SYSFLAGS", Const, 0, ""},
-		{"EWINDOWS", Const, 0, ""},
-		{"EWOULDBLOCK", Const, 0, ""},
-		{"EXDEV", Const, 0, ""},
-		{"EXFULL", Const, 0, ""},
-		{"EXTA", Const, 0, ""},
-		{"EXTB", Const, 0, ""},
-		{"EXTPROC", Const, 0, ""},
-		{"Environ", Func, 0, "func() []string"},
-		{"EpollCreate", Func, 0, "func(size int) (fd int, err error)"},
-		{"EpollCreate1", Func, 0, "func(flag int) (fd int, err error)"},
-		{"EpollCtl", Func, 0, "func(epfd int, op int, fd int, event *EpollEvent) (err error)"},
-		{"EpollEvent", Type, 0, ""},
-		{"EpollEvent.Events", Field, 0, ""},
-		{"EpollEvent.Fd", Field, 0, ""},
-		{"EpollEvent.Pad", Field, 0, ""},
-		{"EpollEvent.PadFd", Field, 0, ""},
-		{"EpollWait", Func, 0, "func(epfd int, events []EpollEvent, msec int) (n int, err error)"},
-		{"Errno", Type, 0, ""},
-		{"EscapeArg", Func, 0, ""},
-		{"Exchangedata", Func, 0, ""},
-		{"Exec", Func, 0, "func(argv0 string, argv []string, envv []string) (err error)"},
-		{"Exit", Func, 0, "func(code int)"},
-		{"ExitProcess", Func, 0, ""},
-		{"FD_CLOEXEC", Const, 0, ""},
-		{"FD_SETSIZE", Const, 0, ""},
-		{"FILE_ACTION_ADDED", Const, 0, ""},
-		{"FILE_ACTION_MODIFIED", Const, 0, ""},
-		{"FILE_ACTION_REMOVED", Const, 0, ""},
-		{"FILE_ACTION_RENAMED_NEW_NAME", Const, 0, ""},
-		{"FILE_ACTION_RENAMED_OLD_NAME", Const, 0, ""},
-		{"FILE_APPEND_DATA", Const, 0, ""},
-		{"FILE_ATTRIBUTE_ARCHIVE", Const, 0, ""},
-		{"FILE_ATTRIBUTE_DIRECTORY", Const, 0, ""},
-		{"FILE_ATTRIBUTE_HIDDEN", Const, 0, ""},
-		{"FILE_ATTRIBUTE_NORMAL", Const, 0, ""},
-		{"FILE_ATTRIBUTE_READONLY", Const, 0, ""},
-		{"FILE_ATTRIBUTE_REPARSE_POINT", Const, 4, ""},
-		{"FILE_ATTRIBUTE_SYSTEM", Const, 0, ""},
-		{"FILE_BEGIN", Const, 0, ""},
-		{"FILE_CURRENT", Const, 0, ""},
-		{"FILE_END", Const, 0, ""},
-		{"FILE_FLAG_BACKUP_SEMANTICS", Const, 0, ""},
-		{"FILE_FLAG_OPEN_REPARSE_POINT", Const, 4, ""},
-		{"FILE_FLAG_OVERLAPPED", Const, 0, ""},
-		{"FILE_LIST_DIRECTORY", Const, 0, ""},
-		{"FILE_MAP_COPY", Const, 0, ""},
-		{"FILE_MAP_EXECUTE", Const, 0, ""},
-		{"FILE_MAP_READ", Const, 0, ""},
-		{"FILE_MAP_WRITE", Const, 0, ""},
-		{"FILE_NOTIFY_CHANGE_ATTRIBUTES", Const, 0, ""},
-		{"FILE_NOTIFY_CHANGE_CREATION", Const, 0, ""},
-		{"FILE_NOTIFY_CHANGE_DIR_NAME", Const, 0, ""},
-		{"FILE_NOTIFY_CHANGE_FILE_NAME", Const, 0, ""},
-		{"FILE_NOTIFY_CHANGE_LAST_ACCESS", Const, 0, ""},
-		{"FILE_NOTIFY_CHANGE_LAST_WRITE", Const, 0, ""},
-		{"FILE_NOTIFY_CHANGE_SIZE", Const, 0, ""},
-		{"FILE_SHARE_DELETE", Const, 0, ""},
-		{"FILE_SHARE_READ", Const, 0, ""},
-		{"FILE_SHARE_WRITE", Const, 0, ""},
-		{"FILE_SKIP_COMPLETION_PORT_ON_SUCCESS", Const, 2, ""},
-		{"FILE_SKIP_SET_EVENT_ON_HANDLE", Const, 2, ""},
-		{"FILE_TYPE_CHAR", Const, 0, ""},
-		{"FILE_TYPE_DISK", Const, 0, ""},
-		{"FILE_TYPE_PIPE", Const, 0, ""},
-		{"FILE_TYPE_REMOTE", Const, 0, ""},
-		{"FILE_TYPE_UNKNOWN", Const, 0, ""},
-		{"FILE_WRITE_ATTRIBUTES", Const, 0, ""},
-		{"FLUSHO", Const, 0, ""},
-		{"FORMAT_MESSAGE_ALLOCATE_BUFFER", Const, 0, ""},
-		{"FORMAT_MESSAGE_ARGUMENT_ARRAY", Const, 0, ""},
-		{"FORMAT_MESSAGE_FROM_HMODULE", Const, 0, ""},
-		{"FORMAT_MESSAGE_FROM_STRING", Const, 0, ""},
-		{"FORMAT_MESSAGE_FROM_SYSTEM", Const, 0, ""},
-		{"FORMAT_MESSAGE_IGNORE_INSERTS", Const, 0, ""},
-		{"FORMAT_MESSAGE_MAX_WIDTH_MASK", Const, 0, ""},
-		{"FSCTL_GET_REPARSE_POINT", Const, 4, ""},
-		{"F_ADDFILESIGS", Const, 0, ""},
-		{"F_ADDSIGS", Const, 0, ""},
-		{"F_ALLOCATEALL", Const, 0, ""},
-		{"F_ALLOCATECONTIG", Const, 0, ""},
-		{"F_CANCEL", Const, 0, ""},
-		{"F_CHKCLEAN", Const, 0, ""},
-		{"F_CLOSEM", Const, 1, ""},
-		{"F_DUP2FD", Const, 0, ""},
-		{"F_DUP2FD_CLOEXEC", Const, 1, ""},
-		{"F_DUPFD", Const, 0, ""},
-		{"F_DUPFD_CLOEXEC", Const, 0, ""},
-		{"F_EXLCK", Const, 0, ""},
-		{"F_FINDSIGS", Const, 16, ""},
-		{"F_FLUSH_DATA", Const, 0, ""},
-		{"F_FREEZE_FS", Const, 0, ""},
-		{"F_FSCTL", Const, 1, ""},
-		{"F_FSDIRMASK", Const, 1, ""},
-		{"F_FSIN", Const, 1, ""},
-		{"F_FSINOUT", Const, 1, ""},
-		{"F_FSOUT", Const, 1, ""},
-		{"F_FSPRIV", Const, 1, ""},
-		{"F_FSVOID", Const, 1, ""},
-		{"F_FULLFSYNC", Const, 0, ""},
-		{"F_GETCODEDIR", Const, 16, ""},
-		{"F_GETFD", Const, 0, ""},
-		{"F_GETFL", Const, 0, ""},
-		{"F_GETLEASE", Const, 0, ""},
-		{"F_GETLK", Const, 0, ""},
-		{"F_GETLK64", Const, 0, ""},
-		{"F_GETLKPID", Const, 0, ""},
-		{"F_GETNOSIGPIPE", Const, 0, ""},
-		{"F_GETOWN", Const, 0, ""},
-		{"F_GETOWN_EX", Const, 0, ""},
-		{"F_GETPATH", Const, 0, ""},
-		{"F_GETPATH_MTMINFO", Const, 0, ""},
-		{"F_GETPIPE_SZ", Const, 0, ""},
-		{"F_GETPROTECTIONCLASS", Const, 0, ""},
-		{"F_GETPROTECTIONLEVEL", Const, 16, ""},
-		{"F_GETSIG", Const, 0, ""},
-		{"F_GLOBAL_NOCACHE", Const, 0, ""},
-		{"F_LOCK", Const, 0, ""},
-		{"F_LOG2PHYS", Const, 0, ""},
-		{"F_LOG2PHYS_EXT", Const, 0, ""},
-		{"F_MARKDEPENDENCY", Const, 0, ""},
-		{"F_MAXFD", Const, 1, ""},
-		{"F_NOCACHE", Const, 0, ""},
-		{"F_NODIRECT", Const, 0, ""},
-		{"F_NOTIFY", Const, 0, ""},
-		{"F_OGETLK", Const, 0, ""},
-		{"F_OK", Const, 0, ""},
-		{"F_OSETLK", Const, 0, ""},
-		{"F_OSETLKW", Const, 0, ""},
-		{"F_PARAM_MASK", Const, 1, ""},
-		{"F_PARAM_MAX", Const, 1, ""},
-		{"F_PATHPKG_CHECK", Const, 0, ""},
-		{"F_PEOFPOSMODE", Const, 0, ""},
-		{"F_PREALLOCATE", Const, 0, ""},
-		{"F_RDADVISE", Const, 0, ""},
-		{"F_RDAHEAD", Const, 0, ""},
-		{"F_RDLCK", Const, 0, ""},
-		{"F_READAHEAD", Const, 0, ""},
-		{"F_READBOOTSTRAP", Const, 0, ""},
-		{"F_SETBACKINGSTORE", Const, 0, ""},
-		{"F_SETFD", Const, 0, ""},
-		{"F_SETFL", Const, 0, ""},
-		{"F_SETLEASE", Const, 0, ""},
-		{"F_SETLK", Const, 0, ""},
-		{"F_SETLK64", Const, 0, ""},
-		{"F_SETLKW", Const, 0, ""},
-		{"F_SETLKW64", Const, 0, ""},
-		{"F_SETLKWTIMEOUT", Const, 16, ""},
-		{"F_SETLK_REMOTE", Const, 0, ""},
-		{"F_SETNOSIGPIPE", Const, 0, ""},
-		{"F_SETOWN", Const, 0, ""},
-		{"F_SETOWN_EX", Const, 0, ""},
-		{"F_SETPIPE_SZ", Const, 0, ""},
-		{"F_SETPROTECTIONCLASS", Const, 0, ""},
-		{"F_SETSIG", Const, 0, ""},
-		{"F_SETSIZE", Const, 0, ""},
-		{"F_SHLCK", Const, 0, ""},
-		{"F_SINGLE_WRITER", Const, 16, ""},
-		{"F_TEST", Const, 0, ""},
-		{"F_THAW_FS", Const, 0, ""},
-		{"F_TLOCK", Const, 0, ""},
-		{"F_TRANSCODEKEY", Const, 16, ""},
-		{"F_ULOCK", Const, 0, ""},
-		{"F_UNLCK", Const, 0, ""},
-		{"F_UNLCKSYS", Const, 0, ""},
-		{"F_VOLPOSMODE", Const, 0, ""},
-		{"F_WRITEBOOTSTRAP", Const, 0, ""},
-		{"F_WRLCK", Const, 0, ""},
-		{"Faccessat", Func, 0, "func(dirfd int, path string, mode uint32, flags int) (err error)"},
-		{"Fallocate", Func, 0, "func(fd int, mode uint32, off int64, len int64) (err error)"},
-		{"Fbootstraptransfer_t", Type, 0, ""},
-		{"Fbootstraptransfer_t.Buffer", Field, 0, ""},
-		{"Fbootstraptransfer_t.Length", Field, 0, ""},
-		{"Fbootstraptransfer_t.Offset", Field, 0, ""},
-		{"Fchdir", Func, 0, "func(fd int) (err error)"},
-		{"Fchflags", Func, 0, ""},
-		{"Fchmod", Func, 0, "func(fd int, mode uint32) (err error)"},
-		{"Fchmodat", Func, 0, "func(dirfd int, path string, mode uint32, flags int) error"},
-		{"Fchown", Func, 0, "func(fd int, uid int, gid int) (err error)"},
-		{"Fchownat", Func, 0, "func(dirfd int, path string, uid int, gid int, flags int) (err error)"},
-		{"FcntlFlock", Func, 3, "func(fd uintptr, cmd int, lk *Flock_t) error"},
-		{"FdSet", Type, 0, ""},
-		{"FdSet.Bits", Field, 0, ""},
-		{"FdSet.X__fds_bits", Field, 0, ""},
-		{"Fdatasync", Func, 0, "func(fd int) (err error)"},
-		{"FileNotifyInformation", Type, 0, ""},
-		{"FileNotifyInformation.Action", Field, 0, ""},
-		{"FileNotifyInformation.FileName", Field, 0, ""},
-		{"FileNotifyInformation.FileNameLength", Field, 0, ""},
-		{"FileNotifyInformation.NextEntryOffset", Field, 0, ""},
-		{"Filetime", Type, 0, ""},
-		{"Filetime.HighDateTime", Field, 0, ""},
-		{"Filetime.LowDateTime", Field, 0, ""},
-		{"FindClose", Func, 0, ""},
-		{"FindFirstFile", Func, 0, ""},
-		{"FindNextFile", Func, 0, ""},
-		{"Flock", Func, 0, "func(fd int, how int) (err error)"},
-		{"Flock_t", Type, 0, ""},
-		{"Flock_t.Len", Field, 0, ""},
-		{"Flock_t.Pad_cgo_0", Field, 0, ""},
-		{"Flock_t.Pad_cgo_1", Field, 3, ""},
-		{"Flock_t.Pid", Field, 0, ""},
-		{"Flock_t.Start", Field, 0, ""},
-		{"Flock_t.Sysid", Field, 0, ""},
-		{"Flock_t.Type", Field, 0, ""},
-		{"Flock_t.Whence", Field, 0, ""},
-		{"FlushBpf", Func, 0, ""},
-		{"FlushFileBuffers", Func, 0, ""},
-		{"FlushViewOfFile", Func, 0, ""},
-		{"ForkExec", Func, 0, "func(argv0 string, argv []string, attr *ProcAttr) (pid int, err error)"},
-		{"ForkLock", Var, 0, ""},
-		{"FormatMessage", Func, 0, ""},
-		{"Fpathconf", Func, 0, ""},
-		{"FreeAddrInfoW", Func, 1, ""},
-		{"FreeEnvironmentStrings", Func, 0, ""},
-		{"FreeLibrary", Func, 0, ""},
-		{"Fsid", Type, 0, ""},
-		{"Fsid.Val", Field, 0, ""},
-		{"Fsid.X__fsid_val", Field, 2, ""},
-		{"Fsid.X__val", Field, 0, ""},
-		{"Fstat", Func, 0, "func(fd int, stat *Stat_t) (err error)"},
-		{"Fstatat", Func, 12, ""},
-		{"Fstatfs", Func, 0, "func(fd int, buf *Statfs_t) (err error)"},
-		{"Fstore_t", Type, 0, ""},
-		{"Fstore_t.Bytesalloc", Field, 0, ""},
-		{"Fstore_t.Flags", Field, 0, ""},
-		{"Fstore_t.Length", Field, 0, ""},
-		{"Fstore_t.Offset", Field, 0, ""},
-		{"Fstore_t.Posmode", Field, 0, ""},
-		{"Fsync", Func, 0, "func(fd int) (err error)"},
-		{"Ftruncate", Func, 0, "func(fd int, length int64) (err error)"},
-		{"FullPath", Func, 4, ""},
-		{"Futimes", Func, 0, "func(fd int, tv []Timeval) (err error)"},
-		{"Futimesat", Func, 0, "func(dirfd int, path string, tv []Timeval) (err error)"},
-		{"GENERIC_ALL", Const, 0, ""},
-		{"GENERIC_EXECUTE", Const, 0, ""},
-		{"GENERIC_READ", Const, 0, ""},
-		{"GENERIC_WRITE", Const, 0, ""},
-		{"GUID", Type, 1, ""},
-		{"GUID.Data1", Field, 1, ""},
-		{"GUID.Data2", Field, 1, ""},
-		{"GUID.Data3", Field, 1, ""},
-		{"GUID.Data4", Field, 1, ""},
-		{"GetAcceptExSockaddrs", Func, 0, ""},
-		{"GetAdaptersInfo", Func, 0, ""},
-		{"GetAddrInfoW", Func, 1, ""},
-		{"GetCommandLine", Func, 0, ""},
-		{"GetComputerName", Func, 0, ""},
-		{"GetConsoleMode", Func, 1, ""},
-		{"GetCurrentDirectory", Func, 0, ""},
-		{"GetCurrentProcess", Func, 0, ""},
-		{"GetEnvironmentStrings", Func, 0, ""},
-		{"GetEnvironmentVariable", Func, 0, ""},
-		{"GetExitCodeProcess", Func, 0, ""},
-		{"GetFileAttributes", Func, 0, ""},
-		{"GetFileAttributesEx", Func, 0, ""},
-		{"GetFileExInfoStandard", Const, 0, ""},
-		{"GetFileExMaxInfoLevel", Const, 0, ""},
-		{"GetFileInformationByHandle", Func, 0, ""},
-		{"GetFileType", Func, 0, ""},
-		{"GetFullPathName", Func, 0, ""},
-		{"GetHostByName", Func, 0, ""},
-		{"GetIfEntry", Func, 0, ""},
-		{"GetLastError", Func, 0, ""},
-		{"GetLengthSid", Func, 0, ""},
-		{"GetLongPathName", Func, 0, ""},
-		{"GetProcAddress", Func, 0, ""},
-		{"GetProcessTimes", Func, 0, ""},
-		{"GetProtoByName", Func, 0, ""},
-		{"GetQueuedCompletionStatus", Func, 0, ""},
-		{"GetServByName", Func, 0, ""},
-		{"GetShortPathName", Func, 0, ""},
-		{"GetStartupInfo", Func, 0, ""},
-		{"GetStdHandle", Func, 0, ""},
-		{"GetSystemTimeAsFileTime", Func, 0, ""},
-		{"GetTempPath", Func, 0, ""},
-		{"GetTimeZoneInformation", Func, 0, ""},
-		{"GetTokenInformation", Func, 0, ""},
-		{"GetUserNameEx", Func, 0, ""},
-		{"GetUserProfileDirectory", Func, 0, ""},
-		{"GetVersion", Func, 0, ""},
-		{"Getcwd", Func, 0, "func(buf []byte) (n int, err error)"},
-		{"Getdents", Func, 0, "func(fd int, buf []byte) (n int, err error)"},
-		{"Getdirentries", Func, 0, ""},
-		{"Getdtablesize", Func, 0, ""},
-		{"Getegid", Func, 0, "func() (egid int)"},
-		{"Getenv", Func, 0, "func(key string) (value string, found bool)"},
-		{"Geteuid", Func, 0, "func() (euid int)"},
-		{"Getfsstat", Func, 0, ""},
-		{"Getgid", Func, 0, "func() (gid int)"},
-		{"Getgroups", Func, 0, "func() (gids []int, err error)"},
-		{"Getpagesize", Func, 0, "func() int"},
-		{"Getpeername", Func, 0, "func(fd int) (sa Sockaddr, err error)"},
-		{"Getpgid", Func, 0, "func(pid int) (pgid int, err error)"},
-		{"Getpgrp", Func, 0, "func() (pid int)"},
-		{"Getpid", Func, 0, "func() (pid int)"},
-		{"Getppid", Func, 0, "func() (ppid int)"},
-		{"Getpriority", Func, 0, "func(which int, who int) (prio int, err error)"},
-		{"Getrlimit", Func, 0, "func(resource int, rlim *Rlimit) (err error)"},
-		{"Getrusage", Func, 0, "func(who int, rusage *Rusage) (err error)"},
-		{"Getsid", Func, 0, ""},
-		{"Getsockname", Func, 0, "func(fd int) (sa Sockaddr, err error)"},
-		{"Getsockopt", Func, 1, ""},
-		{"GetsockoptByte", Func, 0, ""},
-		{"GetsockoptICMPv6Filter", Func, 2, "func(fd int, level int, opt int) (*ICMPv6Filter, error)"},
-		{"GetsockoptIPMreq", Func, 0, "func(fd int, level int, opt int) (*IPMreq, error)"},
-		{"GetsockoptIPMreqn", Func, 0, "func(fd int, level int, opt int) (*IPMreqn, error)"},
-		{"GetsockoptIPv6MTUInfo", Func, 2, "func(fd int, level int, opt int) (*IPv6MTUInfo, error)"},
-		{"GetsockoptIPv6Mreq", Func, 0, "func(fd int, level int, opt int) (*IPv6Mreq, error)"},
-		{"GetsockoptInet4Addr", Func, 0, "func(fd int, level int, opt int) (value [4]byte, err error)"},
-		{"GetsockoptInt", Func, 0, "func(fd int, level int, opt int) (value int, err error)"},
-		{"GetsockoptUcred", Func, 1, "func(fd int, level int, opt int) (*Ucred, error)"},
-		{"Gettid", Func, 0, "func() (tid int)"},
-		{"Gettimeofday", Func, 0, "func(tv *Timeval) (err error)"},
-		{"Getuid", Func, 0, "func() (uid int)"},
-		{"Getwd", Func, 0, "func() (wd string, err error)"},
-		{"Getxattr", Func, 1, "func(path string, attr string, dest []byte) (sz int, err error)"},
-		{"HANDLE_FLAG_INHERIT", Const, 0, ""},
-		{"HKEY_CLASSES_ROOT", Const, 0, ""},
-		{"HKEY_CURRENT_CONFIG", Const, 0, ""},
-		{"HKEY_CURRENT_USER", Const, 0, ""},
-		{"HKEY_DYN_DATA", Const, 0, ""},
-		{"HKEY_LOCAL_MACHINE", Const, 0, ""},
-		{"HKEY_PERFORMANCE_DATA", Const, 0, ""},
-		{"HKEY_USERS", Const, 0, ""},
-		{"HUPCL", Const, 0, ""},
-		{"Handle", Type, 0, ""},
-		{"Hostent", Type, 0, ""},
-		{"Hostent.AddrList", Field, 0, ""},
-		{"Hostent.AddrType", Field, 0, ""},
-		{"Hostent.Aliases", Field, 0, ""},
-		{"Hostent.Length", Field, 0, ""},
-		{"Hostent.Name", Field, 0, ""},
-		{"ICANON", Const, 0, ""},
-		{"ICMP6_FILTER", Const, 2, ""},
-		{"ICMPV6_FILTER", Const, 2, ""},
-		{"ICMPv6Filter", Type, 2, ""},
-		{"ICMPv6Filter.Data", Field, 2, ""},
-		{"ICMPv6Filter.Filt", Field, 2, ""},
-		{"ICRNL", Const, 0, ""},
-		{"IEXTEN", Const, 0, ""},
-		{"IFAN_ARRIVAL", Const, 1, ""},
-		{"IFAN_DEPARTURE", Const, 1, ""},
-		{"IFA_ADDRESS", Const, 0, ""},
-		{"IFA_ANYCAST", Const, 0, ""},
-		{"IFA_BROADCAST", Const, 0, ""},
-		{"IFA_CACHEINFO", Const, 0, ""},
-		{"IFA_F_DADFAILED", Const, 0, ""},
-		{"IFA_F_DEPRECATED", Const, 0, ""},
-		{"IFA_F_HOMEADDRESS", Const, 0, ""},
-		{"IFA_F_NODAD", Const, 0, ""},
-		{"IFA_F_OPTIMISTIC", Const, 0, ""},
-		{"IFA_F_PERMANENT", Const, 0, ""},
-		{"IFA_F_SECONDARY", Const, 0, ""},
-		{"IFA_F_TEMPORARY", Const, 0, ""},
-		{"IFA_F_TENTATIVE", Const, 0, ""},
-		{"IFA_LABEL", Const, 0, ""},
-		{"IFA_LOCAL", Const, 0, ""},
-		{"IFA_MAX", Const, 0, ""},
-		{"IFA_MULTICAST", Const, 0, ""},
-		{"IFA_ROUTE", Const, 1, ""},
-		{"IFA_UNSPEC", Const, 0, ""},
-		{"IFF_ALLMULTI", Const, 0, ""},
-		{"IFF_ALTPHYS", Const, 0, ""},
-		{"IFF_AUTOMEDIA", Const, 0, ""},
-		{"IFF_BROADCAST", Const, 0, ""},
-		{"IFF_CANTCHANGE", Const, 0, ""},
-		{"IFF_CANTCONFIG", Const, 1, ""},
-		{"IFF_DEBUG", Const, 0, ""},
-		{"IFF_DRV_OACTIVE", Const, 0, ""},
-		{"IFF_DRV_RUNNING", Const, 0, ""},
-		{"IFF_DYING", Const, 0, ""},
-		{"IFF_DYNAMIC", Const, 0, ""},
-		{"IFF_LINK0", Const, 0, ""},
-		{"IFF_LINK1", Const, 0, ""},
-		{"IFF_LINK2", Const, 0, ""},
-		{"IFF_LOOPBACK", Const, 0, ""},
-		{"IFF_MASTER", Const, 0, ""},
-		{"IFF_MONITOR", Const, 0, ""},
-		{"IFF_MULTICAST", Const, 0, ""},
-		{"IFF_NOARP", Const, 0, ""},
-		{"IFF_NOTRAILERS", Const, 0, ""},
-		{"IFF_NO_PI", Const, 0, ""},
-		{"IFF_OACTIVE", Const, 0, ""},
-		{"IFF_ONE_QUEUE", Const, 0, ""},
-		{"IFF_POINTOPOINT", Const, 0, ""},
-		{"IFF_POINTTOPOINT", Const, 0, ""},
-		{"IFF_PORTSEL", Const, 0, ""},
-		{"IFF_PPROMISC", Const, 0, ""},
-		{"IFF_PROMISC", Const, 0, ""},
-		{"IFF_RENAMING", Const, 0, ""},
-		{"IFF_RUNNING", Const, 0, ""},
-		{"IFF_SIMPLEX", Const, 0, ""},
-		{"IFF_SLAVE", Const, 0, ""},
-		{"IFF_SMART", Const, 0, ""},
-		{"IFF_STATICARP", Const, 0, ""},
-		{"IFF_TAP", Const, 0, ""},
-		{"IFF_TUN", Const, 0, ""},
-		{"IFF_TUN_EXCL", Const, 0, ""},
-		{"IFF_UP", Const, 0, ""},
-		{"IFF_VNET_HDR", Const, 0, ""},
-		{"IFLA_ADDRESS", Const, 0, ""},
-		{"IFLA_BROADCAST", Const, 0, ""},
-		{"IFLA_COST", Const, 0, ""},
-		{"IFLA_IFALIAS", Const, 0, ""},
-		{"IFLA_IFNAME", Const, 0, ""},
-		{"IFLA_LINK", Const, 0, ""},
-		{"IFLA_LINKINFO", Const, 0, ""},
-		{"IFLA_LINKMODE", Const, 0, ""},
-		{"IFLA_MAP", Const, 0, ""},
-		{"IFLA_MASTER", Const, 0, ""},
-		{"IFLA_MAX", Const, 0, ""},
-		{"IFLA_MTU", Const, 0, ""},
-		{"IFLA_NET_NS_PID", Const, 0, ""},
-		{"IFLA_OPERSTATE", Const, 0, ""},
-		{"IFLA_PRIORITY", Const, 0, ""},
-		{"IFLA_PROTINFO", Const, 0, ""},
-		{"IFLA_QDISC", Const, 0, ""},
-		{"IFLA_STATS", Const, 0, ""},
-		{"IFLA_TXQLEN", Const, 0, ""},
-		{"IFLA_UNSPEC", Const, 0, ""},
-		{"IFLA_WEIGHT", Const, 0, ""},
-		{"IFLA_WIRELESS", Const, 0, ""},
-		{"IFNAMSIZ", Const, 0, ""},
-		{"IFT_1822", Const, 0, ""},
-		{"IFT_A12MPPSWITCH", Const, 0, ""},
-		{"IFT_AAL2", Const, 0, ""},
-		{"IFT_AAL5", Const, 0, ""},
-		{"IFT_ADSL", Const, 0, ""},
-		{"IFT_AFLANE8023", Const, 0, ""},
-		{"IFT_AFLANE8025", Const, 0, ""},
-		{"IFT_ARAP", Const, 0, ""},
-		{"IFT_ARCNET", Const, 0, ""},
-		{"IFT_ARCNETPLUS", Const, 0, ""},
-		{"IFT_ASYNC", Const, 0, ""},
-		{"IFT_ATM", Const, 0, ""},
-		{"IFT_ATMDXI", Const, 0, ""},
-		{"IFT_ATMFUNI", Const, 0, ""},
-		{"IFT_ATMIMA", Const, 0, ""},
-		{"IFT_ATMLOGICAL", Const, 0, ""},
-		{"IFT_ATMRADIO", Const, 0, ""},
-		{"IFT_ATMSUBINTERFACE", Const, 0, ""},
-		{"IFT_ATMVCIENDPT", Const, 0, ""},
-		{"IFT_ATMVIRTUAL", Const, 0, ""},
-		{"IFT_BGPPOLICYACCOUNTING", Const, 0, ""},
-		{"IFT_BLUETOOTH", Const, 1, ""},
-		{"IFT_BRIDGE", Const, 0, ""},
-		{"IFT_BSC", Const, 0, ""},
-		{"IFT_CARP", Const, 0, ""},
-		{"IFT_CCTEMUL", Const, 0, ""},
-		{"IFT_CELLULAR", Const, 0, ""},
-		{"IFT_CEPT", Const, 0, ""},
-		{"IFT_CES", Const, 0, ""},
-		{"IFT_CHANNEL", Const, 0, ""},
-		{"IFT_CNR", Const, 0, ""},
-		{"IFT_COFFEE", Const, 0, ""},
-		{"IFT_COMPOSITELINK", Const, 0, ""},
-		{"IFT_DCN", Const, 0, ""},
-		{"IFT_DIGITALPOWERLINE", Const, 0, ""},
-		{"IFT_DIGITALWRAPPEROVERHEADCHANNEL", Const, 0, ""},
-		{"IFT_DLSW", Const, 0, ""},
-		{"IFT_DOCSCABLEDOWNSTREAM", Const, 0, ""},
-		{"IFT_DOCSCABLEMACLAYER", Const, 0, ""},
-		{"IFT_DOCSCABLEUPSTREAM", Const, 0, ""},
-		{"IFT_DOCSCABLEUPSTREAMCHANNEL", Const, 1, ""},
-		{"IFT_DS0", Const, 0, ""},
-		{"IFT_DS0BUNDLE", Const, 0, ""},
-		{"IFT_DS1FDL", Const, 0, ""},
-		{"IFT_DS3", Const, 0, ""},
-		{"IFT_DTM", Const, 0, ""},
-		{"IFT_DUMMY", Const, 1, ""},
-		{"IFT_DVBASILN", Const, 0, ""},
-		{"IFT_DVBASIOUT", Const, 0, ""},
-		{"IFT_DVBRCCDOWNSTREAM", Const, 0, ""},
-		{"IFT_DVBRCCMACLAYER", Const, 0, ""},
-		{"IFT_DVBRCCUPSTREAM", Const, 0, ""},
-		{"IFT_ECONET", Const, 1, ""},
-		{"IFT_ENC", Const, 0, ""},
-		{"IFT_EON", Const, 0, ""},
-		{"IFT_EPLRS", Const, 0, ""},
-		{"IFT_ESCON", Const, 0, ""},
-		{"IFT_ETHER", Const, 0, ""},
-		{"IFT_FAITH", Const, 0, ""},
-		{"IFT_FAST", Const, 0, ""},
-		{"IFT_FASTETHER", Const, 0, ""},
-		{"IFT_FASTETHERFX", Const, 0, ""},
-		{"IFT_FDDI", Const, 0, ""},
-		{"IFT_FIBRECHANNEL", Const, 0, ""},
-		{"IFT_FRAMERELAYINTERCONNECT", Const, 0, ""},
-		{"IFT_FRAMERELAYMPI", Const, 0, ""},
-		{"IFT_FRDLCIENDPT", Const, 0, ""},
-		{"IFT_FRELAY", Const, 0, ""},
-		{"IFT_FRELAYDCE", Const, 0, ""},
-		{"IFT_FRF16MFRBUNDLE", Const, 0, ""},
-		{"IFT_FRFORWARD", Const, 0, ""},
-		{"IFT_G703AT2MB", Const, 0, ""},
-		{"IFT_G703AT64K", Const, 0, ""},
-		{"IFT_GIF", Const, 0, ""},
-		{"IFT_GIGABITETHERNET", Const, 0, ""},
-		{"IFT_GR303IDT", Const, 0, ""},
-		{"IFT_GR303RDT", Const, 0, ""},
-		{"IFT_H323GATEKEEPER", Const, 0, ""},
-		{"IFT_H323PROXY", Const, 0, ""},
-		{"IFT_HDH1822", Const, 0, ""},
-		{"IFT_HDLC", Const, 0, ""},
-		{"IFT_HDSL2", Const, 0, ""},
-		{"IFT_HIPERLAN2", Const, 0, ""},
-		{"IFT_HIPPI", Const, 0, ""},
-		{"IFT_HIPPIINTERFACE", Const, 0, ""},
-		{"IFT_HOSTPAD", Const, 0, ""},
-		{"IFT_HSSI", Const, 0, ""},
-		{"IFT_HY", Const, 0, ""},
-		{"IFT_IBM370PARCHAN", Const, 0, ""},
-		{"IFT_IDSL", Const, 0, ""},
-		{"IFT_IEEE1394", Const, 0, ""},
-		{"IFT_IEEE80211", Const, 0, ""},
-		{"IFT_IEEE80212", Const, 0, ""},
-		{"IFT_IEEE8023ADLAG", Const, 0, ""},
-		{"IFT_IFGSN", Const, 0, ""},
-		{"IFT_IMT", Const, 0, ""},
-		{"IFT_INFINIBAND", Const, 1, ""},
-		{"IFT_INTERLEAVE", Const, 0, ""},
-		{"IFT_IP", Const, 0, ""},
-		{"IFT_IPFORWARD", Const, 0, ""},
-		{"IFT_IPOVERATM", Const, 0, ""},
-		{"IFT_IPOVERCDLC", Const, 0, ""},
-		{"IFT_IPOVERCLAW", Const, 0, ""},
-		{"IFT_IPSWITCH", Const, 0, ""},
-		{"IFT_IPXIP", Const, 0, ""},
-		{"IFT_ISDN", Const, 0, ""},
-		{"IFT_ISDNBASIC", Const, 0, ""},
-		{"IFT_ISDNPRIMARY", Const, 0, ""},
-		{"IFT_ISDNS", Const, 0, ""},
-		{"IFT_ISDNU", Const, 0, ""},
-		{"IFT_ISO88022LLC", Const, 0, ""},
-		{"IFT_ISO88023", Const, 0, ""},
-		{"IFT_ISO88024", Const, 0, ""},
-		{"IFT_ISO88025", Const, 0, ""},
-		{"IFT_ISO88025CRFPINT", Const, 0, ""},
-		{"IFT_ISO88025DTR", Const, 0, ""},
-		{"IFT_ISO88025FIBER", Const, 0, ""},
-		{"IFT_ISO88026", Const, 0, ""},
-		{"IFT_ISUP", Const, 0, ""},
-		{"IFT_L2VLAN", Const, 0, ""},
-		{"IFT_L3IPVLAN", Const, 0, ""},
-		{"IFT_L3IPXVLAN", Const, 0, ""},
-		{"IFT_LAPB", Const, 0, ""},
-		{"IFT_LAPD", Const, 0, ""},
-		{"IFT_LAPF", Const, 0, ""},
-		{"IFT_LINEGROUP", Const, 1, ""},
-		{"IFT_LOCALTALK", Const, 0, ""},
-		{"IFT_LOOP", Const, 0, ""},
-		{"IFT_MEDIAMAILOVERIP", Const, 0, ""},
-		{"IFT_MFSIGLINK", Const, 0, ""},
-		{"IFT_MIOX25", Const, 0, ""},
-		{"IFT_MODEM", Const, 0, ""},
-		{"IFT_MPC", Const, 0, ""},
-		{"IFT_MPLS", Const, 0, ""},
-		{"IFT_MPLSTUNNEL", Const, 0, ""},
-		{"IFT_MSDSL", Const, 0, ""},
-		{"IFT_MVL", Const, 0, ""},
-		{"IFT_MYRINET", Const, 0, ""},
-		{"IFT_NFAS", Const, 0, ""},
-		{"IFT_NSIP", Const, 0, ""},
-		{"IFT_OPTICALCHANNEL", Const, 0, ""},
-		{"IFT_OPTICALTRANSPORT", Const, 0, ""},
-		{"IFT_OTHER", Const, 0, ""},
-		{"IFT_P10", Const, 0, ""},
-		{"IFT_P80", Const, 0, ""},
-		{"IFT_PARA", Const, 0, ""},
-		{"IFT_PDP", Const, 0, ""},
-		{"IFT_PFLOG", Const, 0, ""},
-		{"IFT_PFLOW", Const, 1, ""},
-		{"IFT_PFSYNC", Const, 0, ""},
-		{"IFT_PLC", Const, 0, ""},
-		{"IFT_PON155", Const, 1, ""},
-		{"IFT_PON622", Const, 1, ""},
-		{"IFT_POS", Const, 0, ""},
-		{"IFT_PPP", Const, 0, ""},
-		{"IFT_PPPMULTILINKBUNDLE", Const, 0, ""},
-		{"IFT_PROPATM", Const, 1, ""},
-		{"IFT_PROPBWAP2MP", Const, 0, ""},
-		{"IFT_PROPCNLS", Const, 0, ""},
-		{"IFT_PROPDOCSWIRELESSDOWNSTREAM", Const, 0, ""},
-		{"IFT_PROPDOCSWIRELESSMACLAYER", Const, 0, ""},
-		{"IFT_PROPDOCSWIRELESSUPSTREAM", Const, 0, ""},
-		{"IFT_PROPMUX", Const, 0, ""},
-		{"IFT_PROPVIRTUAL", Const, 0, ""},
-		{"IFT_PROPWIRELESSP2P", Const, 0, ""},
-		{"IFT_PTPSERIAL", Const, 0, ""},
-		{"IFT_PVC", Const, 0, ""},
-		{"IFT_Q2931", Const, 1, ""},
-		{"IFT_QLLC", Const, 0, ""},
-		{"IFT_RADIOMAC", Const, 0, ""},
-		{"IFT_RADSL", Const, 0, ""},
-		{"IFT_REACHDSL", Const, 0, ""},
-		{"IFT_RFC1483", Const, 0, ""},
-		{"IFT_RS232", Const, 0, ""},
-		{"IFT_RSRB", Const, 0, ""},
-		{"IFT_SDLC", Const, 0, ""},
-		{"IFT_SDSL", Const, 0, ""},
-		{"IFT_SHDSL", Const, 0, ""},
-		{"IFT_SIP", Const, 0, ""},
-		{"IFT_SIPSIG", Const, 1, ""},
-		{"IFT_SIPTG", Const, 1, ""},
-		{"IFT_SLIP", Const, 0, ""},
-		{"IFT_SMDSDXI", Const, 0, ""},
-		{"IFT_SMDSICIP", Const, 0, ""},
-		{"IFT_SONET", Const, 0, ""},
-		{"IFT_SONETOVERHEADCHANNEL", Const, 0, ""},
-		{"IFT_SONETPATH", Const, 0, ""},
-		{"IFT_SONETVT", Const, 0, ""},
-		{"IFT_SRP", Const, 0, ""},
-		{"IFT_SS7SIGLINK", Const, 0, ""},
-		{"IFT_STACKTOSTACK", Const, 0, ""},
-		{"IFT_STARLAN", Const, 0, ""},
-		{"IFT_STF", Const, 0, ""},
-		{"IFT_T1", Const, 0, ""},
-		{"IFT_TDLC", Const, 0, ""},
-		{"IFT_TELINK", Const, 1, ""},
-		{"IFT_TERMPAD", Const, 0, ""},
-		{"IFT_TR008", Const, 0, ""},
-		{"IFT_TRANSPHDLC", Const, 0, ""},
-		{"IFT_TUNNEL", Const, 0, ""},
-		{"IFT_ULTRA", Const, 0, ""},
-		{"IFT_USB", Const, 0, ""},
-		{"IFT_V11", Const, 0, ""},
-		{"IFT_V35", Const, 0, ""},
-		{"IFT_V36", Const, 0, ""},
-		{"IFT_V37", Const, 0, ""},
-		{"IFT_VDSL", Const, 0, ""},
-		{"IFT_VIRTUALIPADDRESS", Const, 0, ""},
-		{"IFT_VIRTUALTG", Const, 1, ""},
-		{"IFT_VOICEDID", Const, 1, ""},
-		{"IFT_VOICEEM", Const, 0, ""},
-		{"IFT_VOICEEMFGD", Const, 1, ""},
-		{"IFT_VOICEENCAP", Const, 0, ""},
-		{"IFT_VOICEFGDEANA", Const, 1, ""},
-		{"IFT_VOICEFXO", Const, 0, ""},
-		{"IFT_VOICEFXS", Const, 0, ""},
-		{"IFT_VOICEOVERATM", Const, 0, ""},
-		{"IFT_VOICEOVERCABLE", Const, 1, ""},
-		{"IFT_VOICEOVERFRAMERELAY", Const, 0, ""},
-		{"IFT_VOICEOVERIP", Const, 0, ""},
-		{"IFT_X213", Const, 0, ""},
-		{"IFT_X25", Const, 0, ""},
-		{"IFT_X25DDN", Const, 0, ""},
-		{"IFT_X25HUNTGROUP", Const, 0, ""},
-		{"IFT_X25MLP", Const, 0, ""},
-		{"IFT_X25PLE", Const, 0, ""},
-		{"IFT_XETHER", Const, 0, ""},
-		{"IGNBRK", Const, 0, ""},
-		{"IGNCR", Const, 0, ""},
-		{"IGNORE", Const, 0, ""},
-		{"IGNPAR", Const, 0, ""},
-		{"IMAXBEL", Const, 0, ""},
-		{"INFINITE", Const, 0, ""},
-		{"INLCR", Const, 0, ""},
-		{"INPCK", Const, 0, ""},
-		{"INVALID_FILE_ATTRIBUTES", Const, 0, ""},
-		{"IN_ACCESS", Const, 0, ""},
-		{"IN_ALL_EVENTS", Const, 0, ""},
-		{"IN_ATTRIB", Const, 0, ""},
-		{"IN_CLASSA_HOST", Const, 0, ""},
-		{"IN_CLASSA_MAX", Const, 0, ""},
-		{"IN_CLASSA_NET", Const, 0, ""},
-		{"IN_CLASSA_NSHIFT", Const, 0, ""},
-		{"IN_CLASSB_HOST", Const, 0, ""},
-		{"IN_CLASSB_MAX", Const, 0, ""},
-		{"IN_CLASSB_NET", Const, 0, ""},
-		{"IN_CLASSB_NSHIFT", Const, 0, ""},
-		{"IN_CLASSC_HOST", Const, 0, ""},
-		{"IN_CLASSC_NET", Const, 0, ""},
-		{"IN_CLASSC_NSHIFT", Const, 0, ""},
-		{"IN_CLASSD_HOST", Const, 0, ""},
-		{"IN_CLASSD_NET", Const, 0, ""},
-		{"IN_CLASSD_NSHIFT", Const, 0, ""},
-		{"IN_CLOEXEC", Const, 0, ""},
-		{"IN_CLOSE", Const, 0, ""},
-		{"IN_CLOSE_NOWRITE", Const, 0, ""},
-		{"IN_CLOSE_WRITE", Const, 0, ""},
-		{"IN_CREATE", Const, 0, ""},
-		{"IN_DELETE", Const, 0, ""},
-		{"IN_DELETE_SELF", Const, 0, ""},
-		{"IN_DONT_FOLLOW", Const, 0, ""},
-		{"IN_EXCL_UNLINK", Const, 0, ""},
-		{"IN_IGNORED", Const, 0, ""},
-		{"IN_ISDIR", Const, 0, ""},
-		{"IN_LINKLOCALNETNUM", Const, 0, ""},
-		{"IN_LOOPBACKNET", Const, 0, ""},
-		{"IN_MASK_ADD", Const, 0, ""},
-		{"IN_MODIFY", Const, 0, ""},
-		{"IN_MOVE", Const, 0, ""},
-		{"IN_MOVED_FROM", Const, 0, ""},
-		{"IN_MOVED_TO", Const, 0, ""},
-		{"IN_MOVE_SELF", Const, 0, ""},
-		{"IN_NONBLOCK", Const, 0, ""},
-		{"IN_ONESHOT", Const, 0, ""},
-		{"IN_ONLYDIR", Const, 0, ""},
-		{"IN_OPEN", Const, 0, ""},
-		{"IN_Q_OVERFLOW", Const, 0, ""},
-		{"IN_RFC3021_HOST", Const, 1, ""},
-		{"IN_RFC3021_MASK", Const, 1, ""},
-		{"IN_RFC3021_NET", Const, 1, ""},
-		{"IN_RFC3021_NSHIFT", Const, 1, ""},
-		{"IN_UNMOUNT", Const, 0, ""},
-		{"IOC_IN", Const, 1, ""},
-		{"IOC_INOUT", Const, 1, ""},
-		{"IOC_OUT", Const, 1, ""},
-		{"IOC_VENDOR", Const, 3, ""},
-		{"IOC_WS2", Const, 1, ""},
-		{"IO_REPARSE_TAG_SYMLINK", Const, 4, ""},
-		{"IPMreq", Type, 0, ""},
-		{"IPMreq.Interface", Field, 0, ""},
-		{"IPMreq.Multiaddr", Field, 0, ""},
-		{"IPMreqn", Type, 0, ""},
-		{"IPMreqn.Address", Field, 0, ""},
-		{"IPMreqn.Ifindex", Field, 0, ""},
-		{"IPMreqn.Multiaddr", Field, 0, ""},
-		{"IPPROTO_3PC", Const, 0, ""},
-		{"IPPROTO_ADFS", Const, 0, ""},
-		{"IPPROTO_AH", Const, 0, ""},
-		{"IPPROTO_AHIP", Const, 0, ""},
-		{"IPPROTO_APES", Const, 0, ""},
-		{"IPPROTO_ARGUS", Const, 0, ""},
-		{"IPPROTO_AX25", Const, 0, ""},
-		{"IPPROTO_BHA", Const, 0, ""},
-		{"IPPROTO_BLT", Const, 0, ""},
-		{"IPPROTO_BRSATMON", Const, 0, ""},
-		{"IPPROTO_CARP", Const, 0, ""},
-		{"IPPROTO_CFTP", Const, 0, ""},
-		{"IPPROTO_CHAOS", Const, 0, ""},
-		{"IPPROTO_CMTP", Const, 0, ""},
-		{"IPPROTO_COMP", Const, 0, ""},
-		{"IPPROTO_CPHB", Const, 0, ""},
-		{"IPPROTO_CPNX", Const, 0, ""},
-		{"IPPROTO_DCCP", Const, 0, ""},
-		{"IPPROTO_DDP", Const, 0, ""},
-		{"IPPROTO_DGP", Const, 0, ""},
-		{"IPPROTO_DIVERT", Const, 0, ""},
-		{"IPPROTO_DIVERT_INIT", Const, 3, ""},
-		{"IPPROTO_DIVERT_RESP", Const, 3, ""},
-		{"IPPROTO_DONE", Const, 0, ""},
-		{"IPPROTO_DSTOPTS", Const, 0, ""},
-		{"IPPROTO_EGP", Const, 0, ""},
-		{"IPPROTO_EMCON", Const, 0, ""},
-		{"IPPROTO_ENCAP", Const, 0, ""},
-		{"IPPROTO_EON", Const, 0, ""},
-		{"IPPROTO_ESP", Const, 0, ""},
-		{"IPPROTO_ETHERIP", Const, 0, ""},
-		{"IPPROTO_FRAGMENT", Const, 0, ""},
-		{"IPPROTO_GGP", Const, 0, ""},
-		{"IPPROTO_GMTP", Const, 0, ""},
-		{"IPPROTO_GRE", Const, 0, ""},
-		{"IPPROTO_HELLO", Const, 0, ""},
-		{"IPPROTO_HMP", Const, 0, ""},
-		{"IPPROTO_HOPOPTS", Const, 0, ""},
-		{"IPPROTO_ICMP", Const, 0, ""},
-		{"IPPROTO_ICMPV6", Const, 0, ""},
-		{"IPPROTO_IDP", Const, 0, ""},
-		{"IPPROTO_IDPR", Const, 0, ""},
-		{"IPPROTO_IDRP", Const, 0, ""},
-		{"IPPROTO_IGMP", Const, 0, ""},
-		{"IPPROTO_IGP", Const, 0, ""},
-		{"IPPROTO_IGRP", Const, 0, ""},
-		{"IPPROTO_IL", Const, 0, ""},
-		{"IPPROTO_INLSP", Const, 0, ""},
-		{"IPPROTO_INP", Const, 0, ""},
-		{"IPPROTO_IP", Const, 0, ""},
-		{"IPPROTO_IPCOMP", Const, 0, ""},
-		{"IPPROTO_IPCV", Const, 0, ""},
-		{"IPPROTO_IPEIP", Const, 0, ""},
-		{"IPPROTO_IPIP", Const, 0, ""},
-		{"IPPROTO_IPPC", Const, 0, ""},
-		{"IPPROTO_IPV4", Const, 0, ""},
-		{"IPPROTO_IPV6", Const, 0, ""},
-		{"IPPROTO_IPV6_ICMP", Const, 1, ""},
-		{"IPPROTO_IRTP", Const, 0, ""},
-		{"IPPROTO_KRYPTOLAN", Const, 0, ""},
-		{"IPPROTO_LARP", Const, 0, ""},
-		{"IPPROTO_LEAF1", Const, 0, ""},
-		{"IPPROTO_LEAF2", Const, 0, ""},
-		{"IPPROTO_MAX", Const, 0, ""},
-		{"IPPROTO_MAXID", Const, 0, ""},
-		{"IPPROTO_MEAS", Const, 0, ""},
-		{"IPPROTO_MH", Const, 1, ""},
-		{"IPPROTO_MHRP", Const, 0, ""},
-		{"IPPROTO_MICP", Const, 0, ""},
-		{"IPPROTO_MOBILE", Const, 0, ""},
-		{"IPPROTO_MPLS", Const, 1, ""},
-		{"IPPROTO_MTP", Const, 0, ""},
-		{"IPPROTO_MUX", Const, 0, ""},
-		{"IPPROTO_ND", Const, 0, ""},
-		{"IPPROTO_NHRP", Const, 0, ""},
-		{"IPPROTO_NONE", Const, 0, ""},
-		{"IPPROTO_NSP", Const, 0, ""},
-		{"IPPROTO_NVPII", Const, 0, ""},
-		{"IPPROTO_OLD_DIVERT", Const, 0, ""},
-		{"IPPROTO_OSPFIGP", Const, 0, ""},
-		{"IPPROTO_PFSYNC", Const, 0, ""},
-		{"IPPROTO_PGM", Const, 0, ""},
-		{"IPPROTO_PIGP", Const, 0, ""},
-		{"IPPROTO_PIM", Const, 0, ""},
-		{"IPPROTO_PRM", Const, 0, ""},
-		{"IPPROTO_PUP", Const, 0, ""},
-		{"IPPROTO_PVP", Const, 0, ""},
-		{"IPPROTO_RAW", Const, 0, ""},
-		{"IPPROTO_RCCMON", Const, 0, ""},
-		{"IPPROTO_RDP", Const, 0, ""},
-		{"IPPROTO_ROUTING", Const, 0, ""},
-		{"IPPROTO_RSVP", Const, 0, ""},
-		{"IPPROTO_RVD", Const, 0, ""},
-		{"IPPROTO_SATEXPAK", Const, 0, ""},
-		{"IPPROTO_SATMON", Const, 0, ""},
-		{"IPPROTO_SCCSP", Const, 0, ""},
-		{"IPPROTO_SCTP", Const, 0, ""},
-		{"IPPROTO_SDRP", Const, 0, ""},
-		{"IPPROTO_SEND", Const, 1, ""},
-		{"IPPROTO_SEP", Const, 0, ""},
-		{"IPPROTO_SKIP", Const, 0, ""},
-		{"IPPROTO_SPACER", Const, 0, ""},
-		{"IPPROTO_SRPC", Const, 0, ""},
-		{"IPPROTO_ST", Const, 0, ""},
-		{"IPPROTO_SVMTP", Const, 0, ""},
-		{"IPPROTO_SWIPE", Const, 0, ""},
-		{"IPPROTO_TCF", Const, 0, ""},
-		{"IPPROTO_TCP", Const, 0, ""},
-		{"IPPROTO_TLSP", Const, 0, ""},
-		{"IPPROTO_TP", Const, 0, ""},
-		{"IPPROTO_TPXX", Const, 0, ""},
-		{"IPPROTO_TRUNK1", Const, 0, ""},
-		{"IPPROTO_TRUNK2", Const, 0, ""},
-		{"IPPROTO_TTP", Const, 0, ""},
-		{"IPPROTO_UDP", Const, 0, ""},
-		{"IPPROTO_UDPLITE", Const, 0, ""},
-		{"IPPROTO_VINES", Const, 0, ""},
-		{"IPPROTO_VISA", Const, 0, ""},
-		{"IPPROTO_VMTP", Const, 0, ""},
-		{"IPPROTO_VRRP", Const, 1, ""},
-		{"IPPROTO_WBEXPAK", Const, 0, ""},
-		{"IPPROTO_WBMON", Const, 0, ""},
-		{"IPPROTO_WSN", Const, 0, ""},
-		{"IPPROTO_XNET", Const, 0, ""},
-		{"IPPROTO_XTP", Const, 0, ""},
-		{"IPV6_2292DSTOPTS", Const, 0, ""},
-		{"IPV6_2292HOPLIMIT", Const, 0, ""},
-		{"IPV6_2292HOPOPTS", Const, 0, ""},
-		{"IPV6_2292NEXTHOP", Const, 0, ""},
-		{"IPV6_2292PKTINFO", Const, 0, ""},
-		{"IPV6_2292PKTOPTIONS", Const, 0, ""},
-		{"IPV6_2292RTHDR", Const, 0, ""},
-		{"IPV6_ADDRFORM", Const, 0, ""},
-		{"IPV6_ADD_MEMBERSHIP", Const, 0, ""},
-		{"IPV6_AUTHHDR", Const, 0, ""},
-		{"IPV6_AUTH_LEVEL", Const, 1, ""},
-		{"IPV6_AUTOFLOWLABEL", Const, 0, ""},
-		{"IPV6_BINDANY", Const, 0, ""},
-		{"IPV6_BINDV6ONLY", Const, 0, ""},
-		{"IPV6_BOUND_IF", Const, 0, ""},
-		{"IPV6_CHECKSUM", Const, 0, ""},
-		{"IPV6_DEFAULT_MULTICAST_HOPS", Const, 0, ""},
-		{"IPV6_DEFAULT_MULTICAST_LOOP", Const, 0, ""},
-		{"IPV6_DEFHLIM", Const, 0, ""},
-		{"IPV6_DONTFRAG", Const, 0, ""},
-		{"IPV6_DROP_MEMBERSHIP", Const, 0, ""},
-		{"IPV6_DSTOPTS", Const, 0, ""},
-		{"IPV6_ESP_NETWORK_LEVEL", Const, 1, ""},
-		{"IPV6_ESP_TRANS_LEVEL", Const, 1, ""},
-		{"IPV6_FAITH", Const, 0, ""},
-		{"IPV6_FLOWINFO_MASK", Const, 0, ""},
-		{"IPV6_FLOWLABEL_MASK", Const, 0, ""},
-		{"IPV6_FRAGTTL", Const, 0, ""},
-		{"IPV6_FW_ADD", Const, 0, ""},
-		{"IPV6_FW_DEL", Const, 0, ""},
-		{"IPV6_FW_FLUSH", Const, 0, ""},
-		{"IPV6_FW_GET", Const, 0, ""},
-		{"IPV6_FW_ZERO", Const, 0, ""},
-		{"IPV6_HLIMDEC", Const, 0, ""},
-		{"IPV6_HOPLIMIT", Const, 0, ""},
-		{"IPV6_HOPOPTS", Const, 0, ""},
-		{"IPV6_IPCOMP_LEVEL", Const, 1, ""},
-		{"IPV6_IPSEC_POLICY", Const, 0, ""},
-		{"IPV6_JOIN_ANYCAST", Const, 0, ""},
-		{"IPV6_JOIN_GROUP", Const, 0, ""},
-		{"IPV6_LEAVE_ANYCAST", Const, 0, ""},
-		{"IPV6_LEAVE_GROUP", Const, 0, ""},
-		{"IPV6_MAXHLIM", Const, 0, ""},
-		{"IPV6_MAXOPTHDR", Const, 0, ""},
-		{"IPV6_MAXPACKET", Const, 0, ""},
-		{"IPV6_MAX_GROUP_SRC_FILTER", Const, 0, ""},
-		{"IPV6_MAX_MEMBERSHIPS", Const, 0, ""},
-		{"IPV6_MAX_SOCK_SRC_FILTER", Const, 0, ""},
-		{"IPV6_MIN_MEMBERSHIPS", Const, 0, ""},
-		{"IPV6_MMTU", Const, 0, ""},
-		{"IPV6_MSFILTER", Const, 0, ""},
-		{"IPV6_MTU", Const, 0, ""},
-		{"IPV6_MTU_DISCOVER", Const, 0, ""},
-		{"IPV6_MULTICAST_HOPS", Const, 0, ""},
-		{"IPV6_MULTICAST_IF", Const, 0, ""},
-		{"IPV6_MULTICAST_LOOP", Const, 0, ""},
-		{"IPV6_NEXTHOP", Const, 0, ""},
-		{"IPV6_OPTIONS", Const, 1, ""},
-		{"IPV6_PATHMTU", Const, 0, ""},
-		{"IPV6_PIPEX", Const, 1, ""},
-		{"IPV6_PKTINFO", Const, 0, ""},
-		{"IPV6_PMTUDISC_DO", Const, 0, ""},
-		{"IPV6_PMTUDISC_DONT", Const, 0, ""},
-		{"IPV6_PMTUDISC_PROBE", Const, 0, ""},
-		{"IPV6_PMTUDISC_WANT", Const, 0, ""},
-		{"IPV6_PORTRANGE", Const, 0, ""},
-		{"IPV6_PORTRANGE_DEFAULT", Const, 0, ""},
-		{"IPV6_PORTRANGE_HIGH", Const, 0, ""},
-		{"IPV6_PORTRANGE_LOW", Const, 0, ""},
-		{"IPV6_PREFER_TEMPADDR", Const, 0, ""},
-		{"IPV6_RECVDSTOPTS", Const, 0, ""},
-		{"IPV6_RECVDSTPORT", Const, 3, ""},
-		{"IPV6_RECVERR", Const, 0, ""},
-		{"IPV6_RECVHOPLIMIT", Const, 0, ""},
-		{"IPV6_RECVHOPOPTS", Const, 0, ""},
-		{"IPV6_RECVPATHMTU", Const, 0, ""},
-		{"IPV6_RECVPKTINFO", Const, 0, ""},
-		{"IPV6_RECVRTHDR", Const, 0, ""},
-		{"IPV6_RECVTCLASS", Const, 0, ""},
-		{"IPV6_ROUTER_ALERT", Const, 0, ""},
-		{"IPV6_RTABLE", Const, 1, ""},
-		{"IPV6_RTHDR", Const, 0, ""},
-		{"IPV6_RTHDRDSTOPTS", Const, 0, ""},
-		{"IPV6_RTHDR_LOOSE", Const, 0, ""},
-		{"IPV6_RTHDR_STRICT", Const, 0, ""},
-		{"IPV6_RTHDR_TYPE_0", Const, 0, ""},
-		{"IPV6_RXDSTOPTS", Const, 0, ""},
-		{"IPV6_RXHOPOPTS", Const, 0, ""},
-		{"IPV6_SOCKOPT_RESERVED1", Const, 0, ""},
-		{"IPV6_TCLASS", Const, 0, ""},
-		{"IPV6_UNICAST_HOPS", Const, 0, ""},
-		{"IPV6_USE_MIN_MTU", Const, 0, ""},
-		{"IPV6_V6ONLY", Const, 0, ""},
-		{"IPV6_VERSION", Const, 0, ""},
-		{"IPV6_VERSION_MASK", Const, 0, ""},
-		{"IPV6_XFRM_POLICY", Const, 0, ""},
-		{"IP_ADD_MEMBERSHIP", Const, 0, ""},
-		{"IP_ADD_SOURCE_MEMBERSHIP", Const, 0, ""},
-		{"IP_AUTH_LEVEL", Const, 1, ""},
-		{"IP_BINDANY", Const, 0, ""},
-		{"IP_BLOCK_SOURCE", Const, 0, ""},
-		{"IP_BOUND_IF", Const, 0, ""},
-		{"IP_DEFAULT_MULTICAST_LOOP", Const, 0, ""},
-		{"IP_DEFAULT_MULTICAST_TTL", Const, 0, ""},
-		{"IP_DF", Const, 0, ""},
-		{"IP_DIVERTFL", Const, 3, ""},
-		{"IP_DONTFRAG", Const, 0, ""},
-		{"IP_DROP_MEMBERSHIP", Const, 0, ""},
-		{"IP_DROP_SOURCE_MEMBERSHIP", Const, 0, ""},
-		{"IP_DUMMYNET3", Const, 0, ""},
-		{"IP_DUMMYNET_CONFIGURE", Const, 0, ""},
-		{"IP_DUMMYNET_DEL", Const, 0, ""},
-		{"IP_DUMMYNET_FLUSH", Const, 0, ""},
-		{"IP_DUMMYNET_GET", Const, 0, ""},
-		{"IP_EF", Const, 1, ""},
-		{"IP_ERRORMTU", Const, 1, ""},
-		{"IP_ESP_NETWORK_LEVEL", Const, 1, ""},
-		{"IP_ESP_TRANS_LEVEL", Const, 1, ""},
-		{"IP_FAITH", Const, 0, ""},
-		{"IP_FREEBIND", Const, 0, ""},
-		{"IP_FW3", Const, 0, ""},
-		{"IP_FW_ADD", Const, 0, ""},
-		{"IP_FW_DEL", Const, 0, ""},
-		{"IP_FW_FLUSH", Const, 0, ""},
-		{"IP_FW_GET", Const, 0, ""},
-		{"IP_FW_NAT_CFG", Const, 0, ""},
-		{"IP_FW_NAT_DEL", Const, 0, ""},
-		{"IP_FW_NAT_GET_CONFIG", Const, 0, ""},
-		{"IP_FW_NAT_GET_LOG", Const, 0, ""},
-		{"IP_FW_RESETLOG", Const, 0, ""},
-		{"IP_FW_TABLE_ADD", Const, 0, ""},
-		{"IP_FW_TABLE_DEL", Const, 0, ""},
-		{"IP_FW_TABLE_FLUSH", Const, 0, ""},
-		{"IP_FW_TABLE_GETSIZE", Const, 0, ""},
-		{"IP_FW_TABLE_LIST", Const, 0, ""},
-		{"IP_FW_ZERO", Const, 0, ""},
-		{"IP_HDRINCL", Const, 0, ""},
-		{"IP_IPCOMP_LEVEL", Const, 1, ""},
-		{"IP_IPSECFLOWINFO", Const, 1, ""},
-		{"IP_IPSEC_LOCAL_AUTH", Const, 1, ""},
-		{"IP_IPSEC_LOCAL_CRED", Const, 1, ""},
-		{"IP_IPSEC_LOCAL_ID", Const, 1, ""},
-		{"IP_IPSEC_POLICY", Const, 0, ""},
-		{"IP_IPSEC_REMOTE_AUTH", Const, 1, ""},
-		{"IP_IPSEC_REMOTE_CRED", Const, 1, ""},
-		{"IP_IPSEC_REMOTE_ID", Const, 1, ""},
-		{"IP_MAXPACKET", Const, 0, ""},
-		{"IP_MAX_GROUP_SRC_FILTER", Const, 0, ""},
-		{"IP_MAX_MEMBERSHIPS", Const, 0, ""},
-		{"IP_MAX_SOCK_MUTE_FILTER", Const, 0, ""},
-		{"IP_MAX_SOCK_SRC_FILTER", Const, 0, ""},
-		{"IP_MAX_SOURCE_FILTER", Const, 0, ""},
-		{"IP_MF", Const, 0, ""},
-		{"IP_MINFRAGSIZE", Const, 1, ""},
-		{"IP_MINTTL", Const, 0, ""},
-		{"IP_MIN_MEMBERSHIPS", Const, 0, ""},
-		{"IP_MSFILTER", Const, 0, ""},
-		{"IP_MSS", Const, 0, ""},
-		{"IP_MTU", Const, 0, ""},
-		{"IP_MTU_DISCOVER", Const, 0, ""},
-		{"IP_MULTICAST_IF", Const, 0, ""},
-		{"IP_MULTICAST_IFINDEX", Const, 0, ""},
-		{"IP_MULTICAST_LOOP", Const, 0, ""},
-		{"IP_MULTICAST_TTL", Const, 0, ""},
-		{"IP_MULTICAST_VIF", Const, 0, ""},
-		{"IP_NAT__XXX", Const, 0, ""},
-		{"IP_OFFMASK", Const, 0, ""},
-		{"IP_OLD_FW_ADD", Const, 0, ""},
-		{"IP_OLD_FW_DEL", Const, 0, ""},
-		{"IP_OLD_FW_FLUSH", Const, 0, ""},
-		{"IP_OLD_FW_GET", Const, 0, ""},
-		{"IP_OLD_FW_RESETLOG", Const, 0, ""},
-		{"IP_OLD_FW_ZERO", Const, 0, ""},
-		{"IP_ONESBCAST", Const, 0, ""},
-		{"IP_OPTIONS", Const, 0, ""},
-		{"IP_ORIGDSTADDR", Const, 0, ""},
-		{"IP_PASSSEC", Const, 0, ""},
-		{"IP_PIPEX", Const, 1, ""},
-		{"IP_PKTINFO", Const, 0, ""},
-		{"IP_PKTOPTIONS", Const, 0, ""},
-		{"IP_PMTUDISC", Const, 0, ""},
-		{"IP_PMTUDISC_DO", Const, 0, ""},
-		{"IP_PMTUDISC_DONT", Const, 0, ""},
-		{"IP_PMTUDISC_PROBE", Const, 0, ""},
-		{"IP_PMTUDISC_WANT", Const, 0, ""},
-		{"IP_PORTRANGE", Const, 0, ""},
-		{"IP_PORTRANGE_DEFAULT", Const, 0, ""},
-		{"IP_PORTRANGE_HIGH", Const, 0, ""},
-		{"IP_PORTRANGE_LOW", Const, 0, ""},
-		{"IP_RECVDSTADDR", Const, 0, ""},
-		{"IP_RECVDSTPORT", Const, 1, ""},
-		{"IP_RECVERR", Const, 0, ""},
-		{"IP_RECVIF", Const, 0, ""},
-		{"IP_RECVOPTS", Const, 0, ""},
-		{"IP_RECVORIGDSTADDR", Const, 0, ""},
-		{"IP_RECVPKTINFO", Const, 0, ""},
-		{"IP_RECVRETOPTS", Const, 0, ""},
-		{"IP_RECVRTABLE", Const, 1, ""},
-		{"IP_RECVTOS", Const, 0, ""},
-		{"IP_RECVTTL", Const, 0, ""},
-		{"IP_RETOPTS", Const, 0, ""},
-		{"IP_RF", Const, 0, ""},
-		{"IP_ROUTER_ALERT", Const, 0, ""},
-		{"IP_RSVP_OFF", Const, 0, ""},
-		{"IP_RSVP_ON", Const, 0, ""},
-		{"IP_RSVP_VIF_OFF", Const, 0, ""},
-		{"IP_RSVP_VIF_ON", Const, 0, ""},
-		{"IP_RTABLE", Const, 1, ""},
-		{"IP_SENDSRCADDR", Const, 0, ""},
-		{"IP_STRIPHDR", Const, 0, ""},
-		{"IP_TOS", Const, 0, ""},
-		{"IP_TRAFFIC_MGT_BACKGROUND", Const, 0, ""},
-		{"IP_TRANSPARENT", Const, 0, ""},
-		{"IP_TTL", Const, 0, ""},
-		{"IP_UNBLOCK_SOURCE", Const, 0, ""},
-		{"IP_XFRM_POLICY", Const, 0, ""},
-		{"IPv6MTUInfo", Type, 2, ""},
-		{"IPv6MTUInfo.Addr", Field, 2, ""},
-		{"IPv6MTUInfo.Mtu", Field, 2, ""},
-		{"IPv6Mreq", Type, 0, ""},
-		{"IPv6Mreq.Interface", Field, 0, ""},
-		{"IPv6Mreq.Multiaddr", Field, 0, ""},
-		{"ISIG", Const, 0, ""},
-		{"ISTRIP", Const, 0, ""},
-		{"IUCLC", Const, 0, ""},
-		{"IUTF8", Const, 0, ""},
-		{"IXANY", Const, 0, ""},
-		{"IXOFF", Const, 0, ""},
-		{"IXON", Const, 0, ""},
-		{"IfAddrmsg", Type, 0, ""},
-		{"IfAddrmsg.Family", Field, 0, ""},
-		{"IfAddrmsg.Flags", Field, 0, ""},
-		{"IfAddrmsg.Index", Field, 0, ""},
-		{"IfAddrmsg.Prefixlen", Field, 0, ""},
-		{"IfAddrmsg.Scope", Field, 0, ""},
-		{"IfAnnounceMsghdr", Type, 1, ""},
-		{"IfAnnounceMsghdr.Hdrlen", Field, 2, ""},
-		{"IfAnnounceMsghdr.Index", Field, 1, ""},
-		{"IfAnnounceMsghdr.Msglen", Field, 1, ""},
-		{"IfAnnounceMsghdr.Name", Field, 1, ""},
-		{"IfAnnounceMsghdr.Type", Field, 1, ""},
-		{"IfAnnounceMsghdr.Version", Field, 1, ""},
-		{"IfAnnounceMsghdr.What", Field, 1, ""},
-		{"IfData", Type, 0, ""},
-		{"IfData.Addrlen", Field, 0, ""},
-		{"IfData.Baudrate", Field, 0, ""},
-		{"IfData.Capabilities", Field, 2, ""},
-		{"IfData.Collisions", Field, 0, ""},
-		{"IfData.Datalen", Field, 0, ""},
-		{"IfData.Epoch", Field, 0, ""},
-		{"IfData.Hdrlen", Field, 0, ""},
-		{"IfData.Hwassist", Field, 0, ""},
-		{"IfData.Ibytes", Field, 0, ""},
-		{"IfData.Ierrors", Field, 0, ""},
-		{"IfData.Imcasts", Field, 0, ""},
-		{"IfData.Ipackets", Field, 0, ""},
-		{"IfData.Iqdrops", Field, 0, ""},
-		{"IfData.Lastchange", Field, 0, ""},
-		{"IfData.Link_state", Field, 0, ""},
-		{"IfData.Mclpool", Field, 2, ""},
-		{"IfData.Metric", Field, 0, ""},
-		{"IfData.Mtu", Field, 0, ""},
-		{"IfData.Noproto", Field, 0, ""},
-		{"IfData.Obytes", Field, 0, ""},
-		{"IfData.Oerrors", Field, 0, ""},
-		{"IfData.Omcasts", Field, 0, ""},
-		{"IfData.Opackets", Field, 0, ""},
-		{"IfData.Pad", Field, 2, ""},
-		{"IfData.Pad_cgo_0", Field, 2, ""},
-		{"IfData.Pad_cgo_1", Field, 2, ""},
-		{"IfData.Physical", Field, 0, ""},
-		{"IfData.Recvquota", Field, 0, ""},
-		{"IfData.Recvtiming", Field, 0, ""},
-		{"IfData.Reserved1", Field, 0, ""},
-		{"IfData.Reserved2", Field, 0, ""},
-		{"IfData.Spare_char1", Field, 0, ""},
-		{"IfData.Spare_char2", Field, 0, ""},
-		{"IfData.Type", Field, 0, ""},
-		{"IfData.Typelen", Field, 0, ""},
-		{"IfData.Unused1", Field, 0, ""},
-		{"IfData.Unused2", Field, 0, ""},
-		{"IfData.Xmitquota", Field, 0, ""},
-		{"IfData.Xmittiming", Field, 0, ""},
-		{"IfInfomsg", Type, 0, ""},
-		{"IfInfomsg.Change", Field, 0, ""},
-		{"IfInfomsg.Family", Field, 0, ""},
-		{"IfInfomsg.Flags", Field, 0, ""},
-		{"IfInfomsg.Index", Field, 0, ""},
-		{"IfInfomsg.Type", Field, 0, ""},
-		{"IfInfomsg.X__ifi_pad", Field, 0, ""},
-		{"IfMsghdr", Type, 0, ""},
-		{"IfMsghdr.Addrs", Field, 0, ""},
-		{"IfMsghdr.Data", Field, 0, ""},
-		{"IfMsghdr.Flags", Field, 0, ""},
-		{"IfMsghdr.Hdrlen", Field, 2, ""},
-		{"IfMsghdr.Index", Field, 0, ""},
-		{"IfMsghdr.Msglen", Field, 0, ""},
-		{"IfMsghdr.Pad1", Field, 2, ""},
-		{"IfMsghdr.Pad2", Field, 2, ""},
-		{"IfMsghdr.Pad_cgo_0", Field, 0, ""},
-		{"IfMsghdr.Pad_cgo_1", Field, 2, ""},
-		{"IfMsghdr.Tableid", Field, 2, ""},
-		{"IfMsghdr.Type", Field, 0, ""},
-		{"IfMsghdr.Version", Field, 0, ""},
-		{"IfMsghdr.Xflags", Field, 2, ""},
-		{"IfaMsghdr", Type, 0, ""},
-		{"IfaMsghdr.Addrs", Field, 0, ""},
-		{"IfaMsghdr.Flags", Field, 0, ""},
-		{"IfaMsghdr.Hdrlen", Field, 2, ""},
-		{"IfaMsghdr.Index", Field, 0, ""},
-		{"IfaMsghdr.Metric", Field, 0, ""},
-		{"IfaMsghdr.Msglen", Field, 0, ""},
-		{"IfaMsghdr.Pad1", Field, 2, ""},
-		{"IfaMsghdr.Pad2", Field, 2, ""},
-		{"IfaMsghdr.Pad_cgo_0", Field, 0, ""},
-		{"IfaMsghdr.Tableid", Field, 2, ""},
-		{"IfaMsghdr.Type", Field, 0, ""},
-		{"IfaMsghdr.Version", Field, 0, ""},
-		{"IfmaMsghdr", Type, 0, ""},
-		{"IfmaMsghdr.Addrs", Field, 0, ""},
-		{"IfmaMsghdr.Flags", Field, 0, ""},
-		{"IfmaMsghdr.Index", Field, 0, ""},
-		{"IfmaMsghdr.Msglen", Field, 0, ""},
-		{"IfmaMsghdr.Pad_cgo_0", Field, 0, ""},
-		{"IfmaMsghdr.Type", Field, 0, ""},
-		{"IfmaMsghdr.Version", Field, 0, ""},
-		{"IfmaMsghdr2", Type, 0, ""},
-		{"IfmaMsghdr2.Addrs", Field, 0, ""},
-		{"IfmaMsghdr2.Flags", Field, 0, ""},
-		{"IfmaMsghdr2.Index", Field, 0, ""},
-		{"IfmaMsghdr2.Msglen", Field, 0, ""},
-		{"IfmaMsghdr2.Pad_cgo_0", Field, 0, ""},
-		{"IfmaMsghdr2.Refcount", Field, 0, ""},
-		{"IfmaMsghdr2.Type", Field, 0, ""},
-		{"IfmaMsghdr2.Version", Field, 0, ""},
-		{"ImplementsGetwd", Const, 0, ""},
-		{"Inet4Pktinfo", Type, 0, ""},
-		{"Inet4Pktinfo.Addr", Field, 0, ""},
-		{"Inet4Pktinfo.Ifindex", Field, 0, ""},
-		{"Inet4Pktinfo.Spec_dst", Field, 0, ""},
-		{"Inet6Pktinfo", Type, 0, ""},
-		{"Inet6Pktinfo.Addr", Field, 0, ""},
-		{"Inet6Pktinfo.Ifindex", Field, 0, ""},
-		{"InotifyAddWatch", Func, 0, "func(fd int, pathname string, mask uint32) (watchdesc int, err error)"},
-		{"InotifyEvent", Type, 0, ""},
-		{"InotifyEvent.Cookie", Field, 0, ""},
-		{"InotifyEvent.Len", Field, 0, ""},
-		{"InotifyEvent.Mask", Field, 0, ""},
-		{"InotifyEvent.Name", Field, 0, ""},
-		{"InotifyEvent.Wd", Field, 0, ""},
-		{"InotifyInit", Func, 0, "func() (fd int, err error)"},
-		{"InotifyInit1", Func, 0, "func(flags int) (fd int, err error)"},
-		{"InotifyRmWatch", Func, 0, "func(fd int, watchdesc uint32) (success int, err error)"},
-		{"InterfaceAddrMessage", Type, 0, ""},
-		{"InterfaceAddrMessage.Data", Field, 0, ""},
-		{"InterfaceAddrMessage.Header", Field, 0, ""},
-		{"InterfaceAnnounceMessage", Type, 1, ""},
-		{"InterfaceAnnounceMessage.Header", Field, 1, ""},
-		{"InterfaceInfo", Type, 0, ""},
-		{"InterfaceInfo.Address", Field, 0, ""},
-		{"InterfaceInfo.BroadcastAddress", Field, 0, ""},
-		{"InterfaceInfo.Flags", Field, 0, ""},
-		{"InterfaceInfo.Netmask", Field, 0, ""},
-		{"InterfaceMessage", Type, 0, ""},
-		{"InterfaceMessage.Data", Field, 0, ""},
-		{"InterfaceMessage.Header", Field, 0, ""},
-		{"InterfaceMulticastAddrMessage", Type, 0, ""},
-		{"InterfaceMulticastAddrMessage.Data", Field, 0, ""},
-		{"InterfaceMulticastAddrMessage.Header", Field, 0, ""},
-		{"InvalidHandle", Const, 0, ""},
-		{"Ioperm", Func, 0, "func(from int, num int, on int) (err error)"},
-		{"Iopl", Func, 0, "func(level int) (err error)"},
-		{"Iovec", Type, 0, ""},
-		{"Iovec.Base", Field, 0, ""},
-		{"Iovec.Len", Field, 0, ""},
-		{"IpAdapterInfo", Type, 0, ""},
-		{"IpAdapterInfo.AdapterName", Field, 0, ""},
-		{"IpAdapterInfo.Address", Field, 0, ""},
-		{"IpAdapterInfo.AddressLength", Field, 0, ""},
-		{"IpAdapterInfo.ComboIndex", Field, 0, ""},
-		{"IpAdapterInfo.CurrentIpAddress", Field, 0, ""},
-		{"IpAdapterInfo.Description", Field, 0, ""},
-		{"IpAdapterInfo.DhcpEnabled", Field, 0, ""},
-		{"IpAdapterInfo.DhcpServer", Field, 0, ""},
-		{"IpAdapterInfo.GatewayList", Field, 0, ""},
-		{"IpAdapterInfo.HaveWins", Field, 0, ""},
-		{"IpAdapterInfo.Index", Field, 0, ""},
-		{"IpAdapterInfo.IpAddressList", Field, 0, ""},
-		{"IpAdapterInfo.LeaseExpires", Field, 0, ""},
-		{"IpAdapterInfo.LeaseObtained", Field, 0, ""},
-		{"IpAdapterInfo.Next", Field, 0, ""},
-		{"IpAdapterInfo.PrimaryWinsServer", Field, 0, ""},
-		{"IpAdapterInfo.SecondaryWinsServer", Field, 0, ""},
-		{"IpAdapterInfo.Type", Field, 0, ""},
-		{"IpAddrString", Type, 0, ""},
-		{"IpAddrString.Context", Field, 0, ""},
-		{"IpAddrString.IpAddress", Field, 0, ""},
-		{"IpAddrString.IpMask", Field, 0, ""},
-		{"IpAddrString.Next", Field, 0, ""},
-		{"IpAddressString", Type, 0, ""},
-		{"IpAddressString.String", Field, 0, ""},
-		{"IpMaskString", Type, 0, ""},
-		{"IpMaskString.String", Field, 2, ""},
-		{"Issetugid", Func, 0, ""},
-		{"KEY_ALL_ACCESS", Const, 0, ""},
-		{"KEY_CREATE_LINK", Const, 0, ""},
-		{"KEY_CREATE_SUB_KEY", Const, 0, ""},
-		{"KEY_ENUMERATE_SUB_KEYS", Const, 0, ""},
-		{"KEY_EXECUTE", Const, 0, ""},
-		{"KEY_NOTIFY", Const, 0, ""},
-		{"KEY_QUERY_VALUE", Const, 0, ""},
-		{"KEY_READ", Const, 0, ""},
-		{"KEY_SET_VALUE", Const, 0, ""},
-		{"KEY_WOW64_32KEY", Const, 0, ""},
-		{"KEY_WOW64_64KEY", Const, 0, ""},
-		{"KEY_WRITE", Const, 0, ""},
-		{"Kevent", Func, 0, ""},
-		{"Kevent_t", Type, 0, ""},
-		{"Kevent_t.Data", Field, 0, ""},
-		{"Kevent_t.Fflags", Field, 0, ""},
-		{"Kevent_t.Filter", Field, 0, ""},
-		{"Kevent_t.Flags", Field, 0, ""},
-		{"Kevent_t.Ident", Field, 0, ""},
-		{"Kevent_t.Pad_cgo_0", Field, 2, ""},
-		{"Kevent_t.Udata", Field, 0, ""},
-		{"Kill", Func, 0, "func(pid int, sig Signal) (err error)"},
-		{"Klogctl", Func, 0, "func(typ int, buf []byte) (n int, err error)"},
-		{"Kqueue", Func, 0, ""},
-		{"LANG_ENGLISH", Const, 0, ""},
-		{"LAYERED_PROTOCOL", Const, 2, ""},
-		{"LCNT_OVERLOAD_FLUSH", Const, 1, ""},
-		{"LINUX_REBOOT_CMD_CAD_OFF", Const, 0, ""},
-		{"LINUX_REBOOT_CMD_CAD_ON", Const, 0, ""},
-		{"LINUX_REBOOT_CMD_HALT", Const, 0, ""},
-		{"LINUX_REBOOT_CMD_KEXEC", Const, 0, ""},
-		{"LINUX_REBOOT_CMD_POWER_OFF", Const, 0, ""},
-		{"LINUX_REBOOT_CMD_RESTART", Const, 0, ""},
-		{"LINUX_REBOOT_CMD_RESTART2", Const, 0, ""},
-		{"LINUX_REBOOT_CMD_SW_SUSPEND", Const, 0, ""},
-		{"LINUX_REBOOT_MAGIC1", Const, 0, ""},
-		{"LINUX_REBOOT_MAGIC2", Const, 0, ""},
-		{"LOCK_EX", Const, 0, ""},
-		{"LOCK_NB", Const, 0, ""},
-		{"LOCK_SH", Const, 0, ""},
-		{"LOCK_UN", Const, 0, ""},
-		{"LazyDLL", Type, 0, ""},
-		{"LazyDLL.Name", Field, 0, ""},
-		{"LazyProc", Type, 0, ""},
-		{"LazyProc.Name", Field, 0, ""},
-		{"Lchown", Func, 0, "func(path string, uid int, gid int) (err error)"},
-		{"Linger", Type, 0, ""},
-		{"Linger.Linger", Field, 0, ""},
-		{"Linger.Onoff", Field, 0, ""},
-		{"Link", Func, 0, "func(oldpath string, newpath string) (err error)"},
-		{"Listen", Func, 0, "func(s int, n int) (err error)"},
-		{"Listxattr", Func, 1, "func(path string, dest []byte) (sz int, err error)"},
-		{"LoadCancelIoEx", Func, 1, ""},
-		{"LoadConnectEx", Func, 1, ""},
-		{"LoadCreateSymbolicLink", Func, 4, ""},
-		{"LoadDLL", Func, 0, ""},
-		{"LoadGetAddrInfo", Func, 1, ""},
-		{"LoadLibrary", Func, 0, ""},
-		{"LoadSetFileCompletionNotificationModes", Func, 2, ""},
-		{"LocalFree", Func, 0, ""},
-		{"Log2phys_t", Type, 0, ""},
-		{"Log2phys_t.Contigbytes", Field, 0, ""},
-		{"Log2phys_t.Devoffset", Field, 0, ""},
-		{"Log2phys_t.Flags", Field, 0, ""},
-		{"LookupAccountName", Func, 0, ""},
-		{"LookupAccountSid", Func, 0, ""},
-		{"LookupSID", Func, 0, ""},
-		{"LsfJump", Func, 0, "func(code int, k int, jt int, jf int) *SockFilter"},
-		{"LsfSocket", Func, 0, "func(ifindex int, proto int) (int, error)"},
-		{"LsfStmt", Func, 0, "func(code int, k int) *SockFilter"},
-		{"Lstat", Func, 0, "func(path string, stat *Stat_t) (err error)"},
-		{"MADV_AUTOSYNC", Const, 1, ""},
-		{"MADV_CAN_REUSE", Const, 0, ""},
-		{"MADV_CORE", Const, 1, ""},
-		{"MADV_DOFORK", Const, 0, ""},
-		{"MADV_DONTFORK", Const, 0, ""},
-		{"MADV_DONTNEED", Const, 0, ""},
-		{"MADV_FREE", Const, 0, ""},
-		{"MADV_FREE_REUSABLE", Const, 0, ""},
-		{"MADV_FREE_REUSE", Const, 0, ""},
-		{"MADV_HUGEPAGE", Const, 0, ""},
-		{"MADV_HWPOISON", Const, 0, ""},
-		{"MADV_MERGEABLE", Const, 0, ""},
-		{"MADV_NOCORE", Const, 1, ""},
-		{"MADV_NOHUGEPAGE", Const, 0, ""},
-		{"MADV_NORMAL", Const, 0, ""},
-		{"MADV_NOSYNC", Const, 1, ""},
-		{"MADV_PROTECT", Const, 1, ""},
-		{"MADV_RANDOM", Const, 0, ""},
-		{"MADV_REMOVE", Const, 0, ""},
-		{"MADV_SEQUENTIAL", Const, 0, ""},
-		{"MADV_SPACEAVAIL", Const, 3, ""},
-		{"MADV_UNMERGEABLE", Const, 0, ""},
-		{"MADV_WILLNEED", Const, 0, ""},
-		{"MADV_ZERO_WIRED_PAGES", Const, 0, ""},
-		{"MAP_32BIT", Const, 0, ""},
-		{"MAP_ALIGNED_SUPER", Const, 3, ""},
-		{"MAP_ALIGNMENT_16MB", Const, 3, ""},
-		{"MAP_ALIGNMENT_1TB", Const, 3, ""},
-		{"MAP_ALIGNMENT_256TB", Const, 3, ""},
-		{"MAP_ALIGNMENT_4GB", Const, 3, ""},
-		{"MAP_ALIGNMENT_64KB", Const, 3, ""},
-		{"MAP_ALIGNMENT_64PB", Const, 3, ""},
-		{"MAP_ALIGNMENT_MASK", Const, 3, ""},
-		{"MAP_ALIGNMENT_SHIFT", Const, 3, ""},
-		{"MAP_ANON", Const, 0, ""},
-		{"MAP_ANONYMOUS", Const, 0, ""},
-		{"MAP_COPY", Const, 0, ""},
-		{"MAP_DENYWRITE", Const, 0, ""},
-		{"MAP_EXECUTABLE", Const, 0, ""},
-		{"MAP_FILE", Const, 0, ""},
-		{"MAP_FIXED", Const, 0, ""},
-		{"MAP_FLAGMASK", Const, 3, ""},
-		{"MAP_GROWSDOWN", Const, 0, ""},
-		{"MAP_HASSEMAPHORE", Const, 0, ""},
-		{"MAP_HUGETLB", Const, 0, ""},
-		{"MAP_INHERIT", Const, 3, ""},
-		{"MAP_INHERIT_COPY", Const, 3, ""},
-		{"MAP_INHERIT_DEFAULT", Const, 3, ""},
-		{"MAP_INHERIT_DONATE_COPY", Const, 3, ""},
-		{"MAP_INHERIT_NONE", Const, 3, ""},
-		{"MAP_INHERIT_SHARE", Const, 3, ""},
-		{"MAP_JIT", Const, 0, ""},
-		{"MAP_LOCKED", Const, 0, ""},
-		{"MAP_NOCACHE", Const, 0, ""},
-		{"MAP_NOCORE", Const, 1, ""},
-		{"MAP_NOEXTEND", Const, 0, ""},
-		{"MAP_NONBLOCK", Const, 0, ""},
-		{"MAP_NORESERVE", Const, 0, ""},
-		{"MAP_NOSYNC", Const, 1, ""},
-		{"MAP_POPULATE", Const, 0, ""},
-		{"MAP_PREFAULT_READ", Const, 1, ""},
-		{"MAP_PRIVATE", Const, 0, ""},
-		{"MAP_RENAME", Const, 0, ""},
-		{"MAP_RESERVED0080", Const, 0, ""},
-		{"MAP_RESERVED0100", Const, 1, ""},
-		{"MAP_SHARED", Const, 0, ""},
-		{"MAP_STACK", Const, 0, ""},
-		{"MAP_TRYFIXED", Const, 3, ""},
-		{"MAP_TYPE", Const, 0, ""},
-		{"MAP_WIRED", Const, 3, ""},
-		{"MAXIMUM_REPARSE_DATA_BUFFER_SIZE", Const, 4, ""},
-		{"MAXLEN_IFDESCR", Const, 0, ""},
-		{"MAXLEN_PHYSADDR", Const, 0, ""},
-		{"MAX_ADAPTER_ADDRESS_LENGTH", Const, 0, ""},
-		{"MAX_ADAPTER_DESCRIPTION_LENGTH", Const, 0, ""},
-		{"MAX_ADAPTER_NAME_LENGTH", Const, 0, ""},
-		{"MAX_COMPUTERNAME_LENGTH", Const, 0, ""},
-		{"MAX_INTERFACE_NAME_LEN", Const, 0, ""},
-		{"MAX_LONG_PATH", Const, 0, ""},
-		{"MAX_PATH", Const, 0, ""},
-		{"MAX_PROTOCOL_CHAIN", Const, 2, ""},
-		{"MCL_CURRENT", Const, 0, ""},
-		{"MCL_FUTURE", Const, 0, ""},
-		{"MNT_DETACH", Const, 0, ""},
-		{"MNT_EXPIRE", Const, 0, ""},
-		{"MNT_FORCE", Const, 0, ""},
-		{"MSG_BCAST", Const, 1, ""},
-		{"MSG_CMSG_CLOEXEC", Const, 0, ""},
-		{"MSG_COMPAT", Const, 0, ""},
-		{"MSG_CONFIRM", Const, 0, ""},
-		{"MSG_CONTROLMBUF", Const, 1, ""},
-		{"MSG_CTRUNC", Const, 0, ""},
-		{"MSG_DONTROUTE", Const, 0, ""},
-		{"MSG_DONTWAIT", Const, 0, ""},
-		{"MSG_EOF", Const, 0, ""},
-		{"MSG_EOR", Const, 0, ""},
-		{"MSG_ERRQUEUE", Const, 0, ""},
-		{"MSG_FASTOPEN", Const, 1, ""},
-		{"MSG_FIN", Const, 0, ""},
-		{"MSG_FLUSH", Const, 0, ""},
-		{"MSG_HAVEMORE", Const, 0, ""},
-		{"MSG_HOLD", Const, 0, ""},
-		{"MSG_IOVUSRSPACE", Const, 1, ""},
-		{"MSG_LENUSRSPACE", Const, 1, ""},
-		{"MSG_MCAST", Const, 1, ""},
-		{"MSG_MORE", Const, 0, ""},
-		{"MSG_NAMEMBUF", Const, 1, ""},
-		{"MSG_NBIO", Const, 0, ""},
-		{"MSG_NEEDSA", Const, 0, ""},
-		{"MSG_NOSIGNAL", Const, 0, ""},
-		{"MSG_NOTIFICATION", Const, 0, ""},
-		{"MSG_OOB", Const, 0, ""},
-		{"MSG_PEEK", Const, 0, ""},
-		{"MSG_PROXY", Const, 0, ""},
-		{"MSG_RCVMORE", Const, 0, ""},
-		{"MSG_RST", Const, 0, ""},
-		{"MSG_SEND", Const, 0, ""},
-		{"MSG_SYN", Const, 0, ""},
-		{"MSG_TRUNC", Const, 0, ""},
-		{"MSG_TRYHARD", Const, 0, ""},
-		{"MSG_USERFLAGS", Const, 1, ""},
-		{"MSG_WAITALL", Const, 0, ""},
-		{"MSG_WAITFORONE", Const, 0, ""},
-		{"MSG_WAITSTREAM", Const, 0, ""},
-		{"MS_ACTIVE", Const, 0, ""},
-		{"MS_ASYNC", Const, 0, ""},
-		{"MS_BIND", Const, 0, ""},
-		{"MS_DEACTIVATE", Const, 0, ""},
-		{"MS_DIRSYNC", Const, 0, ""},
-		{"MS_INVALIDATE", Const, 0, ""},
-		{"MS_I_VERSION", Const, 0, ""},
-		{"MS_KERNMOUNT", Const, 0, ""},
-		{"MS_KILLPAGES", Const, 0, ""},
-		{"MS_MANDLOCK", Const, 0, ""},
-		{"MS_MGC_MSK", Const, 0, ""},
-		{"MS_MGC_VAL", Const, 0, ""},
-		{"MS_MOVE", Const, 0, ""},
-		{"MS_NOATIME", Const, 0, ""},
-		{"MS_NODEV", Const, 0, ""},
-		{"MS_NODIRATIME", Const, 0, ""},
-		{"MS_NOEXEC", Const, 0, ""},
-		{"MS_NOSUID", Const, 0, ""},
-		{"MS_NOUSER", Const, 0, ""},
-		{"MS_POSIXACL", Const, 0, ""},
-		{"MS_PRIVATE", Const, 0, ""},
-		{"MS_RDONLY", Const, 0, ""},
-		{"MS_REC", Const, 0, ""},
-		{"MS_RELATIME", Const, 0, ""},
-		{"MS_REMOUNT", Const, 0, ""},
-		{"MS_RMT_MASK", Const, 0, ""},
-		{"MS_SHARED", Const, 0, ""},
-		{"MS_SILENT", Const, 0, ""},
-		{"MS_SLAVE", Const, 0, ""},
-		{"MS_STRICTATIME", Const, 0, ""},
-		{"MS_SYNC", Const, 0, ""},
-		{"MS_SYNCHRONOUS", Const, 0, ""},
-		{"MS_UNBINDABLE", Const, 0, ""},
-		{"Madvise", Func, 0, "func(b []byte, advice int) (err error)"},
-		{"MapViewOfFile", Func, 0, ""},
-		{"MaxTokenInfoClass", Const, 0, ""},
-		{"Mclpool", Type, 2, ""},
-		{"Mclpool.Alive", Field, 2, ""},
-		{"Mclpool.Cwm", Field, 2, ""},
-		{"Mclpool.Grown", Field, 2, ""},
-		{"Mclpool.Hwm", Field, 2, ""},
-		{"Mclpool.Lwm", Field, 2, ""},
-		{"MibIfRow", Type, 0, ""},
-		{"MibIfRow.AdminStatus", Field, 0, ""},
-		{"MibIfRow.Descr", Field, 0, ""},
-		{"MibIfRow.DescrLen", Field, 0, ""},
-		{"MibIfRow.InDiscards", Field, 0, ""},
-		{"MibIfRow.InErrors", Field, 0, ""},
-		{"MibIfRow.InNUcastPkts", Field, 0, ""},
-		{"MibIfRow.InOctets", Field, 0, ""},
-		{"MibIfRow.InUcastPkts", Field, 0, ""},
-		{"MibIfRow.InUnknownProtos", Field, 0, ""},
-		{"MibIfRow.Index", Field, 0, ""},
-		{"MibIfRow.LastChange", Field, 0, ""},
-		{"MibIfRow.Mtu", Field, 0, ""},
-		{"MibIfRow.Name", Field, 0, ""},
-		{"MibIfRow.OperStatus", Field, 0, ""},
-		{"MibIfRow.OutDiscards", Field, 0, ""},
-		{"MibIfRow.OutErrors", Field, 0, ""},
-		{"MibIfRow.OutNUcastPkts", Field, 0, ""},
-		{"MibIfRow.OutOctets", Field, 0, ""},
-		{"MibIfRow.OutQLen", Field, 0, ""},
-		{"MibIfRow.OutUcastPkts", Field, 0, ""},
-		{"MibIfRow.PhysAddr", Field, 0, ""},
-		{"MibIfRow.PhysAddrLen", Field, 0, ""},
-		{"MibIfRow.Speed", Field, 0, ""},
-		{"MibIfRow.Type", Field, 0, ""},
-		{"Mkdir", Func, 0, "func(path string, mode uint32) (err error)"},
-		{"Mkdirat", Func, 0, "func(dirfd int, path string, mode uint32) (err error)"},
-		{"Mkfifo", Func, 0, "func(path string, mode uint32) (err error)"},
-		{"Mknod", Func, 0, "func(path string, mode uint32, dev int) (err error)"},
-		{"Mknodat", Func, 0, "func(dirfd int, path string, mode uint32, dev int) (err error)"},
-		{"Mlock", Func, 0, "func(b []byte) (err error)"},
-		{"Mlockall", Func, 0, "func(flags int) (err error)"},
-		{"Mmap", Func, 0, "func(fd int, offset int64, length int, prot int, flags int) (data []byte, err error)"},
-		{"Mount", Func, 0, "func(source string, target string, fstype string, flags uintptr, data string) (err error)"},
-		{"MoveFile", Func, 0, ""},
-		{"Mprotect", Func, 0, "func(b []byte, prot int) (err error)"},
-		{"Msghdr", Type, 0, ""},
-		{"Msghdr.Control", Field, 0, ""},
-		{"Msghdr.Controllen", Field, 0, ""},
-		{"Msghdr.Flags", Field, 0, ""},
-		{"Msghdr.Iov", Field, 0, ""},
-		{"Msghdr.Iovlen", Field, 0, ""},
-		{"Msghdr.Name", Field, 0, ""},
-		{"Msghdr.Namelen", Field, 0, ""},
-		{"Msghdr.Pad_cgo_0", Field, 0, ""},
-		{"Msghdr.Pad_cgo_1", Field, 0, ""},
-		{"Munlock", Func, 0, "func(b []byte) (err error)"},
-		{"Munlockall", Func, 0, "func() (err error)"},
-		{"Munmap", Func, 0, "func(b []byte) (err error)"},
-		{"MustLoadDLL", Func, 0, ""},
-		{"NAME_MAX", Const, 0, ""},
-		{"NETLINK_ADD_MEMBERSHIP", Const, 0, ""},
-		{"NETLINK_AUDIT", Const, 0, ""},
-		{"NETLINK_BROADCAST_ERROR", Const, 0, ""},
-		{"NETLINK_CONNECTOR", Const, 0, ""},
-		{"NETLINK_DNRTMSG", Const, 0, ""},
-		{"NETLINK_DROP_MEMBERSHIP", Const, 0, ""},
-		{"NETLINK_ECRYPTFS", Const, 0, ""},
-		{"NETLINK_FIB_LOOKUP", Const, 0, ""},
-		{"NETLINK_FIREWALL", Const, 0, ""},
-		{"NETLINK_GENERIC", Const, 0, ""},
-		{"NETLINK_INET_DIAG", Const, 0, ""},
-		{"NETLINK_IP6_FW", Const, 0, ""},
-		{"NETLINK_ISCSI", Const, 0, ""},
-		{"NETLINK_KOBJECT_UEVENT", Const, 0, ""},
-		{"NETLINK_NETFILTER", Const, 0, ""},
-		{"NETLINK_NFLOG", Const, 0, ""},
-		{"NETLINK_NO_ENOBUFS", Const, 0, ""},
-		{"NETLINK_PKTINFO", Const, 0, ""},
-		{"NETLINK_RDMA", Const, 0, ""},
-		{"NETLINK_ROUTE", Const, 0, ""},
-		{"NETLINK_SCSITRANSPORT", Const, 0, ""},
-		{"NETLINK_SELINUX", Const, 0, ""},
-		{"NETLINK_UNUSED", Const, 0, ""},
-		{"NETLINK_USERSOCK", Const, 0, ""},
-		{"NETLINK_XFRM", Const, 0, ""},
-		{"NET_RT_DUMP", Const, 0, ""},
-		{"NET_RT_DUMP2", Const, 0, ""},
-		{"NET_RT_FLAGS", Const, 0, ""},
-		{"NET_RT_IFLIST", Const, 0, ""},
-		{"NET_RT_IFLIST2", Const, 0, ""},
-		{"NET_RT_IFLISTL", Const, 1, ""},
-		{"NET_RT_IFMALIST", Const, 0, ""},
-		{"NET_RT_MAXID", Const, 0, ""},
-		{"NET_RT_OIFLIST", Const, 1, ""},
-		{"NET_RT_OOIFLIST", Const, 1, ""},
-		{"NET_RT_STAT", Const, 0, ""},
-		{"NET_RT_STATS", Const, 1, ""},
-		{"NET_RT_TABLE", Const, 1, ""},
-		{"NET_RT_TRASH", Const, 0, ""},
-		{"NLA_ALIGNTO", Const, 0, ""},
-		{"NLA_F_NESTED", Const, 0, ""},
-		{"NLA_F_NET_BYTEORDER", Const, 0, ""},
-		{"NLA_HDRLEN", Const, 0, ""},
-		{"NLMSG_ALIGNTO", Const, 0, ""},
-		{"NLMSG_DONE", Const, 0, ""},
-		{"NLMSG_ERROR", Const, 0, ""},
-		{"NLMSG_HDRLEN", Const, 0, ""},
-		{"NLMSG_MIN_TYPE", Const, 0, ""},
-		{"NLMSG_NOOP", Const, 0, ""},
-		{"NLMSG_OVERRUN", Const, 0, ""},
-		{"NLM_F_ACK", Const, 0, ""},
-		{"NLM_F_APPEND", Const, 0, ""},
-		{"NLM_F_ATOMIC", Const, 0, ""},
-		{"NLM_F_CREATE", Const, 0, ""},
-		{"NLM_F_DUMP", Const, 0, ""},
-		{"NLM_F_ECHO", Const, 0, ""},
-		{"NLM_F_EXCL", Const, 0, ""},
-		{"NLM_F_MATCH", Const, 0, ""},
-		{"NLM_F_MULTI", Const, 0, ""},
-		{"NLM_F_REPLACE", Const, 0, ""},
-		{"NLM_F_REQUEST", Const, 0, ""},
-		{"NLM_F_ROOT", Const, 0, ""},
-		{"NOFLSH", Const, 0, ""},
-		{"NOTE_ABSOLUTE", Const, 0, ""},
-		{"NOTE_ATTRIB", Const, 0, ""},
-		{"NOTE_BACKGROUND", Const, 16, ""},
-		{"NOTE_CHILD", Const, 0, ""},
-		{"NOTE_CRITICAL", Const, 16, ""},
-		{"NOTE_DELETE", Const, 0, ""},
-		{"NOTE_EOF", Const, 1, ""},
-		{"NOTE_EXEC", Const, 0, ""},
-		{"NOTE_EXIT", Const, 0, ""},
-		{"NOTE_EXITSTATUS", Const, 0, ""},
-		{"NOTE_EXIT_CSERROR", Const, 16, ""},
-		{"NOTE_EXIT_DECRYPTFAIL", Const, 16, ""},
-		{"NOTE_EXIT_DETAIL", Const, 16, ""},
-		{"NOTE_EXIT_DETAIL_MASK", Const, 16, ""},
-		{"NOTE_EXIT_MEMORY", Const, 16, ""},
-		{"NOTE_EXIT_REPARENTED", Const, 16, ""},
-		{"NOTE_EXTEND", Const, 0, ""},
-		{"NOTE_FFAND", Const, 0, ""},
-		{"NOTE_FFCOPY", Const, 0, ""},
-		{"NOTE_FFCTRLMASK", Const, 0, ""},
-		{"NOTE_FFLAGSMASK", Const, 0, ""},
-		{"NOTE_FFNOP", Const, 0, ""},
-		{"NOTE_FFOR", Const, 0, ""},
-		{"NOTE_FORK", Const, 0, ""},
-		{"NOTE_LEEWAY", Const, 16, ""},
-		{"NOTE_LINK", Const, 0, ""},
-		{"NOTE_LOWAT", Const, 0, ""},
-		{"NOTE_NONE", Const, 0, ""},
-		{"NOTE_NSECONDS", Const, 0, ""},
-		{"NOTE_PCTRLMASK", Const, 0, ""},
-		{"NOTE_PDATAMASK", Const, 0, ""},
-		{"NOTE_REAP", Const, 0, ""},
-		{"NOTE_RENAME", Const, 0, ""},
-		{"NOTE_RESOURCEEND", Const, 0, ""},
-		{"NOTE_REVOKE", Const, 0, ""},
-		{"NOTE_SECONDS", Const, 0, ""},
-		{"NOTE_SIGNAL", Const, 0, ""},
-		{"NOTE_TRACK", Const, 0, ""},
-		{"NOTE_TRACKERR", Const, 0, ""},
-		{"NOTE_TRIGGER", Const, 0, ""},
-		{"NOTE_TRUNCATE", Const, 1, ""},
-		{"NOTE_USECONDS", Const, 0, ""},
-		{"NOTE_VM_ERROR", Const, 0, ""},
-		{"NOTE_VM_PRESSURE", Const, 0, ""},
-		{"NOTE_VM_PRESSURE_SUDDEN_TERMINATE", Const, 0, ""},
-		{"NOTE_VM_PRESSURE_TERMINATE", Const, 0, ""},
-		{"NOTE_WRITE", Const, 0, ""},
-		{"NameCanonical", Const, 0, ""},
-		{"NameCanonicalEx", Const, 0, ""},
-		{"NameDisplay", Const, 0, ""},
-		{"NameDnsDomain", Const, 0, ""},
-		{"NameFullyQualifiedDN", Const, 0, ""},
-		{"NameSamCompatible", Const, 0, ""},
-		{"NameServicePrincipal", Const, 0, ""},
-		{"NameUniqueId", Const, 0, ""},
-		{"NameUnknown", Const, 0, ""},
-		{"NameUserPrincipal", Const, 0, ""},
-		{"Nanosleep", Func, 0, "func(time *Timespec, leftover *Timespec) (err error)"},
-		{"NetApiBufferFree", Func, 0, ""},
-		{"NetGetJoinInformation", Func, 2, ""},
-		{"NetSetupDomainName", Const, 2, ""},
-		{"NetSetupUnjoined", Const, 2, ""},
-		{"NetSetupUnknownStatus", Const, 2, ""},
-		{"NetSetupWorkgroupName", Const, 2, ""},
-		{"NetUserGetInfo", Func, 0, ""},
-		{"NetlinkMessage", Type, 0, ""},
-		{"NetlinkMessage.Data", Field, 0, ""},
-		{"NetlinkMessage.Header", Field, 0, ""},
-		{"NetlinkRIB", Func, 0, "func(proto int, family int) ([]byte, error)"},
-		{"NetlinkRouteAttr", Type, 0, ""},
-		{"NetlinkRouteAttr.Attr", Field, 0, ""},
-		{"NetlinkRouteAttr.Value", Field, 0, ""},
-		{"NetlinkRouteRequest", Type, 0, ""},
-		{"NetlinkRouteRequest.Data", Field, 0, ""},
-		{"NetlinkRouteRequest.Header", Field, 0, ""},
-		{"NewCallback", Func, 0, ""},
-		{"NewCallbackCDecl", Func, 3, ""},
-		{"NewLazyDLL", Func, 0, ""},
-		{"NlAttr", Type, 0, ""},
-		{"NlAttr.Len", Field, 0, ""},
-		{"NlAttr.Type", Field, 0, ""},
-		{"NlMsgerr", Type, 0, ""},
-		{"NlMsgerr.Error", Field, 0, ""},
-		{"NlMsgerr.Msg", Field, 0, ""},
-		{"NlMsghdr", Type, 0, ""},
-		{"NlMsghdr.Flags", Field, 0, ""},
-		{"NlMsghdr.Len", Field, 0, ""},
-		{"NlMsghdr.Pid", Field, 0, ""},
-		{"NlMsghdr.Seq", Field, 0, ""},
-		{"NlMsghdr.Type", Field, 0, ""},
-		{"NsecToFiletime", Func, 0, ""},
-		{"NsecToTimespec", Func, 0, "func(nsec int64) Timespec"},
-		{"NsecToTimeval", Func, 0, "func(nsec int64) Timeval"},
-		{"Ntohs", Func, 0, ""},
-		{"OCRNL", Const, 0, ""},
-		{"OFDEL", Const, 0, ""},
-		{"OFILL", Const, 0, ""},
-		{"OFIOGETBMAP", Const, 1, ""},
-		{"OID_PKIX_KP_SERVER_AUTH", Var, 0, ""},
-		{"OID_SERVER_GATED_CRYPTO", Var, 0, ""},
-		{"OID_SGC_NETSCAPE", Var, 0, ""},
-		{"OLCUC", Const, 0, ""},
-		{"ONLCR", Const, 0, ""},
-		{"ONLRET", Const, 0, ""},
-		{"ONOCR", Const, 0, ""},
-		{"ONOEOT", Const, 1, ""},
-		{"OPEN_ALWAYS", Const, 0, ""},
-		{"OPEN_EXISTING", Const, 0, ""},
-		{"OPOST", Const, 0, ""},
-		{"O_ACCMODE", Const, 0, ""},
-		{"O_ALERT", Const, 0, ""},
-		{"O_ALT_IO", Const, 1, ""},
-		{"O_APPEND", Const, 0, ""},
-		{"O_ASYNC", Const, 0, ""},
-		{"O_CLOEXEC", Const, 0, ""},
-		{"O_CREAT", Const, 0, ""},
-		{"O_DIRECT", Const, 0, ""},
-		{"O_DIRECTORY", Const, 0, ""},
-		{"O_DP_GETRAWENCRYPTED", Const, 16, ""},
-		{"O_DSYNC", Const, 0, ""},
-		{"O_EVTONLY", Const, 0, ""},
-		{"O_EXCL", Const, 0, ""},
-		{"O_EXEC", Const, 0, ""},
-		{"O_EXLOCK", Const, 0, ""},
-		{"O_FSYNC", Const, 0, ""},
-		{"O_LARGEFILE", Const, 0, ""},
-		{"O_NDELAY", Const, 0, ""},
-		{"O_NOATIME", Const, 0, ""},
-		{"O_NOCTTY", Const, 0, ""},
-		{"O_NOFOLLOW", Const, 0, ""},
-		{"O_NONBLOCK", Const, 0, ""},
-		{"O_NOSIGPIPE", Const, 1, ""},
-		{"O_POPUP", Const, 0, ""},
-		{"O_RDONLY", Const, 0, ""},
-		{"O_RDWR", Const, 0, ""},
-		{"O_RSYNC", Const, 0, ""},
-		{"O_SHLOCK", Const, 0, ""},
-		{"O_SYMLINK", Const, 0, ""},
-		{"O_SYNC", Const, 0, ""},
-		{"O_TRUNC", Const, 0, ""},
-		{"O_TTY_INIT", Const, 0, ""},
-		{"O_WRONLY", Const, 0, ""},
-		{"Open", Func, 0, "func(path string, mode int, perm uint32) (fd int, err error)"},
-		{"OpenCurrentProcessToken", Func, 0, ""},
-		{"OpenProcess", Func, 0, ""},
-		{"OpenProcessToken", Func, 0, ""},
-		{"Openat", Func, 0, "func(dirfd int, path string, flags int, mode uint32) (fd int, err error)"},
-		{"Overlapped", Type, 0, ""},
-		{"Overlapped.HEvent", Field, 0, ""},
-		{"Overlapped.Internal", Field, 0, ""},
-		{"Overlapped.InternalHigh", Field, 0, ""},
-		{"Overlapped.Offset", Field, 0, ""},
-		{"Overlapped.OffsetHigh", Field, 0, ""},
-		{"PACKET_ADD_MEMBERSHIP", Const, 0, ""},
-		{"PACKET_BROADCAST", Const, 0, ""},
-		{"PACKET_DROP_MEMBERSHIP", Const, 0, ""},
-		{"PACKET_FASTROUTE", Const, 0, ""},
-		{"PACKET_HOST", Const, 0, ""},
-		{"PACKET_LOOPBACK", Const, 0, ""},
-		{"PACKET_MR_ALLMULTI", Const, 0, ""},
-		{"PACKET_MR_MULTICAST", Const, 0, ""},
-		{"PACKET_MR_PROMISC", Const, 0, ""},
-		{"PACKET_MULTICAST", Const, 0, ""},
-		{"PACKET_OTHERHOST", Const, 0, ""},
-		{"PACKET_OUTGOING", Const, 0, ""},
-		{"PACKET_RECV_OUTPUT", Const, 0, ""},
-		{"PACKET_RX_RING", Const, 0, ""},
-		{"PACKET_STATISTICS", Const, 0, ""},
-		{"PAGE_EXECUTE_READ", Const, 0, ""},
-		{"PAGE_EXECUTE_READWRITE", Const, 0, ""},
-		{"PAGE_EXECUTE_WRITECOPY", Const, 0, ""},
-		{"PAGE_READONLY", Const, 0, ""},
-		{"PAGE_READWRITE", Const, 0, ""},
-		{"PAGE_WRITECOPY", Const, 0, ""},
-		{"PARENB", Const, 0, ""},
-		{"PARMRK", Const, 0, ""},
-		{"PARODD", Const, 0, ""},
-		{"PENDIN", Const, 0, ""},
-		{"PFL_HIDDEN", Const, 2, ""},
-		{"PFL_MATCHES_PROTOCOL_ZERO", Const, 2, ""},
-		{"PFL_MULTIPLE_PROTO_ENTRIES", Const, 2, ""},
-		{"PFL_NETWORKDIRECT_PROVIDER", Const, 2, ""},
-		{"PFL_RECOMMENDED_PROTO_ENTRY", Const, 2, ""},
-		{"PF_FLUSH", Const, 1, ""},
-		{"PKCS_7_ASN_ENCODING", Const, 0, ""},
-		{"PMC5_PIPELINE_FLUSH", Const, 1, ""},
-		{"PRIO_PGRP", Const, 2, ""},
-		{"PRIO_PROCESS", Const, 2, ""},
-		{"PRIO_USER", Const, 2, ""},
-		{"PRI_IOFLUSH", Const, 1, ""},
-		{"PROCESS_QUERY_INFORMATION", Const, 0, ""},
-		{"PROCESS_TERMINATE", Const, 2, ""},
-		{"PROT_EXEC", Const, 0, ""},
-		{"PROT_GROWSDOWN", Const, 0, ""},
-		{"PROT_GROWSUP", Const, 0, ""},
-		{"PROT_NONE", Const, 0, ""},
-		{"PROT_READ", Const, 0, ""},
-		{"PROT_WRITE", Const, 0, ""},
-		{"PROV_DH_SCHANNEL", Const, 0, ""},
-		{"PROV_DSS", Const, 0, ""},
-		{"PROV_DSS_DH", Const, 0, ""},
-		{"PROV_EC_ECDSA_FULL", Const, 0, ""},
-		{"PROV_EC_ECDSA_SIG", Const, 0, ""},
-		{"PROV_EC_ECNRA_FULL", Const, 0, ""},
-		{"PROV_EC_ECNRA_SIG", Const, 0, ""},
-		{"PROV_FORTEZZA", Const, 0, ""},
-		{"PROV_INTEL_SEC", Const, 0, ""},
-		{"PROV_MS_EXCHANGE", Const, 0, ""},
-		{"PROV_REPLACE_OWF", Const, 0, ""},
-		{"PROV_RNG", Const, 0, ""},
-		{"PROV_RSA_AES", Const, 0, ""},
-		{"PROV_RSA_FULL", Const, 0, ""},
-		{"PROV_RSA_SCHANNEL", Const, 0, ""},
-		{"PROV_RSA_SIG", Const, 0, ""},
-		{"PROV_SPYRUS_LYNKS", Const, 0, ""},
-		{"PROV_SSL", Const, 0, ""},
-		{"PR_CAPBSET_DROP", Const, 0, ""},
-		{"PR_CAPBSET_READ", Const, 0, ""},
-		{"PR_CLEAR_SECCOMP_FILTER", Const, 0, ""},
-		{"PR_ENDIAN_BIG", Const, 0, ""},
-		{"PR_ENDIAN_LITTLE", Const, 0, ""},
-		{"PR_ENDIAN_PPC_LITTLE", Const, 0, ""},
-		{"PR_FPEMU_NOPRINT", Const, 0, ""},
-		{"PR_FPEMU_SIGFPE", Const, 0, ""},
-		{"PR_FP_EXC_ASYNC", Const, 0, ""},
-		{"PR_FP_EXC_DISABLED", Const, 0, ""},
-		{"PR_FP_EXC_DIV", Const, 0, ""},
-		{"PR_FP_EXC_INV", Const, 0, ""},
-		{"PR_FP_EXC_NONRECOV", Const, 0, ""},
-		{"PR_FP_EXC_OVF", Const, 0, ""},
-		{"PR_FP_EXC_PRECISE", Const, 0, ""},
-		{"PR_FP_EXC_RES", Const, 0, ""},
-		{"PR_FP_EXC_SW_ENABLE", Const, 0, ""},
-		{"PR_FP_EXC_UND", Const, 0, ""},
-		{"PR_GET_DUMPABLE", Const, 0, ""},
-		{"PR_GET_ENDIAN", Const, 0, ""},
-		{"PR_GET_FPEMU", Const, 0, ""},
-		{"PR_GET_FPEXC", Const, 0, ""},
-		{"PR_GET_KEEPCAPS", Const, 0, ""},
-		{"PR_GET_NAME", Const, 0, ""},
-		{"PR_GET_PDEATHSIG", Const, 0, ""},
-		{"PR_GET_SECCOMP", Const, 0, ""},
-		{"PR_GET_SECCOMP_FILTER", Const, 0, ""},
-		{"PR_GET_SECUREBITS", Const, 0, ""},
-		{"PR_GET_TIMERSLACK", Const, 0, ""},
-		{"PR_GET_TIMING", Const, 0, ""},
-		{"PR_GET_TSC", Const, 0, ""},
-		{"PR_GET_UNALIGN", Const, 0, ""},
-		{"PR_MCE_KILL", Const, 0, ""},
-		{"PR_MCE_KILL_CLEAR", Const, 0, ""},
-		{"PR_MCE_KILL_DEFAULT", Const, 0, ""},
-		{"PR_MCE_KILL_EARLY", Const, 0, ""},
-		{"PR_MCE_KILL_GET", Const, 0, ""},
-		{"PR_MCE_KILL_LATE", Const, 0, ""},
-		{"PR_MCE_KILL_SET", Const, 0, ""},
-		{"PR_SECCOMP_FILTER_EVENT", Const, 0, ""},
-		{"PR_SECCOMP_FILTER_SYSCALL", Const, 0, ""},
-		{"PR_SET_DUMPABLE", Const, 0, ""},
-		{"PR_SET_ENDIAN", Const, 0, ""},
-		{"PR_SET_FPEMU", Const, 0, ""},
-		{"PR_SET_FPEXC", Const, 0, ""},
-		{"PR_SET_KEEPCAPS", Const, 0, ""},
-		{"PR_SET_NAME", Const, 0, ""},
-		{"PR_SET_PDEATHSIG", Const, 0, ""},
-		{"PR_SET_PTRACER", Const, 0, ""},
-		{"PR_SET_SECCOMP", Const, 0, ""},
-		{"PR_SET_SECCOMP_FILTER", Const, 0, ""},
-		{"PR_SET_SECUREBITS", Const, 0, ""},
-		{"PR_SET_TIMERSLACK", Const, 0, ""},
-		{"PR_SET_TIMING", Const, 0, ""},
-		{"PR_SET_TSC", Const, 0, ""},
-		{"PR_SET_UNALIGN", Const, 0, ""},
-		{"PR_TASK_PERF_EVENTS_DISABLE", Const, 0, ""},
-		{"PR_TASK_PERF_EVENTS_ENABLE", Const, 0, ""},
-		{"PR_TIMING_STATISTICAL", Const, 0, ""},
-		{"PR_TIMING_TIMESTAMP", Const, 0, ""},
-		{"PR_TSC_ENABLE", Const, 0, ""},
-		{"PR_TSC_SIGSEGV", Const, 0, ""},
-		{"PR_UNALIGN_NOPRINT", Const, 0, ""},
-		{"PR_UNALIGN_SIGBUS", Const, 0, ""},
-		{"PTRACE_ARCH_PRCTL", Const, 0, ""},
-		{"PTRACE_ATTACH", Const, 0, ""},
-		{"PTRACE_CONT", Const, 0, ""},
-		{"PTRACE_DETACH", Const, 0, ""},
-		{"PTRACE_EVENT_CLONE", Const, 0, ""},
-		{"PTRACE_EVENT_EXEC", Const, 0, ""},
-		{"PTRACE_EVENT_EXIT", Const, 0, ""},
-		{"PTRACE_EVENT_FORK", Const, 0, ""},
-		{"PTRACE_EVENT_VFORK", Const, 0, ""},
-		{"PTRACE_EVENT_VFORK_DONE", Const, 0, ""},
-		{"PTRACE_GETCRUNCHREGS", Const, 0, ""},
-		{"PTRACE_GETEVENTMSG", Const, 0, ""},
-		{"PTRACE_GETFPREGS", Const, 0, ""},
-		{"PTRACE_GETFPXREGS", Const, 0, ""},
-		{"PTRACE_GETHBPREGS", Const, 0, ""},
-		{"PTRACE_GETREGS", Const, 0, ""},
-		{"PTRACE_GETREGSET", Const, 0, ""},
-		{"PTRACE_GETSIGINFO", Const, 0, ""},
-		{"PTRACE_GETVFPREGS", Const, 0, ""},
-		{"PTRACE_GETWMMXREGS", Const, 0, ""},
-		{"PTRACE_GET_THREAD_AREA", Const, 0, ""},
-		{"PTRACE_KILL", Const, 0, ""},
-		{"PTRACE_OLDSETOPTIONS", Const, 0, ""},
-		{"PTRACE_O_MASK", Const, 0, ""},
-		{"PTRACE_O_TRACECLONE", Const, 0, ""},
-		{"PTRACE_O_TRACEEXEC", Const, 0, ""},
-		{"PTRACE_O_TRACEEXIT", Const, 0, ""},
-		{"PTRACE_O_TRACEFORK", Const, 0, ""},
-		{"PTRACE_O_TRACESYSGOOD", Const, 0, ""},
-		{"PTRACE_O_TRACEVFORK", Const, 0, ""},
-		{"PTRACE_O_TRACEVFORKDONE", Const, 0, ""},
-		{"PTRACE_PEEKDATA", Const, 0, ""},
-		{"PTRACE_PEEKTEXT", Const, 0, ""},
-		{"PTRACE_PEEKUSR", Const, 0, ""},
-		{"PTRACE_POKEDATA", Const, 0, ""},
-		{"PTRACE_POKETEXT", Const, 0, ""},
-		{"PTRACE_POKEUSR", Const, 0, ""},
-		{"PTRACE_SETCRUNCHREGS", Const, 0, ""},
-		{"PTRACE_SETFPREGS", Const, 0, ""},
-		{"PTRACE_SETFPXREGS", Const, 0, ""},
-		{"PTRACE_SETHBPREGS", Const, 0, ""},
-		{"PTRACE_SETOPTIONS", Const, 0, ""},
-		{"PTRACE_SETREGS", Const, 0, ""},
-		{"PTRACE_SETREGSET", Const, 0, ""},
-		{"PTRACE_SETSIGINFO", Const, 0, ""},
-		{"PTRACE_SETVFPREGS", Const, 0, ""},
-		{"PTRACE_SETWMMXREGS", Const, 0, ""},
-		{"PTRACE_SET_SYSCALL", Const, 0, ""},
-		{"PTRACE_SET_THREAD_AREA", Const, 0, ""},
-		{"PTRACE_SINGLEBLOCK", Const, 0, ""},
-		{"PTRACE_SINGLESTEP", Const, 0, ""},
-		{"PTRACE_SYSCALL", Const, 0, ""},
-		{"PTRACE_SYSEMU", Const, 0, ""},
-		{"PTRACE_SYSEMU_SINGLESTEP", Const, 0, ""},
-		{"PTRACE_TRACEME", Const, 0, ""},
-		{"PT_ATTACH", Const, 0, ""},
-		{"PT_ATTACHEXC", Const, 0, ""},
-		{"PT_CONTINUE", Const, 0, ""},
-		{"PT_DATA_ADDR", Const, 0, ""},
-		{"PT_DENY_ATTACH", Const, 0, ""},
-		{"PT_DETACH", Const, 0, ""},
-		{"PT_FIRSTMACH", Const, 0, ""},
-		{"PT_FORCEQUOTA", Const, 0, ""},
-		{"PT_KILL", Const, 0, ""},
-		{"PT_MASK", Const, 1, ""},
-		{"PT_READ_D", Const, 0, ""},
-		{"PT_READ_I", Const, 0, ""},
-		{"PT_READ_U", Const, 0, ""},
-		{"PT_SIGEXC", Const, 0, ""},
-		{"PT_STEP", Const, 0, ""},
-		{"PT_TEXT_ADDR", Const, 0, ""},
-		{"PT_TEXT_END_ADDR", Const, 0, ""},
-		{"PT_THUPDATE", Const, 0, ""},
-		{"PT_TRACE_ME", Const, 0, ""},
-		{"PT_WRITE_D", Const, 0, ""},
-		{"PT_WRITE_I", Const, 0, ""},
-		{"PT_WRITE_U", Const, 0, ""},
-		{"ParseDirent", Func, 0, "func(buf []byte, max int, names []string) (consumed int, count int, newnames []string)"},
-		{"ParseNetlinkMessage", Func, 0, "func(b []byte) ([]NetlinkMessage, error)"},
-		{"ParseNetlinkRouteAttr", Func, 0, "func(m *NetlinkMessage) ([]NetlinkRouteAttr, error)"},
-		{"ParseRoutingMessage", Func, 0, ""},
-		{"ParseRoutingSockaddr", Func, 0, ""},
-		{"ParseSocketControlMessage", Func, 0, "func(b []byte) ([]SocketControlMessage, error)"},
-		{"ParseUnixCredentials", Func, 0, "func(m *SocketControlMessage) (*Ucred, error)"},
-		{"ParseUnixRights", Func, 0, "func(m *SocketControlMessage) ([]int, error)"},
-		{"PathMax", Const, 0, ""},
-		{"Pathconf", Func, 0, ""},
-		{"Pause", Func, 0, "func() (err error)"},
-		{"Pipe", Func, 0, "func(p []int) error"},
-		{"Pipe2", Func, 1, "func(p []int, flags int) error"},
-		{"PivotRoot", Func, 0, "func(newroot string, putold string) (err error)"},
-		{"Pointer", Type, 11, ""},
-		{"PostQueuedCompletionStatus", Func, 0, ""},
-		{"Pread", Func, 0, "func(fd int, p []byte, offset int64) (n int, err error)"},
-		{"Proc", Type, 0, ""},
-		{"Proc.Dll", Field, 0, ""},
-		{"Proc.Name", Field, 0, ""},
-		{"ProcAttr", Type, 0, ""},
-		{"ProcAttr.Dir", Field, 0, ""},
-		{"ProcAttr.Env", Field, 0, ""},
-		{"ProcAttr.Files", Field, 0, ""},
-		{"ProcAttr.Sys", Field, 0, ""},
-		{"Process32First", Func, 4, ""},
-		{"Process32Next", Func, 4, ""},
-		{"ProcessEntry32", Type, 4, ""},
-		{"ProcessEntry32.DefaultHeapID", Field, 4, ""},
-		{"ProcessEntry32.ExeFile", Field, 4, ""},
-		{"ProcessEntry32.Flags", Field, 4, ""},
-		{"ProcessEntry32.ModuleID", Field, 4, ""},
-		{"ProcessEntry32.ParentProcessID", Field, 4, ""},
-		{"ProcessEntry32.PriClassBase", Field, 4, ""},
-		{"ProcessEntry32.ProcessID", Field, 4, ""},
-		{"ProcessEntry32.Size", Field, 4, ""},
-		{"ProcessEntry32.Threads", Field, 4, ""},
-		{"ProcessEntry32.Usage", Field, 4, ""},
-		{"ProcessInformation", Type, 0, ""},
-		{"ProcessInformation.Process", Field, 0, ""},
-		{"ProcessInformation.ProcessId", Field, 0, ""},
-		{"ProcessInformation.Thread", Field, 0, ""},
-		{"ProcessInformation.ThreadId", Field, 0, ""},
-		{"Protoent", Type, 0, ""},
-		{"Protoent.Aliases", Field, 0, ""},
-		{"Protoent.Name", Field, 0, ""},
-		{"Protoent.Proto", Field, 0, ""},
-		{"PtraceAttach", Func, 0, "func(pid int) (err error)"},
-		{"PtraceCont", Func, 0, "func(pid int, signal int) (err error)"},
-		{"PtraceDetach", Func, 0, "func(pid int) (err error)"},
-		{"PtraceGetEventMsg", Func, 0, "func(pid int) (msg uint, err error)"},
-		{"PtraceGetRegs", Func, 0, "func(pid int, regsout *PtraceRegs) (err error)"},
-		{"PtracePeekData", Func, 0, "func(pid int, addr uintptr, out []byte) (count int, err error)"},
-		{"PtracePeekText", Func, 0, "func(pid int, addr uintptr, out []byte) (count int, err error)"},
-		{"PtracePokeData", Func, 0, "func(pid int, addr uintptr, data []byte) (count int, err error)"},
-		{"PtracePokeText", Func, 0, "func(pid int, addr uintptr, data []byte) (count int, err error)"},
-		{"PtraceRegs", Type, 0, ""},
-		{"PtraceRegs.Cs", Field, 0, ""},
-		{"PtraceRegs.Ds", Field, 0, ""},
-		{"PtraceRegs.Eax", Field, 0, ""},
-		{"PtraceRegs.Ebp", Field, 0, ""},
-		{"PtraceRegs.Ebx", Field, 0, ""},
-		{"PtraceRegs.Ecx", Field, 0, ""},
-		{"PtraceRegs.Edi", Field, 0, ""},
-		{"PtraceRegs.Edx", Field, 0, ""},
-		{"PtraceRegs.Eflags", Field, 0, ""},
-		{"PtraceRegs.Eip", Field, 0, ""},
-		{"PtraceRegs.Es", Field, 0, ""},
-		{"PtraceRegs.Esi", Field, 0, ""},
-		{"PtraceRegs.Esp", Field, 0, ""},
-		{"PtraceRegs.Fs", Field, 0, ""},
-		{"PtraceRegs.Fs_base", Field, 0, ""},
-		{"PtraceRegs.Gs", Field, 0, ""},
-		{"PtraceRegs.Gs_base", Field, 0, ""},
-		{"PtraceRegs.Orig_eax", Field, 0, ""},
-		{"PtraceRegs.Orig_rax", Field, 0, ""},
-		{"PtraceRegs.R10", Field, 0, ""},
-		{"PtraceRegs.R11", Field, 0, ""},
-		{"PtraceRegs.R12", Field, 0, ""},
-		{"PtraceRegs.R13", Field, 0, ""},
-		{"PtraceRegs.R14", Field, 0, ""},
-		{"PtraceRegs.R15", Field, 0, ""},
-		{"PtraceRegs.R8", Field, 0, ""},
-		{"PtraceRegs.R9", Field, 0, ""},
-		{"PtraceRegs.Rax", Field, 0, ""},
-		{"PtraceRegs.Rbp", Field, 0, ""},
-		{"PtraceRegs.Rbx", Field, 0, ""},
-		{"PtraceRegs.Rcx", Field, 0, ""},
-		{"PtraceRegs.Rdi", Field, 0, ""},
-		{"PtraceRegs.Rdx", Field, 0, ""},
-		{"PtraceRegs.Rip", Field, 0, ""},
-		{"PtraceRegs.Rsi", Field, 0, ""},
-		{"PtraceRegs.Rsp", Field, 0, ""},
-		{"PtraceRegs.Ss", Field, 0, ""},
-		{"PtraceRegs.Uregs", Field, 0, ""},
-		{"PtraceRegs.Xcs", Field, 0, ""},
-		{"PtraceRegs.Xds", Field, 0, ""},
-		{"PtraceRegs.Xes", Field, 0, ""},
-		{"PtraceRegs.Xfs", Field, 0, ""},
-		{"PtraceRegs.Xgs", Field, 0, ""},
-		{"PtraceRegs.Xss", Field, 0, ""},
-		{"PtraceSetOptions", Func, 0, "func(pid int, options int) (err error)"},
-		{"PtraceSetRegs", Func, 0, "func(pid int, regs *PtraceRegs) (err error)"},
-		{"PtraceSingleStep", Func, 0, "func(pid int) (err error)"},
-		{"PtraceSyscall", Func, 1, "func(pid int, signal int) (err error)"},
-		{"Pwrite", Func, 0, "func(fd int, p []byte, offset int64) (n int, err error)"},
-		{"REG_BINARY", Const, 0, ""},
-		{"REG_DWORD", Const, 0, ""},
-		{"REG_DWORD_BIG_ENDIAN", Const, 0, ""},
-		{"REG_DWORD_LITTLE_ENDIAN", Const, 0, ""},
-		{"REG_EXPAND_SZ", Const, 0, ""},
-		{"REG_FULL_RESOURCE_DESCRIPTOR", Const, 0, ""},
-		{"REG_LINK", Const, 0, ""},
-		{"REG_MULTI_SZ", Const, 0, ""},
-		{"REG_NONE", Const, 0, ""},
-		{"REG_QWORD", Const, 0, ""},
-		{"REG_QWORD_LITTLE_ENDIAN", Const, 0, ""},
-		{"REG_RESOURCE_LIST", Const, 0, ""},
-		{"REG_RESOURCE_REQUIREMENTS_LIST", Const, 0, ""},
-		{"REG_SZ", Const, 0, ""},
-		{"RLIMIT_AS", Const, 0, ""},
-		{"RLIMIT_CORE", Const, 0, ""},
-		{"RLIMIT_CPU", Const, 0, ""},
-		{"RLIMIT_CPU_USAGE_MONITOR", Const, 16, ""},
-		{"RLIMIT_DATA", Const, 0, ""},
-		{"RLIMIT_FSIZE", Const, 0, ""},
-		{"RLIMIT_NOFILE", Const, 0, ""},
-		{"RLIMIT_STACK", Const, 0, ""},
-		{"RLIM_INFINITY", Const, 0, ""},
-		{"RTAX_ADVMSS", Const, 0, ""},
-		{"RTAX_AUTHOR", Const, 0, ""},
-		{"RTAX_BRD", Const, 0, ""},
-		{"RTAX_CWND", Const, 0, ""},
-		{"RTAX_DST", Const, 0, ""},
-		{"RTAX_FEATURES", Const, 0, ""},
-		{"RTAX_FEATURE_ALLFRAG", Const, 0, ""},
-		{"RTAX_FEATURE_ECN", Const, 0, ""},
-		{"RTAX_FEATURE_SACK", Const, 0, ""},
-		{"RTAX_FEATURE_TIMESTAMP", Const, 0, ""},
-		{"RTAX_GATEWAY", Const, 0, ""},
-		{"RTAX_GENMASK", Const, 0, ""},
-		{"RTAX_HOPLIMIT", Const, 0, ""},
-		{"RTAX_IFA", Const, 0, ""},
-		{"RTAX_IFP", Const, 0, ""},
-		{"RTAX_INITCWND", Const, 0, ""},
-		{"RTAX_INITRWND", Const, 0, ""},
-		{"RTAX_LABEL", Const, 1, ""},
-		{"RTAX_LOCK", Const, 0, ""},
-		{"RTAX_MAX", Const, 0, ""},
-		{"RTAX_MTU", Const, 0, ""},
-		{"RTAX_NETMASK", Const, 0, ""},
-		{"RTAX_REORDERING", Const, 0, ""},
-		{"RTAX_RTO_MIN", Const, 0, ""},
-		{"RTAX_RTT", Const, 0, ""},
-		{"RTAX_RTTVAR", Const, 0, ""},
-		{"RTAX_SRC", Const, 1, ""},
-		{"RTAX_SRCMASK", Const, 1, ""},
-		{"RTAX_SSTHRESH", Const, 0, ""},
-		{"RTAX_TAG", Const, 1, ""},
-		{"RTAX_UNSPEC", Const, 0, ""},
-		{"RTAX_WINDOW", Const, 0, ""},
-		{"RTA_ALIGNTO", Const, 0, ""},
-		{"RTA_AUTHOR", Const, 0, ""},
-		{"RTA_BRD", Const, 0, ""},
-		{"RTA_CACHEINFO", Const, 0, ""},
-		{"RTA_DST", Const, 0, ""},
-		{"RTA_FLOW", Const, 0, ""},
-		{"RTA_GATEWAY", Const, 0, ""},
-		{"RTA_GENMASK", Const, 0, ""},
-		{"RTA_IFA", Const, 0, ""},
-		{"RTA_IFP", Const, 0, ""},
-		{"RTA_IIF", Const, 0, ""},
-		{"RTA_LABEL", Const, 1, ""},
-		{"RTA_MAX", Const, 0, ""},
-		{"RTA_METRICS", Const, 0, ""},
-		{"RTA_MULTIPATH", Const, 0, ""},
-		{"RTA_NETMASK", Const, 0, ""},
-		{"RTA_OIF", Const, 0, ""},
-		{"RTA_PREFSRC", Const, 0, ""},
-		{"RTA_PRIORITY", Const, 0, ""},
-		{"RTA_SRC", Const, 0, ""},
-		{"RTA_SRCMASK", Const, 1, ""},
-		{"RTA_TABLE", Const, 0, ""},
-		{"RTA_TAG", Const, 1, ""},
-		{"RTA_UNSPEC", Const, 0, ""},
-		{"RTCF_DIRECTSRC", Const, 0, ""},
-		{"RTCF_DOREDIRECT", Const, 0, ""},
-		{"RTCF_LOG", Const, 0, ""},
-		{"RTCF_MASQ", Const, 0, ""},
-		{"RTCF_NAT", Const, 0, ""},
-		{"RTCF_VALVE", Const, 0, ""},
-		{"RTF_ADDRCLASSMASK", Const, 0, ""},
-		{"RTF_ADDRCONF", Const, 0, ""},
-		{"RTF_ALLONLINK", Const, 0, ""},
-		{"RTF_ANNOUNCE", Const, 1, ""},
-		{"RTF_BLACKHOLE", Const, 0, ""},
-		{"RTF_BROADCAST", Const, 0, ""},
-		{"RTF_CACHE", Const, 0, ""},
-		{"RTF_CLONED", Const, 1, ""},
-		{"RTF_CLONING", Const, 0, ""},
-		{"RTF_CONDEMNED", Const, 0, ""},
-		{"RTF_DEFAULT", Const, 0, ""},
-		{"RTF_DELCLONE", Const, 0, ""},
-		{"RTF_DONE", Const, 0, ""},
-		{"RTF_DYNAMIC", Const, 0, ""},
-		{"RTF_FLOW", Const, 0, ""},
-		{"RTF_FMASK", Const, 0, ""},
-		{"RTF_GATEWAY", Const, 0, ""},
-		{"RTF_GWFLAG_COMPAT", Const, 3, ""},
-		{"RTF_HOST", Const, 0, ""},
-		{"RTF_IFREF", Const, 0, ""},
-		{"RTF_IFSCOPE", Const, 0, ""},
-		{"RTF_INTERFACE", Const, 0, ""},
-		{"RTF_IRTT", Const, 0, ""},
-		{"RTF_LINKRT", Const, 0, ""},
-		{"RTF_LLDATA", Const, 0, ""},
-		{"RTF_LLINFO", Const, 0, ""},
-		{"RTF_LOCAL", Const, 0, ""},
-		{"RTF_MASK", Const, 1, ""},
-		{"RTF_MODIFIED", Const, 0, ""},
-		{"RTF_MPATH", Const, 1, ""},
-		{"RTF_MPLS", Const, 1, ""},
-		{"RTF_MSS", Const, 0, ""},
-		{"RTF_MTU", Const, 0, ""},
-		{"RTF_MULTICAST", Const, 0, ""},
-		{"RTF_NAT", Const, 0, ""},
-		{"RTF_NOFORWARD", Const, 0, ""},
-		{"RTF_NONEXTHOP", Const, 0, ""},
-		{"RTF_NOPMTUDISC", Const, 0, ""},
-		{"RTF_PERMANENT_ARP", Const, 1, ""},
-		{"RTF_PINNED", Const, 0, ""},
-		{"RTF_POLICY", Const, 0, ""},
-		{"RTF_PRCLONING", Const, 0, ""},
-		{"RTF_PROTO1", Const, 0, ""},
-		{"RTF_PROTO2", Const, 0, ""},
-		{"RTF_PROTO3", Const, 0, ""},
-		{"RTF_PROXY", Const, 16, ""},
-		{"RTF_REINSTATE", Const, 0, ""},
-		{"RTF_REJECT", Const, 0, ""},
-		{"RTF_RNH_LOCKED", Const, 0, ""},
-		{"RTF_ROUTER", Const, 16, ""},
-		{"RTF_SOURCE", Const, 1, ""},
-		{"RTF_SRC", Const, 1, ""},
-		{"RTF_STATIC", Const, 0, ""},
-		{"RTF_STICKY", Const, 0, ""},
-		{"RTF_THROW", Const, 0, ""},
-		{"RTF_TUNNEL", Const, 1, ""},
-		{"RTF_UP", Const, 0, ""},
-		{"RTF_USETRAILERS", Const, 1, ""},
-		{"RTF_WASCLONED", Const, 0, ""},
-		{"RTF_WINDOW", Const, 0, ""},
-		{"RTF_XRESOLVE", Const, 0, ""},
-		{"RTM_ADD", Const, 0, ""},
-		{"RTM_BASE", Const, 0, ""},
-		{"RTM_CHANGE", Const, 0, ""},
-		{"RTM_CHGADDR", Const, 1, ""},
-		{"RTM_DELACTION", Const, 0, ""},
-		{"RTM_DELADDR", Const, 0, ""},
-		{"RTM_DELADDRLABEL", Const, 0, ""},
-		{"RTM_DELETE", Const, 0, ""},
-		{"RTM_DELLINK", Const, 0, ""},
-		{"RTM_DELMADDR", Const, 0, ""},
-		{"RTM_DELNEIGH", Const, 0, ""},
-		{"RTM_DELQDISC", Const, 0, ""},
-		{"RTM_DELROUTE", Const, 0, ""},
-		{"RTM_DELRULE", Const, 0, ""},
-		{"RTM_DELTCLASS", Const, 0, ""},
-		{"RTM_DELTFILTER", Const, 0, ""},
-		{"RTM_DESYNC", Const, 1, ""},
-		{"RTM_F_CLONED", Const, 0, ""},
-		{"RTM_F_EQUALIZE", Const, 0, ""},
-		{"RTM_F_NOTIFY", Const, 0, ""},
-		{"RTM_F_PREFIX", Const, 0, ""},
-		{"RTM_GET", Const, 0, ""},
-		{"RTM_GET2", Const, 0, ""},
-		{"RTM_GETACTION", Const, 0, ""},
-		{"RTM_GETADDR", Const, 0, ""},
-		{"RTM_GETADDRLABEL", Const, 0, ""},
-		{"RTM_GETANYCAST", Const, 0, ""},
-		{"RTM_GETDCB", Const, 0, ""},
-		{"RTM_GETLINK", Const, 0, ""},
-		{"RTM_GETMULTICAST", Const, 0, ""},
-		{"RTM_GETNEIGH", Const, 0, ""},
-		{"RTM_GETNEIGHTBL", Const, 0, ""},
-		{"RTM_GETQDISC", Const, 0, ""},
-		{"RTM_GETROUTE", Const, 0, ""},
-		{"RTM_GETRULE", Const, 0, ""},
-		{"RTM_GETTCLASS", Const, 0, ""},
-		{"RTM_GETTFILTER", Const, 0, ""},
-		{"RTM_IEEE80211", Const, 0, ""},
-		{"RTM_IFANNOUNCE", Const, 0, ""},
-		{"RTM_IFINFO", Const, 0, ""},
-		{"RTM_IFINFO2", Const, 0, ""},
-		{"RTM_LLINFO_UPD", Const, 1, ""},
-		{"RTM_LOCK", Const, 0, ""},
-		{"RTM_LOSING", Const, 0, ""},
-		{"RTM_MAX", Const, 0, ""},
-		{"RTM_MAXSIZE", Const, 1, ""},
-		{"RTM_MISS", Const, 0, ""},
-		{"RTM_NEWACTION", Const, 0, ""},
-		{"RTM_NEWADDR", Const, 0, ""},
-		{"RTM_NEWADDRLABEL", Const, 0, ""},
-		{"RTM_NEWLINK", Const, 0, ""},
-		{"RTM_NEWMADDR", Const, 0, ""},
-		{"RTM_NEWMADDR2", Const, 0, ""},
-		{"RTM_NEWNDUSEROPT", Const, 0, ""},
-		{"RTM_NEWNEIGH", Const, 0, ""},
-		{"RTM_NEWNEIGHTBL", Const, 0, ""},
-		{"RTM_NEWPREFIX", Const, 0, ""},
-		{"RTM_NEWQDISC", Const, 0, ""},
-		{"RTM_NEWROUTE", Const, 0, ""},
-		{"RTM_NEWRULE", Const, 0, ""},
-		{"RTM_NEWTCLASS", Const, 0, ""},
-		{"RTM_NEWTFILTER", Const, 0, ""},
-		{"RTM_NR_FAMILIES", Const, 0, ""},
-		{"RTM_NR_MSGTYPES", Const, 0, ""},
-		{"RTM_OIFINFO", Const, 1, ""},
-		{"RTM_OLDADD", Const, 0, ""},
-		{"RTM_OLDDEL", Const, 0, ""},
-		{"RTM_OOIFINFO", Const, 1, ""},
-		{"RTM_REDIRECT", Const, 0, ""},
-		{"RTM_RESOLVE", Const, 0, ""},
-		{"RTM_RTTUNIT", Const, 0, ""},
-		{"RTM_SETDCB", Const, 0, ""},
-		{"RTM_SETGATE", Const, 1, ""},
-		{"RTM_SETLINK", Const, 0, ""},
-		{"RTM_SETNEIGHTBL", Const, 0, ""},
-		{"RTM_VERSION", Const, 0, ""},
-		{"RTNH_ALIGNTO", Const, 0, ""},
-		{"RTNH_F_DEAD", Const, 0, ""},
-		{"RTNH_F_ONLINK", Const, 0, ""},
-		{"RTNH_F_PERVASIVE", Const, 0, ""},
-		{"RTNLGRP_IPV4_IFADDR", Const, 1, ""},
-		{"RTNLGRP_IPV4_MROUTE", Const, 1, ""},
-		{"RTNLGRP_IPV4_ROUTE", Const, 1, ""},
-		{"RTNLGRP_IPV4_RULE", Const, 1, ""},
-		{"RTNLGRP_IPV6_IFADDR", Const, 1, ""},
-		{"RTNLGRP_IPV6_IFINFO", Const, 1, ""},
-		{"RTNLGRP_IPV6_MROUTE", Const, 1, ""},
-		{"RTNLGRP_IPV6_PREFIX", Const, 1, ""},
-		{"RTNLGRP_IPV6_ROUTE", Const, 1, ""},
-		{"RTNLGRP_IPV6_RULE", Const, 1, ""},
-		{"RTNLGRP_LINK", Const, 1, ""},
-		{"RTNLGRP_ND_USEROPT", Const, 1, ""},
-		{"RTNLGRP_NEIGH", Const, 1, ""},
-		{"RTNLGRP_NONE", Const, 1, ""},
-		{"RTNLGRP_NOTIFY", Const, 1, ""},
-		{"RTNLGRP_TC", Const, 1, ""},
-		{"RTN_ANYCAST", Const, 0, ""},
-		{"RTN_BLACKHOLE", Const, 0, ""},
-		{"RTN_BROADCAST", Const, 0, ""},
-		{"RTN_LOCAL", Const, 0, ""},
-		{"RTN_MAX", Const, 0, ""},
-		{"RTN_MULTICAST", Const, 0, ""},
-		{"RTN_NAT", Const, 0, ""},
-		{"RTN_PROHIBIT", Const, 0, ""},
-		{"RTN_THROW", Const, 0, ""},
-		{"RTN_UNICAST", Const, 0, ""},
-		{"RTN_UNREACHABLE", Const, 0, ""},
-		{"RTN_UNSPEC", Const, 0, ""},
-		{"RTN_XRESOLVE", Const, 0, ""},
-		{"RTPROT_BIRD", Const, 0, ""},
-		{"RTPROT_BOOT", Const, 0, ""},
-		{"RTPROT_DHCP", Const, 0, ""},
-		{"RTPROT_DNROUTED", Const, 0, ""},
-		{"RTPROT_GATED", Const, 0, ""},
-		{"RTPROT_KERNEL", Const, 0, ""},
-		{"RTPROT_MRT", Const, 0, ""},
-		{"RTPROT_NTK", Const, 0, ""},
-		{"RTPROT_RA", Const, 0, ""},
-		{"RTPROT_REDIRECT", Const, 0, ""},
-		{"RTPROT_STATIC", Const, 0, ""},
-		{"RTPROT_UNSPEC", Const, 0, ""},
-		{"RTPROT_XORP", Const, 0, ""},
-		{"RTPROT_ZEBRA", Const, 0, ""},
-		{"RTV_EXPIRE", Const, 0, ""},
-		{"RTV_HOPCOUNT", Const, 0, ""},
-		{"RTV_MTU", Const, 0, ""},
-		{"RTV_RPIPE", Const, 0, ""},
-		{"RTV_RTT", Const, 0, ""},
-		{"RTV_RTTVAR", Const, 0, ""},
-		{"RTV_SPIPE", Const, 0, ""},
-		{"RTV_SSTHRESH", Const, 0, ""},
-		{"RTV_WEIGHT", Const, 0, ""},
-		{"RT_CACHING_CONTEXT", Const, 1, ""},
-		{"RT_CLASS_DEFAULT", Const, 0, ""},
-		{"RT_CLASS_LOCAL", Const, 0, ""},
-		{"RT_CLASS_MAIN", Const, 0, ""},
-		{"RT_CLASS_MAX", Const, 0, ""},
-		{"RT_CLASS_UNSPEC", Const, 0, ""},
-		{"RT_DEFAULT_FIB", Const, 1, ""},
-		{"RT_NORTREF", Const, 1, ""},
-		{"RT_SCOPE_HOST", Const, 0, ""},
-		{"RT_SCOPE_LINK", Const, 0, ""},
-		{"RT_SCOPE_NOWHERE", Const, 0, ""},
-		{"RT_SCOPE_SITE", Const, 0, ""},
-		{"RT_SCOPE_UNIVERSE", Const, 0, ""},
-		{"RT_TABLEID_MAX", Const, 1, ""},
-		{"RT_TABLE_COMPAT", Const, 0, ""},
-		{"RT_TABLE_DEFAULT", Const, 0, ""},
-		{"RT_TABLE_LOCAL", Const, 0, ""},
-		{"RT_TABLE_MAIN", Const, 0, ""},
-		{"RT_TABLE_MAX", Const, 0, ""},
-		{"RT_TABLE_UNSPEC", Const, 0, ""},
-		{"RUSAGE_CHILDREN", Const, 0, ""},
-		{"RUSAGE_SELF", Const, 0, ""},
-		{"RUSAGE_THREAD", Const, 0, ""},
-		{"Radvisory_t", Type, 0, ""},
-		{"Radvisory_t.Count", Field, 0, ""},
-		{"Radvisory_t.Offset", Field, 0, ""},
-		{"Radvisory_t.Pad_cgo_0", Field, 0, ""},
-		{"RawConn", Type, 9, ""},
-		{"RawSockaddr", Type, 0, ""},
-		{"RawSockaddr.Data", Field, 0, ""},
-		{"RawSockaddr.Family", Field, 0, ""},
-		{"RawSockaddr.Len", Field, 0, ""},
-		{"RawSockaddrAny", Type, 0, ""},
-		{"RawSockaddrAny.Addr", Field, 0, ""},
-		{"RawSockaddrAny.Pad", Field, 0, ""},
-		{"RawSockaddrDatalink", Type, 0, ""},
-		{"RawSockaddrDatalink.Alen", Field, 0, ""},
-		{"RawSockaddrDatalink.Data", Field, 0, ""},
-		{"RawSockaddrDatalink.Family", Field, 0, ""},
-		{"RawSockaddrDatalink.Index", Field, 0, ""},
-		{"RawSockaddrDatalink.Len", Field, 0, ""},
-		{"RawSockaddrDatalink.Nlen", Field, 0, ""},
-		{"RawSockaddrDatalink.Pad_cgo_0", Field, 2, ""},
-		{"RawSockaddrDatalink.Slen", Field, 0, ""},
-		{"RawSockaddrDatalink.Type", Field, 0, ""},
-		{"RawSockaddrInet4", Type, 0, ""},
-		{"RawSockaddrInet4.Addr", Field, 0, ""},
-		{"RawSockaddrInet4.Family", Field, 0, ""},
-		{"RawSockaddrInet4.Len", Field, 0, ""},
-		{"RawSockaddrInet4.Port", Field, 0, ""},
-		{"RawSockaddrInet4.Zero", Field, 0, ""},
-		{"RawSockaddrInet6", Type, 0, ""},
-		{"RawSockaddrInet6.Addr", Field, 0, ""},
-		{"RawSockaddrInet6.Family", Field, 0, ""},
-		{"RawSockaddrInet6.Flowinfo", Field, 0, ""},
-		{"RawSockaddrInet6.Len", Field, 0, ""},
-		{"RawSockaddrInet6.Port", Field, 0, ""},
-		{"RawSockaddrInet6.Scope_id", Field, 0, ""},
-		{"RawSockaddrLinklayer", Type, 0, ""},
-		{"RawSockaddrLinklayer.Addr", Field, 0, ""},
-		{"RawSockaddrLinklayer.Family", Field, 0, ""},
-		{"RawSockaddrLinklayer.Halen", Field, 0, ""},
-		{"RawSockaddrLinklayer.Hatype", Field, 0, ""},
-		{"RawSockaddrLinklayer.Ifindex", Field, 0, ""},
-		{"RawSockaddrLinklayer.Pkttype", Field, 0, ""},
-		{"RawSockaddrLinklayer.Protocol", Field, 0, ""},
-		{"RawSockaddrNetlink", Type, 0, ""},
-		{"RawSockaddrNetlink.Family", Field, 0, ""},
-		{"RawSockaddrNetlink.Groups", Field, 0, ""},
-		{"RawSockaddrNetlink.Pad", Field, 0, ""},
-		{"RawSockaddrNetlink.Pid", Field, 0, ""},
-		{"RawSockaddrUnix", Type, 0, ""},
-		{"RawSockaddrUnix.Family", Field, 0, ""},
-		{"RawSockaddrUnix.Len", Field, 0, ""},
-		{"RawSockaddrUnix.Pad_cgo_0", Field, 2, ""},
-		{"RawSockaddrUnix.Path", Field, 0, ""},
-		{"RawSyscall", Func, 0, "func(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr) (r1 uintptr, r2 uintptr, err Errno)"},
-		{"RawSyscall6", Func, 0, "func(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr, a6 uintptr) (r1 uintptr, r2 uintptr, err Errno)"},
-		{"Read", Func, 0, "func(fd int, p []byte) (n int, err error)"},
-		{"ReadConsole", Func, 1, ""},
-		{"ReadDirectoryChanges", Func, 0, ""},
-		{"ReadDirent", Func, 0, "func(fd int, buf []byte) (n int, err error)"},
-		{"ReadFile", Func, 0, ""},
-		{"Readlink", Func, 0, "func(path string, buf []byte) (n int, err error)"},
-		{"Reboot", Func, 0, "func(cmd int) (err error)"},
-		{"Recvfrom", Func, 0, "func(fd int, p []byte, flags int) (n int, from Sockaddr, err error)"},
-		{"Recvmsg", Func, 0, "func(fd int, p []byte, oob []byte, flags int) (n int, oobn int, recvflags int, from Sockaddr, err error)"},
-		{"RegCloseKey", Func, 0, ""},
-		{"RegEnumKeyEx", Func, 0, ""},
-		{"RegOpenKeyEx", Func, 0, ""},
-		{"RegQueryInfoKey", Func, 0, ""},
-		{"RegQueryValueEx", Func, 0, ""},
-		{"RemoveDirectory", Func, 0, ""},
-		{"Removexattr", Func, 1, "func(path string, attr string) (err error)"},
-		{"Rename", Func, 0, "func(oldpath string, newpath string) (err error)"},
-		{"Renameat", Func, 0, "func(olddirfd int, oldpath string, newdirfd int, newpath string) (err error)"},
-		{"Revoke", Func, 0, ""},
-		{"Rlimit", Type, 0, ""},
-		{"Rlimit.Cur", Field, 0, ""},
-		{"Rlimit.Max", Field, 0, ""},
-		{"Rmdir", Func, 0, "func(path string) error"},
-		{"RouteMessage", Type, 0, ""},
-		{"RouteMessage.Data", Field, 0, ""},
-		{"RouteMessage.Header", Field, 0, ""},
-		{"RouteRIB", Func, 0, ""},
-		{"RoutingMessage", Type, 14, ""},
-		{"RtAttr", Type, 0, ""},
-		{"RtAttr.Len", Field, 0, ""},
-		{"RtAttr.Type", Field, 0, ""},
-		{"RtGenmsg", Type, 0, ""},
-		{"RtGenmsg.Family", Field, 0, ""},
-		{"RtMetrics", Type, 0, ""},
-		{"RtMetrics.Expire", Field, 0, ""},
-		{"RtMetrics.Filler", Field, 0, ""},
-		{"RtMetrics.Hopcount", Field, 0, ""},
-		{"RtMetrics.Locks", Field, 0, ""},
-		{"RtMetrics.Mtu", Field, 0, ""},
-		{"RtMetrics.Pad", Field, 3, ""},
-		{"RtMetrics.Pksent", Field, 0, ""},
-		{"RtMetrics.Recvpipe", Field, 0, ""},
-		{"RtMetrics.Refcnt", Field, 2, ""},
-		{"RtMetrics.Rtt", Field, 0, ""},
-		{"RtMetrics.Rttvar", Field, 0, ""},
-		{"RtMetrics.Sendpipe", Field, 0, ""},
-		{"RtMetrics.Ssthresh", Field, 0, ""},
-		{"RtMetrics.Weight", Field, 0, ""},
-		{"RtMsg", Type, 0, ""},
-		{"RtMsg.Dst_len", Field, 0, ""},
-		{"RtMsg.Family", Field, 0, ""},
-		{"RtMsg.Flags", Field, 0, ""},
-		{"RtMsg.Protocol", Field, 0, ""},
-		{"RtMsg.Scope", Field, 0, ""},
-		{"RtMsg.Src_len", Field, 0, ""},
-		{"RtMsg.Table", Field, 0, ""},
-		{"RtMsg.Tos", Field, 0, ""},
-		{"RtMsg.Type", Field, 0, ""},
-		{"RtMsghdr", Type, 0, ""},
-		{"RtMsghdr.Addrs", Field, 0, ""},
-		{"RtMsghdr.Errno", Field, 0, ""},
-		{"RtMsghdr.Flags", Field, 0, ""},
-		{"RtMsghdr.Fmask", Field, 0, ""},
-		{"RtMsghdr.Hdrlen", Field, 2, ""},
-		{"RtMsghdr.Index", Field, 0, ""},
-		{"RtMsghdr.Inits", Field, 0, ""},
-		{"RtMsghdr.Mpls", Field, 2, ""},
-		{"RtMsghdr.Msglen", Field, 0, ""},
-		{"RtMsghdr.Pad_cgo_0", Field, 0, ""},
-		{"RtMsghdr.Pad_cgo_1", Field, 2, ""},
-		{"RtMsghdr.Pid", Field, 0, ""},
-		{"RtMsghdr.Priority", Field, 2, ""},
-		{"RtMsghdr.Rmx", Field, 0, ""},
-		{"RtMsghdr.Seq", Field, 0, ""},
-		{"RtMsghdr.Tableid", Field, 2, ""},
-		{"RtMsghdr.Type", Field, 0, ""},
-		{"RtMsghdr.Use", Field, 0, ""},
-		{"RtMsghdr.Version", Field, 0, ""},
-		{"RtNexthop", Type, 0, ""},
-		{"RtNexthop.Flags", Field, 0, ""},
-		{"RtNexthop.Hops", Field, 0, ""},
-		{"RtNexthop.Ifindex", Field, 0, ""},
-		{"RtNexthop.Len", Field, 0, ""},
-		{"Rusage", Type, 0, ""},
-		{"Rusage.CreationTime", Field, 0, ""},
-		{"Rusage.ExitTime", Field, 0, ""},
-		{"Rusage.Idrss", Field, 0, ""},
-		{"Rusage.Inblock", Field, 0, ""},
-		{"Rusage.Isrss", Field, 0, ""},
-		{"Rusage.Ixrss", Field, 0, ""},
-		{"Rusage.KernelTime", Field, 0, ""},
-		{"Rusage.Majflt", Field, 0, ""},
-		{"Rusage.Maxrss", Field, 0, ""},
-		{"Rusage.Minflt", Field, 0, ""},
-		{"Rusage.Msgrcv", Field, 0, ""},
-		{"Rusage.Msgsnd", Field, 0, ""},
-		{"Rusage.Nivcsw", Field, 0, ""},
-		{"Rusage.Nsignals", Field, 0, ""},
-		{"Rusage.Nswap", Field, 0, ""},
-		{"Rusage.Nvcsw", Field, 0, ""},
-		{"Rusage.Oublock", Field, 0, ""},
-		{"Rusage.Stime", Field, 0, ""},
-		{"Rusage.UserTime", Field, 0, ""},
-		{"Rusage.Utime", Field, 0, ""},
-		{"SCM_BINTIME", Const, 0, ""},
-		{"SCM_CREDENTIALS", Const, 0, ""},
-		{"SCM_CREDS", Const, 0, ""},
-		{"SCM_RIGHTS", Const, 0, ""},
-		{"SCM_TIMESTAMP", Const, 0, ""},
-		{"SCM_TIMESTAMPING", Const, 0, ""},
-		{"SCM_TIMESTAMPNS", Const, 0, ""},
-		{"SCM_TIMESTAMP_MONOTONIC", Const, 0, ""},
-		{"SHUT_RD", Const, 0, ""},
-		{"SHUT_RDWR", Const, 0, ""},
-		{"SHUT_WR", Const, 0, ""},
-		{"SID", Type, 0, ""},
-		{"SIDAndAttributes", Type, 0, ""},
-		{"SIDAndAttributes.Attributes", Field, 0, ""},
-		{"SIDAndAttributes.Sid", Field, 0, ""},
-		{"SIGABRT", Const, 0, ""},
-		{"SIGALRM", Const, 0, ""},
-		{"SIGBUS", Const, 0, ""},
-		{"SIGCHLD", Const, 0, ""},
-		{"SIGCLD", Const, 0, ""},
-		{"SIGCONT", Const, 0, ""},
-		{"SIGEMT", Const, 0, ""},
-		{"SIGFPE", Const, 0, ""},
-		{"SIGHUP", Const, 0, ""},
-		{"SIGILL", Const, 0, ""},
-		{"SIGINFO", Const, 0, ""},
-		{"SIGINT", Const, 0, ""},
-		{"SIGIO", Const, 0, ""},
-		{"SIGIOT", Const, 0, ""},
-		{"SIGKILL", Const, 0, ""},
-		{"SIGLIBRT", Const, 1, ""},
-		{"SIGLWP", Const, 0, ""},
-		{"SIGPIPE", Const, 0, ""},
-		{"SIGPOLL", Const, 0, ""},
-		{"SIGPROF", Const, 0, ""},
-		{"SIGPWR", Const, 0, ""},
-		{"SIGQUIT", Const, 0, ""},
-		{"SIGSEGV", Const, 0, ""},
-		{"SIGSTKFLT", Const, 0, ""},
-		{"SIGSTOP", Const, 0, ""},
-		{"SIGSYS", Const, 0, ""},
-		{"SIGTERM", Const, 0, ""},
-		{"SIGTHR", Const, 0, ""},
-		{"SIGTRAP", Const, 0, ""},
-		{"SIGTSTP", Const, 0, ""},
-		{"SIGTTIN", Const, 0, ""},
-		{"SIGTTOU", Const, 0, ""},
-		{"SIGUNUSED", Const, 0, ""},
-		{"SIGURG", Const, 0, ""},
-		{"SIGUSR1", Const, 0, ""},
-		{"SIGUSR2", Const, 0, ""},
-		{"SIGVTALRM", Const, 0, ""},
-		{"SIGWINCH", Const, 0, ""},
-		{"SIGXCPU", Const, 0, ""},
-		{"SIGXFSZ", Const, 0, ""},
-		{"SIOCADDDLCI", Const, 0, ""},
-		{"SIOCADDMULTI", Const, 0, ""},
-		{"SIOCADDRT", Const, 0, ""},
-		{"SIOCAIFADDR", Const, 0, ""},
-		{"SIOCAIFGROUP", Const, 0, ""},
-		{"SIOCALIFADDR", Const, 0, ""},
-		{"SIOCARPIPLL", Const, 0, ""},
-		{"SIOCATMARK", Const, 0, ""},
-		{"SIOCAUTOADDR", Const, 0, ""},
-		{"SIOCAUTONETMASK", Const, 0, ""},
-		{"SIOCBRDGADD", Const, 1, ""},
-		{"SIOCBRDGADDS", Const, 1, ""},
-		{"SIOCBRDGARL", Const, 1, ""},
-		{"SIOCBRDGDADDR", Const, 1, ""},
-		{"SIOCBRDGDEL", Const, 1, ""},
-		{"SIOCBRDGDELS", Const, 1, ""},
-		{"SIOCBRDGFLUSH", Const, 1, ""},
-		{"SIOCBRDGFRL", Const, 1, ""},
-		{"SIOCBRDGGCACHE", Const, 1, ""},
-		{"SIOCBRDGGFD", Const, 1, ""},
-		{"SIOCBRDGGHT", Const, 1, ""},
-		{"SIOCBRDGGIFFLGS", Const, 1, ""},
-		{"SIOCBRDGGMA", Const, 1, ""},
-		{"SIOCBRDGGPARAM", Const, 1, ""},
-		{"SIOCBRDGGPRI", Const, 1, ""},
-		{"SIOCBRDGGRL", Const, 1, ""},
-		{"SIOCBRDGGSIFS", Const, 1, ""},
-		{"SIOCBRDGGTO", Const, 1, ""},
-		{"SIOCBRDGIFS", Const, 1, ""},
-		{"SIOCBRDGRTS", Const, 1, ""},
-		{"SIOCBRDGSADDR", Const, 1, ""},
-		{"SIOCBRDGSCACHE", Const, 1, ""},
-		{"SIOCBRDGSFD", Const, 1, ""},
-		{"SIOCBRDGSHT", Const, 1, ""},
-		{"SIOCBRDGSIFCOST", Const, 1, ""},
-		{"SIOCBRDGSIFFLGS", Const, 1, ""},
-		{"SIOCBRDGSIFPRIO", Const, 1, ""},
-		{"SIOCBRDGSMA", Const, 1, ""},
-		{"SIOCBRDGSPRI", Const, 1, ""},
-		{"SIOCBRDGSPROTO", Const, 1, ""},
-		{"SIOCBRDGSTO", Const, 1, ""},
-		{"SIOCBRDGSTXHC", Const, 1, ""},
-		{"SIOCDARP", Const, 0, ""},
-		{"SIOCDELDLCI", Const, 0, ""},
-		{"SIOCDELMULTI", Const, 0, ""},
-		{"SIOCDELRT", Const, 0, ""},
-		{"SIOCDEVPRIVATE", Const, 0, ""},
-		{"SIOCDIFADDR", Const, 0, ""},
-		{"SIOCDIFGROUP", Const, 0, ""},
-		{"SIOCDIFPHYADDR", Const, 0, ""},
-		{"SIOCDLIFADDR", Const, 0, ""},
-		{"SIOCDRARP", Const, 0, ""},
-		{"SIOCGARP", Const, 0, ""},
-		{"SIOCGDRVSPEC", Const, 0, ""},
-		{"SIOCGETKALIVE", Const, 1, ""},
-		{"SIOCGETLABEL", Const, 1, ""},
-		{"SIOCGETPFLOW", Const, 1, ""},
-		{"SIOCGETPFSYNC", Const, 1, ""},
-		{"SIOCGETSGCNT", Const, 0, ""},
-		{"SIOCGETVIFCNT", Const, 0, ""},
-		{"SIOCGETVLAN", Const, 0, ""},
-		{"SIOCGHIWAT", Const, 0, ""},
-		{"SIOCGIFADDR", Const, 0, ""},
-		{"SIOCGIFADDRPREF", Const, 1, ""},
-		{"SIOCGIFALIAS", Const, 1, ""},
-		{"SIOCGIFALTMTU", Const, 0, ""},
-		{"SIOCGIFASYNCMAP", Const, 0, ""},
-		{"SIOCGIFBOND", Const, 0, ""},
-		{"SIOCGIFBR", Const, 0, ""},
-		{"SIOCGIFBRDADDR", Const, 0, ""},
-		{"SIOCGIFCAP", Const, 0, ""},
-		{"SIOCGIFCONF", Const, 0, ""},
-		{"SIOCGIFCOUNT", Const, 0, ""},
-		{"SIOCGIFDATA", Const, 1, ""},
-		{"SIOCGIFDESCR", Const, 0, ""},
-		{"SIOCGIFDEVMTU", Const, 0, ""},
-		{"SIOCGIFDLT", Const, 1, ""},
-		{"SIOCGIFDSTADDR", Const, 0, ""},
-		{"SIOCGIFENCAP", Const, 0, ""},
-		{"SIOCGIFFIB", Const, 1, ""},
-		{"SIOCGIFFLAGS", Const, 0, ""},
-		{"SIOCGIFGATTR", Const, 1, ""},
-		{"SIOCGIFGENERIC", Const, 0, ""},
-		{"SIOCGIFGMEMB", Const, 0, ""},
-		{"SIOCGIFGROUP", Const, 0, ""},
-		{"SIOCGIFHARDMTU", Const, 3, ""},
-		{"SIOCGIFHWADDR", Const, 0, ""},
-		{"SIOCGIFINDEX", Const, 0, ""},
-		{"SIOCGIFKPI", Const, 0, ""},
-		{"SIOCGIFMAC", Const, 0, ""},
-		{"SIOCGIFMAP", Const, 0, ""},
-		{"SIOCGIFMEDIA", Const, 0, ""},
-		{"SIOCGIFMEM", Const, 0, ""},
-		{"SIOCGIFMETRIC", Const, 0, ""},
-		{"SIOCGIFMTU", Const, 0, ""},
-		{"SIOCGIFNAME", Const, 0, ""},
-		{"SIOCGIFNETMASK", Const, 0, ""},
-		{"SIOCGIFPDSTADDR", Const, 0, ""},
-		{"SIOCGIFPFLAGS", Const, 0, ""},
-		{"SIOCGIFPHYS", Const, 0, ""},
-		{"SIOCGIFPRIORITY", Const, 1, ""},
-		{"SIOCGIFPSRCADDR", Const, 0, ""},
-		{"SIOCGIFRDOMAIN", Const, 1, ""},
-		{"SIOCGIFRTLABEL", Const, 1, ""},
-		{"SIOCGIFSLAVE", Const, 0, ""},
-		{"SIOCGIFSTATUS", Const, 0, ""},
-		{"SIOCGIFTIMESLOT", Const, 1, ""},
-		{"SIOCGIFTXQLEN", Const, 0, ""},
-		{"SIOCGIFVLAN", Const, 0, ""},
-		{"SIOCGIFWAKEFLAGS", Const, 0, ""},
-		{"SIOCGIFXFLAGS", Const, 1, ""},
-		{"SIOCGLIFADDR", Const, 0, ""},
-		{"SIOCGLIFPHYADDR", Const, 0, ""},
-		{"SIOCGLIFPHYRTABLE", Const, 1, ""},
-		{"SIOCGLIFPHYTTL", Const, 3, ""},
-		{"SIOCGLINKSTR", Const, 1, ""},
-		{"SIOCGLOWAT", Const, 0, ""},
-		{"SIOCGPGRP", Const, 0, ""},
-		{"SIOCGPRIVATE_0", Const, 0, ""},
-		{"SIOCGPRIVATE_1", Const, 0, ""},
-		{"SIOCGRARP", Const, 0, ""},
-		{"SIOCGSPPPPARAMS", Const, 3, ""},
-		{"SIOCGSTAMP", Const, 0, ""},
-		{"SIOCGSTAMPNS", Const, 0, ""},
-		{"SIOCGVH", Const, 1, ""},
-		{"SIOCGVNETID", Const, 3, ""},
-		{"SIOCIFCREATE", Const, 0, ""},
-		{"SIOCIFCREATE2", Const, 0, ""},
-		{"SIOCIFDESTROY", Const, 0, ""},
-		{"SIOCIFGCLONERS", Const, 0, ""},
-		{"SIOCINITIFADDR", Const, 1, ""},
-		{"SIOCPROTOPRIVATE", Const, 0, ""},
-		{"SIOCRSLVMULTI", Const, 0, ""},
-		{"SIOCRTMSG", Const, 0, ""},
-		{"SIOCSARP", Const, 0, ""},
-		{"SIOCSDRVSPEC", Const, 0, ""},
-		{"SIOCSETKALIVE", Const, 1, ""},
-		{"SIOCSETLABEL", Const, 1, ""},
-		{"SIOCSETPFLOW", Const, 1, ""},
-		{"SIOCSETPFSYNC", Const, 1, ""},
-		{"SIOCSETVLAN", Const, 0, ""},
-		{"SIOCSHIWAT", Const, 0, ""},
-		{"SIOCSIFADDR", Const, 0, ""},
-		{"SIOCSIFADDRPREF", Const, 1, ""},
-		{"SIOCSIFALTMTU", Const, 0, ""},
-		{"SIOCSIFASYNCMAP", Const, 0, ""},
-		{"SIOCSIFBOND", Const, 0, ""},
-		{"SIOCSIFBR", Const, 0, ""},
-		{"SIOCSIFBRDADDR", Const, 0, ""},
-		{"SIOCSIFCAP", Const, 0, ""},
-		{"SIOCSIFDESCR", Const, 0, ""},
-		{"SIOCSIFDSTADDR", Const, 0, ""},
-		{"SIOCSIFENCAP", Const, 0, ""},
-		{"SIOCSIFFIB", Const, 1, ""},
-		{"SIOCSIFFLAGS", Const, 0, ""},
-		{"SIOCSIFGATTR", Const, 1, ""},
-		{"SIOCSIFGENERIC", Const, 0, ""},
-		{"SIOCSIFHWADDR", Const, 0, ""},
-		{"SIOCSIFHWBROADCAST", Const, 0, ""},
-		{"SIOCSIFKPI", Const, 0, ""},
-		{"SIOCSIFLINK", Const, 0, ""},
-		{"SIOCSIFLLADDR", Const, 0, ""},
-		{"SIOCSIFMAC", Const, 0, ""},
-		{"SIOCSIFMAP", Const, 0, ""},
-		{"SIOCSIFMEDIA", Const, 0, ""},
-		{"SIOCSIFMEM", Const, 0, ""},
-		{"SIOCSIFMETRIC", Const, 0, ""},
-		{"SIOCSIFMTU", Const, 0, ""},
-		{"SIOCSIFNAME", Const, 0, ""},
-		{"SIOCSIFNETMASK", Const, 0, ""},
-		{"SIOCSIFPFLAGS", Const, 0, ""},
-		{"SIOCSIFPHYADDR", Const, 0, ""},
-		{"SIOCSIFPHYS", Const, 0, ""},
-		{"SIOCSIFPRIORITY", Const, 1, ""},
-		{"SIOCSIFRDOMAIN", Const, 1, ""},
-		{"SIOCSIFRTLABEL", Const, 1, ""},
-		{"SIOCSIFRVNET", Const, 0, ""},
-		{"SIOCSIFSLAVE", Const, 0, ""},
-		{"SIOCSIFTIMESLOT", Const, 1, ""},
-		{"SIOCSIFTXQLEN", Const, 0, ""},
-		{"SIOCSIFVLAN", Const, 0, ""},
-		{"SIOCSIFVNET", Const, 0, ""},
-		{"SIOCSIFXFLAGS", Const, 1, ""},
-		{"SIOCSLIFPHYADDR", Const, 0, ""},
-		{"SIOCSLIFPHYRTABLE", Const, 1, ""},
-		{"SIOCSLIFPHYTTL", Const, 3, ""},
-		{"SIOCSLINKSTR", Const, 1, ""},
-		{"SIOCSLOWAT", Const, 0, ""},
-		{"SIOCSPGRP", Const, 0, ""},
-		{"SIOCSRARP", Const, 0, ""},
-		{"SIOCSSPPPPARAMS", Const, 3, ""},
-		{"SIOCSVH", Const, 1, ""},
-		{"SIOCSVNETID", Const, 3, ""},
-		{"SIOCZIFDATA", Const, 1, ""},
-		{"SIO_GET_EXTENSION_FUNCTION_POINTER", Const, 1, ""},
-		{"SIO_GET_INTERFACE_LIST", Const, 0, ""},
-		{"SIO_KEEPALIVE_VALS", Const, 3, ""},
-		{"SIO_UDP_CONNRESET", Const, 4, ""},
-		{"SOCK_CLOEXEC", Const, 0, ""},
-		{"SOCK_DCCP", Const, 0, ""},
-		{"SOCK_DGRAM", Const, 0, ""},
-		{"SOCK_FLAGS_MASK", Const, 1, ""},
-		{"SOCK_MAXADDRLEN", Const, 0, ""},
-		{"SOCK_NONBLOCK", Const, 0, ""},
-		{"SOCK_NOSIGPIPE", Const, 1, ""},
-		{"SOCK_PACKET", Const, 0, ""},
-		{"SOCK_RAW", Const, 0, ""},
-		{"SOCK_RDM", Const, 0, ""},
-		{"SOCK_SEQPACKET", Const, 0, ""},
-		{"SOCK_STREAM", Const, 0, ""},
-		{"SOL_AAL", Const, 0, ""},
-		{"SOL_ATM", Const, 0, ""},
-		{"SOL_DECNET", Const, 0, ""},
-		{"SOL_ICMPV6", Const, 0, ""},
-		{"SOL_IP", Const, 0, ""},
-		{"SOL_IPV6", Const, 0, ""},
-		{"SOL_IRDA", Const, 0, ""},
-		{"SOL_PACKET", Const, 0, ""},
-		{"SOL_RAW", Const, 0, ""},
-		{"SOL_SOCKET", Const, 0, ""},
-		{"SOL_TCP", Const, 0, ""},
-		{"SOL_X25", Const, 0, ""},
-		{"SOMAXCONN", Const, 0, ""},
-		{"SO_ACCEPTCONN", Const, 0, ""},
-		{"SO_ACCEPTFILTER", Const, 0, ""},
-		{"SO_ATTACH_FILTER", Const, 0, ""},
-		{"SO_BINDANY", Const, 1, ""},
-		{"SO_BINDTODEVICE", Const, 0, ""},
-		{"SO_BINTIME", Const, 0, ""},
-		{"SO_BROADCAST", Const, 0, ""},
-		{"SO_BSDCOMPAT", Const, 0, ""},
-		{"SO_DEBUG", Const, 0, ""},
-		{"SO_DETACH_FILTER", Const, 0, ""},
-		{"SO_DOMAIN", Const, 0, ""},
-		{"SO_DONTROUTE", Const, 0, ""},
-		{"SO_DONTTRUNC", Const, 0, ""},
-		{"SO_ERROR", Const, 0, ""},
-		{"SO_KEEPALIVE", Const, 0, ""},
-		{"SO_LABEL", Const, 0, ""},
-		{"SO_LINGER", Const, 0, ""},
-		{"SO_LINGER_SEC", Const, 0, ""},
-		{"SO_LISTENINCQLEN", Const, 0, ""},
-		{"SO_LISTENQLEN", Const, 0, ""},
-		{"SO_LISTENQLIMIT", Const, 0, ""},
-		{"SO_MARK", Const, 0, ""},
-		{"SO_NETPROC", Const, 1, ""},
-		{"SO_NKE", Const, 0, ""},
-		{"SO_NOADDRERR", Const, 0, ""},
-		{"SO_NOHEADER", Const, 1, ""},
-		{"SO_NOSIGPIPE", Const, 0, ""},
-		{"SO_NOTIFYCONFLICT", Const, 0, ""},
-		{"SO_NO_CHECK", Const, 0, ""},
-		{"SO_NO_DDP", Const, 0, ""},
-		{"SO_NO_OFFLOAD", Const, 0, ""},
-		{"SO_NP_EXTENSIONS", Const, 0, ""},
-		{"SO_NREAD", Const, 0, ""},
-		{"SO_NUMRCVPKT", Const, 16, ""},
-		{"SO_NWRITE", Const, 0, ""},
-		{"SO_OOBINLINE", Const, 0, ""},
-		{"SO_OVERFLOWED", Const, 1, ""},
-		{"SO_PASSCRED", Const, 0, ""},
-		{"SO_PASSSEC", Const, 0, ""},
-		{"SO_PEERCRED", Const, 0, ""},
-		{"SO_PEERLABEL", Const, 0, ""},
-		{"SO_PEERNAME", Const, 0, ""},
-		{"SO_PEERSEC", Const, 0, ""},
-		{"SO_PRIORITY", Const, 0, ""},
-		{"SO_PROTOCOL", Const, 0, ""},
-		{"SO_PROTOTYPE", Const, 1, ""},
-		{"SO_RANDOMPORT", Const, 0, ""},
-		{"SO_RCVBUF", Const, 0, ""},
-		{"SO_RCVBUFFORCE", Const, 0, ""},
-		{"SO_RCVLOWAT", Const, 0, ""},
-		{"SO_RCVTIMEO", Const, 0, ""},
-		{"SO_RESTRICTIONS", Const, 0, ""},
-		{"SO_RESTRICT_DENYIN", Const, 0, ""},
-		{"SO_RESTRICT_DENYOUT", Const, 0, ""},
-		{"SO_RESTRICT_DENYSET", Const, 0, ""},
-		{"SO_REUSEADDR", Const, 0, ""},
-		{"SO_REUSEPORT", Const, 0, ""},
-		{"SO_REUSESHAREUID", Const, 0, ""},
-		{"SO_RTABLE", Const, 1, ""},
-		{"SO_RXQ_OVFL", Const, 0, ""},
-		{"SO_SECURITY_AUTHENTICATION", Const, 0, ""},
-		{"SO_SECURITY_ENCRYPTION_NETWORK", Const, 0, ""},
-		{"SO_SECURITY_ENCRYPTION_TRANSPORT", Const, 0, ""},
-		{"SO_SETFIB", Const, 0, ""},
-		{"SO_SNDBUF", Const, 0, ""},
-		{"SO_SNDBUFFORCE", Const, 0, ""},
-		{"SO_SNDLOWAT", Const, 0, ""},
-		{"SO_SNDTIMEO", Const, 0, ""},
-		{"SO_SPLICE", Const, 1, ""},
-		{"SO_TIMESTAMP", Const, 0, ""},
-		{"SO_TIMESTAMPING", Const, 0, ""},
-		{"SO_TIMESTAMPNS", Const, 0, ""},
-		{"SO_TIMESTAMP_MONOTONIC", Const, 0, ""},
-		{"SO_TYPE", Const, 0, ""},
-		{"SO_UPCALLCLOSEWAIT", Const, 0, ""},
-		{"SO_UPDATE_ACCEPT_CONTEXT", Const, 0, ""},
-		{"SO_UPDATE_CONNECT_CONTEXT", Const, 1, ""},
-		{"SO_USELOOPBACK", Const, 0, ""},
-		{"SO_USER_COOKIE", Const, 1, ""},
-		{"SO_VENDOR", Const, 3, ""},
-		{"SO_WANTMORE", Const, 0, ""},
-		{"SO_WANTOOBFLAG", Const, 0, ""},
-		{"SSLExtraCertChainPolicyPara", Type, 0, ""},
-		{"SSLExtraCertChainPolicyPara.AuthType", Field, 0, ""},
-		{"SSLExtraCertChainPolicyPara.Checks", Field, 0, ""},
-		{"SSLExtraCertChainPolicyPara.ServerName", Field, 0, ""},
-		{"SSLExtraCertChainPolicyPara.Size", Field, 0, ""},
-		{"STANDARD_RIGHTS_ALL", Const, 0, ""},
-		{"STANDARD_RIGHTS_EXECUTE", Const, 0, ""},
-		{"STANDARD_RIGHTS_READ", Const, 0, ""},
-		{"STANDARD_RIGHTS_REQUIRED", Const, 0, ""},
-		{"STANDARD_RIGHTS_WRITE", Const, 0, ""},
-		{"STARTF_USESHOWWINDOW", Const, 0, ""},
-		{"STARTF_USESTDHANDLES", Const, 0, ""},
-		{"STD_ERROR_HANDLE", Const, 0, ""},
-		{"STD_INPUT_HANDLE", Const, 0, ""},
-		{"STD_OUTPUT_HANDLE", Const, 0, ""},
-		{"SUBLANG_ENGLISH_US", Const, 0, ""},
-		{"SW_FORCEMINIMIZE", Const, 0, ""},
-		{"SW_HIDE", Const, 0, ""},
-		{"SW_MAXIMIZE", Const, 0, ""},
-		{"SW_MINIMIZE", Const, 0, ""},
-		{"SW_NORMAL", Const, 0, ""},
-		{"SW_RESTORE", Const, 0, ""},
-		{"SW_SHOW", Const, 0, ""},
-		{"SW_SHOWDEFAULT", Const, 0, ""},
-		{"SW_SHOWMAXIMIZED", Const, 0, ""},
-		{"SW_SHOWMINIMIZED", Const, 0, ""},
-		{"SW_SHOWMINNOACTIVE", Const, 0, ""},
-		{"SW_SHOWNA", Const, 0, ""},
-		{"SW_SHOWNOACTIVATE", Const, 0, ""},
-		{"SW_SHOWNORMAL", Const, 0, ""},
-		{"SYMBOLIC_LINK_FLAG_DIRECTORY", Const, 4, ""},
-		{"SYNCHRONIZE", Const, 0, ""},
-		{"SYSCTL_VERSION", Const, 1, ""},
-		{"SYSCTL_VERS_0", Const, 1, ""},
-		{"SYSCTL_VERS_1", Const, 1, ""},
-		{"SYSCTL_VERS_MASK", Const, 1, ""},
-		{"SYS_ABORT2", Const, 0, ""},
-		{"SYS_ACCEPT", Const, 0, ""},
-		{"SYS_ACCEPT4", Const, 0, ""},
-		{"SYS_ACCEPT_NOCANCEL", Const, 0, ""},
-		{"SYS_ACCESS", Const, 0, ""},
-		{"SYS_ACCESS_EXTENDED", Const, 0, ""},
-		{"SYS_ACCT", Const, 0, ""},
-		{"SYS_ADD_KEY", Const, 0, ""},
-		{"SYS_ADD_PROFIL", Const, 0, ""},
-		{"SYS_ADJFREQ", Const, 1, ""},
-		{"SYS_ADJTIME", Const, 0, ""},
-		{"SYS_ADJTIMEX", Const, 0, ""},
-		{"SYS_AFS_SYSCALL", Const, 0, ""},
-		{"SYS_AIO_CANCEL", Const, 0, ""},
-		{"SYS_AIO_ERROR", Const, 0, ""},
-		{"SYS_AIO_FSYNC", Const, 0, ""},
-		{"SYS_AIO_MLOCK", Const, 14, ""},
-		{"SYS_AIO_READ", Const, 0, ""},
-		{"SYS_AIO_RETURN", Const, 0, ""},
-		{"SYS_AIO_SUSPEND", Const, 0, ""},
-		{"SYS_AIO_SUSPEND_NOCANCEL", Const, 0, ""},
-		{"SYS_AIO_WAITCOMPLETE", Const, 14, ""},
-		{"SYS_AIO_WRITE", Const, 0, ""},
-		{"SYS_ALARM", Const, 0, ""},
-		{"SYS_ARCH_PRCTL", Const, 0, ""},
-		{"SYS_ARM_FADVISE64_64", Const, 0, ""},
-		{"SYS_ARM_SYNC_FILE_RANGE", Const, 0, ""},
-		{"SYS_ATGETMSG", Const, 0, ""},
-		{"SYS_ATPGETREQ", Const, 0, ""},
-		{"SYS_ATPGETRSP", Const, 0, ""},
-		{"SYS_ATPSNDREQ", Const, 0, ""},
-		{"SYS_ATPSNDRSP", Const, 0, ""},
-		{"SYS_ATPUTMSG", Const, 0, ""},
-		{"SYS_ATSOCKET", Const, 0, ""},
-		{"SYS_AUDIT", Const, 0, ""},
-		{"SYS_AUDITCTL", Const, 0, ""},
-		{"SYS_AUDITON", Const, 0, ""},
-		{"SYS_AUDIT_SESSION_JOIN", Const, 0, ""},
-		{"SYS_AUDIT_SESSION_PORT", Const, 0, ""},
-		{"SYS_AUDIT_SESSION_SELF", Const, 0, ""},
-		{"SYS_BDFLUSH", Const, 0, ""},
-		{"SYS_BIND", Const, 0, ""},
-		{"SYS_BINDAT", Const, 3, ""},
-		{"SYS_BREAK", Const, 0, ""},
-		{"SYS_BRK", Const, 0, ""},
-		{"SYS_BSDTHREAD_CREATE", Const, 0, ""},
-		{"SYS_BSDTHREAD_REGISTER", Const, 0, ""},
-		{"SYS_BSDTHREAD_TERMINATE", Const, 0, ""},
-		{"SYS_CAPGET", Const, 0, ""},
-		{"SYS_CAPSET", Const, 0, ""},
-		{"SYS_CAP_ENTER", Const, 0, ""},
-		{"SYS_CAP_FCNTLS_GET", Const, 1, ""},
-		{"SYS_CAP_FCNTLS_LIMIT", Const, 1, ""},
-		{"SYS_CAP_GETMODE", Const, 0, ""},
-		{"SYS_CAP_GETRIGHTS", Const, 0, ""},
-		{"SYS_CAP_IOCTLS_GET", Const, 1, ""},
-		{"SYS_CAP_IOCTLS_LIMIT", Const, 1, ""},
-		{"SYS_CAP_NEW", Const, 0, ""},
-		{"SYS_CAP_RIGHTS_GET", Const, 1, ""},
-		{"SYS_CAP_RIGHTS_LIMIT", Const, 1, ""},
-		{"SYS_CHDIR", Const, 0, ""},
-		{"SYS_CHFLAGS", Const, 0, ""},
-		{"SYS_CHFLAGSAT", Const, 3, ""},
-		{"SYS_CHMOD", Const, 0, ""},
-		{"SYS_CHMOD_EXTENDED", Const, 0, ""},
-		{"SYS_CHOWN", Const, 0, ""},
-		{"SYS_CHOWN32", Const, 0, ""},
-		{"SYS_CHROOT", Const, 0, ""},
-		{"SYS_CHUD", Const, 0, ""},
-		{"SYS_CLOCK_ADJTIME", Const, 0, ""},
-		{"SYS_CLOCK_GETCPUCLOCKID2", Const, 1, ""},
-		{"SYS_CLOCK_GETRES", Const, 0, ""},
-		{"SYS_CLOCK_GETTIME", Const, 0, ""},
-		{"SYS_CLOCK_NANOSLEEP", Const, 0, ""},
-		{"SYS_CLOCK_SETTIME", Const, 0, ""},
-		{"SYS_CLONE", Const, 0, ""},
-		{"SYS_CLOSE", Const, 0, ""},
-		{"SYS_CLOSEFROM", Const, 0, ""},
-		{"SYS_CLOSE_NOCANCEL", Const, 0, ""},
-		{"SYS_CONNECT", Const, 0, ""},
-		{"SYS_CONNECTAT", Const, 3, ""},
-		{"SYS_CONNECT_NOCANCEL", Const, 0, ""},
-		{"SYS_COPYFILE", Const, 0, ""},
-		{"SYS_CPUSET", Const, 0, ""},
-		{"SYS_CPUSET_GETAFFINITY", Const, 0, ""},
-		{"SYS_CPUSET_GETID", Const, 0, ""},
-		{"SYS_CPUSET_SETAFFINITY", Const, 0, ""},
-		{"SYS_CPUSET_SETID", Const, 0, ""},
-		{"SYS_CREAT", Const, 0, ""},
-		{"SYS_CREATE_MODULE", Const, 0, ""},
-		{"SYS_CSOPS", Const, 0, ""},
-		{"SYS_CSOPS_AUDITTOKEN", Const, 16, ""},
-		{"SYS_DELETE", Const, 0, ""},
-		{"SYS_DELETE_MODULE", Const, 0, ""},
-		{"SYS_DUP", Const, 0, ""},
-		{"SYS_DUP2", Const, 0, ""},
-		{"SYS_DUP3", Const, 0, ""},
-		{"SYS_EACCESS", Const, 0, ""},
-		{"SYS_EPOLL_CREATE", Const, 0, ""},
-		{"SYS_EPOLL_CREATE1", Const, 0, ""},
-		{"SYS_EPOLL_CTL", Const, 0, ""},
-		{"SYS_EPOLL_CTL_OLD", Const, 0, ""},
-		{"SYS_EPOLL_PWAIT", Const, 0, ""},
-		{"SYS_EPOLL_WAIT", Const, 0, ""},
-		{"SYS_EPOLL_WAIT_OLD", Const, 0, ""},
-		{"SYS_EVENTFD", Const, 0, ""},
-		{"SYS_EVENTFD2", Const, 0, ""},
-		{"SYS_EXCHANGEDATA", Const, 0, ""},
-		{"SYS_EXECVE", Const, 0, ""},
-		{"SYS_EXIT", Const, 0, ""},
-		{"SYS_EXIT_GROUP", Const, 0, ""},
-		{"SYS_EXTATTRCTL", Const, 0, ""},
-		{"SYS_EXTATTR_DELETE_FD", Const, 0, ""},
-		{"SYS_EXTATTR_DELETE_FILE", Const, 0, ""},
-		{"SYS_EXTATTR_DELETE_LINK", Const, 0, ""},
-		{"SYS_EXTATTR_GET_FD", Const, 0, ""},
-		{"SYS_EXTATTR_GET_FILE", Const, 0, ""},
-		{"SYS_EXTATTR_GET_LINK", Const, 0, ""},
-		{"SYS_EXTATTR_LIST_FD", Const, 0, ""},
-		{"SYS_EXTATTR_LIST_FILE", Const, 0, ""},
-		{"SYS_EXTATTR_LIST_LINK", Const, 0, ""},
-		{"SYS_EXTATTR_SET_FD", Const, 0, ""},
-		{"SYS_EXTATTR_SET_FILE", Const, 0, ""},
-		{"SYS_EXTATTR_SET_LINK", Const, 0, ""},
-		{"SYS_FACCESSAT", Const, 0, ""},
-		{"SYS_FADVISE64", Const, 0, ""},
-		{"SYS_FADVISE64_64", Const, 0, ""},
-		{"SYS_FALLOCATE", Const, 0, ""},
-		{"SYS_FANOTIFY_INIT", Const, 0, ""},
-		{"SYS_FANOTIFY_MARK", Const, 0, ""},
-		{"SYS_FCHDIR", Const, 0, ""},
-		{"SYS_FCHFLAGS", Const, 0, ""},
-		{"SYS_FCHMOD", Const, 0, ""},
-		{"SYS_FCHMODAT", Const, 0, ""},
-		{"SYS_FCHMOD_EXTENDED", Const, 0, ""},
-		{"SYS_FCHOWN", Const, 0, ""},
-		{"SYS_FCHOWN32", Const, 0, ""},
-		{"SYS_FCHOWNAT", Const, 0, ""},
-		{"SYS_FCHROOT", Const, 1, ""},
-		{"SYS_FCNTL", Const, 0, ""},
-		{"SYS_FCNTL64", Const, 0, ""},
-		{"SYS_FCNTL_NOCANCEL", Const, 0, ""},
-		{"SYS_FDATASYNC", Const, 0, ""},
-		{"SYS_FEXECVE", Const, 0, ""},
-		{"SYS_FFCLOCK_GETCOUNTER", Const, 0, ""},
-		{"SYS_FFCLOCK_GETESTIMATE", Const, 0, ""},
-		{"SYS_FFCLOCK_SETESTIMATE", Const, 0, ""},
-		{"SYS_FFSCTL", Const, 0, ""},
-		{"SYS_FGETATTRLIST", Const, 0, ""},
-		{"SYS_FGETXATTR", Const, 0, ""},
-		{"SYS_FHOPEN", Const, 0, ""},
-		{"SYS_FHSTAT", Const, 0, ""},
-		{"SYS_FHSTATFS", Const, 0, ""},
-		{"SYS_FILEPORT_MAKEFD", Const, 0, ""},
-		{"SYS_FILEPORT_MAKEPORT", Const, 0, ""},
-		{"SYS_FKTRACE", Const, 1, ""},
-		{"SYS_FLISTXATTR", Const, 0, ""},
-		{"SYS_FLOCK", Const, 0, ""},
-		{"SYS_FORK", Const, 0, ""},
-		{"SYS_FPATHCONF", Const, 0, ""},
-		{"SYS_FREEBSD6_FTRUNCATE", Const, 0, ""},
-		{"SYS_FREEBSD6_LSEEK", Const, 0, ""},
-		{"SYS_FREEBSD6_MMAP", Const, 0, ""},
-		{"SYS_FREEBSD6_PREAD", Const, 0, ""},
-		{"SYS_FREEBSD6_PWRITE", Const, 0, ""},
-		{"SYS_FREEBSD6_TRUNCATE", Const, 0, ""},
-		{"SYS_FREMOVEXATTR", Const, 0, ""},
-		{"SYS_FSCTL", Const, 0, ""},
-		{"SYS_FSETATTRLIST", Const, 0, ""},
-		{"SYS_FSETXATTR", Const, 0, ""},
-		{"SYS_FSGETPATH", Const, 0, ""},
-		{"SYS_FSTAT", Const, 0, ""},
-		{"SYS_FSTAT64", Const, 0, ""},
-		{"SYS_FSTAT64_EXTENDED", Const, 0, ""},
-		{"SYS_FSTATAT", Const, 0, ""},
-		{"SYS_FSTATAT64", Const, 0, ""},
-		{"SYS_FSTATFS", Const, 0, ""},
-		{"SYS_FSTATFS64", Const, 0, ""},
-		{"SYS_FSTATV", Const, 0, ""},
-		{"SYS_FSTATVFS1", Const, 1, ""},
-		{"SYS_FSTAT_EXTENDED", Const, 0, ""},
-		{"SYS_FSYNC", Const, 0, ""},
-		{"SYS_FSYNC_NOCANCEL", Const, 0, ""},
-		{"SYS_FSYNC_RANGE", Const, 1, ""},
-		{"SYS_FTIME", Const, 0, ""},
-		{"SYS_FTRUNCATE", Const, 0, ""},
-		{"SYS_FTRUNCATE64", Const, 0, ""},
-		{"SYS_FUTEX", Const, 0, ""},
-		{"SYS_FUTIMENS", Const, 1, ""},
-		{"SYS_FUTIMES", Const, 0, ""},
-		{"SYS_FUTIMESAT", Const, 0, ""},
-		{"SYS_GETATTRLIST", Const, 0, ""},
-		{"SYS_GETAUDIT", Const, 0, ""},
-		{"SYS_GETAUDIT_ADDR", Const, 0, ""},
-		{"SYS_GETAUID", Const, 0, ""},
-		{"SYS_GETCONTEXT", Const, 0, ""},
-		{"SYS_GETCPU", Const, 0, ""},
-		{"SYS_GETCWD", Const, 0, ""},
-		{"SYS_GETDENTS", Const, 0, ""},
-		{"SYS_GETDENTS64", Const, 0, ""},
-		{"SYS_GETDIRENTRIES", Const, 0, ""},
-		{"SYS_GETDIRENTRIES64", Const, 0, ""},
-		{"SYS_GETDIRENTRIESATTR", Const, 0, ""},
-		{"SYS_GETDTABLECOUNT", Const, 1, ""},
-		{"SYS_GETDTABLESIZE", Const, 0, ""},
-		{"SYS_GETEGID", Const, 0, ""},
-		{"SYS_GETEGID32", Const, 0, ""},
-		{"SYS_GETEUID", Const, 0, ""},
-		{"SYS_GETEUID32", Const, 0, ""},
-		{"SYS_GETFH", Const, 0, ""},
-		{"SYS_GETFSSTAT", Const, 0, ""},
-		{"SYS_GETFSSTAT64", Const, 0, ""},
-		{"SYS_GETGID", Const, 0, ""},
-		{"SYS_GETGID32", Const, 0, ""},
-		{"SYS_GETGROUPS", Const, 0, ""},
-		{"SYS_GETGROUPS32", Const, 0, ""},
-		{"SYS_GETHOSTUUID", Const, 0, ""},
-		{"SYS_GETITIMER", Const, 0, ""},
-		{"SYS_GETLCID", Const, 0, ""},
-		{"SYS_GETLOGIN", Const, 0, ""},
-		{"SYS_GETLOGINCLASS", Const, 0, ""},
-		{"SYS_GETPEERNAME", Const, 0, ""},
-		{"SYS_GETPGID", Const, 0, ""},
-		{"SYS_GETPGRP", Const, 0, ""},
-		{"SYS_GETPID", Const, 0, ""},
-		{"SYS_GETPMSG", Const, 0, ""},
-		{"SYS_GETPPID", Const, 0, ""},
-		{"SYS_GETPRIORITY", Const, 0, ""},
-		{"SYS_GETRESGID", Const, 0, ""},
-		{"SYS_GETRESGID32", Const, 0, ""},
-		{"SYS_GETRESUID", Const, 0, ""},
-		{"SYS_GETRESUID32", Const, 0, ""},
-		{"SYS_GETRLIMIT", Const, 0, ""},
-		{"SYS_GETRTABLE", Const, 1, ""},
-		{"SYS_GETRUSAGE", Const, 0, ""},
-		{"SYS_GETSGROUPS", Const, 0, ""},
-		{"SYS_GETSID", Const, 0, ""},
-		{"SYS_GETSOCKNAME", Const, 0, ""},
-		{"SYS_GETSOCKOPT", Const, 0, ""},
-		{"SYS_GETTHRID", Const, 1, ""},
-		{"SYS_GETTID", Const, 0, ""},
-		{"SYS_GETTIMEOFDAY", Const, 0, ""},
-		{"SYS_GETUID", Const, 0, ""},
-		{"SYS_GETUID32", Const, 0, ""},
-		{"SYS_GETVFSSTAT", Const, 1, ""},
-		{"SYS_GETWGROUPS", Const, 0, ""},
-		{"SYS_GETXATTR", Const, 0, ""},
-		{"SYS_GET_KERNEL_SYMS", Const, 0, ""},
-		{"SYS_GET_MEMPOLICY", Const, 0, ""},
-		{"SYS_GET_ROBUST_LIST", Const, 0, ""},
-		{"SYS_GET_THREAD_AREA", Const, 0, ""},
-		{"SYS_GSSD_SYSCALL", Const, 14, ""},
-		{"SYS_GTTY", Const, 0, ""},
-		{"SYS_IDENTITYSVC", Const, 0, ""},
-		{"SYS_IDLE", Const, 0, ""},
-		{"SYS_INITGROUPS", Const, 0, ""},
-		{"SYS_INIT_MODULE", Const, 0, ""},
-		{"SYS_INOTIFY_ADD_WATCH", Const, 0, ""},
-		{"SYS_INOTIFY_INIT", Const, 0, ""},
-		{"SYS_INOTIFY_INIT1", Const, 0, ""},
-		{"SYS_INOTIFY_RM_WATCH", Const, 0, ""},
-		{"SYS_IOCTL", Const, 0, ""},
-		{"SYS_IOPERM", Const, 0, ""},
-		{"SYS_IOPL", Const, 0, ""},
-		{"SYS_IOPOLICYSYS", Const, 0, ""},
-		{"SYS_IOPRIO_GET", Const, 0, ""},
-		{"SYS_IOPRIO_SET", Const, 0, ""},
-		{"SYS_IO_CANCEL", Const, 0, ""},
-		{"SYS_IO_DESTROY", Const, 0, ""},
-		{"SYS_IO_GETEVENTS", Const, 0, ""},
-		{"SYS_IO_SETUP", Const, 0, ""},
-		{"SYS_IO_SUBMIT", Const, 0, ""},
-		{"SYS_IPC", Const, 0, ""},
-		{"SYS_ISSETUGID", Const, 0, ""},
-		{"SYS_JAIL", Const, 0, ""},
-		{"SYS_JAIL_ATTACH", Const, 0, ""},
-		{"SYS_JAIL_GET", Const, 0, ""},
-		{"SYS_JAIL_REMOVE", Const, 0, ""},
-		{"SYS_JAIL_SET", Const, 0, ""},
-		{"SYS_KAS_INFO", Const, 16, ""},
-		{"SYS_KDEBUG_TRACE", Const, 0, ""},
-		{"SYS_KENV", Const, 0, ""},
-		{"SYS_KEVENT", Const, 0, ""},
-		{"SYS_KEVENT64", Const, 0, ""},
-		{"SYS_KEXEC_LOAD", Const, 0, ""},
-		{"SYS_KEYCTL", Const, 0, ""},
-		{"SYS_KILL", Const, 0, ""},
-		{"SYS_KLDFIND", Const, 0, ""},
-		{"SYS_KLDFIRSTMOD", Const, 0, ""},
-		{"SYS_KLDLOAD", Const, 0, ""},
-		{"SYS_KLDNEXT", Const, 0, ""},
-		{"SYS_KLDSTAT", Const, 0, ""},
-		{"SYS_KLDSYM", Const, 0, ""},
-		{"SYS_KLDUNLOAD", Const, 0, ""},
-		{"SYS_KLDUNLOADF", Const, 0, ""},
-		{"SYS_KMQ_NOTIFY", Const, 14, ""},
-		{"SYS_KMQ_OPEN", Const, 14, ""},
-		{"SYS_KMQ_SETATTR", Const, 14, ""},
-		{"SYS_KMQ_TIMEDRECEIVE", Const, 14, ""},
-		{"SYS_KMQ_TIMEDSEND", Const, 14, ""},
-		{"SYS_KMQ_UNLINK", Const, 14, ""},
-		{"SYS_KQUEUE", Const, 0, ""},
-		{"SYS_KQUEUE1", Const, 1, ""},
-		{"SYS_KSEM_CLOSE", Const, 14, ""},
-		{"SYS_KSEM_DESTROY", Const, 14, ""},
-		{"SYS_KSEM_GETVALUE", Const, 14, ""},
-		{"SYS_KSEM_INIT", Const, 14, ""},
-		{"SYS_KSEM_OPEN", Const, 14, ""},
-		{"SYS_KSEM_POST", Const, 14, ""},
-		{"SYS_KSEM_TIMEDWAIT", Const, 14, ""},
-		{"SYS_KSEM_TRYWAIT", Const, 14, ""},
-		{"SYS_KSEM_UNLINK", Const, 14, ""},
-		{"SYS_KSEM_WAIT", Const, 14, ""},
-		{"SYS_KTIMER_CREATE", Const, 0, ""},
-		{"SYS_KTIMER_DELETE", Const, 0, ""},
-		{"SYS_KTIMER_GETOVERRUN", Const, 0, ""},
-		{"SYS_KTIMER_GETTIME", Const, 0, ""},
-		{"SYS_KTIMER_SETTIME", Const, 0, ""},
-		{"SYS_KTRACE", Const, 0, ""},
-		{"SYS_LCHFLAGS", Const, 0, ""},
-		{"SYS_LCHMOD", Const, 0, ""},
-		{"SYS_LCHOWN", Const, 0, ""},
-		{"SYS_LCHOWN32", Const, 0, ""},
-		{"SYS_LEDGER", Const, 16, ""},
-		{"SYS_LGETFH", Const, 0, ""},
-		{"SYS_LGETXATTR", Const, 0, ""},
-		{"SYS_LINK", Const, 0, ""},
-		{"SYS_LINKAT", Const, 0, ""},
-		{"SYS_LIO_LISTIO", Const, 0, ""},
-		{"SYS_LISTEN", Const, 0, ""},
-		{"SYS_LISTXATTR", Const, 0, ""},
-		{"SYS_LLISTXATTR", Const, 0, ""},
-		{"SYS_LOCK", Const, 0, ""},
-		{"SYS_LOOKUP_DCOOKIE", Const, 0, ""},
-		{"SYS_LPATHCONF", Const, 0, ""},
-		{"SYS_LREMOVEXATTR", Const, 0, ""},
-		{"SYS_LSEEK", Const, 0, ""},
-		{"SYS_LSETXATTR", Const, 0, ""},
-		{"SYS_LSTAT", Const, 0, ""},
-		{"SYS_LSTAT64", Const, 0, ""},
-		{"SYS_LSTAT64_EXTENDED", Const, 0, ""},
-		{"SYS_LSTATV", Const, 0, ""},
-		{"SYS_LSTAT_EXTENDED", Const, 0, ""},
-		{"SYS_LUTIMES", Const, 0, ""},
-		{"SYS_MAC_SYSCALL", Const, 0, ""},
-		{"SYS_MADVISE", Const, 0, ""},
-		{"SYS_MADVISE1", Const, 0, ""},
-		{"SYS_MAXSYSCALL", Const, 0, ""},
-		{"SYS_MBIND", Const, 0, ""},
-		{"SYS_MIGRATE_PAGES", Const, 0, ""},
-		{"SYS_MINCORE", Const, 0, ""},
-		{"SYS_MINHERIT", Const, 0, ""},
-		{"SYS_MKCOMPLEX", Const, 0, ""},
-		{"SYS_MKDIR", Const, 0, ""},
-		{"SYS_MKDIRAT", Const, 0, ""},
-		{"SYS_MKDIR_EXTENDED", Const, 0, ""},
-		{"SYS_MKFIFO", Const, 0, ""},
-		{"SYS_MKFIFOAT", Const, 0, ""},
-		{"SYS_MKFIFO_EXTENDED", Const, 0, ""},
-		{"SYS_MKNOD", Const, 0, ""},
-		{"SYS_MKNODAT", Const, 0, ""},
-		{"SYS_MLOCK", Const, 0, ""},
-		{"SYS_MLOCKALL", Const, 0, ""},
-		{"SYS_MMAP", Const, 0, ""},
-		{"SYS_MMAP2", Const, 0, ""},
-		{"SYS_MODCTL", Const, 1, ""},
-		{"SYS_MODFIND", Const, 0, ""},
-		{"SYS_MODFNEXT", Const, 0, ""},
-		{"SYS_MODIFY_LDT", Const, 0, ""},
-		{"SYS_MODNEXT", Const, 0, ""},
-		{"SYS_MODSTAT", Const, 0, ""},
-		{"SYS_MODWATCH", Const, 0, ""},
-		{"SYS_MOUNT", Const, 0, ""},
-		{"SYS_MOVE_PAGES", Const, 0, ""},
-		{"SYS_MPROTECT", Const, 0, ""},
-		{"SYS_MPX", Const, 0, ""},
-		{"SYS_MQUERY", Const, 1, ""},
-		{"SYS_MQ_GETSETATTR", Const, 0, ""},
-		{"SYS_MQ_NOTIFY", Const, 0, ""},
-		{"SYS_MQ_OPEN", Const, 0, ""},
-		{"SYS_MQ_TIMEDRECEIVE", Const, 0, ""},
-		{"SYS_MQ_TIMEDSEND", Const, 0, ""},
-		{"SYS_MQ_UNLINK", Const, 0, ""},
-		{"SYS_MREMAP", Const, 0, ""},
-		{"SYS_MSGCTL", Const, 0, ""},
-		{"SYS_MSGGET", Const, 0, ""},
-		{"SYS_MSGRCV", Const, 0, ""},
-		{"SYS_MSGRCV_NOCANCEL", Const, 0, ""},
-		{"SYS_MSGSND", Const, 0, ""},
-		{"SYS_MSGSND_NOCANCEL", Const, 0, ""},
-		{"SYS_MSGSYS", Const, 0, ""},
-		{"SYS_MSYNC", Const, 0, ""},
-		{"SYS_MSYNC_NOCANCEL", Const, 0, ""},
-		{"SYS_MUNLOCK", Const, 0, ""},
-		{"SYS_MUNLOCKALL", Const, 0, ""},
-		{"SYS_MUNMAP", Const, 0, ""},
-		{"SYS_NAME_TO_HANDLE_AT", Const, 0, ""},
-		{"SYS_NANOSLEEP", Const, 0, ""},
-		{"SYS_NEWFSTATAT", Const, 0, ""},
-		{"SYS_NFSCLNT", Const, 0, ""},
-		{"SYS_NFSSERVCTL", Const, 0, ""},
-		{"SYS_NFSSVC", Const, 0, ""},
-		{"SYS_NFSTAT", Const, 0, ""},
-		{"SYS_NICE", Const, 0, ""},
-		{"SYS_NLM_SYSCALL", Const, 14, ""},
-		{"SYS_NLSTAT", Const, 0, ""},
-		{"SYS_NMOUNT", Const, 0, ""},
-		{"SYS_NSTAT", Const, 0, ""},
-		{"SYS_NTP_ADJTIME", Const, 0, ""},
-		{"SYS_NTP_GETTIME", Const, 0, ""},
-		{"SYS_NUMA_GETAFFINITY", Const, 14, ""},
-		{"SYS_NUMA_SETAFFINITY", Const, 14, ""},
-		{"SYS_OABI_SYSCALL_BASE", Const, 0, ""},
-		{"SYS_OBREAK", Const, 0, ""},
-		{"SYS_OLDFSTAT", Const, 0, ""},
-		{"SYS_OLDLSTAT", Const, 0, ""},
-		{"SYS_OLDOLDUNAME", Const, 0, ""},
-		{"SYS_OLDSTAT", Const, 0, ""},
-		{"SYS_OLDUNAME", Const, 0, ""},
-		{"SYS_OPEN", Const, 0, ""},
-		{"SYS_OPENAT", Const, 0, ""},
-		{"SYS_OPENBSD_POLL", Const, 0, ""},
-		{"SYS_OPEN_BY_HANDLE_AT", Const, 0, ""},
-		{"SYS_OPEN_DPROTECTED_NP", Const, 16, ""},
-		{"SYS_OPEN_EXTENDED", Const, 0, ""},
-		{"SYS_OPEN_NOCANCEL", Const, 0, ""},
-		{"SYS_OVADVISE", Const, 0, ""},
-		{"SYS_PACCEPT", Const, 1, ""},
-		{"SYS_PATHCONF", Const, 0, ""},
-		{"SYS_PAUSE", Const, 0, ""},
-		{"SYS_PCICONFIG_IOBASE", Const, 0, ""},
-		{"SYS_PCICONFIG_READ", Const, 0, ""},
-		{"SYS_PCICONFIG_WRITE", Const, 0, ""},
-		{"SYS_PDFORK", Const, 0, ""},
-		{"SYS_PDGETPID", Const, 0, ""},
-		{"SYS_PDKILL", Const, 0, ""},
-		{"SYS_PERF_EVENT_OPEN", Const, 0, ""},
-		{"SYS_PERSONALITY", Const, 0, ""},
-		{"SYS_PID_HIBERNATE", Const, 0, ""},
-		{"SYS_PID_RESUME", Const, 0, ""},
-		{"SYS_PID_SHUTDOWN_SOCKETS", Const, 0, ""},
-		{"SYS_PID_SUSPEND", Const, 0, ""},
-		{"SYS_PIPE", Const, 0, ""},
-		{"SYS_PIPE2", Const, 0, ""},
-		{"SYS_PIVOT_ROOT", Const, 0, ""},
-		{"SYS_PMC_CONTROL", Const, 1, ""},
-		{"SYS_PMC_GET_INFO", Const, 1, ""},
-		{"SYS_POLL", Const, 0, ""},
-		{"SYS_POLLTS", Const, 1, ""},
-		{"SYS_POLL_NOCANCEL", Const, 0, ""},
-		{"SYS_POSIX_FADVISE", Const, 0, ""},
-		{"SYS_POSIX_FALLOCATE", Const, 0, ""},
-		{"SYS_POSIX_OPENPT", Const, 0, ""},
-		{"SYS_POSIX_SPAWN", Const, 0, ""},
-		{"SYS_PPOLL", Const, 0, ""},
-		{"SYS_PRCTL", Const, 0, ""},
-		{"SYS_PREAD", Const, 0, ""},
-		{"SYS_PREAD64", Const, 0, ""},
-		{"SYS_PREADV", Const, 0, ""},
-		{"SYS_PREAD_NOCANCEL", Const, 0, ""},
-		{"SYS_PRLIMIT64", Const, 0, ""},
-		{"SYS_PROCCTL", Const, 3, ""},
-		{"SYS_PROCESS_POLICY", Const, 0, ""},
-		{"SYS_PROCESS_VM_READV", Const, 0, ""},
-		{"SYS_PROCESS_VM_WRITEV", Const, 0, ""},
-		{"SYS_PROC_INFO", Const, 0, ""},
-		{"SYS_PROF", Const, 0, ""},
-		{"SYS_PROFIL", Const, 0, ""},
-		{"SYS_PSELECT", Const, 0, ""},
-		{"SYS_PSELECT6", Const, 0, ""},
-		{"SYS_PSET_ASSIGN", Const, 1, ""},
-		{"SYS_PSET_CREATE", Const, 1, ""},
-		{"SYS_PSET_DESTROY", Const, 1, ""},
-		{"SYS_PSYNCH_CVBROAD", Const, 0, ""},
-		{"SYS_PSYNCH_CVCLRPREPOST", Const, 0, ""},
-		{"SYS_PSYNCH_CVSIGNAL", Const, 0, ""},
-		{"SYS_PSYNCH_CVWAIT", Const, 0, ""},
-		{"SYS_PSYNCH_MUTEXDROP", Const, 0, ""},
-		{"SYS_PSYNCH_MUTEXWAIT", Const, 0, ""},
-		{"SYS_PSYNCH_RW_DOWNGRADE", Const, 0, ""},
-		{"SYS_PSYNCH_RW_LONGRDLOCK", Const, 0, ""},
-		{"SYS_PSYNCH_RW_RDLOCK", Const, 0, ""},
-		{"SYS_PSYNCH_RW_UNLOCK", Const, 0, ""},
-		{"SYS_PSYNCH_RW_UNLOCK2", Const, 0, ""},
-		{"SYS_PSYNCH_RW_UPGRADE", Const, 0, ""},
-		{"SYS_PSYNCH_RW_WRLOCK", Const, 0, ""},
-		{"SYS_PSYNCH_RW_YIELDWRLOCK", Const, 0, ""},
-		{"SYS_PTRACE", Const, 0, ""},
-		{"SYS_PUTPMSG", Const, 0, ""},
-		{"SYS_PWRITE", Const, 0, ""},
-		{"SYS_PWRITE64", Const, 0, ""},
-		{"SYS_PWRITEV", Const, 0, ""},
-		{"SYS_PWRITE_NOCANCEL", Const, 0, ""},
-		{"SYS_QUERY_MODULE", Const, 0, ""},
-		{"SYS_QUOTACTL", Const, 0, ""},
-		{"SYS_RASCTL", Const, 1, ""},
-		{"SYS_RCTL_ADD_RULE", Const, 0, ""},
-		{"SYS_RCTL_GET_LIMITS", Const, 0, ""},
-		{"SYS_RCTL_GET_RACCT", Const, 0, ""},
-		{"SYS_RCTL_GET_RULES", Const, 0, ""},
-		{"SYS_RCTL_REMOVE_RULE", Const, 0, ""},
-		{"SYS_READ", Const, 0, ""},
-		{"SYS_READAHEAD", Const, 0, ""},
-		{"SYS_READDIR", Const, 0, ""},
-		{"SYS_READLINK", Const, 0, ""},
-		{"SYS_READLINKAT", Const, 0, ""},
-		{"SYS_READV", Const, 0, ""},
-		{"SYS_READV_NOCANCEL", Const, 0, ""},
-		{"SYS_READ_NOCANCEL", Const, 0, ""},
-		{"SYS_REBOOT", Const, 0, ""},
-		{"SYS_RECV", Const, 0, ""},
-		{"SYS_RECVFROM", Const, 0, ""},
-		{"SYS_RECVFROM_NOCANCEL", Const, 0, ""},
-		{"SYS_RECVMMSG", Const, 0, ""},
-		{"SYS_RECVMSG", Const, 0, ""},
-		{"SYS_RECVMSG_NOCANCEL", Const, 0, ""},
-		{"SYS_REMAP_FILE_PAGES", Const, 0, ""},
-		{"SYS_REMOVEXATTR", Const, 0, ""},
-		{"SYS_RENAME", Const, 0, ""},
-		{"SYS_RENAMEAT", Const, 0, ""},
-		{"SYS_REQUEST_KEY", Const, 0, ""},
-		{"SYS_RESTART_SYSCALL", Const, 0, ""},
-		{"SYS_REVOKE", Const, 0, ""},
-		{"SYS_RFORK", Const, 0, ""},
-		{"SYS_RMDIR", Const, 0, ""},
-		{"SYS_RTPRIO", Const, 0, ""},
-		{"SYS_RTPRIO_THREAD", Const, 0, ""},
-		{"SYS_RT_SIGACTION", Const, 0, ""},
-		{"SYS_RT_SIGPENDING", Const, 0, ""},
-		{"SYS_RT_SIGPROCMASK", Const, 0, ""},
-		{"SYS_RT_SIGQUEUEINFO", Const, 0, ""},
-		{"SYS_RT_SIGRETURN", Const, 0, ""},
-		{"SYS_RT_SIGSUSPEND", Const, 0, ""},
-		{"SYS_RT_SIGTIMEDWAIT", Const, 0, ""},
-		{"SYS_RT_TGSIGQUEUEINFO", Const, 0, ""},
-		{"SYS_SBRK", Const, 0, ""},
-		{"SYS_SCHED_GETAFFINITY", Const, 0, ""},
-		{"SYS_SCHED_GETPARAM", Const, 0, ""},
-		{"SYS_SCHED_GETSCHEDULER", Const, 0, ""},
-		{"SYS_SCHED_GET_PRIORITY_MAX", Const, 0, ""},
-		{"SYS_SCHED_GET_PRIORITY_MIN", Const, 0, ""},
-		{"SYS_SCHED_RR_GET_INTERVAL", Const, 0, ""},
-		{"SYS_SCHED_SETAFFINITY", Const, 0, ""},
-		{"SYS_SCHED_SETPARAM", Const, 0, ""},
-		{"SYS_SCHED_SETSCHEDULER", Const, 0, ""},
-		{"SYS_SCHED_YIELD", Const, 0, ""},
-		{"SYS_SCTP_GENERIC_RECVMSG", Const, 0, ""},
-		{"SYS_SCTP_GENERIC_SENDMSG", Const, 0, ""},
-		{"SYS_SCTP_GENERIC_SENDMSG_IOV", Const, 0, ""},
-		{"SYS_SCTP_PEELOFF", Const, 0, ""},
-		{"SYS_SEARCHFS", Const, 0, ""},
-		{"SYS_SECURITY", Const, 0, ""},
-		{"SYS_SELECT", Const, 0, ""},
-		{"SYS_SELECT_NOCANCEL", Const, 0, ""},
-		{"SYS_SEMCONFIG", Const, 1, ""},
-		{"SYS_SEMCTL", Const, 0, ""},
-		{"SYS_SEMGET", Const, 0, ""},
-		{"SYS_SEMOP", Const, 0, ""},
-		{"SYS_SEMSYS", Const, 0, ""},
-		{"SYS_SEMTIMEDOP", Const, 0, ""},
-		{"SYS_SEM_CLOSE", Const, 0, ""},
-		{"SYS_SEM_DESTROY", Const, 0, ""},
-		{"SYS_SEM_GETVALUE", Const, 0, ""},
-		{"SYS_SEM_INIT", Const, 0, ""},
-		{"SYS_SEM_OPEN", Const, 0, ""},
-		{"SYS_SEM_POST", Const, 0, ""},
-		{"SYS_SEM_TRYWAIT", Const, 0, ""},
-		{"SYS_SEM_UNLINK", Const, 0, ""},
-		{"SYS_SEM_WAIT", Const, 0, ""},
-		{"SYS_SEM_WAIT_NOCANCEL", Const, 0, ""},
-		{"SYS_SEND", Const, 0, ""},
-		{"SYS_SENDFILE", Const, 0, ""},
-		{"SYS_SENDFILE64", Const, 0, ""},
-		{"SYS_SENDMMSG", Const, 0, ""},
-		{"SYS_SENDMSG", Const, 0, ""},
-		{"SYS_SENDMSG_NOCANCEL", Const, 0, ""},
-		{"SYS_SENDTO", Const, 0, ""},
-		{"SYS_SENDTO_NOCANCEL", Const, 0, ""},
-		{"SYS_SETATTRLIST", Const, 0, ""},
-		{"SYS_SETAUDIT", Const, 0, ""},
-		{"SYS_SETAUDIT_ADDR", Const, 0, ""},
-		{"SYS_SETAUID", Const, 0, ""},
-		{"SYS_SETCONTEXT", Const, 0, ""},
-		{"SYS_SETDOMAINNAME", Const, 0, ""},
-		{"SYS_SETEGID", Const, 0, ""},
-		{"SYS_SETEUID", Const, 0, ""},
-		{"SYS_SETFIB", Const, 0, ""},
-		{"SYS_SETFSGID", Const, 0, ""},
-		{"SYS_SETFSGID32", Const, 0, ""},
-		{"SYS_SETFSUID", Const, 0, ""},
-		{"SYS_SETFSUID32", Const, 0, ""},
-		{"SYS_SETGID", Const, 0, ""},
-		{"SYS_SETGID32", Const, 0, ""},
-		{"SYS_SETGROUPS", Const, 0, ""},
-		{"SYS_SETGROUPS32", Const, 0, ""},
-		{"SYS_SETHOSTNAME", Const, 0, ""},
-		{"SYS_SETITIMER", Const, 0, ""},
-		{"SYS_SETLCID", Const, 0, ""},
-		{"SYS_SETLOGIN", Const, 0, ""},
-		{"SYS_SETLOGINCLASS", Const, 0, ""},
-		{"SYS_SETNS", Const, 0, ""},
-		{"SYS_SETPGID", Const, 0, ""},
-		{"SYS_SETPRIORITY", Const, 0, ""},
-		{"SYS_SETPRIVEXEC", Const, 0, ""},
-		{"SYS_SETREGID", Const, 0, ""},
-		{"SYS_SETREGID32", Const, 0, ""},
-		{"SYS_SETRESGID", Const, 0, ""},
-		{"SYS_SETRESGID32", Const, 0, ""},
-		{"SYS_SETRESUID", Const, 0, ""},
-		{"SYS_SETRESUID32", Const, 0, ""},
-		{"SYS_SETREUID", Const, 0, ""},
-		{"SYS_SETREUID32", Const, 0, ""},
-		{"SYS_SETRLIMIT", Const, 0, ""},
-		{"SYS_SETRTABLE", Const, 1, ""},
-		{"SYS_SETSGROUPS", Const, 0, ""},
-		{"SYS_SETSID", Const, 0, ""},
-		{"SYS_SETSOCKOPT", Const, 0, ""},
-		{"SYS_SETTID", Const, 0, ""},
-		{"SYS_SETTID_WITH_PID", Const, 0, ""},
-		{"SYS_SETTIMEOFDAY", Const, 0, ""},
-		{"SYS_SETUID", Const, 0, ""},
-		{"SYS_SETUID32", Const, 0, ""},
-		{"SYS_SETWGROUPS", Const, 0, ""},
-		{"SYS_SETXATTR", Const, 0, ""},
-		{"SYS_SET_MEMPOLICY", Const, 0, ""},
-		{"SYS_SET_ROBUST_LIST", Const, 0, ""},
-		{"SYS_SET_THREAD_AREA", Const, 0, ""},
-		{"SYS_SET_TID_ADDRESS", Const, 0, ""},
-		{"SYS_SGETMASK", Const, 0, ""},
-		{"SYS_SHARED_REGION_CHECK_NP", Const, 0, ""},
-		{"SYS_SHARED_REGION_MAP_AND_SLIDE_NP", Const, 0, ""},
-		{"SYS_SHMAT", Const, 0, ""},
-		{"SYS_SHMCTL", Const, 0, ""},
-		{"SYS_SHMDT", Const, 0, ""},
-		{"SYS_SHMGET", Const, 0, ""},
-		{"SYS_SHMSYS", Const, 0, ""},
-		{"SYS_SHM_OPEN", Const, 0, ""},
-		{"SYS_SHM_UNLINK", Const, 0, ""},
-		{"SYS_SHUTDOWN", Const, 0, ""},
-		{"SYS_SIGACTION", Const, 0, ""},
-		{"SYS_SIGALTSTACK", Const, 0, ""},
-		{"SYS_SIGNAL", Const, 0, ""},
-		{"SYS_SIGNALFD", Const, 0, ""},
-		{"SYS_SIGNALFD4", Const, 0, ""},
-		{"SYS_SIGPENDING", Const, 0, ""},
-		{"SYS_SIGPROCMASK", Const, 0, ""},
-		{"SYS_SIGQUEUE", Const, 0, ""},
-		{"SYS_SIGQUEUEINFO", Const, 1, ""},
-		{"SYS_SIGRETURN", Const, 0, ""},
-		{"SYS_SIGSUSPEND", Const, 0, ""},
-		{"SYS_SIGSUSPEND_NOCANCEL", Const, 0, ""},
-		{"SYS_SIGTIMEDWAIT", Const, 0, ""},
-		{"SYS_SIGWAIT", Const, 0, ""},
-		{"SYS_SIGWAITINFO", Const, 0, ""},
-		{"SYS_SOCKET", Const, 0, ""},
-		{"SYS_SOCKETCALL", Const, 0, ""},
-		{"SYS_SOCKETPAIR", Const, 0, ""},
-		{"SYS_SPLICE", Const, 0, ""},
-		{"SYS_SSETMASK", Const, 0, ""},
-		{"SYS_SSTK", Const, 0, ""},
-		{"SYS_STACK_SNAPSHOT", Const, 0, ""},
-		{"SYS_STAT", Const, 0, ""},
-		{"SYS_STAT64", Const, 0, ""},
-		{"SYS_STAT64_EXTENDED", Const, 0, ""},
-		{"SYS_STATFS", Const, 0, ""},
-		{"SYS_STATFS64", Const, 0, ""},
-		{"SYS_STATV", Const, 0, ""},
-		{"SYS_STATVFS1", Const, 1, ""},
-		{"SYS_STAT_EXTENDED", Const, 0, ""},
-		{"SYS_STIME", Const, 0, ""},
-		{"SYS_STTY", Const, 0, ""},
-		{"SYS_SWAPCONTEXT", Const, 0, ""},
-		{"SYS_SWAPCTL", Const, 1, ""},
-		{"SYS_SWAPOFF", Const, 0, ""},
-		{"SYS_SWAPON", Const, 0, ""},
-		{"SYS_SYMLINK", Const, 0, ""},
-		{"SYS_SYMLINKAT", Const, 0, ""},
-		{"SYS_SYNC", Const, 0, ""},
-		{"SYS_SYNCFS", Const, 0, ""},
-		{"SYS_SYNC_FILE_RANGE", Const, 0, ""},
-		{"SYS_SYSARCH", Const, 0, ""},
-		{"SYS_SYSCALL", Const, 0, ""},
-		{"SYS_SYSCALL_BASE", Const, 0, ""},
-		{"SYS_SYSFS", Const, 0, ""},
-		{"SYS_SYSINFO", Const, 0, ""},
-		{"SYS_SYSLOG", Const, 0, ""},
-		{"SYS_TEE", Const, 0, ""},
-		{"SYS_TGKILL", Const, 0, ""},
-		{"SYS_THREAD_SELFID", Const, 0, ""},
-		{"SYS_THR_CREATE", Const, 0, ""},
-		{"SYS_THR_EXIT", Const, 0, ""},
-		{"SYS_THR_KILL", Const, 0, ""},
-		{"SYS_THR_KILL2", Const, 0, ""},
-		{"SYS_THR_NEW", Const, 0, ""},
-		{"SYS_THR_SELF", Const, 0, ""},
-		{"SYS_THR_SET_NAME", Const, 0, ""},
-		{"SYS_THR_SUSPEND", Const, 0, ""},
-		{"SYS_THR_WAKE", Const, 0, ""},
-		{"SYS_TIME", Const, 0, ""},
-		{"SYS_TIMERFD_CREATE", Const, 0, ""},
-		{"SYS_TIMERFD_GETTIME", Const, 0, ""},
-		{"SYS_TIMERFD_SETTIME", Const, 0, ""},
-		{"SYS_TIMER_CREATE", Const, 0, ""},
-		{"SYS_TIMER_DELETE", Const, 0, ""},
-		{"SYS_TIMER_GETOVERRUN", Const, 0, ""},
-		{"SYS_TIMER_GETTIME", Const, 0, ""},
-		{"SYS_TIMER_SETTIME", Const, 0, ""},
-		{"SYS_TIMES", Const, 0, ""},
-		{"SYS_TKILL", Const, 0, ""},
-		{"SYS_TRUNCATE", Const, 0, ""},
-		{"SYS_TRUNCATE64", Const, 0, ""},
-		{"SYS_TUXCALL", Const, 0, ""},
-		{"SYS_UGETRLIMIT", Const, 0, ""},
-		{"SYS_ULIMIT", Const, 0, ""},
-		{"SYS_UMASK", Const, 0, ""},
-		{"SYS_UMASK_EXTENDED", Const, 0, ""},
-		{"SYS_UMOUNT", Const, 0, ""},
-		{"SYS_UMOUNT2", Const, 0, ""},
-		{"SYS_UNAME", Const, 0, ""},
-		{"SYS_UNDELETE", Const, 0, ""},
-		{"SYS_UNLINK", Const, 0, ""},
-		{"SYS_UNLINKAT", Const, 0, ""},
-		{"SYS_UNMOUNT", Const, 0, ""},
-		{"SYS_UNSHARE", Const, 0, ""},
-		{"SYS_USELIB", Const, 0, ""},
-		{"SYS_USTAT", Const, 0, ""},
-		{"SYS_UTIME", Const, 0, ""},
-		{"SYS_UTIMENSAT", Const, 0, ""},
-		{"SYS_UTIMES", Const, 0, ""},
-		{"SYS_UTRACE", Const, 0, ""},
-		{"SYS_UUIDGEN", Const, 0, ""},
-		{"SYS_VADVISE", Const, 1, ""},
-		{"SYS_VFORK", Const, 0, ""},
-		{"SYS_VHANGUP", Const, 0, ""},
-		{"SYS_VM86", Const, 0, ""},
-		{"SYS_VM86OLD", Const, 0, ""},
-		{"SYS_VMSPLICE", Const, 0, ""},
-		{"SYS_VM_PRESSURE_MONITOR", Const, 0, ""},
-		{"SYS_VSERVER", Const, 0, ""},
-		{"SYS_WAIT4", Const, 0, ""},
-		{"SYS_WAIT4_NOCANCEL", Const, 0, ""},
-		{"SYS_WAIT6", Const, 1, ""},
-		{"SYS_WAITEVENT", Const, 0, ""},
-		{"SYS_WAITID", Const, 0, ""},
-		{"SYS_WAITID_NOCANCEL", Const, 0, ""},
-		{"SYS_WAITPID", Const, 0, ""},
-		{"SYS_WATCHEVENT", Const, 0, ""},
-		{"SYS_WORKQ_KERNRETURN", Const, 0, ""},
-		{"SYS_WORKQ_OPEN", Const, 0, ""},
-		{"SYS_WRITE", Const, 0, ""},
-		{"SYS_WRITEV", Const, 0, ""},
-		{"SYS_WRITEV_NOCANCEL", Const, 0, ""},
-		{"SYS_WRITE_NOCANCEL", Const, 0, ""},
-		{"SYS_YIELD", Const, 0, ""},
-		{"SYS__LLSEEK", Const, 0, ""},
-		{"SYS__LWP_CONTINUE", Const, 1, ""},
-		{"SYS__LWP_CREATE", Const, 1, ""},
-		{"SYS__LWP_CTL", Const, 1, ""},
-		{"SYS__LWP_DETACH", Const, 1, ""},
-		{"SYS__LWP_EXIT", Const, 1, ""},
-		{"SYS__LWP_GETNAME", Const, 1, ""},
-		{"SYS__LWP_GETPRIVATE", Const, 1, ""},
-		{"SYS__LWP_KILL", Const, 1, ""},
-		{"SYS__LWP_PARK", Const, 1, ""},
-		{"SYS__LWP_SELF", Const, 1, ""},
-		{"SYS__LWP_SETNAME", Const, 1, ""},
-		{"SYS__LWP_SETPRIVATE", Const, 1, ""},
-		{"SYS__LWP_SUSPEND", Const, 1, ""},
-		{"SYS__LWP_UNPARK", Const, 1, ""},
-		{"SYS__LWP_UNPARK_ALL", Const, 1, ""},
-		{"SYS__LWP_WAIT", Const, 1, ""},
-		{"SYS__LWP_WAKEUP", Const, 1, ""},
-		{"SYS__NEWSELECT", Const, 0, ""},
-		{"SYS__PSET_BIND", Const, 1, ""},
-		{"SYS__SCHED_GETAFFINITY", Const, 1, ""},
-		{"SYS__SCHED_GETPARAM", Const, 1, ""},
-		{"SYS__SCHED_SETAFFINITY", Const, 1, ""},
-		{"SYS__SCHED_SETPARAM", Const, 1, ""},
-		{"SYS__SYSCTL", Const, 0, ""},
-		{"SYS__UMTX_LOCK", Const, 0, ""},
-		{"SYS__UMTX_OP", Const, 0, ""},
-		{"SYS__UMTX_UNLOCK", Const, 0, ""},
-		{"SYS___ACL_ACLCHECK_FD", Const, 0, ""},
-		{"SYS___ACL_ACLCHECK_FILE", Const, 0, ""},
-		{"SYS___ACL_ACLCHECK_LINK", Const, 0, ""},
-		{"SYS___ACL_DELETE_FD", Const, 0, ""},
-		{"SYS___ACL_DELETE_FILE", Const, 0, ""},
-		{"SYS___ACL_DELETE_LINK", Const, 0, ""},
-		{"SYS___ACL_GET_FD", Const, 0, ""},
-		{"SYS___ACL_GET_FILE", Const, 0, ""},
-		{"SYS___ACL_GET_LINK", Const, 0, ""},
-		{"SYS___ACL_SET_FD", Const, 0, ""},
-		{"SYS___ACL_SET_FILE", Const, 0, ""},
-		{"SYS___ACL_SET_LINK", Const, 0, ""},
-		{"SYS___CAP_RIGHTS_GET", Const, 14, ""},
-		{"SYS___CLONE", Const, 1, ""},
-		{"SYS___DISABLE_THREADSIGNAL", Const, 0, ""},
-		{"SYS___GETCWD", Const, 0, ""},
-		{"SYS___GETLOGIN", Const, 1, ""},
-		{"SYS___GET_TCB", Const, 1, ""},
-		{"SYS___MAC_EXECVE", Const, 0, ""},
-		{"SYS___MAC_GETFSSTAT", Const, 0, ""},
-		{"SYS___MAC_GET_FD", Const, 0, ""},
-		{"SYS___MAC_GET_FILE", Const, 0, ""},
-		{"SYS___MAC_GET_LCID", Const, 0, ""},
-		{"SYS___MAC_GET_LCTX", Const, 0, ""},
-		{"SYS___MAC_GET_LINK", Const, 0, ""},
-		{"SYS___MAC_GET_MOUNT", Const, 0, ""},
-		{"SYS___MAC_GET_PID", Const, 0, ""},
-		{"SYS___MAC_GET_PROC", Const, 0, ""},
-		{"SYS___MAC_MOUNT", Const, 0, ""},
-		{"SYS___MAC_SET_FD", Const, 0, ""},
-		{"SYS___MAC_SET_FILE", Const, 0, ""},
-		{"SYS___MAC_SET_LCTX", Const, 0, ""},
-		{"SYS___MAC_SET_LINK", Const, 0, ""},
-		{"SYS___MAC_SET_PROC", Const, 0, ""},
-		{"SYS___MAC_SYSCALL", Const, 0, ""},
-		{"SYS___OLD_SEMWAIT_SIGNAL", Const, 0, ""},
-		{"SYS___OLD_SEMWAIT_SIGNAL_NOCANCEL", Const, 0, ""},
-		{"SYS___POSIX_CHOWN", Const, 1, ""},
-		{"SYS___POSIX_FCHOWN", Const, 1, ""},
-		{"SYS___POSIX_LCHOWN", Const, 1, ""},
-		{"SYS___POSIX_RENAME", Const, 1, ""},
-		{"SYS___PTHREAD_CANCELED", Const, 0, ""},
-		{"SYS___PTHREAD_CHDIR", Const, 0, ""},
-		{"SYS___PTHREAD_FCHDIR", Const, 0, ""},
-		{"SYS___PTHREAD_KILL", Const, 0, ""},
-		{"SYS___PTHREAD_MARKCANCEL", Const, 0, ""},
-		{"SYS___PTHREAD_SIGMASK", Const, 0, ""},
-		{"SYS___QUOTACTL", Const, 1, ""},
-		{"SYS___SEMCTL", Const, 1, ""},
-		{"SYS___SEMWAIT_SIGNAL", Const, 0, ""},
-		{"SYS___SEMWAIT_SIGNAL_NOCANCEL", Const, 0, ""},
-		{"SYS___SETLOGIN", Const, 1, ""},
-		{"SYS___SETUGID", Const, 0, ""},
-		{"SYS___SET_TCB", Const, 1, ""},
-		{"SYS___SIGACTION_SIGTRAMP", Const, 1, ""},
-		{"SYS___SIGTIMEDWAIT", Const, 1, ""},
-		{"SYS___SIGWAIT", Const, 0, ""},
-		{"SYS___SIGWAIT_NOCANCEL", Const, 0, ""},
-		{"SYS___SYSCTL", Const, 0, ""},
-		{"SYS___TFORK", Const, 1, ""},
-		{"SYS___THREXIT", Const, 1, ""},
-		{"SYS___THRSIGDIVERT", Const, 1, ""},
-		{"SYS___THRSLEEP", Const, 1, ""},
-		{"SYS___THRWAKEUP", Const, 1, ""},
-		{"S_ARCH1", Const, 1, ""},
-		{"S_ARCH2", Const, 1, ""},
-		{"S_BLKSIZE", Const, 0, ""},
-		{"S_IEXEC", Const, 0, ""},
-		{"S_IFBLK", Const, 0, ""},
-		{"S_IFCHR", Const, 0, ""},
-		{"S_IFDIR", Const, 0, ""},
-		{"S_IFIFO", Const, 0, ""},
-		{"S_IFLNK", Const, 0, ""},
-		{"S_IFMT", Const, 0, ""},
-		{"S_IFREG", Const, 0, ""},
-		{"S_IFSOCK", Const, 0, ""},
-		{"S_IFWHT", Const, 0, ""},
-		{"S_IREAD", Const, 0, ""},
-		{"S_IRGRP", Const, 0, ""},
-		{"S_IROTH", Const, 0, ""},
-		{"S_IRUSR", Const, 0, ""},
-		{"S_IRWXG", Const, 0, ""},
-		{"S_IRWXO", Const, 0, ""},
-		{"S_IRWXU", Const, 0, ""},
-		{"S_ISGID", Const, 0, ""},
-		{"S_ISTXT", Const, 0, ""},
-		{"S_ISUID", Const, 0, ""},
-		{"S_ISVTX", Const, 0, ""},
-		{"S_IWGRP", Const, 0, ""},
-		{"S_IWOTH", Const, 0, ""},
-		{"S_IWRITE", Const, 0, ""},
-		{"S_IWUSR", Const, 0, ""},
-		{"S_IXGRP", Const, 0, ""},
-		{"S_IXOTH", Const, 0, ""},
-		{"S_IXUSR", Const, 0, ""},
-		{"S_LOGIN_SET", Const, 1, ""},
-		{"SecurityAttributes", Type, 0, ""},
-		{"SecurityAttributes.InheritHandle", Field, 0, ""},
-		{"SecurityAttributes.Length", Field, 0, ""},
-		{"SecurityAttributes.SecurityDescriptor", Field, 0, ""},
-		{"Seek", Func, 0, "func(fd int, offset int64, whence int) (off int64, err error)"},
-		{"Select", Func, 0, "func(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error)"},
-		{"Sendfile", Func, 0, "func(outfd int, infd int, offset *int64, count int) (written int, err error)"},
-		{"Sendmsg", Func, 0, "func(fd int, p []byte, oob []byte, to Sockaddr, flags int) (err error)"},
-		{"SendmsgN", Func, 3, "func(fd int, p []byte, oob []byte, to Sockaddr, flags int) (n int, err error)"},
-		{"Sendto", Func, 0, "func(fd int, p []byte, flags int, to Sockaddr) (err error)"},
-		{"Servent", Type, 0, ""},
-		{"Servent.Aliases", Field, 0, ""},
-		{"Servent.Name", Field, 0, ""},
-		{"Servent.Port", Field, 0, ""},
-		{"Servent.Proto", Field, 0, ""},
-		{"SetBpf", Func, 0, ""},
-		{"SetBpfBuflen", Func, 0, ""},
-		{"SetBpfDatalink", Func, 0, ""},
-		{"SetBpfHeadercmpl", Func, 0, ""},
-		{"SetBpfImmediate", Func, 0, ""},
-		{"SetBpfInterface", Func, 0, ""},
-		{"SetBpfPromisc", Func, 0, ""},
-		{"SetBpfTimeout", Func, 0, ""},
-		{"SetCurrentDirectory", Func, 0, ""},
-		{"SetEndOfFile", Func, 0, ""},
-		{"SetEnvironmentVariable", Func, 0, ""},
-		{"SetFileAttributes", Func, 0, ""},
-		{"SetFileCompletionNotificationModes", Func, 2, ""},
-		{"SetFilePointer", Func, 0, ""},
-		{"SetFileTime", Func, 0, ""},
-		{"SetHandleInformation", Func, 0, ""},
-		{"SetKevent", Func, 0, ""},
-		{"SetLsfPromisc", Func, 0, "func(name string, m bool) error"},
-		{"SetNonblock", Func, 0, "func(fd int, nonblocking bool) (err error)"},
-		{"Setdomainname", Func, 0, "func(p []byte) (err error)"},
-		{"Setegid", Func, 0, "func(egid int) (err error)"},
-		{"Setenv", Func, 0, "func(key string, value string) error"},
-		{"Seteuid", Func, 0, "func(euid int) (err error)"},
-		{"Setfsgid", Func, 0, "func(gid int) (err error)"},
-		{"Setfsuid", Func, 0, "func(uid int) (err error)"},
-		{"Setgid", Func, 0, "func(gid int) (err error)"},
-		{"Setgroups", Func, 0, "func(gids []int) (err error)"},
-		{"Sethostname", Func, 0, "func(p []byte) (err error)"},
-		{"Setlogin", Func, 0, ""},
-		{"Setpgid", Func, 0, "func(pid int, pgid int) (err error)"},
-		{"Setpriority", Func, 0, "func(which int, who int, prio int) (err error)"},
-		{"Setprivexec", Func, 0, ""},
-		{"Setregid", Func, 0, "func(rgid int, egid int) (err error)"},
-		{"Setresgid", Func, 0, "func(rgid int, egid int, sgid int) (err error)"},
-		{"Setresuid", Func, 0, "func(ruid int, euid int, suid int) (err error)"},
-		{"Setreuid", Func, 0, "func(ruid int, euid int) (err error)"},
-		{"Setrlimit", Func, 0, "func(resource int, rlim *Rlimit) error"},
-		{"Setsid", Func, 0, "func() (pid int, err error)"},
-		{"Setsockopt", Func, 0, ""},
-		{"SetsockoptByte", Func, 0, "func(fd int, level int, opt int, value byte) (err error)"},
-		{"SetsockoptICMPv6Filter", Func, 2, "func(fd int, level int, opt int, filter *ICMPv6Filter) error"},
-		{"SetsockoptIPMreq", Func, 0, "func(fd int, level int, opt int, mreq *IPMreq) (err error)"},
-		{"SetsockoptIPMreqn", Func, 0, "func(fd int, level int, opt int, mreq *IPMreqn) (err error)"},
-		{"SetsockoptIPv6Mreq", Func, 0, "func(fd int, level int, opt int, mreq *IPv6Mreq) (err error)"},
-		{"SetsockoptInet4Addr", Func, 0, "func(fd int, level int, opt int, value [4]byte) (err error)"},
-		{"SetsockoptInt", Func, 0, "func(fd int, level int, opt int, value int) (err error)"},
-		{"SetsockoptLinger", Func, 0, "func(fd int, level int, opt int, l *Linger) (err error)"},
-		{"SetsockoptString", Func, 0, "func(fd int, level int, opt int, s string) (err error)"},
-		{"SetsockoptTimeval", Func, 0, "func(fd int, level int, opt int, tv *Timeval) (err error)"},
-		{"Settimeofday", Func, 0, "func(tv *Timeval) (err error)"},
-		{"Setuid", Func, 0, "func(uid int) (err error)"},
-		{"Setxattr", Func, 1, "func(path string, attr string, data []byte, flags int) (err error)"},
-		{"Shutdown", Func, 0, "func(fd int, how int) (err error)"},
-		{"SidTypeAlias", Const, 0, ""},
-		{"SidTypeComputer", Const, 0, ""},
-		{"SidTypeDeletedAccount", Const, 0, ""},
-		{"SidTypeDomain", Const, 0, ""},
-		{"SidTypeGroup", Const, 0, ""},
-		{"SidTypeInvalid", Const, 0, ""},
-		{"SidTypeLabel", Const, 0, ""},
-		{"SidTypeUnknown", Const, 0, ""},
-		{"SidTypeUser", Const, 0, ""},
-		{"SidTypeWellKnownGroup", Const, 0, ""},
-		{"Signal", Type, 0, ""},
-		{"SizeofBpfHdr", Const, 0, ""},
-		{"SizeofBpfInsn", Const, 0, ""},
-		{"SizeofBpfProgram", Const, 0, ""},
-		{"SizeofBpfStat", Const, 0, ""},
-		{"SizeofBpfVersion", Const, 0, ""},
-		{"SizeofBpfZbuf", Const, 0, ""},
-		{"SizeofBpfZbufHeader", Const, 0, ""},
-		{"SizeofCmsghdr", Const, 0, ""},
-		{"SizeofICMPv6Filter", Const, 2, ""},
-		{"SizeofIPMreq", Const, 0, ""},
-		{"SizeofIPMreqn", Const, 0, ""},
-		{"SizeofIPv6MTUInfo", Const, 2, ""},
-		{"SizeofIPv6Mreq", Const, 0, ""},
-		{"SizeofIfAddrmsg", Const, 0, ""},
-		{"SizeofIfAnnounceMsghdr", Const, 1, ""},
-		{"SizeofIfData", Const, 0, ""},
-		{"SizeofIfInfomsg", Const, 0, ""},
-		{"SizeofIfMsghdr", Const, 0, ""},
-		{"SizeofIfaMsghdr", Const, 0, ""},
-		{"SizeofIfmaMsghdr", Const, 0, ""},
-		{"SizeofIfmaMsghdr2", Const, 0, ""},
-		{"SizeofInet4Pktinfo", Const, 0, ""},
-		{"SizeofInet6Pktinfo", Const, 0, ""},
-		{"SizeofInotifyEvent", Const, 0, ""},
-		{"SizeofLinger", Const, 0, ""},
-		{"SizeofMsghdr", Const, 0, ""},
-		{"SizeofNlAttr", Const, 0, ""},
-		{"SizeofNlMsgerr", Const, 0, ""},
-		{"SizeofNlMsghdr", Const, 0, ""},
-		{"SizeofRtAttr", Const, 0, ""},
-		{"SizeofRtGenmsg", Const, 0, ""},
-		{"SizeofRtMetrics", Const, 0, ""},
-		{"SizeofRtMsg", Const, 0, ""},
-		{"SizeofRtMsghdr", Const, 0, ""},
-		{"SizeofRtNexthop", Const, 0, ""},
-		{"SizeofSockFilter", Const, 0, ""},
-		{"SizeofSockFprog", Const, 0, ""},
-		{"SizeofSockaddrAny", Const, 0, ""},
-		{"SizeofSockaddrDatalink", Const, 0, ""},
-		{"SizeofSockaddrInet4", Const, 0, ""},
-		{"SizeofSockaddrInet6", Const, 0, ""},
-		{"SizeofSockaddrLinklayer", Const, 0, ""},
-		{"SizeofSockaddrNetlink", Const, 0, ""},
-		{"SizeofSockaddrUnix", Const, 0, ""},
-		{"SizeofTCPInfo", Const, 1, ""},
-		{"SizeofUcred", Const, 0, ""},
-		{"SlicePtrFromStrings", Func, 1, "func(ss []string) ([]*byte, error)"},
-		{"SockFilter", Type, 0, ""},
-		{"SockFilter.Code", Field, 0, ""},
-		{"SockFilter.Jf", Field, 0, ""},
-		{"SockFilter.Jt", Field, 0, ""},
-		{"SockFilter.K", Field, 0, ""},
-		{"SockFprog", Type, 0, ""},
-		{"SockFprog.Filter", Field, 0, ""},
-		{"SockFprog.Len", Field, 0, ""},
-		{"SockFprog.Pad_cgo_0", Field, 0, ""},
-		{"SockaddrDatalink", Type, 0, ""},
-		{"SockaddrDatalink.Alen", Field, 0, ""},
-		{"SockaddrDatalink.Data", Field, 0, ""},
-		{"SockaddrDatalink.Family", Field, 0, ""},
-		{"SockaddrDatalink.Index", Field, 0, ""},
-		{"SockaddrDatalink.Len", Field, 0, ""},
-		{"SockaddrDatalink.Nlen", Field, 0, ""},
-		{"SockaddrDatalink.Slen", Field, 0, ""},
-		{"SockaddrDatalink.Type", Field, 0, ""},
-		{"SockaddrGen", Type, 0, ""},
-		{"SockaddrInet4", Type, 0, ""},
-		{"SockaddrInet4.Addr", Field, 0, ""},
-		{"SockaddrInet4.Port", Field, 0, ""},
-		{"SockaddrInet6", Type, 0, ""},
-		{"SockaddrInet6.Addr", Field, 0, ""},
-		{"SockaddrInet6.Port", Field, 0, ""},
-		{"SockaddrInet6.ZoneId", Field, 0, ""},
-		{"SockaddrLinklayer", Type, 0, ""},
-		{"SockaddrLinklayer.Addr", Field, 0, ""},
-		{"SockaddrLinklayer.Halen", Field, 0, ""},
-		{"SockaddrLinklayer.Hatype", Field, 0, ""},
-		{"SockaddrLinklayer.Ifindex", Field, 0, ""},
-		{"SockaddrLinklayer.Pkttype", Field, 0, ""},
-		{"SockaddrLinklayer.Protocol", Field, 0, ""},
-		{"SockaddrNetlink", Type, 0, ""},
-		{"SockaddrNetlink.Family", Field, 0, ""},
-		{"SockaddrNetlink.Groups", Field, 0, ""},
-		{"SockaddrNetlink.Pad", Field, 0, ""},
-		{"SockaddrNetlink.Pid", Field, 0, ""},
-		{"SockaddrUnix", Type, 0, ""},
-		{"SockaddrUnix.Name", Field, 0, ""},
-		{"Socket", Func, 0, "func(domain int, typ int, proto int) (fd int, err error)"},
-		{"SocketControlMessage", Type, 0, ""},
-		{"SocketControlMessage.Data", Field, 0, ""},
-		{"SocketControlMessage.Header", Field, 0, ""},
-		{"SocketDisableIPv6", Var, 0, ""},
-		{"Socketpair", Func, 0, "func(domain int, typ int, proto int) (fd [2]int, err error)"},
-		{"Splice", Func, 0, "func(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int64, err error)"},
-		{"StartProcess", Func, 0, "func(argv0 string, argv []string, attr *ProcAttr) (pid int, handle uintptr, err error)"},
-		{"StartupInfo", Type, 0, ""},
-		{"StartupInfo.Cb", Field, 0, ""},
-		{"StartupInfo.Desktop", Field, 0, ""},
-		{"StartupInfo.FillAttribute", Field, 0, ""},
-		{"StartupInfo.Flags", Field, 0, ""},
-		{"StartupInfo.ShowWindow", Field, 0, ""},
-		{"StartupInfo.StdErr", Field, 0, ""},
-		{"StartupInfo.StdInput", Field, 0, ""},
-		{"StartupInfo.StdOutput", Field, 0, ""},
-		{"StartupInfo.Title", Field, 0, ""},
-		{"StartupInfo.X", Field, 0, ""},
-		{"StartupInfo.XCountChars", Field, 0, ""},
-		{"StartupInfo.XSize", Field, 0, ""},
-		{"StartupInfo.Y", Field, 0, ""},
-		{"StartupInfo.YCountChars", Field, 0, ""},
-		{"StartupInfo.YSize", Field, 0, ""},
-		{"Stat", Func, 0, "func(path string, stat *Stat_t) (err error)"},
-		{"Stat_t", Type, 0, ""},
-		{"Stat_t.Atim", Field, 0, ""},
-		{"Stat_t.Atim_ext", Field, 12, ""},
-		{"Stat_t.Atimespec", Field, 0, ""},
-		{"Stat_t.Birthtimespec", Field, 0, ""},
-		{"Stat_t.Blksize", Field, 0, ""},
-		{"Stat_t.Blocks", Field, 0, ""},
-		{"Stat_t.Btim_ext", Field, 12, ""},
-		{"Stat_t.Ctim", Field, 0, ""},
-		{"Stat_t.Ctim_ext", Field, 12, ""},
-		{"Stat_t.Ctimespec", Field, 0, ""},
-		{"Stat_t.Dev", Field, 0, ""},
-		{"Stat_t.Flags", Field, 0, ""},
-		{"Stat_t.Gen", Field, 0, ""},
-		{"Stat_t.Gid", Field, 0, ""},
-		{"Stat_t.Ino", Field, 0, ""},
-		{"Stat_t.Lspare", Field, 0, ""},
-		{"Stat_t.Lspare0", Field, 2, ""},
-		{"Stat_t.Lspare1", Field, 2, ""},
-		{"Stat_t.Mode", Field, 0, ""},
-		{"Stat_t.Mtim", Field, 0, ""},
-		{"Stat_t.Mtim_ext", Field, 12, ""},
-		{"Stat_t.Mtimespec", Field, 0, ""},
-		{"Stat_t.Nlink", Field, 0, ""},
-		{"Stat_t.Pad_cgo_0", Field, 0, ""},
-		{"Stat_t.Pad_cgo_1", Field, 0, ""},
-		{"Stat_t.Pad_cgo_2", Field, 0, ""},
-		{"Stat_t.Padding0", Field, 12, ""},
-		{"Stat_t.Padding1", Field, 12, ""},
-		{"Stat_t.Qspare", Field, 0, ""},
-		{"Stat_t.Rdev", Field, 0, ""},
-		{"Stat_t.Size", Field, 0, ""},
-		{"Stat_t.Spare", Field, 2, ""},
-		{"Stat_t.Uid", Field, 0, ""},
-		{"Stat_t.X__pad0", Field, 0, ""},
-		{"Stat_t.X__pad1", Field, 0, ""},
-		{"Stat_t.X__pad2", Field, 0, ""},
-		{"Stat_t.X__st_birthtim", Field, 2, ""},
-		{"Stat_t.X__st_ino", Field, 0, ""},
-		{"Stat_t.X__unused", Field, 0, ""},
-		{"Statfs", Func, 0, "func(path string, buf *Statfs_t) (err error)"},
-		{"Statfs_t", Type, 0, ""},
-		{"Statfs_t.Asyncreads", Field, 0, ""},
-		{"Statfs_t.Asyncwrites", Field, 0, ""},
-		{"Statfs_t.Bavail", Field, 0, ""},
-		{"Statfs_t.Bfree", Field, 0, ""},
-		{"Statfs_t.Blocks", Field, 0, ""},
-		{"Statfs_t.Bsize", Field, 0, ""},
-		{"Statfs_t.Charspare", Field, 0, ""},
-		{"Statfs_t.F_asyncreads", Field, 2, ""},
-		{"Statfs_t.F_asyncwrites", Field, 2, ""},
-		{"Statfs_t.F_bavail", Field, 2, ""},
-		{"Statfs_t.F_bfree", Field, 2, ""},
-		{"Statfs_t.F_blocks", Field, 2, ""},
-		{"Statfs_t.F_bsize", Field, 2, ""},
-		{"Statfs_t.F_ctime", Field, 2, ""},
-		{"Statfs_t.F_favail", Field, 2, ""},
-		{"Statfs_t.F_ffree", Field, 2, ""},
-		{"Statfs_t.F_files", Field, 2, ""},
-		{"Statfs_t.F_flags", Field, 2, ""},
-		{"Statfs_t.F_fsid", Field, 2, ""},
-		{"Statfs_t.F_fstypename", Field, 2, ""},
-		{"Statfs_t.F_iosize", Field, 2, ""},
-		{"Statfs_t.F_mntfromname", Field, 2, ""},
-		{"Statfs_t.F_mntfromspec", Field, 3, ""},
-		{"Statfs_t.F_mntonname", Field, 2, ""},
-		{"Statfs_t.F_namemax", Field, 2, ""},
-		{"Statfs_t.F_owner", Field, 2, ""},
-		{"Statfs_t.F_spare", Field, 2, ""},
-		{"Statfs_t.F_syncreads", Field, 2, ""},
-		{"Statfs_t.F_syncwrites", Field, 2, ""},
-		{"Statfs_t.Ffree", Field, 0, ""},
-		{"Statfs_t.Files", Field, 0, ""},
-		{"Statfs_t.Flags", Field, 0, ""},
-		{"Statfs_t.Frsize", Field, 0, ""},
-		{"Statfs_t.Fsid", Field, 0, ""},
-		{"Statfs_t.Fssubtype", Field, 0, ""},
-		{"Statfs_t.Fstypename", Field, 0, ""},
-		{"Statfs_t.Iosize", Field, 0, ""},
-		{"Statfs_t.Mntfromname", Field, 0, ""},
-		{"Statfs_t.Mntonname", Field, 0, ""},
-		{"Statfs_t.Mount_info", Field, 2, ""},
-		{"Statfs_t.Namelen", Field, 0, ""},
-		{"Statfs_t.Namemax", Field, 0, ""},
-		{"Statfs_t.Owner", Field, 0, ""},
-		{"Statfs_t.Pad_cgo_0", Field, 0, ""},
-		{"Statfs_t.Pad_cgo_1", Field, 2, ""},
-		{"Statfs_t.Reserved", Field, 0, ""},
-		{"Statfs_t.Spare", Field, 0, ""},
-		{"Statfs_t.Syncreads", Field, 0, ""},
-		{"Statfs_t.Syncwrites", Field, 0, ""},
-		{"Statfs_t.Type", Field, 0, ""},
-		{"Statfs_t.Version", Field, 0, ""},
-		{"Stderr", Var, 0, ""},
-		{"Stdin", Var, 0, ""},
-		{"Stdout", Var, 0, ""},
-		{"StringBytePtr", Func, 0, "func(s string) *byte"},
-		{"StringByteSlice", Func, 0, "func(s string) []byte"},
-		{"StringSlicePtr", Func, 0, "func(ss []string) []*byte"},
-		{"StringToSid", Func, 0, ""},
-		{"StringToUTF16", Func, 0, ""},
-		{"StringToUTF16Ptr", Func, 0, ""},
-		{"Symlink", Func, 0, "func(oldpath string, newpath string) (err error)"},
-		{"Sync", Func, 0, "func()"},
-		{"SyncFileRange", Func, 0, "func(fd int, off int64, n int64, flags int) (err error)"},
-		{"SysProcAttr", Type, 0, ""},
-		{"SysProcAttr.AdditionalInheritedHandles", Field, 17, ""},
-		{"SysProcAttr.AmbientCaps", Field, 9, ""},
-		{"SysProcAttr.CgroupFD", Field, 20, ""},
-		{"SysProcAttr.Chroot", Field, 0, ""},
-		{"SysProcAttr.Cloneflags", Field, 2, ""},
-		{"SysProcAttr.CmdLine", Field, 0, ""},
-		{"SysProcAttr.CreationFlags", Field, 1, ""},
-		{"SysProcAttr.Credential", Field, 0, ""},
-		{"SysProcAttr.Ctty", Field, 1, ""},
-		{"SysProcAttr.Foreground", Field, 5, ""},
-		{"SysProcAttr.GidMappings", Field, 4, ""},
-		{"SysProcAttr.GidMappingsEnableSetgroups", Field, 5, ""},
-		{"SysProcAttr.HideWindow", Field, 0, ""},
-		{"SysProcAttr.Jail", Field, 21, ""},
-		{"SysProcAttr.NoInheritHandles", Field, 16, ""},
-		{"SysProcAttr.Noctty", Field, 0, ""},
-		{"SysProcAttr.ParentProcess", Field, 17, ""},
-		{"SysProcAttr.Pdeathsig", Field, 0, ""},
-		{"SysProcAttr.Pgid", Field, 5, ""},
-		{"SysProcAttr.PidFD", Field, 22, ""},
-		{"SysProcAttr.ProcessAttributes", Field, 13, ""},
-		{"SysProcAttr.Ptrace", Field, 0, ""},
-		{"SysProcAttr.Setctty", Field, 0, ""},
-		{"SysProcAttr.Setpgid", Field, 0, ""},
-		{"SysProcAttr.Setsid", Field, 0, ""},
-		{"SysProcAttr.ThreadAttributes", Field, 13, ""},
-		{"SysProcAttr.Token", Field, 10, ""},
-		{"SysProcAttr.UidMappings", Field, 4, ""},
-		{"SysProcAttr.Unshareflags", Field, 7, ""},
-		{"SysProcAttr.UseCgroupFD", Field, 20, ""},
-		{"SysProcIDMap", Type, 4, ""},
-		{"SysProcIDMap.ContainerID", Field, 4, ""},
-		{"SysProcIDMap.HostID", Field, 4, ""},
-		{"SysProcIDMap.Size", Field, 4, ""},
-		{"Syscall", Func, 0, "func(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr) (r1 uintptr, r2 uintptr, err Errno)"},
-		{"Syscall12", Func, 0, ""},
-		{"Syscall15", Func, 0, ""},
-		{"Syscall18", Func, 12, ""},
-		{"Syscall6", Func, 0, "func(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr, a6 uintptr) (r1 uintptr, r2 uintptr, err Errno)"},
-		{"Syscall9", Func, 0, ""},
-		{"SyscallN", Func, 18, ""},
-		{"Sysctl", Func, 0, ""},
-		{"SysctlUint32", Func, 0, ""},
-		{"Sysctlnode", Type, 2, ""},
-		{"Sysctlnode.Flags", Field, 2, ""},
-		{"Sysctlnode.Name", Field, 2, ""},
-		{"Sysctlnode.Num", Field, 2, ""},
-		{"Sysctlnode.Un", Field, 2, ""},
-		{"Sysctlnode.Ver", Field, 2, ""},
-		{"Sysctlnode.X__rsvd", Field, 2, ""},
-		{"Sysctlnode.X_sysctl_desc", Field, 2, ""},
-		{"Sysctlnode.X_sysctl_func", Field, 2, ""},
-		{"Sysctlnode.X_sysctl_parent", Field, 2, ""},
-		{"Sysctlnode.X_sysctl_size", Field, 2, ""},
-		{"Sysinfo", Func, 0, "func(info *Sysinfo_t) (err error)"},
-		{"Sysinfo_t", Type, 0, ""},
-		{"Sysinfo_t.Bufferram", Field, 0, ""},
-		{"Sysinfo_t.Freehigh", Field, 0, ""},
-		{"Sysinfo_t.Freeram", Field, 0, ""},
-		{"Sysinfo_t.Freeswap", Field, 0, ""},
-		{"Sysinfo_t.Loads", Field, 0, ""},
-		{"Sysinfo_t.Pad", Field, 0, ""},
-		{"Sysinfo_t.Pad_cgo_0", Field, 0, ""},
-		{"Sysinfo_t.Pad_cgo_1", Field, 0, ""},
-		{"Sysinfo_t.Procs", Field, 0, ""},
-		{"Sysinfo_t.Sharedram", Field, 0, ""},
-		{"Sysinfo_t.Totalhigh", Field, 0, ""},
-		{"Sysinfo_t.Totalram", Field, 0, ""},
-		{"Sysinfo_t.Totalswap", Field, 0, ""},
-		{"Sysinfo_t.Unit", Field, 0, ""},
-		{"Sysinfo_t.Uptime", Field, 0, ""},
-		{"Sysinfo_t.X_f", Field, 0, ""},
-		{"Systemtime", Type, 0, ""},
-		{"Systemtime.Day", Field, 0, ""},
-		{"Systemtime.DayOfWeek", Field, 0, ""},
-		{"Systemtime.Hour", Field, 0, ""},
-		{"Systemtime.Milliseconds", Field, 0, ""},
-		{"Systemtime.Minute", Field, 0, ""},
-		{"Systemtime.Month", Field, 0, ""},
-		{"Systemtime.Second", Field, 0, ""},
-		{"Systemtime.Year", Field, 0, ""},
-		{"TCGETS", Const, 0, ""},
-		{"TCIFLUSH", Const, 1, ""},
-		{"TCIOFLUSH", Const, 1, ""},
-		{"TCOFLUSH", Const, 1, ""},
-		{"TCPInfo", Type, 1, ""},
-		{"TCPInfo.Advmss", Field, 1, ""},
-		{"TCPInfo.Ato", Field, 1, ""},
-		{"TCPInfo.Backoff", Field, 1, ""},
-		{"TCPInfo.Ca_state", Field, 1, ""},
-		{"TCPInfo.Fackets", Field, 1, ""},
-		{"TCPInfo.Last_ack_recv", Field, 1, ""},
-		{"TCPInfo.Last_ack_sent", Field, 1, ""},
-		{"TCPInfo.Last_data_recv", Field, 1, ""},
-		{"TCPInfo.Last_data_sent", Field, 1, ""},
-		{"TCPInfo.Lost", Field, 1, ""},
-		{"TCPInfo.Options", Field, 1, ""},
-		{"TCPInfo.Pad_cgo_0", Field, 1, ""},
-		{"TCPInfo.Pmtu", Field, 1, ""},
-		{"TCPInfo.Probes", Field, 1, ""},
-		{"TCPInfo.Rcv_mss", Field, 1, ""},
-		{"TCPInfo.Rcv_rtt", Field, 1, ""},
-		{"TCPInfo.Rcv_space", Field, 1, ""},
-		{"TCPInfo.Rcv_ssthresh", Field, 1, ""},
-		{"TCPInfo.Reordering", Field, 1, ""},
-		{"TCPInfo.Retrans", Field, 1, ""},
-		{"TCPInfo.Retransmits", Field, 1, ""},
-		{"TCPInfo.Rto", Field, 1, ""},
-		{"TCPInfo.Rtt", Field, 1, ""},
-		{"TCPInfo.Rttvar", Field, 1, ""},
-		{"TCPInfo.Sacked", Field, 1, ""},
-		{"TCPInfo.Snd_cwnd", Field, 1, ""},
-		{"TCPInfo.Snd_mss", Field, 1, ""},
-		{"TCPInfo.Snd_ssthresh", Field, 1, ""},
-		{"TCPInfo.State", Field, 1, ""},
-		{"TCPInfo.Total_retrans", Field, 1, ""},
-		{"TCPInfo.Unacked", Field, 1, ""},
-		{"TCPKeepalive", Type, 3, ""},
-		{"TCPKeepalive.Interval", Field, 3, ""},
-		{"TCPKeepalive.OnOff", Field, 3, ""},
-		{"TCPKeepalive.Time", Field, 3, ""},
-		{"TCP_CA_NAME_MAX", Const, 0, ""},
-		{"TCP_CONGCTL", Const, 1, ""},
-		{"TCP_CONGESTION", Const, 0, ""},
-		{"TCP_CONNECTIONTIMEOUT", Const, 0, ""},
-		{"TCP_CORK", Const, 0, ""},
-		{"TCP_DEFER_ACCEPT", Const, 0, ""},
-		{"TCP_ENABLE_ECN", Const, 16, ""},
-		{"TCP_INFO", Const, 0, ""},
-		{"TCP_KEEPALIVE", Const, 0, ""},
-		{"TCP_KEEPCNT", Const, 0, ""},
-		{"TCP_KEEPIDLE", Const, 0, ""},
-		{"TCP_KEEPINIT", Const, 1, ""},
-		{"TCP_KEEPINTVL", Const, 0, ""},
-		{"TCP_LINGER2", Const, 0, ""},
-		{"TCP_MAXBURST", Const, 0, ""},
-		{"TCP_MAXHLEN", Const, 0, ""},
-		{"TCP_MAXOLEN", Const, 0, ""},
-		{"TCP_MAXSEG", Const, 0, ""},
-		{"TCP_MAXWIN", Const, 0, ""},
-		{"TCP_MAX_SACK", Const, 0, ""},
-		{"TCP_MAX_WINSHIFT", Const, 0, ""},
-		{"TCP_MD5SIG", Const, 0, ""},
-		{"TCP_MD5SIG_MAXKEYLEN", Const, 0, ""},
-		{"TCP_MINMSS", Const, 0, ""},
-		{"TCP_MINMSSOVERLOAD", Const, 0, ""},
-		{"TCP_MSS", Const, 0, ""},
-		{"TCP_NODELAY", Const, 0, ""},
-		{"TCP_NOOPT", Const, 0, ""},
-		{"TCP_NOPUSH", Const, 0, ""},
-		{"TCP_NOTSENT_LOWAT", Const, 16, ""},
-		{"TCP_NSTATES", Const, 1, ""},
-		{"TCP_QUICKACK", Const, 0, ""},
-		{"TCP_RXT_CONNDROPTIME", Const, 0, ""},
-		{"TCP_RXT_FINDROP", Const, 0, ""},
-		{"TCP_SACK_ENABLE", Const, 1, ""},
-		{"TCP_SENDMOREACKS", Const, 16, ""},
-		{"TCP_SYNCNT", Const, 0, ""},
-		{"TCP_VENDOR", Const, 3, ""},
-		{"TCP_WINDOW_CLAMP", Const, 0, ""},
-		{"TCSAFLUSH", Const, 1, ""},
-		{"TCSETS", Const, 0, ""},
-		{"TF_DISCONNECT", Const, 0, ""},
-		{"TF_REUSE_SOCKET", Const, 0, ""},
-		{"TF_USE_DEFAULT_WORKER", Const, 0, ""},
-		{"TF_USE_KERNEL_APC", Const, 0, ""},
-		{"TF_USE_SYSTEM_THREAD", Const, 0, ""},
-		{"TF_WRITE_BEHIND", Const, 0, ""},
-		{"TH32CS_INHERIT", Const, 4, ""},
-		{"TH32CS_SNAPALL", Const, 4, ""},
-		{"TH32CS_SNAPHEAPLIST", Const, 4, ""},
-		{"TH32CS_SNAPMODULE", Const, 4, ""},
-		{"TH32CS_SNAPMODULE32", Const, 4, ""},
-		{"TH32CS_SNAPPROCESS", Const, 4, ""},
-		{"TH32CS_SNAPTHREAD", Const, 4, ""},
-		{"TIME_ZONE_ID_DAYLIGHT", Const, 0, ""},
-		{"TIME_ZONE_ID_STANDARD", Const, 0, ""},
-		{"TIME_ZONE_ID_UNKNOWN", Const, 0, ""},
-		{"TIOCCBRK", Const, 0, ""},
-		{"TIOCCDTR", Const, 0, ""},
-		{"TIOCCONS", Const, 0, ""},
-		{"TIOCDCDTIMESTAMP", Const, 0, ""},
-		{"TIOCDRAIN", Const, 0, ""},
-		{"TIOCDSIMICROCODE", Const, 0, ""},
-		{"TIOCEXCL", Const, 0, ""},
-		{"TIOCEXT", Const, 0, ""},
-		{"TIOCFLAG_CDTRCTS", Const, 1, ""},
-		{"TIOCFLAG_CLOCAL", Const, 1, ""},
-		{"TIOCFLAG_CRTSCTS", Const, 1, ""},
-		{"TIOCFLAG_MDMBUF", Const, 1, ""},
-		{"TIOCFLAG_PPS", Const, 1, ""},
-		{"TIOCFLAG_SOFTCAR", Const, 1, ""},
-		{"TIOCFLUSH", Const, 0, ""},
-		{"TIOCGDEV", Const, 0, ""},
-		{"TIOCGDRAINWAIT", Const, 0, ""},
-		{"TIOCGETA", Const, 0, ""},
-		{"TIOCGETD", Const, 0, ""},
-		{"TIOCGFLAGS", Const, 1, ""},
-		{"TIOCGICOUNT", Const, 0, ""},
-		{"TIOCGLCKTRMIOS", Const, 0, ""},
-		{"TIOCGLINED", Const, 1, ""},
-		{"TIOCGPGRP", Const, 0, ""},
-		{"TIOCGPTN", Const, 0, ""},
-		{"TIOCGQSIZE", Const, 1, ""},
-		{"TIOCGRANTPT", Const, 1, ""},
-		{"TIOCGRS485", Const, 0, ""},
-		{"TIOCGSERIAL", Const, 0, ""},
-		{"TIOCGSID", Const, 0, ""},
-		{"TIOCGSIZE", Const, 1, ""},
-		{"TIOCGSOFTCAR", Const, 0, ""},
-		{"TIOCGTSTAMP", Const, 1, ""},
-		{"TIOCGWINSZ", Const, 0, ""},
-		{"TIOCINQ", Const, 0, ""},
-		{"TIOCIXOFF", Const, 0, ""},
-		{"TIOCIXON", Const, 0, ""},
-		{"TIOCLINUX", Const, 0, ""},
-		{"TIOCMBIC", Const, 0, ""},
-		{"TIOCMBIS", Const, 0, ""},
-		{"TIOCMGDTRWAIT", Const, 0, ""},
-		{"TIOCMGET", Const, 0, ""},
-		{"TIOCMIWAIT", Const, 0, ""},
-		{"TIOCMODG", Const, 0, ""},
-		{"TIOCMODS", Const, 0, ""},
-		{"TIOCMSDTRWAIT", Const, 0, ""},
-		{"TIOCMSET", Const, 0, ""},
-		{"TIOCM_CAR", Const, 0, ""},
-		{"TIOCM_CD", Const, 0, ""},
-		{"TIOCM_CTS", Const, 0, ""},
-		{"TIOCM_DCD", Const, 0, ""},
-		{"TIOCM_DSR", Const, 0, ""},
-		{"TIOCM_DTR", Const, 0, ""},
-		{"TIOCM_LE", Const, 0, ""},
-		{"TIOCM_RI", Const, 0, ""},
-		{"TIOCM_RNG", Const, 0, ""},
-		{"TIOCM_RTS", Const, 0, ""},
-		{"TIOCM_SR", Const, 0, ""},
-		{"TIOCM_ST", Const, 0, ""},
-		{"TIOCNOTTY", Const, 0, ""},
-		{"TIOCNXCL", Const, 0, ""},
-		{"TIOCOUTQ", Const, 0, ""},
-		{"TIOCPKT", Const, 0, ""},
-		{"TIOCPKT_DATA", Const, 0, ""},
-		{"TIOCPKT_DOSTOP", Const, 0, ""},
-		{"TIOCPKT_FLUSHREAD", Const, 0, ""},
-		{"TIOCPKT_FLUSHWRITE", Const, 0, ""},
-		{"TIOCPKT_IOCTL", Const, 0, ""},
-		{"TIOCPKT_NOSTOP", Const, 0, ""},
-		{"TIOCPKT_START", Const, 0, ""},
-		{"TIOCPKT_STOP", Const, 0, ""},
-		{"TIOCPTMASTER", Const, 0, ""},
-		{"TIOCPTMGET", Const, 1, ""},
-		{"TIOCPTSNAME", Const, 1, ""},
-		{"TIOCPTYGNAME", Const, 0, ""},
-		{"TIOCPTYGRANT", Const, 0, ""},
-		{"TIOCPTYUNLK", Const, 0, ""},
-		{"TIOCRCVFRAME", Const, 1, ""},
-		{"TIOCREMOTE", Const, 0, ""},
-		{"TIOCSBRK", Const, 0, ""},
-		{"TIOCSCONS", Const, 0, ""},
-		{"TIOCSCTTY", Const, 0, ""},
-		{"TIOCSDRAINWAIT", Const, 0, ""},
-		{"TIOCSDTR", Const, 0, ""},
-		{"TIOCSERCONFIG", Const, 0, ""},
-		{"TIOCSERGETLSR", Const, 0, ""},
-		{"TIOCSERGETMULTI", Const, 0, ""},
-		{"TIOCSERGSTRUCT", Const, 0, ""},
-		{"TIOCSERGWILD", Const, 0, ""},
-		{"TIOCSERSETMULTI", Const, 0, ""},
-		{"TIOCSERSWILD", Const, 0, ""},
-		{"TIOCSER_TEMT", Const, 0, ""},
-		{"TIOCSETA", Const, 0, ""},
-		{"TIOCSETAF", Const, 0, ""},
-		{"TIOCSETAW", Const, 0, ""},
-		{"TIOCSETD", Const, 0, ""},
-		{"TIOCSFLAGS", Const, 1, ""},
-		{"TIOCSIG", Const, 0, ""},
-		{"TIOCSLCKTRMIOS", Const, 0, ""},
-		{"TIOCSLINED", Const, 1, ""},
-		{"TIOCSPGRP", Const, 0, ""},
-		{"TIOCSPTLCK", Const, 0, ""},
-		{"TIOCSQSIZE", Const, 1, ""},
-		{"TIOCSRS485", Const, 0, ""},
-		{"TIOCSSERIAL", Const, 0, ""},
-		{"TIOCSSIZE", Const, 1, ""},
-		{"TIOCSSOFTCAR", Const, 0, ""},
-		{"TIOCSTART", Const, 0, ""},
-		{"TIOCSTAT", Const, 0, ""},
-		{"TIOCSTI", Const, 0, ""},
-		{"TIOCSTOP", Const, 0, ""},
-		{"TIOCSTSTAMP", Const, 1, ""},
-		{"TIOCSWINSZ", Const, 0, ""},
-		{"TIOCTIMESTAMP", Const, 0, ""},
-		{"TIOCUCNTL", Const, 0, ""},
-		{"TIOCVHANGUP", Const, 0, ""},
-		{"TIOCXMTFRAME", Const, 1, ""},
-		{"TOKEN_ADJUST_DEFAULT", Const, 0, ""},
-		{"TOKEN_ADJUST_GROUPS", Const, 0, ""},
-		{"TOKEN_ADJUST_PRIVILEGES", Const, 0, ""},
-		{"TOKEN_ADJUST_SESSIONID", Const, 11, ""},
-		{"TOKEN_ALL_ACCESS", Const, 0, ""},
-		{"TOKEN_ASSIGN_PRIMARY", Const, 0, ""},
-		{"TOKEN_DUPLICATE", Const, 0, ""},
-		{"TOKEN_EXECUTE", Const, 0, ""},
-		{"TOKEN_IMPERSONATE", Const, 0, ""},
-		{"TOKEN_QUERY", Const, 0, ""},
-		{"TOKEN_QUERY_SOURCE", Const, 0, ""},
-		{"TOKEN_READ", Const, 0, ""},
-		{"TOKEN_WRITE", Const, 0, ""},
-		{"TOSTOP", Const, 0, ""},
-		{"TRUNCATE_EXISTING", Const, 0, ""},
-		{"TUNATTACHFILTER", Const, 0, ""},
-		{"TUNDETACHFILTER", Const, 0, ""},
-		{"TUNGETFEATURES", Const, 0, ""},
-		{"TUNGETIFF", Const, 0, ""},
-		{"TUNGETSNDBUF", Const, 0, ""},
-		{"TUNGETVNETHDRSZ", Const, 0, ""},
-		{"TUNSETDEBUG", Const, 0, ""},
-		{"TUNSETGROUP", Const, 0, ""},
-		{"TUNSETIFF", Const, 0, ""},
-		{"TUNSETLINK", Const, 0, ""},
-		{"TUNSETNOCSUM", Const, 0, ""},
-		{"TUNSETOFFLOAD", Const, 0, ""},
-		{"TUNSETOWNER", Const, 0, ""},
-		{"TUNSETPERSIST", Const, 0, ""},
-		{"TUNSETSNDBUF", Const, 0, ""},
-		{"TUNSETTXFILTER", Const, 0, ""},
-		{"TUNSETVNETHDRSZ", Const, 0, ""},
-		{"Tee", Func, 0, "func(rfd int, wfd int, len int, flags int) (n int64, err error)"},
-		{"TerminateProcess", Func, 0, ""},
-		{"Termios", Type, 0, ""},
-		{"Termios.Cc", Field, 0, ""},
-		{"Termios.Cflag", Field, 0, ""},
-		{"Termios.Iflag", Field, 0, ""},
-		{"Termios.Ispeed", Field, 0, ""},
-		{"Termios.Lflag", Field, 0, ""},
-		{"Termios.Line", Field, 0, ""},
-		{"Termios.Oflag", Field, 0, ""},
-		{"Termios.Ospeed", Field, 0, ""},
-		{"Termios.Pad_cgo_0", Field, 0, ""},
-		{"Tgkill", Func, 0, "func(tgid int, tid int, sig Signal) (err error)"},
-		{"Time", Func, 0, "func(t *Time_t) (tt Time_t, err error)"},
-		{"Time_t", Type, 0, ""},
-		{"Times", Func, 0, "func(tms *Tms) (ticks uintptr, err error)"},
-		{"Timespec", Type, 0, ""},
-		{"Timespec.Nsec", Field, 0, ""},
-		{"Timespec.Pad_cgo_0", Field, 2, ""},
-		{"Timespec.Sec", Field, 0, ""},
-		{"TimespecToNsec", Func, 0, "func(ts Timespec) int64"},
-		{"Timeval", Type, 0, ""},
-		{"Timeval.Pad_cgo_0", Field, 0, ""},
-		{"Timeval.Sec", Field, 0, ""},
-		{"Timeval.Usec", Field, 0, ""},
-		{"Timeval32", Type, 0, ""},
-		{"Timeval32.Sec", Field, 0, ""},
-		{"Timeval32.Usec", Field, 0, ""},
-		{"TimevalToNsec", Func, 0, "func(tv Timeval) int64"},
-		{"Timex", Type, 0, ""},
-		{"Timex.Calcnt", Field, 0, ""},
-		{"Timex.Constant", Field, 0, ""},
-		{"Timex.Errcnt", Field, 0, ""},
-		{"Timex.Esterror", Field, 0, ""},
-		{"Timex.Freq", Field, 0, ""},
-		{"Timex.Jitcnt", Field, 0, ""},
-		{"Timex.Jitter", Field, 0, ""},
-		{"Timex.Maxerror", Field, 0, ""},
-		{"Timex.Modes", Field, 0, ""},
-		{"Timex.Offset", Field, 0, ""},
-		{"Timex.Pad_cgo_0", Field, 0, ""},
-		{"Timex.Pad_cgo_1", Field, 0, ""},
-		{"Timex.Pad_cgo_2", Field, 0, ""},
-		{"Timex.Pad_cgo_3", Field, 0, ""},
-		{"Timex.Ppsfreq", Field, 0, ""},
-		{"Timex.Precision", Field, 0, ""},
-		{"Timex.Shift", Field, 0, ""},
-		{"Timex.Stabil", Field, 0, ""},
-		{"Timex.Status", Field, 0, ""},
-		{"Timex.Stbcnt", Field, 0, ""},
-		{"Timex.Tai", Field, 0, ""},
-		{"Timex.Tick", Field, 0, ""},
-		{"Timex.Time", Field, 0, ""},
-		{"Timex.Tolerance", Field, 0, ""},
-		{"Timezoneinformation", Type, 0, ""},
-		{"Timezoneinformation.Bias", Field, 0, ""},
-		{"Timezoneinformation.DaylightBias", Field, 0, ""},
-		{"Timezoneinformation.DaylightDate", Field, 0, ""},
-		{"Timezoneinformation.DaylightName", Field, 0, ""},
-		{"Timezoneinformation.StandardBias", Field, 0, ""},
-		{"Timezoneinformation.StandardDate", Field, 0, ""},
-		{"Timezoneinformation.StandardName", Field, 0, ""},
-		{"Tms", Type, 0, ""},
-		{"Tms.Cstime", Field, 0, ""},
-		{"Tms.Cutime", Field, 0, ""},
-		{"Tms.Stime", Field, 0, ""},
-		{"Tms.Utime", Field, 0, ""},
-		{"Token", Type, 0, ""},
-		{"TokenAccessInformation", Const, 0, ""},
-		{"TokenAuditPolicy", Const, 0, ""},
-		{"TokenDefaultDacl", Const, 0, ""},
-		{"TokenElevation", Const, 0, ""},
-		{"TokenElevationType", Const, 0, ""},
-		{"TokenGroups", Const, 0, ""},
-		{"TokenGroupsAndPrivileges", Const, 0, ""},
-		{"TokenHasRestrictions", Const, 0, ""},
-		{"TokenImpersonationLevel", Const, 0, ""},
-		{"TokenIntegrityLevel", Const, 0, ""},
-		{"TokenLinkedToken", Const, 0, ""},
-		{"TokenLogonSid", Const, 0, ""},
-		{"TokenMandatoryPolicy", Const, 0, ""},
-		{"TokenOrigin", Const, 0, ""},
-		{"TokenOwner", Const, 0, ""},
-		{"TokenPrimaryGroup", Const, 0, ""},
-		{"TokenPrivileges", Const, 0, ""},
-		{"TokenRestrictedSids", Const, 0, ""},
-		{"TokenSandBoxInert", Const, 0, ""},
-		{"TokenSessionId", Const, 0, ""},
-		{"TokenSessionReference", Const, 0, ""},
-		{"TokenSource", Const, 0, ""},
-		{"TokenStatistics", Const, 0, ""},
-		{"TokenType", Const, 0, ""},
-		{"TokenUIAccess", Const, 0, ""},
-		{"TokenUser", Const, 0, ""},
-		{"TokenVirtualizationAllowed", Const, 0, ""},
-		{"TokenVirtualizationEnabled", Const, 0, ""},
-		{"Tokenprimarygroup", Type, 0, ""},
-		{"Tokenprimarygroup.PrimaryGroup", Field, 0, ""},
-		{"Tokenuser", Type, 0, ""},
-		{"Tokenuser.User", Field, 0, ""},
-		{"TranslateAccountName", Func, 0, ""},
-		{"TranslateName", Func, 0, ""},
-		{"TransmitFile", Func, 0, ""},
-		{"TransmitFileBuffers", Type, 0, ""},
-		{"TransmitFileBuffers.Head", Field, 0, ""},
-		{"TransmitFileBuffers.HeadLength", Field, 0, ""},
-		{"TransmitFileBuffers.Tail", Field, 0, ""},
-		{"TransmitFileBuffers.TailLength", Field, 0, ""},
-		{"Truncate", Func, 0, "func(path string, length int64) (err error)"},
-		{"UNIX_PATH_MAX", Const, 12, ""},
-		{"USAGE_MATCH_TYPE_AND", Const, 0, ""},
-		{"USAGE_MATCH_TYPE_OR", Const, 0, ""},
-		{"UTF16FromString", Func, 1, ""},
-		{"UTF16PtrFromString", Func, 1, ""},
-		{"UTF16ToString", Func, 0, ""},
-		{"Ucred", Type, 0, ""},
-		{"Ucred.Gid", Field, 0, ""},
-		{"Ucred.Pid", Field, 0, ""},
-		{"Ucred.Uid", Field, 0, ""},
-		{"Umask", Func, 0, "func(mask int) (oldmask int)"},
-		{"Uname", Func, 0, "func(buf *Utsname) (err error)"},
-		{"Undelete", Func, 0, ""},
-		{"UnixCredentials", Func, 0, "func(ucred *Ucred) []byte"},
-		{"UnixRights", Func, 0, "func(fds ...int) []byte"},
-		{"Unlink", Func, 0, "func(path string) error"},
-		{"Unlinkat", Func, 0, "func(dirfd int, path string) error"},
-		{"UnmapViewOfFile", Func, 0, ""},
-		{"Unmount", Func, 0, "func(target string, flags int) (err error)"},
-		{"Unsetenv", Func, 4, "func(key string) error"},
-		{"Unshare", Func, 0, "func(flags int) (err error)"},
-		{"UserInfo10", Type, 0, ""},
-		{"UserInfo10.Comment", Field, 0, ""},
-		{"UserInfo10.FullName", Field, 0, ""},
-		{"UserInfo10.Name", Field, 0, ""},
-		{"UserInfo10.UsrComment", Field, 0, ""},
-		{"Ustat", Func, 0, "func(dev int, ubuf *Ustat_t) (err error)"},
-		{"Ustat_t", Type, 0, ""},
-		{"Ustat_t.Fname", Field, 0, ""},
-		{"Ustat_t.Fpack", Field, 0, ""},
-		{"Ustat_t.Pad_cgo_0", Field, 0, ""},
-		{"Ustat_t.Pad_cgo_1", Field, 0, ""},
-		{"Ustat_t.Tfree", Field, 0, ""},
-		{"Ustat_t.Tinode", Field, 0, ""},
-		{"Utimbuf", Type, 0, ""},
-		{"Utimbuf.Actime", Field, 0, ""},
-		{"Utimbuf.Modtime", Field, 0, ""},
-		{"Utime", Func, 0, "func(path string, buf *Utimbuf) (err error)"},
-		{"Utimes", Func, 0, "func(path string, tv []Timeval) (err error)"},
-		{"UtimesNano", Func, 1, "func(path string, ts []Timespec) (err error)"},
-		{"Utsname", Type, 0, ""},
-		{"Utsname.Domainname", Field, 0, ""},
-		{"Utsname.Machine", Field, 0, ""},
-		{"Utsname.Nodename", Field, 0, ""},
-		{"Utsname.Release", Field, 0, ""},
-		{"Utsname.Sysname", Field, 0, ""},
-		{"Utsname.Version", Field, 0, ""},
-		{"VDISCARD", Const, 0, ""},
-		{"VDSUSP", Const, 1, ""},
-		{"VEOF", Const, 0, ""},
-		{"VEOL", Const, 0, ""},
-		{"VEOL2", Const, 0, ""},
-		{"VERASE", Const, 0, ""},
-		{"VERASE2", Const, 1, ""},
-		{"VINTR", Const, 0, ""},
-		{"VKILL", Const, 0, ""},
-		{"VLNEXT", Const, 0, ""},
-		{"VMIN", Const, 0, ""},
-		{"VQUIT", Const, 0, ""},
-		{"VREPRINT", Const, 0, ""},
-		{"VSTART", Const, 0, ""},
-		{"VSTATUS", Const, 1, ""},
-		{"VSTOP", Const, 0, ""},
-		{"VSUSP", Const, 0, ""},
-		{"VSWTC", Const, 0, ""},
-		{"VT0", Const, 1, ""},
-		{"VT1", Const, 1, ""},
-		{"VTDLY", Const, 1, ""},
-		{"VTIME", Const, 0, ""},
-		{"VWERASE", Const, 0, ""},
-		{"VirtualLock", Func, 0, ""},
-		{"VirtualUnlock", Func, 0, ""},
-		{"WAIT_ABANDONED", Const, 0, ""},
-		{"WAIT_FAILED", Const, 0, ""},
-		{"WAIT_OBJECT_0", Const, 0, ""},
-		{"WAIT_TIMEOUT", Const, 0, ""},
-		{"WALL", Const, 0, ""},
-		{"WALLSIG", Const, 1, ""},
-		{"WALTSIG", Const, 1, ""},
-		{"WCLONE", Const, 0, ""},
-		{"WCONTINUED", Const, 0, ""},
-		{"WCOREFLAG", Const, 0, ""},
-		{"WEXITED", Const, 0, ""},
-		{"WLINUXCLONE", Const, 0, ""},
-		{"WNOHANG", Const, 0, ""},
-		{"WNOTHREAD", Const, 0, ""},
-		{"WNOWAIT", Const, 0, ""},
-		{"WNOZOMBIE", Const, 1, ""},
-		{"WOPTSCHECKED", Const, 1, ""},
-		{"WORDSIZE", Const, 0, ""},
-		{"WSABuf", Type, 0, ""},
-		{"WSABuf.Buf", Field, 0, ""},
-		{"WSABuf.Len", Field, 0, ""},
-		{"WSACleanup", Func, 0, ""},
-		{"WSADESCRIPTION_LEN", Const, 0, ""},
-		{"WSAData", Type, 0, ""},
-		{"WSAData.Description", Field, 0, ""},
-		{"WSAData.HighVersion", Field, 0, ""},
-		{"WSAData.MaxSockets", Field, 0, ""},
-		{"WSAData.MaxUdpDg", Field, 0, ""},
-		{"WSAData.SystemStatus", Field, 0, ""},
-		{"WSAData.VendorInfo", Field, 0, ""},
-		{"WSAData.Version", Field, 0, ""},
-		{"WSAEACCES", Const, 2, ""},
-		{"WSAECONNABORTED", Const, 9, ""},
-		{"WSAECONNRESET", Const, 3, ""},
-		{"WSAENOPROTOOPT", Const, 23, ""},
-		{"WSAEnumProtocols", Func, 2, ""},
-		{"WSAID_CONNECTEX", Var, 1, ""},
-		{"WSAIoctl", Func, 0, ""},
-		{"WSAPROTOCOL_LEN", Const, 2, ""},
-		{"WSAProtocolChain", Type, 2, ""},
-		{"WSAProtocolChain.ChainEntries", Field, 2, ""},
-		{"WSAProtocolChain.ChainLen", Field, 2, ""},
-		{"WSAProtocolInfo", Type, 2, ""},
-		{"WSAProtocolInfo.AddressFamily", Field, 2, ""},
-		{"WSAProtocolInfo.CatalogEntryId", Field, 2, ""},
-		{"WSAProtocolInfo.MaxSockAddr", Field, 2, ""},
-		{"WSAProtocolInfo.MessageSize", Field, 2, ""},
-		{"WSAProtocolInfo.MinSockAddr", Field, 2, ""},
-		{"WSAProtocolInfo.NetworkByteOrder", Field, 2, ""},
-		{"WSAProtocolInfo.Protocol", Field, 2, ""},
-		{"WSAProtocolInfo.ProtocolChain", Field, 2, ""},
-		{"WSAProtocolInfo.ProtocolMaxOffset", Field, 2, ""},
-		{"WSAProtocolInfo.ProtocolName", Field, 2, ""},
-		{"WSAProtocolInfo.ProviderFlags", Field, 2, ""},
-		{"WSAProtocolInfo.ProviderId", Field, 2, ""},
-		{"WSAProtocolInfo.ProviderReserved", Field, 2, ""},
-		{"WSAProtocolInfo.SecurityScheme", Field, 2, ""},
-		{"WSAProtocolInfo.ServiceFlags1", Field, 2, ""},
-		{"WSAProtocolInfo.ServiceFlags2", Field, 2, ""},
-		{"WSAProtocolInfo.ServiceFlags3", Field, 2, ""},
-		{"WSAProtocolInfo.ServiceFlags4", Field, 2, ""},
-		{"WSAProtocolInfo.SocketType", Field, 2, ""},
-		{"WSAProtocolInfo.Version", Field, 2, ""},
-		{"WSARecv", Func, 0, ""},
-		{"WSARecvFrom", Func, 0, ""},
-		{"WSASYS_STATUS_LEN", Const, 0, ""},
-		{"WSASend", Func, 0, ""},
-		{"WSASendTo", Func, 0, ""},
-		{"WSASendto", Func, 0, ""},
-		{"WSAStartup", Func, 0, ""},
-		{"WSTOPPED", Const, 0, ""},
-		{"WTRAPPED", Const, 1, ""},
-		{"WUNTRACED", Const, 0, ""},
-		{"Wait4", Func, 0, "func(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error)"},
-		{"WaitForSingleObject", Func, 0, ""},
-		{"WaitStatus", Type, 0, ""},
-		{"WaitStatus.ExitCode", Field, 0, ""},
-		{"Win32FileAttributeData", Type, 0, ""},
-		{"Win32FileAttributeData.CreationTime", Field, 0, ""},
-		{"Win32FileAttributeData.FileAttributes", Field, 0, ""},
-		{"Win32FileAttributeData.FileSizeHigh", Field, 0, ""},
-		{"Win32FileAttributeData.FileSizeLow", Field, 0, ""},
-		{"Win32FileAttributeData.LastAccessTime", Field, 0, ""},
-		{"Win32FileAttributeData.LastWriteTime", Field, 0, ""},
-		{"Win32finddata", Type, 0, ""},
-		{"Win32finddata.AlternateFileName", Field, 0, ""},
-		{"Win32finddata.CreationTime", Field, 0, ""},
-		{"Win32finddata.FileAttributes", Field, 0, ""},
-		{"Win32finddata.FileName", Field, 0, ""},
-		{"Win32finddata.FileSizeHigh", Field, 0, ""},
-		{"Win32finddata.FileSizeLow", Field, 0, ""},
-		{"Win32finddata.LastAccessTime", Field, 0, ""},
-		{"Win32finddata.LastWriteTime", Field, 0, ""},
-		{"Win32finddata.Reserved0", Field, 0, ""},
-		{"Win32finddata.Reserved1", Field, 0, ""},
-		{"Write", Func, 0, "func(fd int, p []byte) (n int, err error)"},
-		{"WriteConsole", Func, 1, ""},
-		{"WriteFile", Func, 0, ""},
-		{"X509_ASN_ENCODING", Const, 0, ""},
-		{"XCASE", Const, 0, ""},
-		{"XP1_CONNECTIONLESS", Const, 2, ""},
-		{"XP1_CONNECT_DATA", Const, 2, ""},
-		{"XP1_DISCONNECT_DATA", Const, 2, ""},
-		{"XP1_EXPEDITED_DATA", Const, 2, ""},
-		{"XP1_GRACEFUL_CLOSE", Const, 2, ""},
-		{"XP1_GUARANTEED_DELIVERY", Const, 2, ""},
-		{"XP1_GUARANTEED_ORDER", Const, 2, ""},
-		{"XP1_IFS_HANDLES", Const, 2, ""},
-		{"XP1_MESSAGE_ORIENTED", Const, 2, ""},
-		{"XP1_MULTIPOINT_CONTROL_PLANE", Const, 2, ""},
-		{"XP1_MULTIPOINT_DATA_PLANE", Const, 2, ""},
-		{"XP1_PARTIAL_MESSAGE", Const, 2, ""},
-		{"XP1_PSEUDO_STREAM", Const, 2, ""},
-		{"XP1_QOS_SUPPORTED", Const, 2, ""},
-		{"XP1_SAN_SUPPORT_SDP", Const, 2, ""},
-		{"XP1_SUPPORT_BROADCAST", Const, 2, ""},
-		{"XP1_SUPPORT_MULTIPOINT", Const, 2, ""},
-		{"XP1_UNI_RECV", Const, 2, ""},
-		{"XP1_UNI_SEND", Const, 2, ""},
-	},
-	"syscall/js": {
-		{"CopyBytesToGo", Func, 0, ""},
-		{"CopyBytesToJS", Func, 0, ""},
-		{"Error", Type, 0, ""},
-		{"Func", Type, 0, ""},
-		{"FuncOf", Func, 0, ""},
-		{"Global", Func, 0, ""},
-		{"Null", Func, 0, ""},
-		{"Type", Type, 0, ""},
-		{"TypeBoolean", Const, 0, ""},
-		{"TypeFunction", Const, 0, ""},
-		{"TypeNull", Const, 0, ""},
-		{"TypeNumber", Const, 0, ""},
-		{"TypeObject", Const, 0, ""},
-		{"TypeString", Const, 0, ""},
-		{"TypeSymbol", Const, 0, ""},
-		{"TypeUndefined", Const, 0, ""},
-		{"Undefined", Func, 0, ""},
-		{"Value", Type, 0, ""},
-		{"ValueError", Type, 0, ""},
-		{"ValueOf", Func, 0, ""},
-	},
-	"testing": {
-		{"(*B).ArtifactDir", Method, 26, ""},
-		{"(*B).Attr", Method, 25, ""},
-		{"(*B).Chdir", Method, 24, ""},
-		{"(*B).Cleanup", Method, 14, ""},
-		{"(*B).Context", Method, 24, ""},
-		{"(*B).Elapsed", Method, 20, ""},
-		{"(*B).Error", Method, 0, ""},
-		{"(*B).Errorf", Method, 0, ""},
-		{"(*B).Fail", Method, 0, ""},
-		{"(*B).FailNow", Method, 0, ""},
-		{"(*B).Failed", Method, 0, ""},
-		{"(*B).Fatal", Method, 0, ""},
-		{"(*B).Fatalf", Method, 0, ""},
-		{"(*B).Helper", Method, 9, ""},
-		{"(*B).Log", Method, 0, ""},
-		{"(*B).Logf", Method, 0, ""},
-		{"(*B).Loop", Method, 24, ""},
-		{"(*B).Name", Method, 8, ""},
-		{"(*B).Output", Method, 25, ""},
-		{"(*B).ReportAllocs", Method, 1, ""},
-		{"(*B).ReportMetric", Method, 13, ""},
-		{"(*B).ResetTimer", Method, 0, ""},
-		{"(*B).Run", Method, 7, ""},
-		{"(*B).RunParallel", Method, 3, ""},
-		{"(*B).SetBytes", Method, 0, ""},
-		{"(*B).SetParallelism", Method, 3, ""},
-		{"(*B).Setenv", Method, 17, ""},
-		{"(*B).Skip", Method, 1, ""},
-		{"(*B).SkipNow", Method, 1, ""},
-		{"(*B).Skipf", Method, 1, ""},
-		{"(*B).Skipped", Method, 1, ""},
-		{"(*B).StartTimer", Method, 0, ""},
-		{"(*B).StopTimer", Method, 0, ""},
-		{"(*B).TempDir", Method, 15, ""},
-		{"(*F).Add", Method, 18, ""},
-		{"(*F).ArtifactDir", Method, 26, ""},
-		{"(*F).Attr", Method, 25, ""},
-		{"(*F).Chdir", Method, 24, ""},
-		{"(*F).Cleanup", Method, 18, ""},
-		{"(*F).Context", Method, 24, ""},
-		{"(*F).Error", Method, 18, ""},
-		{"(*F).Errorf", Method, 18, ""},
-		{"(*F).Fail", Method, 18, ""},
-		{"(*F).FailNow", Method, 18, ""},
-		{"(*F).Failed", Method, 18, ""},
-		{"(*F).Fatal", Method, 18, ""},
-		{"(*F).Fatalf", Method, 18, ""},
-		{"(*F).Fuzz", Method, 18, ""},
-		{"(*F).Helper", Method, 18, ""},
-		{"(*F).Log", Method, 18, ""},
-		{"(*F).Logf", Method, 18, ""},
-		{"(*F).Name", Method, 18, ""},
-		{"(*F).Output", Method, 25, ""},
-		{"(*F).Setenv", Method, 18, ""},
-		{"(*F).Skip", Method, 18, ""},
-		{"(*F).SkipNow", Method, 18, ""},
-		{"(*F).Skipf", Method, 18, ""},
-		{"(*F).Skipped", Method, 18, ""},
-		{"(*F).TempDir", Method, 18, ""},
-		{"(*M).Run", Method, 4, ""},
-		{"(*PB).Next", Method, 3, ""},
-		{"(*T).ArtifactDir", Method, 26, ""},
-		{"(*T).Attr", Method, 25, ""},
-		{"(*T).Chdir", Method, 24, ""},
-		{"(*T).Cleanup", Method, 14, ""},
-		{"(*T).Context", Method, 24, ""},
-		{"(*T).Deadline", Method, 15, ""},
-		{"(*T).Error", Method, 0, ""},
-		{"(*T).Errorf", Method, 0, ""},
-		{"(*T).Fail", Method, 0, ""},
-		{"(*T).FailNow", Method, 0, ""},
-		{"(*T).Failed", Method, 0, ""},
-		{"(*T).Fatal", Method, 0, ""},
-		{"(*T).Fatalf", Method, 0, ""},
-		{"(*T).Helper", Method, 9, ""},
-		{"(*T).Log", Method, 0, ""},
-		{"(*T).Logf", Method, 0, ""},
-		{"(*T).Name", Method, 8, ""},
-		{"(*T).Output", Method, 25, ""},
-		{"(*T).Parallel", Method, 0, ""},
-		{"(*T).Run", Method, 7, ""},
-		{"(*T).Setenv", Method, 17, ""},
-		{"(*T).Skip", Method, 1, ""},
-		{"(*T).SkipNow", Method, 1, ""},
-		{"(*T).Skipf", Method, 1, ""},
-		{"(*T).Skipped", Method, 1, ""},
-		{"(*T).TempDir", Method, 15, ""},
-		{"(BenchmarkResult).AllocedBytesPerOp", Method, 1, ""},
-		{"(BenchmarkResult).AllocsPerOp", Method, 1, ""},
-		{"(BenchmarkResult).MemString", Method, 1, ""},
-		{"(BenchmarkResult).NsPerOp", Method, 0, ""},
-		{"(BenchmarkResult).String", Method, 0, ""},
-		{"(TB).ArtifactDir", Method, 26, ""},
-		{"(TB).Attr", Method, 25, ""},
-		{"(TB).Chdir", Method, 24, ""},
-		{"(TB).Cleanup", Method, 14, ""},
-		{"(TB).Context", Method, 24, ""},
-		{"(TB).Error", Method, 2, ""},
-		{"(TB).Errorf", Method, 2, ""},
-		{"(TB).Fail", Method, 2, ""},
-		{"(TB).FailNow", Method, 2, ""},
-		{"(TB).Failed", Method, 2, ""},
-		{"(TB).Fatal", Method, 2, ""},
-		{"(TB).Fatalf", Method, 2, ""},
-		{"(TB).Helper", Method, 9, ""},
-		{"(TB).Log", Method, 2, ""},
-		{"(TB).Logf", Method, 2, ""},
-		{"(TB).Name", Method, 8, ""},
-		{"(TB).Output", Method, 25, ""},
-		{"(TB).Setenv", Method, 17, ""},
-		{"(TB).Skip", Method, 2, ""},
-		{"(TB).SkipNow", Method, 2, ""},
-		{"(TB).Skipf", Method, 2, ""},
-		{"(TB).Skipped", Method, 2, ""},
-		{"(TB).TempDir", Method, 15, ""},
-		{"AllocsPerRun", Func, 1, "func(runs int, f func()) (avg float64)"},
-		{"B", Type, 0, ""},
-		{"B.N", Field, 0, ""},
-		{"Benchmark", Func, 0, "func(f func(b *B)) BenchmarkResult"},
-		{"BenchmarkResult", Type, 0, ""},
-		{"BenchmarkResult.Bytes", Field, 0, ""},
-		{"BenchmarkResult.Extra", Field, 13, ""},
-		{"BenchmarkResult.MemAllocs", Field, 1, ""},
-		{"BenchmarkResult.MemBytes", Field, 1, ""},
-		{"BenchmarkResult.N", Field, 0, ""},
-		{"BenchmarkResult.T", Field, 0, ""},
-		{"Cover", Type, 2, ""},
-		{"Cover.Blocks", Field, 2, ""},
-		{"Cover.Counters", Field, 2, ""},
-		{"Cover.CoveredPackages", Field, 2, ""},
-		{"Cover.Mode", Field, 2, ""},
-		{"CoverBlock", Type, 2, ""},
-		{"CoverBlock.Col0", Field, 2, ""},
-		{"CoverBlock.Col1", Field, 2, ""},
-		{"CoverBlock.Line0", Field, 2, ""},
-		{"CoverBlock.Line1", Field, 2, ""},
-		{"CoverBlock.Stmts", Field, 2, ""},
-		{"CoverMode", Func, 8, "func() string"},
-		{"Coverage", Func, 4, "func() float64"},
-		{"F", Type, 18, ""},
-		{"Init", Func, 13, "func()"},
-		{"InternalBenchmark", Type, 0, ""},
-		{"InternalBenchmark.F", Field, 0, ""},
-		{"InternalBenchmark.Name", Field, 0, ""},
-		{"InternalExample", Type, 0, ""},
-		{"InternalExample.F", Field, 0, ""},
-		{"InternalExample.Name", Field, 0, ""},
-		{"InternalExample.Output", Field, 0, ""},
-		{"InternalExample.Unordered", Field, 7, ""},
-		{"InternalFuzzTarget", Type, 18, ""},
-		{"InternalFuzzTarget.Fn", Field, 18, ""},
-		{"InternalFuzzTarget.Name", Field, 18, ""},
-		{"InternalTest", Type, 0, ""},
-		{"InternalTest.F", Field, 0, ""},
-		{"InternalTest.Name", Field, 0, ""},
-		{"M", Type, 4, ""},
-		{"Main", Func, 0, "func(matchString func(pat string, str string) (bool, error), tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample)"},
-		{"MainStart", Func, 4, "func(deps testDeps, tests []InternalTest, benchmarks []InternalBenchmark, fuzzTargets []InternalFuzzTarget, examples []InternalExample) *M"},
-		{"PB", Type, 3, ""},
-		{"RegisterCover", Func, 2, "func(c Cover)"},
-		{"RunBenchmarks", Func, 0, "func(matchString func(pat string, str string) (bool, error), benchmarks []InternalBenchmark)"},
-		{"RunExamples", Func, 0, "func(matchString func(pat string, str string) (bool, error), examples []InternalExample) (ok bool)"},
-		{"RunTests", Func, 0, "func(matchString func(pat string, str string) (bool, error), tests []InternalTest) (ok bool)"},
-		{"Short", Func, 0, "func() bool"},
-		{"T", Type, 0, ""},
-		{"Testing", Func, 21, "func() bool"},
-		{"Verbose", Func, 1, "func() bool"},
-	},
-	"testing/cryptotest": {
-		{"SetGlobalRandom", Func, 26, "func(t *testing.T, seed uint64)"},
-	},
-	"testing/fstest": {
-		{"(MapFS).Glob", Method, 16, ""},
-		{"(MapFS).Lstat", Method, 25, ""},
-		{"(MapFS).Open", Method, 16, ""},
-		{"(MapFS).ReadDir", Method, 16, ""},
-		{"(MapFS).ReadFile", Method, 16, ""},
-		{"(MapFS).ReadLink", Method, 25, ""},
-		{"(MapFS).Stat", Method, 16, ""},
-		{"(MapFS).Sub", Method, 16, ""},
-		{"MapFS", Type, 16, ""},
-		{"MapFile", Type, 16, ""},
-		{"MapFile.Data", Field, 16, ""},
-		{"MapFile.ModTime", Field, 16, ""},
-		{"MapFile.Mode", Field, 16, ""},
-		{"MapFile.Sys", Field, 16, ""},
-		{"TestFS", Func, 16, "func(fsys fs.FS, expected ...string) error"},
-	},
-	"testing/iotest": {
-		{"DataErrReader", Func, 0, "func(r io.Reader) io.Reader"},
-		{"ErrReader", Func, 16, "func(err error) io.Reader"},
-		{"ErrTimeout", Var, 0, ""},
-		{"HalfReader", Func, 0, "func(r io.Reader) io.Reader"},
-		{"NewReadLogger", Func, 0, "func(prefix string, r io.Reader) io.Reader"},
-		{"NewWriteLogger", Func, 0, "func(prefix string, w io.Writer) io.Writer"},
-		{"OneByteReader", Func, 0, "func(r io.Reader) io.Reader"},
-		{"TestReader", Func, 16, "func(r io.Reader, content []byte) error"},
-		{"TimeoutReader", Func, 0, "func(r io.Reader) io.Reader"},
-		{"TruncateWriter", Func, 0, "func(w io.Writer, n int64) io.Writer"},
-	},
-	"testing/quick": {
-		{"(*CheckEqualError).Error", Method, 0, ""},
-		{"(*CheckError).Error", Method, 0, ""},
-		{"(Generator).Generate", Method, 0, ""},
-		{"(SetupError).Error", Method, 0, ""},
-		{"Check", Func, 0, "func(f any, config *Config) error"},
-		{"CheckEqual", Func, 0, "func(f any, g any, config *Config) error"},
-		{"CheckEqualError", Type, 0, ""},
-		{"CheckEqualError.CheckError", Field, 0, ""},
-		{"CheckEqualError.Out1", Field, 0, ""},
-		{"CheckEqualError.Out2", Field, 0, ""},
-		{"CheckError", Type, 0, ""},
-		{"CheckError.Count", Field, 0, ""},
-		{"CheckError.In", Field, 0, ""},
-		{"Config", Type, 0, ""},
-		{"Config.MaxCount", Field, 0, ""},
-		{"Config.MaxCountScale", Field, 0, ""},
-		{"Config.Rand", Field, 0, ""},
-		{"Config.Values", Field, 0, ""},
-		{"Generator", Type, 0, ""},
-		{"SetupError", Type, 0, ""},
-		{"Value", Func, 0, "func(t reflect.Type, rand *rand.Rand) (value reflect.Value, ok bool)"},
-	},
-	"testing/slogtest": {
-		{"Run", Func, 22, "func(t *testing.T, newHandler func(*testing.T) slog.Handler, result func(*testing.T) map[string]any)"},
-		{"TestHandler", Func, 21, "func(h slog.Handler, results func() []map[string]any) error"},
-	},
-	"testing/synctest": {
-		{"Test", Func, 25, "func(t *testing.T, f func(*testing.T))"},
-		{"Wait", Func, 25, "func()"},
-	},
-	"text/scanner": {
-		{"(*Position).IsValid", Method, 0, ""},
-		{"(*Scanner).Init", Method, 0, ""},
-		{"(*Scanner).IsValid", Method, 0, ""},
-		{"(*Scanner).Next", Method, 0, ""},
-		{"(*Scanner).Peek", Method, 0, ""},
-		{"(*Scanner).Pos", Method, 0, ""},
-		{"(*Scanner).Scan", Method, 0, ""},
-		{"(*Scanner).TokenText", Method, 0, ""},
-		{"(Position).String", Method, 0, ""},
-		{"(Scanner).String", Method, 0, ""},
-		{"Char", Const, 0, ""},
-		{"Comment", Const, 0, ""},
-		{"EOF", Const, 0, ""},
-		{"Float", Const, 0, ""},
-		{"GoTokens", Const, 0, ""},
-		{"GoWhitespace", Const, 0, ""},
-		{"Ident", Const, 0, ""},
-		{"Int", Const, 0, ""},
-		{"Position", Type, 0, ""},
-		{"Position.Column", Field, 0, ""},
-		{"Position.Filename", Field, 0, ""},
-		{"Position.Line", Field, 0, ""},
-		{"Position.Offset", Field, 0, ""},
-		{"RawString", Const, 0, ""},
-		{"ScanChars", Const, 0, ""},
-		{"ScanComments", Const, 0, ""},
-		{"ScanFloats", Const, 0, ""},
-		{"ScanIdents", Const, 0, ""},
-		{"ScanInts", Const, 0, ""},
-		{"ScanRawStrings", Const, 0, ""},
-		{"ScanStrings", Const, 0, ""},
-		{"Scanner", Type, 0, ""},
-		{"Scanner.Error", Field, 0, ""},
-		{"Scanner.ErrorCount", Field, 0, ""},
-		{"Scanner.IsIdentRune", Field, 4, ""},
-		{"Scanner.Mode", Field, 0, ""},
-		{"Scanner.Position", Field, 0, ""},
-		{"Scanner.Whitespace", Field, 0, ""},
-		{"SkipComments", Const, 0, ""},
-		{"String", Const, 0, ""},
-		{"TokenString", Func, 0, "func(tok rune) string"},
-	},
-	"text/tabwriter": {
-		{"(*Writer).Flush", Method, 0, ""},
-		{"(*Writer).Init", Method, 0, ""},
-		{"(*Writer).Write", Method, 0, ""},
-		{"AlignRight", Const, 0, ""},
-		{"Debug", Const, 0, ""},
-		{"DiscardEmptyColumns", Const, 0, ""},
-		{"Escape", Const, 0, ""},
-		{"FilterHTML", Const, 0, ""},
-		{"NewWriter", Func, 0, "func(output io.Writer, minwidth int, tabwidth int, padding int, padchar byte, flags uint) *Writer"},
-		{"StripEscape", Const, 0, ""},
-		{"TabIndent", Const, 0, ""},
-		{"Writer", Type, 0, ""},
-	},
-	"text/template": {
-		{"(*Template).AddParseTree", Method, 0, ""},
-		{"(*Template).Clone", Method, 0, ""},
-		{"(*Template).DefinedTemplates", Method, 5, ""},
-		{"(*Template).Delims", Method, 0, ""},
-		{"(*Template).Execute", Method, 0, ""},
-		{"(*Template).ExecuteTemplate", Method, 0, ""},
-		{"(*Template).Funcs", Method, 0, ""},
-		{"(*Template).Lookup", Method, 0, ""},
-		{"(*Template).Name", Method, 0, ""},
-		{"(*Template).New", Method, 0, ""},
-		{"(*Template).Option", Method, 5, ""},
-		{"(*Template).Parse", Method, 0, ""},
-		{"(*Template).ParseFS", Method, 16, ""},
-		{"(*Template).ParseFiles", Method, 0, ""},
-		{"(*Template).ParseGlob", Method, 0, ""},
-		{"(*Template).Templates", Method, 0, ""},
-		{"(ExecError).Error", Method, 6, ""},
-		{"(ExecError).Unwrap", Method, 13, ""},
-		{"(Template).Copy", Method, 2, ""},
-		{"(Template).ErrorContext", Method, 1, ""},
-		{"ExecError", Type, 6, ""},
-		{"ExecError.Err", Field, 6, ""},
-		{"ExecError.Name", Field, 6, ""},
-		{"FuncMap", Type, 0, ""},
-		{"HTMLEscape", Func, 0, "func(w io.Writer, b []byte)"},
-		{"HTMLEscapeString", Func, 0, "func(s string) string"},
-		{"HTMLEscaper", Func, 0, "func(args ...any) string"},
-		{"IsTrue", Func, 6, "func(val any) (truth bool, ok bool)"},
-		{"JSEscape", Func, 0, "func(w io.Writer, b []byte)"},
-		{"JSEscapeString", Func, 0, "func(s string) string"},
-		{"JSEscaper", Func, 0, "func(args ...any) string"},
-		{"Must", Func, 0, "func(t *Template, err error) *Template"},
-		{"New", Func, 0, "func(name string) *Template"},
-		{"ParseFS", Func, 16, "func(fsys fs.FS, patterns ...string) (*Template, error)"},
-		{"ParseFiles", Func, 0, "func(filenames ...string) (*Template, error)"},
-		{"ParseGlob", Func, 0, "func(pattern string) (*Template, error)"},
-		{"Template", Type, 0, ""},
-		{"Template.Tree", Field, 0, ""},
-		{"URLQueryEscaper", Func, 0, "func(args ...any) string"},
-	},
-	"text/template/parse": {
-		{"(*ActionNode).Copy", Method, 0, ""},
-		{"(*ActionNode).String", Method, 0, ""},
-		{"(*BoolNode).Copy", Method, 0, ""},
-		{"(*BoolNode).String", Method, 0, ""},
-		{"(*BranchNode).Copy", Method, 4, ""},
-		{"(*BranchNode).String", Method, 0, ""},
-		{"(*BreakNode).Copy", Method, 18, ""},
-		{"(*BreakNode).String", Method, 18, ""},
-		{"(*ChainNode).Add", Method, 1, ""},
-		{"(*ChainNode).Copy", Method, 1, ""},
-		{"(*ChainNode).String", Method, 1, ""},
-		{"(*CommandNode).Copy", Method, 0, ""},
-		{"(*CommandNode).String", Method, 0, ""},
-		{"(*CommentNode).Copy", Method, 16, ""},
-		{"(*CommentNode).String", Method, 16, ""},
-		{"(*ContinueNode).Copy", Method, 18, ""},
-		{"(*ContinueNode).String", Method, 18, ""},
-		{"(*DotNode).Copy", Method, 0, ""},
-		{"(*DotNode).String", Method, 0, ""},
-		{"(*DotNode).Type", Method, 0, ""},
-		{"(*FieldNode).Copy", Method, 0, ""},
-		{"(*FieldNode).String", Method, 0, ""},
-		{"(*IdentifierNode).Copy", Method, 0, ""},
-		{"(*IdentifierNode).SetPos", Method, 1, ""},
-		{"(*IdentifierNode).SetTree", Method, 4, ""},
-		{"(*IdentifierNode).String", Method, 0, ""},
-		{"(*IfNode).Copy", Method, 0, ""},
-		{"(*IfNode).String", Method, 0, ""},
-		{"(*ListNode).Copy", Method, 0, ""},
-		{"(*ListNode).CopyList", Method, 0, ""},
-		{"(*ListNode).String", Method, 0, ""},
-		{"(*NilNode).Copy", Method, 1, ""},
-		{"(*NilNode).String", Method, 1, ""},
-		{"(*NilNode).Type", Method, 1, ""},
-		{"(*NumberNode).Copy", Method, 0, ""},
-		{"(*NumberNode).String", Method, 0, ""},
-		{"(*PipeNode).Copy", Method, 0, ""},
-		{"(*PipeNode).CopyPipe", Method, 0, ""},
-		{"(*PipeNode).String", Method, 0, ""},
-		{"(*RangeNode).Copy", Method, 0, ""},
-		{"(*RangeNode).String", Method, 0, ""},
-		{"(*StringNode).Copy", Method, 0, ""},
-		{"(*StringNode).String", Method, 0, ""},
-		{"(*TemplateNode).Copy", Method, 0, ""},
-		{"(*TemplateNode).String", Method, 0, ""},
-		{"(*TextNode).Copy", Method, 0, ""},
-		{"(*TextNode).String", Method, 0, ""},
-		{"(*Tree).Copy", Method, 2, ""},
-		{"(*Tree).ErrorContext", Method, 1, ""},
-		{"(*Tree).Parse", Method, 0, ""},
-		{"(*VariableNode).Copy", Method, 0, ""},
-		{"(*VariableNode).String", Method, 0, ""},
-		{"(*WithNode).Copy", Method, 0, ""},
-		{"(*WithNode).String", Method, 0, ""},
-		{"(ActionNode).Position", Method, 1, ""},
-		{"(ActionNode).Type", Method, 0, ""},
-		{"(BoolNode).Position", Method, 1, ""},
-		{"(BoolNode).Type", Method, 0, ""},
-		{"(BranchNode).Position", Method, 1, ""},
-		{"(BranchNode).Type", Method, 0, ""},
-		{"(BreakNode).Position", Method, 18, ""},
-		{"(BreakNode).Type", Method, 18, ""},
-		{"(ChainNode).Position", Method, 1, ""},
-		{"(ChainNode).Type", Method, 1, ""},
-		{"(CommandNode).Position", Method, 1, ""},
-		{"(CommandNode).Type", Method, 0, ""},
-		{"(CommentNode).Position", Method, 16, ""},
-		{"(CommentNode).Type", Method, 16, ""},
-		{"(ContinueNode).Position", Method, 18, ""},
-		{"(ContinueNode).Type", Method, 18, ""},
-		{"(DotNode).Position", Method, 1, ""},
-		{"(FieldNode).Position", Method, 1, ""},
-		{"(FieldNode).Type", Method, 0, ""},
-		{"(IdentifierNode).Position", Method, 1, ""},
-		{"(IdentifierNode).Type", Method, 0, ""},
-		{"(IfNode).Position", Method, 1, ""},
-		{"(IfNode).Type", Method, 0, ""},
-		{"(ListNode).Position", Method, 1, ""},
-		{"(ListNode).Type", Method, 0, ""},
-		{"(NilNode).Position", Method, 1, ""},
-		{"(Node).Copy", Method, 0, ""},
-		{"(Node).Position", Method, 1, ""},
-		{"(Node).String", Method, 0, ""},
-		{"(Node).Type", Method, 0, ""},
-		{"(NodeType).Type", Method, 0, ""},
-		{"(NumberNode).Position", Method, 1, ""},
-		{"(NumberNode).Type", Method, 0, ""},
-		{"(PipeNode).Position", Method, 1, ""},
-		{"(PipeNode).Type", Method, 0, ""},
-		{"(Pos).Position", Method, 1, ""},
-		{"(RangeNode).Position", Method, 1, ""},
-		{"(RangeNode).Type", Method, 0, ""},
-		{"(StringNode).Position", Method, 1, ""},
-		{"(StringNode).Type", Method, 0, ""},
-		{"(TemplateNode).Position", Method, 1, ""},
-		{"(TemplateNode).Type", Method, 0, ""},
-		{"(TextNode).Position", Method, 1, ""},
-		{"(TextNode).Type", Method, 0, ""},
-		{"(VariableNode).Position", Method, 1, ""},
-		{"(VariableNode).Type", Method, 0, ""},
-		{"(WithNode).Position", Method, 1, ""},
-		{"(WithNode).Type", Method, 0, ""},
-		{"ActionNode", Type, 0, ""},
-		{"ActionNode.Line", Field, 0, ""},
-		{"ActionNode.NodeType", Field, 0, ""},
-		{"ActionNode.Pipe", Field, 0, ""},
-		{"ActionNode.Pos", Field, 1, ""},
-		{"BoolNode", Type, 0, ""},
-		{"BoolNode.NodeType", Field, 0, ""},
-		{"BoolNode.Pos", Field, 1, ""},
-		{"BoolNode.True", Field, 0, ""},
-		{"BranchNode", Type, 0, ""},
-		{"BranchNode.ElseList", Field, 0, ""},
-		{"BranchNode.Line", Field, 0, ""},
-		{"BranchNode.List", Field, 0, ""},
-		{"BranchNode.NodeType", Field, 0, ""},
-		{"BranchNode.Pipe", Field, 0, ""},
-		{"BranchNode.Pos", Field, 1, ""},
-		{"BreakNode", Type, 18, ""},
-		{"BreakNode.Line", Field, 18, ""},
-		{"BreakNode.NodeType", Field, 18, ""},
-		{"BreakNode.Pos", Field, 18, ""},
-		{"ChainNode", Type, 1, ""},
-		{"ChainNode.Field", Field, 1, ""},
-		{"ChainNode.Node", Field, 1, ""},
-		{"ChainNode.NodeType", Field, 1, ""},
-		{"ChainNode.Pos", Field, 1, ""},
-		{"CommandNode", Type, 0, ""},
-		{"CommandNode.Args", Field, 0, ""},
-		{"CommandNode.NodeType", Field, 0, ""},
-		{"CommandNode.Pos", Field, 1, ""},
-		{"CommentNode", Type, 16, ""},
-		{"CommentNode.NodeType", Field, 16, ""},
-		{"CommentNode.Pos", Field, 16, ""},
-		{"CommentNode.Text", Field, 16, ""},
-		{"ContinueNode", Type, 18, ""},
-		{"ContinueNode.Line", Field, 18, ""},
-		{"ContinueNode.NodeType", Field, 18, ""},
-		{"ContinueNode.Pos", Field, 18, ""},
-		{"DotNode", Type, 0, ""},
-		{"DotNode.NodeType", Field, 4, ""},
-		{"DotNode.Pos", Field, 1, ""},
-		{"FieldNode", Type, 0, ""},
-		{"FieldNode.Ident", Field, 0, ""},
-		{"FieldNode.NodeType", Field, 0, ""},
-		{"FieldNode.Pos", Field, 1, ""},
-		{"IdentifierNode", Type, 0, ""},
-		{"IdentifierNode.Ident", Field, 0, ""},
-		{"IdentifierNode.NodeType", Field, 0, ""},
-		{"IdentifierNode.Pos", Field, 1, ""},
-		{"IfNode", Type, 0, ""},
-		{"IfNode.BranchNode", Field, 0, ""},
-		{"IsEmptyTree", Func, 0, "func(n Node) bool"},
-		{"ListNode", Type, 0, ""},
-		{"ListNode.NodeType", Field, 0, ""},
-		{"ListNode.Nodes", Field, 0, ""},
-		{"ListNode.Pos", Field, 1, ""},
-		{"Mode", Type, 16, ""},
-		{"New", Func, 0, "func(name string, funcs ...map[string]any) *Tree"},
-		{"NewIdentifier", Func, 0, "func(ident string) *IdentifierNode"},
-		{"NilNode", Type, 1, ""},
-		{"NilNode.NodeType", Field, 4, ""},
-		{"NilNode.Pos", Field, 1, ""},
-		{"Node", Type, 0, ""},
-		{"NodeAction", Const, 0, ""},
-		{"NodeBool", Const, 0, ""},
-		{"NodeBreak", Const, 18, ""},
-		{"NodeChain", Const, 1, ""},
-		{"NodeCommand", Const, 0, ""},
-		{"NodeComment", Const, 16, ""},
-		{"NodeContinue", Const, 18, ""},
-		{"NodeDot", Const, 0, ""},
-		{"NodeField", Const, 0, ""},
-		{"NodeIdentifier", Const, 0, ""},
-		{"NodeIf", Const, 0, ""},
-		{"NodeList", Const, 0, ""},
-		{"NodeNil", Const, 1, ""},
-		{"NodeNumber", Const, 0, ""},
-		{"NodePipe", Const, 0, ""},
-		{"NodeRange", Const, 0, ""},
-		{"NodeString", Const, 0, ""},
-		{"NodeTemplate", Const, 0, ""},
-		{"NodeText", Const, 0, ""},
-		{"NodeType", Type, 0, ""},
-		{"NodeVariable", Const, 0, ""},
-		{"NodeWith", Const, 0, ""},
-		{"NumberNode", Type, 0, ""},
-		{"NumberNode.Complex128", Field, 0, ""},
-		{"NumberNode.Float64", Field, 0, ""},
-		{"NumberNode.Int64", Field, 0, ""},
-		{"NumberNode.IsComplex", Field, 0, ""},
-		{"NumberNode.IsFloat", Field, 0, ""},
-		{"NumberNode.IsInt", Field, 0, ""},
-		{"NumberNode.IsUint", Field, 0, ""},
-		{"NumberNode.NodeType", Field, 0, ""},
-		{"NumberNode.Pos", Field, 1, ""},
-		{"NumberNode.Text", Field, 0, ""},
-		{"NumberNode.Uint64", Field, 0, ""},
-		{"Parse", Func, 0, "func(name string, text string, leftDelim string, rightDelim string, funcs ...map[string]any) (map[string]*Tree, error)"},
-		{"ParseComments", Const, 16, ""},
-		{"PipeNode", Type, 0, ""},
-		{"PipeNode.Cmds", Field, 0, ""},
-		{"PipeNode.Decl", Field, 0, ""},
-		{"PipeNode.IsAssign", Field, 11, ""},
-		{"PipeNode.Line", Field, 0, ""},
-		{"PipeNode.NodeType", Field, 0, ""},
-		{"PipeNode.Pos", Field, 1, ""},
-		{"Pos", Type, 1, ""},
-		{"RangeNode", Type, 0, ""},
-		{"RangeNode.BranchNode", Field, 0, ""},
-		{"SkipFuncCheck", Const, 17, ""},
-		{"StringNode", Type, 0, ""},
-		{"StringNode.NodeType", Field, 0, ""},
-		{"StringNode.Pos", Field, 1, ""},
-		{"StringNode.Quoted", Field, 0, ""},
-		{"StringNode.Text", Field, 0, ""},
-		{"TemplateNode", Type, 0, ""},
-		{"TemplateNode.Line", Field, 0, ""},
-		{"TemplateNode.Name", Field, 0, ""},
-		{"TemplateNode.NodeType", Field, 0, ""},
-		{"TemplateNode.Pipe", Field, 0, ""},
-		{"TemplateNode.Pos", Field, 1, ""},
-		{"TextNode", Type, 0, ""},
-		{"TextNode.NodeType", Field, 0, ""},
-		{"TextNode.Pos", Field, 1, ""},
-		{"TextNode.Text", Field, 0, ""},
-		{"Tree", Type, 0, ""},
-		{"Tree.Mode", Field, 16, ""},
-		{"Tree.Name", Field, 0, ""},
-		{"Tree.ParseName", Field, 1, ""},
-		{"Tree.Root", Field, 0, ""},
-		{"VariableNode", Type, 0, ""},
-		{"VariableNode.Ident", Field, 0, ""},
-		{"VariableNode.NodeType", Field, 0, ""},
-		{"VariableNode.Pos", Field, 1, ""},
-		{"WithNode", Type, 0, ""},
-		{"WithNode.BranchNode", Field, 0, ""},
-	},
-	"time": {
-		{"(*Location).String", Method, 0, ""},
-		{"(*ParseError).Error", Method, 0, ""},
-		{"(*Ticker).Reset", Method, 15, ""},
-		{"(*Ticker).Stop", Method, 0, ""},
-		{"(*Time).GobDecode", Method, 0, ""},
-		{"(*Time).UnmarshalBinary", Method, 2, ""},
-		{"(*Time).UnmarshalJSON", Method, 0, ""},
-		{"(*Time).UnmarshalText", Method, 2, ""},
-		{"(*Timer).Reset", Method, 1, ""},
-		{"(*Timer).Stop", Method, 0, ""},
-		{"(Duration).Abs", Method, 19, ""},
-		{"(Duration).Hours", Method, 0, ""},
-		{"(Duration).Microseconds", Method, 13, ""},
-		{"(Duration).Milliseconds", Method, 13, ""},
-		{"(Duration).Minutes", Method, 0, ""},
-		{"(Duration).Nanoseconds", Method, 0, ""},
-		{"(Duration).Round", Method, 9, ""},
-		{"(Duration).Seconds", Method, 0, ""},
-		{"(Duration).String", Method, 0, ""},
-		{"(Duration).Truncate", Method, 9, ""},
-		{"(Month).String", Method, 0, ""},
-		{"(Time).Add", Method, 0, ""},
-		{"(Time).AddDate", Method, 0, ""},
-		{"(Time).After", Method, 0, ""},
-		{"(Time).AppendBinary", Method, 24, ""},
-		{"(Time).AppendFormat", Method, 5, ""},
-		{"(Time).AppendText", Method, 24, ""},
-		{"(Time).Before", Method, 0, ""},
-		{"(Time).Clock", Method, 0, ""},
-		{"(Time).Compare", Method, 20, ""},
-		{"(Time).Date", Method, 0, ""},
-		{"(Time).Day", Method, 0, ""},
-		{"(Time).Equal", Method, 0, ""},
-		{"(Time).Format", Method, 0, ""},
-		{"(Time).GoString", Method, 17, ""},
-		{"(Time).GobEncode", Method, 0, ""},
-		{"(Time).Hour", Method, 0, ""},
-		{"(Time).ISOWeek", Method, 0, ""},
-		{"(Time).In", Method, 0, ""},
-		{"(Time).IsDST", Method, 17, ""},
-		{"(Time).IsZero", Method, 0, ""},
-		{"(Time).Local", Method, 0, ""},
-		{"(Time).Location", Method, 0, ""},
-		{"(Time).MarshalBinary", Method, 2, ""},
-		{"(Time).MarshalJSON", Method, 0, ""},
-		{"(Time).MarshalText", Method, 2, ""},
-		{"(Time).Minute", Method, 0, ""},
-		{"(Time).Month", Method, 0, ""},
-		{"(Time).Nanosecond", Method, 0, ""},
-		{"(Time).Round", Method, 1, ""},
-		{"(Time).Second", Method, 0, ""},
-		{"(Time).String", Method, 0, ""},
-		{"(Time).Sub", Method, 0, ""},
-		{"(Time).Truncate", Method, 1, ""},
-		{"(Time).UTC", Method, 0, ""},
-		{"(Time).Unix", Method, 0, ""},
-		{"(Time).UnixMicro", Method, 17, ""},
-		{"(Time).UnixMilli", Method, 17, ""},
-		{"(Time).UnixNano", Method, 0, ""},
-		{"(Time).Weekday", Method, 0, ""},
-		{"(Time).Year", Method, 0, ""},
-		{"(Time).YearDay", Method, 1, ""},
-		{"(Time).Zone", Method, 0, ""},
-		{"(Time).ZoneBounds", Method, 19, ""},
-		{"(Weekday).String", Method, 0, ""},
-		{"ANSIC", Const, 0, ""},
-		{"After", Func, 0, "func(d Duration) <-chan Time"},
-		{"AfterFunc", Func, 0, "func(d Duration, f func()) *Timer"},
-		{"April", Const, 0, ""},
-		{"August", Const, 0, ""},
-		{"Date", Func, 0, "func(year int, month Month, day int, hour int, min int, sec int, nsec int, loc *Location) Time"},
-		{"DateOnly", Const, 20, ""},
-		{"DateTime", Const, 20, ""},
-		{"December", Const, 0, ""},
-		{"Duration", Type, 0, ""},
-		{"February", Const, 0, ""},
-		{"FixedZone", Func, 0, "func(name string, offset int) *Location"},
-		{"Friday", Const, 0, ""},
-		{"Hour", Const, 0, ""},
-		{"January", Const, 0, ""},
-		{"July", Const, 0, ""},
-		{"June", Const, 0, ""},
-		{"Kitchen", Const, 0, ""},
-		{"Layout", Const, 17, ""},
-		{"LoadLocation", Func, 0, "func(name string) (*Location, error)"},
-		{"LoadLocationFromTZData", Func, 10, "func(name string, data []byte) (*Location, error)"},
-		{"Local", Var, 0, ""},
-		{"Location", Type, 0, ""},
-		{"March", Const, 0, ""},
-		{"May", Const, 0, ""},
-		{"Microsecond", Const, 0, ""},
-		{"Millisecond", Const, 0, ""},
-		{"Minute", Const, 0, ""},
-		{"Monday", Const, 0, ""},
-		{"Month", Type, 0, ""},
-		{"Nanosecond", Const, 0, ""},
-		{"NewTicker", Func, 0, "func(d Duration) *Ticker"},
-		{"NewTimer", Func, 0, "func(d Duration) *Timer"},
-		{"November", Const, 0, ""},
-		{"Now", Func, 0, "func() Time"},
-		{"October", Const, 0, ""},
-		{"Parse", Func, 0, "func(layout string, value string) (Time, error)"},
-		{"ParseDuration", Func, 0, "func(s string) (Duration, error)"},
-		{"ParseError", Type, 0, ""},
-		{"ParseError.Layout", Field, 0, ""},
-		{"ParseError.LayoutElem", Field, 0, ""},
-		{"ParseError.Message", Field, 0, ""},
-		{"ParseError.Value", Field, 0, ""},
-		{"ParseError.ValueElem", Field, 0, ""},
-		{"ParseInLocation", Func, 1, "func(layout string, value string, loc *Location) (Time, error)"},
-		{"RFC1123", Const, 0, ""},
-		{"RFC1123Z", Const, 0, ""},
-		{"RFC3339", Const, 0, ""},
-		{"RFC3339Nano", Const, 0, ""},
-		{"RFC822", Const, 0, ""},
-		{"RFC822Z", Const, 0, ""},
-		{"RFC850", Const, 0, ""},
-		{"RubyDate", Const, 0, ""},
-		{"Saturday", Const, 0, ""},
-		{"Second", Const, 0, ""},
-		{"September", Const, 0, ""},
-		{"Since", Func, 0, "func(t Time) Duration"},
-		{"Sleep", Func, 0, "func(d Duration)"},
-		{"Stamp", Const, 0, ""},
-		{"StampMicro", Const, 0, ""},
-		{"StampMilli", Const, 0, ""},
-		{"StampNano", Const, 0, ""},
-		{"Sunday", Const, 0, ""},
-		{"Thursday", Const, 0, ""},
-		{"Tick", Func, 0, "func(d Duration) <-chan Time"},
-		{"Ticker", Type, 0, ""},
-		{"Ticker.C", Field, 0, ""},
-		{"Time", Type, 0, ""},
-		{"TimeOnly", Const, 20, ""},
-		{"Timer", Type, 0, ""},
-		{"Timer.C", Field, 0, ""},
-		{"Tuesday", Const, 0, ""},
-		{"UTC", Var, 0, ""},
-		{"Unix", Func, 0, "func(sec int64, nsec int64) Time"},
-		{"UnixDate", Const, 0, ""},
-		{"UnixMicro", Func, 17, "func(usec int64) Time"},
-		{"UnixMilli", Func, 17, "func(msec int64) Time"},
-		{"Until", Func, 8, "func(t Time) Duration"},
-		{"Wednesday", Const, 0, ""},
-		{"Weekday", Type, 0, ""},
-	},
-	"unicode": {
-		{"(SpecialCase).ToLower", Method, 0, ""},
-		{"(SpecialCase).ToTitle", Method, 0, ""},
-		{"(SpecialCase).ToUpper", Method, 0, ""},
-		{"ASCII_Hex_Digit", Var, 0, ""},
-		{"Adlam", Var, 7, ""},
-		{"Ahom", Var, 5, ""},
-		{"Anatolian_Hieroglyphs", Var, 5, ""},
-		{"Arabic", Var, 0, ""},
-		{"Armenian", Var, 0, ""},
-		{"Avestan", Var, 0, ""},
-		{"AzeriCase", Var, 0, ""},
-		{"Balinese", Var, 0, ""},
-		{"Bamum", Var, 0, ""},
-		{"Bassa_Vah", Var, 4, ""},
-		{"Batak", Var, 0, ""},
-		{"Bengali", Var, 0, ""},
-		{"Bhaiksuki", Var, 7, ""},
-		{"Bidi_Control", Var, 0, ""},
-		{"Bopomofo", Var, 0, ""},
-		{"Brahmi", Var, 0, ""},
-		{"Braille", Var, 0, ""},
-		{"Buginese", Var, 0, ""},
-		{"Buhid", Var, 0, ""},
-		{"C", Var, 0, ""},
-		{"Canadian_Aboriginal", Var, 0, ""},
-		{"Carian", Var, 0, ""},
-		{"CaseRange", Type, 0, ""},
-		{"CaseRange.Delta", Field, 0, ""},
-		{"CaseRange.Hi", Field, 0, ""},
-		{"CaseRange.Lo", Field, 0, ""},
-		{"CaseRanges", Var, 0, ""},
-		{"Categories", Var, 0, ""},
-		{"CategoryAliases", Var, 25, ""},
-		{"Caucasian_Albanian", Var, 4, ""},
-		{"Cc", Var, 0, ""},
-		{"Cf", Var, 0, ""},
-		{"Chakma", Var, 1, ""},
-		{"Cham", Var, 0, ""},
-		{"Cherokee", Var, 0, ""},
-		{"Chorasmian", Var, 16, ""},
-		{"Cn", Var, 25, ""},
-		{"Co", Var, 0, ""},
-		{"Common", Var, 0, ""},
-		{"Coptic", Var, 0, ""},
-		{"Cs", Var, 0, ""},
-		{"Cuneiform", Var, 0, ""},
-		{"Cypriot", Var, 0, ""},
-		{"Cypro_Minoan", Var, 21, ""},
-		{"Cyrillic", Var, 0, ""},
-		{"Dash", Var, 0, ""},
-		{"Deprecated", Var, 0, ""},
-		{"Deseret", Var, 0, ""},
-		{"Devanagari", Var, 0, ""},
-		{"Diacritic", Var, 0, ""},
-		{"Digit", Var, 0, ""},
-		{"Dives_Akuru", Var, 16, ""},
-		{"Dogra", Var, 13, ""},
-		{"Duployan", Var, 4, ""},
-		{"Egyptian_Hieroglyphs", Var, 0, ""},
-		{"Elbasan", Var, 4, ""},
-		{"Elymaic", Var, 14, ""},
-		{"Ethiopic", Var, 0, ""},
-		{"Extender", Var, 0, ""},
-		{"FoldCategory", Var, 0, ""},
-		{"FoldScript", Var, 0, ""},
-		{"Georgian", Var, 0, ""},
-		{"Glagolitic", Var, 0, ""},
-		{"Gothic", Var, 0, ""},
-		{"Grantha", Var, 4, ""},
-		{"GraphicRanges", Var, 0, ""},
-		{"Greek", Var, 0, ""},
-		{"Gujarati", Var, 0, ""},
-		{"Gunjala_Gondi", Var, 13, ""},
-		{"Gurmukhi", Var, 0, ""},
-		{"Han", Var, 0, ""},
-		{"Hangul", Var, 0, ""},
-		{"Hanifi_Rohingya", Var, 13, ""},
-		{"Hanunoo", Var, 0, ""},
-		{"Hatran", Var, 5, ""},
-		{"Hebrew", Var, 0, ""},
-		{"Hex_Digit", Var, 0, ""},
-		{"Hiragana", Var, 0, ""},
-		{"Hyphen", Var, 0, ""},
-		{"IDS_Binary_Operator", Var, 0, ""},
-		{"IDS_Trinary_Operator", Var, 0, ""},
-		{"Ideographic", Var, 0, ""},
-		{"Imperial_Aramaic", Var, 0, ""},
-		{"In", Func, 2, "func(r rune, ranges ...*RangeTable) bool"},
-		{"Inherited", Var, 0, ""},
-		{"Inscriptional_Pahlavi", Var, 0, ""},
-		{"Inscriptional_Parthian", Var, 0, ""},
-		{"Is", Func, 0, "func(rangeTab *RangeTable, r rune) bool"},
-		{"IsControl", Func, 0, "func(r rune) bool"},
-		{"IsDigit", Func, 0, "func(r rune) bool"},
-		{"IsGraphic", Func, 0, "func(r rune) bool"},
-		{"IsLetter", Func, 0, "func(r rune) bool"},
-		{"IsLower", Func, 0, "func(r rune) bool"},
-		{"IsMark", Func, 0, "func(r rune) bool"},
-		{"IsNumber", Func, 0, "func(r rune) bool"},
-		{"IsOneOf", Func, 0, "func(ranges []*RangeTable, r rune) bool"},
-		{"IsPrint", Func, 0, "func(r rune) bool"},
-		{"IsPunct", Func, 0, "func(r rune) bool"},
-		{"IsSpace", Func, 0, "func(r rune) bool"},
-		{"IsSymbol", Func, 0, "func(r rune) bool"},
-		{"IsTitle", Func, 0, "func(r rune) bool"},
-		{"IsUpper", Func, 0, "func(r rune) bool"},
-		{"Javanese", Var, 0, ""},
-		{"Join_Control", Var, 0, ""},
-		{"Kaithi", Var, 0, ""},
-		{"Kannada", Var, 0, ""},
-		{"Katakana", Var, 0, ""},
-		{"Kawi", Var, 21, ""},
-		{"Kayah_Li", Var, 0, ""},
-		{"Kharoshthi", Var, 0, ""},
-		{"Khitan_Small_Script", Var, 16, ""},
-		{"Khmer", Var, 0, ""},
-		{"Khojki", Var, 4, ""},
-		{"Khudawadi", Var, 4, ""},
-		{"L", Var, 0, ""},
-		{"LC", Var, 25, ""},
-		{"Lao", Var, 0, ""},
-		{"Latin", Var, 0, ""},
-		{"Lepcha", Var, 0, ""},
-		{"Letter", Var, 0, ""},
-		{"Limbu", Var, 0, ""},
-		{"Linear_A", Var, 4, ""},
-		{"Linear_B", Var, 0, ""},
-		{"Lisu", Var, 0, ""},
-		{"Ll", Var, 0, ""},
-		{"Lm", Var, 0, ""},
-		{"Lo", Var, 0, ""},
-		{"Logical_Order_Exception", Var, 0, ""},
-		{"Lower", Var, 0, ""},
-		{"LowerCase", Const, 0, ""},
-		{"Lt", Var, 0, ""},
-		{"Lu", Var, 0, ""},
-		{"Lycian", Var, 0, ""},
-		{"Lydian", Var, 0, ""},
-		{"M", Var, 0, ""},
-		{"Mahajani", Var, 4, ""},
-		{"Makasar", Var, 13, ""},
-		{"Malayalam", Var, 0, ""},
-		{"Mandaic", Var, 0, ""},
-		{"Manichaean", Var, 4, ""},
-		{"Marchen", Var, 7, ""},
-		{"Mark", Var, 0, ""},
-		{"Masaram_Gondi", Var, 10, ""},
-		{"MaxASCII", Const, 0, ""},
-		{"MaxCase", Const, 0, ""},
-		{"MaxLatin1", Const, 0, ""},
-		{"MaxRune", Const, 0, ""},
-		{"Mc", Var, 0, ""},
-		{"Me", Var, 0, ""},
-		{"Medefaidrin", Var, 13, ""},
-		{"Meetei_Mayek", Var, 0, ""},
-		{"Mende_Kikakui", Var, 4, ""},
-		{"Meroitic_Cursive", Var, 1, ""},
-		{"Meroitic_Hieroglyphs", Var, 1, ""},
-		{"Miao", Var, 1, ""},
-		{"Mn", Var, 0, ""},
-		{"Modi", Var, 4, ""},
-		{"Mongolian", Var, 0, ""},
-		{"Mro", Var, 4, ""},
-		{"Multani", Var, 5, ""},
-		{"Myanmar", Var, 0, ""},
-		{"N", Var, 0, ""},
-		{"Nabataean", Var, 4, ""},
-		{"Nag_Mundari", Var, 21, ""},
-		{"Nandinagari", Var, 14, ""},
-		{"Nd", Var, 0, ""},
-		{"New_Tai_Lue", Var, 0, ""},
-		{"Newa", Var, 7, ""},
-		{"Nko", Var, 0, ""},
-		{"Nl", Var, 0, ""},
-		{"No", Var, 0, ""},
-		{"Noncharacter_Code_Point", Var, 0, ""},
-		{"Number", Var, 0, ""},
-		{"Nushu", Var, 10, ""},
-		{"Nyiakeng_Puachue_Hmong", Var, 14, ""},
-		{"Ogham", Var, 0, ""},
-		{"Ol_Chiki", Var, 0, ""},
-		{"Old_Hungarian", Var, 5, ""},
-		{"Old_Italic", Var, 0, ""},
-		{"Old_North_Arabian", Var, 4, ""},
-		{"Old_Permic", Var, 4, ""},
-		{"Old_Persian", Var, 0, ""},
-		{"Old_Sogdian", Var, 13, ""},
-		{"Old_South_Arabian", Var, 0, ""},
-		{"Old_Turkic", Var, 0, ""},
-		{"Old_Uyghur", Var, 21, ""},
-		{"Oriya", Var, 0, ""},
-		{"Osage", Var, 7, ""},
-		{"Osmanya", Var, 0, ""},
-		{"Other", Var, 0, ""},
-		{"Other_Alphabetic", Var, 0, ""},
-		{"Other_Default_Ignorable_Code_Point", Var, 0, ""},
-		{"Other_Grapheme_Extend", Var, 0, ""},
-		{"Other_ID_Continue", Var, 0, ""},
-		{"Other_ID_Start", Var, 0, ""},
-		{"Other_Lowercase", Var, 0, ""},
-		{"Other_Math", Var, 0, ""},
-		{"Other_Uppercase", Var, 0, ""},
-		{"P", Var, 0, ""},
-		{"Pahawh_Hmong", Var, 4, ""},
-		{"Palmyrene", Var, 4, ""},
-		{"Pattern_Syntax", Var, 0, ""},
-		{"Pattern_White_Space", Var, 0, ""},
-		{"Pau_Cin_Hau", Var, 4, ""},
-		{"Pc", Var, 0, ""},
-		{"Pd", Var, 0, ""},
-		{"Pe", Var, 0, ""},
-		{"Pf", Var, 0, ""},
-		{"Phags_Pa", Var, 0, ""},
-		{"Phoenician", Var, 0, ""},
-		{"Pi", Var, 0, ""},
-		{"Po", Var, 0, ""},
-		{"Prepended_Concatenation_Mark", Var, 7, ""},
-		{"PrintRanges", Var, 0, ""},
-		{"Properties", Var, 0, ""},
-		{"Ps", Var, 0, ""},
-		{"Psalter_Pahlavi", Var, 4, ""},
-		{"Punct", Var, 0, ""},
-		{"Quotation_Mark", Var, 0, ""},
-		{"Radical", Var, 0, ""},
-		{"Range16", Type, 0, ""},
-		{"Range16.Hi", Field, 0, ""},
-		{"Range16.Lo", Field, 0, ""},
-		{"Range16.Stride", Field, 0, ""},
-		{"Range32", Type, 0, ""},
-		{"Range32.Hi", Field, 0, ""},
-		{"Range32.Lo", Field, 0, ""},
-		{"Range32.Stride", Field, 0, ""},
-		{"RangeTable", Type, 0, ""},
-		{"RangeTable.LatinOffset", Field, 1, ""},
-		{"RangeTable.R16", Field, 0, ""},
-		{"RangeTable.R32", Field, 0, ""},
-		{"Regional_Indicator", Var, 10, ""},
-		{"Rejang", Var, 0, ""},
-		{"ReplacementChar", Const, 0, ""},
-		{"Runic", Var, 0, ""},
-		{"S", Var, 0, ""},
-		{"STerm", Var, 0, ""},
-		{"Samaritan", Var, 0, ""},
-		{"Saurashtra", Var, 0, ""},
-		{"Sc", Var, 0, ""},
-		{"Scripts", Var, 0, ""},
-		{"Sentence_Terminal", Var, 7, ""},
-		{"Sharada", Var, 1, ""},
-		{"Shavian", Var, 0, ""},
-		{"Siddham", Var, 4, ""},
-		{"SignWriting", Var, 5, ""},
-		{"SimpleFold", Func, 0, "func(r rune) rune"},
-		{"Sinhala", Var, 0, ""},
-		{"Sk", Var, 0, ""},
-		{"Sm", Var, 0, ""},
-		{"So", Var, 0, ""},
-		{"Soft_Dotted", Var, 0, ""},
-		{"Sogdian", Var, 13, ""},
-		{"Sora_Sompeng", Var, 1, ""},
-		{"Soyombo", Var, 10, ""},
-		{"Space", Var, 0, ""},
-		{"SpecialCase", Type, 0, ""},
-		{"Sundanese", Var, 0, ""},
-		{"Syloti_Nagri", Var, 0, ""},
-		{"Symbol", Var, 0, ""},
-		{"Syriac", Var, 0, ""},
-		{"Tagalog", Var, 0, ""},
-		{"Tagbanwa", Var, 0, ""},
-		{"Tai_Le", Var, 0, ""},
-		{"Tai_Tham", Var, 0, ""},
-		{"Tai_Viet", Var, 0, ""},
-		{"Takri", Var, 1, ""},
-		{"Tamil", Var, 0, ""},
-		{"Tangsa", Var, 21, ""},
-		{"Tangut", Var, 7, ""},
-		{"Telugu", Var, 0, ""},
-		{"Terminal_Punctuation", Var, 0, ""},
-		{"Thaana", Var, 0, ""},
-		{"Thai", Var, 0, ""},
-		{"Tibetan", Var, 0, ""},
-		{"Tifinagh", Var, 0, ""},
-		{"Tirhuta", Var, 4, ""},
-		{"Title", Var, 0, ""},
-		{"TitleCase", Const, 0, ""},
-		{"To", Func, 0, "func(_case int, r rune) rune"},
-		{"ToLower", Func, 0, "func(r rune) rune"},
-		{"ToTitle", Func, 0, "func(r rune) rune"},
-		{"ToUpper", Func, 0, "func(r rune) rune"},
-		{"Toto", Var, 21, ""},
-		{"TurkishCase", Var, 0, ""},
-		{"Ugaritic", Var, 0, ""},
-		{"Unified_Ideograph", Var, 0, ""},
-		{"Upper", Var, 0, ""},
-		{"UpperCase", Const, 0, ""},
-		{"UpperLower", Const, 0, ""},
-		{"Vai", Var, 0, ""},
-		{"Variation_Selector", Var, 0, ""},
-		{"Version", Const, 0, ""},
-		{"Vithkuqi", Var, 21, ""},
-		{"Wancho", Var, 14, ""},
-		{"Warang_Citi", Var, 4, ""},
-		{"White_Space", Var, 0, ""},
-		{"Yezidi", Var, 16, ""},
-		{"Yi", Var, 0, ""},
-		{"Z", Var, 0, ""},
-		{"Zanabazar_Square", Var, 10, ""},
-		{"Zl", Var, 0, ""},
-		{"Zp", Var, 0, ""},
-		{"Zs", Var, 0, ""},
-	},
-	"unicode/utf16": {
-		{"AppendRune", Func, 20, "func(a []uint16, r rune) []uint16"},
-		{"Decode", Func, 0, "func(s []uint16) []rune"},
-		{"DecodeRune", Func, 0, "func(r1 rune, r2 rune) rune"},
-		{"Encode", Func, 0, "func(s []rune) []uint16"},
-		{"EncodeRune", Func, 0, "func(r rune) (r1 rune, r2 rune)"},
-		{"IsSurrogate", Func, 0, "func(r rune) bool"},
-		{"RuneLen", Func, 23, "func(r rune) int"},
-	},
-	"unicode/utf8": {
-		{"AppendRune", Func, 18, "func(p []byte, r rune) []byte"},
-		{"DecodeLastRune", Func, 0, "func(p []byte) (r rune, size int)"},
-		{"DecodeLastRuneInString", Func, 0, "func(s string) (r rune, size int)"},
-		{"DecodeRune", Func, 0, "func(p []byte) (r rune, size int)"},
-		{"DecodeRuneInString", Func, 0, "func(s string) (r rune, size int)"},
-		{"EncodeRune", Func, 0, "func(p []byte, r rune) int"},
-		{"FullRune", Func, 0, "func(p []byte) bool"},
-		{"FullRuneInString", Func, 0, "func(s string) bool"},
-		{"MaxRune", Const, 0, ""},
-		{"RuneCount", Func, 0, "func(p []byte) int"},
-		{"RuneCountInString", Func, 0, "func(s string) (n int)"},
-		{"RuneError", Const, 0, ""},
-		{"RuneLen", Func, 0, "func(r rune) int"},
-		{"RuneSelf", Const, 0, ""},
-		{"RuneStart", Func, 0, "func(b byte) bool"},
-		{"UTFMax", Const, 0, ""},
-		{"Valid", Func, 0, "func(p []byte) bool"},
-		{"ValidRune", Func, 1, "func(r rune) bool"},
-		{"ValidString", Func, 0, "func(s string) bool"},
-	},
-	"unique": {
-		{"(Handle).Value", Method, 23, ""},
-		{"Handle", Type, 23, ""},
-		{"Make", Func, 23, "func[T comparable](value T) Handle[T]"},
-	},
-	"unsafe": {
-		{"Add", Func, 0, ""},
-		{"Alignof", Func, 0, ""},
-		{"Offsetof", Func, 0, ""},
-		{"Pointer", Type, 0, ""},
-		{"Sizeof", Func, 0, ""},
-		{"Slice", Func, 0, ""},
-		{"SliceData", Func, 0, ""},
-		{"String", Func, 0, ""},
-		{"StringData", Func, 0, ""},
-	},
-	"weak": {
-		{"(Pointer).Value", Method, 24, ""},
-		{"Make", Func, 24, "func[T any](ptr *T) Pointer[T]"},
-		{"Pointer", Type, 24, ""},
-	},
-}
diff --git a/vendor/golang.org/x/tools/internal/stdlib/stdlib.go b/vendor/golang.org/x/tools/internal/stdlib/stdlib.go
deleted file mode 100644
index 59a5de36a2..0000000000
--- a/vendor/golang.org/x/tools/internal/stdlib/stdlib.go
+++ /dev/null
@@ -1,105 +0,0 @@
-// Copyright 2022 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:generate go run generate.go
-
-// Package stdlib provides a table of all exported symbols in the
-// standard library, along with the version at which they first
-// appeared. It also provides the import graph of std packages.
-package stdlib
-
-import (
-	"fmt"
-	"strings"
-)
-
-type Symbol struct {
-	Name    string
-	Kind    Kind
-	Version Version // Go version that first included the symbol
-	// Signature provides the type of a function (defined only for Kind=Func).
-	// Imported types are denoted as pkg.T; pkg is not fully qualified.
-	// TODO(adonovan): use an unambiguous encoding that is parseable.
-	//
-	// Example2:
-	//    func[M ~map[K]V, K comparable, V any](m M) M
-	//    func(fi fs.FileInfo, link string) (*Header, error)
-	Signature string // if Kind == stdlib.Func
-}
-
-// A Kind indicates the kind of a symbol:
-// function, variable, constant, type, and so on.
-type Kind int8
-
-const (
-	Invalid Kind = iota // Example name:
-	Type                // "Buffer"
-	Func                // "Println"
-	Var                 // "EOF"
-	Const               // "Pi"
-	Field               // "Point.X"
-	Method              // "(*Buffer).Grow" or "(Reader).Read"
-)
-
-func (kind Kind) String() string {
-	return [...]string{
-		Invalid: "invalid",
-		Type:    "type",
-		Func:    "func",
-		Var:     "var",
-		Const:   "const",
-		Field:   "field",
-		Method:  "method",
-	}[kind]
-}
-
-// A Version represents a version of Go of the form "go1.%d".
-type Version int8
-
-// String returns a version string of the form "go1.23", without allocating.
-func (v Version) String() string { return versions[v] }
-
-var versions [30]string // (increase constant as needed)
-
-func init() {
-	for i := range versions {
-		versions[i] = fmt.Sprintf("go1.%d", i)
-	}
-}
-
-// HasPackage reports whether the specified package path is part of
-// the standard library's public API.
-func HasPackage(path string) bool {
-	_, ok := PackageSymbols[path]
-	return ok
-}
-
-// SplitField splits the field symbol name into type and field
-// components. It must be called only on Field symbols.
-//
-// Example: "File.Package" -> ("File", "Package")
-func (sym *Symbol) SplitField() (typename, name string) {
-	if sym.Kind != Field {
-		panic("not a field")
-	}
-	typename, name, _ = strings.Cut(sym.Name, ".")
-	return
-}
-
-// SplitMethod splits the method symbol name into pointer, receiver,
-// and method components. It must be called only on Method symbols.
-//
-// Example: "(*Buffer).Grow" -> (true, "Buffer", "Grow")
-func (sym *Symbol) SplitMethod() (ptr bool, recv, name string) {
-	if sym.Kind != Method {
-		panic("not a method")
-	}
-	recv, name, _ = strings.Cut(sym.Name, ".")
-	recv = recv[len("(") : len(recv)-len(")")]
-	ptr = recv[0] == '*'
-	if ptr {
-		recv = recv[len("*"):]
-	}
-	return
-}
diff --git a/vendor/golang.org/x/tools/internal/typeparams/common.go b/vendor/golang.org/x/tools/internal/typeparams/common.go
deleted file mode 100644
index cdae2b8e81..0000000000
--- a/vendor/golang.org/x/tools/internal/typeparams/common.go
+++ /dev/null
@@ -1,68 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package typeparams contains common utilities for writing tools that
-// interact with generic Go code, as introduced with Go 1.18. It
-// supplements the standard library APIs. Notably, the StructuralTerms
-// API computes a minimal representation of the structural
-// restrictions on a type parameter.
-//
-// An external version of these APIs is available in the
-// golang.org/x/exp/typeparams module.
-package typeparams
-
-import (
-	"go/ast"
-	"go/token"
-	"go/types"
-)
-
-// UnpackIndexExpr extracts data from AST nodes that represent index
-// expressions.
-//
-// For an ast.IndexExpr, the resulting indices slice will contain exactly one
-// index expression. For an ast.IndexListExpr (go1.18+), it may have a variable
-// number of index expressions.
-//
-// For nodes that don't represent index expressions, the first return value of
-// UnpackIndexExpr will be nil.
-func UnpackIndexExpr(n ast.Node) (x ast.Expr, lbrack token.Pos, indices []ast.Expr, rbrack token.Pos) {
-	switch e := n.(type) {
-	case *ast.IndexExpr:
-		return e.X, e.Lbrack, []ast.Expr{e.Index}, e.Rbrack
-	case *ast.IndexListExpr:
-		return e.X, e.Lbrack, e.Indices, e.Rbrack
-	}
-	return nil, token.NoPos, nil, token.NoPos
-}
-
-// PackIndexExpr returns an *ast.IndexExpr or *ast.IndexListExpr, depending on
-// the cardinality of indices. Calling PackIndexExpr with len(indices) == 0
-// will panic.
-func PackIndexExpr(x ast.Expr, lbrack token.Pos, indices []ast.Expr, rbrack token.Pos) ast.Expr {
-	switch len(indices) {
-	case 0:
-		panic("empty indices")
-	case 1:
-		return &ast.IndexExpr{
-			X:      x,
-			Lbrack: lbrack,
-			Index:  indices[0],
-			Rbrack: rbrack,
-		}
-	default:
-		return &ast.IndexListExpr{
-			X:       x,
-			Lbrack:  lbrack,
-			Indices: indices,
-			Rbrack:  rbrack,
-		}
-	}
-}
-
-// IsTypeParam reports whether t is a type parameter (or an alias of one).
-func IsTypeParam(t types.Type) bool {
-	_, ok := types.Unalias(t).(*types.TypeParam)
-	return ok
-}
diff --git a/vendor/golang.org/x/tools/internal/typeparams/coretype.go b/vendor/golang.org/x/tools/internal/typeparams/coretype.go
deleted file mode 100644
index 2e05de4649..0000000000
--- a/vendor/golang.org/x/tools/internal/typeparams/coretype.go
+++ /dev/null
@@ -1,157 +0,0 @@
-// Copyright 2022 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package typeparams
-
-import (
-	"fmt"
-	"go/types"
-)
-
-// CoreType returns the core type of T or nil if T does not have a core type.
-//
-// As of Go1.25, the notion of a core type has been removed from the language spec.
-// See https://go.dev/blog/coretypes for more details.
-// TODO(mkalil): We should eventually consider removing all uses of CoreType.
-func CoreType(T types.Type) types.Type {
-	U := T.Underlying()
-	if _, ok := U.(*types.Interface); !ok {
-		return U // for non-interface types,
-	}
-
-	terms, err := NormalTerms(U)
-	if len(terms) == 0 || err != nil {
-		// len(terms) -> empty type set of interface.
-		// err != nil => U is invalid, exceeds complexity bounds, or has an empty type set.
-		return nil // no core type.
-	}
-
-	U = terms[0].Type().Underlying()
-	var identical int // i in [0,identical) => Identical(U, terms[i].Type().Underlying())
-	for identical = 1; identical < len(terms); identical++ {
-		if !types.Identical(U, terms[identical].Type().Underlying()) {
-			break
-		}
-	}
-
-	if identical == len(terms) {
-		// From the deprecated core types spec:
-		// "There is a single type U which is the underlying type of all types in the type set of T"
-		return U
-	}
-	ch, ok := U.(*types.Chan)
-	if !ok {
-		return nil // no core type as identical < len(terms) and U is not a channel.
-	}
-	// From the deprecated core types spec:
-	// "the type chan E if T contains only bidirectional channels, or the type chan<- E or
-	// <-chan E depending on the direction of the directional channels present."
-	for chans := identical; chans < len(terms); chans++ {
-		curr, ok := terms[chans].Type().Underlying().(*types.Chan)
-		if !ok {
-			return nil
-		}
-		if !types.Identical(ch.Elem(), curr.Elem()) {
-			return nil // channel elements are not identical.
-		}
-		if ch.Dir() == types.SendRecv {
-			// ch is bidirectional. We can safely always use curr's direction.
-			ch = curr
-		} else if curr.Dir() != types.SendRecv && ch.Dir() != curr.Dir() {
-			// ch and curr are not bidirectional and not the same direction.
-			return nil
-		}
-	}
-	return ch
-}
-
-// NormalTerms returns a slice of terms representing the normalized structural
-// type restrictions of a type, if any.
-//
-// For all types other than *types.TypeParam, *types.Interface, and
-// *types.Union, this is just a single term with Tilde() == false and
-// Type() == typ. For *types.TypeParam, *types.Interface, and *types.Union, see
-// below.
-//
-// Structural type restrictions of a type parameter are created via
-// non-interface types embedded in its constraint interface (directly, or via a
-// chain of interface embeddings). For example, in the declaration type
-// T[P interface{~int; m()}] int the structural restriction of the type
-// parameter P is ~int.
-//
-// With interface embedding and unions, the specification of structural type
-// restrictions may be arbitrarily complex. For example, consider the
-// following:
-//
-//	type A interface{ ~string|~[]byte }
-//
-//	type B interface{ int|string }
-//
-//	type C interface { ~string|~int }
-//
-//	type T[P interface{ A|B; C }] int
-//
-// In this example, the structural type restriction of P is ~string|int: A|B
-// expands to ~string|~[]byte|int|string, which reduces to ~string|~[]byte|int,
-// which when intersected with C (~string|~int) yields ~string|int.
-//
-// NormalTerms computes these expansions and reductions, producing a
-// "normalized" form of the embeddings. A structural restriction is normalized
-// if it is a single union containing no interface terms, and is minimal in the
-// sense that removing any term changes the set of types satisfying the
-// constraint. It is left as a proof for the reader that, modulo sorting, there
-// is exactly one such normalized form.
-//
-// Because the minimal representation always takes this form, NormalTerms
-// returns a slice of tilde terms corresponding to the terms of the union in
-// the normalized structural restriction. An error is returned if the type is
-// invalid, exceeds complexity bounds, or has an empty type set. In the latter
-// case, NormalTerms returns ErrEmptyTypeSet.
-//
-// NormalTerms makes no guarantees about the order of terms, except that it
-// is deterministic.
-func NormalTerms(T types.Type) ([]*types.Term, error) {
-	// typeSetOf(T) == typeSetOf(Unalias(T))
-	typ := types.Unalias(T)
-	if named, ok := typ.(*types.Named); ok {
-		typ = named.Underlying()
-	}
-	switch typ := typ.(type) {
-	case *types.TypeParam:
-		return StructuralTerms(typ)
-	case *types.Union:
-		return UnionTermSet(typ)
-	case *types.Interface:
-		return InterfaceTermSet(typ)
-	default:
-		return []*types.Term{types.NewTerm(false, T)}, nil
-	}
-}
-
-// Deref returns the type of the variable pointed to by t,
-// if t's core type is a pointer; otherwise it returns t.
-//
-// Do not assume that Deref(T)==T implies T is not a pointer:
-// consider "type T *T", for example.
-//
-// TODO(adonovan): ideally this would live in typesinternal, but that
-// creates an import cycle. Move there when we melt this package down.
-func Deref(t types.Type) types.Type {
-	if ptr, ok := CoreType(t).(*types.Pointer); ok {
-		return ptr.Elem()
-	}
-	return t
-}
-
-// MustDeref returns the type of the variable pointed to by t.
-// It panics if t's core type is not a pointer.
-//
-// TODO(adonovan): ideally this would live in typesinternal, but that
-// creates an import cycle. Move there when we melt this package down.
-func MustDeref(t types.Type) types.Type {
-	if ptr, ok := CoreType(t).(*types.Pointer); ok {
-		return ptr.Elem()
-	}
-	panic(fmt.Sprintf("%v is not a pointer", t))
-}
diff --git a/vendor/golang.org/x/tools/internal/typeparams/free.go b/vendor/golang.org/x/tools/internal/typeparams/free.go
deleted file mode 100644
index 4c391876e4..0000000000
--- a/vendor/golang.org/x/tools/internal/typeparams/free.go
+++ /dev/null
@@ -1,129 +0,0 @@
-// Copyright 2024 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package typeparams
-
-import (
-	"go/types"
-)
-
-// Free is a memoization of the set of free type parameters within a
-// type. It makes a sequence of calls to [Free.Has] for overlapping
-// types more efficient. The zero value is ready for use.
-//
-// NOTE: Adapted from go/types/infer.go. If it is later exported, factor.
-type Free struct {
-	seen map[types.Type]bool
-}
-
-// Has reports whether the specified type has a free type parameter.
-func (w *Free) Has(typ types.Type) (res bool) {
-	// detect cycles
-	if x, ok := w.seen[typ]; ok {
-		return x
-	}
-	if w.seen == nil {
-		w.seen = make(map[types.Type]bool)
-	}
-	w.seen[typ] = false
-	defer func() {
-		w.seen[typ] = res
-	}()
-
-	switch t := typ.(type) {
-	case nil, *types.Basic: // TODO(gri) should nil be handled here?
-		break
-
-	case *types.Alias:
-		if t.TypeParams().Len() > t.TypeArgs().Len() {
-			return true // This is an uninstantiated Alias.
-		}
-		// The expansion of an alias can have free type parameters,
-		// whether or not the alias itself has type parameters:
-		//
-		//   func _[K comparable]() {
-		//     type Set      = map[K]bool // free(Set)      = {K}
-		//     type MapTo[V] = map[K]V    // free(Map[foo]) = {V}
-		//   }
-		//
-		// So, we must Unalias.
-		return w.Has(types.Unalias(t))
-
-	case *types.Array:
-		return w.Has(t.Elem())
-
-	case *types.Slice:
-		return w.Has(t.Elem())
-
-	case *types.Struct:
-		for i, n := 0, t.NumFields(); i < n; i++ {
-			if w.Has(t.Field(i).Type()) {
-				return true
-			}
-		}
-
-	case *types.Pointer:
-		return w.Has(t.Elem())
-
-	case *types.Tuple:
-		n := t.Len()
-		for i := range n {
-			if w.Has(t.At(i).Type()) {
-				return true
-			}
-		}
-
-	case *types.Signature:
-		// t.tparams may not be nil if we are looking at a signature
-		// of a generic function type (or an interface method) that is
-		// part of the type we're testing. We don't care about these type
-		// parameters.
-		// Similarly, the receiver of a method may declare (rather than
-		// use) type parameters, we don't care about those either.
-		// Thus, we only need to look at the input and result parameters.
-		return w.Has(t.Params()) || w.Has(t.Results())
-
-	case *types.Interface:
-		for i, n := 0, t.NumMethods(); i < n; i++ {
-			if w.Has(t.Method(i).Type()) {
-				return true
-			}
-		}
-		terms, err := InterfaceTermSet(t)
-		if err != nil {
-			return false // ill typed
-		}
-		for _, term := range terms {
-			if w.Has(term.Type()) {
-				return true
-			}
-		}
-
-	case *types.Map:
-		return w.Has(t.Key()) || w.Has(t.Elem())
-
-	case *types.Chan:
-		return w.Has(t.Elem())
-
-	case *types.Named:
-		args := t.TypeArgs()
-		if params := t.TypeParams(); params.Len() > args.Len() {
-			return true // this is an uninstantiated named type.
-		}
-		for i, n := 0, args.Len(); i < n; i++ {
-			if w.Has(args.At(i)) {
-				return true
-			}
-		}
-		return w.Has(t.Underlying()) // recurse for types local to parameterized functions
-
-	case *types.TypeParam:
-		return true
-
-	default:
-		panic(t) // unreachable
-	}
-
-	return false
-}
diff --git a/vendor/golang.org/x/tools/internal/typeparams/normalize.go b/vendor/golang.org/x/tools/internal/typeparams/normalize.go
deleted file mode 100644
index 8d13f12147..0000000000
--- a/vendor/golang.org/x/tools/internal/typeparams/normalize.go
+++ /dev/null
@@ -1,216 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package typeparams
-
-import (
-	"errors"
-	"fmt"
-	"go/types"
-	"os"
-	"strings"
-)
-
-//go:generate go run copytermlist.go
-
-const debug = false
-
-var ErrEmptyTypeSet = errors.New("empty type set")
-
-// StructuralTerms returns a slice of terms representing the normalized
-// structural type restrictions of a type parameter, if any.
-//
-// Structural type restrictions of a type parameter are created via
-// non-interface types embedded in its constraint interface (directly, or via a
-// chain of interface embeddings). For example, in the declaration
-//
-//	type T[P interface{~int; m()}] int
-//
-// the structural restriction of the type parameter P is ~int.
-//
-// With interface embedding and unions, the specification of structural type
-// restrictions may be arbitrarily complex. For example, consider the
-// following:
-//
-//	type A interface{ ~string|~[]byte }
-//
-//	type B interface{ int|string }
-//
-//	type C interface { ~string|~int }
-//
-//	type T[P interface{ A|B; C }] int
-//
-// In this example, the structural type restriction of P is ~string|int: A|B
-// expands to ~string|~[]byte|int|string, which reduces to ~string|~[]byte|int,
-// which when intersected with C (~string|~int) yields ~string|int.
-//
-// StructuralTerms computes these expansions and reductions, producing a
-// "normalized" form of the embeddings. A structural restriction is normalized
-// if it is a single union containing no interface terms, and is minimal in the
-// sense that removing any term changes the set of types satisfying the
-// constraint. It is left as a proof for the reader that, modulo sorting, there
-// is exactly one such normalized form.
-//
-// Because the minimal representation always takes this form, StructuralTerms
-// returns a slice of tilde terms corresponding to the terms of the union in
-// the normalized structural restriction. An error is returned if the
-// constraint interface is invalid, exceeds complexity bounds, or has an empty
-// type set. In the latter case, StructuralTerms returns ErrEmptyTypeSet.
-//
-// StructuralTerms makes no guarantees about the order of terms, except that it
-// is deterministic.
-func StructuralTerms(tparam *types.TypeParam) ([]*types.Term, error) {
-	constraint := tparam.Constraint()
-	if constraint == nil {
-		return nil, fmt.Errorf("%s has nil constraint", tparam)
-	}
-	iface, _ := constraint.Underlying().(*types.Interface)
-	if iface == nil {
-		return nil, fmt.Errorf("constraint is %T, not *types.Interface", constraint.Underlying())
-	}
-	return InterfaceTermSet(iface)
-}
-
-// InterfaceTermSet computes the normalized terms for a constraint interface,
-// returning an error if the term set cannot be computed or is empty. In the
-// latter case, the error will be ErrEmptyTypeSet.
-//
-// See the documentation of StructuralTerms for more information on
-// normalization.
-func InterfaceTermSet(iface *types.Interface) ([]*types.Term, error) {
-	return computeTermSet(iface)
-}
-
-// UnionTermSet computes the normalized terms for a union, returning an error
-// if the term set cannot be computed or is empty. In the latter case, the
-// error will be ErrEmptyTypeSet.
-//
-// See the documentation of StructuralTerms for more information on
-// normalization.
-func UnionTermSet(union *types.Union) ([]*types.Term, error) {
-	return computeTermSet(union)
-}
-
-func computeTermSet(typ types.Type) ([]*types.Term, error) {
-	tset, err := computeTermSetInternal(typ, make(map[types.Type]*termSet), 0)
-	if err != nil {
-		return nil, err
-	}
-	if tset.terms.isEmpty() {
-		return nil, ErrEmptyTypeSet
-	}
-	if tset.terms.isAll() {
-		return nil, nil
-	}
-	var terms []*types.Term
-	for _, term := range tset.terms {
-		terms = append(terms, types.NewTerm(term.tilde, term.typ))
-	}
-	return terms, nil
-}
-
-// A termSet holds the normalized set of terms for a given type.
-//
-// The name termSet is intentionally distinct from 'type set': a type set is
-// all types that implement a type (and includes method restrictions), whereas
-// a term set just represents the structural restrictions on a type.
-type termSet struct {
-	complete bool
-	terms    termlist
-}
-
-func indentf(depth int, format string, args ...any) {
-	fmt.Fprintf(os.Stderr, strings.Repeat(".", depth)+format+"\n", args...)
-}
-
-func computeTermSetInternal(t types.Type, seen map[types.Type]*termSet, depth int) (res *termSet, err error) {
-	if t == nil {
-		panic("nil type")
-	}
-
-	if debug {
-		indentf(depth, "%s", t.String())
-		defer func() {
-			if err != nil {
-				indentf(depth, "=> %s", err)
-			} else {
-				indentf(depth, "=> %s", res.terms.String())
-			}
-		}()
-	}
-
-	const maxTermCount = 100
-	if tset, ok := seen[t]; ok {
-		if !tset.complete {
-			return nil, fmt.Errorf("cycle detected in the declaration of %s", t)
-		}
-		return tset, nil
-	}
-
-	// Mark the current type as seen to avoid infinite recursion.
-	tset := new(termSet)
-	defer func() {
-		tset.complete = true
-	}()
-	seen[t] = tset
-
-	switch u := t.Underlying().(type) {
-	case *types.Interface:
-		// The term set of an interface is the intersection of the term sets of its
-		// embedded types.
-		tset.terms = allTermlist
-		for embedded := range u.EmbeddedTypes() {
-			if _, ok := embedded.Underlying().(*types.TypeParam); ok {
-				return nil, fmt.Errorf("invalid embedded type %T", embedded)
-			}
-			tset2, err := computeTermSetInternal(embedded, seen, depth+1)
-			if err != nil {
-				return nil, err
-			}
-			tset.terms = tset.terms.intersect(tset2.terms)
-		}
-	case *types.Union:
-		// The term set of a union is the union of term sets of its terms.
-		tset.terms = nil
-		for t := range u.Terms() {
-			var terms termlist
-			switch t.Type().Underlying().(type) {
-			case *types.Interface:
-				tset2, err := computeTermSetInternal(t.Type(), seen, depth+1)
-				if err != nil {
-					return nil, err
-				}
-				terms = tset2.terms
-			case *types.TypeParam, *types.Union:
-				// A stand-alone type parameter or union is not permitted as union
-				// term.
-				return nil, fmt.Errorf("invalid union term %T", t)
-			default:
-				if t.Type() == types.Typ[types.Invalid] {
-					continue
-				}
-				terms = termlist{{t.Tilde(), t.Type()}}
-			}
-			tset.terms = tset.terms.union(terms)
-			if len(tset.terms) > maxTermCount {
-				return nil, fmt.Errorf("exceeded max term count %d", maxTermCount)
-			}
-		}
-	case *types.TypeParam:
-		panic("unreachable")
-	default:
-		// For all other types, the term set is just a single non-tilde term
-		// holding the type itself.
-		if u != types.Typ[types.Invalid] {
-			tset.terms = termlist{{false, t}}
-		}
-	}
-	return tset, nil
-}
-
-// under is a facade for the go/types internal function of the same name. It is
-// used by typeterm.go.
-func under(t types.Type) types.Type {
-	return t.Underlying()
-}
diff --git a/vendor/golang.org/x/tools/internal/typeparams/termlist.go b/vendor/golang.org/x/tools/internal/typeparams/termlist.go
deleted file mode 100644
index 9bc29143f6..0000000000
--- a/vendor/golang.org/x/tools/internal/typeparams/termlist.go
+++ /dev/null
@@ -1,169 +0,0 @@
-// Code generated by "go test -run=Generate -write=all"; DO NOT EDIT.
-// Source: ../../cmd/compile/internal/types2/termlist.go
-
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by copytermlist.go DO NOT EDIT.
-
-package typeparams
-
-import (
-	"go/types"
-	"strings"
-)
-
-// A termlist represents the type set represented by the union
-// t1 ∪ y2 ∪ ... tn of the type sets of the terms t1 to tn.
-// A termlist is in normal form if all terms are disjoint.
-// termlist operations don't require the operands to be in
-// normal form.
-type termlist []*term
-
-// allTermlist represents the set of all types.
-// It is in normal form.
-var allTermlist = termlist{new(term)}
-
-// termSep is the separator used between individual terms.
-const termSep = " | "
-
-// String prints the termlist exactly (without normalization).
-func (xl termlist) String() string {
-	if len(xl) == 0 {
-		return "∅"
-	}
-	var buf strings.Builder
-	for i, x := range xl {
-		if i > 0 {
-			buf.WriteString(termSep)
-		}
-		buf.WriteString(x.String())
-	}
-	return buf.String()
-}
-
-// isEmpty reports whether the termlist xl represents the empty set of types.
-func (xl termlist) isEmpty() bool {
-	// If there's a non-nil term, the entire list is not empty.
-	// If the termlist is in normal form, this requires at most
-	// one iteration.
-	for _, x := range xl {
-		if x != nil {
-			return false
-		}
-	}
-	return true
-}
-
-// isAll reports whether the termlist xl represents the set of all types.
-func (xl termlist) isAll() bool {
-	// If there's a 𝓤 term, the entire list is 𝓤.
-	// If the termlist is in normal form, this requires at most
-	// one iteration.
-	for _, x := range xl {
-		if x != nil && x.typ == nil {
-			return true
-		}
-	}
-	return false
-}
-
-// norm returns the normal form of xl.
-func (xl termlist) norm() termlist {
-	// Quadratic algorithm, but good enough for now.
-	// TODO(gri) fix asymptotic performance
-	used := make([]bool, len(xl))
-	var rl termlist
-	for i, xi := range xl {
-		if xi == nil || used[i] {
-			continue
-		}
-		for j := i + 1; j < len(xl); j++ {
-			xj := xl[j]
-			if xj == nil || used[j] {
-				continue
-			}
-			if u1, u2 := xi.union(xj); u2 == nil {
-				// If we encounter a 𝓤 term, the entire list is 𝓤.
-				// Exit early.
-				// (Note that this is not just an optimization;
-				// if we continue, we may end up with a 𝓤 term
-				// and other terms and the result would not be
-				// in normal form.)
-				if u1.typ == nil {
-					return allTermlist
-				}
-				xi = u1
-				used[j] = true // xj is now unioned into xi - ignore it in future iterations
-			}
-		}
-		rl = append(rl, xi)
-	}
-	return rl
-}
-
-// union returns the union xl ∪ yl.
-func (xl termlist) union(yl termlist) termlist {
-	return append(xl, yl...).norm()
-}
-
-// intersect returns the intersection xl ∩ yl.
-func (xl termlist) intersect(yl termlist) termlist {
-	if xl.isEmpty() || yl.isEmpty() {
-		return nil
-	}
-
-	// Quadratic algorithm, but good enough for now.
-	// TODO(gri) fix asymptotic performance
-	var rl termlist
-	for _, x := range xl {
-		for _, y := range yl {
-			if r := x.intersect(y); r != nil {
-				rl = append(rl, r)
-			}
-		}
-	}
-	return rl.norm()
-}
-
-// equal reports whether xl and yl represent the same type set.
-func (xl termlist) equal(yl termlist) bool {
-	// TODO(gri) this should be more efficient
-	return xl.subsetOf(yl) && yl.subsetOf(xl)
-}
-
-// includes reports whether t ∈ xl.
-func (xl termlist) includes(t types.Type) bool {
-	for _, x := range xl {
-		if x.includes(t) {
-			return true
-		}
-	}
-	return false
-}
-
-// supersetOf reports whether y ⊆ xl.
-func (xl termlist) supersetOf(y *term) bool {
-	for _, x := range xl {
-		if y.subsetOf(x) {
-			return true
-		}
-	}
-	return false
-}
-
-// subsetOf reports whether xl ⊆ yl.
-func (xl termlist) subsetOf(yl termlist) bool {
-	if yl.isEmpty() {
-		return xl.isEmpty()
-	}
-
-	// each term x of xl must be a subset of yl
-	for _, x := range xl {
-		if !yl.supersetOf(x) {
-			return false // x is not a subset yl
-		}
-	}
-	return true
-}
diff --git a/vendor/golang.org/x/tools/internal/typeparams/typeterm.go b/vendor/golang.org/x/tools/internal/typeparams/typeterm.go
deleted file mode 100644
index fa758cdc98..0000000000
--- a/vendor/golang.org/x/tools/internal/typeparams/typeterm.go
+++ /dev/null
@@ -1,172 +0,0 @@
-// Code generated by "go test -run=Generate -write=all"; DO NOT EDIT.
-// Source: ../../cmd/compile/internal/types2/typeterm.go
-
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Code generated by copytermlist.go DO NOT EDIT.
-
-package typeparams
-
-import "go/types"
-
-// A term describes elementary type sets:
-//
-//	 ∅:  (*term)(nil)     == ∅                      // set of no types (empty set)
-//	 𝓤:  &term{}          == 𝓤                      // set of all types (𝓤niverse)
-//	 T:  &term{false, T}  == {T}                    // set of type T
-//	~t:  &term{true, t}   == {t' | under(t') == t}  // set of types with underlying type t
-type term struct {
-	tilde bool // valid if typ != nil
-	typ   types.Type
-}
-
-func (x *term) String() string {
-	switch {
-	case x == nil:
-		return "∅"
-	case x.typ == nil:
-		return "𝓤"
-	case x.tilde:
-		return "~" + x.typ.String()
-	default:
-		return x.typ.String()
-	}
-}
-
-// equal reports whether x and y represent the same type set.
-func (x *term) equal(y *term) bool {
-	// easy cases
-	switch {
-	case x == nil || y == nil:
-		return x == y
-	case x.typ == nil || y.typ == nil:
-		return x.typ == y.typ
-	}
-	// ∅ ⊂ x, y ⊂ 𝓤
-
-	return x.tilde == y.tilde && types.Identical(x.typ, y.typ)
-}
-
-// union returns the union x ∪ y: zero, one, or two non-nil terms.
-func (x *term) union(y *term) (_, _ *term) {
-	// easy cases
-	switch {
-	case x == nil && y == nil:
-		return nil, nil // ∅ ∪ ∅ == ∅
-	case x == nil:
-		return y, nil // ∅ ∪ y == y
-	case y == nil:
-		return x, nil // x ∪ ∅ == x
-	case x.typ == nil:
-		return x, nil // 𝓤 ∪ y == 𝓤
-	case y.typ == nil:
-		return y, nil // x ∪ 𝓤 == 𝓤
-	}
-	// ∅ ⊂ x, y ⊂ 𝓤
-
-	if x.disjoint(y) {
-		return x, y // x ∪ y == (x, y) if x ∩ y == ∅
-	}
-	// x.typ == y.typ
-
-	// ~t ∪ ~t == ~t
-	// ~t ∪  T == ~t
-	//  T ∪ ~t == ~t
-	//  T ∪  T ==  T
-	if x.tilde || !y.tilde {
-		return x, nil
-	}
-	return y, nil
-}
-
-// intersect returns the intersection x ∩ y.
-func (x *term) intersect(y *term) *term {
-	// easy cases
-	switch {
-	case x == nil || y == nil:
-		return nil // ∅ ∩ y == ∅ and ∩ ∅ == ∅
-	case x.typ == nil:
-		return y // 𝓤 ∩ y == y
-	case y.typ == nil:
-		return x // x ∩ 𝓤 == x
-	}
-	// ∅ ⊂ x, y ⊂ 𝓤
-
-	if x.disjoint(y) {
-		return nil // x ∩ y == ∅ if x ∩ y == ∅
-	}
-	// x.typ == y.typ
-
-	// ~t ∩ ~t == ~t
-	// ~t ∩  T ==  T
-	//  T ∩ ~t ==  T
-	//  T ∩  T ==  T
-	if !x.tilde || y.tilde {
-		return x
-	}
-	return y
-}
-
-// includes reports whether t ∈ x.
-func (x *term) includes(t types.Type) bool {
-	// easy cases
-	switch {
-	case x == nil:
-		return false // t ∈ ∅ == false
-	case x.typ == nil:
-		return true // t ∈ 𝓤 == true
-	}
-	// ∅ ⊂ x ⊂ 𝓤
-
-	u := t
-	if x.tilde {
-		u = under(u)
-	}
-	return types.Identical(x.typ, u)
-}
-
-// subsetOf reports whether x ⊆ y.
-func (x *term) subsetOf(y *term) bool {
-	// easy cases
-	switch {
-	case x == nil:
-		return true // ∅ ⊆ y == true
-	case y == nil:
-		return false // x ⊆ ∅ == false since x != ∅
-	case y.typ == nil:
-		return true // x ⊆ 𝓤 == true
-	case x.typ == nil:
-		return false // 𝓤 ⊆ y == false since y != 𝓤
-	}
-	// ∅ ⊂ x, y ⊂ 𝓤
-
-	if x.disjoint(y) {
-		return false // x ⊆ y == false if x ∩ y == ∅
-	}
-	// x.typ == y.typ
-
-	// ~t ⊆ ~t == true
-	// ~t ⊆ T == false
-	//  T ⊆ ~t == true
-	//  T ⊆  T == true
-	return !x.tilde || y.tilde
-}
-
-// disjoint reports whether x ∩ y == ∅.
-// x.typ and y.typ must not be nil.
-func (x *term) disjoint(y *term) bool {
-	if debug && (x.typ == nil || y.typ == nil) {
-		panic("invalid argument(s)")
-	}
-	ux := x.typ
-	if y.tilde {
-		ux = under(ux)
-	}
-	uy := y.typ
-	if x.tilde {
-		uy = under(uy)
-	}
-	return !types.Identical(ux, uy)
-}
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/classify_call.go b/vendor/golang.org/x/tools/internal/typesinternal/classify_call.go
deleted file mode 100644
index 7ebe9768bc..0000000000
--- a/vendor/golang.org/x/tools/internal/typesinternal/classify_call.go
+++ /dev/null
@@ -1,137 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package typesinternal
-
-import (
-	"fmt"
-	"go/ast"
-	"go/types"
-	_ "unsafe" // for go:linkname hack
-)
-
-// CallKind describes the function position of an [*ast.CallExpr].
-type CallKind int
-
-const (
-	CallStatic     CallKind = iota // static call to known function
-	CallInterface                  // dynamic call through an interface method
-	CallDynamic                    // dynamic call of a func value
-	CallBuiltin                    // call to a builtin function
-	CallConversion                 // a conversion (not a call)
-)
-
-var callKindNames = []string{
-	"CallStatic",
-	"CallInterface",
-	"CallDynamic",
-	"CallBuiltin",
-	"CallConversion",
-}
-
-func (k CallKind) String() string {
-	if i := int(k); i >= 0 && i < len(callKindNames) {
-		return callKindNames[i]
-	}
-	return fmt.Sprintf("typeutil.CallKind(%d)", k)
-}
-
-// ClassifyCall classifies the function position of a call expression ([*ast.CallExpr]).
-// It distinguishes among true function calls, calls to builtins, and type conversions,
-// and further classifies function calls as static calls (where the function is known),
-// dynamic interface calls, and other dynamic calls.
-//
-// For the declarations:
-//
-//	func f() {}
-//	func g[T any]() {}
-//	var v func()
-//	var s []func()
-//	type I interface { M() }
-//	var i I
-//
-// ClassifyCall returns the following:
-//
-//	f()           CallStatic
-//	g[int]()      CallStatic
-//	i.M()         CallInterface
-//	min(1, 2)     CallBuiltin
-//	v()           CallDynamic
-//	s[0]()        CallDynamic
-//	int(x)        CallConversion
-//	[]byte("")    CallConversion
-func ClassifyCall(info *types.Info, call *ast.CallExpr) CallKind {
-	if info.Types == nil {
-		panic("ClassifyCall: info.Types is nil")
-	}
-	tv := info.Types[call.Fun]
-	if tv.IsType() {
-		return CallConversion
-	}
-	if tv.IsBuiltin() {
-		return CallBuiltin
-	}
-	obj := info.Uses[UsedIdent(info, call.Fun)]
-	// Classify the call by the type of the object, if any.
-	switch obj := obj.(type) {
-	case *types.Func:
-		if interfaceMethod(obj) {
-			return CallInterface
-		}
-		return CallStatic
-	default:
-		return CallDynamic
-	}
-}
-
-// UsedIdent returns the identifier such that info.Uses[UsedIdent(info, e)]
-// is the [types.Object] used by e, if any.
-//
-// If e is one of various forms of reference:
-//
-//	f, c, v, T           lexical reference
-//	pkg.X                qualified identifier
-//	f[T] or pkg.F[K,V]   instantiations of the above kinds
-//	expr.f               field or method value selector
-//	T.f                  method expression selector
-//
-// UsedIdent returns the identifier whose is associated value in [types.Info.Uses]
-// is the object to which it refers.
-//
-// For the declarations:
-//
-//	func F[T any] {...}
-//	type I interface { M() }
-//	var (
-//	  x int
-//	  s struct { f  int }
-//	  a []int
-//	  i I
-//	)
-//
-// UsedIdent returns the following:
-//
-//	Expr          UsedIdent
-//	x             x
-//	s.f           f
-//	F[int]        F
-//	i.M           M
-//	I.M           M
-//	min           min
-//	int           int
-//	1             nil
-//	a[0]          nil
-//	[]byte        nil
-//
-// Note: if e is an instantiated function or method, UsedIdent returns
-// the corresponding generic function or method on the generic type.
-func UsedIdent(info *types.Info, e ast.Expr) *ast.Ident {
-	return usedIdent(info, e)
-}
-
-//go:linkname usedIdent golang.org/x/tools/go/types/typeutil.usedIdent
-func usedIdent(info *types.Info, e ast.Expr) *ast.Ident
-
-//go:linkname interfaceMethod golang.org/x/tools/go/types/typeutil.interfaceMethod
-func interfaceMethod(f *types.Func) bool
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/element.go b/vendor/golang.org/x/tools/internal/typesinternal/element.go
deleted file mode 100644
index 89eeea1653..0000000000
--- a/vendor/golang.org/x/tools/internal/typesinternal/element.go
+++ /dev/null
@@ -1,137 +0,0 @@
-// Copyright 2024 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package typesinternal
-
-import (
-	"fmt"
-	"go/types"
-
-	"golang.org/x/tools/go/types/typeutil"
-)
-
-// ForEachElement calls f for type T and each type reachable from its
-// type through reflection. It does this by recursively stripping off
-// type constructors; in addition, for each named type N, the type *N
-// is added to the result as it may have additional methods.
-//
-// The caller must provide an initially empty set used to de-duplicate
-// identical types, potentially across multiple calls to ForEachElement.
-// (Its final value holds all the elements seen, matching the arguments
-// passed to f.)
-//
-// TODO(adonovan): share/harmonize with go/callgraph/rta.
-func ForEachElement(rtypes *typeutil.Map, msets *typeutil.MethodSetCache, T types.Type, f func(types.Type)) {
-	var visit func(T types.Type, skip bool)
-	visit = func(T types.Type, skip bool) {
-		if !skip {
-			if seen, _ := rtypes.Set(T, true).(bool); seen {
-				return // de-dup
-			}
-
-			f(T) // notify caller of new element type
-		}
-
-		// Recursion over signatures of each method.
-		tmset := msets.MethodSet(T)
-		for method := range tmset.Methods() {
-			sig := method.Type().(*types.Signature)
-			if sig.TypeParams() != nil {
-				continue // skip type-parameterized methods
-			}
-
-			// It is tempting to call visit(sig, false)
-			// but, as noted in golang.org/cl/65450043,
-			// the Signature.Recv field is ignored by
-			// types.Identical and typeutil.Map, which
-			// is confusing at best.
-			//
-			// More importantly, the true signature rtype
-			// reachable from a method using reflection
-			// has no receiver but an extra ordinary parameter.
-			// For the Read method of io.Reader we want:
-			//   func(Reader, []byte) (int, error)
-			// but here sig is:
-			//   func([]byte) (int, error)
-			// with .Recv = Reader (though it is hard to
-			// notice because it doesn't affect Signature.String
-			// or types.Identical).
-			//
-			// TODO(adonovan): construct and visit the correct
-			// non-method signature with an extra parameter
-			// (though since unnamed func types have no methods
-			// there is essentially no actual demand for this).
-			//
-			// TODO(adonovan): document whether or not it is
-			// safe to skip non-exported methods (as RTA does).
-			visit(sig.Params(), true)  // skip the Tuple
-			visit(sig.Results(), true) // skip the Tuple
-		}
-
-		switch T := T.(type) {
-		case *types.Alias:
-			visit(types.Unalias(T), skip) // emulates the pre-Alias behavior
-
-		case *types.Basic:
-			// nop
-
-		case *types.Interface:
-			// nop---handled by recursion over method set.
-
-		case *types.Pointer:
-			visit(T.Elem(), false)
-
-		case *types.Slice:
-			visit(T.Elem(), false)
-
-		case *types.Chan:
-			visit(T.Elem(), false)
-
-		case *types.Map:
-			visit(T.Key(), false)
-			visit(T.Elem(), false)
-
-		case *types.Signature:
-			if T.Recv() != nil {
-				panic(fmt.Sprintf("Signature %s has Recv %s", T, T.Recv()))
-			}
-			visit(T.Params(), true)  // skip the Tuple
-			visit(T.Results(), true) // skip the Tuple
-
-		case *types.Named:
-			// A pointer-to-named type can be derived from a named
-			// type via reflection.  It may have methods too.
-			visit(types.NewPointer(T), false)
-
-			// Consider 'type T struct{S}' where S has methods.
-			// Reflection provides no way to get from T to struct{S},
-			// only to S, so the method set of struct{S} is unwanted,
-			// so set 'skip' flag during recursion.
-			visit(T.Underlying(), true) // skip the unnamed type
-
-		case *types.Array:
-			visit(T.Elem(), false)
-
-		case *types.Struct:
-			for i, n := 0, T.NumFields(); i < n; i++ {
-				// TODO(adonovan): document whether or not
-				// it is safe to skip non-exported fields.
-				visit(T.Field(i).Type(), false)
-			}
-
-		case *types.Tuple:
-			for i, n := 0, T.Len(); i < n; i++ {
-				visit(T.At(i).Type(), false)
-			}
-
-		case *types.TypeParam, *types.Union:
-			// forEachReachable must not be called on parameterized types.
-			panic(fmt.Sprintf("ForEachElement called on type containing %T", T))
-
-		default:
-			panic(fmt.Sprintf("ForEachElement called on unexpected type %T", T))
-		}
-	}
-	visit(T, false)
-}
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/errorcode.go b/vendor/golang.org/x/tools/internal/typesinternal/errorcode.go
deleted file mode 100644
index 235a6defc4..0000000000
--- a/vendor/golang.org/x/tools/internal/typesinternal/errorcode.go
+++ /dev/null
@@ -1,1560 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package typesinternal
-
-//go:generate stringer -type=ErrorCode
-
-type ErrorCode int
-
-// This file defines the error codes that can be produced during type-checking.
-// Collectively, these codes provide an identifier that may be used to
-// implement special handling for certain types of errors.
-//
-// Error codes should be fine-grained enough that the exact nature of the error
-// can be easily determined, but coarse enough that they are not an
-// implementation detail of the type checking algorithm. As a rule-of-thumb,
-// errors should be considered equivalent if there is a theoretical refactoring
-// of the type checker in which they are emitted in exactly one place. For
-// example, the type checker emits different error messages for "too many
-// arguments" and "too few arguments", but one can imagine an alternative type
-// checker where this check instead just emits a single "wrong number of
-// arguments", so these errors should have the same code.
-//
-// Error code names should be as brief as possible while retaining accuracy and
-// distinctiveness. In most cases names should start with an adjective
-// describing the nature of the error (e.g. "invalid", "unused", "misplaced"),
-// and end with a noun identifying the relevant language object. For example,
-// "DuplicateDecl" or "InvalidSliceExpr". For brevity, naming follows the
-// convention that "bad" implies a problem with syntax, and "invalid" implies a
-// problem with types.
-
-const (
-	// InvalidSyntaxTree occurs if an invalid syntax tree is provided
-	// to the type checker. It should never happen.
-	InvalidSyntaxTree ErrorCode = -1
-)
-
-const (
-	_ ErrorCode = iota
-
-	// Test is reserved for errors that only apply while in self-test mode.
-	Test
-
-	/* package names */
-
-	// BlankPkgName occurs when a package name is the blank identifier "_".
-	//
-	// Per the spec:
-	//  "The PackageName must not be the blank identifier."
-	BlankPkgName
-
-	// MismatchedPkgName occurs when a file's package name doesn't match the
-	// package name already established by other files.
-	MismatchedPkgName
-
-	// InvalidPkgUse occurs when a package identifier is used outside of a
-	// selector expression.
-	//
-	// Example:
-	//  import "fmt"
-	//
-	//  var _ = fmt
-	InvalidPkgUse
-
-	/* imports */
-
-	// BadImportPath occurs when an import path is not valid.
-	BadImportPath
-
-	// BrokenImport occurs when importing a package fails.
-	//
-	// Example:
-	//  import "amissingpackage"
-	BrokenImport
-
-	// ImportCRenamed occurs when the special import "C" is renamed. "C" is a
-	// pseudo-package, and must not be renamed.
-	//
-	// Example:
-	//  import _ "C"
-	ImportCRenamed
-
-	// UnusedImport occurs when an import is unused.
-	//
-	// Example:
-	//  import "fmt"
-	//
-	//  func main() {}
-	UnusedImport
-
-	/* initialization */
-
-	// InvalidInitCycle occurs when an invalid cycle is detected within the
-	// initialization graph.
-	//
-	// Example:
-	//  var x int = f()
-	//
-	//  func f() int { return x }
-	InvalidInitCycle
-
-	/* decls */
-
-	// DuplicateDecl occurs when an identifier is declared multiple times.
-	//
-	// Example:
-	//  var x = 1
-	//  var x = 2
-	DuplicateDecl
-
-	// InvalidDeclCycle occurs when a declaration cycle is not valid.
-	//
-	// Example:
-	//  import "unsafe"
-	//
-	//  type T struct {
-	//  	a [n]int
-	//  }
-	//
-	//  var n = unsafe.Sizeof(T{})
-	InvalidDeclCycle
-
-	// InvalidTypeCycle occurs when a cycle in type definitions results in a
-	// type that is not well-defined.
-	//
-	// Example:
-	//  import "unsafe"
-	//
-	//  type T [unsafe.Sizeof(T{})]int
-	InvalidTypeCycle
-
-	/* decls > const */
-
-	// InvalidConstInit occurs when a const declaration has a non-constant
-	// initializer.
-	//
-	// Example:
-	//  var x int
-	//  const _ = x
-	InvalidConstInit
-
-	// InvalidConstVal occurs when a const value cannot be converted to its
-	// target type.
-	//
-	// TODO(findleyr): this error code and example are not very clear. Consider
-	// removing it.
-	//
-	// Example:
-	//  const _ = 1 << "hello"
-	InvalidConstVal
-
-	// InvalidConstType occurs when the underlying type in a const declaration
-	// is not a valid constant type.
-	//
-	// Example:
-	//  const c *int = 4
-	InvalidConstType
-
-	/* decls > var (+ other variable assignment codes) */
-
-	// UntypedNilUse occurs when the predeclared (untyped) value nil is used to
-	// initialize a variable declared without an explicit type.
-	//
-	// Example:
-	//  var x = nil
-	UntypedNilUse
-
-	// WrongAssignCount occurs when the number of values on the right-hand side
-	// of an assignment or initialization expression does not match the number
-	// of variables on the left-hand side.
-	//
-	// Example:
-	//  var x = 1, 2
-	WrongAssignCount
-
-	// UnassignableOperand occurs when the left-hand side of an assignment is
-	// not assignable.
-	//
-	// Example:
-	//  func f() {
-	//  	const c = 1
-	//  	c = 2
-	//  }
-	UnassignableOperand
-
-	// NoNewVar occurs when a short variable declaration (':=') does not declare
-	// new variables.
-	//
-	// Example:
-	//  func f() {
-	//  	x := 1
-	//  	x := 2
-	//  }
-	NoNewVar
-
-	// MultiValAssignOp occurs when an assignment operation (+=, *=, etc) does
-	// not have single-valued left-hand or right-hand side.
-	//
-	// Per the spec:
-	//  "In assignment operations, both the left- and right-hand expression lists
-	//  must contain exactly one single-valued expression"
-	//
-	// Example:
-	//  func f() int {
-	//  	x, y := 1, 2
-	//  	x, y += 1
-	//  	return x + y
-	//  }
-	MultiValAssignOp
-
-	// InvalidIfaceAssign occurs when a value of type T is used as an
-	// interface, but T does not implement a method of the expected interface.
-	//
-	// Example:
-	//  type I interface {
-	//  	f()
-	//  }
-	//
-	//  type T int
-	//
-	//  var x I = T(1)
-	InvalidIfaceAssign
-
-	// InvalidChanAssign occurs when a chan assignment is invalid.
-	//
-	// Per the spec, a value x is assignable to a channel type T if:
-	//  "x is a bidirectional channel value, T is a channel type, x's type V and
-	//  T have identical element types, and at least one of V or T is not a
-	//  defined type."
-	//
-	// Example:
-	//  type T1 chan int
-	//  type T2 chan int
-	//
-	//  var x T1
-	//  // Invalid assignment because both types are named
-	//  var _ T2 = x
-	InvalidChanAssign
-
-	// IncompatibleAssign occurs when the type of the right-hand side expression
-	// in an assignment cannot be assigned to the type of the variable being
-	// assigned.
-	//
-	// Example:
-	//  var x []int
-	//  var _ int = x
-	IncompatibleAssign
-
-	// UnaddressableFieldAssign occurs when trying to assign to a struct field
-	// in a map value.
-	//
-	// Example:
-	//  func f() {
-	//  	m := make(map[string]struct{i int})
-	//  	m["foo"].i = 42
-	//  }
-	UnaddressableFieldAssign
-
-	/* decls > type (+ other type expression codes) */
-
-	// NotAType occurs when the identifier used as the underlying type in a type
-	// declaration or the right-hand side of a type alias does not denote a type.
-	//
-	// Example:
-	//  var S = 2
-	//
-	//  type T S
-	NotAType
-
-	// InvalidArrayLen occurs when an array length is not a constant value.
-	//
-	// Example:
-	//  var n = 3
-	//  var _ = [n]int{}
-	InvalidArrayLen
-
-	// BlankIfaceMethod occurs when a method name is '_'.
-	//
-	// Per the spec:
-	//  "The name of each explicitly specified method must be unique and not
-	//  blank."
-	//
-	// Example:
-	//  type T interface {
-	//  	_(int)
-	//  }
-	BlankIfaceMethod
-
-	// IncomparableMapKey occurs when a map key type does not support the == and
-	// != operators.
-	//
-	// Per the spec:
-	//  "The comparison operators == and != must be fully defined for operands of
-	//  the key type; thus the key type must not be a function, map, or slice."
-	//
-	// Example:
-	//  var x map[T]int
-	//
-	//  type T []int
-	IncomparableMapKey
-
-	// InvalidIfaceEmbed occurs when a non-interface type is embedded in an
-	// interface.
-	//
-	// Example:
-	//  type T struct {}
-	//
-	//  func (T) m()
-	//
-	//  type I interface {
-	//  	T
-	//  }
-	InvalidIfaceEmbed
-
-	// InvalidPtrEmbed occurs when an embedded field is of the pointer form *T,
-	// and T itself is itself a pointer, an unsafe.Pointer, or an interface.
-	//
-	// Per the spec:
-	//  "An embedded field must be specified as a type name T or as a pointer to
-	//  a non-interface type name *T, and T itself may not be a pointer type."
-	//
-	// Example:
-	//  type T *int
-	//
-	//  type S struct {
-	//  	*T
-	//  }
-	InvalidPtrEmbed
-
-	/* decls > func and method */
-
-	// BadRecv occurs when a method declaration does not have exactly one
-	// receiver parameter.
-	//
-	// Example:
-	//  func () _() {}
-	BadRecv
-
-	// InvalidRecv occurs when a receiver type expression is not of the form T
-	// or *T, or T is a pointer type.
-	//
-	// Example:
-	//  type T struct {}
-	//
-	//  func (**T) m() {}
-	InvalidRecv
-
-	// DuplicateFieldAndMethod occurs when an identifier appears as both a field
-	// and method name.
-	//
-	// Example:
-	//  type T struct {
-	//  	m int
-	//  }
-	//
-	//  func (T) m() {}
-	DuplicateFieldAndMethod
-
-	// DuplicateMethod occurs when two methods on the same receiver type have
-	// the same name.
-	//
-	// Example:
-	//  type T struct {}
-	//  func (T) m() {}
-	//  func (T) m(i int) int { return i }
-	DuplicateMethod
-
-	/* decls > special */
-
-	// InvalidBlank occurs when a blank identifier is used as a value or type.
-	//
-	// Per the spec:
-	//  "The blank identifier may appear as an operand only on the left-hand side
-	//  of an assignment."
-	//
-	// Example:
-	//  var x = _
-	InvalidBlank
-
-	// InvalidIota occurs when the predeclared identifier iota is used outside
-	// of a constant declaration.
-	//
-	// Example:
-	//  var x = iota
-	InvalidIota
-
-	// MissingInitBody occurs when an init function is missing its body.
-	//
-	// Example:
-	//  func init()
-	MissingInitBody
-
-	// InvalidInitSig occurs when an init function declares parameters or
-	// results.
-	//
-	// Example:
-	//  func init() int { return 1 }
-	InvalidInitSig
-
-	// InvalidInitDecl occurs when init is declared as anything other than a
-	// function.
-	//
-	// Example:
-	//  var init = 1
-	InvalidInitDecl
-
-	// InvalidMainDecl occurs when main is declared as anything other than a
-	// function, in a main package.
-	InvalidMainDecl
-
-	/* exprs */
-
-	// TooManyValues occurs when a function returns too many values for the
-	// expression context in which it is used.
-	//
-	// Example:
-	//  func ReturnTwo() (int, int) {
-	//  	return 1, 2
-	//  }
-	//
-	//  var x = ReturnTwo()
-	TooManyValues
-
-	// NotAnExpr occurs when a type expression is used where a value expression
-	// is expected.
-	//
-	// Example:
-	//  type T struct {}
-	//
-	//  func f() {
-	//  	T
-	//  }
-	NotAnExpr
-
-	/* exprs > const */
-
-	// TruncatedFloat occurs when a float constant is truncated to an integer
-	// value.
-	//
-	// Example:
-	//  var _ int = 98.6
-	TruncatedFloat
-
-	// NumericOverflow occurs when a numeric constant overflows its target type.
-	//
-	// Example:
-	//  var x int8 = 1000
-	NumericOverflow
-
-	/* exprs > operation */
-
-	// UndefinedOp occurs when an operator is not defined for the type(s) used
-	// in an operation.
-	//
-	// Example:
-	//  var c = "a" - "b"
-	UndefinedOp
-
-	// MismatchedTypes occurs when operand types are incompatible in a binary
-	// operation.
-	//
-	// Example:
-	//  var a = "hello"
-	//  var b = 1
-	//  var c = a - b
-	MismatchedTypes
-
-	// DivByZero occurs when a division operation is provable at compile
-	// time to be a division by zero.
-	//
-	// Example:
-	//  const divisor = 0
-	//  var x int = 1/divisor
-	DivByZero
-
-	// NonNumericIncDec occurs when an increment or decrement operator is
-	// applied to a non-numeric value.
-	//
-	// Example:
-	//  func f() {
-	//  	var c = "c"
-	//  	c++
-	//  }
-	NonNumericIncDec
-
-	/* exprs > ptr */
-
-	// UnaddressableOperand occurs when the & operator is applied to an
-	// unaddressable expression.
-	//
-	// Example:
-	//  var x = &1
-	UnaddressableOperand
-
-	// InvalidIndirection occurs when a non-pointer value is indirected via the
-	// '*' operator.
-	//
-	// Example:
-	//  var x int
-	//  var y = *x
-	InvalidIndirection
-
-	/* exprs > [] */
-
-	// NonIndexableOperand occurs when an index operation is applied to a value
-	// that cannot be indexed.
-	//
-	// Example:
-	//  var x = 1
-	//  var y = x[1]
-	NonIndexableOperand
-
-	// InvalidIndex occurs when an index argument is not of integer type,
-	// negative, or out-of-bounds.
-	//
-	// Example:
-	//  var s = [...]int{1,2,3}
-	//  var x = s[5]
-	//
-	// Example:
-	//  var s = []int{1,2,3}
-	//  var _ = s[-1]
-	//
-	// Example:
-	//  var s = []int{1,2,3}
-	//  var i string
-	//  var _ = s[i]
-	InvalidIndex
-
-	// SwappedSliceIndices occurs when constant indices in a slice expression
-	// are decreasing in value.
-	//
-	// Example:
-	//  var _ = []int{1,2,3}[2:1]
-	SwappedSliceIndices
-
-	/* operators > slice */
-
-	// NonSliceableOperand occurs when a slice operation is applied to a value
-	// whose type is not sliceable, or is unaddressable.
-	//
-	// Example:
-	//  var x = [...]int{1, 2, 3}[:1]
-	//
-	// Example:
-	//  var x = 1
-	//  var y = 1[:1]
-	NonSliceableOperand
-
-	// InvalidSliceExpr occurs when a three-index slice expression (a[x:y:z]) is
-	// applied to a string.
-	//
-	// Example:
-	//  var s = "hello"
-	//  var x = s[1:2:3]
-	InvalidSliceExpr
-
-	/* exprs > shift */
-
-	// InvalidShiftCount occurs when the right-hand side of a shift operation is
-	// either non-integer, negative, or too large.
-	//
-	// Example:
-	//  var (
-	//  	x string
-	//  	y int = 1 << x
-	//  )
-	InvalidShiftCount
-
-	// InvalidShiftOperand occurs when the shifted operand is not an integer.
-	//
-	// Example:
-	//  var s = "hello"
-	//  var x = s << 2
-	InvalidShiftOperand
-
-	/* exprs > chan */
-
-	// InvalidReceive occurs when there is a channel receive from a value that
-	// is either not a channel, or is a send-only channel.
-	//
-	// Example:
-	//  func f() {
-	//  	var x = 1
-	//  	<-x
-	//  }
-	InvalidReceive
-
-	// InvalidSend occurs when there is a channel send to a value that is not a
-	// channel, or is a receive-only channel.
-	//
-	// Example:
-	//  func f() {
-	//  	var x = 1
-	//  	x <- "hello!"
-	//  }
-	InvalidSend
-
-	/* exprs > literal */
-
-	// DuplicateLitKey occurs when an index is duplicated in a slice, array, or
-	// map literal.
-	//
-	// Example:
-	//  var _ = []int{0:1, 0:2}
-	//
-	// Example:
-	//  var _ = map[string]int{"a": 1, "a": 2}
-	DuplicateLitKey
-
-	// MissingLitKey occurs when a map literal is missing a key expression.
-	//
-	// Example:
-	//  var _ = map[string]int{1}
-	MissingLitKey
-
-	// InvalidLitIndex occurs when the key in a key-value element of a slice or
-	// array literal is not an integer constant.
-	//
-	// Example:
-	//  var i = 0
-	//  var x = []string{i: "world"}
-	InvalidLitIndex
-
-	// OversizeArrayLit occurs when an array literal exceeds its length.
-	//
-	// Example:
-	//  var _ = [2]int{1,2,3}
-	OversizeArrayLit
-
-	// MixedStructLit occurs when a struct literal contains a mix of positional
-	// and named elements.
-	//
-	// Example:
-	//  var _ = struct{i, j int}{i: 1, 2}
-	MixedStructLit
-
-	// InvalidStructLit occurs when a positional struct literal has an incorrect
-	// number of values.
-	//
-	// Example:
-	//  var _ = struct{i, j int}{1,2,3}
-	InvalidStructLit
-
-	// MissingLitField occurs when a struct literal refers to a field that does
-	// not exist on the struct type.
-	//
-	// Example:
-	//  var _ = struct{i int}{j: 2}
-	MissingLitField
-
-	// DuplicateLitField occurs when a struct literal contains duplicated
-	// fields.
-	//
-	// Example:
-	//  var _ = struct{i int}{i: 1, i: 2}
-	DuplicateLitField
-
-	// UnexportedLitField occurs when a positional struct literal implicitly
-	// assigns an unexported field of an imported type.
-	UnexportedLitField
-
-	// InvalidLitField occurs when a field name is not a valid identifier.
-	//
-	// Example:
-	//  var _ = struct{i int}{1: 1}
-	InvalidLitField
-
-	// UntypedLit occurs when a composite literal omits a required type
-	// identifier.
-	//
-	// Example:
-	//  type outer struct{
-	//  	inner struct { i int }
-	//  }
-	//
-	//  var _ = outer{inner: {1}}
-	UntypedLit
-
-	// InvalidLit occurs when a composite literal expression does not match its
-	// type.
-	//
-	// Example:
-	//  type P *struct{
-	//  	x int
-	//  }
-	//  var _ = P {}
-	InvalidLit
-
-	/* exprs > selector */
-
-	// AmbiguousSelector occurs when a selector is ambiguous.
-	//
-	// Example:
-	//  type E1 struct { i int }
-	//  type E2 struct { i int }
-	//  type T struct { E1; E2 }
-	//
-	//  var x T
-	//  var _ = x.i
-	AmbiguousSelector
-
-	// UndeclaredImportedName occurs when a package-qualified identifier is
-	// undeclared by the imported package.
-	//
-	// Example:
-	//  import "go/types"
-	//
-	//  var _ = types.NotAnActualIdentifier
-	UndeclaredImportedName
-
-	// UnexportedName occurs when a selector refers to an unexported identifier
-	// of an imported package.
-	//
-	// Example:
-	//  import "reflect"
-	//
-	//  type _ reflect.flag
-	UnexportedName
-
-	// UndeclaredName occurs when an identifier is not declared in the current
-	// scope.
-	//
-	// Example:
-	//  var x T
-	UndeclaredName
-
-	// MissingFieldOrMethod occurs when a selector references a field or method
-	// that does not exist.
-	//
-	// Example:
-	//  type T struct {}
-	//
-	//  var x = T{}.f
-	MissingFieldOrMethod
-
-	/* exprs > ... */
-
-	// BadDotDotDotSyntax occurs when a "..." occurs in a context where it is
-	// not valid.
-	//
-	// Example:
-	//  var _ = map[int][...]int{0: {}}
-	BadDotDotDotSyntax
-
-	// NonVariadicDotDotDot occurs when a "..." is used on the final argument to
-	// a non-variadic function.
-	//
-	// Example:
-	//  func printArgs(s []string) {
-	//  	for _, a := range s {
-	//  		println(a)
-	//  	}
-	//  }
-	//
-	//  func f() {
-	//  	s := []string{"a", "b", "c"}
-	//  	printArgs(s...)
-	//  }
-	NonVariadicDotDotDot
-
-	// MisplacedDotDotDot occurs when a "..." is used somewhere other than the
-	// final argument to a function call.
-	//
-	// Example:
-	//  func printArgs(args ...int) {
-	//  	for _, a := range args {
-	//  		println(a)
-	//  	}
-	//  }
-	//
-	//  func f() {
-	//  	a := []int{1,2,3}
-	//  	printArgs(0, a...)
-	//  }
-	MisplacedDotDotDot
-
-	// InvalidDotDotDotOperand occurs when a "..." operator is applied to a
-	// single-valued operand.
-	//
-	// Example:
-	//  func printArgs(args ...int) {
-	//  	for _, a := range args {
-	//  		println(a)
-	//  	}
-	//  }
-	//
-	//  func f() {
-	//  	a := 1
-	//  	printArgs(a...)
-	//  }
-	//
-	// Example:
-	//  func args() (int, int) {
-	//  	return 1, 2
-	//  }
-	//
-	//  func printArgs(args ...int) {
-	//  	for _, a := range args {
-	//  		println(a)
-	//  	}
-	//  }
-	//
-	//  func g() {
-	//  	printArgs(args()...)
-	//  }
-	InvalidDotDotDotOperand
-
-	// InvalidDotDotDot occurs when a "..." is used in a non-variadic built-in
-	// function.
-	//
-	// Example:
-	//  var s = []int{1, 2, 3}
-	//  var l = len(s...)
-	InvalidDotDotDot
-
-	/* exprs > built-in */
-
-	// UncalledBuiltin occurs when a built-in function is used as a
-	// function-valued expression, instead of being called.
-	//
-	// Per the spec:
-	//  "The built-in functions do not have standard Go types, so they can only
-	//  appear in call expressions; they cannot be used as function values."
-	//
-	// Example:
-	//  var _ = copy
-	UncalledBuiltin
-
-	// InvalidAppend occurs when append is called with a first argument that is
-	// not a slice.
-	//
-	// Example:
-	//  var _ = append(1, 2)
-	InvalidAppend
-
-	// InvalidCap occurs when an argument to the cap built-in function is not of
-	// supported type.
-	//
-	// See https://golang.org/ref/spec#Length_and_capacity for information on
-	// which underlying types are supported as arguments to cap and len.
-	//
-	// Example:
-	//  var s = 2
-	//  var x = cap(s)
-	InvalidCap
-
-	// InvalidClose occurs when close(...) is called with an argument that is
-	// not of channel type, or that is a receive-only channel.
-	//
-	// Example:
-	//  func f() {
-	//  	var x int
-	//  	close(x)
-	//  }
-	InvalidClose
-
-	// InvalidCopy occurs when the arguments are not of slice type or do not
-	// have compatible type.
-	//
-	// See https://golang.org/ref/spec#Appending_and_copying_slices for more
-	// information on the type requirements for the copy built-in.
-	//
-	// Example:
-	//  func f() {
-	//  	var x []int
-	//  	y := []int64{1,2,3}
-	//  	copy(x, y)
-	//  }
-	InvalidCopy
-
-	// InvalidComplex occurs when the complex built-in function is called with
-	// arguments with incompatible types.
-	//
-	// Example:
-	//  var _ = complex(float32(1), float64(2))
-	InvalidComplex
-
-	// InvalidDelete occurs when the delete built-in function is called with a
-	// first argument that is not a map.
-	//
-	// Example:
-	//  func f() {
-	//  	m := "hello"
-	//  	delete(m, "e")
-	//  }
-	InvalidDelete
-
-	// InvalidImag occurs when the imag built-in function is called with an
-	// argument that does not have complex type.
-	//
-	// Example:
-	//  var _ = imag(int(1))
-	InvalidImag
-
-	// InvalidLen occurs when an argument to the len built-in function is not of
-	// supported type.
-	//
-	// See https://golang.org/ref/spec#Length_and_capacity for information on
-	// which underlying types are supported as arguments to cap and len.
-	//
-	// Example:
-	//  var s = 2
-	//  var x = len(s)
-	InvalidLen
-
-	// SwappedMakeArgs occurs when make is called with three arguments, and its
-	// length argument is larger than its capacity argument.
-	//
-	// Example:
-	//  var x = make([]int, 3, 2)
-	SwappedMakeArgs
-
-	// InvalidMake occurs when make is called with an unsupported type argument.
-	//
-	// See https://golang.org/ref/spec#Making_slices_maps_and_channels for
-	// information on the types that may be created using make.
-	//
-	// Example:
-	//  var x = make(int)
-	InvalidMake
-
-	// InvalidReal occurs when the real built-in function is called with an
-	// argument that does not have complex type.
-	//
-	// Example:
-	//  var _ = real(int(1))
-	InvalidReal
-
-	/* exprs > assertion */
-
-	// InvalidAssert occurs when a type assertion is applied to a
-	// value that is not of interface type.
-	//
-	// Example:
-	//  var x = 1
-	//  var _ = x.(float64)
-	InvalidAssert
-
-	// ImpossibleAssert occurs for a type assertion x.(T) when the value x of
-	// interface cannot have dynamic type T, due to a missing or mismatching
-	// method on T.
-	//
-	// Example:
-	//  type T int
-	//
-	//  func (t *T) m() int { return int(*t) }
-	//
-	//  type I interface { m() int }
-	//
-	//  var x I
-	//  var _ = x.(T)
-	ImpossibleAssert
-
-	/* exprs > conversion */
-
-	// InvalidConversion occurs when the argument type cannot be converted to the
-	// target.
-	//
-	// See https://golang.org/ref/spec#Conversions for the rules of
-	// convertibility.
-	//
-	// Example:
-	//  var x float64
-	//  var _ = string(x)
-	InvalidConversion
-
-	// InvalidUntypedConversion occurs when there is no valid implicit
-	// conversion from an untyped value satisfying the type constraints of the
-	// context in which it is used.
-	//
-	// Example:
-	//  var _ = 1 + ""
-	InvalidUntypedConversion
-
-	/* offsetof */
-
-	// BadOffsetofSyntax occurs when unsafe.Offsetof is called with an argument
-	// that is not a selector expression.
-	//
-	// Example:
-	//  import "unsafe"
-	//
-	//  var x int
-	//  var _ = unsafe.Offsetof(x)
-	BadOffsetofSyntax
-
-	// InvalidOffsetof occurs when unsafe.Offsetof is called with a method
-	// selector, rather than a field selector, or when the field is embedded via
-	// a pointer.
-	//
-	// Per the spec:
-	//
-	//  "If f is an embedded field, it must be reachable without pointer
-	//  indirections through fields of the struct. "
-	//
-	// Example:
-	//  import "unsafe"
-	//
-	//  type T struct { f int }
-	//  type S struct { *T }
-	//  var s S
-	//  var _ = unsafe.Offsetof(s.f)
-	//
-	// Example:
-	//  import "unsafe"
-	//
-	//  type S struct{}
-	//
-	//  func (S) m() {}
-	//
-	//  var s S
-	//  var _ = unsafe.Offsetof(s.m)
-	InvalidOffsetof
-
-	/* control flow > scope */
-
-	// UnusedExpr occurs when a side-effect free expression is used as a
-	// statement. Such a statement has no effect.
-	//
-	// Example:
-	//  func f(i int) {
-	//  	i*i
-	//  }
-	UnusedExpr
-
-	// UnusedVar occurs when a variable is declared but unused.
-	//
-	// Example:
-	//  func f() {
-	//  	x := 1
-	//  }
-	UnusedVar
-
-	// MissingReturn occurs when a function with results is missing a return
-	// statement.
-	//
-	// Example:
-	//  func f() int {}
-	MissingReturn
-
-	// WrongResultCount occurs when a return statement returns an incorrect
-	// number of values.
-	//
-	// Example:
-	//  func ReturnOne() int {
-	//  	return 1, 2
-	//  }
-	WrongResultCount
-
-	// OutOfScopeResult occurs when the name of a value implicitly returned by
-	// an empty return statement is shadowed in a nested scope.
-	//
-	// Example:
-	//  func factor(n int) (i int) {
-	//  	for i := 2; i < n; i++ {
-	//  		if n%i == 0 {
-	//  			return
-	//  		}
-	//  	}
-	//  	return 0
-	//  }
-	OutOfScopeResult
-
-	/* control flow > if */
-
-	// InvalidCond occurs when an if condition is not a boolean expression.
-	//
-	// Example:
-	//  func checkReturn(i int) {
-	//  	if i {
-	//  		panic("non-zero return")
-	//  	}
-	//  }
-	InvalidCond
-
-	/* control flow > for */
-
-	// InvalidPostDecl occurs when there is a declaration in a for-loop post
-	// statement.
-	//
-	// Example:
-	//  func f() {
-	//  	for i := 0; i < 10; j := 0 {}
-	//  }
-	InvalidPostDecl
-
-	// InvalidChanRange occurs when a send-only channel used in a range
-	// expression.
-	//
-	// Example:
-	//  func sum(c chan<- int) {
-	//  	s := 0
-	//  	for i := range c {
-	//  		s += i
-	//  	}
-	//  }
-	InvalidChanRange
-
-	// InvalidIterVar occurs when two iteration variables are used while ranging
-	// over a channel.
-	//
-	// Example:
-	//  func f(c chan int) {
-	//  	for k, v := range c {
-	//  		println(k, v)
-	//  	}
-	//  }
-	InvalidIterVar
-
-	// InvalidRangeExpr occurs when the type of a range expression is not array,
-	// slice, string, map, or channel.
-	//
-	// Example:
-	//  func f(i int) {
-	//  	for j := range i {
-	//  		println(j)
-	//  	}
-	//  }
-	InvalidRangeExpr
-
-	/* control flow > switch */
-
-	// MisplacedBreak occurs when a break statement is not within a for, switch,
-	// or select statement of the innermost function definition.
-	//
-	// Example:
-	//  func f() {
-	//  	break
-	//  }
-	MisplacedBreak
-
-	// MisplacedContinue occurs when a continue statement is not within a for
-	// loop of the innermost function definition.
-	//
-	// Example:
-	//  func sumeven(n int) int {
-	//  	proceed := func() {
-	//  		continue
-	//  	}
-	//  	sum := 0
-	//  	for i := 1; i <= n; i++ {
-	//  		if i % 2 != 0 {
-	//  			proceed()
-	//  		}
-	//  		sum += i
-	//  	}
-	//  	return sum
-	//  }
-	MisplacedContinue
-
-	// MisplacedFallthrough occurs when a fallthrough statement is not within an
-	// expression switch.
-	//
-	// Example:
-	//  func typename(i interface{}) string {
-	//  	switch i.(type) {
-	//  	case int64:
-	//  		fallthrough
-	//  	case int:
-	//  		return "int"
-	//  	}
-	//  	return "unsupported"
-	//  }
-	MisplacedFallthrough
-
-	// DuplicateCase occurs when a type or expression switch has duplicate
-	// cases.
-	//
-	// Example:
-	//  func printInt(i int) {
-	//  	switch i {
-	//  	case 1:
-	//  		println("one")
-	//  	case 1:
-	//  		println("One")
-	//  	}
-	//  }
-	DuplicateCase
-
-	// DuplicateDefault occurs when a type or expression switch has multiple
-	// default clauses.
-	//
-	// Example:
-	//  func printInt(i int) {
-	//  	switch i {
-	//  	case 1:
-	//  		println("one")
-	//  	default:
-	//  		println("One")
-	//  	default:
-	//  		println("1")
-	//  	}
-	//  }
-	DuplicateDefault
-
-	// BadTypeKeyword occurs when a .(type) expression is used anywhere other
-	// than a type switch.
-	//
-	// Example:
-	//  type I interface {
-	//  	m()
-	//  }
-	//  var t I
-	//  var _ = t.(type)
-	BadTypeKeyword
-
-	// InvalidTypeSwitch occurs when .(type) is used on an expression that is
-	// not of interface type.
-	//
-	// Example:
-	//  func f(i int) {
-	//  	switch x := i.(type) {}
-	//  }
-	InvalidTypeSwitch
-
-	// InvalidExprSwitch occurs when a switch expression is not comparable.
-	//
-	// Example:
-	//  func _() {
-	//  	var a struct{ _ func() }
-	//  	switch a /* ERROR cannot switch on a */ {
-	//  	}
-	//  }
-	InvalidExprSwitch
-
-	/* control flow > select */
-
-	// InvalidSelectCase occurs when a select case is not a channel send or
-	// receive.
-	//
-	// Example:
-	//  func checkChan(c <-chan int) bool {
-	//  	select {
-	//  	case c:
-	//  		return true
-	//  	default:
-	//  		return false
-	//  	}
-	//  }
-	InvalidSelectCase
-
-	/* control flow > labels and jumps */
-
-	// UndeclaredLabel occurs when an undeclared label is jumped to.
-	//
-	// Example:
-	//  func f() {
-	//  	goto L
-	//  }
-	UndeclaredLabel
-
-	// DuplicateLabel occurs when a label is declared more than once.
-	//
-	// Example:
-	//  func f() int {
-	//  L:
-	//  L:
-	//  	return 1
-	//  }
-	DuplicateLabel
-
-	// MisplacedLabel occurs when a break or continue label is not on a for,
-	// switch, or select statement.
-	//
-	// Example:
-	//  func f() {
-	//  L:
-	//  	a := []int{1,2,3}
-	//  	for _, e := range a {
-	//  		if e > 10 {
-	//  			break L
-	//  		}
-	//  		println(a)
-	//  	}
-	//  }
-	MisplacedLabel
-
-	// UnusedLabel occurs when a label is declared but not used.
-	//
-	// Example:
-	//  func f() {
-	//  L:
-	//  }
-	UnusedLabel
-
-	// JumpOverDecl occurs when a label jumps over a variable declaration.
-	//
-	// Example:
-	//  func f() int {
-	//  	goto L
-	//  	x := 2
-	//  L:
-	//  	x++
-	//  	return x
-	//  }
-	JumpOverDecl
-
-	// JumpIntoBlock occurs when a forward jump goes to a label inside a nested
-	// block.
-	//
-	// Example:
-	//  func f(x int) {
-	//  	goto L
-	//  	if x > 0 {
-	//  	L:
-	//  		print("inside block")
-	//  	}
-	// }
-	JumpIntoBlock
-
-	/* control flow > calls */
-
-	// InvalidMethodExpr occurs when a pointer method is called but the argument
-	// is not addressable.
-	//
-	// Example:
-	//  type T struct {}
-	//
-	//  func (*T) m() int { return 1 }
-	//
-	//  var _ = T.m(T{})
-	InvalidMethodExpr
-
-	// WrongArgCount occurs when too few or too many arguments are passed by a
-	// function call.
-	//
-	// Example:
-	//  func f(i int) {}
-	//  var x = f()
-	WrongArgCount
-
-	// InvalidCall occurs when an expression is called that is not of function
-	// type.
-	//
-	// Example:
-	//  var x = "x"
-	//  var y = x()
-	InvalidCall
-
-	/* control flow > suspended */
-
-	// UnusedResults occurs when a restricted expression-only built-in function
-	// is suspended via go or defer. Such a suspension discards the results of
-	// these side-effect free built-in functions, and therefore is ineffectual.
-	//
-	// Example:
-	//  func f(a []int) int {
-	//  	defer len(a)
-	//  	return i
-	//  }
-	UnusedResults
-
-	// InvalidDefer occurs when a deferred expression is not a function call,
-	// for example if the expression is a type conversion.
-	//
-	// Example:
-	//  func f(i int) int {
-	//  	defer int32(i)
-	//  	return i
-	//  }
-	InvalidDefer
-
-	// InvalidGo occurs when a go expression is not a function call, for example
-	// if the expression is a type conversion.
-	//
-	// Example:
-	//  func f(i int) int {
-	//  	go int32(i)
-	//  	return i
-	//  }
-	InvalidGo
-
-	// All codes below were added in Go 1.17.
-
-	/* decl */
-
-	// BadDecl occurs when a declaration has invalid syntax.
-	BadDecl
-
-	// RepeatedDecl occurs when an identifier occurs more than once on the left
-	// hand side of a short variable declaration.
-	//
-	// Example:
-	//  func _() {
-	//  	x, y, y := 1, 2, 3
-	//  }
-	RepeatedDecl
-
-	/* unsafe */
-
-	// InvalidUnsafeAdd occurs when unsafe.Add is called with a
-	// length argument that is not of integer type.
-	//
-	// Example:
-	//  import "unsafe"
-	//
-	//  var p unsafe.Pointer
-	//  var _ = unsafe.Add(p, float64(1))
-	InvalidUnsafeAdd
-
-	// InvalidUnsafeSlice occurs when unsafe.Slice is called with a
-	// pointer argument that is not of pointer type or a length argument
-	// that is not of integer type, negative, or out of bounds.
-	//
-	// Example:
-	//  import "unsafe"
-	//
-	//  var x int
-	//  var _ = unsafe.Slice(x, 1)
-	//
-	// Example:
-	//  import "unsafe"
-	//
-	//  var x int
-	//  var _ = unsafe.Slice(&x, float64(1))
-	//
-	// Example:
-	//  import "unsafe"
-	//
-	//  var x int
-	//  var _ = unsafe.Slice(&x, -1)
-	//
-	// Example:
-	//  import "unsafe"
-	//
-	//  var x int
-	//  var _ = unsafe.Slice(&x, uint64(1) << 63)
-	InvalidUnsafeSlice
-
-	// All codes below were added in Go 1.18.
-
-	/* features */
-
-	// UnsupportedFeature occurs when a language feature is used that is not
-	// supported at this Go version.
-	UnsupportedFeature
-
-	/* type params */
-
-	// NotAGenericType occurs when a non-generic type is used where a generic
-	// type is expected: in type or function instantiation.
-	//
-	// Example:
-	//  type T int
-	//
-	//  var _ T[int]
-	NotAGenericType
-
-	// WrongTypeArgCount occurs when a type or function is instantiated with an
-	// incorrect number of type arguments, including when a generic type or
-	// function is used without instantiation.
-	//
-	// Errors involving failed type inference are assigned other error codes.
-	//
-	// Example:
-	//  type T[p any] int
-	//
-	//  var _ T[int, string]
-	//
-	// Example:
-	//  func f[T any]() {}
-	//
-	//  var x = f
-	WrongTypeArgCount
-
-	// CannotInferTypeArgs occurs when type or function type argument inference
-	// fails to infer all type arguments.
-	//
-	// Example:
-	//  func f[T any]() {}
-	//
-	//  func _() {
-	//  	f()
-	//  }
-	//
-	// Example:
-	//   type N[P, Q any] struct{}
-	//
-	//   var _ N[int]
-	CannotInferTypeArgs
-
-	// InvalidTypeArg occurs when a type argument does not satisfy its
-	// corresponding type parameter constraints.
-	//
-	// Example:
-	//  type T[P ~int] struct{}
-	//
-	//  var _ T[string]
-	InvalidTypeArg // arguments? InferenceFailed
-
-	// InvalidInstanceCycle occurs when an invalid cycle is detected
-	// within the instantiation graph.
-	//
-	// Example:
-	//  func f[T any]() { f[*T]() }
-	InvalidInstanceCycle
-
-	// InvalidUnion occurs when an embedded union or approximation element is
-	// not valid.
-	//
-	// Example:
-	//  type _ interface {
-	//   	~int | interface{ m() }
-	//  }
-	InvalidUnion
-
-	// MisplacedConstraintIface occurs when a constraint-type interface is used
-	// outside of constraint position.
-	//
-	// Example:
-	//   type I interface { ~int }
-	//
-	//   var _ I
-	MisplacedConstraintIface
-
-	// InvalidMethodTypeParams occurs when methods have type parameters.
-	//
-	// It cannot be encountered with an AST parsed using go/parser.
-	InvalidMethodTypeParams
-
-	// MisplacedTypeParam occurs when a type parameter is used in a place where
-	// it is not permitted.
-	//
-	// Example:
-	//  type T[P any] P
-	//
-	// Example:
-	//  type T[P any] struct{ *P }
-	MisplacedTypeParam
-
-	// InvalidUnsafeSliceData occurs when unsafe.SliceData is called with
-	// an argument that is not of slice type. It also occurs if it is used
-	// in a package compiled for a language version before go1.20.
-	//
-	// Example:
-	//  import "unsafe"
-	//
-	//  var x int
-	//  var _ = unsafe.SliceData(x)
-	InvalidUnsafeSliceData
-
-	// InvalidUnsafeString occurs when unsafe.String is called with
-	// a length argument that is not of integer type, negative, or
-	// out of bounds. It also occurs if it is used in a package
-	// compiled for a language version before go1.20.
-	//
-	// Example:
-	//  import "unsafe"
-	//
-	//  var b [10]byte
-	//  var _ = unsafe.String(&b[0], -1)
-	InvalidUnsafeString
-
-	// InvalidUnsafeStringData occurs if it is used in a package
-	// compiled for a language version before go1.20.
-	_ // not used anymore
-
-)
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/errorcode_string.go b/vendor/golang.org/x/tools/internal/typesinternal/errorcode_string.go
deleted file mode 100644
index 15ecf7c5de..0000000000
--- a/vendor/golang.org/x/tools/internal/typesinternal/errorcode_string.go
+++ /dev/null
@@ -1,179 +0,0 @@
-// Code generated by "stringer -type=ErrorCode"; DO NOT EDIT.
-
-package typesinternal
-
-import "strconv"
-
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[InvalidSyntaxTree - -1]
-	_ = x[Test-1]
-	_ = x[BlankPkgName-2]
-	_ = x[MismatchedPkgName-3]
-	_ = x[InvalidPkgUse-4]
-	_ = x[BadImportPath-5]
-	_ = x[BrokenImport-6]
-	_ = x[ImportCRenamed-7]
-	_ = x[UnusedImport-8]
-	_ = x[InvalidInitCycle-9]
-	_ = x[DuplicateDecl-10]
-	_ = x[InvalidDeclCycle-11]
-	_ = x[InvalidTypeCycle-12]
-	_ = x[InvalidConstInit-13]
-	_ = x[InvalidConstVal-14]
-	_ = x[InvalidConstType-15]
-	_ = x[UntypedNilUse-16]
-	_ = x[WrongAssignCount-17]
-	_ = x[UnassignableOperand-18]
-	_ = x[NoNewVar-19]
-	_ = x[MultiValAssignOp-20]
-	_ = x[InvalidIfaceAssign-21]
-	_ = x[InvalidChanAssign-22]
-	_ = x[IncompatibleAssign-23]
-	_ = x[UnaddressableFieldAssign-24]
-	_ = x[NotAType-25]
-	_ = x[InvalidArrayLen-26]
-	_ = x[BlankIfaceMethod-27]
-	_ = x[IncomparableMapKey-28]
-	_ = x[InvalidIfaceEmbed-29]
-	_ = x[InvalidPtrEmbed-30]
-	_ = x[BadRecv-31]
-	_ = x[InvalidRecv-32]
-	_ = x[DuplicateFieldAndMethod-33]
-	_ = x[DuplicateMethod-34]
-	_ = x[InvalidBlank-35]
-	_ = x[InvalidIota-36]
-	_ = x[MissingInitBody-37]
-	_ = x[InvalidInitSig-38]
-	_ = x[InvalidInitDecl-39]
-	_ = x[InvalidMainDecl-40]
-	_ = x[TooManyValues-41]
-	_ = x[NotAnExpr-42]
-	_ = x[TruncatedFloat-43]
-	_ = x[NumericOverflow-44]
-	_ = x[UndefinedOp-45]
-	_ = x[MismatchedTypes-46]
-	_ = x[DivByZero-47]
-	_ = x[NonNumericIncDec-48]
-	_ = x[UnaddressableOperand-49]
-	_ = x[InvalidIndirection-50]
-	_ = x[NonIndexableOperand-51]
-	_ = x[InvalidIndex-52]
-	_ = x[SwappedSliceIndices-53]
-	_ = x[NonSliceableOperand-54]
-	_ = x[InvalidSliceExpr-55]
-	_ = x[InvalidShiftCount-56]
-	_ = x[InvalidShiftOperand-57]
-	_ = x[InvalidReceive-58]
-	_ = x[InvalidSend-59]
-	_ = x[DuplicateLitKey-60]
-	_ = x[MissingLitKey-61]
-	_ = x[InvalidLitIndex-62]
-	_ = x[OversizeArrayLit-63]
-	_ = x[MixedStructLit-64]
-	_ = x[InvalidStructLit-65]
-	_ = x[MissingLitField-66]
-	_ = x[DuplicateLitField-67]
-	_ = x[UnexportedLitField-68]
-	_ = x[InvalidLitField-69]
-	_ = x[UntypedLit-70]
-	_ = x[InvalidLit-71]
-	_ = x[AmbiguousSelector-72]
-	_ = x[UndeclaredImportedName-73]
-	_ = x[UnexportedName-74]
-	_ = x[UndeclaredName-75]
-	_ = x[MissingFieldOrMethod-76]
-	_ = x[BadDotDotDotSyntax-77]
-	_ = x[NonVariadicDotDotDot-78]
-	_ = x[MisplacedDotDotDot-79]
-	_ = x[InvalidDotDotDotOperand-80]
-	_ = x[InvalidDotDotDot-81]
-	_ = x[UncalledBuiltin-82]
-	_ = x[InvalidAppend-83]
-	_ = x[InvalidCap-84]
-	_ = x[InvalidClose-85]
-	_ = x[InvalidCopy-86]
-	_ = x[InvalidComplex-87]
-	_ = x[InvalidDelete-88]
-	_ = x[InvalidImag-89]
-	_ = x[InvalidLen-90]
-	_ = x[SwappedMakeArgs-91]
-	_ = x[InvalidMake-92]
-	_ = x[InvalidReal-93]
-	_ = x[InvalidAssert-94]
-	_ = x[ImpossibleAssert-95]
-	_ = x[InvalidConversion-96]
-	_ = x[InvalidUntypedConversion-97]
-	_ = x[BadOffsetofSyntax-98]
-	_ = x[InvalidOffsetof-99]
-	_ = x[UnusedExpr-100]
-	_ = x[UnusedVar-101]
-	_ = x[MissingReturn-102]
-	_ = x[WrongResultCount-103]
-	_ = x[OutOfScopeResult-104]
-	_ = x[InvalidCond-105]
-	_ = x[InvalidPostDecl-106]
-	_ = x[InvalidChanRange-107]
-	_ = x[InvalidIterVar-108]
-	_ = x[InvalidRangeExpr-109]
-	_ = x[MisplacedBreak-110]
-	_ = x[MisplacedContinue-111]
-	_ = x[MisplacedFallthrough-112]
-	_ = x[DuplicateCase-113]
-	_ = x[DuplicateDefault-114]
-	_ = x[BadTypeKeyword-115]
-	_ = x[InvalidTypeSwitch-116]
-	_ = x[InvalidExprSwitch-117]
-	_ = x[InvalidSelectCase-118]
-	_ = x[UndeclaredLabel-119]
-	_ = x[DuplicateLabel-120]
-	_ = x[MisplacedLabel-121]
-	_ = x[UnusedLabel-122]
-	_ = x[JumpOverDecl-123]
-	_ = x[JumpIntoBlock-124]
-	_ = x[InvalidMethodExpr-125]
-	_ = x[WrongArgCount-126]
-	_ = x[InvalidCall-127]
-	_ = x[UnusedResults-128]
-	_ = x[InvalidDefer-129]
-	_ = x[InvalidGo-130]
-	_ = x[BadDecl-131]
-	_ = x[RepeatedDecl-132]
-	_ = x[InvalidUnsafeAdd-133]
-	_ = x[InvalidUnsafeSlice-134]
-	_ = x[UnsupportedFeature-135]
-	_ = x[NotAGenericType-136]
-	_ = x[WrongTypeArgCount-137]
-	_ = x[CannotInferTypeArgs-138]
-	_ = x[InvalidTypeArg-139]
-	_ = x[InvalidInstanceCycle-140]
-	_ = x[InvalidUnion-141]
-	_ = x[MisplacedConstraintIface-142]
-	_ = x[InvalidMethodTypeParams-143]
-	_ = x[MisplacedTypeParam-144]
-	_ = x[InvalidUnsafeSliceData-145]
-	_ = x[InvalidUnsafeString-146]
-}
-
-const (
-	_ErrorCode_name_0 = "InvalidSyntaxTree"
-	_ErrorCode_name_1 = "TestBlankPkgNameMismatchedPkgNameInvalidPkgUseBadImportPathBrokenImportImportCRenamedUnusedImportInvalidInitCycleDuplicateDeclInvalidDeclCycleInvalidTypeCycleInvalidConstInitInvalidConstValInvalidConstTypeUntypedNilUseWrongAssignCountUnassignableOperandNoNewVarMultiValAssignOpInvalidIfaceAssignInvalidChanAssignIncompatibleAssignUnaddressableFieldAssignNotATypeInvalidArrayLenBlankIfaceMethodIncomparableMapKeyInvalidIfaceEmbedInvalidPtrEmbedBadRecvInvalidRecvDuplicateFieldAndMethodDuplicateMethodInvalidBlankInvalidIotaMissingInitBodyInvalidInitSigInvalidInitDeclInvalidMainDeclTooManyValuesNotAnExprTruncatedFloatNumericOverflowUndefinedOpMismatchedTypesDivByZeroNonNumericIncDecUnaddressableOperandInvalidIndirectionNonIndexableOperandInvalidIndexSwappedSliceIndicesNonSliceableOperandInvalidSliceExprInvalidShiftCountInvalidShiftOperandInvalidReceiveInvalidSendDuplicateLitKeyMissingLitKeyInvalidLitIndexOversizeArrayLitMixedStructLitInvalidStructLitMissingLitFieldDuplicateLitFieldUnexportedLitFieldInvalidLitFieldUntypedLitInvalidLitAmbiguousSelectorUndeclaredImportedNameUnexportedNameUndeclaredNameMissingFieldOrMethodBadDotDotDotSyntaxNonVariadicDotDotDotMisplacedDotDotDotInvalidDotDotDotOperandInvalidDotDotDotUncalledBuiltinInvalidAppendInvalidCapInvalidCloseInvalidCopyInvalidComplexInvalidDeleteInvalidImagInvalidLenSwappedMakeArgsInvalidMakeInvalidRealInvalidAssertImpossibleAssertInvalidConversionInvalidUntypedConversionBadOffsetofSyntaxInvalidOffsetofUnusedExprUnusedVarMissingReturnWrongResultCountOutOfScopeResultInvalidCondInvalidPostDeclInvalidChanRangeInvalidIterVarInvalidRangeExprMisplacedBreakMisplacedContinueMisplacedFallthroughDuplicateCaseDuplicateDefaultBadTypeKeywordInvalidTypeSwitchInvalidExprSwitchInvalidSelectCaseUndeclaredLabelDuplicateLabelMisplacedLabelUnusedLabelJumpOverDeclJumpIntoBlockInvalidMethodExprWrongArgCountInvalidCallUnusedResultsInvalidDeferInvalidGoBadDeclRepeatedDeclInvalidUnsafeAddInvalidUnsafeSliceUnsupportedFeatureNotAGenericTypeWrongTypeArgCountCannotInferTypeArgsInvalidTypeArgInvalidInstanceCycleInvalidUnionMisplacedConstraintIfaceInvalidMethodTypeParamsMisplacedTypeParamInvalidUnsafeSliceDataInvalidUnsafeString"
-)
-
-var (
-	_ErrorCode_index_1 = [...]uint16{0, 4, 16, 33, 46, 59, 71, 85, 97, 113, 126, 142, 158, 174, 189, 205, 218, 234, 253, 261, 277, 295, 312, 330, 354, 362, 377, 393, 411, 428, 443, 450, 461, 484, 499, 511, 522, 537, 551, 566, 581, 594, 603, 617, 632, 643, 658, 667, 683, 703, 721, 740, 752, 771, 790, 806, 823, 842, 856, 867, 882, 895, 910, 926, 940, 956, 971, 988, 1006, 1021, 1031, 1041, 1058, 1080, 1094, 1108, 1128, 1146, 1166, 1184, 1207, 1223, 1238, 1251, 1261, 1273, 1284, 1298, 1311, 1322, 1332, 1347, 1358, 1369, 1382, 1398, 1415, 1439, 1456, 1471, 1481, 1490, 1503, 1519, 1535, 1546, 1561, 1577, 1591, 1607, 1621, 1638, 1658, 1671, 1687, 1701, 1718, 1735, 1752, 1767, 1781, 1795, 1806, 1818, 1831, 1848, 1861, 1872, 1885, 1897, 1906, 1913, 1925, 1941, 1959, 1977, 1992, 2009, 2028, 2042, 2062, 2074, 2098, 2121, 2139, 2161, 2180}
-)
-
-func (i ErrorCode) String() string {
-	switch {
-	case i == -1:
-		return _ErrorCode_name_0
-	case 1 <= i && i <= 146:
-		i -= 1
-		return _ErrorCode_name_1[_ErrorCode_index_1[i]:_ErrorCode_index_1[i+1]]
-	default:
-		return "ErrorCode(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-}
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/fx.go b/vendor/golang.org/x/tools/internal/typesinternal/fx.go
deleted file mode 100644
index c846a53d5f..0000000000
--- a/vendor/golang.org/x/tools/internal/typesinternal/fx.go
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright 2025 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package typesinternal
-
-import (
-	"go/ast"
-	"go/token"
-	"go/types"
-)
-
-// NoEffects reports whether the expression has no side effects, i.e., it
-// does not modify the memory state. This function is conservative: it may
-// return false even when the expression has no effect.
-func NoEffects(info *types.Info, expr ast.Expr) bool {
-	noEffects := true
-	ast.Inspect(expr, func(n ast.Node) bool {
-		switch v := n.(type) {
-		case nil, *ast.Ident, *ast.BasicLit, *ast.BinaryExpr, *ast.ParenExpr,
-			*ast.SelectorExpr, *ast.IndexExpr, *ast.SliceExpr, *ast.TypeAssertExpr,
-			*ast.StarExpr, *ast.CompositeLit,
-			// non-expressions that may appear within expressions
-			*ast.KeyValueExpr,
-			*ast.FieldList,
-			*ast.Field,
-			*ast.Ellipsis,
-			*ast.IndexListExpr:
-			// No effect.
-
-		case *ast.ArrayType,
-			*ast.StructType,
-			*ast.ChanType,
-			*ast.FuncType,
-			*ast.MapType,
-			*ast.InterfaceType:
-			// Type syntax: no effects, recursively.
-			// Prune descent.
-			return false
-
-		case *ast.UnaryExpr:
-			// Channel send <-ch has effects.
-			if v.Op == token.ARROW {
-				noEffects = false
-			}
-
-		case *ast.CallExpr:
-			// Type conversion has no effects.
-			if !info.Types[v.Fun].IsType() {
-				if CallsPureBuiltin(info, v) {
-					// A call such as len(e) has no effects of its
-					// own, though the subexpression e might.
-				} else {
-					noEffects = false
-				}
-			}
-
-		case *ast.FuncLit:
-			// A FuncLit has no effects, but do not descend into it.
-			return false
-
-		default:
-			// All other expressions have effects
-			noEffects = false
-		}
-
-		return noEffects
-	})
-	return noEffects
-}
-
-// CallsPureBuiltin reports whether call is a call of a built-in
-// function that is a pure computation over its operands (analogous to
-// a + operator). Because it does not depend on program state, it may
-// be evaluated at any point--though not necessarily at multiple
-// points (consider new, make).
-func CallsPureBuiltin(info *types.Info, call *ast.CallExpr) bool {
-	if id, ok := ast.Unparen(call.Fun).(*ast.Ident); ok {
-		if b, ok := info.ObjectOf(id).(*types.Builtin); ok {
-			switch b.Name() {
-			case "len", "cap", "complex", "imag", "real", "make", "new", "max", "min":
-				return true
-			}
-			// Not: append clear close copy delete panic print println recover
-		}
-	}
-	return false
-}
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/isnamed.go b/vendor/golang.org/x/tools/internal/typesinternal/isnamed.go
deleted file mode 100644
index e0d63c46c6..0000000000
--- a/vendor/golang.org/x/tools/internal/typesinternal/isnamed.go
+++ /dev/null
@@ -1,71 +0,0 @@
-// Copyright 2025 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package typesinternal
-
-import (
-	"go/types"
-	"slices"
-)
-
-// IsTypeNamed reports whether t is (or is an alias for) a
-// package-level defined type with the given package path and one of
-// the given names. It returns false if t is nil.
-//
-// This function avoids allocating the concatenation of "pkg.Name",
-// which is important for the performance of syntax matching.
-func IsTypeNamed(t types.Type, pkgPath string, names ...string) bool {
-	if named, ok := types.Unalias(t).(*types.Named); ok {
-		tname := named.Obj()
-		return tname != nil &&
-			IsPackageLevel(tname) &&
-			tname.Pkg().Path() == pkgPath &&
-			slices.Contains(names, tname.Name())
-	}
-	return false
-}
-
-// IsPointerToNamed reports whether t is (or is an alias for) a pointer to a
-// package-level defined type with the given package path and one of the given
-// names. It returns false if t is not a pointer type.
-func IsPointerToNamed(t types.Type, pkgPath string, names ...string) bool {
-	r := Unpointer(t)
-	if r == t {
-		return false
-	}
-	return IsTypeNamed(r, pkgPath, names...)
-}
-
-// IsFunctionNamed reports whether obj is a package-level function
-// defined in the given package and has one of the given names.
-// It returns false if obj is nil.
-//
-// This function avoids allocating the concatenation of "pkg.Name",
-// which is important for the performance of syntax matching.
-func IsFunctionNamed(obj types.Object, pkgPath string, names ...string) bool {
-	f, ok := obj.(*types.Func)
-	return ok &&
-		IsPackageLevel(obj) &&
-		f.Pkg().Path() == pkgPath &&
-		f.Signature().Recv() == nil &&
-		slices.Contains(names, f.Name())
-}
-
-// IsMethodNamed reports whether obj is a method defined on a
-// package-level type with the given package and type name, and has
-// one of the given names. It returns false if obj is nil.
-//
-// This function avoids allocating the concatenation of "pkg.TypeName.Name",
-// which is important for the performance of syntax matching.
-func IsMethodNamed(obj types.Object, pkgPath string, typeName string, names ...string) bool {
-	if fn, ok := obj.(*types.Func); ok {
-		if recv := fn.Signature().Recv(); recv != nil {
-			_, T := ReceiverNamed(recv)
-			return T != nil &&
-				IsTypeNamed(T, pkgPath, typeName) &&
-				slices.Contains(names, fn.Name())
-		}
-	}
-	return false
-}
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/qualifier.go b/vendor/golang.org/x/tools/internal/typesinternal/qualifier.go
deleted file mode 100644
index 4e2756fc49..0000000000
--- a/vendor/golang.org/x/tools/internal/typesinternal/qualifier.go
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright 2024 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package typesinternal
-
-import (
-	"go/ast"
-	"go/types"
-	"strconv"
-)
-
-// FileQualifier returns a [types.Qualifier] function that qualifies
-// imported symbols appropriately based on the import environment of a given
-// file.
-// If the same package is imported multiple times, the last appearance is
-// recorded.
-//
-// TODO(adonovan): this function ignores the effect of shadowing. It
-// should accept a [token.Pos] and a [types.Info] and compute only the
-// set of imports that are not shadowed at that point, analogous to
-// [analysis.AddImport]. It could also compute (as a side
-// effect) the set of additional imports required to ensure that there
-// is an accessible import for each necessary package, making it
-// converge even more closely with AddImport.
-func FileQualifier(f *ast.File, pkg *types.Package) types.Qualifier {
-	// Construct mapping of import paths to their defined names.
-	// It is only necessary to look at renaming imports.
-	imports := make(map[string]string)
-	for _, imp := range f.Imports {
-		if imp.Name != nil && imp.Name.Name != "_" {
-			path, _ := strconv.Unquote(imp.Path.Value)
-			imports[path] = imp.Name.Name
-		}
-	}
-
-	// Define qualifier to replace full package paths with names of the imports.
-	return func(p *types.Package) string {
-		if p == nil || p == pkg {
-			return ""
-		}
-
-		if name, ok := imports[p.Path()]; ok {
-			if name == "." {
-				return ""
-			} else {
-				return name
-			}
-		}
-
-		// If there is no local renaming, fall back to the package name.
-		return p.Name()
-	}
-}
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/recv.go b/vendor/golang.org/x/tools/internal/typesinternal/recv.go
deleted file mode 100644
index 8352ea7617..0000000000
--- a/vendor/golang.org/x/tools/internal/typesinternal/recv.go
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright 2024 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package typesinternal
-
-import (
-	"go/types"
-)
-
-// ReceiverNamed returns the named type (if any) associated with the
-// type of recv, which may be of the form N or *N, or aliases thereof.
-// It also reports whether a Pointer was present.
-//
-// The named result may be nil if recv is from a method on an
-// anonymous interface or struct types or in ill-typed code.
-func ReceiverNamed(recv *types.Var) (isPtr bool, named *types.Named) {
-	t := recv.Type()
-	if ptr, ok := types.Unalias(t).(*types.Pointer); ok {
-		isPtr = true
-		t = ptr.Elem()
-	}
-	named, _ = types.Unalias(t).(*types.Named)
-	return
-}
-
-// Unpointer returns T given *T or an alias thereof.
-// For all other types it is the identity function.
-// It does not look at underlying types.
-// The result may be an alias.
-//
-// Use this function to strip off the optional pointer on a receiver
-// in a field or method selection, without losing the named type
-// (which is needed to compute the method set).
-//
-// See also [typeparams.MustDeref], which removes one level of
-// indirection from the type, regardless of named types (analogous to
-// a LOAD instruction).
-func Unpointer(t types.Type) types.Type {
-	if ptr, ok := types.Unalias(t).(*types.Pointer); ok {
-		return ptr.Elem()
-	}
-	return t
-}
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/toonew.go b/vendor/golang.org/x/tools/internal/typesinternal/toonew.go
deleted file mode 100644
index cc86487eaa..0000000000
--- a/vendor/golang.org/x/tools/internal/typesinternal/toonew.go
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright 2024 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package typesinternal
-
-import (
-	"go/types"
-
-	"golang.org/x/tools/internal/stdlib"
-	"golang.org/x/tools/internal/versions"
-)
-
-// TooNewStdSymbols computes the set of package-level symbols
-// exported by pkg that are not available at the specified version.
-// The result maps each symbol to its minimum version.
-//
-// The pkg is allowed to contain type errors.
-func TooNewStdSymbols(pkg *types.Package, version string) map[types.Object]string {
-	disallowed := make(map[types.Object]string)
-
-	// Pass 1: package-level symbols.
-	symbols := stdlib.PackageSymbols[pkg.Path()]
-	for _, sym := range symbols {
-		symver := sym.Version.String()
-		if versions.Before(version, symver) {
-			switch sym.Kind {
-			case stdlib.Func, stdlib.Var, stdlib.Const, stdlib.Type:
-				disallowed[pkg.Scope().Lookup(sym.Name)] = symver
-			}
-		}
-	}
-
-	// Pass 2: fields and methods.
-	//
-	// We allow fields and methods if their associated type is
-	// disallowed, as otherwise we would report false positives
-	// for compatibility shims. Consider:
-	//
-	//   //go:build go1.22
-	//   type T struct { F std.Real } // correct new API
-	//
-	//   //go:build !go1.22
-	//   type T struct { F fake } // shim
-	//   type fake struct { ... }
-	//   func (fake) M () {}
-	//
-	// These alternative declarations of T use either the std.Real
-	// type, introduced in go1.22, or a fake type, for the field
-	// F. (The fakery could be arbitrarily deep, involving more
-	// nested fields and methods than are shown here.) Clients
-	// that use the compatibility shim T will compile with any
-	// version of go, whether older or newer than go1.22, but only
-	// the newer version will use the std.Real implementation.
-	//
-	// Now consider a reference to method M in new(T).F.M() in a
-	// module that requires a minimum of go1.21. The analysis may
-	// occur using a version of Go higher than 1.21, selecting the
-	// first version of T, so the method M is Real.M. This would
-	// spuriously cause the analyzer to report a reference to a
-	// too-new symbol even though this expression compiles just
-	// fine (with the fake implementation) using go1.21.
-	for _, sym := range symbols {
-		symVersion := sym.Version.String()
-		if !versions.Before(version, symVersion) {
-			continue // allowed
-		}
-
-		var obj types.Object
-		switch sym.Kind {
-		case stdlib.Field:
-			typename, name := sym.SplitField()
-			if t := pkg.Scope().Lookup(typename); t != nil && disallowed[t] == "" {
-				obj, _, _ = types.LookupFieldOrMethod(t.Type(), false, pkg, name)
-			}
-
-		case stdlib.Method:
-			ptr, recvname, name := sym.SplitMethod()
-			if t := pkg.Scope().Lookup(recvname); t != nil && disallowed[t] == "" {
-				obj, _, _ = types.LookupFieldOrMethod(t.Type(), ptr, pkg, name)
-			}
-		}
-		if obj != nil {
-			disallowed[obj] = symVersion
-		}
-	}
-
-	return disallowed
-}
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/types.go b/vendor/golang.org/x/tools/internal/typesinternal/types.go
deleted file mode 100644
index d2c0b4c5ff..0000000000
--- a/vendor/golang.org/x/tools/internal/typesinternal/types.go
+++ /dev/null
@@ -1,272 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package typesinternal provides helpful operators for dealing with
-// go/types:
-//
-//   - operators for querying typed syntax trees (e.g. [Imports], [IsFunctionNamed]);
-//   - functions for converting types to strings or syntax (e.g. [TypeExpr], FileQualifier]);
-//   - helpers for working with the [go/types] API (e.g. [NewTypesInfo]);
-//   - access to internal go/types APIs that are not yet
-//     exported (e.g. [SetUsesCgo], [ErrorCodeStartEnd], [VarKind]); and
-//   - common algorithms related to types (e.g. [TooNewStdSymbols]).
-//
-// See also:
-//   - [golang.org/x/tools/internal/astutil], for operations on untyped syntax;
-//   - [golang.org/x/tools/internal/analysisinernal], for helpers for analyzers;
-//   - [golang.org/x/tools/internal/refactor], for operators to compute text edits.
-package typesinternal
-
-import (
-	"go/ast"
-	"go/token"
-	"go/types"
-	"iter"
-	"reflect"
-
-	"golang.org/x/tools/go/ast/inspector"
-)
-
-func SetUsesCgo(conf *types.Config) bool {
-	v := reflect.ValueOf(conf).Elem()
-
-	f := v.FieldByName("go115UsesCgo")
-	if !f.IsValid() {
-		f = v.FieldByName("UsesCgo")
-		if !f.IsValid() {
-			return false
-		}
-	}
-
-	*(*bool)(f.Addr().UnsafePointer()) = true
-
-	return true
-}
-
-// ErrorCodeStartEnd extracts additional information from types.Error values
-// generated by Go version 1.16 and later: the error code, start position, and
-// end position. If all positions are valid, start <= err.Pos <= end.
-//
-// If the data could not be read, the final result parameter will be false.
-//
-// TODO(adonovan): eliminate start/end when proposal #71803 is accepted.
-func ErrorCodeStartEnd(err types.Error) (code ErrorCode, start, end token.Pos, ok bool) {
-	var data [3]int
-	// By coincidence all of these fields are ints, which simplifies things.
-	v := reflect.ValueOf(err)
-	for i, name := range []string{"go116code", "go116start", "go116end"} {
-		f := v.FieldByName(name)
-		if !f.IsValid() {
-			return 0, 0, 0, false
-		}
-		data[i] = int(f.Int())
-	}
-	return ErrorCode(data[0]), token.Pos(data[1]), token.Pos(data[2]), true
-}
-
-// NameRelativeTo returns a types.Qualifier that qualifies members of
-// all packages other than pkg, using only the package name.
-// (By contrast, [types.RelativeTo] uses the complete package path,
-// which is often excessive.)
-//
-// If pkg is nil, it is equivalent to [*types.Package.Name].
-//
-// TODO(adonovan): all uses of this with TypeString should be
-// eliminated when https://go.dev/issues/75604 is resolved.
-func NameRelativeTo(pkg *types.Package) types.Qualifier {
-	return func(other *types.Package) string {
-		if pkg != nil && pkg == other {
-			return "" // same package; unqualified
-		}
-		return other.Name()
-	}
-}
-
-// TypeNameFor returns the type name symbol for the specified type, if
-// it is a [*types.Alias], [*types.Named], [*types.TypeParam], or a
-// [*types.Basic] representing a type.
-//
-// For all other types, and for Basic types representing a builtin,
-// constant, or nil, it returns nil. Be careful not to convert the
-// resulting nil pointer to a [types.Object]!
-//
-// If t is the type of a constant, it may be an "untyped" type, which
-// has no TypeName. To access the name of such types (e.g. "untyped
-// int"), use [types.Basic.Name].
-func TypeNameFor(t types.Type) *types.TypeName {
-	switch t := t.(type) {
-	case *types.Alias:
-		return t.Obj()
-	case *types.Named:
-		return t.Obj()
-	case *types.TypeParam:
-		return t.Obj()
-	case *types.Basic:
-		// See issues #71886 and #66890 for some history.
-		if tname, ok := types.Universe.Lookup(t.Name()).(*types.TypeName); ok {
-			return tname
-		}
-	}
-	return nil
-}
-
-// A NamedOrAlias is a [types.Type] that is named (as
-// defined by the spec) and capable of bearing type parameters: it
-// abstracts aliases ([types.Alias]) and defined types
-// ([types.Named]).
-//
-// Every type declared by an explicit "type" declaration is a
-// NamedOrAlias. (Built-in type symbols may additionally
-// have type [types.Basic], which is not a NamedOrAlias,
-// though the spec regards them as "named"; see [TypeNameFor].)
-//
-// NamedOrAlias cannot expose the Origin method, because
-// [types.Alias.Origin] and [types.Named.Origin] have different
-// (covariant) result types; use [Origin] instead.
-type NamedOrAlias interface {
-	types.Type
-	Obj() *types.TypeName
-	TypeArgs() *types.TypeList
-	TypeParams() *types.TypeParamList
-	SetTypeParams(tparams []*types.TypeParam)
-}
-
-var (
-	_ NamedOrAlias = (*types.Alias)(nil)
-	_ NamedOrAlias = (*types.Named)(nil)
-)
-
-// Origin returns the generic type of the Named or Alias type t if it
-// is instantiated, otherwise it returns t.
-func Origin(t NamedOrAlias) NamedOrAlias {
-	switch t := t.(type) {
-	case *types.Alias:
-		return t.Origin()
-	case *types.Named:
-		return t.Origin()
-	}
-	return t
-}
-
-// IsPackageLevel reports whether obj is a package-level symbol.
-func IsPackageLevel(obj types.Object) bool {
-	return obj.Pkg() != nil && obj.Parent() == obj.Pkg().Scope()
-}
-
-// NewTypesInfo returns a *types.Info with all maps populated.
-func NewTypesInfo() *types.Info {
-	return &types.Info{
-		Types:        map[ast.Expr]types.TypeAndValue{},
-		Instances:    map[*ast.Ident]types.Instance{},
-		Defs:         map[*ast.Ident]types.Object{},
-		Uses:         map[*ast.Ident]types.Object{},
-		Implicits:    map[ast.Node]types.Object{},
-		Selections:   map[*ast.SelectorExpr]*types.Selection{},
-		Scopes:       map[ast.Node]*types.Scope{},
-		FileVersions: map[*ast.File]string{},
-	}
-}
-
-// EnclosingScope returns the innermost block logically enclosing the cursor.
-func EnclosingScope(info *types.Info, cur inspector.Cursor) *types.Scope {
-	for cur := range cur.Enclosing() {
-		n := cur.Node()
-		// A function's Scope is associated with its FuncType.
-		switch f := n.(type) {
-		case *ast.FuncDecl:
-			n = f.Type
-		case *ast.FuncLit:
-			n = f.Type
-		}
-		if b := info.Scopes[n]; b != nil {
-			return b
-		}
-	}
-	panic("no Scope for *ast.File")
-}
-
-// Imports reports whether path is imported by pkg.
-func Imports(pkg *types.Package, path string) bool {
-	for _, imp := range pkg.Imports() {
-		if imp.Path() == path {
-			return true
-		}
-	}
-	return false
-}
-
-// ObjectKind returns a description of the object's kind.
-//
-// from objectKind in go/types
-func ObjectKind(obj types.Object) string {
-	switch obj := obj.(type) {
-	case *types.PkgName:
-		return "package name"
-	case *types.Const:
-		return "constant"
-	case *types.TypeName:
-		if obj.IsAlias() {
-			return "type alias"
-		} else if _, ok := obj.Type().(*types.TypeParam); ok {
-			return "type parameter"
-		} else {
-			return "defined type"
-		}
-	case *types.Var:
-		switch obj.Kind() {
-		case PackageVar:
-			return "package-level variable"
-		case LocalVar:
-			return "local variable"
-		case RecvVar:
-			return "receiver"
-		case ParamVar:
-			return "parameter"
-		case ResultVar:
-			return "result variable"
-		case FieldVar:
-			return "struct field"
-		}
-	case *types.Func:
-		if obj.Signature().Recv() != nil {
-			return "method"
-		} else {
-			return "function"
-		}
-	case *types.Label:
-		return "label"
-	case *types.Builtin:
-		return "built-in function"
-	case *types.Nil:
-		return "untyped nil"
-	}
-	return "unknown symbol"
-}
-
-// ImplicitFieldSelections returns the sequence of implicit embedded fields
-// traversed by the given selection. It skips the final leaf field or method.
-// The boolean component indicates whether the traversal traversed a pointer.
-func ImplicitFieldSelections(seln types.Selection) iter.Seq2[*types.Var, bool] {
-	return func(yield func(*types.Var, bool) bool) {
-		var (
-			t       = seln.Recv()
-			indices = seln.Index()
-		)
-		for _, idx := range indices[:len(indices)-1] {
-			ptr, isPtr := t.Underlying().(*types.Pointer)
-			if isPtr {
-				t = ptr.Elem()
-			}
-			structType, ok := t.Underlying().(*types.Struct)
-			if !ok {
-				break
-			}
-			field := structType.Field(idx)
-			if !yield(field, isPtr) {
-				break
-			}
-			t = field.Type()
-		}
-	}
-}
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/varkind.go b/vendor/golang.org/x/tools/internal/typesinternal/varkind.go
deleted file mode 100644
index 26499cdd2e..0000000000
--- a/vendor/golang.org/x/tools/internal/typesinternal/varkind.go
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright 2024 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build go1.25
-
-package typesinternal
-
-import "go/types"
-
-type VarKind = types.VarKind
-
-const (
-	PackageVar = types.PackageVar
-	LocalVar   = types.LocalVar
-	RecvVar    = types.RecvVar
-	ParamVar   = types.ParamVar
-	ResultVar  = types.ResultVar
-	FieldVar   = types.FieldVar
-)
-
-func GetVarKind(v *types.Var) VarKind       { return v.Kind() }
-func SetVarKind(v *types.Var, kind VarKind) { v.SetKind(kind) }
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/varkind_go124.go b/vendor/golang.org/x/tools/internal/typesinternal/varkind_go124.go
deleted file mode 100644
index 17b1804b4e..0000000000
--- a/vendor/golang.org/x/tools/internal/typesinternal/varkind_go124.go
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright 2024 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build !go1.25
-
-package typesinternal
-
-import "go/types"
-
-type VarKind uint8
-
-const (
-	_          VarKind = iota // (not meaningful)
-	PackageVar                // a package-level variable
-	LocalVar                  // a local variable
-	RecvVar                   // a method receiver variable
-	ParamVar                  // a function parameter variable
-	ResultVar                 // a function result variable
-	FieldVar                  // a struct field
-)
-
-func (kind VarKind) String() string {
-	return [...]string{
-		0:          "VarKind(0)",
-		PackageVar: "PackageVar",
-		LocalVar:   "LocalVar",
-		RecvVar:    "RecvVar",
-		ParamVar:   "ParamVar",
-		ResultVar:  "ResultVar",
-		FieldVar:   "FieldVar",
-	}[kind]
-}
-
-// GetVarKind returns an invalid VarKind.
-func GetVarKind(v *types.Var) VarKind { return 0 }
-
-// SetVarKind has no effect.
-func SetVarKind(v *types.Var, kind VarKind) {}
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/zerovalue.go b/vendor/golang.org/x/tools/internal/typesinternal/zerovalue.go
deleted file mode 100644
index d612a71029..0000000000
--- a/vendor/golang.org/x/tools/internal/typesinternal/zerovalue.go
+++ /dev/null
@@ -1,381 +0,0 @@
-// Copyright 2024 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package typesinternal
-
-import (
-	"fmt"
-	"go/ast"
-	"go/token"
-	"go/types"
-	"strings"
-)
-
-// ZeroString returns the string representation of the zero value for any type t.
-// The boolean result indicates whether the type is or contains an invalid type
-// or a non-basic (constraint) interface type.
-//
-// Even for invalid input types, ZeroString may return a partially correct
-// string representation. The caller should use the returned isValid boolean
-// to determine the validity of the expression.
-//
-// When assigning to a wider type (such as 'any'), it's the caller's
-// responsibility to handle any necessary type conversions.
-//
-// This string can be used on the right-hand side of an assignment where the
-// left-hand side has that explicit type.
-// References to named types are qualified by an appropriate (optional)
-// qualifier function.
-// Exception: This does not apply to tuples. Their string representation is
-// informational only and cannot be used in an assignment.
-//
-// See [ZeroExpr] for a variant that returns an [ast.Expr].
-func ZeroString(t types.Type, qual types.Qualifier) (_ string, isValid bool) {
-	switch t := t.(type) {
-	case *types.Basic:
-		switch {
-		case t.Info()&types.IsBoolean != 0:
-			return "false", true
-		case t.Info()&types.IsNumeric != 0:
-			return "0", true
-		case t.Info()&types.IsString != 0:
-			return `""`, true
-		case t.Kind() == types.UnsafePointer:
-			fallthrough
-		case t.Kind() == types.UntypedNil:
-			return "nil", true
-		case t.Kind() == types.Invalid:
-			return "invalid", false
-		default:
-			panic(fmt.Sprintf("ZeroString for unexpected type %v", t))
-		}
-
-	case *types.Pointer, *types.Slice, *types.Chan, *types.Map, *types.Signature:
-		return "nil", true
-
-	case *types.Interface:
-		if !t.IsMethodSet() {
-			return "invalid", false
-		}
-		return "nil", true
-
-	case *types.Named:
-		switch under := t.Underlying().(type) {
-		case *types.Struct, *types.Array:
-			return types.TypeString(t, qual) + "{}", true
-		default:
-			return ZeroString(under, qual)
-		}
-
-	case *types.Alias:
-		switch t.Underlying().(type) {
-		case *types.Struct, *types.Array:
-			return types.TypeString(t, qual) + "{}", true
-		default:
-			// A type parameter can have alias but alias type's underlying type
-			// can never be a type parameter.
-			// Use types.Unalias to preserve the info of type parameter instead
-			// of call Underlying() going right through and get the underlying
-			// type of the type parameter which is always an interface.
-			return ZeroString(types.Unalias(t), qual)
-		}
-
-	case *types.Array, *types.Struct:
-		return types.TypeString(t, qual) + "{}", true
-
-	case *types.TypeParam:
-		// Assumes func new is not shadowed.
-		return "*new(" + types.TypeString(t, qual) + ")", true
-
-	case *types.Tuple:
-		// Tuples are not normal values.
-		// We are currently format as "(t[0], ..., t[n])". Could be something else.
-		isValid := true
-		components := make([]string, t.Len())
-		for i := 0; i < t.Len(); i++ {
-			comp, ok := ZeroString(t.At(i).Type(), qual)
-
-			components[i] = comp
-			isValid = isValid && ok
-		}
-		return "(" + strings.Join(components, ", ") + ")", isValid
-
-	case *types.Union:
-		// Variables of these types cannot be created, so it makes
-		// no sense to ask for their zero value.
-		panic(fmt.Sprintf("invalid type for a variable: %v", t))
-
-	default:
-		panic(t) // unreachable.
-	}
-}
-
-// ZeroExpr returns the ast.Expr representation of the zero value for any type t.
-// The boolean result indicates whether the type is or contains an invalid type
-// or a non-basic (constraint) interface type.
-//
-// Even for invalid input types, ZeroExpr may return a partially correct ast.Expr
-// representation. The caller should use the returned isValid boolean to determine
-// the validity of the expression.
-//
-// This function is designed for types suitable for variables and should not be
-// used with Tuple or Union types.References to named types are qualified by an
-// appropriate (optional) qualifier function.
-//
-// See [ZeroString] for a variant that returns a string.
-func ZeroExpr(t types.Type, qual types.Qualifier) (_ ast.Expr, isValid bool) {
-	switch t := t.(type) {
-	case *types.Basic:
-		switch {
-		case t.Info()&types.IsBoolean != 0:
-			return &ast.Ident{Name: "false"}, true
-		case t.Info()&types.IsNumeric != 0:
-			return &ast.BasicLit{Kind: token.INT, Value: "0"}, true
-		case t.Info()&types.IsString != 0:
-			return &ast.BasicLit{Kind: token.STRING, Value: `""`}, true
-		case t.Kind() == types.UnsafePointer:
-			fallthrough
-		case t.Kind() == types.UntypedNil:
-			return ast.NewIdent("nil"), true
-		case t.Kind() == types.Invalid:
-			return &ast.BasicLit{Kind: token.STRING, Value: `"invalid"`}, false
-		default:
-			panic(fmt.Sprintf("ZeroExpr for unexpected type %v", t))
-		}
-
-	case *types.Pointer, *types.Slice, *types.Chan, *types.Map, *types.Signature:
-		return ast.NewIdent("nil"), true
-
-	case *types.Interface:
-		if !t.IsMethodSet() {
-			return &ast.BasicLit{Kind: token.STRING, Value: `"invalid"`}, false
-		}
-		return ast.NewIdent("nil"), true
-
-	case *types.Named:
-		switch under := t.Underlying().(type) {
-		case *types.Struct, *types.Array:
-			return &ast.CompositeLit{
-				Type: TypeExpr(t, qual),
-			}, true
-		default:
-			return ZeroExpr(under, qual)
-		}
-
-	case *types.Alias:
-		switch t.Underlying().(type) {
-		case *types.Struct, *types.Array:
-			return &ast.CompositeLit{
-				Type: TypeExpr(t, qual),
-			}, true
-		default:
-			return ZeroExpr(types.Unalias(t), qual)
-		}
-
-	case *types.Array, *types.Struct:
-		return &ast.CompositeLit{
-			Type: TypeExpr(t, qual),
-		}, true
-
-	case *types.TypeParam:
-		return &ast.StarExpr{ // *new(T)
-			X: &ast.CallExpr{
-				// Assumes func new is not shadowed.
-				Fun: ast.NewIdent("new"),
-				Args: []ast.Expr{
-					ast.NewIdent(t.Obj().Name()),
-				},
-			},
-		}, true
-
-	case *types.Tuple:
-		// Unlike ZeroString, there is no ast.Expr can express tuple by
-		// "(t[0], ..., t[n])".
-		panic(fmt.Sprintf("invalid type for a variable: %v", t))
-
-	case *types.Union:
-		// Variables of these types cannot be created, so it makes
-		// no sense to ask for their zero value.
-		panic(fmt.Sprintf("invalid type for a variable: %v", t))
-
-	default:
-		panic(t) // unreachable.
-	}
-}
-
-// TypeExpr returns syntax for the specified type. References to named types
-// are qualified by an appropriate (optional) qualifier function.
-// It may panic for types such as Tuple or Union.
-//
-// See also https://go.dev/issues/75604, which will provide a robust
-// Type-to-valid-Go-syntax formatter.
-func TypeExpr(t types.Type, qual types.Qualifier) ast.Expr {
-	switch t := t.(type) {
-	case *types.Basic:
-		switch t.Kind() {
-		case types.UnsafePointer:
-			return &ast.SelectorExpr{X: ast.NewIdent(qual(types.NewPackage("unsafe", "unsafe"))), Sel: ast.NewIdent("Pointer")}
-		default:
-			return ast.NewIdent(t.Name())
-		}
-
-	case *types.Pointer:
-		return &ast.UnaryExpr{
-			Op: token.MUL,
-			X:  TypeExpr(t.Elem(), qual),
-		}
-
-	case *types.Array:
-		return &ast.ArrayType{
-			Len: &ast.BasicLit{
-				Kind:  token.INT,
-				Value: fmt.Sprintf("%d", t.Len()),
-			},
-			Elt: TypeExpr(t.Elem(), qual),
-		}
-
-	case *types.Slice:
-		return &ast.ArrayType{
-			Elt: TypeExpr(t.Elem(), qual),
-		}
-
-	case *types.Map:
-		return &ast.MapType{
-			Key:   TypeExpr(t.Key(), qual),
-			Value: TypeExpr(t.Elem(), qual),
-		}
-
-	case *types.Chan:
-		dir := ast.ChanDir(t.Dir())
-		if t.Dir() == types.SendRecv {
-			dir = ast.SEND | ast.RECV
-		}
-		return &ast.ChanType{
-			Dir:   dir,
-			Value: TypeExpr(t.Elem(), qual),
-		}
-
-	case *types.Signature:
-		var params []*ast.Field
-		for v := range t.Params().Variables() {
-			params = append(params, &ast.Field{
-				Type: TypeExpr(v.Type(), qual),
-				Names: []*ast.Ident{
-					{
-						Name: v.Name(),
-					},
-				},
-			})
-		}
-		if t.Variadic() {
-			last := params[len(params)-1]
-			last.Type = &ast.Ellipsis{Elt: last.Type.(*ast.ArrayType).Elt}
-		}
-		var returns []*ast.Field
-		for v := range t.Results().Variables() {
-			returns = append(returns, &ast.Field{
-				Type: TypeExpr(v.Type(), qual),
-			})
-		}
-		return &ast.FuncType{
-			Params: &ast.FieldList{
-				List: params,
-			},
-			Results: &ast.FieldList{
-				List: returns,
-			},
-		}
-
-	case *types.TypeParam:
-		pkgName := qual(t.Obj().Pkg())
-		if pkgName == "" || t.Obj().Pkg() == nil {
-			return ast.NewIdent(t.Obj().Name())
-		}
-		return &ast.SelectorExpr{
-			X:   ast.NewIdent(pkgName),
-			Sel: ast.NewIdent(t.Obj().Name()),
-		}
-
-	// types.TypeParam also implements interface NamedOrAlias. To differentiate,
-	// case TypeParam need to be present before case NamedOrAlias.
-	// TODO(hxjiang): remove this comment once TypeArgs() is added to interface
-	// NamedOrAlias.
-	case NamedOrAlias:
-		var expr ast.Expr = ast.NewIdent(t.Obj().Name())
-		if pkgName := qual(t.Obj().Pkg()); pkgName != "." && pkgName != "" {
-			expr = &ast.SelectorExpr{
-				X:   ast.NewIdent(pkgName),
-				Sel: expr.(*ast.Ident),
-			}
-		}
-
-		// TODO(hxjiang): call t.TypeArgs after adding method TypeArgs() to
-		// typesinternal.NamedOrAlias.
-		if hasTypeArgs, ok := t.(interface{ TypeArgs() *types.TypeList }); ok {
-			if typeArgs := hasTypeArgs.TypeArgs(); typeArgs != nil && typeArgs.Len() > 0 {
-				var indices []ast.Expr
-				for t0 := range typeArgs.Types() {
-					indices = append(indices, TypeExpr(t0, qual))
-				}
-				expr = &ast.IndexListExpr{
-					X:       expr,
-					Indices: indices,
-				}
-			}
-		}
-
-		return expr
-
-	case *types.Struct:
-		return ast.NewIdent(t.String())
-
-	case *types.Interface:
-		return ast.NewIdent(t.String())
-
-	case *types.Union:
-		if t.Len() == 0 {
-			panic("Union type should have at least one term")
-		}
-		// Same as go/ast, the return expression will put last term in the
-		// Y field at topmost level of BinaryExpr.
-		// For union of type "float32 | float64 | int64", the structure looks
-		// similar to:
-		// {
-		// 	X: {
-		// 		X: float32,
-		// 		Op: |
-		// 		Y: float64,
-		// 	}
-		// 	Op: |,
-		// 	Y: int64,
-		// }
-		var union ast.Expr
-		for i := range t.Len() {
-			term := t.Term(i)
-			termExpr := TypeExpr(term.Type(), qual)
-			if term.Tilde() {
-				termExpr = &ast.UnaryExpr{
-					Op: token.TILDE,
-					X:  termExpr,
-				}
-			}
-			if i == 0 {
-				union = termExpr
-			} else {
-				union = &ast.BinaryExpr{
-					X:  union,
-					Op: token.OR,
-					Y:  termExpr,
-				}
-			}
-		}
-		return union
-
-	case *types.Tuple:
-		panic("invalid input type types.Tuple")
-
-	default:
-		panic("unreachable")
-	}
-}
diff --git a/vendor/golang.org/x/tools/internal/versions/features.go b/vendor/golang.org/x/tools/internal/versions/features.go
deleted file mode 100644
index 360a5b5529..0000000000
--- a/vendor/golang.org/x/tools/internal/versions/features.go
+++ /dev/null
@@ -1,49 +0,0 @@
-// Copyright 2023 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package versions
-
-// This file contains predicates for working with file versions to
-// decide when a tool should consider a language feature enabled.
-
-// named constants, to avoid misspelling
-const (
-	Go1_17 = "go1.17"
-	Go1_18 = "go1.18"
-	Go1_19 = "go1.19"
-	Go1_20 = "go1.20"
-	Go1_21 = "go1.21"
-	Go1_22 = "go1.22"
-	Go1_23 = "go1.23"
-	Go1_24 = "go1.24"
-	Go1_25 = "go1.25"
-	Go1_26 = "go1.26"
-	Go1_27 = "go1.27"
-)
-
-// Future is an invalid unknown Go version sometime in the future.
-// Do not use directly with Compare.
-const Future = ""
-
-// AtLeast reports whether the file version v comes after a Go release.
-//
-// Use this predicate to enable a behavior once a certain Go release
-// has happened (and stays enabled in the future).
-func AtLeast(v, release string) bool {
-	if v == Future {
-		return true // an unknown future version is always after y.
-	}
-	return Compare(Lang(v), Lang(release)) >= 0
-}
-
-// Before reports whether the file version v is strictly before a Go release.
-//
-// Use this predicate to disable a behavior once a certain Go release
-// has happened (and stays enabled in the future).
-func Before(v, release string) bool {
-	if v == Future {
-		return false // an unknown future version happens after y.
-	}
-	return Compare(Lang(v), Lang(release)) < 0
-}
diff --git a/vendor/golang.org/x/tools/internal/versions/gover.go b/vendor/golang.org/x/tools/internal/versions/gover.go
deleted file mode 100644
index bbabcd22e9..0000000000
--- a/vendor/golang.org/x/tools/internal/versions/gover.go
+++ /dev/null
@@ -1,172 +0,0 @@
-// Copyright 2023 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This is a fork of internal/gover for use by x/tools until
-// go1.21 and earlier are no longer supported by x/tools.
-
-package versions
-
-import "strings"
-
-// A gover is a parsed Go gover: major[.Minor[.Patch]][kind[pre]]
-// The numbers are the original decimal strings to avoid integer overflows
-// and since there is very little actual math. (Probably overflow doesn't matter in practice,
-// but at the time this code was written, there was an existing test that used
-// go1.99999999999, which does not fit in an int on 32-bit platforms.
-// The "big decimal" representation avoids the problem entirely.)
-type gover struct {
-	major string // decimal
-	minor string // decimal or ""
-	patch string // decimal or ""
-	kind  string // "", "alpha", "beta", "rc"
-	pre   string // decimal or ""
-}
-
-// compare returns -1, 0, or +1 depending on whether
-// x < y, x == y, or x > y, interpreted as toolchain versions.
-// The versions x and y must not begin with a "go" prefix: just "1.21" not "go1.21".
-// Malformed versions compare less than well-formed versions and equal to each other.
-// The language version "1.21" compares less than the release candidate and eventual releases "1.21rc1" and "1.21.0".
-func compare(x, y string) int {
-	vx := parse(x)
-	vy := parse(y)
-
-	if c := cmpInt(vx.major, vy.major); c != 0 {
-		return c
-	}
-	if c := cmpInt(vx.minor, vy.minor); c != 0 {
-		return c
-	}
-	if c := cmpInt(vx.patch, vy.patch); c != 0 {
-		return c
-	}
-	if c := strings.Compare(vx.kind, vy.kind); c != 0 { // "" < alpha < beta < rc
-		return c
-	}
-	if c := cmpInt(vx.pre, vy.pre); c != 0 {
-		return c
-	}
-	return 0
-}
-
-// lang returns the Go language version. For example, lang("1.2.3") == "1.2".
-func lang(x string) string {
-	v := parse(x)
-	if v.minor == "" || v.major == "1" && v.minor == "0" {
-		return v.major
-	}
-	return v.major + "." + v.minor
-}
-
-// isValid reports whether the version x is valid.
-func isValid(x string) bool {
-	return parse(x) != gover{}
-}
-
-// parse parses the Go version string x into a version.
-// It returns the zero version if x is malformed.
-func parse(x string) gover {
-	var v gover
-
-	// Parse major version.
-	var ok bool
-	v.major, x, ok = cutInt(x)
-	if !ok {
-		return gover{}
-	}
-	if x == "" {
-		// Interpret "1" as "1.0.0".
-		v.minor = "0"
-		v.patch = "0"
-		return v
-	}
-
-	// Parse . before minor version.
-	if x[0] != '.' {
-		return gover{}
-	}
-
-	// Parse minor version.
-	v.minor, x, ok = cutInt(x[1:])
-	if !ok {
-		return gover{}
-	}
-	if x == "" {
-		// Patch missing is same as "0" for older versions.
-		// Starting in Go 1.21, patch missing is different from explicit .0.
-		if cmpInt(v.minor, "21") < 0 {
-			v.patch = "0"
-		}
-		return v
-	}
-
-	// Parse patch if present.
-	if x[0] == '.' {
-		v.patch, x, ok = cutInt(x[1:])
-		if !ok || x != "" {
-			// Note that we are disallowing prereleases (alpha, beta, rc) for patch releases here (x != "").
-			// Allowing them would be a bit confusing because we already have:
-			//	1.21 < 1.21rc1
-			// But a prerelease of a patch would have the opposite effect:
-			//	1.21.3rc1 < 1.21.3
-			// We've never needed them before, so let's not start now.
-			return gover{}
-		}
-		return v
-	}
-
-	// Parse prerelease.
-	i := 0
-	for i < len(x) && (x[i] < '0' || '9' < x[i]) {
-		if x[i] < 'a' || 'z' < x[i] {
-			return gover{}
-		}
-		i++
-	}
-	if i == 0 {
-		return gover{}
-	}
-	v.kind, x = x[:i], x[i:]
-	if x == "" {
-		return v
-	}
-	v.pre, x, ok = cutInt(x)
-	if !ok || x != "" {
-		return gover{}
-	}
-
-	return v
-}
-
-// cutInt scans the leading decimal number at the start of x to an integer
-// and returns that value and the rest of the string.
-func cutInt(x string) (n, rest string, ok bool) {
-	i := 0
-	for i < len(x) && '0' <= x[i] && x[i] <= '9' {
-		i++
-	}
-	if i == 0 || x[0] == '0' && i != 1 { // no digits or unnecessary leading zero
-		return "", "", false
-	}
-	return x[:i], x[i:], true
-}
-
-// cmpInt returns cmp.Compare(x, y) interpreting x and y as decimal numbers.
-// (Copied from golang.org/x/mod/semver's compareInt.)
-func cmpInt(x, y string) int {
-	if x == y {
-		return 0
-	}
-	if len(x) < len(y) {
-		return -1
-	}
-	if len(x) > len(y) {
-		return +1
-	}
-	if x < y {
-		return -1
-	} else {
-		return +1
-	}
-}
diff --git a/vendor/golang.org/x/tools/internal/versions/types.go b/vendor/golang.org/x/tools/internal/versions/types.go
deleted file mode 100644
index 0fc10ce4eb..0000000000
--- a/vendor/golang.org/x/tools/internal/versions/types.go
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright 2023 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package versions
-
-import (
-	"go/ast"
-	"go/types"
-)
-
-// FileVersion returns a file's Go version.
-// The reported version is an unknown Future version if a
-// version cannot be determined.
-func FileVersion(info *types.Info, file *ast.File) string {
-	// In tools built with Go >= 1.22, the Go version of a file
-	// follow a cascades of sources:
-	// 1) types.Info.FileVersion, which follows the cascade:
-	//   1.a) file version (ast.File.GoVersion),
-	//   1.b) the package version (types.Config.GoVersion), or
-	// 2) is some unknown Future version.
-	//
-	// File versions require a valid package version to be provided to types
-	// in Config.GoVersion. Config.GoVersion is either from the package's module
-	// or the toolchain (go run). This value should be provided by go/packages
-	// or unitchecker.Config.GoVersion.
-	if v := info.FileVersions[file]; IsValid(v) {
-		return v
-	}
-	// Note: we could instead return runtime.Version() [if valid].
-	// This would act as a max version on what a tool can support.
-	return Future
-}
diff --git a/vendor/golang.org/x/tools/internal/versions/versions.go b/vendor/golang.org/x/tools/internal/versions/versions.go
deleted file mode 100644
index 8d1f7453db..0000000000
--- a/vendor/golang.org/x/tools/internal/versions/versions.go
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2023 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package versions
-
-import (
-	"strings"
-)
-
-// Note: If we use build tags to use go/versions when go >=1.22,
-// we run into go.dev/issue/53737. Under some operations users would see an
-// import of "go/versions" even if they would not compile the file.
-// For example, during `go get -u ./...` (go.dev/issue/64490) we do not try to include
-// For this reason, this library just a clone of go/versions for the moment.
-
-// Lang returns the Go language version for version x.
-// If x is not a valid version, Lang returns the empty string.
-// For example:
-//
-//	Lang("go1.21rc2") = "go1.21"
-//	Lang("go1.21.2") = "go1.21"
-//	Lang("go1.21") = "go1.21"
-//	Lang("go1") = "go1"
-//	Lang("bad") = ""
-//	Lang("1.21") = ""
-func Lang(x string) string {
-	v := lang(stripGo(x))
-	if v == "" {
-		return ""
-	}
-	return x[:2+len(v)] // "go"+v without allocation
-}
-
-// Compare returns -1, 0, or +1 depending on whether
-// x < y, x == y, or x > y, interpreted as Go versions.
-// The versions x and y must begin with a "go" prefix: "go1.21" not "1.21".
-// Invalid versions, including the empty string, compare less than
-// valid versions and equal to each other.
-// The language version "go1.21" compares less than the
-// release candidate and eventual releases "go1.21rc1" and "go1.21.0".
-// Custom toolchain suffixes are ignored during comparison:
-// "go1.21.0" and "go1.21.0-bigcorp" are equal.
-func Compare(x, y string) int { return compare(stripGo(x), stripGo(y)) }
-
-// IsValid reports whether the version x is valid.
-func IsValid(x string) bool { return isValid(stripGo(x)) }
-
-// stripGo converts from a "go1.21" version to a "1.21" version.
-// If v does not start with "go", stripGo returns the empty string (a known invalid version).
-func stripGo(v string) string {
-	v, _, _ = strings.Cut(v, "-") // strip -bigcorp suffix.
-	if len(v) < 2 || v[:2] != "go" {
-		return ""
-	}
-	return v[2:]
-}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 03e12c8dda..c377f2c8db 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -94,15 +94,12 @@ github.com/jedisct1/xsecretbox
 # github.com/k-sone/critbitgo v1.4.0
 ## explicit
 github.com/k-sone/critbitgo
-# github.com/kardianos/service v1.2.4
+# github.com/kardianos/service v1.3.0
 ## explicit; go 1.23.0
 github.com/kardianos/service
 # github.com/lifenjoiner/dhcpdns v0.0.7
 ## explicit; go 1.20
 github.com/lifenjoiner/dhcpdns
-# github.com/miekg/dns v1.1.72
-## explicit; go 1.24.0
-github.com/miekg/dns
 # github.com/pkg/errors v0.9.1
 ## explicit
 github.com/pkg/errors
@@ -162,9 +159,6 @@ golang.org/x/crypto/pbkdf2
 golang.org/x/crypto/poly1305
 golang.org/x/crypto/salsa20/salsa
 golang.org/x/crypto/scrypt
-# golang.org/x/mod v0.37.0
-## explicit; go 1.25.0
-golang.org/x/mod/semver
 # golang.org/x/net v0.56.0
 ## explicit; go 1.25.0
 golang.org/x/net/bpf
@@ -180,9 +174,6 @@ golang.org/x/net/internal/socks
 golang.org/x/net/ipv4
 golang.org/x/net/ipv6
 golang.org/x/net/proxy
-# golang.org/x/sync v0.21.0
-## explicit; go 1.25.0
-golang.org/x/sync/errgroup
 # golang.org/x/sys v0.46.0
 ## explicit; go 1.25.0
 golang.org/x/sys/cpu
@@ -198,27 +189,6 @@ golang.org/x/text/secure/bidirule
 golang.org/x/text/transform
 golang.org/x/text/unicode/bidi
 golang.org/x/text/unicode/norm
-# golang.org/x/tools v0.46.0
-## explicit; go 1.25.0
-golang.org/x/tools/go/ast/edge
-golang.org/x/tools/go/ast/inspector
-golang.org/x/tools/go/gcexportdata
-golang.org/x/tools/go/packages
-golang.org/x/tools/go/types/objectpath
-golang.org/x/tools/go/types/typeutil
-golang.org/x/tools/internal/aliases
-golang.org/x/tools/internal/event
-golang.org/x/tools/internal/event/core
-golang.org/x/tools/internal/event/keys
-golang.org/x/tools/internal/event/label
-golang.org/x/tools/internal/gcimporter
-golang.org/x/tools/internal/gocommand
-golang.org/x/tools/internal/packagesinternal
-golang.org/x/tools/internal/pkgbits
-golang.org/x/tools/internal/stdlib
-golang.org/x/tools/internal/typeparams
-golang.org/x/tools/internal/typesinternal
-golang.org/x/tools/internal/versions
 # google.golang.org/genproto/googleapis/rpc v0.0.0-20260618152121-87f3d3e198d3
 ## explicit; go 1.25.0
 google.golang.org/genproto/googleapis/rpc/status