[chore] remove vendor

103 files changed, 0 insertions, 44189 deletions

diff --git a/vendor/golang.org/x/tools/LICENSE b/vendor/golang.org/x/tools/LICENSE
deleted file mode 100644
index 2a7cf70da..000000000
--- 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 733099041..000000000
--- 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/astutil/enclosing.go b/vendor/golang.org/x/tools/go/ast/astutil/enclosing.go
deleted file mode 100644
index 0fb4e7eea..000000000
--- a/vendor/golang.org/x/tools/go/ast/astutil/enclosing.go
+++ /dev/null
@@ -1,663 +0,0 @@
-// Copyright 2013 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 astutil
-
-// This file defines utilities for working with source positions.
-
-import (
-	"fmt"
-	"go/ast"
-	"go/token"
-	"sort"
-)
-
-// PathEnclosingInterval returns the node that encloses the source
-// interval [start, end), and all its ancestors up to the AST root.
-//
-// The definition of "enclosing" used by this function considers
-// additional whitespace abutting a node to be enclosed by it.
-// In this example:
-//
-//	z := x + y // add them
-//	     <-A->
-//	    <----B----->
-//
-// the ast.BinaryExpr(+) node is considered to enclose interval B
-// even though its [Pos()..End()) is actually only interval A.
-// This behaviour makes user interfaces more tolerant of imperfect
-// input.
-//
-// This function treats tokens as nodes, though they are not included
-// in the result. e.g. PathEnclosingInterval("+") returns the
-// enclosing ast.BinaryExpr("x + y").
-//
-// If start==end, the 1-char interval following start is used instead.
-//
-// The 'exact' result is true if the interval contains only path[0]
-// and perhaps some adjacent whitespace.  It is false if the interval
-// overlaps multiple children of path[0], or if it contains only
-// interior whitespace of path[0].
-// In this example:
-//
-//	z := x + y // add them
-//	  <--C-->     <---E-->
-//	    ^
-//	    D
-//
-// intervals C, D and E are inexact.  C is contained by the
-// z-assignment statement, because it spans three of its children (:=,
-// x, +).  So too is the 1-char interval D, because it contains only
-// interior whitespace of the assignment.  E is considered interior
-// whitespace of the BlockStmt containing the assignment.
-//
-// The resulting path is never empty; it always contains at least the
-// 'root' *ast.File.  Ideally PathEnclosingInterval would reject
-// intervals that lie wholly or partially outside the range of the
-// file, but unfortunately ast.File records only the token.Pos of
-// the 'package' keyword, but not of the start of the file itself.
-func PathEnclosingInterval(root *ast.File, start, end token.Pos) (path []ast.Node, exact bool) {
-	// fmt.Printf("EnclosingInterval %d %d\n", start, end) // debugging
-
-	// Precondition: node.[Pos..End) and adjoining whitespace contain [start, end).
-	var visit func(node ast.Node) bool
-	visit = func(node ast.Node) bool {
-		path = append(path, node)
-
-		nodePos := node.Pos()
-		nodeEnd := node.End()
-
-		// fmt.Printf("visit(%T, %d, %d)\n", node, nodePos, nodeEnd) // debugging
-
-		// Intersect [start, end) with interval of node.
-		if start < nodePos {
-			start = nodePos
-		}
-		if end > nodeEnd {
-			end = nodeEnd
-		}
-
-		// Find sole child that contains [start, end).
-		children := childrenOf(node)
-		l := len(children)
-		for i, child := range children {
-			// [childPos, childEnd) is unaugmented interval of child.
-			childPos := child.Pos()
-			childEnd := child.End()
-
-			// [augPos, augEnd) is whitespace-augmented interval of child.
-			augPos := childPos
-			augEnd := childEnd
-			if i > 0 {
-				augPos = children[i-1].End() // start of preceding whitespace
-			}
-			if i < l-1 {
-				nextChildPos := children[i+1].Pos()
-				// Does [start, end) lie between child and next child?
-				if start >= augEnd && end <= nextChildPos {
-					return false // inexact match
-				}
-				augEnd = nextChildPos // end of following whitespace
-			}
-
-			// fmt.Printf("\tchild %d: [%d..%d)\tcontains interval [%d..%d)?\n",
-			// 	i, augPos, augEnd, start, end) // debugging
-
-			// Does augmented child strictly contain [start, end)?
-			if augPos <= start && end <= augEnd {
-				if is[tokenNode](child) {
-					return true
-				}
-
-				// childrenOf elides the FuncType node beneath FuncDecl.
-				// Add it back here for TypeParams, Params, Results,
-				// all FieldLists). But we don't add it back for the "func" token
-				// even though it is the tree at FuncDecl.Type.Func.
-				if decl, ok := node.(*ast.FuncDecl); ok {
-					if fields, ok := child.(*ast.FieldList); ok && fields != decl.Recv {
-						path = append(path, decl.Type)
-					}
-				}
-
-				return visit(child)
-			}
-
-			// Does [start, end) overlap multiple children?
-			// i.e. left-augmented child contains start
-			// but LR-augmented child does not contain end.
-			if start < childEnd && end > augEnd {
-				break
-			}
-		}
-
-		// No single child contained [start, end),
-		// so node is the result.  Is it exact?
-
-		// (It's tempting to put this condition before the
-		// child loop, but it gives the wrong result in the
-		// case where a node (e.g. ExprStmt) and its sole
-		// child have equal intervals.)
-		if start == nodePos && end == nodeEnd {
-			return true // exact match
-		}
-
-		return false // inexact: overlaps multiple children
-	}
-
-	// Ensure [start,end) is nondecreasing.
-	if start > end {
-		start, end = end, start
-	}
-
-	if start < root.End() && end > root.Pos() {
-		if start == end {
-			end = start + 1 // empty interval => interval of size 1
-		}
-		exact = visit(root)
-
-		// Reverse the path:
-		for i, l := 0, len(path); i < l/2; i++ {
-			path[i], path[l-1-i] = path[l-1-i], path[i]
-		}
-	} else {
-		// Selection lies within whitespace preceding the
-		// first (or following the last) declaration in the file.
-		// The result nonetheless always includes the ast.File.
-		path = append(path, root)
-	}
-
-	return
-}
-
-// tokenNode is a dummy implementation of ast.Node for a single token.
-// They are used transiently by PathEnclosingInterval but never escape
-// this package.
-type tokenNode struct {
-	pos token.Pos
-	end token.Pos
-}
-
-func (n tokenNode) Pos() token.Pos {
-	return n.pos
-}
-
-func (n tokenNode) End() token.Pos {
-	return n.end
-}
-
-func tok(pos token.Pos, len int) ast.Node {
-	return tokenNode{pos, pos + token.Pos(len)}
-}
-
-// childrenOf returns the direct non-nil children of ast.Node n.
-// It may include fake ast.Node implementations for bare tokens.
-// it is not safe to call (e.g.) ast.Walk on such nodes.
-func childrenOf(n ast.Node) []ast.Node {
-	var children []ast.Node
-
-	// First add nodes for all true subtrees.
-	ast.Inspect(n, func(node ast.Node) bool {
-		if node == n { // push n
-			return true // recur
-		}
-		if node != nil { // push child
-			children = append(children, node)
-		}
-		return false // no recursion
-	})
-
-	// TODO(adonovan): be more careful about missing (!Pos.Valid)
-	// tokens in trees produced from invalid input.
-
-	// Then add fake Nodes for bare tokens.
-	switch n := n.(type) {
-	case *ast.ArrayType:
-		children = append(children,
-			tok(n.Lbrack, len("[")),
-			tok(n.Elt.End(), len("]")))
-
-	case *ast.AssignStmt:
-		children = append(children,
-			tok(n.TokPos, len(n.Tok.String())))
-
-	case *ast.BasicLit:
-		children = append(children,
-			tok(n.ValuePos, len(n.Value)))
-
-	case *ast.BinaryExpr:
-		children = append(children, tok(n.OpPos, len(n.Op.String())))
-
-	case *ast.BlockStmt:
-		if n.Lbrace.IsValid() {
-			children = append(children, tok(n.Lbrace, len("{")))
-		}
-		if n.Rbrace.IsValid() {
-			children = append(children, tok(n.Rbrace, len("}")))
-		}
-
-	case *ast.BranchStmt:
-		children = append(children,
-			tok(n.TokPos, len(n.Tok.String())))
-
-	case *ast.CallExpr:
-		children = append(children,
-			tok(n.Lparen, len("(")),
-			tok(n.Rparen, len(")")))
-		if n.Ellipsis != 0 {
-			children = append(children, tok(n.Ellipsis, len("...")))
-		}
-
-	case *ast.CaseClause:
-		if n.List == nil {
-			children = append(children,
-				tok(n.Case, len("default")))
-		} else {
-			children = append(children,
-				tok(n.Case, len("case")))
-		}
-		children = append(children, tok(n.Colon, len(":")))
-
-	case *ast.ChanType:
-		switch n.Dir {
-		case ast.RECV:
-			children = append(children, tok(n.Begin, len("<-chan")))
-		case ast.SEND:
-			children = append(children, tok(n.Begin, len("chan<-")))
-		case ast.RECV | ast.SEND:
-			children = append(children, tok(n.Begin, len("chan")))
-		}
-
-	case *ast.CommClause:
-		if n.Comm == nil {
-			children = append(children,
-				tok(n.Case, len("default")))
-		} else {
-			children = append(children,
-				tok(n.Case, len("case")))
-		}
-		children = append(children, tok(n.Colon, len(":")))
-
-	case *ast.Comment:
-		// nop
-
-	case *ast.CommentGroup:
-		// nop
-
-	case *ast.CompositeLit:
-		children = append(children,
-			tok(n.Lbrace, len("{")),
-			tok(n.Rbrace, len("{")))
-
-	case *ast.DeclStmt:
-		// nop
-
-	case *ast.DeferStmt:
-		children = append(children,
-			tok(n.Defer, len("defer")))
-
-	case *ast.Ellipsis:
-		children = append(children,
-			tok(n.Ellipsis, len("...")))
-
-	case *ast.EmptyStmt:
-		// nop
-
-	case *ast.ExprStmt:
-		// nop
-
-	case *ast.Field:
-		// TODO(adonovan): Field.{Doc,Comment,Tag}?
-
-	case *ast.FieldList:
-		if n.Opening.IsValid() {
-			children = append(children, tok(n.Opening, len("(")))
-		}
-		if n.Closing.IsValid() {
-			children = append(children, tok(n.Closing, len(")")))
-		}
-
-	case *ast.File:
-		// TODO test: Doc
-		children = append(children,
-			tok(n.Package, len("package")))
-
-	case *ast.ForStmt:
-		children = append(children,
-			tok(n.For, len("for")))
-
-	case *ast.FuncDecl:
-		// TODO(adonovan): FuncDecl.Comment?
-
-		// Uniquely, FuncDecl breaks the invariant that
-		// preorder traversal yields tokens in lexical order:
-		// in fact, FuncDecl.Recv precedes FuncDecl.Type.Func.
-		//
-		// As a workaround, we inline the case for FuncType
-		// here and order things correctly.
-		// We also need to insert the elided FuncType just
-		// before the 'visit' recursion.
-		//
-		children = nil // discard ast.Walk(FuncDecl) info subtrees
-		children = append(children, tok(n.Type.Func, len("func")))
-		if n.Recv != nil {
-			children = append(children, n.Recv)
-		}
-		children = append(children, n.Name)
-		if tparams := n.Type.TypeParams; tparams != nil {
-			children = append(children, tparams)
-		}
-		if n.Type.Params != nil {
-			children = append(children, n.Type.Params)
-		}
-		if n.Type.Results != nil {
-			children = append(children, n.Type.Results)
-		}
-		if n.Body != nil {
-			children = append(children, n.Body)
-		}
-
-	case *ast.FuncLit:
-		// nop
-
-	case *ast.FuncType:
-		if n.Func != 0 {
-			children = append(children,
-				tok(n.Func, len("func")))
-		}
-
-	case *ast.GenDecl:
-		children = append(children,
-			tok(n.TokPos, len(n.Tok.String())))
-		if n.Lparen != 0 {
-			children = append(children,
-				tok(n.Lparen, len("(")),
-				tok(n.Rparen, len(")")))
-		}
-
-	case *ast.GoStmt:
-		children = append(children,
-			tok(n.Go, len("go")))
-
-	case *ast.Ident:
-		children = append(children,
-			tok(n.NamePos, len(n.Name)))
-
-	case *ast.IfStmt:
-		children = append(children,
-			tok(n.If, len("if")))
-
-	case *ast.ImportSpec:
-		// TODO(adonovan): ImportSpec.{Doc,EndPos}?
-
-	case *ast.IncDecStmt:
-		children = append(children,
-			tok(n.TokPos, len(n.Tok.String())))
-
-	case *ast.IndexExpr:
-		children = append(children,
-			tok(n.Lbrack, len("[")),
-			tok(n.Rbrack, len("]")))
-
-	case *ast.IndexListExpr:
-		children = append(children,
-			tok(n.Lbrack, len("[")),
-			tok(n.Rbrack, len("]")))
-
-	case *ast.InterfaceType:
-		children = append(children,
-			tok(n.Interface, len("interface")))
-
-	case *ast.KeyValueExpr:
-		children = append(children,
-			tok(n.Colon, len(":")))
-
-	case *ast.LabeledStmt:
-		children = append(children,
-			tok(n.Colon, len(":")))
-
-	case *ast.MapType:
-		children = append(children,
-			tok(n.Map, len("map")))
-
-	case *ast.ParenExpr:
-		children = append(children,
-			tok(n.Lparen, len("(")),
-			tok(n.Rparen, len(")")))
-
-	case *ast.RangeStmt:
-		children = append(children,
-			tok(n.For, len("for")),
-			tok(n.TokPos, len(n.Tok.String())))
-
-	case *ast.ReturnStmt:
-		children = append(children,
-			tok(n.Return, len("return")))
-
-	case *ast.SelectStmt:
-		children = append(children,
-			tok(n.Select, len("select")))
-
-	case *ast.SelectorExpr:
-		// nop
-
-	case *ast.SendStmt:
-		children = append(children,
-			tok(n.Arrow, len("<-")))
-
-	case *ast.SliceExpr:
-		children = append(children,
-			tok(n.Lbrack, len("[")),
-			tok(n.Rbrack, len("]")))
-
-	case *ast.StarExpr:
-		children = append(children, tok(n.Star, len("*")))
-
-	case *ast.StructType:
-		children = append(children, tok(n.Struct, len("struct")))
-
-	case *ast.SwitchStmt:
-		children = append(children, tok(n.Switch, len("switch")))
-
-	case *ast.TypeAssertExpr:
-		children = append(children,
-			tok(n.Lparen-1, len(".")),
-			tok(n.Lparen, len("(")),
-			tok(n.Rparen, len(")")))
-
-	case *ast.TypeSpec:
-		// TODO(adonovan): TypeSpec.{Doc,Comment}?
-
-	case *ast.TypeSwitchStmt:
-		children = append(children, tok(n.Switch, len("switch")))
-
-	case *ast.UnaryExpr:
-		children = append(children, tok(n.OpPos, len(n.Op.String())))
-
-	case *ast.ValueSpec:
-		// TODO(adonovan): ValueSpec.{Doc,Comment}?
-
-	case *ast.BadDecl, *ast.BadExpr, *ast.BadStmt:
-		// nop
-	}
-
-	// TODO(adonovan): opt: merge the logic of ast.Inspect() into
-	// the switch above so we can make interleaved callbacks for
-	// both Nodes and Tokens in the right order and avoid the need
-	// to sort.
-	sort.Sort(byPos(children))
-
-	return children
-}
-
-type byPos []ast.Node
-
-func (sl byPos) Len() int {
-	return len(sl)
-}
-func (sl byPos) Less(i, j int) bool {
-	return sl[i].Pos() < sl[j].Pos()
-}
-func (sl byPos) Swap(i, j int) {
-	sl[i], sl[j] = sl[j], sl[i]
-}
-
-// NodeDescription returns a description of the concrete type of n suitable
-// for a user interface.
-//
-// TODO(adonovan): in some cases (e.g. Field, FieldList, Ident,
-// StarExpr) we could be much more specific given the path to the AST
-// root.  Perhaps we should do that.
-func NodeDescription(n ast.Node) string {
-	switch n := n.(type) {
-	case *ast.ArrayType:
-		return "array type"
-	case *ast.AssignStmt:
-		return "assignment"
-	case *ast.BadDecl:
-		return "bad declaration"
-	case *ast.BadExpr:
-		return "bad expression"
-	case *ast.BadStmt:
-		return "bad statement"
-	case *ast.BasicLit:
-		return "basic literal"
-	case *ast.BinaryExpr:
-		return fmt.Sprintf("binary %s operation", n.Op)
-	case *ast.BlockStmt:
-		return "block"
-	case *ast.BranchStmt:
-		switch n.Tok {
-		case token.BREAK:
-			return "break statement"
-		case token.CONTINUE:
-			return "continue statement"
-		case token.GOTO:
-			return "goto statement"
-		case token.FALLTHROUGH:
-			return "fall-through statement"
-		}
-	case *ast.CallExpr:
-		if len(n.Args) == 1 && !n.Ellipsis.IsValid() {
-			return "function call (or conversion)"
-		}
-		return "function call"
-	case *ast.CaseClause:
-		return "case clause"
-	case *ast.ChanType:
-		return "channel type"
-	case *ast.CommClause:
-		return "communication clause"
-	case *ast.Comment:
-		return "comment"
-	case *ast.CommentGroup:
-		return "comment group"
-	case *ast.CompositeLit:
-		return "composite literal"
-	case *ast.DeclStmt:
-		return NodeDescription(n.Decl) + " statement"
-	case *ast.DeferStmt:
-		return "defer statement"
-	case *ast.Ellipsis:
-		return "ellipsis"
-	case *ast.EmptyStmt:
-		return "empty statement"
-	case *ast.ExprStmt:
-		return "expression statement"
-	case *ast.Field:
-		// Can be any of these:
-		// struct {x, y int}  -- struct field(s)
-		// struct {T}         -- anon struct field
-		// interface {I}      -- interface embedding
-		// interface {f()}    -- interface method
-		// func (A) func(B) C -- receiver, param(s), result(s)
-		return "field/method/parameter"
-	case *ast.FieldList:
-		return "field/method/parameter list"
-	case *ast.File:
-		return "source file"
-	case *ast.ForStmt:
-		return "for loop"
-	case *ast.FuncDecl:
-		return "function declaration"
-	case *ast.FuncLit:
-		return "function literal"
-	case *ast.FuncType:
-		return "function type"
-	case *ast.GenDecl:
-		switch n.Tok {
-		case token.IMPORT:
-			return "import declaration"
-		case token.CONST:
-			return "constant declaration"
-		case token.TYPE:
-			return "type declaration"
-		case token.VAR:
-			return "variable declaration"
-		}
-	case *ast.GoStmt:
-		return "go statement"
-	case *ast.Ident:
-		return "identifier"
-	case *ast.IfStmt:
-		return "if statement"
-	case *ast.ImportSpec:
-		return "import specification"
-	case *ast.IncDecStmt:
-		if n.Tok == token.INC {
-			return "increment statement"
-		}
-		return "decrement statement"
-	case *ast.IndexExpr:
-		return "index expression"
-	case *ast.IndexListExpr:
-		return "index list expression"
-	case *ast.InterfaceType:
-		return "interface type"
-	case *ast.KeyValueExpr:
-		return "key/value association"
-	case *ast.LabeledStmt:
-		return "statement label"
-	case *ast.MapType:
-		return "map type"
-	case *ast.Package:
-		return "package"
-	case *ast.ParenExpr:
-		return "parenthesized " + NodeDescription(n.X)
-	case *ast.RangeStmt:
-		return "range loop"
-	case *ast.ReturnStmt:
-		return "return statement"
-	case *ast.SelectStmt:
-		return "select statement"
-	case *ast.SelectorExpr:
-		return "selector"
-	case *ast.SendStmt:
-		return "channel send"
-	case *ast.SliceExpr:
-		return "slice expression"
-	case *ast.StarExpr:
-		return "*-operation" // load/store expr or pointer type
-	case *ast.StructType:
-		return "struct type"
-	case *ast.SwitchStmt:
-		return "switch statement"
-	case *ast.TypeAssertExpr:
-		return "type assertion"
-	case *ast.TypeSpec:
-		return "type specification"
-	case *ast.TypeSwitchStmt:
-		return "type switch"
-	case *ast.UnaryExpr:
-		return fmt.Sprintf("unary %s operation", n.Op)
-	case *ast.ValueSpec:
-		return "value specification"
-
-	}
-	panic(fmt.Sprintf("unexpected node type: %T", n))
-}
-
-func is[T any](x any) bool {
-	_, ok := x.(T)
-	return ok
-}
diff --git a/vendor/golang.org/x/tools/go/ast/astutil/imports.go b/vendor/golang.org/x/tools/go/ast/astutil/imports.go
deleted file mode 100644
index 5bacc0fa4..000000000
--- a/vendor/golang.org/x/tools/go/ast/astutil/imports.go
+++ /dev/null
@@ -1,472 +0,0 @@
-// Copyright 2013 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 astutil contains common utilities for working with the Go AST.
-package astutil // import "golang.org/x/tools/go/ast/astutil"
-
-import (
-	"fmt"
-	"go/ast"
-	"go/token"
-	"slices"
-	"strconv"
-	"strings"
-)
-
-// AddImport adds the import path to the file f, if absent.
-func AddImport(fset *token.FileSet, f *ast.File, path string) (added bool) {
-	return AddNamedImport(fset, f, "", path)
-}
-
-// AddNamedImport adds the import with the given name and path to the file f, if absent.
-// If name is not empty, it is used to rename the import.
-//
-// For example, calling
-//
-//	AddNamedImport(fset, f, "pathpkg", "path")
-//
-// adds
-//
-//	import pathpkg "path"
-func AddNamedImport(fset *token.FileSet, f *ast.File, name, path string) (added bool) {
-	if imports(f, name, path) {
-		return false
-	}
-
-	newImport := &ast.ImportSpec{
-		Path: &ast.BasicLit{
-			Kind:  token.STRING,
-			Value: strconv.Quote(path),
-		},
-	}
-	if name != "" {
-		newImport.Name = &ast.Ident{Name: name}
-	}
-
-	// Find an import decl to add to.
-	// The goal is to find an existing import
-	// whose import path has the longest shared
-	// prefix with path.
-	var (
-		bestMatch  = -1         // length of longest shared prefix
-		lastImport = -1         // index in f.Decls of the file's final import decl
-		impDecl    *ast.GenDecl // import decl containing the best match
-		impIndex   = -1         // spec index in impDecl containing the best match
-
-		isThirdPartyPath = isThirdParty(path)
-	)
-	for i, decl := range f.Decls {
-		gen, ok := decl.(*ast.GenDecl)
-		if ok && gen.Tok == token.IMPORT {
-			lastImport = i
-			// Do not add to import "C", to avoid disrupting the
-			// association with its doc comment, breaking cgo.
-			if declImports(gen, "C") {
-				continue
-			}
-
-			// Match an empty import decl if that's all that is available.
-			if len(gen.Specs) == 0 && bestMatch == -1 {
-				impDecl = gen
-			}
-
-			// Compute longest shared prefix with imports in this group and find best
-			// matched import spec.
-			// 1. Always prefer import spec with longest shared prefix.
-			// 2. While match length is 0,
-			// - for stdlib package: prefer first import spec.
-			// - for third party package: prefer first third party import spec.
-			// We cannot use last import spec as best match for third party package
-			// because grouped imports are usually placed last by goimports -local
-			// flag.
-			// See issue #19190.
-			seenAnyThirdParty := false
-			for j, spec := range gen.Specs {
-				impspec := spec.(*ast.ImportSpec)
-				p := importPath(impspec)
-				n := matchLen(p, path)
-				if n > bestMatch || (bestMatch == 0 && !seenAnyThirdParty && isThirdPartyPath) {
-					bestMatch = n
-					impDecl = gen
-					impIndex = j
-				}
-				seenAnyThirdParty = seenAnyThirdParty || isThirdParty(p)
-			}
-		}
-	}
-
-	// If no import decl found, add one after the last import.
-	if impDecl == nil {
-		impDecl = &ast.GenDecl{
-			Tok: token.IMPORT,
-		}
-		if lastImport >= 0 {
-			impDecl.TokPos = f.Decls[lastImport].End()
-		} else {
-			// There are no existing imports.
-			// Our new import, preceded by a blank line,  goes after the package declaration
-			// and after the comment, if any, that starts on the same line as the
-			// package declaration.
-			impDecl.TokPos = f.Package
-
-			file := fset.File(f.Package)
-			pkgLine := file.Line(f.Package)
-			for _, c := range f.Comments {
-				if file.Line(c.Pos()) > pkgLine {
-					break
-				}
-				// +2 for a blank line
-				impDecl.TokPos = c.End() + 2
-			}
-		}
-		f.Decls = append(f.Decls, nil)
-		copy(f.Decls[lastImport+2:], f.Decls[lastImport+1:])
-		f.Decls[lastImport+1] = impDecl
-	}
-
-	// Insert new import at insertAt.
-	insertAt := 0
-	if impIndex >= 0 {
-		// insert after the found import
-		insertAt = impIndex + 1
-	}
-	impDecl.Specs = append(impDecl.Specs, nil)
-	copy(impDecl.Specs[insertAt+1:], impDecl.Specs[insertAt:])
-	impDecl.Specs[insertAt] = newImport
-	pos := impDecl.Pos()
-	if insertAt > 0 {
-		// If there is a comment after an existing import, preserve the comment
-		// position by adding the new import after the comment.
-		if spec, ok := impDecl.Specs[insertAt-1].(*ast.ImportSpec); ok && spec.Comment != nil {
-			pos = spec.Comment.End()
-		} else {
-			// Assign same position as the previous import,
-			// so that the sorter sees it as being in the same block.
-			pos = impDecl.Specs[insertAt-1].Pos()
-		}
-	}
-	if newImport.Name != nil {
-		newImport.Name.NamePos = pos
-	}
-	newImport.Path.ValuePos = pos
-	newImport.EndPos = pos
-
-	// Clean up parens. impDecl contains at least one spec.
-	if len(impDecl.Specs) == 1 {
-		// Remove unneeded parens.
-		impDecl.Lparen = token.NoPos
-	} else if !impDecl.Lparen.IsValid() {
-		// impDecl needs parens added.
-		impDecl.Lparen = impDecl.Specs[0].Pos()
-	}
-
-	f.Imports = append(f.Imports, newImport)
-
-	if len(f.Decls) <= 1 {
-		return true
-	}
-
-	// Merge all the import declarations into the first one.
-	var first *ast.GenDecl
-	for i := 0; i < len(f.Decls); i++ {
-		decl := f.Decls[i]
-		gen, ok := decl.(*ast.GenDecl)
-		if !ok || gen.Tok != token.IMPORT || declImports(gen, "C") {
-			continue
-		}
-		if first == nil {
-			first = gen
-			continue // Don't touch the first one.
-		}
-		// We now know there is more than one package in this import
-		// declaration. Ensure that it ends up parenthesized.
-		first.Lparen = first.Pos()
-		// Move the imports of the other import declaration to the first one.
-		for _, spec := range gen.Specs {
-			spec.(*ast.ImportSpec).Path.ValuePos = first.Pos()
-			first.Specs = append(first.Specs, spec)
-		}
-		f.Decls = slices.Delete(f.Decls, i, i+1)
-		i--
-	}
-
-	return true
-}
-
-func isThirdParty(importPath string) bool {
-	// Third party package import path usually contains "." (".com", ".org", ...)
-	// This logic is taken from golang.org/x/tools/imports package.
-	return strings.Contains(importPath, ".")
-}
-
-// DeleteImport deletes the import path from the file f, if present.
-// If there are duplicate import declarations, all matching ones are deleted.
-func DeleteImport(fset *token.FileSet, f *ast.File, path string) (deleted bool) {
-	return DeleteNamedImport(fset, f, "", path)
-}
-
-// DeleteNamedImport deletes the import with the given name and path from the file f, if present.
-// If there are duplicate import declarations, all matching ones are deleted.
-func DeleteNamedImport(fset *token.FileSet, f *ast.File, name, path string) (deleted bool) {
-	var (
-		delspecs    = make(map[*ast.ImportSpec]bool)
-		delcomments = make(map[*ast.CommentGroup]bool)
-	)
-
-	// Find the import nodes that import path, if any.
-	for i := 0; i < len(f.Decls); i++ {
-		gen, ok := f.Decls[i].(*ast.GenDecl)
-		if !ok || gen.Tok != token.IMPORT {
-			continue
-		}
-		for j := 0; j < len(gen.Specs); j++ {
-			impspec := gen.Specs[j].(*ast.ImportSpec)
-			if importName(impspec) != name || importPath(impspec) != path {
-				continue
-			}
-
-			// We found an import spec that imports path.
-			// Delete it.
-			delspecs[impspec] = true
-			deleted = true
-			gen.Specs = slices.Delete(gen.Specs, j, j+1)
-
-			// If this was the last import spec in this decl,
-			// delete the decl, too.
-			if len(gen.Specs) == 0 {
-				f.Decls = slices.Delete(f.Decls, i, i+1)
-				i--
-				break
-			} else if len(gen.Specs) == 1 {
-				if impspec.Doc != nil {
-					delcomments[impspec.Doc] = true
-				}
-				if impspec.Comment != nil {
-					delcomments[impspec.Comment] = true
-				}
-				for _, cg := range f.Comments {
-					// Found comment on the same line as the import spec.
-					if cg.End() < impspec.Pos() && fset.Position(cg.End()).Line == fset.Position(impspec.Pos()).Line {
-						delcomments[cg] = true
-						break
-					}
-				}
-
-				spec := gen.Specs[0].(*ast.ImportSpec)
-
-				// Move the documentation right after the import decl.
-				if spec.Doc != nil {
-					for fset.Position(gen.TokPos).Line+1 < fset.Position(spec.Doc.Pos()).Line {
-						fset.File(gen.TokPos).MergeLine(fset.Position(gen.TokPos).Line)
-					}
-				}
-				for _, cg := range f.Comments {
-					if cg.End() < spec.Pos() && fset.Position(cg.End()).Line == fset.Position(spec.Pos()).Line {
-						for fset.Position(gen.TokPos).Line+1 < fset.Position(spec.Pos()).Line {
-							fset.File(gen.TokPos).MergeLine(fset.Position(gen.TokPos).Line)
-						}
-						break
-					}
-				}
-			}
-			if j > 0 {
-				lastImpspec := gen.Specs[j-1].(*ast.ImportSpec)
-				lastLine := fset.PositionFor(lastImpspec.Path.ValuePos, false).Line
-				line := fset.PositionFor(impspec.Path.ValuePos, false).Line
-
-				// We deleted an entry but now there may be
-				// a blank line-sized hole where the import was.
-				if line-lastLine > 1 || !gen.Rparen.IsValid() {
-					// There was a blank line immediately preceding the deleted import,
-					// so there's no need to close the hole. The right parenthesis is
-					// invalid after AddImport to an import statement without parenthesis.
-					// Do nothing.
-				} else if line != fset.File(gen.Rparen).LineCount() {
-					// There was no blank line. Close the hole.
-					fset.File(gen.Rparen).MergeLine(line)
-				}
-			}
-			j--
-		}
-	}
-
-	// Delete imports from f.Imports.
-	before := len(f.Imports)
-	f.Imports = slices.DeleteFunc(f.Imports, func(imp *ast.ImportSpec) bool {
-		_, ok := delspecs[imp]
-		return ok
-	})
-	if len(f.Imports)+len(delspecs) != before {
-		// This can happen when the AST is invalid (i.e. imports differ between f.Decls and f.Imports).
-		panic(fmt.Sprintf("deleted specs from Decls but not Imports: %v", delspecs))
-	}
-
-	// Delete comments from f.Comments.
-	f.Comments = slices.DeleteFunc(f.Comments, func(cg *ast.CommentGroup) bool {
-		_, ok := delcomments[cg]
-		return ok
-	})
-
-	return
-}
-
-// RewriteImport rewrites any import of path oldPath to path newPath.
-func RewriteImport(fset *token.FileSet, f *ast.File, oldPath, newPath string) (rewrote bool) {
-	for _, imp := range f.Imports {
-		if importPath(imp) == oldPath {
-			rewrote = true
-			// record old End, because the default is to compute
-			// it using the length of imp.Path.Value.
-			imp.EndPos = imp.End()
-			imp.Path.Value = strconv.Quote(newPath)
-		}
-	}
-	return
-}
-
-// UsesImport reports whether a given import is used.
-// The provided File must have been parsed with syntactic object resolution
-// (not using go/parser.SkipObjectResolution).
-func UsesImport(f *ast.File, path string) (used bool) {
-	if f.Scope == nil {
-		panic("file f was not parsed with syntactic object resolution")
-	}
-	spec := importSpec(f, path)
-	if spec == nil {
-		return
-	}
-
-	name := spec.Name.String()
-	switch name {
-	case "<nil>":
-		// If the package name is not explicitly specified,
-		// make an educated guess. This is not guaranteed to be correct.
-		lastSlash := strings.LastIndex(path, "/")
-		if lastSlash == -1 {
-			name = path
-		} else {
-			name = path[lastSlash+1:]
-		}
-	case "_", ".":
-		// Not sure if this import is used - err on the side of caution.
-		return true
-	}
-
-	ast.Walk(visitFn(func(n ast.Node) {
-		sel, ok := n.(*ast.SelectorExpr)
-		if ok && isTopName(sel.X, name) {
-			used = true
-		}
-	}), f)
-
-	return
-}
-
-type visitFn func(node ast.Node)
-
-func (fn visitFn) Visit(node ast.Node) ast.Visitor {
-	fn(node)
-	return fn
-}
-
-// imports reports whether f has an import with the specified name and path.
-func imports(f *ast.File, name, path string) bool {
-	for _, s := range f.Imports {
-		if importName(s) == name && importPath(s) == path {
-			return true
-		}
-	}
-	return false
-}
-
-// importSpec returns the import spec if f imports path,
-// or nil otherwise.
-func importSpec(f *ast.File, path string) *ast.ImportSpec {
-	for _, s := range f.Imports {
-		if importPath(s) == path {
-			return s
-		}
-	}
-	return nil
-}
-
-// importName returns the name of s,
-// or "" if the import is not named.
-func importName(s *ast.ImportSpec) string {
-	if s.Name == nil {
-		return ""
-	}
-	return s.Name.Name
-}
-
-// importPath returns the unquoted import path of s,
-// or "" if the path is not properly quoted.
-func importPath(s *ast.ImportSpec) string {
-	t, err := strconv.Unquote(s.Path.Value)
-	if err != nil {
-		return ""
-	}
-	return t
-}
-
-// declImports reports whether gen contains an import of path.
-func declImports(gen *ast.GenDecl, path string) bool {
-	if gen.Tok != token.IMPORT {
-		return false
-	}
-	for _, spec := range gen.Specs {
-		impspec := spec.(*ast.ImportSpec)
-		if importPath(impspec) == path {
-			return true
-		}
-	}
-	return false
-}
-
-// matchLen returns the length of the longest path segment prefix shared by x and y.
-func matchLen(x, y string) int {
-	n := 0
-	for i := 0; i < len(x) && i < len(y) && x[i] == y[i]; i++ {
-		if x[i] == '/' {
-			n++
-		}
-	}
-	return n
-}
-
-// isTopName returns true if n is a top-level unresolved identifier with the given name.
-func isTopName(n ast.Expr, name string) bool {
-	id, ok := n.(*ast.Ident)
-	return ok && id.Name == name && id.Obj == nil
-}
-
-// Imports returns the file imports grouped by paragraph.
-func Imports(fset *token.FileSet, f *ast.File) [][]*ast.ImportSpec {
-	var groups [][]*ast.ImportSpec
-
-	for _, decl := range f.Decls {
-		genDecl, ok := decl.(*ast.GenDecl)
-		if !ok || genDecl.Tok != token.IMPORT {
-			break
-		}
-
-		group := []*ast.ImportSpec{}
-
-		var lastLine int
-		for _, spec := range genDecl.Specs {
-			importSpec := spec.(*ast.ImportSpec)
-			pos := importSpec.Path.ValuePos
-			line := fset.Position(pos).Line
-			if lastLine > 0 && pos > 0 && line-lastLine > 1 {
-				groups = append(groups, group)
-				group = []*ast.ImportSpec{}
-			}
-			group = append(group, importSpec)
-			lastLine = line
-		}
-		groups = append(groups, group)
-	}
-
-	return groups
-}
diff --git a/vendor/golang.org/x/tools/go/ast/astutil/rewrite.go b/vendor/golang.org/x/tools/go/ast/astutil/rewrite.go
deleted file mode 100644
index 4ad054930..000000000
--- a/vendor/golang.org/x/tools/go/ast/astutil/rewrite.go
+++ /dev/null
@@ -1,490 +0,0 @@
-// Copyright 2017 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 astutil
-
-import (
-	"fmt"
-	"go/ast"
-	"reflect"
-	"sort"
-)
-
-// An ApplyFunc is invoked by Apply for each node n, even if n is nil,
-// before and/or after the node's children, using a Cursor describing
-// the current node and providing operations on it.
-//
-// The return value of ApplyFunc controls the syntax tree traversal.
-// See Apply for details.
-type ApplyFunc func(*Cursor) bool
-
-// Apply traverses a syntax tree recursively, starting with root,
-// and calling pre and post for each node as described below.
-// Apply returns the syntax tree, possibly modified.
-//
-// If pre is not nil, it is called for each node before the node's
-// children are traversed (pre-order). If pre returns false, no
-// children are traversed, and post is not called for that node.
-//
-// If post is not nil, and a prior call of pre didn't return false,
-// post is called for each node after its children are traversed
-// (post-order). If post returns false, traversal is terminated and
-// Apply returns immediately.
-//
-// Only fields that refer to AST nodes are considered children;
-// i.e., token.Pos, Scopes, Objects, and fields of basic types
-// (strings, etc.) are ignored.
-//
-// Children are traversed in the order in which they appear in the
-// respective node's struct definition. A package's files are
-// traversed in the filenames' alphabetical order.
-func Apply(root ast.Node, pre, post ApplyFunc) (result ast.Node) {
-	parent := &struct{ ast.Node }{root}
-	defer func() {
-		if r := recover(); r != nil && r != abort {
-			panic(r)
-		}
-		result = parent.Node
-	}()
-	a := &application{pre: pre, post: post}
-	a.apply(parent, "Node", nil, root)
-	return
-}
-
-var abort = new(int) // singleton, to signal termination of Apply
-
-// A Cursor describes a node encountered during Apply.
-// Information about the node and its parent is available
-// from the Node, Parent, Name, and Index methods.
-//
-// If p is a variable of type and value of the current parent node
-// c.Parent(), and f is the field identifier with name c.Name(),
-// the following invariants hold:
-//
-//	p.f            == c.Node()  if c.Index() <  0
-//	p.f[c.Index()] == c.Node()  if c.Index() >= 0
-//
-// The methods Replace, Delete, InsertBefore, and InsertAfter
-// can be used to change the AST without disrupting Apply.
-//
-// This type is not to be confused with [inspector.Cursor] from
-// package [golang.org/x/tools/go/ast/inspector], which provides
-// stateless navigation of immutable syntax trees.
-type Cursor struct {
-	parent ast.Node
-	name   string
-	iter   *iterator // valid if non-nil
-	node   ast.Node
-}
-
-// Node returns the current Node.
-func (c *Cursor) Node() ast.Node { return c.node }
-
-// Parent returns the parent of the current Node.
-func (c *Cursor) Parent() ast.Node { return c.parent }
-
-// Name returns the name of the parent Node field that contains the current Node.
-// If the parent is a *ast.Package and the current Node is a *ast.File, Name returns
-// the filename for the current Node.
-func (c *Cursor) Name() string { return c.name }
-
-// Index reports the index >= 0 of the current Node in the slice of Nodes that
-// contains it, or a value < 0 if the current Node is not part of a slice.
-// The index of the current node changes if InsertBefore is called while
-// processing the current node.
-func (c *Cursor) Index() int {
-	if c.iter != nil {
-		return c.iter.index
-	}
-	return -1
-}
-
-// field returns the current node's parent field value.
-func (c *Cursor) field() reflect.Value {
-	return reflect.Indirect(reflect.ValueOf(c.parent)).FieldByName(c.name)
-}
-
-// Replace replaces the current Node with n.
-// The replacement node is not walked by Apply.
-func (c *Cursor) Replace(n ast.Node) {
-	if _, ok := c.node.(*ast.File); ok {
-		file, ok := n.(*ast.File)
-		if !ok {
-			panic("attempt to replace *ast.File with non-*ast.File")
-		}
-		c.parent.(*ast.Package).Files[c.name] = file
-		return
-	}
-
-	v := c.field()
-	if i := c.Index(); i >= 0 {
-		v = v.Index(i)
-	}
-	v.Set(reflect.ValueOf(n))
-}
-
-// Delete deletes the current Node from its containing slice.
-// If the current Node is not part of a slice, Delete panics.
-// As a special case, if the current node is a package file,
-// Delete removes it from the package's Files map.
-func (c *Cursor) Delete() {
-	if _, ok := c.node.(*ast.File); ok {
-		delete(c.parent.(*ast.Package).Files, c.name)
-		return
-	}
-
-	i := c.Index()
-	if i < 0 {
-		panic("Delete node not contained in slice")
-	}
-	v := c.field()
-	l := v.Len()
-	reflect.Copy(v.Slice(i, l), v.Slice(i+1, l))
-	v.Index(l - 1).Set(reflect.Zero(v.Type().Elem()))
-	v.SetLen(l - 1)
-	c.iter.step--
-}
-
-// InsertAfter inserts n after the current Node in its containing slice.
-// If the current Node is not part of a slice, InsertAfter panics.
-// Apply does not walk n.
-func (c *Cursor) InsertAfter(n ast.Node) {
-	i := c.Index()
-	if i < 0 {
-		panic("InsertAfter node not contained in slice")
-	}
-	v := c.field()
-	v.Set(reflect.Append(v, reflect.Zero(v.Type().Elem())))
-	l := v.Len()
-	reflect.Copy(v.Slice(i+2, l), v.Slice(i+1, l))
-	v.Index(i + 1).Set(reflect.ValueOf(n))
-	c.iter.step++
-}
-
-// InsertBefore inserts n before the current Node in its containing slice.
-// If the current Node is not part of a slice, InsertBefore panics.
-// Apply will not walk n.
-func (c *Cursor) InsertBefore(n ast.Node) {
-	i := c.Index()
-	if i < 0 {
-		panic("InsertBefore node not contained in slice")
-	}
-	v := c.field()
-	v.Set(reflect.Append(v, reflect.Zero(v.Type().Elem())))
-	l := v.Len()
-	reflect.Copy(v.Slice(i+1, l), v.Slice(i, l))
-	v.Index(i).Set(reflect.ValueOf(n))
-	c.iter.index++
-}
-
-// application carries all the shared data so we can pass it around cheaply.
-type application struct {
-	pre, post ApplyFunc
-	cursor    Cursor
-	iter      iterator
-}
-
-func (a *application) apply(parent ast.Node, name string, iter *iterator, n ast.Node) {
-	// convert typed nil into untyped nil
-	if v := reflect.ValueOf(n); v.Kind() == reflect.Pointer && v.IsNil() {
-		n = nil
-	}
-
-	// avoid heap-allocating a new cursor for each apply call; reuse a.cursor instead
-	saved := a.cursor
-	a.cursor.parent = parent
-	a.cursor.name = name
-	a.cursor.iter = iter
-	a.cursor.node = n
-
-	if a.pre != nil && !a.pre(&a.cursor) {
-		a.cursor = saved
-		return
-	}
-
-	// walk children
-	// (the order of the cases matches the order of the corresponding node types in go/ast)
-	switch n := n.(type) {
-	case nil:
-		// nothing to do
-
-	// Comments and fields
-	case *ast.Comment:
-		// nothing to do
-
-	case *ast.CommentGroup:
-		if n != nil {
-			a.applyList(n, "List")
-		}
-
-	case *ast.Field:
-		a.apply(n, "Doc", nil, n.Doc)
-		a.applyList(n, "Names")
-		a.apply(n, "Type", nil, n.Type)
-		a.apply(n, "Tag", nil, n.Tag)
-		a.apply(n, "Comment", nil, n.Comment)
-
-	case *ast.FieldList:
-		a.applyList(n, "List")
-
-	// Expressions
-	case *ast.BadExpr, *ast.Ident, *ast.BasicLit:
-		// nothing to do
-
-	case *ast.Ellipsis:
-		a.apply(n, "Elt", nil, n.Elt)
-
-	case *ast.FuncLit:
-		a.apply(n, "Type", nil, n.Type)
-		a.apply(n, "Body", nil, n.Body)
-
-	case *ast.CompositeLit:
-		a.apply(n, "Type", nil, n.Type)
-		a.applyList(n, "Elts")
-
-	case *ast.ParenExpr:
-		a.apply(n, "X", nil, n.X)
-
-	case *ast.SelectorExpr:
-		a.apply(n, "X", nil, n.X)
-		a.apply(n, "Sel", nil, n.Sel)
-
-	case *ast.IndexExpr:
-		a.apply(n, "X", nil, n.X)
-		a.apply(n, "Index", nil, n.Index)
-
-	case *ast.IndexListExpr:
-		a.apply(n, "X", nil, n.X)
-		a.applyList(n, "Indices")
-
-	case *ast.SliceExpr:
-		a.apply(n, "X", nil, n.X)
-		a.apply(n, "Low", nil, n.Low)
-		a.apply(n, "High", nil, n.High)
-		a.apply(n, "Max", nil, n.Max)
-
-	case *ast.TypeAssertExpr:
-		a.apply(n, "X", nil, n.X)
-		a.apply(n, "Type", nil, n.Type)
-
-	case *ast.CallExpr:
-		a.apply(n, "Fun", nil, n.Fun)
-		a.applyList(n, "Args")
-
-	case *ast.StarExpr:
-		a.apply(n, "X", nil, n.X)
-
-	case *ast.UnaryExpr:
-		a.apply(n, "X", nil, n.X)
-
-	case *ast.BinaryExpr:
-		a.apply(n, "X", nil, n.X)
-		a.apply(n, "Y", nil, n.Y)
-
-	case *ast.KeyValueExpr:
-		a.apply(n, "Key", nil, n.Key)
-		a.apply(n, "Value", nil, n.Value)
-
-	// Types
-	case *ast.ArrayType:
-		a.apply(n, "Len", nil, n.Len)
-		a.apply(n, "Elt", nil, n.Elt)
-
-	case *ast.StructType:
-		a.apply(n, "Fields", nil, n.Fields)
-
-	case *ast.FuncType:
-		if tparams := n.TypeParams; tparams != nil {
-			a.apply(n, "TypeParams", nil, tparams)
-		}
-		a.apply(n, "Params", nil, n.Params)
-		a.apply(n, "Results", nil, n.Results)
-
-	case *ast.InterfaceType:
-		a.apply(n, "Methods", nil, n.Methods)
-
-	case *ast.MapType:
-		a.apply(n, "Key", nil, n.Key)
-		a.apply(n, "Value", nil, n.Value)
-
-	case *ast.ChanType:
-		a.apply(n, "Value", nil, n.Value)
-
-	// Statements
-	case *ast.BadStmt:
-		// nothing to do
-
-	case *ast.DeclStmt:
-		a.apply(n, "Decl", nil, n.Decl)
-
-	case *ast.EmptyStmt:
-		// nothing to do
-
-	case *ast.LabeledStmt:
-		a.apply(n, "Label", nil, n.Label)
-		a.apply(n, "Stmt", nil, n.Stmt)
-
-	case *ast.ExprStmt:
-		a.apply(n, "X", nil, n.X)
-
-	case *ast.SendStmt:
-		a.apply(n, "Chan", nil, n.Chan)
-		a.apply(n, "Value", nil, n.Value)
-
-	case *ast.IncDecStmt:
-		a.apply(n, "X", nil, n.X)
-
-	case *ast.AssignStmt:
-		a.applyList(n, "Lhs")
-		a.applyList(n, "Rhs")
-
-	case *ast.GoStmt:
-		a.apply(n, "Call", nil, n.Call)
-
-	case *ast.DeferStmt:
-		a.apply(n, "Call", nil, n.Call)
-
-	case *ast.ReturnStmt:
-		a.applyList(n, "Results")
-
-	case *ast.BranchStmt:
-		a.apply(n, "Label", nil, n.Label)
-
-	case *ast.BlockStmt:
-		a.applyList(n, "List")
-
-	case *ast.IfStmt:
-		a.apply(n, "Init", nil, n.Init)
-		a.apply(n, "Cond", nil, n.Cond)
-		a.apply(n, "Body", nil, n.Body)
-		a.apply(n, "Else", nil, n.Else)
-
-	case *ast.CaseClause:
-		a.applyList(n, "List")
-		a.applyList(n, "Body")
-
-	case *ast.SwitchStmt:
-		a.apply(n, "Init", nil, n.Init)
-		a.apply(n, "Tag", nil, n.Tag)
-		a.apply(n, "Body", nil, n.Body)
-
-	case *ast.TypeSwitchStmt:
-		a.apply(n, "Init", nil, n.Init)
-		a.apply(n, "Assign", nil, n.Assign)
-		a.apply(n, "Body", nil, n.Body)
-
-	case *ast.CommClause:
-		a.apply(n, "Comm", nil, n.Comm)
-		a.applyList(n, "Body")
-
-	case *ast.SelectStmt:
-		a.apply(n, "Body", nil, n.Body)
-
-	case *ast.ForStmt:
-		a.apply(n, "Init", nil, n.Init)
-		a.apply(n, "Cond", nil, n.Cond)
-		a.apply(n, "Post", nil, n.Post)
-		a.apply(n, "Body", nil, n.Body)
-
-	case *ast.RangeStmt:
-		a.apply(n, "Key", nil, n.Key)
-		a.apply(n, "Value", nil, n.Value)
-		a.apply(n, "X", nil, n.X)
-		a.apply(n, "Body", nil, n.Body)
-
-	// Declarations
-	case *ast.ImportSpec:
-		a.apply(n, "Doc", nil, n.Doc)
-		a.apply(n, "Name", nil, n.Name)
-		a.apply(n, "Path", nil, n.Path)
-		a.apply(n, "Comment", nil, n.Comment)
-
-	case *ast.ValueSpec:
-		a.apply(n, "Doc", nil, n.Doc)
-		a.applyList(n, "Names")
-		a.apply(n, "Type", nil, n.Type)
-		a.applyList(n, "Values")
-		a.apply(n, "Comment", nil, n.Comment)
-
-	case *ast.TypeSpec:
-		a.apply(n, "Doc", nil, n.Doc)
-		a.apply(n, "Name", nil, n.Name)
-		if tparams := n.TypeParams; tparams != nil {
-			a.apply(n, "TypeParams", nil, tparams)
-		}
-		a.apply(n, "Type", nil, n.Type)
-		a.apply(n, "Comment", nil, n.Comment)
-
-	case *ast.BadDecl:
-		// nothing to do
-
-	case *ast.GenDecl:
-		a.apply(n, "Doc", nil, n.Doc)
-		a.applyList(n, "Specs")
-
-	case *ast.FuncDecl:
-		a.apply(n, "Doc", nil, n.Doc)
-		a.apply(n, "Recv", nil, n.Recv)
-		a.apply(n, "Name", nil, n.Name)
-		a.apply(n, "Type", nil, n.Type)
-		a.apply(n, "Body", nil, n.Body)
-
-	// Files and packages
-	case *ast.File:
-		a.apply(n, "Doc", nil, n.Doc)
-		a.apply(n, "Name", nil, n.Name)
-		a.applyList(n, "Decls")
-		// Don't walk n.Comments; they have either been walked already if
-		// they are Doc comments, or they can be easily walked explicitly.
-
-	case *ast.Package:
-		// collect and sort names for reproducible behavior
-		var names []string
-		for name := range n.Files {
-			names = append(names, name)
-		}
-		sort.Strings(names)
-		for _, name := range names {
-			a.apply(n, name, nil, n.Files[name])
-		}
-
-	default:
-		panic(fmt.Sprintf("Apply: unexpected node type %T", n))
-	}
-
-	if a.post != nil && !a.post(&a.cursor) {
-		panic(abort)
-	}
-
-	a.cursor = saved
-}
-
-// An iterator controls iteration over a slice of nodes.
-type iterator struct {
-	index, step int
-}
-
-func (a *application) applyList(parent ast.Node, name string) {
-	// avoid heap-allocating a new iterator for each applyList call; reuse a.iter instead
-	saved := a.iter
-	a.iter.index = 0
-	for {
-		// must reload parent.name each time, since cursor modifications might change it
-		v := reflect.Indirect(reflect.ValueOf(parent)).FieldByName(name)
-		if a.iter.index >= v.Len() {
-			break
-		}
-
-		// element x may be nil in a bad AST - be cautious
-		var x ast.Node
-		if e := v.Index(a.iter.index); e.IsValid() {
-			x = e.Interface().(ast.Node)
-		}
-
-		a.iter.step = 1
-		a.apply(parent, name, &a.iter, x)
-		a.iter.index += a.iter.step
-	}
-	a.iter = saved
-}
diff --git a/vendor/golang.org/x/tools/go/ast/astutil/util.go b/vendor/golang.org/x/tools/go/ast/astutil/util.go
deleted file mode 100644
index c820b2084..000000000
--- a/vendor/golang.org/x/tools/go/ast/astutil/util.go
+++ /dev/null
@@ -1,13 +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.
-
-package astutil
-
-import "go/ast"
-
-// Unparen returns e with any enclosing parentheses stripped.
-// Deprecated: use [ast.Unparen].
-//
-//go:fix inline
-func Unparen(e ast.Expr) ast.Expr { return ast.Unparen(e) }
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 4f6ccfd6e..000000000
--- a/vendor/golang.org/x/tools/go/ast/edge/edge.go
+++ /dev/null
@@ -1,295 +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 idx != -1 {
-		v = v.Index(idx) // asserts valid index
-	} else {
-		// (The type assertion below asserts that v is not a slice.)
-	}
-	return v.Interface().(ast.Node) // may be nil
-}
-
-const (
-	Invalid Kind = iota // for nodes at the root of the traversal
-
-	// Kinds are sorted alphabetically.
-	// Numbering is not stable.
-	// Each is named Type_Field, where Type is the
-	// ast.Node struct type and Field is the name of the field
-
-	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 7e72d3c28..000000000
--- a/vendor/golang.org/x/tools/go/ast/inspector/cursor.go
+++ /dev/null
@@ -1,502 +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.
-//
-// Call [Inspector.Root] to obtain a valid cursor for the virtual root
-// node of the traversal.
-//
-// 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 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}
-}
-
-// Inspector returns the cursor's Inspector.
-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 [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.in == nil {
-		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)
-}
-
-// 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.)
-//
-// 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 := int32(-1) // push index of latest (=innermost) node containing range
-	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 {
-				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
-			} 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 a703cdfcf..000000000
--- 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 c576dc70a..000000000
--- a/vendor/golang.org/x/tools/go/ast/inspector/iter.go
+++ /dev/null
@@ -1,85 +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 of events: only nodes whose type matches an
-// element of the types slice are included in the sequence.
-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) { ... }
-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 9852331a3..000000000
--- 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 5f1c93c8a..000000000
--- 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 7b90bc923..000000000
--- 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 37a7247e2..000000000
--- 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 366aab6b2..000000000
--- 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 f37bc6510..000000000
--- 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 680a70ca8..000000000
--- a/vendor/golang.org/x/tools/go/packages/golist.go
+++ /dev/null
@@ -1,1086 +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 r.seenPackages[p.ID] != nil {
-		return
-	}
-	r.seenPackages[p.ID] = p
-	r.dr.Packages = append(r.dr.Packages, p)
-}
-
-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 {
-		eqidx := strings.Index(pattern, "=")
-		if eqidx < 0 {
-			restPatterns = append(restPatterns, pattern)
-		} else {
-			query, value := pattern[:eqidx], pattern[eqidx+len("="):]
-			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
-				pkg.Errors = append(pkg.Errors, Error{
-					Msg:  "go list failed to return CompiledGoFiles. This may indicate failure to perform cgo processing; try building at the command line. See https://golang.org/issue/38990.",
-					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)),
-	}
-
-	// 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 d9d5a45cd..000000000
--- 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 69eec9f44..000000000
--- 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 060ab08ef..000000000
--- a/vendor/golang.org/x/tools/go/packages/packages.go
+++ /dev/null
@@ -1,1559 +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)
-		}
-	}
-
-	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
-	}
-	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
-}
-
-// 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
-
-	// 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,
-		}
-		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" {
-		// Fill in the blanks to avoid surprises.
-		lpkg.Types = types.Unsafe
-		lpkg.Fset = ld.Fset
-		lpkg.Syntax = []*ast.File{}
-		lpkg.TypesInfo = new(types.Info)
-		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 && !lpg.needsrc,
-	// so that NeedSyntax without NeedTypes can be satisfied by export data.
-	if !lpkg.needsrc {
-		if err := ld.loadFromExportData(lpkg); err != nil {
-			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
-	}
-
-	// Populate TypesInfo only if needed, as it
-	// causes the type checker to work much harder.
-	if ld.Config.Mode&NeedTypesInfo != 0 {
-		lpkg.TypesInfo = &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),
-		}
-	}
-	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
-		}
-		log.Fatalf("internal error: package %q without types was imported from %q", path, lpkg)
-		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
-	}
-	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
-}
-
-// 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{}
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 af6a60d75..000000000
--- 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 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 6c0c74968..000000000
--- a/vendor/golang.org/x/tools/go/types/objectpath/objectpath.go
+++ /dev/null
@@ -1,820 +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 (
-	"fmt"
-	"go/types"
-	"strconv"
-	"strings"
-
-	"golang.org/x/tools/internal/aliases"
-	"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 {
-	scopeMemo map[*types.Scope][]types.Object // memoization of scopeObjects
-}
-
-// 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)
-	}
-	scope := pkg.Scope()
-
-	// 2. package-level object?
-	if 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:
-		// Could be:
-		// - a field (obj.IsField())
-		// - a func parameter or result
-		// - a local var.
-		// Sadly there is no way to distinguish
-		// a param/result from a local
-		// so we must proceed to the find.
-
-	case *types.Func:
-		// A func, if not package-level, must be a method.
-		if recv := obj.Type().(*types.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 API for the path to the var (field/param/result) or method.
-
-	// First inspect package-level named types.
-	// In the presence of path aliases, these give
-	// the best paths because non-types may
-	// refer to types, but not the reverse.
-	empty := make([]byte, 0, 48) // initial space
-	objs := enc.scopeObjects(scope)
-	for _, o := range objs {
-		tname, ok := o.(*types.TypeName)
-		if !ok {
-			continue // handle non-types in second pass
-		}
-
-		path := append(empty, o.Name()...)
-		path = append(path, opType)
-
-		T := o.Type()
-		if alias, ok := T.(*types.Alias); ok {
-			if r := findTypeParam(obj, aliases.TypeParams(alias), path, opTypeParam); r != nil {
-				return Path(r), nil
-			}
-			if r := find(obj, aliases.Rhs(alias), append(path, opRhs)); r != nil {
-				return Path(r), nil
-			}
-
-		} else if tname.IsAlias() {
-			// legacy alias
-			if r := find(obj, T, path); r != nil {
-				return Path(r), nil
-			}
-
-		} else if named, ok := T.(*types.Named); ok {
-			// defined (named) type
-			if r := findTypeParam(obj, named.TypeParams(), path, opTypeParam); r != nil {
-				return Path(r), nil
-			}
-			if r := find(obj, named.Underlying(), append(path, opUnderlying)); r != nil {
-				return Path(r), nil
-			}
-		}
-	}
-
-	// Then inspect everything else:
-	// non-types, and declared methods of defined types.
-	for _, o := range objs {
-		path := append(empty, o.Name()...)
-		if _, ok := o.(*types.TypeName); !ok {
-			if o.Exported() {
-				// exported non-type (const, var, func)
-				if r := find(obj, o.Type(), append(path, opType)); r != nil {
-					return Path(r), nil
-				}
-			}
-			continue
-		}
-
-		// Inspect declared methods of defined types.
-		if T, ok := types.Unalias(o.Type()).(*types.Named); ok {
-			path = append(path, opType)
-			// 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)
-				path2 := appendOpArg(path, opMethod, i)
-				if m == obj {
-					return Path(path2), nil // found declared method
-				}
-				if r := find(obj, m.Type(), append(path2, opType)); r != nil {
-					return Path(r), nil
-				}
-			}
-		}
-	}
-
-	return "", fmt.Errorf("can't find path for %v in %s", obj, pkg.Path())
-}
-
-func appendOpArg(path []byte, op byte, arg int) []byte {
-	path = append(path, op)
-	path = strconv.AppendInt(path, int64(arg), 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.Type().(*types.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)))
-}
-
-// find finds obj within type T, returning the path to it, or nil if not found.
-//
-// The seen map is used to short circuit cycles through type parameters. If
-// nil, it will be allocated as necessary.
-//
-// The seenMethods map is used internally 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.
-func find(obj types.Object, T types.Type, path []byte) []byte {
-	return (&finder{obj: obj}).find(T, path)
-}
-
-// finder closes over search state for a call to find.
-type finder struct {
-	obj             types.Object             // the sought object
-	seenTParamNames map[*types.TypeName]bool // for cycle breaking through type parameters
-	seenMethods     map[*types.Func]bool     // for cycle breaking through recursive interfaces
-}
-
-func (f *finder) find(T types.Type, path []byte) []byte {
-	switch T := T.(type) {
-	case *types.Alias:
-		return f.find(types.Unalias(T), path)
-	case *types.Basic, *types.Named:
-		// Named types belonging to pkg were handled already,
-		// so T must belong to another package. No path.
-		return nil
-	case *types.Pointer:
-		return f.find(T.Elem(), append(path, opElem))
-	case *types.Slice:
-		return f.find(T.Elem(), append(path, opElem))
-	case *types.Array:
-		return f.find(T.Elem(), append(path, opElem))
-	case *types.Chan:
-		return f.find(T.Elem(), append(path, opElem))
-	case *types.Map:
-		if r := f.find(T.Key(), append(path, opKey)); r != nil {
-			return r
-		}
-		return f.find(T.Elem(), append(path, opElem))
-	case *types.Signature:
-		if r := f.findTypeParam(T.RecvTypeParams(), path, opRecvTypeParam); r != nil {
-			return r
-		}
-		if r := f.findTypeParam(T.TypeParams(), path, opTypeParam); r != nil {
-			return r
-		}
-		if r := f.find(T.Params(), append(path, opParams)); r != nil {
-			return r
-		}
-		return f.find(T.Results(), append(path, opResults))
-	case *types.Struct:
-		for i := 0; i < T.NumFields(); i++ {
-			fld := T.Field(i)
-			path2 := appendOpArg(path, opField, i)
-			if fld == f.obj {
-				return path2 // found field var
-			}
-			if r := f.find(fld.Type(), append(path2, opType)); r != nil {
-				return r
-			}
-		}
-		return nil
-	case *types.Tuple:
-		for i := 0; i < T.Len(); i++ {
-			v := T.At(i)
-			path2 := appendOpArg(path, opAt, i)
-			if v == f.obj {
-				return path2 // found param/result var
-			}
-			if r := f.find(v.Type(), append(path2, opType)); r != nil {
-				return r
-			}
-		}
-		return nil
-	case *types.Interface:
-		for i := 0; i < T.NumMethods(); i++ {
-			m := T.Method(i)
-			if f.seenMethods[m] {
-				return nil
-			}
-			path2 := appendOpArg(path, opMethod, i)
-			if m == f.obj {
-				return path2 // found interface method
-			}
-			if f.seenMethods == nil {
-				f.seenMethods = make(map[*types.Func]bool)
-			}
-			f.seenMethods[m] = true
-			if r := f.find(m.Type(), append(path2, opType)); r != nil {
-				return r
-			}
-		}
-		return nil
-	case *types.TypeParam:
-		name := T.Obj()
-		if f.seenTParamNames[name] {
-			return nil
-		}
-		if name == f.obj {
-			return append(path, opObj)
-		}
-		if f.seenTParamNames == nil {
-			f.seenTParamNames = make(map[*types.TypeName]bool)
-		}
-		f.seenTParamNames[name] = true
-		if r := f.find(T.Constraint(), append(path, opConstraint)); r != nil {
-			return r
-		}
-		return nil
-	}
-	panic(T)
-}
-
-func findTypeParam(obj types.Object, list *types.TypeParamList, path []byte, op byte) []byte {
-	return (&finder{obj: obj}).findTypeParam(list, path, op)
-}
-
-func (f *finder) findTypeParam(list *types.TypeParamList, path []byte, op byte) []byte {
-	for i := 0; i < list.Len(); i++ {
-		tparam := list.At(i)
-		path2 := appendOpArg(path, op, i)
-		if r := f.find(tparam, path2); r != nil {
-			return r
-		}
-	}
-	return nil
-}
-
-// 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 = aliases.Rhs(alias)
-			} else if false && aliases.Enabled() {
-				// The Enabled check is too expensive, so for now we
-				// simply assume that aliases are not enabled.
-				//
-				// Now that go1.24 is assured, we should be able to
-				// replace this with "if true {", but it causes 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("tuple 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("tuple 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
-}
-
-// scopeObjects is a memoization of scope objects.
-// Callers must not modify the result.
-func (enc *Encoder) scopeObjects(scope *types.Scope) []types.Object {
-	m := enc.scopeMemo
-	if m == nil {
-		m = make(map[*types.Scope][]types.Object)
-		enc.scopeMemo = m
-	}
-	objs, ok := m[scope]
-	if !ok {
-		names := scope.Names() // allocates and sorts
-		objs = make([]types.Object, len(names))
-		for i, name := range names {
-			objs[i] = scope.Lookup(name)
-		}
-		m[scope] = objs
-	}
-	return objs
-}
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 5f10f56cb..000000000
--- a/vendor/golang.org/x/tools/go/types/typeutil/callee.go
+++ /dev/null
@@ -1,85 +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.
-//
-// 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 b81ce0c33..000000000
--- 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 f035a0b6b..000000000
--- a/vendor/golang.org/x/tools/go/types/typeutil/map.go
+++ /dev/null
@@ -1,460 +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 i := 0; i < targs.Len(); i++ {
-			targ := targs.At(i)
-			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 f7666028f..000000000
--- 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 9dda6a25d..000000000
--- 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/imports/forward.go b/vendor/golang.org/x/tools/imports/forward.go
deleted file mode 100644
index 22ae77772..000000000
--- a/vendor/golang.org/x/tools/imports/forward.go
+++ /dev/null
@@ -1,71 +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 imports implements a Go pretty-printer (like package "go/format")
-// that also adds or removes import statements as necessary.
-package imports // import "golang.org/x/tools/imports"
-
-import (
-	"log"
-	"os"
-
-	"golang.org/x/tools/internal/gocommand"
-	intimp "golang.org/x/tools/internal/imports"
-)
-
-// Options specifies options for processing files.
-type Options struct {
-	Fragment  bool // Accept fragment of a source file (no package statement)
-	AllErrors bool // Report all errors (not just the first 10 on different lines)
-
-	Comments  bool // Print comments (true if nil *Options provided)
-	TabIndent bool // Use tabs for indent (true if nil *Options provided)
-	TabWidth  int  // Tab width (8 if nil *Options provided)
-
-	FormatOnly bool // Disable the insertion and deletion of imports
-}
-
-// Debug controls verbose logging.
-var Debug = false
-
-// LocalPrefix is a comma-separated string of import path prefixes, which, if
-// set, instructs Process to sort the import paths with the given prefixes
-// into another group after 3rd-party packages.
-var LocalPrefix string
-
-// Process formats and adjusts imports for the provided file.
-// If opt is nil the defaults are used, and if src is nil the source
-// is read from the filesystem.
-//
-// Note that filename's directory influences which imports can be chosen,
-// so it is important that filename be accurate.
-// To process data “as if” it were in filename, pass the data as a non-nil src.
-func Process(filename string, src []byte, opt *Options) ([]byte, error) {
-	var err error
-	if src == nil {
-		src, err = os.ReadFile(filename)
-		if err != nil {
-			return nil, err
-		}
-	}
-	if opt == nil {
-		opt = &Options{Comments: true, TabIndent: true, TabWidth: 8}
-	}
-	intopt := &intimp.Options{
-		Env: &intimp.ProcessEnv{
-			GocmdRunner: &gocommand.Runner{},
-		},
-		LocalPrefix: LocalPrefix,
-		AllErrors:   opt.AllErrors,
-		Comments:    opt.Comments,
-		FormatOnly:  opt.FormatOnly,
-		Fragment:    opt.Fragment,
-		TabIndent:   opt.TabIndent,
-		TabWidth:    opt.TabWidth,
-	}
-	if Debug {
-		intopt.Env.Logf = log.Printf
-	}
-	return intimp.Process(filename, src, intopt)
-}
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 b9425f5a2..000000000
--- a/vendor/golang.org/x/tools/internal/aliases/aliases.go
+++ /dev/null
@@ -1,38 +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"
-)
-
-// Package aliases defines backward compatible shims
-// for the types.Alias type representation added in 1.22.
-// This defines placeholders for x/tools until 1.26.
-
-// NewAlias creates a new TypeName in Package pkg that
-// is an alias for the type rhs.
-//
-// The enabled parameter determines whether the resulting [TypeName]'s
-// type is an [types.Alias]. Its value must be the result of a call to
-// [Enabled], which computes the effective value of
-// GODEBUG=gotypesalias=... by invoking the type checker. The Enabled
-// function is expensive and should be called once per task (e.g.
-// package import), not once per call to NewAlias.
-//
-// Precondition: enabled || len(tparams)==0.
-// If materialized aliases are disabled, there must not be any type parameters.
-func NewAlias(enabled bool, pos token.Pos, pkg *types.Package, name string, rhs types.Type, tparams []*types.TypeParam) *types.TypeName {
-	if enabled {
-		tname := types.NewTypeName(pos, pkg, name, nil)
-		SetTypeParams(types.NewAlias(tname, rhs), tparams)
-		return tname
-	}
-	if len(tparams) > 0 {
-		panic("cannot create an alias with type parameters when gotypesalias is not enabled")
-	}
-	return types.NewTypeName(pos, pkg, name, rhs)
-}
diff --git a/vendor/golang.org/x/tools/internal/aliases/aliases_go122.go b/vendor/golang.org/x/tools/internal/aliases/aliases_go122.go
deleted file mode 100644
index 7716a3331..000000000
--- a/vendor/golang.org/x/tools/internal/aliases/aliases_go122.go
+++ /dev/null
@@ -1,80 +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/ast"
-	"go/parser"
-	"go/token"
-	"go/types"
-)
-
-// Rhs returns the type on the right-hand side of the alias declaration.
-func Rhs(alias *types.Alias) types.Type {
-	if alias, ok := any(alias).(interface{ Rhs() types.Type }); ok {
-		return alias.Rhs() // go1.23+
-	}
-
-	// go1.22's Alias didn't have the Rhs method,
-	// so Unalias is the best we can do.
-	return types.Unalias(alias)
-}
-
-// TypeParams returns the type parameter list of the alias.
-func TypeParams(alias *types.Alias) *types.TypeParamList {
-	if alias, ok := any(alias).(interface{ TypeParams() *types.TypeParamList }); ok {
-		return alias.TypeParams() // go1.23+
-	}
-	return nil
-}
-
-// SetTypeParams sets the type parameters of the alias type.
-func SetTypeParams(alias *types.Alias, tparams []*types.TypeParam) {
-	if alias, ok := any(alias).(interface {
-		SetTypeParams(tparams []*types.TypeParam)
-	}); ok {
-		alias.SetTypeParams(tparams) // go1.23+
-	} else if len(tparams) > 0 {
-		panic("cannot set type parameters of an Alias type in go1.22")
-	}
-}
-
-// TypeArgs returns the type arguments used to instantiate the Alias type.
-func TypeArgs(alias *types.Alias) *types.TypeList {
-	if alias, ok := any(alias).(interface{ TypeArgs() *types.TypeList }); ok {
-		return alias.TypeArgs() // go1.23+
-	}
-	return nil // empty (go1.22)
-}
-
-// Origin returns the generic Alias type of which alias is an instance.
-// If alias is not an instance of a generic alias, Origin returns alias.
-func Origin(alias *types.Alias) *types.Alias {
-	if alias, ok := any(alias).(interface{ Origin() *types.Alias }); ok {
-		return alias.Origin() // go1.23+
-	}
-	return alias // not an instance of a generic alias (go1.22)
-}
-
-// Enabled reports whether [NewAlias] should create [types.Alias] types.
-//
-// This function is expensive! Call it sparingly.
-func Enabled() bool {
-	// The only reliable way to compute the answer is to invoke go/types.
-	// We don't parse the GODEBUG environment variable, because
-	// (a) it's tricky to do so in a manner that is consistent
-	//     with the godebug package; in particular, a simple
-	//     substring check is not good enough. The value is a
-	//     rightmost-wins list of options. But more importantly:
-	// (b) it is impossible to detect changes to the effective
-	//     setting caused by os.Setenv("GODEBUG"), as happens in
-	//     many tests. Therefore any attempt to cache the result
-	//     is just incorrect.
-	fset := token.NewFileSet()
-	f, _ := parser.ParseFile(fset, "a.go", "package p; type A = int", parser.SkipObjectResolution)
-	pkg, _ := new(types.Config).Check("p", fset, []*ast.File{f}, nil)
-	_, enabled := pkg.Scope().Lookup("A").Type().(*types.Alias)
-	return enabled
-}
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 ade5d1e79..000000000
--- a/vendor/golang.org/x/tools/internal/event/core/event.go
+++ /dev/null
@@ -1,80 +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"
-	"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 index := 0; ev.Valid(index); index++ {
-		if l := ev.Label(index); l.Valid() {
-			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)]
-}
-
-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 05f3a9a57..000000000
--- a/vendor/golang.org/x/tools/internal/event/core/export.go
+++ /dev/null
@@ -1,70 +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"
-	"unsafe"
-
-	"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 unsafe.Pointer
-)
-
-// 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) {
-	p := unsafe.Pointer(&e)
-	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
-		p = nil
-	}
-	atomic.StorePointer(&exporter, p)
-}
-
-// 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)(atomic.LoadPointer(&exporter))
-	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)(atomic.LoadPointer(&exporter))
-	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 06c1d4615..000000000
--- 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 5dc6e6bab..000000000
--- 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 4d55e577d..000000000
--- 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 4cfa51b61..000000000
--- a/vendor/golang.org/x/tools/internal/event/keys/keys.go
+++ /dev/null
@@ -1,564 +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"
-	"io"
-	"math"
-	"strconv"
-
-	"golang.org/x/tools/internal/event/label"
-)
-
-// Value represents a 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) Format(w io.Writer, buf []byte, l label.Label) {
-	fmt.Fprint(w, k.From(l))
-}
-
-// Get can be used to get a label for the key from 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 can be used to get a value from 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 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) Format(w io.Writer, buf []byte, l label.Label) {}
-
-// New creates a new Label with this key.
-func (k *Tag) New() label.Label { return label.OfValue(k, nil) }
-
-// Int represents a key
-type Int struct {
-	name        string
-	description string
-}
-
-// NewInt creates a new Key for int 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) Format(w io.Writer, buf []byte, l label.Label) {
-	w.Write(strconv.AppendInt(buf, int64(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 label.Of64(k, uint64(v)) }
-
-// Get can be used to get a label for the key from a label.Map.
-func (k *Int) Get(lm label.Map) int {
-	if t := lm.Find(k); t.Valid() {
-		return k.From(t)
-	}
-	return 0
-}
-
-// From can be used to get a value from a Label.
-func (k *Int) From(t label.Label) int { return int(t.Unpack64()) }
-
-// Int8 represents a key
-type Int8 struct {
-	name        string
-	description string
-}
-
-// NewInt8 creates a new Key for int8 values.
-func NewInt8(name, description string) *Int8 {
-	return &Int8{name: name, description: description}
-}
-
-func (k *Int8) Name() string        { return k.name }
-func (k *Int8) Description() string { return k.description }
-
-func (k *Int8) Format(w io.Writer, buf []byte, l label.Label) {
-	w.Write(strconv.AppendInt(buf, int64(k.From(l)), 10))
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *Int8) Of(v int8) label.Label { return label.Of64(k, uint64(v)) }
-
-// Get can be used to get a label for the key from a label.Map.
-func (k *Int8) Get(lm label.Map) int8 {
-	if t := lm.Find(k); t.Valid() {
-		return k.From(t)
-	}
-	return 0
-}
-
-// From can be used to get a value from a Label.
-func (k *Int8) From(t label.Label) int8 { return int8(t.Unpack64()) }
-
-// Int16 represents a key
-type Int16 struct {
-	name        string
-	description string
-}
-
-// NewInt16 creates a new Key for int16 values.
-func NewInt16(name, description string) *Int16 {
-	return &Int16{name: name, description: description}
-}
-
-func (k *Int16) Name() string        { return k.name }
-func (k *Int16) Description() string { return k.description }
-
-func (k *Int16) Format(w io.Writer, buf []byte, l label.Label) {
-	w.Write(strconv.AppendInt(buf, int64(k.From(l)), 10))
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *Int16) Of(v int16) label.Label { return label.Of64(k, uint64(v)) }
-
-// Get can be used to get a label for the key from a label.Map.
-func (k *Int16) Get(lm label.Map) int16 {
-	if t := lm.Find(k); t.Valid() {
-		return k.From(t)
-	}
-	return 0
-}
-
-// From can be used to get a value from a Label.
-func (k *Int16) From(t label.Label) int16 { return int16(t.Unpack64()) }
-
-// Int32 represents a key
-type Int32 struct {
-	name        string
-	description string
-}
-
-// NewInt32 creates a new Key for int32 values.
-func NewInt32(name, description string) *Int32 {
-	return &Int32{name: name, description: description}
-}
-
-func (k *Int32) Name() string        { return k.name }
-func (k *Int32) Description() string { return k.description }
-
-func (k *Int32) Format(w io.Writer, buf []byte, l label.Label) {
-	w.Write(strconv.AppendInt(buf, int64(k.From(l)), 10))
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *Int32) Of(v int32) label.Label { return label.Of64(k, uint64(v)) }
-
-// Get can be used to get a label for the key from a label.Map.
-func (k *Int32) Get(lm label.Map) int32 {
-	if t := lm.Find(k); t.Valid() {
-		return k.From(t)
-	}
-	return 0
-}
-
-// From can be used to get a value from a Label.
-func (k *Int32) From(t label.Label) int32 { return int32(t.Unpack64()) }
-
-// Int64 represents a key
-type Int64 struct {
-	name        string
-	description string
-}
-
-// NewInt64 creates a new Key for int64 values.
-func NewInt64(name, description string) *Int64 {
-	return &Int64{name: name, description: description}
-}
-
-func (k *Int64) Name() string        { return k.name }
-func (k *Int64) Description() string { return k.description }
-
-func (k *Int64) Format(w io.Writer, buf []byte, l label.Label) {
-	w.Write(strconv.AppendInt(buf, k.From(l), 10))
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *Int64) Of(v int64) label.Label { return label.Of64(k, uint64(v)) }
-
-// Get can be used to get a label for the key from a label.Map.
-func (k *Int64) Get(lm label.Map) int64 {
-	if t := lm.Find(k); t.Valid() {
-		return k.From(t)
-	}
-	return 0
-}
-
-// From can be used to get a value from a Label.
-func (k *Int64) From(t label.Label) int64 { return int64(t.Unpack64()) }
-
-// UInt represents a key
-type UInt struct {
-	name        string
-	description string
-}
-
-// NewUInt creates a new Key for uint 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) Format(w io.Writer, buf []byte, l label.Label) {
-	w.Write(strconv.AppendUint(buf, uint64(k.From(l)), 10))
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *UInt) Of(v uint) label.Label { return label.Of64(k, uint64(v)) }
-
-// Get can be used to get a label for the key from a label.Map.
-func (k *UInt) Get(lm label.Map) uint {
-	if t := lm.Find(k); t.Valid() {
-		return k.From(t)
-	}
-	return 0
-}
-
-// From can be used to get a value from a Label.
-func (k *UInt) From(t label.Label) uint { return uint(t.Unpack64()) }
-
-// UInt8 represents a key
-type UInt8 struct {
-	name        string
-	description string
-}
-
-// NewUInt8 creates a new Key for uint8 values.
-func NewUInt8(name, description string) *UInt8 {
-	return &UInt8{name: name, description: description}
-}
-
-func (k *UInt8) Name() string        { return k.name }
-func (k *UInt8) Description() string { return k.description }
-
-func (k *UInt8) Format(w io.Writer, buf []byte, l label.Label) {
-	w.Write(strconv.AppendUint(buf, uint64(k.From(l)), 10))
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *UInt8) Of(v uint8) label.Label { return label.Of64(k, uint64(v)) }
-
-// Get can be used to get a label for the key from a label.Map.
-func (k *UInt8) Get(lm label.Map) uint8 {
-	if t := lm.Find(k); t.Valid() {
-		return k.From(t)
-	}
-	return 0
-}
-
-// From can be used to get a value from a Label.
-func (k *UInt8) From(t label.Label) uint8 { return uint8(t.Unpack64()) }
-
-// UInt16 represents a key
-type UInt16 struct {
-	name        string
-	description string
-}
-
-// NewUInt16 creates a new Key for uint16 values.
-func NewUInt16(name, description string) *UInt16 {
-	return &UInt16{name: name, description: description}
-}
-
-func (k *UInt16) Name() string        { return k.name }
-func (k *UInt16) Description() string { return k.description }
-
-func (k *UInt16) Format(w io.Writer, buf []byte, l label.Label) {
-	w.Write(strconv.AppendUint(buf, uint64(k.From(l)), 10))
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *UInt16) Of(v uint16) label.Label { return label.Of64(k, uint64(v)) }
-
-// Get can be used to get a label for the key from a label.Map.
-func (k *UInt16) Get(lm label.Map) uint16 {
-	if t := lm.Find(k); t.Valid() {
-		return k.From(t)
-	}
-	return 0
-}
-
-// From can be used to get a value from a Label.
-func (k *UInt16) From(t label.Label) uint16 { return uint16(t.Unpack64()) }
-
-// UInt32 represents a key
-type UInt32 struct {
-	name        string
-	description string
-}
-
-// NewUInt32 creates a new Key for uint32 values.
-func NewUInt32(name, description string) *UInt32 {
-	return &UInt32{name: name, description: description}
-}
-
-func (k *UInt32) Name() string        { return k.name }
-func (k *UInt32) Description() string { return k.description }
-
-func (k *UInt32) Format(w io.Writer, buf []byte, l label.Label) {
-	w.Write(strconv.AppendUint(buf, uint64(k.From(l)), 10))
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *UInt32) Of(v uint32) label.Label { return label.Of64(k, uint64(v)) }
-
-// Get can be used to get a label for the key from a label.Map.
-func (k *UInt32) Get(lm label.Map) uint32 {
-	if t := lm.Find(k); t.Valid() {
-		return k.From(t)
-	}
-	return 0
-}
-
-// From can be used to get a value from a Label.
-func (k *UInt32) From(t label.Label) uint32 { return uint32(t.Unpack64()) }
-
-// UInt64 represents a key
-type UInt64 struct {
-	name        string
-	description string
-}
-
-// NewUInt64 creates a new Key for uint64 values.
-func NewUInt64(name, description string) *UInt64 {
-	return &UInt64{name: name, description: description}
-}
-
-func (k *UInt64) Name() string        { return k.name }
-func (k *UInt64) Description() string { return k.description }
-
-func (k *UInt64) Format(w io.Writer, buf []byte, l label.Label) {
-	w.Write(strconv.AppendUint(buf, k.From(l), 10))
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *UInt64) Of(v uint64) label.Label { return label.Of64(k, v) }
-
-// Get can be used to get a label for the key from a label.Map.
-func (k *UInt64) Get(lm label.Map) uint64 {
-	if t := lm.Find(k); t.Valid() {
-		return k.From(t)
-	}
-	return 0
-}
-
-// From can be used to get a value from a Label.
-func (k *UInt64) From(t label.Label) uint64 { return t.Unpack64() }
-
-// Float32 represents a key
-type Float32 struct {
-	name        string
-	description string
-}
-
-// NewFloat32 creates a new Key for float32 values.
-func NewFloat32(name, description string) *Float32 {
-	return &Float32{name: name, description: description}
-}
-
-func (k *Float32) Name() string        { return k.name }
-func (k *Float32) Description() string { return k.description }
-
-func (k *Float32) Format(w io.Writer, buf []byte, l label.Label) {
-	w.Write(strconv.AppendFloat(buf, float64(k.From(l)), 'E', -1, 32))
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *Float32) Of(v float32) label.Label {
-	return label.Of64(k, uint64(math.Float32bits(v)))
-}
-
-// Get can be used to get a label for the key from a label.Map.
-func (k *Float32) Get(lm label.Map) float32 {
-	if t := lm.Find(k); t.Valid() {
-		return k.From(t)
-	}
-	return 0
-}
-
-// From can be used to get a value from a Label.
-func (k *Float32) From(t label.Label) float32 {
-	return math.Float32frombits(uint32(t.Unpack64()))
-}
-
-// Float64 represents a key
-type Float64 struct {
-	name        string
-	description string
-}
-
-// NewFloat64 creates a new Key for int64 values.
-func NewFloat64(name, description string) *Float64 {
-	return &Float64{name: name, description: description}
-}
-
-func (k *Float64) Name() string        { return k.name }
-func (k *Float64) Description() string { return k.description }
-
-func (k *Float64) Format(w io.Writer, buf []byte, l label.Label) {
-	w.Write(strconv.AppendFloat(buf, k.From(l), 'E', -1, 64))
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *Float64) Of(v float64) label.Label {
-	return label.Of64(k, math.Float64bits(v))
-}
-
-// Get can be used to get a label for the key from a label.Map.
-func (k *Float64) Get(lm label.Map) float64 {
-	if t := lm.Find(k); t.Valid() {
-		return k.From(t)
-	}
-	return 0
-}
-
-// From can be used to get a value from a Label.
-func (k *Float64) 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) Format(w io.Writer, buf []byte, l label.Label) {
-	w.Write(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 can be used to get a label for the key from a label.Map.
-func (k *String) Get(lm label.Map) string {
-	if t := lm.Find(k); t.Valid() {
-		return k.From(t)
-	}
-	return ""
-}
-
-// From can be used to get a value from a Label.
-func (k *String) From(t label.Label) string { return t.UnpackString() }
-
-// Boolean represents a key
-type Boolean struct {
-	name        string
-	description string
-}
-
-// NewBoolean creates a new Key for bool values.
-func NewBoolean(name, description string) *Boolean {
-	return &Boolean{name: name, description: description}
-}
-
-func (k *Boolean) Name() string        { return k.name }
-func (k *Boolean) Description() string { return k.description }
-
-func (k *Boolean) Format(w io.Writer, buf []byte, l label.Label) {
-	w.Write(strconv.AppendBool(buf, k.From(l)))
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *Boolean) Of(v bool) label.Label {
-	if v {
-		return label.Of64(k, 1)
-	}
-	return label.Of64(k, 0)
-}
-
-// Get can be used to get a label for the key from a label.Map.
-func (k *Boolean) Get(lm label.Map) bool {
-	if t := lm.Find(k); t.Valid() {
-		return k.From(t)
-	}
-	return false
-}
-
-// From can be used to get a value from a Label.
-func (k *Boolean) From(t label.Label) bool { return t.Unpack64() > 0 }
-
-// Error represents a key
-type Error struct {
-	name        string
-	description string
-}
-
-// NewError creates a new Key for int64 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) Format(w io.Writer, buf []byte, l label.Label) {
-	io.WriteString(w, k.From(l).Error())
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *Error) Of(v error) label.Label { return label.OfValue(k, v) }
-
-// Get can be used to get a label for the key from 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 can be used to get a value from 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 7e9586659..000000000
--- 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 c0e8e731c..000000000
--- 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 92a391057..000000000
--- a/vendor/golang.org/x/tools/internal/event/label/label.go
+++ /dev/null
@@ -1,214 +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"
-	"reflect"
-	"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
-
-	// Format is used in formatting to append the value of the label to the
-	// supplied buffer.
-	// The formatter may use the supplied buf as a scratch area to avoid
-	// allocations.
-	Format(w io.Writer, buf []byte, l Label)
-}
-
-// 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 {
-	hdr := (*reflect.StringHeader)(unsafe.Pointer(&v))
-	return Label{
-		key:     k,
-		packed:  uint64(hdr.Len),
-		untyped: stringptr(hdr.Data),
-	}
-}
-
-// 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 {
-	var v string
-	hdr := (*reflect.StringHeader)(unsafe.Pointer(&v))
-	hdr.Data = uintptr(t.untyped.(stringptr))
-	hdr.Len = int(t.packed)
-	return v
-}
-
-// 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, "=")
-	var buf [128]byte
-	t.Key().Format(f, buf[:0], t)
-}
-
-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 734c46198..000000000
--- 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 {
-	// 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 5662a311d..000000000
--- 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 3dbd21d1b..000000000
--- 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 4a4357d2b..000000000
--- a/vendor/golang.org/x/tools/internal/gcimporter/iexport.go
+++ /dev/null
@@ -1,1595 +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"
-	"golang.org/x/tools/internal/aliases"
-)
-
-// 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) // may fail when aliases are not enabled
-
-			var tparams *types.TypeParamList
-			if materialized {
-				tparams = aliases.TypeParams(alias)
-			}
-			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 = aliases.Rhs(alias)
-			}
-			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)
-
-			// 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 i := 0; i < rparams.Len(); i++ {
-					rparam := rparams.At(i)
-					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) {
-	// 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())
-}
-
-// TODO(rfindley): what does 'pkg' even mean here? It would be better to pass
-// it in explicitly into signatures and structs that may use it for
-// constructing fields.
-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))
-}
-
-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 := aliases.TypeArgs(t); targs.Len() > 0 {
-			w.startType(instanceType)
-			w.pos(t.Obj().Pos())
-			w.typeList(targs, pkg)
-			w.typ(aliases.Origin(t), 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)
-		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)
-
-		n := t.NumEmbeddeds()
-		w.uint64(uint64(n))
-		for i := 0; i < n; i++ {
-			ft := t.EmbeddedType(i)
-			tPkg := pkg
-			if named, _ := types.Unalias(ft).(*types.Named); named != nil {
-				w.pos(named.Obj().Pos())
-			} else {
-				w.pos(token.NoPos)
-			}
-			w.typ(ft, tPkg)
-		}
-
-		// 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 i := 0; i < ts.Len(); i++ {
-		w.typ(ts.At(i), pkg)
-	}
-}
-
-func (w *exportWriter) tparamList(prefix string, list *types.TypeParamList, pkg *types.Package) {
-	ll := uint64(list.Len())
-	w.uint64(ll)
-	for i := 0; i < list.Len(); i++ {
-		tparam := list.At(i)
-		// Set the type parameter exportName before exporting its type.
-		exportName := tparamExportName(prefix, tparam)
-		w.p.tparamNames[tparam.Obj()] = exportName
-		w.typ(list.At(i), 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 82e6c9d2d..000000000
--- a/vendor/golang.org/x/tools/internal/gcimporter/iimport.go
+++ /dev/null
@@ -1,1120 +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
-	iexportVersion         = iexportVersionGenerics
-
-	iexportVersionCurrent = 2
-)
-
-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 iexportVersionGo1_18, iexportVersionPosCol, iexportVersionGo1_11:
-	default:
-		if version > iexportVersionGo1_18 {
-			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,
-		aliases: aliases.Enabled(),
-		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
-
-	aliases bool
-	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, currPkg: pkg}
-	r.declReader.Reset(p.declData[off:])
-
-	r.obj(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
-	currPkg    *types.Package
-	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) {}
-
-func (r *importReader) obj(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.NewAlias(r.p.aliases, pos, r.currPkg, name, typ, tparams)
-		markBlack(obj) // workaround for golang/go#69912
-		r.declare(obj)
-
-	case constTag:
-		typ, val := r.value()
-
-		r.declare(types.NewConst(pos, r.currPkg, name, typ, val))
-
-	case funcTag, genericFuncTag:
-		var tparams []*types.TypeParam
-		if tag == genericFuncTag {
-			tparams = r.tparamList()
-		}
-		sig := r.signature(nil, nil, tparams)
-		r.declare(types.NewFunc(pos, r.currPkg, name, sig))
-
-	case typeTag, genericTypeTag:
-		// Types can be recursive. We need to setup a stub
-		// declaration before recursing.
-		obj := types.NewTypeName(pos, r.currPkg, 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()
-				recv := r.param()
-
-				// 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(recv, rparams, nil)
-
-				named.AddMethod(types.NewFunc(mpos, r.currPkg, 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, r.currPkg, 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{r.currPkg, 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, r.currPkg, 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:
-		r.currPkg = r.pkg()
-		return r.signature(nil, nil, nil)
-
-	case structType:
-		r.currPkg = 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, r.currPkg, fname, ftyp, emb)
-			}
-
-			fields[i] = field
-			tags[i] = tag
-		}
-		return types.NewStruct(fields, tags)
-
-	case interfaceType:
-		r.currPkg = r.pkg()
-
-		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, r.currPkg, "", base)
-			}
-			msig := r.signature(recv, nil, nil)
-
-			if method == nil {
-				method = types.NewFunc(mpos, r.currPkg, 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(recv *types.Var, rparams []*types.TypeParam, tparams []*types.TypeParam) *types.Signature {
-	params := r.paramList()
-	results := r.paramList()
-	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() *types.Tuple {
-	xs := make([]*types.Var, r.uint64())
-	for i := range xs {
-		xs[i] = r.param()
-	}
-	return types.NewTuple(xs...)
-}
-
-func (r *importReader) param() *types.Var {
-	pos := r.pos()
-	name := r.ident()
-	typ := r.typ()
-	return types.NewParam(pos, r.currPkg, 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 907c8557a..000000000
--- 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 4af810dc4..000000000
--- 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_yes.go b/vendor/golang.org/x/tools/internal/gcimporter/ureader_yes.go
deleted file mode 100644
index 37b4a39e9..000000000
--- a/vendor/golang.org/x/tools/internal/gcimporter/ureader_yes.go
+++ /dev/null
@@ -1,761 +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"
-
-	"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
-	aliases bool                      // create types.Alias nodes
-
-	// 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.
-	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,
-		aliases: aliases.Enabled(),
-
-		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 {
-	// bounds is a slice of typeInfos corresponding to the underlying
-	// bounds of the element's type parameters.
-	bounds []typeInfo
-
-	// tparams is a slice of the constructed TypeParams for the element.
-	tparams []*types.TypeParam
-
-	// 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:
-		return r.dict.tparams[r.Len()]
-
-	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
-	}
-
-	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()
-			}
-			typ := r.typ()
-			declare(aliases.NewAlias(r.p.aliases, 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()
-			tparams := r.typeParamNames()
-			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())
-
-			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())
-			}
-
-		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)
-		}
-
-		dict.bounds = make([]typeInfo, r.Len())
-		for i := range dict.bounds {
-			dict.bounds[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() []*types.TypeParam {
-	r.Sync(pkgbits.SyncTypeParamNames)
-
-	// Note: This code assumes it only processes objects without
-	// implement type parameters. This is currently fine, because
-	// reader is only used to read in exported declarations, which are
-	// always package scoped.
-
-	if len(r.dict.bounds) == 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.
-
-	r.dict.tparams = make([]*types.TypeParam, len(r.dict.bounds))
-	for i := range r.dict.bounds {
-		pos := r.pos()
-		pkg, name := r.localIdent()
-
-		tname := types.NewTypeName(pos, pkg, name, nil)
-		r.dict.tparams[i] = types.NewTypeParam(tname, nil)
-	}
-
-	typs := make([]types.Type, len(r.dict.bounds))
-	for i, bound := range r.dict.bounds {
-		typs[i] = r.p.typIdx(bound, r.dict)
-	}
-
-	// TODO(mdempsky): This is subtle, elaborate further.
-	//
-	// We have to save tparams outside of the closure, because
-	// typeParamNames() can be called multiple times with the same
-	// dictionary instance.
-	//
-	// Also, this needs to happen later to make sure SetUnderlying has
-	// been called.
-	//
-	// 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.
-	tparams := r.dict.tparams
-	r.p.later(func() {
-		for i, typ := range typs {
-			tparams[i].SetConstraint(typ)
-		}
-	})
-
-	return r.dict.tparams
-}
-
-func (r *reader) method() *types.Func {
-	r.Sync(pkgbits.SyncMethod)
-	pos := r.pos()
-	pkg, name := r.selector()
-
-	rparams := r.typeParamNames()
-	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 58721202d..000000000
--- 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 469c648e4..000000000
--- 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 169d37c8e..000000000
--- 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 e38d1fb48..000000000
--- 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 446c5846a..000000000
--- a/vendor/golang.org/x/tools/internal/gocommand/version.go
+++ /dev/null
@@ -1,71 +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"
-	"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 = ""
-	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 i := len(tags) - 1; i >= 0; i-- {
-		var version int
-		if _, err := fmt.Sscanf(tags[i], "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/gopathwalk/walk.go b/vendor/golang.org/x/tools/internal/gopathwalk/walk.go
deleted file mode 100644
index 5252144d0..000000000
--- a/vendor/golang.org/x/tools/internal/gopathwalk/walk.go
+++ /dev/null
@@ -1,336 +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 gopathwalk is like filepath.Walk but specialized for finding Go
-// packages, particularly in $GOPATH and $GOROOT.
-package gopathwalk
-
-import (
-	"bufio"
-	"bytes"
-	"io"
-	"io/fs"
-	"os"
-	"path/filepath"
-	"runtime"
-	"slices"
-	"strings"
-	"sync"
-	"time"
-)
-
-// Options controls the behavior of a Walk call.
-type Options struct {
-	// If Logf is non-nil, debug logging is enabled through this function.
-	Logf func(format string, args ...any)
-
-	// Search module caches. Also disables legacy goimports ignore rules.
-	ModulesEnabled bool
-
-	// Maximum number of concurrent calls to user-provided callbacks,
-	// or 0 for GOMAXPROCS.
-	Concurrency int
-}
-
-// RootType indicates the type of a Root.
-type RootType int
-
-const (
-	RootUnknown RootType = iota
-	RootGOROOT
-	RootGOPATH
-	RootCurrentModule
-	RootModuleCache
-	RootOther
-)
-
-// A Root is a starting point for a Walk.
-type Root struct {
-	Path string
-	Type RootType
-}
-
-// Walk concurrently walks Go source directories ($GOROOT, $GOPATH, etc) to find packages.
-//
-// For each package found, add will be called with the absolute
-// paths of the containing source directory and the package directory.
-//
-// Unlike filepath.WalkDir, Walk follows symbolic links
-// (while guarding against cycles).
-func Walk(roots []Root, add func(root Root, dir string), opts Options) {
-	WalkSkip(roots, add, func(Root, string) bool { return false }, opts)
-}
-
-// WalkSkip concurrently walks Go source directories ($GOROOT, $GOPATH, etc) to
-// find packages.
-//
-// For each package found, add will be called with the absolute
-// paths of the containing source directory and the package directory.
-// For each directory that will be scanned, skip will be called
-// with the absolute paths of the containing source directory and the directory.
-// If skip returns false on a directory it will be processed.
-//
-// Unlike filepath.WalkDir, WalkSkip follows symbolic links
-// (while guarding against cycles).
-func WalkSkip(roots []Root, add func(root Root, dir string), skip func(root Root, dir string) bool, opts Options) {
-	for _, root := range roots {
-		walkDir(root, add, skip, opts)
-	}
-}
-
-// walkDir creates a walker and starts fastwalk with this walker.
-func walkDir(root Root, add func(Root, string), skip func(root Root, dir string) bool, opts Options) {
-	if opts.Logf == nil {
-		opts.Logf = func(format string, args ...any) {}
-	}
-	if _, err := os.Stat(root.Path); os.IsNotExist(err) {
-		opts.Logf("skipping nonexistent directory: %v", root.Path)
-		return
-	}
-	start := time.Now()
-	opts.Logf("scanning %s", root.Path)
-
-	concurrency := opts.Concurrency
-	if concurrency == 0 {
-		// The walk be either CPU-bound or I/O-bound, depending on what the
-		// caller-supplied add function does and the details of the user's platform
-		// and machine. Rather than trying to fine-tune the concurrency level for a
-		// specific environment, we default to GOMAXPROCS: it is likely to be a good
-		// choice for a CPU-bound add function, and if it is instead I/O-bound, then
-		// dealing with I/O saturation is arguably the job of the kernel and/or
-		// runtime. (Oversaturating I/O seems unlikely to harm performance as badly
-		// as failing to saturate would.)
-		concurrency = runtime.GOMAXPROCS(0)
-	}
-	w := &walker{
-		root: root,
-		add:  add,
-		skip: skip,
-		opts: opts,
-		sem:  make(chan struct{}, concurrency),
-	}
-	w.init()
-
-	w.sem <- struct{}{}
-	path := root.Path
-	if path == "" {
-		path = "."
-	}
-	if fi, err := os.Lstat(path); err == nil {
-		w.walk(path, nil, fs.FileInfoToDirEntry(fi))
-	} else {
-		w.opts.Logf("scanning directory %v: %v", root.Path, err)
-	}
-	<-w.sem
-	w.walking.Wait()
-
-	opts.Logf("scanned %s in %v", root.Path, time.Since(start))
-}
-
-// walker is the callback for fastwalk.Walk.
-type walker struct {
-	root Root                    // The source directory to scan.
-	add  func(Root, string)      // The callback that will be invoked for every possible Go package dir.
-	skip func(Root, string) bool // The callback that will be invoked for every dir. dir is skipped if it returns true.
-	opts Options                 // Options passed to Walk by the user.
-
-	walking     sync.WaitGroup
-	sem         chan struct{} // Channel of semaphore tokens; send to acquire, receive to release.
-	ignoredDirs []string
-
-	added sync.Map // map[string]bool
-}
-
-// A symlinkList is a linked list of os.FileInfos for parent directories
-// reached via symlinks.
-type symlinkList struct {
-	info os.FileInfo
-	prev *symlinkList
-}
-
-// init initializes the walker based on its Options
-func (w *walker) init() {
-	var ignoredPaths []string
-	if w.root.Type == RootModuleCache {
-		ignoredPaths = []string{"cache"}
-	}
-	if !w.opts.ModulesEnabled && w.root.Type == RootGOPATH {
-		ignoredPaths = w.getIgnoredDirs(w.root.Path)
-		ignoredPaths = append(ignoredPaths, "v", "mod")
-	}
-
-	for _, p := range ignoredPaths {
-		full := filepath.Join(w.root.Path, p)
-		w.ignoredDirs = append(w.ignoredDirs, full)
-		w.opts.Logf("Directory added to ignore list: %s", full)
-	}
-}
-
-// getIgnoredDirs reads an optional config file at <path>/.goimportsignore
-// of relative directories to ignore when scanning for go files.
-// The provided path is one of the $GOPATH entries with "src" appended.
-func (w *walker) getIgnoredDirs(path string) []string {
-	file := filepath.Join(path, ".goimportsignore")
-	slurp, err := os.ReadFile(file)
-	if err != nil {
-		w.opts.Logf("%v", err)
-	} else {
-		w.opts.Logf("Read %s", file)
-	}
-	if err != nil {
-		return nil
-	}
-
-	var ignoredDirs []string
-	bs := bufio.NewScanner(bytes.NewReader(slurp))
-	for bs.Scan() {
-		line := strings.TrimSpace(bs.Text())
-		if line == "" || strings.HasPrefix(line, "#") {
-			continue
-		}
-		ignoredDirs = append(ignoredDirs, line)
-	}
-	return ignoredDirs
-}
-
-// shouldSkipDir reports whether the file should be skipped or not.
-func (w *walker) shouldSkipDir(dir string) bool {
-	if slices.Contains(w.ignoredDirs, dir) {
-		return true
-	}
-	if w.skip != nil {
-		// Check with the user specified callback.
-		return w.skip(w.root, dir)
-	}
-	return false
-}
-
-// walk walks through the given path.
-//
-// Errors are logged if w.opts.Logf is non-nil, but otherwise ignored.
-func (w *walker) walk(path string, pathSymlinks *symlinkList, d fs.DirEntry) {
-	if d.Type()&os.ModeSymlink != 0 {
-		// Walk the symlink's target rather than the symlink itself.
-		//
-		// (Note that os.Stat, unlike the lower-lever os.Readlink,
-		// follows arbitrarily many layers of symlinks, so it will eventually
-		// reach either a non-symlink or a nonexistent target.)
-		//
-		// TODO(bcmills): 'go list all' itself ignores symlinks within GOROOT/src
-		// and GOPATH/src. Do we really need to traverse them here? If so, why?
-
-		fi, err := os.Stat(path)
-		if err != nil {
-			w.opts.Logf("%v", err)
-			return
-		}
-
-		// Avoid walking symlink cycles: if we have already followed a symlink to
-		// this directory as a parent of itself, don't follow it again.
-		//
-		// This doesn't catch the first time through a cycle, but it also minimizes
-		// the number of extra stat calls we make if we *don't* encounter a cycle.
-		// Since we don't actually expect to encounter symlink cycles in practice,
-		// this seems like the right tradeoff.
-		for parent := pathSymlinks; parent != nil; parent = parent.prev {
-			if os.SameFile(fi, parent.info) {
-				return
-			}
-		}
-
-		pathSymlinks = &symlinkList{
-			info: fi,
-			prev: pathSymlinks,
-		}
-		d = fs.FileInfoToDirEntry(fi)
-	}
-
-	if d.Type().IsRegular() {
-		if !strings.HasSuffix(path, ".go") {
-			return
-		}
-
-		dir := filepath.Dir(path)
-		if dir == w.root.Path && (w.root.Type == RootGOROOT || w.root.Type == RootGOPATH) {
-			// Doesn't make sense to have regular files
-			// directly in your $GOPATH/src or $GOROOT/src.
-			//
-			// TODO(bcmills): there are many levels of directory within
-			// RootModuleCache where this also wouldn't make sense,
-			// Can we generalize this to any directory without a corresponding
-			// import path?
-			return
-		}
-
-		if _, dup := w.added.LoadOrStore(dir, true); !dup {
-			w.add(w.root, dir)
-		}
-	}
-
-	if !d.IsDir() {
-		return
-	}
-
-	base := filepath.Base(path)
-	if base == "" || base[0] == '.' || base[0] == '_' ||
-		base == "testdata" ||
-		(w.root.Type == RootGOROOT && w.opts.ModulesEnabled && base == "vendor") ||
-		(!w.opts.ModulesEnabled && base == "node_modules") ||
-		w.shouldSkipDir(path) {
-		return
-	}
-
-	// Read the directory and walk its entries.
-
-	f, err := os.Open(path)
-	if err != nil {
-		w.opts.Logf("%v", err)
-		return
-	}
-	defer f.Close()
-
-	for {
-		// We impose an arbitrary limit on the number of ReadDir results per
-		// directory to limit the amount of memory consumed for stale or upcoming
-		// directory entries. The limit trades off CPU (number of syscalls to read
-		// the whole directory) against RAM (reachable directory entries other than
-		// the one currently being processed).
-		//
-		// Since we process the directories recursively, we will end up maintaining
-		// a slice of entries for each level of the directory tree.
-		// (Compare https://go.dev/issue/36197.)
-		ents, err := f.ReadDir(1024)
-		if err != nil {
-			if err != io.EOF {
-				w.opts.Logf("%v", err)
-			}
-			break
-		}
-
-		for _, d := range ents {
-			nextPath := filepath.Join(path, d.Name())
-			if d.IsDir() {
-				select {
-				case w.sem <- struct{}{}:
-					// Got a new semaphore token, so we can traverse the directory concurrently.
-					d := d
-					w.walking.Add(1)
-					go func() {
-						defer func() {
-							<-w.sem
-							w.walking.Done()
-						}()
-						w.walk(nextPath, pathSymlinks, d)
-					}()
-					continue
-
-				default:
-					// No tokens available, so traverse serially.
-				}
-			}
-
-			w.walk(nextPath, pathSymlinks, d)
-		}
-	}
-}
diff --git a/vendor/golang.org/x/tools/internal/imports/fix.go b/vendor/golang.org/x/tools/internal/imports/fix.go
deleted file mode 100644
index 1b4dc0cb5..000000000
--- a/vendor/golang.org/x/tools/internal/imports/fix.go
+++ /dev/null
@@ -1,1896 +0,0 @@
-// Copyright 2013 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 imports
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"go/ast"
-	"go/build"
-	"go/parser"
-	"go/token"
-	"go/types"
-	"io/fs"
-	"io/ioutil"
-	"maps"
-	"os"
-	"path"
-	"path/filepath"
-	"reflect"
-	"sort"
-	"strconv"
-	"strings"
-	"sync"
-	"unicode"
-	"unicode/utf8"
-
-	"golang.org/x/tools/go/ast/astutil"
-	"golang.org/x/tools/internal/event"
-	"golang.org/x/tools/internal/gocommand"
-	"golang.org/x/tools/internal/gopathwalk"
-	"golang.org/x/tools/internal/stdlib"
-)
-
-// importToGroup is a list of functions which map from an import path to
-// a group number.
-var importToGroup = []func(localPrefix, importPath string) (num int, ok bool){
-	func(localPrefix, importPath string) (num int, ok bool) {
-		if localPrefix == "" {
-			return
-		}
-		for p := range strings.SplitSeq(localPrefix, ",") {
-			if strings.HasPrefix(importPath, p) || strings.TrimSuffix(p, "/") == importPath {
-				return 3, true
-			}
-		}
-		return
-	},
-	func(_, importPath string) (num int, ok bool) {
-		if strings.HasPrefix(importPath, "appengine") {
-			return 2, true
-		}
-		return
-	},
-	func(_, importPath string) (num int, ok bool) {
-		firstComponent := strings.Split(importPath, "/")[0]
-		if strings.Contains(firstComponent, ".") {
-			return 1, true
-		}
-		return
-	},
-}
-
-func importGroup(localPrefix, importPath string) int {
-	for _, fn := range importToGroup {
-		if n, ok := fn(localPrefix, importPath); ok {
-			return n
-		}
-	}
-	return 0
-}
-
-type ImportFixType int
-
-const (
-	AddImport ImportFixType = iota
-	DeleteImport
-	SetImportName
-)
-
-type ImportFix struct {
-	// StmtInfo represents the import statement this fix will add, remove, or change.
-	StmtInfo ImportInfo
-	// IdentName is the identifier that this fix will add or remove.
-	IdentName string
-	// FixType is the type of fix this is (AddImport, DeleteImport, SetImportName).
-	FixType   ImportFixType
-	Relevance float64 // see pkg
-}
-
-// parseOtherFiles parses all the Go files in srcDir except filename, including
-// test files if filename looks like a test.
-//
-// It returns an error only if ctx is cancelled. Files with parse errors are
-// ignored.
-func parseOtherFiles(ctx context.Context, fset *token.FileSet, srcDir, filename string) ([]*ast.File, error) {
-	// This could use go/packages but it doesn't buy much, and it fails
-	// with https://golang.org/issue/26296 in LoadFiles mode in some cases.
-	considerTests := strings.HasSuffix(filename, "_test.go")
-
-	fileBase := filepath.Base(filename)
-	packageFileInfos, err := os.ReadDir(srcDir)
-	if err != nil {
-		return nil, ctx.Err()
-	}
-
-	var files []*ast.File
-	for _, fi := range packageFileInfos {
-		if ctx.Err() != nil {
-			return nil, ctx.Err()
-		}
-		if fi.Name() == fileBase || !strings.HasSuffix(fi.Name(), ".go") {
-			continue
-		}
-		if !considerTests && strings.HasSuffix(fi.Name(), "_test.go") {
-			continue
-		}
-
-		f, err := parser.ParseFile(fset, filepath.Join(srcDir, fi.Name()), nil, parser.SkipObjectResolution)
-		if err != nil {
-			continue
-		}
-
-		files = append(files, f)
-	}
-
-	return files, ctx.Err()
-}
-
-// addGlobals puts the names of package vars into the provided map.
-func addGlobals(f *ast.File, globals map[string]bool) {
-	for _, decl := range f.Decls {
-		genDecl, ok := decl.(*ast.GenDecl)
-		if !ok {
-			continue
-		}
-
-		for _, spec := range genDecl.Specs {
-			valueSpec, ok := spec.(*ast.ValueSpec)
-			if !ok {
-				continue
-			}
-			globals[valueSpec.Names[0].Name] = true
-		}
-	}
-}
-
-// collectReferences builds a map of selector expressions, from
-// left hand side (X) to a set of right hand sides (Sel).
-func collectReferences(f *ast.File) References {
-	refs := References{}
-
-	var visitor visitFn
-	visitor = func(node ast.Node) ast.Visitor {
-		if node == nil {
-			return visitor
-		}
-		switch v := node.(type) {
-		case *ast.SelectorExpr:
-			xident, ok := v.X.(*ast.Ident)
-			if !ok {
-				break
-			}
-			if xident.Obj != nil {
-				// If the parser can resolve it, it's not a package ref.
-				break
-			}
-			if !ast.IsExported(v.Sel.Name) {
-				// Whatever this is, it's not exported from a package.
-				break
-			}
-			pkgName := xident.Name
-			r := refs[pkgName]
-			if r == nil {
-				r = make(map[string]bool)
-				refs[pkgName] = r
-			}
-			r[v.Sel.Name] = true
-		}
-		return visitor
-	}
-	ast.Walk(visitor, f)
-	return refs
-}
-
-// collectImports returns all the imports in f.
-// Unnamed imports (., _) and "C" are ignored.
-func collectImports(f *ast.File) []*ImportInfo {
-	var imports []*ImportInfo
-	for _, imp := range f.Imports {
-		var name string
-		if imp.Name != nil {
-			name = imp.Name.Name
-		}
-		if imp.Path.Value == `"C"` || name == "_" || name == "." {
-			continue
-		}
-		path := strings.Trim(imp.Path.Value, `"`)
-		imports = append(imports, &ImportInfo{
-			Name:       name,
-			ImportPath: path,
-		})
-	}
-	return imports
-}
-
-// findMissingImport searches pass's candidates for an import that provides
-// pkg, containing all of syms.
-func (p *pass) findMissingImport(pkg string, syms map[string]bool) *ImportInfo {
-	for _, candidate := range p.candidates {
-		pkgInfo, ok := p.knownPackages[candidate.ImportPath]
-		if !ok {
-			continue
-		}
-		if p.importIdentifier(candidate) != pkg {
-			continue
-		}
-
-		allFound := true
-		for right := range syms {
-			if !pkgInfo.Exports[right] {
-				allFound = false
-				break
-			}
-		}
-
-		if allFound {
-			return candidate
-		}
-	}
-	return nil
-}
-
-// A pass contains all the inputs and state necessary to fix a file's imports.
-// It can be modified in some ways during use; see comments below.
-type pass struct {
-	// Inputs. These must be set before a call to load, and not modified after.
-	fset                 *token.FileSet // fset used to parse f and its siblings.
-	f                    *ast.File      // the file being fixed.
-	srcDir               string         // the directory containing f.
-	logf                 func(string, ...any)
-	source               Source      // the environment to use for go commands, etc.
-	loadRealPackageNames bool        // if true, load package names from disk rather than guessing them.
-	otherFiles           []*ast.File // sibling files.
-	goroot               string
-
-	// Intermediate state, generated by load.
-	existingImports map[string][]*ImportInfo
-	allRefs         References
-	missingRefs     References
-
-	// Inputs to fix. These can be augmented between successive fix calls.
-	lastTry       bool                    // indicates that this is the last call and fix should clean up as best it can.
-	candidates    []*ImportInfo           // candidate imports in priority order.
-	knownPackages map[string]*PackageInfo // information about all known packages.
-}
-
-// loadPackageNames saves the package names for everything referenced by imports.
-func (p *pass) loadPackageNames(ctx context.Context, imports []*ImportInfo) error {
-	if p.logf != nil {
-		p.logf("loading package names for %v packages", len(imports))
-		defer func() {
-			p.logf("done loading package names for %v packages", len(imports))
-		}()
-	}
-	var unknown []string
-	for _, imp := range imports {
-		if _, ok := p.knownPackages[imp.ImportPath]; ok {
-			continue
-		}
-		unknown = append(unknown, imp.ImportPath)
-	}
-
-	names, err := p.source.LoadPackageNames(ctx, p.srcDir, unknown)
-	if err != nil {
-		return err
-	}
-
-	// TODO(rfindley): revisit this. Why do we need to store known packages with
-	// no exports? The inconsistent data is confusing.
-	for path, name := range names {
-		p.knownPackages[path] = &PackageInfo{
-			Name:    name,
-			Exports: map[string]bool{},
-		}
-	}
-	return nil
-}
-
-// WithoutVersion removes a trailing major version, if there is one.
-func WithoutVersion(nm string) string {
-	if v := path.Base(nm); len(v) > 0 && v[0] == 'v' {
-		if _, err := strconv.Atoi(v[1:]); err == nil {
-			// this is, for instance, called with rand/v2 and returns rand
-			if len(v) < len(nm) {
-				xnm := nm[:len(nm)-len(v)-1]
-				return path.Base(xnm)
-			}
-		}
-	}
-	return nm
-}
-
-// importIdentifier returns the identifier that imp will introduce. It will
-// guess if the package name has not been loaded, e.g. because the source
-// is not available.
-func (p *pass) importIdentifier(imp *ImportInfo) string {
-	if imp.Name != "" {
-		return imp.Name
-	}
-	known := p.knownPackages[imp.ImportPath]
-	if known != nil && known.Name != "" {
-		return WithoutVersion(known.Name)
-	}
-	return ImportPathToAssumedName(imp.ImportPath)
-}
-
-// load reads in everything necessary to run a pass, and reports whether the
-// file already has all the imports it needs. It fills in p.missingRefs with the
-// file's missing symbols, if any, or removes unused imports if not.
-func (p *pass) load(ctx context.Context) ([]*ImportFix, bool) {
-	p.knownPackages = map[string]*PackageInfo{}
-	p.missingRefs = References{}
-	p.existingImports = map[string][]*ImportInfo{}
-
-	// Load basic information about the file in question.
-	p.allRefs = collectReferences(p.f)
-
-	// Load stuff from other files in the same package:
-	// global variables so we know they don't need resolving, and imports
-	// that we might want to mimic.
-	globals := map[string]bool{}
-	for _, otherFile := range p.otherFiles {
-		// Don't load globals from files that are in the same directory
-		// but a different package. Using them to suggest imports is OK.
-		if p.f.Name.Name == otherFile.Name.Name {
-			addGlobals(otherFile, globals)
-		}
-		p.candidates = append(p.candidates, collectImports(otherFile)...)
-	}
-
-	// Resolve all the import paths we've seen to package names, and store
-	// f's imports by the identifier they introduce.
-	imports := collectImports(p.f)
-	if p.loadRealPackageNames {
-		err := p.loadPackageNames(ctx, append(imports, p.candidates...))
-		if err != nil {
-			if p.logf != nil {
-				p.logf("loading package names: %v", err)
-			}
-			return nil, false
-		}
-	}
-	for _, imp := range imports {
-		p.existingImports[p.importIdentifier(imp)] = append(p.existingImports[p.importIdentifier(imp)], imp)
-	}
-
-	// Find missing references.
-	for left, rights := range p.allRefs {
-		if globals[left] {
-			continue
-		}
-		_, ok := p.existingImports[left]
-		if !ok {
-			p.missingRefs[left] = rights
-			continue
-		}
-	}
-	if len(p.missingRefs) != 0 {
-		return nil, false
-	}
-
-	return p.fix()
-}
-
-// fix attempts to satisfy missing imports using p.candidates. If it finds
-// everything, or if p.lastTry is true, it updates fixes to add the imports it found,
-// delete anything unused, and update import names, and returns true.
-func (p *pass) fix() ([]*ImportFix, bool) {
-	// Find missing imports.
-	var selected []*ImportInfo
-	for left, rights := range p.missingRefs {
-		if imp := p.findMissingImport(left, rights); imp != nil {
-			selected = append(selected, imp)
-		}
-	}
-
-	if !p.lastTry && len(selected) != len(p.missingRefs) {
-		return nil, false
-	}
-
-	// Found everything, or giving up. Add the new imports and remove any unused.
-	var fixes []*ImportFix
-	for _, identifierImports := range p.existingImports {
-		for _, imp := range identifierImports {
-			// We deliberately ignore globals here, because we can't be sure
-			// they're in the same package. People do things like put multiple
-			// main packages in the same directory, and we don't want to
-			// remove imports if they happen to have the same name as a var in
-			// a different package.
-			if _, ok := p.allRefs[p.importIdentifier(imp)]; !ok {
-				fixes = append(fixes, &ImportFix{
-					StmtInfo:  *imp,
-					IdentName: p.importIdentifier(imp),
-					FixType:   DeleteImport,
-				})
-				continue
-			}
-
-			// An existing import may need to update its import name to be correct.
-			if name := p.importSpecName(imp); name != imp.Name {
-				fixes = append(fixes, &ImportFix{
-					StmtInfo: ImportInfo{
-						Name:       name,
-						ImportPath: imp.ImportPath,
-					},
-					IdentName: p.importIdentifier(imp),
-					FixType:   SetImportName,
-				})
-			}
-		}
-	}
-	// Collecting fixes involved map iteration, so sort for stability. See
-	// golang/go#59976.
-	sortFixes(fixes)
-
-	// collect selected fixes in a separate slice, so that it can be sorted
-	// separately. Note that these fixes must occur after fixes to existing
-	// imports. TODO(rfindley): figure out why.
-	var selectedFixes []*ImportFix
-	for _, imp := range selected {
-		selectedFixes = append(selectedFixes, &ImportFix{
-			StmtInfo: ImportInfo{
-				Name:       p.importSpecName(imp),
-				ImportPath: imp.ImportPath,
-			},
-			IdentName: p.importIdentifier(imp),
-			FixType:   AddImport,
-		})
-	}
-	sortFixes(selectedFixes)
-
-	return append(fixes, selectedFixes...), true
-}
-
-func sortFixes(fixes []*ImportFix) {
-	sort.Slice(fixes, func(i, j int) bool {
-		fi, fj := fixes[i], fixes[j]
-		if fi.StmtInfo.ImportPath != fj.StmtInfo.ImportPath {
-			return fi.StmtInfo.ImportPath < fj.StmtInfo.ImportPath
-		}
-		if fi.StmtInfo.Name != fj.StmtInfo.Name {
-			return fi.StmtInfo.Name < fj.StmtInfo.Name
-		}
-		if fi.IdentName != fj.IdentName {
-			return fi.IdentName < fj.IdentName
-		}
-		return fi.FixType < fj.FixType
-	})
-}
-
-// importSpecName gets the import name of imp in the import spec.
-//
-// When the import identifier matches the assumed import name, the import name does
-// not appear in the import spec.
-func (p *pass) importSpecName(imp *ImportInfo) string {
-	// If we did not load the real package names, or the name is already set,
-	// we just return the existing name.
-	if !p.loadRealPackageNames || imp.Name != "" {
-		return imp.Name
-	}
-
-	ident := p.importIdentifier(imp)
-	if ident == ImportPathToAssumedName(imp.ImportPath) {
-		return "" // ident not needed since the assumed and real names are the same.
-	}
-	return ident
-}
-
-// apply will perform the fixes on f in order.
-func apply(fset *token.FileSet, f *ast.File, fixes []*ImportFix) {
-	for _, fix := range fixes {
-		switch fix.FixType {
-		case DeleteImport:
-			astutil.DeleteNamedImport(fset, f, fix.StmtInfo.Name, fix.StmtInfo.ImportPath)
-		case AddImport:
-			astutil.AddNamedImport(fset, f, fix.StmtInfo.Name, fix.StmtInfo.ImportPath)
-		case SetImportName:
-			// Find the matching import path and change the name.
-			for _, spec := range f.Imports {
-				path := strings.Trim(spec.Path.Value, `"`)
-				if path == fix.StmtInfo.ImportPath {
-					spec.Name = &ast.Ident{
-						Name:    fix.StmtInfo.Name,
-						NamePos: spec.Pos(),
-					}
-				}
-			}
-		}
-	}
-}
-
-// assumeSiblingImportsValid assumes that siblings' use of packages is valid,
-// adding the exports they use.
-func (p *pass) assumeSiblingImportsValid() {
-	for _, f := range p.otherFiles {
-		refs := collectReferences(f)
-		imports := collectImports(f)
-		importsByName := map[string]*ImportInfo{}
-		for _, imp := range imports {
-			importsByName[p.importIdentifier(imp)] = imp
-		}
-		for left, rights := range refs {
-			if imp, ok := importsByName[left]; ok {
-				if m, ok := stdlib.PackageSymbols[imp.ImportPath]; ok {
-					// We have the stdlib in memory; no need to guess.
-					rights = symbolNameSet(m)
-				}
-				// TODO(rfindley): we should set package name here, for consistency.
-				p.addCandidate(imp, &PackageInfo{
-					// no name; we already know it.
-					Exports: rights,
-				})
-			}
-		}
-	}
-}
-
-// addCandidate adds a candidate import to p, and merges in the information
-// in pkg.
-func (p *pass) addCandidate(imp *ImportInfo, pkg *PackageInfo) {
-	p.candidates = append(p.candidates, imp)
-	if existing, ok := p.knownPackages[imp.ImportPath]; ok {
-		if existing.Name == "" {
-			existing.Name = pkg.Name
-		}
-		for export := range pkg.Exports {
-			existing.Exports[export] = true
-		}
-	} else {
-		p.knownPackages[imp.ImportPath] = pkg
-	}
-}
-
-// fixImports adds and removes imports from f so that all its references are
-// satisfied and there are no unused imports.
-//
-// This is declared as a variable rather than a function so goimports can
-// easily be extended by adding a file with an init function.
-//
-// DO NOT REMOVE: used internally at Google.
-var fixImports = fixImportsDefault
-
-func fixImportsDefault(fset *token.FileSet, f *ast.File, filename string, env *ProcessEnv) error {
-	fixes, err := getFixes(context.Background(), fset, f, filename, env)
-	if err != nil {
-		return err
-	}
-	apply(fset, f, fixes)
-	return nil
-}
-
-// getFixes gets the import fixes that need to be made to f in order to fix the imports.
-// It does not modify the ast.
-func getFixes(ctx context.Context, fset *token.FileSet, f *ast.File, filename string, env *ProcessEnv) ([]*ImportFix, error) {
-	source, err := NewProcessEnvSource(env, filename, f.Name.Name)
-	if err != nil {
-		return nil, err
-	}
-	goEnv, err := env.goEnv()
-	if err != nil {
-		return nil, err
-	}
-	return getFixesWithSource(ctx, fset, f, filename, goEnv["GOROOT"], env.logf, source)
-}
-
-func getFixesWithSource(ctx context.Context, fset *token.FileSet, f *ast.File, filename string, goroot string, logf func(string, ...any), source Source) ([]*ImportFix, error) {
-	// This logic is defensively duplicated from getFixes.
-	abs, err := filepath.Abs(filename)
-	if err != nil {
-		return nil, err
-	}
-	srcDir := filepath.Dir(abs)
-
-	if logf != nil {
-		logf("fixImports(filename=%q), srcDir=%q ...", filename, srcDir)
-	}
-
-	// First pass: looking only at f, and using the naive algorithm to
-	// derive package names from import paths, see if the file is already
-	// complete. We can't add any imports yet, because we don't know
-	// if missing references are actually package vars.
-	p := &pass{
-		fset:   fset,
-		f:      f,
-		srcDir: srcDir,
-		logf:   logf,
-		goroot: goroot,
-		source: source,
-	}
-	if fixes, done := p.load(ctx); done {
-		return fixes, nil
-	}
-
-	otherFiles, err := parseOtherFiles(ctx, fset, srcDir, filename)
-	if err != nil {
-		return nil, err
-	}
-
-	// Second pass: add information from other files in the same package,
-	// like their package vars and imports.
-	p.otherFiles = otherFiles
-	if fixes, done := p.load(ctx); done {
-		return fixes, nil
-	}
-
-	// Now we can try adding imports from the stdlib.
-	p.assumeSiblingImportsValid()
-	addStdlibCandidates(p, p.missingRefs)
-	if fixes, done := p.fix(); done {
-		return fixes, nil
-	}
-
-	// Third pass: get real package names where we had previously used
-	// the naive algorithm.
-	p = &pass{
-		fset:   fset,
-		f:      f,
-		srcDir: srcDir,
-		logf:   logf,
-		goroot: goroot,
-		source: p.source, // safe to reuse, as it's just a wrapper around env
-	}
-	p.loadRealPackageNames = true
-	p.otherFiles = otherFiles
-	if fixes, done := p.load(ctx); done {
-		return fixes, nil
-	}
-
-	if err := addStdlibCandidates(p, p.missingRefs); err != nil {
-		return nil, err
-	}
-	p.assumeSiblingImportsValid()
-	if fixes, done := p.fix(); done {
-		return fixes, nil
-	}
-
-	// Go look for candidates in $GOPATH, etc. We don't necessarily load
-	// the real exports of sibling imports, so keep assuming their contents.
-	if err := addExternalCandidates(ctx, p, p.missingRefs, filename); err != nil {
-		return nil, err
-	}
-
-	p.lastTry = true
-	fixes, _ := p.fix()
-	return fixes, nil
-}
-
-// MaxRelevance is the highest relevance, used for the standard library.
-// Chosen arbitrarily to match pre-existing gopls code.
-const MaxRelevance = 7.0
-
-// getCandidatePkgs works with the passed callback to find all acceptable packages.
-// It deduplicates by import path, and uses a cached stdlib rather than reading
-// from disk.
-func getCandidatePkgs(ctx context.Context, wrappedCallback *scanCallback, filename, filePkg string, env *ProcessEnv) error {
-	notSelf := func(p *pkg) bool {
-		return p.packageName != filePkg || p.dir != filepath.Dir(filename)
-	}
-	goenv, err := env.goEnv()
-	if err != nil {
-		return err
-	}
-
-	var mu sync.Mutex // to guard asynchronous access to dupCheck
-	dupCheck := map[string]struct{}{}
-
-	// Start off with the standard library.
-	for importPath, symbols := range stdlib.PackageSymbols {
-		p := &pkg{
-			dir:             filepath.Join(goenv["GOROOT"], "src", importPath),
-			importPathShort: importPath,
-			packageName:     path.Base(importPath),
-			relevance:       MaxRelevance,
-		}
-		dupCheck[importPath] = struct{}{}
-		if notSelf(p) && wrappedCallback.dirFound(p) && wrappedCallback.packageNameLoaded(p) {
-			var exports []stdlib.Symbol
-			for _, sym := range symbols {
-				switch sym.Kind {
-				case stdlib.Func, stdlib.Type, stdlib.Var, stdlib.Const:
-					exports = append(exports, sym)
-				}
-			}
-			wrappedCallback.exportsLoaded(p, exports)
-		}
-	}
-
-	scanFilter := &scanCallback{
-		rootFound: func(root gopathwalk.Root) bool {
-			// Exclude goroot results -- getting them is relatively expensive, not cached,
-			// and generally redundant with the in-memory version.
-			return root.Type != gopathwalk.RootGOROOT && wrappedCallback.rootFound(root)
-		},
-		dirFound: wrappedCallback.dirFound,
-		packageNameLoaded: func(pkg *pkg) bool {
-			mu.Lock()
-			defer mu.Unlock()
-			if _, ok := dupCheck[pkg.importPathShort]; ok {
-				return false
-			}
-			dupCheck[pkg.importPathShort] = struct{}{}
-			return notSelf(pkg) && wrappedCallback.packageNameLoaded(pkg)
-		},
-		exportsLoaded: func(pkg *pkg, exports []stdlib.Symbol) {
-			// If we're an x_test, load the package under test's test variant.
-			if strings.HasSuffix(filePkg, "_test") && pkg.dir == filepath.Dir(filename) {
-				var err error
-				_, exports, err = loadExportsFromFiles(ctx, env, pkg.dir, true)
-				if err != nil {
-					return
-				}
-			}
-			wrappedCallback.exportsLoaded(pkg, exports)
-		},
-	}
-	resolver, err := env.GetResolver()
-	if err != nil {
-		return err
-	}
-	return resolver.scan(ctx, scanFilter)
-}
-
-func ScoreImportPaths(ctx context.Context, env *ProcessEnv, paths []string) (map[string]float64, error) {
-	result := make(map[string]float64)
-	resolver, err := env.GetResolver()
-	if err != nil {
-		return nil, err
-	}
-	for _, path := range paths {
-		result[path] = resolver.scoreImportPath(ctx, path)
-	}
-	return result, nil
-}
-
-func PrimeCache(ctx context.Context, resolver Resolver) error {
-	// Fully scan the disk for directories, but don't actually read any Go files.
-	callback := &scanCallback{
-		rootFound: func(root gopathwalk.Root) bool {
-			// See getCandidatePkgs: walking GOROOT is apparently expensive and
-			// unnecessary.
-			return root.Type != gopathwalk.RootGOROOT
-		},
-		dirFound: func(pkg *pkg) bool {
-			return false
-		},
-		// packageNameLoaded and exportsLoaded must never be called.
-	}
-
-	return resolver.scan(ctx, callback)
-}
-
-func candidateImportName(pkg *pkg) string {
-	if ImportPathToAssumedName(pkg.importPathShort) != pkg.packageName {
-		return pkg.packageName
-	}
-	return ""
-}
-
-// GetAllCandidates calls wrapped for each package whose name starts with
-// searchPrefix, and can be imported from filename with the package name filePkg.
-//
-// Beware that the wrapped function may be called multiple times concurrently.
-// TODO(adonovan): encapsulate the concurrency.
-func GetAllCandidates(ctx context.Context, wrapped func(ImportFix), searchPrefix, filename, filePkg string, env *ProcessEnv) error {
-	callback := &scanCallback{
-		rootFound: func(gopathwalk.Root) bool {
-			return true
-		},
-		dirFound: func(pkg *pkg) bool {
-			if !CanUse(filename, pkg.dir) {
-				return false
-			}
-			// Try the assumed package name first, then a simpler path match
-			// in case of packages named vN, which are not uncommon.
-			return strings.HasPrefix(ImportPathToAssumedName(pkg.importPathShort), searchPrefix) ||
-				strings.HasPrefix(path.Base(pkg.importPathShort), searchPrefix)
-		},
-		packageNameLoaded: func(pkg *pkg) bool {
-			if !strings.HasPrefix(pkg.packageName, searchPrefix) {
-				return false
-			}
-			wrapped(ImportFix{
-				StmtInfo: ImportInfo{
-					ImportPath: pkg.importPathShort,
-					Name:       candidateImportName(pkg),
-				},
-				IdentName: pkg.packageName,
-				FixType:   AddImport,
-				Relevance: pkg.relevance,
-			})
-			return false
-		},
-	}
-	return getCandidatePkgs(ctx, callback, filename, filePkg, env)
-}
-
-// GetImportPaths calls wrapped for each package whose import path starts with
-// searchPrefix, and can be imported from filename with the package name filePkg.
-func GetImportPaths(ctx context.Context, wrapped func(ImportFix), searchPrefix, filename, filePkg string, env *ProcessEnv) error {
-	callback := &scanCallback{
-		rootFound: func(gopathwalk.Root) bool {
-			return true
-		},
-		dirFound: func(pkg *pkg) bool {
-			if !CanUse(filename, pkg.dir) {
-				return false
-			}
-			return strings.HasPrefix(pkg.importPathShort, searchPrefix)
-		},
-		packageNameLoaded: func(pkg *pkg) bool {
-			wrapped(ImportFix{
-				StmtInfo: ImportInfo{
-					ImportPath: pkg.importPathShort,
-					Name:       candidateImportName(pkg),
-				},
-				IdentName: pkg.packageName,
-				FixType:   AddImport,
-				Relevance: pkg.relevance,
-			})
-			return false
-		},
-	}
-	return getCandidatePkgs(ctx, callback, filename, filePkg, env)
-}
-
-// A PackageExport is a package and its exports.
-type PackageExport struct {
-	Fix     *ImportFix
-	Exports []stdlib.Symbol
-}
-
-// GetPackageExports returns all known packages with name pkg and their exports.
-func GetPackageExports(ctx context.Context, wrapped func(PackageExport), searchPkg, filename, filePkg string, env *ProcessEnv) error {
-	callback := &scanCallback{
-		rootFound: func(gopathwalk.Root) bool {
-			return true
-		},
-		dirFound: func(pkg *pkg) bool {
-			return pkgIsCandidate(filename, References{searchPkg: nil}, pkg)
-		},
-		packageNameLoaded: func(pkg *pkg) bool {
-			return pkg.packageName == searchPkg
-		},
-		exportsLoaded: func(pkg *pkg, exports []stdlib.Symbol) {
-			sortSymbols(exports)
-			wrapped(PackageExport{
-				Fix: &ImportFix{
-					StmtInfo: ImportInfo{
-						ImportPath: pkg.importPathShort,
-						Name:       candidateImportName(pkg),
-					},
-					IdentName: pkg.packageName,
-					FixType:   AddImport,
-					Relevance: pkg.relevance,
-				},
-				Exports: exports,
-			})
-		},
-	}
-	return getCandidatePkgs(ctx, callback, filename, filePkg, env)
-}
-
-// TODO(rfindley): we should depend on GOOS and GOARCH, to provide accurate
-// imports when doing cross-platform development.
-var requiredGoEnvVars = []string{
-	"GO111MODULE",
-	"GOFLAGS",
-	"GOINSECURE",
-	"GOMOD",
-	"GOMODCACHE",
-	"GONOPROXY",
-	"GONOSUMDB",
-	"GOPATH",
-	"GOPROXY",
-	"GOROOT",
-	"GOSUMDB",
-	"GOWORK",
-}
-
-// ProcessEnv contains environment variables and settings that affect the use of
-// the go command, the go/build package, etc.
-//
-// ...a ProcessEnv *also* overwrites its Env along with derived state in the
-// form of the resolver. And because it is lazily initialized, an env may just
-// be broken and unusable, but there is no way for the caller to detect that:
-// all queries will just fail.
-//
-// TODO(rfindley): refactor this package so that this type (perhaps renamed to
-// just Env or Config) is an immutable configuration struct, to be exchanged
-// for an initialized object via a constructor that returns an error. Perhaps
-// the signature should be `func NewResolver(*Env) (*Resolver, error)`, where
-// resolver is a concrete type used for resolving imports. Via this
-// refactoring, we can avoid the need to call ProcessEnv.init and
-// ProcessEnv.GoEnv everywhere, and implicitly fix all the places where this
-// these are misused. Also, we'd delegate the caller the decision of how to
-// handle a broken environment.
-type ProcessEnv struct {
-	GocmdRunner *gocommand.Runner
-
-	BuildFlags []string
-	ModFlag    string
-
-	// SkipPathInScan returns true if the path should be skipped from scans of
-	// the RootCurrentModule root type. The function argument is a clean,
-	// absolute path.
-	SkipPathInScan func(string) bool
-
-	// Env overrides the OS environment, and can be used to specify
-	// GOPROXY, GO111MODULE, etc. PATH cannot be set here, because
-	// exec.Command will not honor it.
-	// Specifying all of requiredGoEnvVars avoids a call to `go env`.
-	Env map[string]string
-
-	WorkingDir string
-
-	// If Logf is non-nil, debug logging is enabled through this function.
-	Logf func(format string, args ...any)
-
-	// If set, ModCache holds a shared cache of directory info to use across
-	// multiple ProcessEnvs.
-	ModCache *DirInfoCache
-
-	initialized bool // see TODO above
-
-	// resolver and resolverErr are lazily evaluated (see GetResolver).
-	// This is unclean, but see the big TODO in the docstring for ProcessEnv
-	// above: for now, we can't be sure that the ProcessEnv is fully initialized.
-	resolver    Resolver
-	resolverErr error
-}
-
-func (e *ProcessEnv) goEnv() (map[string]string, error) {
-	if err := e.init(); err != nil {
-		return nil, err
-	}
-	return e.Env, nil
-}
-
-func (e *ProcessEnv) matchFile(dir, name string) (bool, error) {
-	bctx, err := e.buildContext()
-	if err != nil {
-		return false, err
-	}
-	return bctx.MatchFile(dir, name)
-}
-
-// CopyConfig copies the env's configuration into a new env.
-func (e *ProcessEnv) CopyConfig() *ProcessEnv {
-	copy := &ProcessEnv{
-		GocmdRunner: e.GocmdRunner,
-		initialized: e.initialized,
-		BuildFlags:  e.BuildFlags,
-		Logf:        e.Logf,
-		WorkingDir:  e.WorkingDir,
-		resolver:    nil,
-		Env:         map[string]string{},
-	}
-	maps.Copy(copy.Env, e.Env)
-	return copy
-}
-
-func (e *ProcessEnv) init() error {
-	if e.initialized {
-		return nil
-	}
-
-	foundAllRequired := true
-	for _, k := range requiredGoEnvVars {
-		if _, ok := e.Env[k]; !ok {
-			foundAllRequired = false
-			break
-		}
-	}
-	if foundAllRequired {
-		e.initialized = true
-		return nil
-	}
-
-	if e.Env == nil {
-		e.Env = map[string]string{}
-	}
-
-	goEnv := map[string]string{}
-	stdout, err := e.invokeGo(context.TODO(), "env", append([]string{"-json"}, requiredGoEnvVars...)...)
-	if err != nil {
-		return err
-	}
-	if err := json.Unmarshal(stdout.Bytes(), &goEnv); err != nil {
-		return err
-	}
-	maps.Copy(e.Env, goEnv)
-	e.initialized = true
-	return nil
-}
-
-func (e *ProcessEnv) env() []string {
-	var env []string // the gocommand package will prepend os.Environ.
-	for k, v := range e.Env {
-		env = append(env, k+"="+v)
-	}
-	return env
-}
-
-func (e *ProcessEnv) GetResolver() (Resolver, error) {
-	if err := e.init(); err != nil {
-		return nil, err
-	}
-
-	if e.resolver == nil && e.resolverErr == nil {
-		// TODO(rfindley): we should only use a gopathResolver here if the working
-		// directory is actually *in* GOPATH. (I seem to recall an open gopls issue
-		// for this behavior, but I can't find it).
-		//
-		// For gopls, we can optionally explicitly choose a resolver type, since we
-		// already know the view type.
-		if e.Env["GOMOD"] == "" && (e.Env["GOWORK"] == "" || e.Env["GOWORK"] == "off") {
-			e.resolver = newGopathResolver(e)
-			e.logf("created gopath resolver")
-		} else if r, err := newModuleResolver(e, e.ModCache); err != nil {
-			e.resolverErr = err
-			e.logf("failed to create module resolver: %v", err)
-		} else {
-			e.resolver = Resolver(r)
-			e.logf("created module resolver")
-		}
-	}
-
-	return e.resolver, e.resolverErr
-}
-
-// logf logs if e.Logf is non-nil.
-func (e *ProcessEnv) logf(format string, args ...any) {
-	if e.Logf != nil {
-		e.Logf(format, args...)
-	}
-}
-
-// buildContext returns the build.Context to use for matching files.
-//
-// TODO(rfindley): support dynamic GOOS, GOARCH here, when doing cross-platform
-// development.
-func (e *ProcessEnv) buildContext() (*build.Context, error) {
-	ctx := build.Default
-	goenv, err := e.goEnv()
-	if err != nil {
-		return nil, err
-	}
-	ctx.GOROOT = goenv["GOROOT"]
-	ctx.GOPATH = goenv["GOPATH"]
-
-	// As of Go 1.14, build.Context has a Dir field
-	// (see golang.org/issue/34860).
-	// Populate it only if present.
-	rc := reflect.ValueOf(&ctx).Elem()
-	dir := rc.FieldByName("Dir")
-	if dir.IsValid() && dir.Kind() == reflect.String {
-		dir.SetString(e.WorkingDir)
-	}
-
-	// Since Go 1.11, go/build.Context.Import may invoke 'go list' depending on
-	// the value in GO111MODULE in the process's environment. We always want to
-	// run in GOPATH mode when calling Import, so we need to prevent this from
-	// happening. In Go 1.16, GO111MODULE defaults to "on", so this problem comes
-	// up more frequently.
-	//
-	// HACK: setting any of the Context I/O hooks prevents Import from invoking
-	// 'go list', regardless of GO111MODULE. This is undocumented, but it's
-	// unlikely to change before GOPATH support is removed.
-	ctx.ReadDir = ioutil.ReadDir
-
-	return &ctx, nil
-}
-
-func (e *ProcessEnv) invokeGo(ctx context.Context, verb string, args ...string) (*bytes.Buffer, error) {
-	inv := gocommand.Invocation{
-		Verb:       verb,
-		Args:       args,
-		BuildFlags: e.BuildFlags,
-		Env:        e.env(),
-		Logf:       e.Logf,
-		WorkingDir: e.WorkingDir,
-	}
-	return e.GocmdRunner.Run(ctx, inv)
-}
-
-func addStdlibCandidates(pass *pass, refs References) error {
-	localbase := func(nm string) string {
-		ans := path.Base(nm)
-		if ans[0] == 'v' {
-			// this is called, for instance, with math/rand/v2 and returns rand/v2
-			if _, err := strconv.Atoi(ans[1:]); err == nil {
-				ix := strings.LastIndex(nm, ans)
-				more := path.Base(nm[:ix])
-				ans = path.Join(more, ans)
-			}
-		}
-		return ans
-	}
-	add := func(pkg string) {
-		// Prevent self-imports.
-		if path.Base(pkg) == pass.f.Name.Name && filepath.Join(pass.goroot, "src", pkg) == pass.srcDir {
-			return
-		}
-		exports := symbolNameSet(stdlib.PackageSymbols[pkg])
-		pass.addCandidate(
-			&ImportInfo{ImportPath: pkg},
-			&PackageInfo{Name: localbase(pkg), Exports: exports})
-	}
-	for left := range refs {
-		if left == "rand" {
-			// Make sure we try crypto/rand before any version of math/rand as both have Int()
-			// and our policy is to recommend crypto
-			add("crypto/rand")
-			// if the user's no later than go1.21, this should be "math/rand"
-			// but we have no way of figuring out what the user is using
-			// TODO: investigate using the toolchain version to disambiguate in the stdlib
-			add("math/rand/v2")
-			// math/rand has an overlapping API
-			// TestIssue66407 fails without this
-			add("math/rand")
-			continue
-		}
-		for importPath := range stdlib.PackageSymbols {
-			if path.Base(importPath) == left {
-				add(importPath)
-			}
-		}
-	}
-	return nil
-}
-
-// A Resolver does the build-system-specific parts of goimports.
-type Resolver interface {
-	// loadPackageNames loads the package names in importPaths.
-	loadPackageNames(importPaths []string, srcDir string) (map[string]string, error)
-
-	// scan works with callback to search for packages. See scanCallback for details.
-	scan(ctx context.Context, callback *scanCallback) error
-
-	// loadExports returns the package name and set of exported symbols in the
-	// package at dir. loadExports may be called concurrently.
-	loadExports(ctx context.Context, pkg *pkg, includeTest bool) (string, []stdlib.Symbol, error)
-
-	// scoreImportPath returns the relevance for an import path.
-	scoreImportPath(ctx context.Context, path string) float64
-
-	// ClearForNewScan returns a new Resolver based on the receiver that has
-	// cleared its internal caches of directory contents.
-	//
-	// The new resolver should be primed and then set via
-	// [ProcessEnv.UpdateResolver].
-	ClearForNewScan() Resolver
-}
-
-// A scanCallback controls a call to scan and receives its results.
-// In general, minor errors will be silently discarded; a user should not
-// expect to receive a full series of calls for everything.
-type scanCallback struct {
-	// rootFound is called before scanning a new root dir. If it returns true,
-	// the root will be scanned. Returning false will not necessarily prevent
-	// directories from that root making it to dirFound.
-	rootFound func(gopathwalk.Root) bool
-	// dirFound is called when a directory is found that is possibly a Go package.
-	// pkg will be populated with everything except packageName.
-	// If it returns true, the package's name will be loaded.
-	dirFound func(pkg *pkg) bool
-	// packageNameLoaded is called when a package is found and its name is loaded.
-	// If it returns true, the package's exports will be loaded.
-	packageNameLoaded func(pkg *pkg) bool
-	// exportsLoaded is called when a package's exports have been loaded.
-	exportsLoaded func(pkg *pkg, exports []stdlib.Symbol)
-}
-
-func addExternalCandidates(ctx context.Context, pass *pass, refs References, filename string) error {
-	ctx, done := event.Start(ctx, "imports.addExternalCandidates")
-	defer done()
-
-	results, err := pass.source.ResolveReferences(ctx, filename, refs)
-	if err != nil {
-		return err
-	}
-
-	for _, result := range results {
-		if result == nil {
-			continue
-		}
-		// Don't offer completions that would shadow predeclared
-		// names, such as github.com/coreos/etcd/error.
-		if types.Universe.Lookup(result.Package.Name) != nil { // predeclared
-			// Ideally we would skip this candidate only
-			// if the predeclared name is actually
-			// referenced by the file, but that's a lot
-			// trickier to compute and would still create
-			// an import that is likely to surprise the
-			// user before long.
-			continue
-		}
-		pass.addCandidate(result.Import, result.Package)
-	}
-	return nil
-}
-
-// notIdentifier reports whether ch is an invalid identifier character.
-func notIdentifier(ch rune) bool {
-	return !('a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' ||
-		'0' <= ch && ch <= '9' ||
-		ch == '_' ||
-		ch >= utf8.RuneSelf && (unicode.IsLetter(ch) || unicode.IsDigit(ch)))
-}
-
-// ImportPathToAssumedName returns the assumed package name of an import path.
-// It does this using only string parsing of the import path.
-// It picks the last element of the path that does not look like a major
-// version, and then picks the valid identifier off the start of that element.
-// It is used to determine if a local rename should be added to an import for
-// clarity.
-// This function could be moved to a standard package and exported if we want
-// for use in other tools.
-func ImportPathToAssumedName(importPath string) string {
-	base := path.Base(importPath)
-	if strings.HasPrefix(base, "v") {
-		if _, err := strconv.Atoi(base[1:]); err == nil {
-			dir := path.Dir(importPath)
-			if dir != "." {
-				base = path.Base(dir)
-			}
-		}
-	}
-	base = strings.TrimPrefix(base, "go-")
-	if i := strings.IndexFunc(base, notIdentifier); i >= 0 {
-		base = base[:i]
-	}
-	return base
-}
-
-// gopathResolver implements resolver for GOPATH workspaces.
-type gopathResolver struct {
-	env      *ProcessEnv
-	cache    *DirInfoCache
-	scanSema chan struct{} // scanSema prevents concurrent scans.
-}
-
-func newGopathResolver(env *ProcessEnv) *gopathResolver {
-	r := &gopathResolver{
-		env:      env,
-		cache:    NewDirInfoCache(),
-		scanSema: make(chan struct{}, 1),
-	}
-	r.scanSema <- struct{}{}
-	return r
-}
-
-func (r *gopathResolver) ClearForNewScan() Resolver {
-	return newGopathResolver(r.env)
-}
-
-func (r *gopathResolver) loadPackageNames(importPaths []string, srcDir string) (map[string]string, error) {
-	names := map[string]string{}
-	bctx, err := r.env.buildContext()
-	if err != nil {
-		return nil, err
-	}
-	for _, path := range importPaths {
-		names[path] = importPathToName(bctx, path, srcDir)
-	}
-	return names, nil
-}
-
-// importPathToName finds out the actual package name, as declared in its .go files.
-func importPathToName(bctx *build.Context, importPath, srcDir string) string {
-	// Fast path for standard library without going to disk.
-	if stdlib.HasPackage(importPath) {
-		return path.Base(importPath) // stdlib packages always match their paths.
-	}
-
-	buildPkg, err := bctx.Import(importPath, srcDir, build.FindOnly)
-	if err != nil {
-		return ""
-	}
-	pkgName, err := packageDirToName(buildPkg.Dir)
-	if err != nil {
-		return ""
-	}
-	return pkgName
-}
-
-// packageDirToName is a faster version of build.Import if
-// the only thing desired is the package name. Given a directory,
-// packageDirToName then only parses one file in the package,
-// trusting that the files in the directory are consistent.
-func packageDirToName(dir string) (packageName string, err error) {
-	d, err := os.Open(dir)
-	if err != nil {
-		return "", err
-	}
-	names, err := d.Readdirnames(-1)
-	d.Close()
-	if err != nil {
-		return "", err
-	}
-	sort.Strings(names) // to have predictable behavior
-	var lastErr error
-	var nfile int
-	for _, name := range names {
-		if !strings.HasSuffix(name, ".go") {
-			continue
-		}
-		if strings.HasSuffix(name, "_test.go") {
-			continue
-		}
-		nfile++
-		fullFile := filepath.Join(dir, name)
-
-		fset := token.NewFileSet()
-		f, err := parser.ParseFile(fset, fullFile, nil, parser.PackageClauseOnly)
-		if err != nil {
-			lastErr = err
-			continue
-		}
-		pkgName := f.Name.Name
-		if pkgName == "documentation" {
-			// Special case from go/build.ImportDir, not
-			// handled by ctx.MatchFile.
-			continue
-		}
-		if pkgName == "main" {
-			// Also skip package main, assuming it's a +build ignore generator or example.
-			// Since you can't import a package main anyway, there's no harm here.
-			continue
-		}
-		return pkgName, nil
-	}
-	if lastErr != nil {
-		return "", lastErr
-	}
-	return "", fmt.Errorf("no importable package found in %d Go files", nfile)
-}
-
-type pkg struct {
-	dir             string  // absolute file path to pkg directory ("/usr/lib/go/src/net/http")
-	importPathShort string  // vendorless import path ("net/http", "a/b")
-	packageName     string  // package name loaded from source if requested
-	relevance       float64 // a weakly-defined score of how relevant a package is. 0 is most relevant.
-}
-
-type pkgDistance struct {
-	pkg      *pkg
-	distance int // relative distance to target
-}
-
-// byDistanceOrImportPathShortLength sorts by relative distance breaking ties
-// on the short import path length and then the import string itself.
-type byDistanceOrImportPathShortLength []pkgDistance
-
-func (s byDistanceOrImportPathShortLength) Len() int { return len(s) }
-func (s byDistanceOrImportPathShortLength) Less(i, j int) bool {
-	di, dj := s[i].distance, s[j].distance
-	if di == -1 {
-		return false
-	}
-	if dj == -1 {
-		return true
-	}
-	if di != dj {
-		return di < dj
-	}
-
-	vi, vj := s[i].pkg.importPathShort, s[j].pkg.importPathShort
-	if len(vi) != len(vj) {
-		return len(vi) < len(vj)
-	}
-	return vi < vj
-}
-func (s byDistanceOrImportPathShortLength) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
-
-func distance(basepath, targetpath string) int {
-	p, err := filepath.Rel(basepath, targetpath)
-	if err != nil {
-		return -1
-	}
-	if p == "." {
-		return 0
-	}
-	return strings.Count(p, string(filepath.Separator)) + 1
-}
-
-func (r *gopathResolver) scan(ctx context.Context, callback *scanCallback) error {
-	add := func(root gopathwalk.Root, dir string) {
-		// We assume cached directories have not changed. We can skip them and their
-		// children.
-		if _, ok := r.cache.Load(dir); ok {
-			return
-		}
-
-		importpath := filepath.ToSlash(dir[len(root.Path)+len("/"):])
-		info := directoryPackageInfo{
-			status:                 directoryScanned,
-			dir:                    dir,
-			rootType:               root.Type,
-			nonCanonicalImportPath: VendorlessPath(importpath),
-		}
-		r.cache.Store(dir, info)
-	}
-	processDir := func(info directoryPackageInfo) {
-		// Skip this directory if we were not able to get the package information successfully.
-		if scanned, err := info.reachedStatus(directoryScanned); !scanned || err != nil {
-			return
-		}
-
-		p := &pkg{
-			importPathShort: info.nonCanonicalImportPath,
-			dir:             info.dir,
-			relevance:       MaxRelevance - 1,
-		}
-		if info.rootType == gopathwalk.RootGOROOT {
-			p.relevance = MaxRelevance
-		}
-
-		if !callback.dirFound(p) {
-			return
-		}
-		var err error
-		p.packageName, err = r.cache.CachePackageName(info)
-		if err != nil {
-			return
-		}
-
-		if !callback.packageNameLoaded(p) {
-			return
-		}
-		if _, exports, err := r.loadExports(ctx, p, false); err == nil {
-			callback.exportsLoaded(p, exports)
-		}
-	}
-	stop := r.cache.ScanAndListen(ctx, processDir)
-	defer stop()
-
-	goenv, err := r.env.goEnv()
-	if err != nil {
-		return err
-	}
-	var roots []gopathwalk.Root
-	roots = append(roots, gopathwalk.Root{Path: filepath.Join(goenv["GOROOT"], "src"), Type: gopathwalk.RootGOROOT})
-	for _, p := range filepath.SplitList(goenv["GOPATH"]) {
-		roots = append(roots, gopathwalk.Root{Path: filepath.Join(p, "src"), Type: gopathwalk.RootGOPATH})
-	}
-	// The callback is not necessarily safe to use in the goroutine below. Process roots eagerly.
-	roots = filterRoots(roots, callback.rootFound)
-	// We can't cancel walks, because we need them to finish to have a usable
-	// cache. Instead, run them in a separate goroutine and detach.
-	scanDone := make(chan struct{})
-	go func() {
-		select {
-		case <-ctx.Done():
-			return
-		case <-r.scanSema:
-		}
-		defer func() { r.scanSema <- struct{}{} }()
-		gopathwalk.Walk(roots, add, gopathwalk.Options{Logf: r.env.Logf, ModulesEnabled: false})
-		close(scanDone)
-	}()
-	select {
-	case <-ctx.Done():
-	case <-scanDone:
-	}
-	return nil
-}
-
-func (r *gopathResolver) scoreImportPath(ctx context.Context, path string) float64 {
-	if stdlib.HasPackage(path) {
-		return MaxRelevance
-	}
-	return MaxRelevance - 1
-}
-
-func filterRoots(roots []gopathwalk.Root, include func(gopathwalk.Root) bool) []gopathwalk.Root {
-	var result []gopathwalk.Root
-	for _, root := range roots {
-		if !include(root) {
-			continue
-		}
-		result = append(result, root)
-	}
-	return result
-}
-
-func (r *gopathResolver) loadExports(ctx context.Context, pkg *pkg, includeTest bool) (string, []stdlib.Symbol, error) {
-	if info, ok := r.cache.Load(pkg.dir); ok && !includeTest {
-		return r.cache.CacheExports(ctx, r.env, info)
-	}
-	return loadExportsFromFiles(ctx, r.env, pkg.dir, includeTest)
-}
-
-// VendorlessPath returns the devendorized version of the import path ipath.
-// For example, VendorlessPath("foo/bar/vendor/a/b") returns "a/b".
-func VendorlessPath(ipath string) string {
-	// Devendorize for use in import statement.
-	if i := strings.LastIndex(ipath, "/vendor/"); i >= 0 {
-		return ipath[i+len("/vendor/"):]
-	}
-	if strings.HasPrefix(ipath, "vendor/") {
-		return ipath[len("vendor/"):]
-	}
-	return ipath
-}
-
-func loadExportsFromFiles(ctx context.Context, env *ProcessEnv, dir string, includeTest bool) (string, []stdlib.Symbol, error) {
-	// Look for non-test, buildable .go files which could provide exports.
-	all, err := os.ReadDir(dir)
-	if err != nil {
-		return "", nil, err
-	}
-	var files []fs.DirEntry
-	for _, fi := range all {
-		name := fi.Name()
-		if !strings.HasSuffix(name, ".go") || (!includeTest && strings.HasSuffix(name, "_test.go")) {
-			continue
-		}
-		match, err := env.matchFile(dir, fi.Name())
-		if err != nil || !match {
-			continue
-		}
-		files = append(files, fi)
-	}
-
-	if len(files) == 0 {
-		return "", nil, fmt.Errorf("dir %v contains no buildable, non-test .go files", dir)
-	}
-
-	var pkgName string
-	var exports []stdlib.Symbol
-	fset := token.NewFileSet()
-	for _, fi := range files {
-		select {
-		case <-ctx.Done():
-			return "", nil, ctx.Err()
-		default:
-		}
-
-		fullFile := filepath.Join(dir, fi.Name())
-		// Legacy ast.Object resolution is needed here.
-		f, err := parser.ParseFile(fset, fullFile, nil, 0)
-		if err != nil {
-			env.logf("error parsing %v: %v", fullFile, err)
-			continue
-		}
-		if f.Name.Name == "documentation" {
-			// Special case from go/build.ImportDir, not
-			// handled by MatchFile above.
-			continue
-		}
-		if includeTest && strings.HasSuffix(f.Name.Name, "_test") {
-			// x_test package. We want internal test files only.
-			continue
-		}
-		pkgName = f.Name.Name
-		for name, obj := range f.Scope.Objects {
-			if ast.IsExported(name) {
-				var kind stdlib.Kind
-				switch obj.Kind {
-				case ast.Con:
-					kind = stdlib.Const
-				case ast.Typ:
-					kind = stdlib.Type
-				case ast.Var:
-					kind = stdlib.Var
-				case ast.Fun:
-					kind = stdlib.Func
-				}
-				exports = append(exports, stdlib.Symbol{
-					Name:    name,
-					Kind:    kind,
-					Version: 0, // unknown; be permissive
-				})
-			}
-		}
-	}
-	sortSymbols(exports)
-
-	env.logf("loaded exports in dir %v (package %v): %v", dir, pkgName, exports)
-	return pkgName, exports, nil
-}
-
-func sortSymbols(syms []stdlib.Symbol) {
-	sort.Slice(syms, func(i, j int) bool {
-		return syms[i].Name < syms[j].Name
-	})
-}
-
-// A symbolSearcher searches for a package with a set of symbols, among a set
-// of candidates. See [symbolSearcher.search].
-//
-// The search occurs within the scope of a single file, with context captured
-// in srcDir and xtest.
-type symbolSearcher struct {
-	logf        func(string, ...any)
-	srcDir      string // directory containing the file
-	xtest       bool   // if set, the file containing is an x_test file
-	loadExports func(ctx context.Context, pkg *pkg, includeTest bool) (string, []stdlib.Symbol, error)
-}
-
-// search searches the provided candidates for a package containing all
-// exported symbols.
-//
-// If successful, returns the resulting package.
-func (s *symbolSearcher) search(ctx context.Context, candidates []pkgDistance, pkgName string, symbols map[string]bool) (*pkg, error) {
-	// Sort the candidates by their import package length,
-	// assuming that shorter package names are better than long
-	// ones.  Note that this sorts by the de-vendored name, so
-	// there's no "penalty" for vendoring.
-	sort.Sort(byDistanceOrImportPathShortLength(candidates))
-	if s.logf != nil {
-		for i, c := range candidates {
-			s.logf("%s candidate %d/%d: %v in %v", pkgName, i+1, len(candidates), c.pkg.importPathShort, c.pkg.dir)
-		}
-	}
-
-	// Arrange rescv so that we can we can await results in order of relevance
-	// and exit as soon as we find the first match.
-	//
-	// Search with bounded concurrency, returning as soon as the first result
-	// among rescv is non-nil.
-	rescv := make([]chan *pkg, len(candidates))
-	for i := range candidates {
-		rescv[i] = make(chan *pkg, 1)
-	}
-	const maxConcurrentPackageImport = 4
-	loadExportsSem := make(chan struct{}, maxConcurrentPackageImport)
-
-	// Ensure that all work is completed at exit.
-	ctx, cancel := context.WithCancel(ctx)
-	var wg sync.WaitGroup
-	defer func() {
-		cancel()
-		wg.Wait()
-	}()
-
-	// Start the search.
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		for i, c := range candidates {
-			select {
-			case loadExportsSem <- struct{}{}:
-			case <-ctx.Done():
-				return
-			}
-
-			i := i
-			c := c
-			wg.Add(1)
-			go func() {
-				defer func() {
-					<-loadExportsSem
-					wg.Done()
-				}()
-				if s.logf != nil {
-					s.logf("loading exports in dir %s (seeking package %s)", c.pkg.dir, pkgName)
-				}
-				pkg, err := s.searchOne(ctx, c, symbols)
-				if err != nil {
-					if s.logf != nil && ctx.Err() == nil {
-						s.logf("loading exports in dir %s (seeking package %s): %v", c.pkg.dir, pkgName, err)
-					}
-					pkg = nil
-				}
-				rescv[i] <- pkg // may be nil
-			}()
-		}
-	}()
-
-	// Await the first (best) result.
-	for _, resc := range rescv {
-		select {
-		case r := <-resc:
-			if r != nil {
-				return r, nil
-			}
-		case <-ctx.Done():
-			return nil, ctx.Err()
-		}
-	}
-	return nil, nil
-}
-
-func (s *symbolSearcher) searchOne(ctx context.Context, c pkgDistance, symbols map[string]bool) (*pkg, error) {
-	if ctx.Err() != nil {
-		return nil, ctx.Err()
-	}
-	// If we're considering the package under test from an x_test, load the
-	// test variant.
-	includeTest := s.xtest && c.pkg.dir == s.srcDir
-	_, exports, err := s.loadExports(ctx, c.pkg, includeTest)
-	if err != nil {
-		return nil, err
-	}
-
-	exportsMap := make(map[string]bool, len(exports))
-	for _, sym := range exports {
-		exportsMap[sym.Name] = true
-	}
-	for symbol := range symbols {
-		if !exportsMap[symbol] {
-			return nil, nil // no match
-		}
-	}
-	return c.pkg, nil
-}
-
-// pkgIsCandidate reports whether pkg is a candidate for satisfying the
-// finding which package pkgIdent in the file named by filename is trying
-// to refer to.
-//
-// This check is purely lexical and is meant to be as fast as possible
-// because it's run over all $GOPATH directories to filter out poor
-// candidates in order to limit the CPU and I/O later parsing the
-// exports in candidate packages.
-//
-// filename is the file being formatted.
-// pkgIdent is the package being searched for, like "client" (if
-// searching for "client.New")
-func pkgIsCandidate(filename string, refs References, pkg *pkg) bool {
-	// Check "internal" and "vendor" visibility:
-	if !CanUse(filename, pkg.dir) {
-		return false
-	}
-
-	// Speed optimization to minimize disk I/O:
-	//
-	// Use the matchesPath heuristic to filter to package paths that could
-	// reasonably match a dangling reference.
-	//
-	// This permits mismatch naming like directory "go-foo" being package "foo",
-	// or "pkg.v3" being "pkg", or directory
-	// "google.golang.org/api/cloudbilling/v1" being package "cloudbilling", but
-	// doesn't permit a directory "foo" to be package "bar", which is strongly
-	// discouraged anyway. There's no reason goimports needs to be slow just to
-	// accommodate that.
-	for pkgIdent := range refs {
-		if matchesPath(pkgIdent, pkg.importPathShort) {
-			return true
-		}
-	}
-	return false
-}
-
-// CanUse reports whether the package in dir is usable from filename,
-// respecting the Go "internal" and "vendor" visibility rules.
-func CanUse(filename, dir string) bool {
-	// Fast path check, before any allocations. If it doesn't contain vendor
-	// or internal, it's not tricky:
-	// Note that this can false-negative on directories like "notinternal",
-	// but we check it correctly below. This is just a fast path.
-	if !strings.Contains(dir, "vendor") && !strings.Contains(dir, "internal") {
-		return true
-	}
-
-	dirSlash := filepath.ToSlash(dir)
-	if !strings.Contains(dirSlash, "/vendor/") && !strings.Contains(dirSlash, "/internal/") && !strings.HasSuffix(dirSlash, "/internal") {
-		return true
-	}
-	// Vendor or internal directory only visible from children of parent.
-	// That means the path from the current directory to the target directory
-	// can contain ../vendor or ../internal but not ../foo/vendor or ../foo/internal
-	// or bar/vendor or bar/internal.
-	// After stripping all the leading ../, the only okay place to see vendor or internal
-	// is at the very beginning of the path.
-	absfile, err := filepath.Abs(filename)
-	if err != nil {
-		return false
-	}
-	absdir, err := filepath.Abs(dir)
-	if err != nil {
-		return false
-	}
-	rel, err := filepath.Rel(absfile, absdir)
-	if err != nil {
-		return false
-	}
-	relSlash := filepath.ToSlash(rel)
-	if i := strings.LastIndex(relSlash, "../"); i >= 0 {
-		relSlash = relSlash[i+len("../"):]
-	}
-	return !strings.Contains(relSlash, "/vendor/") && !strings.Contains(relSlash, "/internal/") && !strings.HasSuffix(relSlash, "/internal")
-}
-
-// matchesPath reports whether ident may match a potential package name
-// referred to by path, using heuristics to filter out unidiomatic package
-// names.
-//
-// Specifically, it checks whether either of the last two '/'- or '\'-delimited
-// path segments matches the identifier. The segment-matching heuristic must
-// allow for various conventions around segment naming, including go-foo,
-// foo-go, and foo.v3. To handle all of these, matching considers both (1) the
-// entire segment, ignoring '-' and '.', as well as (2) the last subsegment
-// separated by '-' or '.'. So the segment foo-go matches all of the following
-// identifiers: foo, go, and foogo. All matches are case insensitive (for ASCII
-// identifiers).
-//
-// See the docstring for [pkgIsCandidate] for an explanation of how this
-// heuristic filters potential candidate packages.
-func matchesPath(ident, path string) bool {
-	// Ignore case, for ASCII.
-	lowerIfASCII := func(b byte) byte {
-		if 'A' <= b && b <= 'Z' {
-			return b + ('a' - 'A')
-		}
-		return b
-	}
-
-	// match reports whether path[start:end] matches ident, ignoring [.-].
-	match := func(start, end int) bool {
-		ii := len(ident) - 1 // current byte in ident
-		pi := end - 1        // current byte in path
-		for ; pi >= start && ii >= 0; pi-- {
-			pb := path[pi]
-			if pb == '-' || pb == '.' {
-				continue
-			}
-			pb = lowerIfASCII(pb)
-			ib := lowerIfASCII(ident[ii])
-			if pb != ib {
-				return false
-			}
-			ii--
-		}
-		return ii < 0 && pi < start // all bytes matched
-	}
-
-	// segmentEnd and subsegmentEnd hold the end points of the current segment
-	// and subsegment intervals.
-	segmentEnd := len(path)
-	subsegmentEnd := len(path)
-
-	// Count slashes; we only care about the last two segments.
-	nslash := 0
-
-	for i := len(path) - 1; i >= 0; i-- {
-		switch b := path[i]; b {
-		// TODO(rfindley): we handle backlashes here only because the previous
-		// heuristic handled backslashes. This is perhaps overly defensive, but is
-		// the result of many lessons regarding Chesterton's fence and the
-		// goimports codebase.
-		//
-		// However, this function is only ever called with something called an
-		// 'importPath'. Is it possible that this is a real import path, and
-		// therefore we need only consider forward slashes?
-		case '/', '\\':
-			if match(i+1, segmentEnd) || match(i+1, subsegmentEnd) {
-				return true
-			}
-			nslash++
-			if nslash == 2 {
-				return false // did not match above
-			}
-			segmentEnd, subsegmentEnd = i, i // reset
-		case '-', '.':
-			if match(i+1, subsegmentEnd) {
-				return true
-			}
-			subsegmentEnd = i
-		}
-	}
-	return match(0, segmentEnd) || match(0, subsegmentEnd)
-}
-
-type visitFn func(node ast.Node) ast.Visitor
-
-func (fn visitFn) Visit(node ast.Node) ast.Visitor {
-	return fn(node)
-}
-
-func symbolNameSet(symbols []stdlib.Symbol) map[string]bool {
-	names := make(map[string]bool)
-	for _, sym := range symbols {
-		switch sym.Kind {
-		case stdlib.Const, stdlib.Var, stdlib.Type, stdlib.Func:
-			names[sym.Name] = true
-		}
-	}
-	return names
-}
diff --git a/vendor/golang.org/x/tools/internal/imports/imports.go b/vendor/golang.org/x/tools/internal/imports/imports.go
deleted file mode 100644
index b5f5218b5..000000000
--- a/vendor/golang.org/x/tools/internal/imports/imports.go
+++ /dev/null
@@ -1,359 +0,0 @@
-// Copyright 2013 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 imports implements a Go pretty-printer (like package "go/format")
-// that also adds or removes import statements as necessary.
-package imports
-
-import (
-	"bufio"
-	"bytes"
-	"context"
-	"fmt"
-	"go/ast"
-	"go/format"
-	"go/parser"
-	"go/printer"
-	"go/token"
-	"io"
-	"regexp"
-	"strconv"
-	"strings"
-
-	"golang.org/x/tools/go/ast/astutil"
-	"golang.org/x/tools/internal/event"
-)
-
-// Options is golang.org/x/tools/imports.Options with extra internal-only options.
-type Options struct {
-	Env *ProcessEnv // The environment to use. Note: this contains the cached module and filesystem state.
-
-	// LocalPrefix is a comma-separated string of import path prefixes, which, if
-	// set, instructs Process to sort the import paths with the given prefixes
-	// into another group after 3rd-party packages.
-	LocalPrefix string
-
-	Fragment  bool // Accept fragment of a source file (no package statement)
-	AllErrors bool // Report all errors (not just the first 10 on different lines)
-
-	Comments  bool // Print comments (true if nil *Options provided)
-	TabIndent bool // Use tabs for indent (true if nil *Options provided)
-	TabWidth  int  // Tab width (8 if nil *Options provided)
-
-	FormatOnly bool // Disable the insertion and deletion of imports
-}
-
-// Process implements golang.org/x/tools/imports.Process with explicit context in opt.Env.
-func Process(filename string, src []byte, opt *Options) (formatted []byte, err error) {
-	fileSet := token.NewFileSet()
-	var parserMode parser.Mode
-	if opt.Comments {
-		parserMode |= parser.ParseComments
-	}
-	if opt.AllErrors {
-		parserMode |= parser.AllErrors
-	}
-	file, adjust, err := parse(fileSet, filename, src, parserMode, opt.Fragment)
-	if err != nil {
-		return nil, err
-	}
-
-	if !opt.FormatOnly {
-		if err := fixImports(fileSet, file, filename, opt.Env); err != nil {
-			return nil, err
-		}
-	}
-	return formatFile(fileSet, file, src, adjust, opt)
-}
-
-// FixImports returns a list of fixes to the imports that, when applied,
-// will leave the imports in the same state as Process. src and opt must
-// be specified.
-//
-// Note that filename's directory influences which imports can be chosen,
-// so it is important that filename be accurate.
-func FixImports(ctx context.Context, filename string, src []byte, goroot string, logf func(string, ...any), source Source) (fixes []*ImportFix, err error) {
-	ctx, done := event.Start(ctx, "imports.FixImports")
-	defer done()
-
-	fileSet := token.NewFileSet()
-	// TODO(rfindley): these default values for ParseComments and AllErrors were
-	// extracted from gopls, but are they even needed?
-	file, _, err := parse(fileSet, filename, src, parser.ParseComments|parser.AllErrors, true)
-	if err != nil {
-		return nil, err
-	}
-
-	return getFixesWithSource(ctx, fileSet, file, filename, goroot, logf, source)
-}
-
-// ApplyFixes applies all of the fixes to the file and formats it. extraMode
-// is added in when parsing the file. src and opts must be specified, but no
-// env is needed.
-func ApplyFixes(fixes []*ImportFix, filename string, src []byte, opt *Options, extraMode parser.Mode) (formatted []byte, err error) {
-	// Don't use parse() -- we don't care about fragments or statement lists
-	// here, and we need to work with unparsable files.
-	fileSet := token.NewFileSet()
-	parserMode := parser.SkipObjectResolution
-	if opt.Comments {
-		parserMode |= parser.ParseComments
-	}
-	if opt.AllErrors {
-		parserMode |= parser.AllErrors
-	}
-	parserMode |= extraMode
-
-	file, err := parser.ParseFile(fileSet, filename, src, parserMode)
-	if file == nil {
-		return nil, err
-	}
-
-	// Apply the fixes to the file.
-	apply(fileSet, file, fixes)
-
-	return formatFile(fileSet, file, src, nil, opt)
-}
-
-// formatFile formats the file syntax tree.
-// It may mutate the token.FileSet and the ast.File.
-//
-// If an adjust function is provided, it is called after formatting
-// with the original source (formatFile's src parameter) and the
-// formatted file, and returns the postpocessed result.
-func formatFile(fset *token.FileSet, file *ast.File, src []byte, adjust func(orig []byte, src []byte) []byte, opt *Options) ([]byte, error) {
-	mergeImports(file)
-	sortImports(opt.LocalPrefix, fset.File(file.FileStart), file)
-	var spacesBefore []string // import paths we need spaces before
-	for _, impSection := range astutil.Imports(fset, file) {
-		// Within each block of contiguous imports, see if any
-		// import lines are in different group numbers. If so,
-		// we'll need to put a space between them so it's
-		// compatible with gofmt.
-		lastGroup := -1
-		for _, importSpec := range impSection {
-			importPath, _ := strconv.Unquote(importSpec.Path.Value)
-			groupNum := importGroup(opt.LocalPrefix, importPath)
-			if groupNum != lastGroup && lastGroup != -1 {
-				spacesBefore = append(spacesBefore, importPath)
-			}
-			lastGroup = groupNum
-		}
-
-	}
-
-	printerMode := printer.UseSpaces
-	if opt.TabIndent {
-		printerMode |= printer.TabIndent
-	}
-	printConfig := &printer.Config{Mode: printerMode, Tabwidth: opt.TabWidth}
-
-	var buf bytes.Buffer
-	err := printConfig.Fprint(&buf, fset, file)
-	if err != nil {
-		return nil, err
-	}
-	out := buf.Bytes()
-	if adjust != nil {
-		out = adjust(src, out)
-	}
-	if len(spacesBefore) > 0 {
-		out, err = addImportSpaces(bytes.NewReader(out), spacesBefore)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	out, err = format.Source(out)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// parse parses src, which was read from filename,
-// as a Go source file or statement list.
-func parse(fset *token.FileSet, filename string, src []byte, parserMode parser.Mode, fragment bool) (*ast.File, func(orig, src []byte) []byte, error) {
-	if parserMode&parser.SkipObjectResolution != 0 {
-		panic("legacy ast.Object resolution is required")
-	}
-
-	// Try as whole source file.
-	file, err := parser.ParseFile(fset, filename, src, parserMode)
-	if err == nil {
-		return file, nil, nil
-	}
-	// If the error is that the source file didn't begin with a
-	// package line and we accept fragmented input, fall through to
-	// try as a source fragment.  Stop and return on any other error.
-	if !fragment || !strings.Contains(err.Error(), "expected 'package'") {
-		return nil, nil, err
-	}
-
-	// If this is a declaration list, make it a source file
-	// by inserting a package clause.
-	// Insert using a ;, not a newline, so that parse errors are on
-	// the correct line.
-	const prefix = "package main;"
-	psrc := append([]byte(prefix), src...)
-	file, err = parser.ParseFile(fset, filename, psrc, parserMode)
-	if err == nil {
-		// Gofmt will turn the ; into a \n.
-		// Do that ourselves now and update the file contents,
-		// so that positions and line numbers are correct going forward.
-		psrc[len(prefix)-1] = '\n'
-		fset.File(file.Package).SetLinesForContent(psrc)
-
-		// If a main function exists, we will assume this is a main
-		// package and leave the file.
-		if containsMainFunc(file) {
-			return file, nil, nil
-		}
-
-		adjust := func(orig, src []byte) []byte {
-			// Remove the package clause.
-			src = src[len(prefix):]
-			return matchSpace(orig, src)
-		}
-		return file, adjust, nil
-	}
-	// If the error is that the source file didn't begin with a
-	// declaration, fall through to try as a statement list.
-	// Stop and return on any other error.
-	if !strings.Contains(err.Error(), "expected declaration") {
-		return nil, nil, err
-	}
-
-	// If this is a statement list, make it a source file
-	// by inserting a package clause and turning the list
-	// into a function body.  This handles expressions too.
-	// Insert using a ;, not a newline, so that the line numbers
-	// in fsrc match the ones in src.
-	fsrc := append(append([]byte("package p; func _() {"), src...), '}')
-	file, err = parser.ParseFile(fset, filename, fsrc, parserMode)
-	if err == nil {
-		adjust := func(orig, src []byte) []byte {
-			// Remove the wrapping.
-			// Gofmt has turned the ; into a \n\n.
-			src = src[len("package p\n\nfunc _() {"):]
-			src = src[:len(src)-len("}\n")]
-			// Gofmt has also indented the function body one level.
-			// Remove that indent.
-			src = bytes.ReplaceAll(src, []byte("\n\t"), []byte("\n"))
-			return matchSpace(orig, src)
-		}
-		return file, adjust, nil
-	}
-
-	// Failed, and out of options.
-	return nil, nil, err
-}
-
-// containsMainFunc checks if a file contains a function declaration with the
-// function signature 'func main()'
-func containsMainFunc(file *ast.File) bool {
-	for _, decl := range file.Decls {
-		if f, ok := decl.(*ast.FuncDecl); ok {
-			if f.Name.Name != "main" {
-				continue
-			}
-
-			if len(f.Type.Params.List) != 0 {
-				continue
-			}
-
-			if f.Type.Results != nil && len(f.Type.Results.List) != 0 {
-				continue
-			}
-
-			return true
-		}
-	}
-
-	return false
-}
-
-func cutSpace(b []byte) (before, middle, after []byte) {
-	i := 0
-	for i < len(b) && (b[i] == ' ' || b[i] == '\t' || b[i] == '\n') {
-		i++
-	}
-	j := len(b)
-	for j > 0 && (b[j-1] == ' ' || b[j-1] == '\t' || b[j-1] == '\n') {
-		j--
-	}
-	if i <= j {
-		return b[:i], b[i:j], b[j:]
-	}
-	return nil, nil, b[j:]
-}
-
-// matchSpace reformats src to use the same space context as orig.
-//  1. If orig begins with blank lines, matchSpace inserts them at the beginning of src.
-//  2. matchSpace copies the indentation of the first non-blank line in orig
-//     to every non-blank line in src.
-//  3. matchSpace copies the trailing space from orig and uses it in place
-//     of src's trailing space.
-func matchSpace(orig []byte, src []byte) []byte {
-	before, _, after := cutSpace(orig)
-	i := bytes.LastIndex(before, []byte{'\n'})
-	before, indent := before[:i+1], before[i+1:]
-
-	_, src, _ = cutSpace(src)
-
-	var b bytes.Buffer
-	b.Write(before)
-	for len(src) > 0 {
-		line := src
-		if i := bytes.IndexByte(line, '\n'); i >= 0 {
-			line, src = line[:i+1], line[i+1:]
-		} else {
-			src = nil
-		}
-		if len(line) > 0 && line[0] != '\n' { // not blank
-			b.Write(indent)
-		}
-		b.Write(line)
-	}
-	b.Write(after)
-	return b.Bytes()
-}
-
-var impLine = regexp.MustCompile(`^\s+(?:[\w\.]+\s+)?"(.+?)"`)
-
-func addImportSpaces(r io.Reader, breaks []string) ([]byte, error) {
-	var out bytes.Buffer
-	in := bufio.NewReader(r)
-	inImports := false
-	done := false
-	for {
-		s, err := in.ReadString('\n')
-		if err == io.EOF {
-			break
-		} else if err != nil {
-			return nil, err
-		}
-
-		if !inImports && !done && strings.HasPrefix(s, "import") {
-			inImports = true
-		}
-		if inImports && (strings.HasPrefix(s, "var") ||
-			strings.HasPrefix(s, "func") ||
-			strings.HasPrefix(s, "const") ||
-			strings.HasPrefix(s, "type")) {
-			done = true
-			inImports = false
-		}
-		if inImports && len(breaks) > 0 {
-			if m := impLine.FindStringSubmatch(s); m != nil {
-				if m[1] == breaks[0] {
-					out.WriteByte('\n')
-					breaks = breaks[1:]
-				}
-			}
-		}
-
-		fmt.Fprint(&out, s)
-	}
-	return out.Bytes(), nil
-}
diff --git a/vendor/golang.org/x/tools/internal/imports/mod.go b/vendor/golang.org/x/tools/internal/imports/mod.go
deleted file mode 100644
index df94ec818..000000000
--- a/vendor/golang.org/x/tools/internal/imports/mod.go
+++ /dev/null
@@ -1,841 +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 imports
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"os"
-	"path"
-	"path/filepath"
-	"regexp"
-	"slices"
-	"sort"
-	"strconv"
-	"strings"
-
-	"golang.org/x/mod/module"
-	"golang.org/x/tools/internal/event"
-	"golang.org/x/tools/internal/gocommand"
-	"golang.org/x/tools/internal/gopathwalk"
-	"golang.org/x/tools/internal/stdlib"
-)
-
-// Notes(rfindley): ModuleResolver appears to be heavily optimized for scanning
-// as fast as possible, which is desirable for a call to goimports from the
-// command line, but it doesn't work as well for gopls, where it suffers from
-// slow startup (golang/go#44863) and intermittent hanging (golang/go#59216),
-// both caused by populating the cache, albeit in slightly different ways.
-//
-// A high level list of TODOs:
-//  - Optimize the scan itself, as there is some redundancy statting and
-//    reading go.mod files.
-//  - Invert the relationship between ProcessEnv and Resolver (see the
-//    docstring of ProcessEnv).
-//  - Make it easier to use an external resolver implementation.
-//
-// Smaller TODOs are annotated in the code below.
-
-// ModuleResolver implements the Resolver interface for a workspace using
-// modules.
-//
-// A goal of the ModuleResolver is to invoke the Go command as little as
-// possible. To this end, it runs the Go command only for listing module
-// information (i.e. `go list -m -e -json ...`). Package scanning, the process
-// of loading package information for the modules, is implemented internally
-// via the scan method.
-//
-// It has two types of state: the state derived from the go command, which
-// is populated by init, and the state derived from scans, which is populated
-// via scan. A root is considered scanned if it has been walked to discover
-// directories. However, if the scan did not require additional information
-// from the directory (such as package name or exports), the directory
-// information itself may be partially populated. It will be lazily filled in
-// as needed by scans, using the scanCallback.
-type ModuleResolver struct {
-	env *ProcessEnv
-
-	// Module state, populated during construction
-	dummyVendorMod *gocommand.ModuleJSON            // if vendoring is enabled, a pseudo-module to represent the /vendor directory
-	moduleCacheDir string                           // GOMODCACHE, inferred from GOPATH if unset
-	roots          []gopathwalk.Root                // roots to scan, in approximate order of importance
-	mains          []*gocommand.ModuleJSON          // main modules
-	mainByDir      map[string]*gocommand.ModuleJSON // module information by dir, to join with roots
-	modsByModPath  []*gocommand.ModuleJSON          // all modules, ordered by # of path components in their module path
-	modsByDir      []*gocommand.ModuleJSON          // ...or by the number of path components in their Dir.
-
-	// Scanning state, populated by scan
-
-	// scanSema prevents concurrent scans, and guards scannedRoots and the cache
-	// fields below (though the caches themselves are concurrency safe).
-	// Receive to acquire, send to release.
-	scanSema     chan struct{}
-	scannedRoots map[gopathwalk.Root]bool // if true, root has been walked
-
-	// Caches of directory info, populated by scans and scan callbacks
-	//
-	// moduleCacheCache stores cached information about roots in the module
-	// cache, which are immutable and therefore do not need to be invalidated.
-	//
-	// otherCache stores information about all other roots (even GOROOT), which
-	// may change.
-	moduleCacheCache *DirInfoCache
-	otherCache       *DirInfoCache
-}
-
-// newModuleResolver returns a new module-aware goimports resolver.
-//
-// Note: use caution when modifying this constructor: changes must also be
-// reflected in ModuleResolver.ClearForNewScan.
-func newModuleResolver(e *ProcessEnv, moduleCacheCache *DirInfoCache) (*ModuleResolver, error) {
-	r := &ModuleResolver{
-		env:      e,
-		scanSema: make(chan struct{}, 1),
-	}
-	r.scanSema <- struct{}{} // release
-
-	goenv, err := r.env.goEnv()
-	if err != nil {
-		return nil, err
-	}
-
-	// TODO(rfindley): can we refactor to share logic with r.env.invokeGo?
-	inv := gocommand.Invocation{
-		BuildFlags: r.env.BuildFlags,
-		ModFlag:    r.env.ModFlag,
-		Env:        r.env.env(),
-		Logf:       r.env.Logf,
-		WorkingDir: r.env.WorkingDir,
-	}
-
-	vendorEnabled := false
-	var mainModVendor *gocommand.ModuleJSON    // for module vendoring
-	var mainModsVendor []*gocommand.ModuleJSON // for workspace vendoring
-
-	goWork := r.env.Env["GOWORK"]
-	if len(goWork) == 0 {
-		// TODO(rfindley): VendorEnabled runs the go command to get GOFLAGS, but
-		// they should be available from the ProcessEnv. Can we avoid the redundant
-		// invocation?
-		vendorEnabled, mainModVendor, err = gocommand.VendorEnabled(context.TODO(), inv, r.env.GocmdRunner)
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		vendorEnabled, mainModsVendor, err = gocommand.WorkspaceVendorEnabled(context.Background(), inv, r.env.GocmdRunner)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	if vendorEnabled {
-		if mainModVendor != nil {
-			// Module vendor mode is on, so all the non-Main modules are irrelevant,
-			// and we need to search /vendor for everything.
-			r.mains = []*gocommand.ModuleJSON{mainModVendor}
-			r.dummyVendorMod = &gocommand.ModuleJSON{
-				Path: "",
-				Dir:  filepath.Join(mainModVendor.Dir, "vendor"),
-			}
-			r.modsByModPath = []*gocommand.ModuleJSON{mainModVendor, r.dummyVendorMod}
-			r.modsByDir = []*gocommand.ModuleJSON{mainModVendor, r.dummyVendorMod}
-		} else {
-			// Workspace vendor mode is on, so all the non-Main modules are irrelevant,
-			// and we need to search /vendor for everything.
-			r.mains = mainModsVendor
-			r.dummyVendorMod = &gocommand.ModuleJSON{
-				Path: "",
-				Dir:  filepath.Join(filepath.Dir(goWork), "vendor"),
-			}
-			r.modsByModPath = append(slices.Clone(mainModsVendor), r.dummyVendorMod)
-			r.modsByDir = append(slices.Clone(mainModsVendor), r.dummyVendorMod)
-		}
-	} else {
-		// Vendor mode is off, so run go list -m ... to find everything.
-		err := r.initAllMods()
-		// We expect an error when running outside of a module with
-		// GO111MODULE=on. Other errors are fatal.
-		if err != nil {
-			if errMsg := err.Error(); !strings.Contains(errMsg, "working directory is not part of a module") && !strings.Contains(errMsg, "go.mod file not found") {
-				return nil, err
-			}
-		}
-	}
-
-	r.moduleCacheDir = gomodcacheForEnv(goenv)
-	if r.moduleCacheDir == "" {
-		return nil, fmt.Errorf("cannot resolve GOMODCACHE")
-	}
-
-	sort.Slice(r.modsByModPath, func(i, j int) bool {
-		count := func(x int) int {
-			return strings.Count(r.modsByModPath[x].Path, "/")
-		}
-		return count(j) < count(i) // descending order
-	})
-	sort.Slice(r.modsByDir, func(i, j int) bool {
-		count := func(x int) int {
-			return strings.Count(r.modsByDir[x].Dir, string(filepath.Separator))
-		}
-		return count(j) < count(i) // descending order
-	})
-
-	r.roots = []gopathwalk.Root{}
-	if goenv["GOROOT"] != "" { // "" happens in tests
-		r.roots = append(r.roots, gopathwalk.Root{Path: filepath.Join(goenv["GOROOT"], "/src"), Type: gopathwalk.RootGOROOT})
-	}
-	r.mainByDir = make(map[string]*gocommand.ModuleJSON)
-	for _, main := range r.mains {
-		r.roots = append(r.roots, gopathwalk.Root{Path: main.Dir, Type: gopathwalk.RootCurrentModule})
-		r.mainByDir[main.Dir] = main
-	}
-	if vendorEnabled {
-		r.roots = append(r.roots, gopathwalk.Root{Path: r.dummyVendorMod.Dir, Type: gopathwalk.RootOther})
-	} else {
-		addDep := func(mod *gocommand.ModuleJSON) {
-			if mod.Replace == nil {
-				// This is redundant with the cache, but we'll skip it cheaply enough
-				// when we encounter it in the module cache scan.
-				//
-				// Including it at a lower index in r.roots than the module cache dir
-				// helps prioritize matches from within existing dependencies.
-				r.roots = append(r.roots, gopathwalk.Root{Path: mod.Dir, Type: gopathwalk.RootModuleCache})
-			} else {
-				r.roots = append(r.roots, gopathwalk.Root{Path: mod.Dir, Type: gopathwalk.RootOther})
-			}
-		}
-		// Walk dependent modules before scanning the full mod cache, direct deps first.
-		for _, mod := range r.modsByModPath {
-			if !mod.Indirect && !mod.Main {
-				addDep(mod)
-			}
-		}
-		for _, mod := range r.modsByModPath {
-			if mod.Indirect && !mod.Main {
-				addDep(mod)
-			}
-		}
-		// If provided, share the moduleCacheCache.
-		//
-		// TODO(rfindley): The module cache is immutable. However, the loaded
-		// exports do depend on GOOS and GOARCH. Fortunately, the
-		// ProcessEnv.buildContext does not adjust these from build.DefaultContext
-		// (even though it should). So for now, this is OK to share, but we need to
-		// add logic for handling GOOS/GOARCH.
-		r.moduleCacheCache = moduleCacheCache
-		r.roots = append(r.roots, gopathwalk.Root{Path: r.moduleCacheDir, Type: gopathwalk.RootModuleCache})
-	}
-
-	r.scannedRoots = map[gopathwalk.Root]bool{}
-	if r.moduleCacheCache == nil {
-		r.moduleCacheCache = NewDirInfoCache()
-	}
-	r.otherCache = NewDirInfoCache()
-	return r, nil
-}
-
-// gomodcacheForEnv returns the GOMODCACHE value to use based on the given env
-// map, which must have GOMODCACHE and GOPATH populated.
-//
-// TODO(rfindley): this is defensive refactoring.
-//  1. Is this even relevant anymore? Can't we just read GOMODCACHE.
-//  2. Use this to separate module cache scanning from other scanning.
-func gomodcacheForEnv(goenv map[string]string) string {
-	if gmc := goenv["GOMODCACHE"]; gmc != "" {
-		// golang/go#67156: ensure that the module cache is clean, since it is
-		// assumed as a prefix to directories scanned by gopathwalk, which are
-		// themselves clean.
-		return filepath.Clean(gmc)
-	}
-	gopaths := filepath.SplitList(goenv["GOPATH"])
-	if len(gopaths) == 0 {
-		return ""
-	}
-	return filepath.Join(gopaths[0], "/pkg/mod")
-}
-
-func (r *ModuleResolver) initAllMods() error {
-	stdout, err := r.env.invokeGo(context.TODO(), "list", "-m", "-e", "-json", "...")
-	if err != nil {
-		return err
-	}
-	for dec := json.NewDecoder(stdout); dec.More(); {
-		mod := &gocommand.ModuleJSON{}
-		if err := dec.Decode(mod); err != nil {
-			return err
-		}
-		if mod.Dir == "" {
-			r.env.logf("module %v has not been downloaded and will be ignored", mod.Path)
-			// Can't do anything with a module that's not downloaded.
-			continue
-		}
-		// golang/go#36193: the go command doesn't always clean paths.
-		mod.Dir = filepath.Clean(mod.Dir)
-		r.modsByModPath = append(r.modsByModPath, mod)
-		r.modsByDir = append(r.modsByDir, mod)
-		if mod.Main {
-			r.mains = append(r.mains, mod)
-		}
-	}
-	return nil
-}
-
-// ClearForNewScan invalidates the last scan.
-//
-// It preserves the set of roots, but forgets about the set of directories.
-// Though it forgets the set of module cache directories, it remembers their
-// contents, since they are assumed to be immutable.
-func (r *ModuleResolver) ClearForNewScan() Resolver {
-	<-r.scanSema // acquire r, to guard scannedRoots
-	r2 := &ModuleResolver{
-		env:            r.env,
-		dummyVendorMod: r.dummyVendorMod,
-		moduleCacheDir: r.moduleCacheDir,
-		roots:          r.roots,
-		mains:          r.mains,
-		mainByDir:      r.mainByDir,
-		modsByModPath:  r.modsByModPath,
-
-		scanSema:         make(chan struct{}, 1),
-		scannedRoots:     make(map[gopathwalk.Root]bool),
-		otherCache:       NewDirInfoCache(),
-		moduleCacheCache: r.moduleCacheCache,
-	}
-	r2.scanSema <- struct{}{} // r2 must start released
-	// Invalidate root scans. We don't need to invalidate module cache roots,
-	// because they are immutable.
-	// (We don't support a use case where GOMODCACHE is cleaned in the middle of
-	// e.g. a gopls session: the user must restart gopls to get accurate
-	// imports.)
-	//
-	// Scanning for new directories in GOMODCACHE should be handled elsewhere,
-	// via a call to ScanModuleCache.
-	for _, root := range r.roots {
-		if root.Type == gopathwalk.RootModuleCache && r.scannedRoots[root] {
-			r2.scannedRoots[root] = true
-		}
-	}
-	r.scanSema <- struct{}{} // release r
-	return r2
-}
-
-// ClearModuleInfo invalidates resolver state that depends on go.mod file
-// contents (essentially, the output of go list -m -json ...).
-//
-// Notably, it does not forget directory contents, which are reset
-// asynchronously via ClearForNewScan.
-//
-// If the ProcessEnv is a GOPATH environment, ClearModuleInfo is a no op.
-//
-// TODO(rfindley): move this to a new env.go, consolidating ProcessEnv methods.
-func (e *ProcessEnv) ClearModuleInfo() {
-	if r, ok := e.resolver.(*ModuleResolver); ok {
-		resolver, err := newModuleResolver(e, e.ModCache)
-		if err != nil {
-			e.resolver = nil
-			e.resolverErr = err
-			return
-		}
-
-		<-r.scanSema // acquire (guards caches)
-		resolver.moduleCacheCache = r.moduleCacheCache
-		resolver.otherCache = r.otherCache
-		r.scanSema <- struct{}{} // release
-
-		e.UpdateResolver(resolver)
-	}
-}
-
-// UpdateResolver sets the resolver for the ProcessEnv to use in imports
-// operations. Only for use with the result of [Resolver.ClearForNewScan].
-//
-// TODO(rfindley): this awkward API is a result of the (arguably) inverted
-// relationship between configuration and state described in the doc comment
-// for [ProcessEnv].
-func (e *ProcessEnv) UpdateResolver(r Resolver) {
-	e.resolver = r
-	e.resolverErr = nil
-}
-
-// findPackage returns the module and directory from within the main modules
-// and their dependencies that contains the package at the given import path,
-// or returns nil, "" if no module is in scope.
-func (r *ModuleResolver) findPackage(importPath string) (*gocommand.ModuleJSON, string) {
-	// This can't find packages in the stdlib, but that's harmless for all
-	// the existing code paths.
-	for _, m := range r.modsByModPath {
-		if !strings.HasPrefix(importPath, m.Path) {
-			continue
-		}
-		pathInModule := importPath[len(m.Path):]
-		pkgDir := filepath.Join(m.Dir, pathInModule)
-		if r.dirIsNestedModule(pkgDir, m) {
-			continue
-		}
-
-		if info, ok := r.cacheLoad(pkgDir); ok {
-			if loaded, err := info.reachedStatus(nameLoaded); loaded {
-				if err != nil {
-					continue // No package in this dir.
-				}
-				return m, pkgDir
-			}
-			if scanned, err := info.reachedStatus(directoryScanned); scanned && err != nil {
-				continue // Dir is unreadable, etc.
-			}
-			// This is slightly wrong: a directory doesn't have to have an
-			// importable package to count as a package for package-to-module
-			// resolution. package main or _test files should count but
-			// don't.
-			// TODO(heschi): fix this.
-			if _, err := r.cachePackageName(info); err == nil {
-				return m, pkgDir
-			}
-		}
-
-		// Not cached. Read the filesystem.
-		pkgFiles, err := os.ReadDir(pkgDir)
-		if err != nil {
-			continue
-		}
-		// A module only contains a package if it has buildable go
-		// files in that directory. If not, it could be provided by an
-		// outer module. See #29736.
-		for _, fi := range pkgFiles {
-			if ok, _ := r.env.matchFile(pkgDir, fi.Name()); ok {
-				return m, pkgDir
-			}
-		}
-	}
-	return nil, ""
-}
-
-func (r *ModuleResolver) cacheLoad(dir string) (directoryPackageInfo, bool) {
-	if info, ok := r.moduleCacheCache.Load(dir); ok {
-		return info, ok
-	}
-	return r.otherCache.Load(dir)
-}
-
-func (r *ModuleResolver) cacheStore(info directoryPackageInfo) {
-	if info.rootType == gopathwalk.RootModuleCache {
-		r.moduleCacheCache.Store(info.dir, info)
-	} else {
-		r.otherCache.Store(info.dir, info)
-	}
-}
-
-// cachePackageName caches the package name for a dir already in the cache.
-func (r *ModuleResolver) cachePackageName(info directoryPackageInfo) (string, error) {
-	if info.rootType == gopathwalk.RootModuleCache {
-		return r.moduleCacheCache.CachePackageName(info)
-	}
-	return r.otherCache.CachePackageName(info)
-}
-
-func (r *ModuleResolver) cacheExports(ctx context.Context, env *ProcessEnv, info directoryPackageInfo) (string, []stdlib.Symbol, error) {
-	if info.rootType == gopathwalk.RootModuleCache {
-		return r.moduleCacheCache.CacheExports(ctx, env, info)
-	}
-	return r.otherCache.CacheExports(ctx, env, info)
-}
-
-// findModuleByDir returns the module that contains dir, or nil if no such
-// module is in scope.
-func (r *ModuleResolver) findModuleByDir(dir string) *gocommand.ModuleJSON {
-	// This is quite tricky and may not be correct. dir could be:
-	// - a package in the main module.
-	// - a replace target underneath the main module's directory.
-	//    - a nested module in the above.
-	// - a replace target somewhere totally random.
-	//    - a nested module in the above.
-	// - in the mod cache.
-	// - in /vendor/ in -mod=vendor mode.
-	//    - nested module? Dunno.
-	// Rumor has it that replace targets cannot contain other replace targets.
-	//
-	// Note that it is critical here that modsByDir is sorted to have deeper dirs
-	// first. This ensures that findModuleByDir finds the innermost module.
-	// See also golang/go#56291.
-	for _, m := range r.modsByDir {
-		if !strings.HasPrefix(dir, m.Dir) {
-			continue
-		}
-
-		if r.dirIsNestedModule(dir, m) {
-			continue
-		}
-
-		return m
-	}
-	return nil
-}
-
-// dirIsNestedModule reports if dir is contained in a nested module underneath
-// mod, not actually in mod.
-func (r *ModuleResolver) dirIsNestedModule(dir string, mod *gocommand.ModuleJSON) bool {
-	if !strings.HasPrefix(dir, mod.Dir) {
-		return false
-	}
-	if r.dirInModuleCache(dir) {
-		// Nested modules in the module cache are pruned,
-		// so it cannot be a nested module.
-		return false
-	}
-	if mod != nil && mod == r.dummyVendorMod {
-		// The /vendor pseudomodule is flattened and doesn't actually count.
-		return false
-	}
-	modDir, _ := r.modInfo(dir)
-	if modDir == "" {
-		return false
-	}
-	return modDir != mod.Dir
-}
-
-func readModName(modFile string) string {
-	modBytes, err := os.ReadFile(modFile)
-	if err != nil {
-		return ""
-	}
-	return modulePath(modBytes)
-}
-
-func (r *ModuleResolver) modInfo(dir string) (modDir, modName string) {
-	if r.dirInModuleCache(dir) {
-		if matches := modCacheRegexp.FindStringSubmatch(dir); len(matches) == 3 {
-			index := strings.Index(dir, matches[1]+"@"+matches[2])
-			modDir := filepath.Join(dir[:index], matches[1]+"@"+matches[2])
-			return modDir, readModName(filepath.Join(modDir, "go.mod"))
-		}
-	}
-	for {
-		if info, ok := r.cacheLoad(dir); ok {
-			return info.moduleDir, info.moduleName
-		}
-		f := filepath.Join(dir, "go.mod")
-		info, err := os.Stat(f)
-		if err == nil && !info.IsDir() {
-			return dir, readModName(f)
-		}
-
-		d := filepath.Dir(dir)
-		if len(d) >= len(dir) {
-			return "", "" // reached top of file system, no go.mod
-		}
-		dir = d
-	}
-}
-
-func (r *ModuleResolver) dirInModuleCache(dir string) bool {
-	if r.moduleCacheDir == "" {
-		return false
-	}
-	return strings.HasPrefix(dir, r.moduleCacheDir)
-}
-
-func (r *ModuleResolver) loadPackageNames(importPaths []string, srcDir string) (map[string]string, error) {
-	names := map[string]string{}
-	for _, path := range importPaths {
-		// TODO(rfindley): shouldn't this use the dirInfoCache?
-		_, packageDir := r.findPackage(path)
-		if packageDir == "" {
-			continue
-		}
-		name, err := packageDirToName(packageDir)
-		if err != nil {
-			continue
-		}
-		names[path] = name
-	}
-	return names, nil
-}
-
-func (r *ModuleResolver) scan(ctx context.Context, callback *scanCallback) error {
-	ctx, done := event.Start(ctx, "imports.ModuleResolver.scan")
-	defer done()
-
-	processDir := func(info directoryPackageInfo) {
-		// Skip this directory if we were not able to get the package information successfully.
-		if scanned, err := info.reachedStatus(directoryScanned); !scanned || err != nil {
-			return
-		}
-		pkg, err := r.canonicalize(info)
-		if err != nil {
-			return
-		}
-		if !callback.dirFound(pkg) {
-			return
-		}
-
-		pkg.packageName, err = r.cachePackageName(info)
-		if err != nil {
-			return
-		}
-		if !callback.packageNameLoaded(pkg) {
-			return
-		}
-
-		_, exports, err := r.loadExports(ctx, pkg, false)
-		if err != nil {
-			return
-		}
-		callback.exportsLoaded(pkg, exports)
-	}
-
-	// Start processing everything in the cache, and listen for the new stuff
-	// we discover in the walk below.
-	stop1 := r.moduleCacheCache.ScanAndListen(ctx, processDir)
-	defer stop1()
-	stop2 := r.otherCache.ScanAndListen(ctx, processDir)
-	defer stop2()
-
-	// We assume cached directories are fully cached, including all their
-	// children, and have not changed. We can skip them.
-	skip := func(root gopathwalk.Root, dir string) bool {
-		if r.env.SkipPathInScan != nil && root.Type == gopathwalk.RootCurrentModule {
-			if root.Path == dir {
-				return false
-			}
-
-			if r.env.SkipPathInScan(filepath.Clean(dir)) {
-				return true
-			}
-		}
-
-		info, ok := r.cacheLoad(dir)
-		if !ok {
-			return false
-		}
-		// This directory can be skipped as long as we have already scanned it.
-		// Packages with errors will continue to have errors, so there is no need
-		// to rescan them.
-		packageScanned, _ := info.reachedStatus(directoryScanned)
-		return packageScanned
-	}
-
-	add := func(root gopathwalk.Root, dir string) {
-		r.cacheStore(r.scanDirForPackage(root, dir))
-	}
-
-	// r.roots and the callback are not necessarily safe to use in the
-	// goroutine below. Process them eagerly.
-	roots := filterRoots(r.roots, callback.rootFound)
-	// We can't cancel walks, because we need them to finish to have a usable
-	// cache. Instead, run them in a separate goroutine and detach.
-	scanDone := make(chan struct{})
-	go func() {
-		select {
-		case <-ctx.Done():
-			return
-		case <-r.scanSema: // acquire
-		}
-		defer func() { r.scanSema <- struct{}{} }() // release
-		// We have the lock on r.scannedRoots, and no other scans can run.
-		for _, root := range roots {
-			if ctx.Err() != nil {
-				return
-			}
-
-			if r.scannedRoots[root] {
-				continue
-			}
-			gopathwalk.WalkSkip([]gopathwalk.Root{root}, add, skip, gopathwalk.Options{Logf: r.env.Logf, ModulesEnabled: true})
-			r.scannedRoots[root] = true
-		}
-		close(scanDone)
-	}()
-	select {
-	case <-ctx.Done():
-	case <-scanDone:
-	}
-	return nil
-}
-
-func (r *ModuleResolver) scoreImportPath(ctx context.Context, path string) float64 {
-	if stdlib.HasPackage(path) {
-		return MaxRelevance
-	}
-	mod, _ := r.findPackage(path)
-	return modRelevance(mod)
-}
-
-func modRelevance(mod *gocommand.ModuleJSON) float64 {
-	var relevance float64
-	switch {
-	case mod == nil: // out of scope
-		return MaxRelevance - 4
-	case mod.Indirect:
-		relevance = MaxRelevance - 3
-	case !mod.Main:
-		relevance = MaxRelevance - 2
-	default:
-		relevance = MaxRelevance - 1 // main module ties with stdlib
-	}
-
-	_, versionString, ok := module.SplitPathVersion(mod.Path)
-	if ok {
-		index := strings.Index(versionString, "v")
-		if index == -1 {
-			return relevance
-		}
-		if versionNumber, err := strconv.ParseFloat(versionString[index+1:], 64); err == nil {
-			relevance += versionNumber / 1000
-		}
-	}
-
-	return relevance
-}
-
-// canonicalize gets the result of canonicalizing the packages using the results
-// of initializing the resolver from 'go list -m'.
-func (r *ModuleResolver) canonicalize(info directoryPackageInfo) (*pkg, error) {
-	// Packages in GOROOT are already canonical, regardless of the std/cmd modules.
-	if info.rootType == gopathwalk.RootGOROOT {
-		return &pkg{
-			importPathShort: info.nonCanonicalImportPath,
-			dir:             info.dir,
-			packageName:     path.Base(info.nonCanonicalImportPath),
-			relevance:       MaxRelevance,
-		}, nil
-	}
-
-	importPath := info.nonCanonicalImportPath
-	mod := r.findModuleByDir(info.dir)
-	// Check if the directory is underneath a module that's in scope.
-	if mod != nil {
-		// It is. If dir is the target of a replace directive,
-		// our guessed import path is wrong. Use the real one.
-		if mod.Dir == info.dir {
-			importPath = mod.Path
-		} else {
-			dirInMod := info.dir[len(mod.Dir)+len("/"):]
-			importPath = path.Join(mod.Path, filepath.ToSlash(dirInMod))
-		}
-	} else if !strings.HasPrefix(importPath, info.moduleName) {
-		// The module's name doesn't match the package's import path. It
-		// probably needs a replace directive we don't have.
-		return nil, fmt.Errorf("package in %q is not valid without a replace statement", info.dir)
-	}
-
-	res := &pkg{
-		importPathShort: importPath,
-		dir:             info.dir,
-		relevance:       modRelevance(mod),
-	}
-	// We may have discovered a package that has a different version
-	// in scope already. Canonicalize to that one if possible.
-	if _, canonicalDir := r.findPackage(importPath); canonicalDir != "" {
-		res.dir = canonicalDir
-	}
-	return res, nil
-}
-
-func (r *ModuleResolver) loadExports(ctx context.Context, pkg *pkg, includeTest bool) (string, []stdlib.Symbol, error) {
-	if info, ok := r.cacheLoad(pkg.dir); ok && !includeTest {
-		return r.cacheExports(ctx, r.env, info)
-	}
-	return loadExportsFromFiles(ctx, r.env, pkg.dir, includeTest)
-}
-
-func (r *ModuleResolver) scanDirForPackage(root gopathwalk.Root, dir string) directoryPackageInfo {
-	subdir := ""
-	if prefix := root.Path + string(filepath.Separator); strings.HasPrefix(dir, prefix) {
-		subdir = dir[len(prefix):]
-	}
-	importPath := filepath.ToSlash(subdir)
-	if strings.HasPrefix(importPath, "vendor/") {
-		// Only enter vendor directories if they're explicitly requested as a root.
-		return directoryPackageInfo{
-			status: directoryScanned,
-			err:    fmt.Errorf("unwanted vendor directory"),
-		}
-	}
-	switch root.Type {
-	case gopathwalk.RootCurrentModule:
-		importPath = path.Join(r.mainByDir[root.Path].Path, filepath.ToSlash(subdir))
-	case gopathwalk.RootModuleCache:
-		matches := modCacheRegexp.FindStringSubmatch(subdir)
-		if len(matches) == 0 {
-			return directoryPackageInfo{
-				status: directoryScanned,
-				err:    fmt.Errorf("invalid module cache path: %v", subdir),
-			}
-		}
-		modPath, err := module.UnescapePath(filepath.ToSlash(matches[1]))
-		if err != nil {
-			r.env.logf("decoding module cache path %q: %v", subdir, err)
-			return directoryPackageInfo{
-				status: directoryScanned,
-				err:    fmt.Errorf("decoding module cache path %q: %v", subdir, err),
-			}
-		}
-		importPath = path.Join(modPath, filepath.ToSlash(matches[3]))
-	}
-
-	modDir, modName := r.modInfo(dir)
-	result := directoryPackageInfo{
-		status:                 directoryScanned,
-		dir:                    dir,
-		rootType:               root.Type,
-		nonCanonicalImportPath: importPath,
-		moduleDir:              modDir,
-		moduleName:             modName,
-	}
-	if root.Type == gopathwalk.RootGOROOT {
-		// stdlib packages are always in scope, despite the confusing go.mod
-		return result
-	}
-	return result
-}
-
-// modCacheRegexp splits a path in a module cache into module, module version, and package.
-var modCacheRegexp = regexp.MustCompile(`(.*)@([^/\\]*)(.*)`)
-
-var (
-	slashSlash = []byte("//")
-	moduleStr  = []byte("module")
-)
-
-// modulePath returns the module path from the gomod file text.
-// If it cannot find a module path, it returns an empty string.
-// It is tolerant of unrelated problems in the go.mod file.
-//
-// Copied from cmd/go/internal/modfile.
-func modulePath(mod []byte) string {
-	for len(mod) > 0 {
-		line := mod
-		mod = nil
-		if i := bytes.IndexByte(line, '\n'); i >= 0 {
-			line, mod = line[:i], line[i+1:]
-		}
-		if i := bytes.Index(line, slashSlash); i >= 0 {
-			line = line[:i]
-		}
-		line = bytes.TrimSpace(line)
-		if !bytes.HasPrefix(line, moduleStr) {
-			continue
-		}
-		line = line[len(moduleStr):]
-		n := len(line)
-		line = bytes.TrimSpace(line)
-		if len(line) == n || len(line) == 0 {
-			continue
-		}
-
-		if line[0] == '"' || line[0] == '`' {
-			p, err := strconv.Unquote(string(line))
-			if err != nil {
-				return "" // malformed quoted string or multiline module path
-			}
-			return p
-		}
-
-		return string(line)
-	}
-	return "" // missing module path
-}
diff --git a/vendor/golang.org/x/tools/internal/imports/mod_cache.go b/vendor/golang.org/x/tools/internal/imports/mod_cache.go
deleted file mode 100644
index b96c9d4bf..000000000
--- a/vendor/golang.org/x/tools/internal/imports/mod_cache.go
+++ /dev/null
@@ -1,331 +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 imports
-
-import (
-	"context"
-	"fmt"
-	"path"
-	"path/filepath"
-	"strings"
-	"sync"
-
-	"golang.org/x/mod/module"
-	"golang.org/x/tools/internal/gopathwalk"
-	"golang.org/x/tools/internal/stdlib"
-)
-
-// To find packages to import, the resolver needs to know about all of
-// the packages that could be imported. This includes packages that are
-// already in modules that are in (1) the current module, (2) replace targets,
-// and (3) packages in the module cache. Packages in (1) and (2) may change over
-// time, as the client may edit the current module and locally replaced modules.
-// The module cache (which includes all of the packages in (3)) can only
-// ever be added to.
-//
-// The resolver can thus save state about packages in the module cache
-// and guarantee that this will not change over time. To obtain information
-// about new modules added to the module cache, the module cache should be
-// rescanned.
-//
-// It is OK to serve information about modules that have been deleted,
-// as they do still exist.
-// TODO(suzmue): can we share information with the caller about
-// what module needs to be downloaded to import this package?
-
-type directoryPackageStatus int
-
-const (
-	_ directoryPackageStatus = iota
-	directoryScanned
-	nameLoaded
-	exportsLoaded
-)
-
-// directoryPackageInfo holds (possibly incomplete) information about packages
-// contained in a given directory.
-type directoryPackageInfo struct {
-	// status indicates the extent to which this struct has been filled in.
-	status directoryPackageStatus
-	// err is non-nil when there was an error trying to reach status.
-	err error
-
-	// Set when status >= directoryScanned.
-
-	// dir is the absolute directory of this package.
-	dir      string
-	rootType gopathwalk.RootType
-	// nonCanonicalImportPath is the package's expected import path. It may
-	// not actually be importable at that path.
-	nonCanonicalImportPath string
-
-	// Module-related information.
-	moduleDir  string // The directory that is the module root of this dir.
-	moduleName string // The module name that contains this dir.
-
-	// Set when status >= nameLoaded.
-
-	packageName string // the package name, as declared in the source.
-
-	// Set when status >= exportsLoaded.
-	// TODO(rfindley): it's hard to see this, but exports depend implicitly on
-	// the default build context GOOS and GOARCH.
-	//
-	// We can make this explicit, and key exports by GOOS, GOARCH.
-	exports []stdlib.Symbol
-}
-
-// reachedStatus returns true when info has a status at least target and any error associated with
-// an attempt to reach target.
-func (info *directoryPackageInfo) reachedStatus(target directoryPackageStatus) (bool, error) {
-	if info.err == nil {
-		return info.status >= target, nil
-	}
-	if info.status == target {
-		return true, info.err
-	}
-	return true, nil
-}
-
-// DirInfoCache is a concurrency-safe map for storing information about
-// directories that may contain packages.
-//
-// The information in this cache is built incrementally. Entries are initialized in scan.
-// No new keys should be added in any other functions, as all directories containing
-// packages are identified in scan.
-//
-// Other functions, including loadExports and findPackage, may update entries in this cache
-// as they discover new things about the directory.
-//
-// The information in the cache is not expected to change for the cache's
-// lifetime, so there is no protection against competing writes. Users should
-// take care not to hold the cache across changes to the underlying files.
-type DirInfoCache struct {
-	mu sync.Mutex
-	// dirs stores information about packages in directories, keyed by absolute path.
-	dirs      map[string]*directoryPackageInfo
-	listeners map[*int]cacheListener
-}
-
-func NewDirInfoCache() *DirInfoCache {
-	return &DirInfoCache{
-		dirs:      make(map[string]*directoryPackageInfo),
-		listeners: make(map[*int]cacheListener),
-	}
-}
-
-type cacheListener func(directoryPackageInfo)
-
-// ScanAndListen calls listener on all the items in the cache, and on anything
-// newly added. The returned stop function waits for all in-flight callbacks to
-// finish and blocks new ones.
-func (d *DirInfoCache) ScanAndListen(ctx context.Context, listener cacheListener) func() {
-	ctx, cancel := context.WithCancel(ctx)
-
-	// Flushing out all the callbacks is tricky without knowing how many there
-	// are going to be. Setting an arbitrary limit makes it much easier.
-	const maxInFlight = 10
-	sema := make(chan struct{}, maxInFlight)
-	for range maxInFlight {
-		sema <- struct{}{}
-	}
-
-	cookie := new(int) // A unique ID we can use for the listener.
-
-	// We can't hold mu while calling the listener.
-	d.mu.Lock()
-	var keys []string
-	for key := range d.dirs {
-		keys = append(keys, key)
-	}
-	d.listeners[cookie] = func(info directoryPackageInfo) {
-		select {
-		case <-ctx.Done():
-			return
-		case <-sema:
-		}
-		listener(info)
-		sema <- struct{}{}
-	}
-	d.mu.Unlock()
-
-	stop := func() {
-		cancel()
-		d.mu.Lock()
-		delete(d.listeners, cookie)
-		d.mu.Unlock()
-		for range maxInFlight {
-			<-sema
-		}
-	}
-
-	// Process the pre-existing keys.
-	for _, k := range keys {
-		select {
-		case <-ctx.Done():
-			return stop
-		default:
-		}
-		if v, ok := d.Load(k); ok {
-			listener(v)
-		}
-	}
-
-	return stop
-}
-
-// Store stores the package info for dir.
-func (d *DirInfoCache) Store(dir string, info directoryPackageInfo) {
-	d.mu.Lock()
-	// TODO(rfindley, golang/go#59216): should we overwrite an existing entry?
-	// That seems incorrect as the cache should be idempotent.
-	_, old := d.dirs[dir]
-	d.dirs[dir] = &info
-	var listeners []cacheListener
-	for _, l := range d.listeners {
-		listeners = append(listeners, l)
-	}
-	d.mu.Unlock()
-
-	if !old {
-		for _, l := range listeners {
-			l(info)
-		}
-	}
-}
-
-// Load returns a copy of the directoryPackageInfo for absolute directory dir.
-func (d *DirInfoCache) Load(dir string) (directoryPackageInfo, bool) {
-	d.mu.Lock()
-	defer d.mu.Unlock()
-	info, ok := d.dirs[dir]
-	if !ok {
-		return directoryPackageInfo{}, false
-	}
-	return *info, true
-}
-
-// Keys returns the keys currently present in d.
-func (d *DirInfoCache) Keys() (keys []string) {
-	d.mu.Lock()
-	defer d.mu.Unlock()
-	for key := range d.dirs {
-		keys = append(keys, key)
-	}
-	return keys
-}
-
-func (d *DirInfoCache) CachePackageName(info directoryPackageInfo) (string, error) {
-	if loaded, err := info.reachedStatus(nameLoaded); loaded {
-		return info.packageName, err
-	}
-	if scanned, err := info.reachedStatus(directoryScanned); !scanned || err != nil {
-		return "", fmt.Errorf("cannot read package name, scan error: %v", err)
-	}
-	info.packageName, info.err = packageDirToName(info.dir)
-	info.status = nameLoaded
-	d.Store(info.dir, info)
-	return info.packageName, info.err
-}
-
-func (d *DirInfoCache) CacheExports(ctx context.Context, env *ProcessEnv, info directoryPackageInfo) (string, []stdlib.Symbol, error) {
-	if reached, _ := info.reachedStatus(exportsLoaded); reached {
-		return info.packageName, info.exports, info.err
-	}
-	if reached, err := info.reachedStatus(nameLoaded); reached && err != nil {
-		return "", nil, err
-	}
-	info.packageName, info.exports, info.err = loadExportsFromFiles(ctx, env, info.dir, false)
-	if info.err == context.Canceled || info.err == context.DeadlineExceeded {
-		return info.packageName, info.exports, info.err
-	}
-	// The cache structure wants things to proceed linearly. We can skip a
-	// step here, but only if we succeed.
-	if info.status == nameLoaded || info.err == nil {
-		info.status = exportsLoaded
-	} else {
-		info.status = nameLoaded
-	}
-	d.Store(info.dir, info)
-	return info.packageName, info.exports, info.err
-}
-
-// ScanModuleCache walks the given directory, which must be a GOMODCACHE value,
-// for directory package information, storing the results in cache.
-func ScanModuleCache(dir string, cache *DirInfoCache, logf func(string, ...any)) {
-	// Note(rfindley): it's hard to see, but this function attempts to implement
-	// just the side effects on cache of calling PrimeCache with a ProcessEnv
-	// that has the given dir as its GOMODCACHE.
-	//
-	// Teasing out the control flow, we see that we can avoid any handling of
-	// vendor/ and can infer module info entirely from the path, simplifying the
-	// logic here.
-
-	root := gopathwalk.Root{
-		Path: filepath.Clean(dir),
-		Type: gopathwalk.RootModuleCache,
-	}
-
-	directoryInfo := func(root gopathwalk.Root, dir string) directoryPackageInfo {
-		// This is a copy of ModuleResolver.scanDirForPackage, trimmed down to
-		// logic that applies to a module cache directory.
-
-		subdir := ""
-		if dir != root.Path {
-			subdir = dir[len(root.Path)+len("/"):]
-		}
-
-		matches := modCacheRegexp.FindStringSubmatch(subdir)
-		if len(matches) == 0 {
-			return directoryPackageInfo{
-				status: directoryScanned,
-				err:    fmt.Errorf("invalid module cache path: %v", subdir),
-			}
-		}
-		modPath, err := module.UnescapePath(filepath.ToSlash(matches[1]))
-		if err != nil {
-			if logf != nil {
-				logf("decoding module cache path %q: %v", subdir, err)
-			}
-			return directoryPackageInfo{
-				status: directoryScanned,
-				err:    fmt.Errorf("decoding module cache path %q: %v", subdir, err),
-			}
-		}
-		importPath := path.Join(modPath, filepath.ToSlash(matches[3]))
-		index := strings.Index(dir, matches[1]+"@"+matches[2])
-		modDir := filepath.Join(dir[:index], matches[1]+"@"+matches[2])
-		modName := readModName(filepath.Join(modDir, "go.mod"))
-		return directoryPackageInfo{
-			status:                 directoryScanned,
-			dir:                    dir,
-			rootType:               root.Type,
-			nonCanonicalImportPath: importPath,
-			moduleDir:              modDir,
-			moduleName:             modName,
-		}
-	}
-
-	add := func(root gopathwalk.Root, dir string) {
-		info := directoryInfo(root, dir)
-		cache.Store(info.dir, info)
-	}
-
-	skip := func(_ gopathwalk.Root, dir string) bool {
-		// Skip directories that have already been scanned.
-		//
-		// Note that gopathwalk only adds "package" directories, which must contain
-		// a .go file, and all such package directories in the module cache are
-		// immutable. So if we can load a dir, it can be skipped.
-		info, ok := cache.Load(dir)
-		if !ok {
-			return false
-		}
-		packageScanned, _ := info.reachedStatus(directoryScanned)
-		return packageScanned
-	}
-
-	gopathwalk.WalkSkip([]gopathwalk.Root{root}, add, skip, gopathwalk.Options{Logf: logf, ModulesEnabled: true})
-}
diff --git a/vendor/golang.org/x/tools/internal/imports/sortimports.go b/vendor/golang.org/x/tools/internal/imports/sortimports.go
deleted file mode 100644
index 67c17bc43..000000000
--- a/vendor/golang.org/x/tools/internal/imports/sortimports.go
+++ /dev/null
@@ -1,298 +0,0 @@
-// Copyright 2013 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.
-
-// Hacked up copy of go/ast/import.go
-// Modified to use a single token.File in preference to a FileSet.
-
-package imports
-
-import (
-	"go/ast"
-	"go/token"
-	"log"
-	"slices"
-	"sort"
-	"strconv"
-)
-
-// sortImports sorts runs of consecutive import lines in import blocks in f.
-// It also removes duplicate imports when it is possible to do so without data loss.
-//
-// It may mutate the token.File and the ast.File.
-func sortImports(localPrefix string, tokFile *token.File, f *ast.File) {
-	for i, d := range f.Decls {
-		d, ok := d.(*ast.GenDecl)
-		if !ok || d.Tok != token.IMPORT {
-			// Not an import declaration, so we're done.
-			// Imports are always first.
-			break
-		}
-
-		if len(d.Specs) == 0 {
-			// Empty import block, remove it.
-			f.Decls = slices.Delete(f.Decls, i, i+1)
-		}
-
-		if !d.Lparen.IsValid() {
-			// Not a block: sorted by default.
-			continue
-		}
-
-		// Identify and sort runs of specs on successive lines.
-		i := 0
-		specs := d.Specs[:0]
-		for j, s := range d.Specs {
-			if j > i && tokFile.Line(s.Pos()) > 1+tokFile.Line(d.Specs[j-1].End()) {
-				// j begins a new run.  End this one.
-				specs = append(specs, sortSpecs(localPrefix, tokFile, f, d.Specs[i:j])...)
-				i = j
-			}
-		}
-		specs = append(specs, sortSpecs(localPrefix, tokFile, f, d.Specs[i:])...)
-		d.Specs = specs
-
-		// Deduping can leave a blank line before the rparen; clean that up.
-		// Ignore line directives.
-		if len(d.Specs) > 0 {
-			lastSpec := d.Specs[len(d.Specs)-1]
-			lastLine := tokFile.PositionFor(lastSpec.Pos(), false).Line
-			if rParenLine := tokFile.PositionFor(d.Rparen, false).Line; rParenLine > lastLine+1 {
-				tokFile.MergeLine(rParenLine - 1) // has side effects!
-			}
-		}
-	}
-}
-
-// mergeImports merges all the import declarations into the first one.
-// Taken from golang.org/x/tools/ast/astutil.
-// This does not adjust line numbers properly
-func mergeImports(f *ast.File) {
-	if len(f.Decls) <= 1 {
-		return
-	}
-
-	// Merge all the import declarations into the first one.
-	var first *ast.GenDecl
-	for i := 0; i < len(f.Decls); i++ {
-		decl := f.Decls[i]
-		gen, ok := decl.(*ast.GenDecl)
-		if !ok || gen.Tok != token.IMPORT || declImports(gen, "C") {
-			continue
-		}
-		if first == nil {
-			first = gen
-			continue // Don't touch the first one.
-		}
-		// We now know there is more than one package in this import
-		// declaration. Ensure that it ends up parenthesized.
-		first.Lparen = first.Pos()
-		// Move the imports of the other import declaration to the first one.
-		for _, spec := range gen.Specs {
-			spec.(*ast.ImportSpec).Path.ValuePos = first.Pos()
-			first.Specs = append(first.Specs, spec)
-		}
-		f.Decls = slices.Delete(f.Decls, i, i+1)
-		i--
-	}
-}
-
-// declImports reports whether gen contains an import of path.
-// Taken from golang.org/x/tools/ast/astutil.
-func declImports(gen *ast.GenDecl, path string) bool {
-	if gen.Tok != token.IMPORT {
-		return false
-	}
-	for _, spec := range gen.Specs {
-		impspec := spec.(*ast.ImportSpec)
-		if importPath(impspec) == path {
-			return true
-		}
-	}
-	return false
-}
-
-func importPath(s ast.Spec) string {
-	t, err := strconv.Unquote(s.(*ast.ImportSpec).Path.Value)
-	if err == nil {
-		return t
-	}
-	return ""
-}
-
-func importName(s ast.Spec) string {
-	n := s.(*ast.ImportSpec).Name
-	if n == nil {
-		return ""
-	}
-	return n.Name
-}
-
-func importComment(s ast.Spec) string {
-	c := s.(*ast.ImportSpec).Comment
-	if c == nil {
-		return ""
-	}
-	return c.Text()
-}
-
-// collapse indicates whether prev may be removed, leaving only next.
-func collapse(prev, next ast.Spec) bool {
-	if importPath(next) != importPath(prev) || importName(next) != importName(prev) {
-		return false
-	}
-	return prev.(*ast.ImportSpec).Comment == nil
-}
-
-type posSpan struct {
-	Start token.Pos
-	End   token.Pos
-}
-
-// sortSpecs sorts the import specs within each import decl.
-// It may mutate the token.File.
-func sortSpecs(localPrefix string, tokFile *token.File, f *ast.File, specs []ast.Spec) []ast.Spec {
-	// Can't short-circuit here even if specs are already sorted,
-	// since they might yet need deduplication.
-	// A lone import, however, may be safely ignored.
-	if len(specs) <= 1 {
-		return specs
-	}
-
-	// Record positions for specs.
-	pos := make([]posSpan, len(specs))
-	for i, s := range specs {
-		pos[i] = posSpan{s.Pos(), s.End()}
-	}
-
-	// Identify comments in this range.
-	// Any comment from pos[0].Start to the final line counts.
-	lastLine := tokFile.Line(pos[len(pos)-1].End)
-	cstart := len(f.Comments)
-	cend := len(f.Comments)
-	for i, g := range f.Comments {
-		if g.Pos() < pos[0].Start {
-			continue
-		}
-		if i < cstart {
-			cstart = i
-		}
-		if tokFile.Line(g.End()) > lastLine {
-			cend = i
-			break
-		}
-	}
-	comments := f.Comments[cstart:cend]
-
-	// Assign each comment to the import spec preceding it.
-	importComment := map[*ast.ImportSpec][]*ast.CommentGroup{}
-	specIndex := 0
-	for _, g := range comments {
-		for specIndex+1 < len(specs) && pos[specIndex+1].Start <= g.Pos() {
-			specIndex++
-		}
-		s := specs[specIndex].(*ast.ImportSpec)
-		importComment[s] = append(importComment[s], g)
-	}
-
-	// Sort the import specs by import path.
-	// Remove duplicates, when possible without data loss.
-	// Reassign the import paths to have the same position sequence.
-	// Reassign each comment to abut the end of its spec.
-	// Sort the comments by new position.
-	sort.Sort(byImportSpec{localPrefix, specs})
-
-	// Dedup. Thanks to our sorting, we can just consider
-	// adjacent pairs of imports.
-	deduped := specs[:0]
-	for i, s := range specs {
-		if i == len(specs)-1 || !collapse(s, specs[i+1]) {
-			deduped = append(deduped, s)
-		} else {
-			p := s.Pos()
-			tokFile.MergeLine(tokFile.Line(p)) // has side effects!
-		}
-	}
-	specs = deduped
-
-	// Fix up comment positions
-	for i, s := range specs {
-		s := s.(*ast.ImportSpec)
-		if s.Name != nil {
-			s.Name.NamePos = pos[i].Start
-		}
-		s.Path.ValuePos = pos[i].Start
-		s.EndPos = pos[i].End
-		nextSpecPos := pos[i].End
-
-		for _, g := range importComment[s] {
-			for _, c := range g.List {
-				c.Slash = pos[i].End
-				nextSpecPos = c.End()
-			}
-		}
-		if i < len(specs)-1 {
-			pos[i+1].Start = nextSpecPos
-			pos[i+1].End = nextSpecPos
-		}
-	}
-
-	sort.Sort(byCommentPos(comments))
-
-	// Fixup comments can insert blank lines, because import specs are on different lines.
-	// We remove those blank lines here by merging import spec to the first import spec line.
-	firstSpecLine := tokFile.Line(specs[0].Pos())
-	for _, s := range specs[1:] {
-		p := s.Pos()
-		line := tokFile.Line(p)
-		for previousLine := line - 1; previousLine >= firstSpecLine; {
-			// MergeLine can panic. Avoid the panic at the cost of not removing the blank line
-			// golang/go#50329
-			if previousLine > 0 && previousLine < tokFile.LineCount() {
-				tokFile.MergeLine(previousLine) // has side effects!
-				previousLine--
-			} else {
-				// try to gather some data to diagnose how this could happen
-				req := "Please report what the imports section of your go file looked like."
-				log.Printf("panic avoided: first:%d line:%d previous:%d max:%d. %s",
-					firstSpecLine, line, previousLine, tokFile.LineCount(), req)
-			}
-		}
-	}
-	return specs
-}
-
-type byImportSpec struct {
-	localPrefix string
-	specs       []ast.Spec // slice of *ast.ImportSpec
-}
-
-func (x byImportSpec) Len() int      { return len(x.specs) }
-func (x byImportSpec) Swap(i, j int) { x.specs[i], x.specs[j] = x.specs[j], x.specs[i] }
-func (x byImportSpec) Less(i, j int) bool {
-	ipath := importPath(x.specs[i])
-	jpath := importPath(x.specs[j])
-
-	igroup := importGroup(x.localPrefix, ipath)
-	jgroup := importGroup(x.localPrefix, jpath)
-	if igroup != jgroup {
-		return igroup < jgroup
-	}
-
-	if ipath != jpath {
-		return ipath < jpath
-	}
-	iname := importName(x.specs[i])
-	jname := importName(x.specs[j])
-
-	if iname != jname {
-		return iname < jname
-	}
-	return importComment(x.specs[i]) < importComment(x.specs[j])
-}
-
-type byCommentPos []*ast.CommentGroup
-
-func (x byCommentPos) Len() int           { return len(x) }
-func (x byCommentPos) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
-func (x byCommentPos) Less(i, j int) bool { return x[i].Pos() < x[j].Pos() }
diff --git a/vendor/golang.org/x/tools/internal/imports/source.go b/vendor/golang.org/x/tools/internal/imports/source.go
deleted file mode 100644
index cbe4f3c5b..000000000
--- a/vendor/golang.org/x/tools/internal/imports/source.go
+++ /dev/null
@@ -1,63 +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 imports
-
-import "context"
-
-// These types document the APIs below.
-//
-// TODO(rfindley): consider making these defined types rather than aliases.
-type (
-	ImportPath  = string
-	PackageName = string
-	Symbol      = string
-
-	// References is set of References found in a Go file. The first map key is the
-	// left hand side of a selector expression, the second key is the right hand
-	// side, and the value should always be true.
-	References = map[PackageName]map[Symbol]bool
-)
-
-// A Result satisfies a missing import.
-//
-// The Import field describes the missing import spec, and the Package field
-// summarizes the package exports.
-type Result struct {
-	Import  *ImportInfo
-	Package *PackageInfo
-}
-
-// An ImportInfo represents a single import statement.
-type ImportInfo struct {
-	ImportPath string // import path, e.g. "crypto/rand".
-	Name       string // import name, e.g. "crand", or "" if none.
-}
-
-// A PackageInfo represents what's known about a package.
-type PackageInfo struct {
-	Name    string          // package name in the package declaration, if known
-	Exports map[string]bool // set of names of known package level sortSymbols
-}
-
-// A Source provides imports to satisfy unresolved references in the file being
-// fixed.
-type Source interface {
-	// LoadPackageNames queries PackageName information for the requested import
-	// paths, when operating from the provided srcDir.
-	//
-	// TODO(rfindley): try to refactor to remove this operation.
-	LoadPackageNames(ctx context.Context, srcDir string, paths []ImportPath) (map[ImportPath]PackageName, error)
-
-	// ResolveReferences asks the Source for the best package name to satisfy
-	// each of the missing references, in the context of fixing the given
-	// filename.
-	//
-	// Returns a map from package name to a [Result] for that package name that
-	// provides the required symbols. Keys may be omitted in the map if no
-	// candidates satisfy all missing references for that package name. It is up
-	// to each data source to select the best result for each entry in the
-	// missing map.
-	ResolveReferences(ctx context.Context, filename string, missing References) ([]*Result, error)
-}
diff --git a/vendor/golang.org/x/tools/internal/imports/source_env.go b/vendor/golang.org/x/tools/internal/imports/source_env.go
deleted file mode 100644
index ec996c3cc..000000000
--- a/vendor/golang.org/x/tools/internal/imports/source_env.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 imports
-
-import (
-	"context"
-	"path/filepath"
-	"strings"
-	"sync"
-
-	"golang.org/x/sync/errgroup"
-	"golang.org/x/tools/internal/gopathwalk"
-)
-
-// ProcessEnvSource implements the [Source] interface using the legacy
-// [ProcessEnv] abstraction.
-type ProcessEnvSource struct {
-	env      *ProcessEnv
-	srcDir   string
-	filename string
-	pkgName  string
-}
-
-// NewProcessEnvSource returns a [ProcessEnvSource] wrapping the given
-// env, to be used for fixing imports in the file with name filename in package
-// named pkgName.
-func NewProcessEnvSource(env *ProcessEnv, filename, pkgName string) (*ProcessEnvSource, error) {
-	abs, err := filepath.Abs(filename)
-	if err != nil {
-		return nil, err
-	}
-	srcDir := filepath.Dir(abs)
-	return &ProcessEnvSource{
-		env:      env,
-		srcDir:   srcDir,
-		filename: filename,
-		pkgName:  pkgName,
-	}, nil
-}
-
-func (s *ProcessEnvSource) LoadPackageNames(ctx context.Context, srcDir string, unknown []string) (map[string]string, error) {
-	r, err := s.env.GetResolver()
-	if err != nil {
-		return nil, err
-	}
-	return r.loadPackageNames(unknown, srcDir)
-}
-
-func (s *ProcessEnvSource) ResolveReferences(ctx context.Context, filename string, refs map[string]map[string]bool) ([]*Result, error) {
-	var mu sync.Mutex
-	found := make(map[string][]pkgDistance)
-	callback := &scanCallback{
-		rootFound: func(gopathwalk.Root) bool {
-			return true // We want everything.
-		},
-		dirFound: func(pkg *pkg) bool {
-			return pkgIsCandidate(filename, refs, pkg)
-		},
-		packageNameLoaded: func(pkg *pkg) bool {
-			if _, want := refs[pkg.packageName]; !want {
-				return false
-			}
-			if pkg.dir == s.srcDir && s.pkgName == pkg.packageName {
-				// The candidate is in the same directory and has the
-				// same package name. Don't try to import ourselves.
-				return false
-			}
-			if !CanUse(filename, pkg.dir) {
-				return false
-			}
-			mu.Lock()
-			defer mu.Unlock()
-			found[pkg.packageName] = append(found[pkg.packageName], pkgDistance{pkg, distance(s.srcDir, pkg.dir)})
-			return false // We'll do our own loading after we sort.
-		},
-	}
-	resolver, err := s.env.GetResolver()
-	if err != nil {
-		return nil, err
-	}
-	if err := resolver.scan(ctx, callback); err != nil {
-		return nil, err
-	}
-
-	g, ctx := errgroup.WithContext(ctx)
-
-	searcher := symbolSearcher{
-		logf:        s.env.logf,
-		srcDir:      s.srcDir,
-		xtest:       strings.HasSuffix(s.pkgName, "_test"),
-		loadExports: resolver.loadExports,
-	}
-
-	var resultMu sync.Mutex
-	results := make(map[string]*Result, len(refs))
-	for pkgName, symbols := range refs {
-		g.Go(func() error {
-			found, err := searcher.search(ctx, found[pkgName], pkgName, symbols)
-			if err != nil {
-				return err
-			}
-			if found == nil {
-				return nil // No matching package.
-			}
-
-			imp := &ImportInfo{
-				ImportPath: found.importPathShort,
-			}
-			pkg := &PackageInfo{
-				Name:    pkgName,
-				Exports: symbols,
-			}
-			resultMu.Lock()
-			results[pkgName] = &Result{Import: imp, Package: pkg}
-			resultMu.Unlock()
-			return nil
-		})
-	}
-	if err := g.Wait(); err != nil {
-		return nil, err
-	}
-	var ans []*Result
-	for _, x := range results {
-		ans = append(ans, x)
-	}
-	return ans, nil
-}
diff --git a/vendor/golang.org/x/tools/internal/imports/source_modindex.go b/vendor/golang.org/x/tools/internal/imports/source_modindex.go
deleted file mode 100644
index ca745d4a1..000000000
--- a/vendor/golang.org/x/tools/internal/imports/source_modindex.go
+++ /dev/null
@@ -1,100 +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 imports
-
-import (
-	"context"
-	"sync"
-	"time"
-
-	"golang.org/x/tools/internal/modindex"
-)
-
-// This code is here rather than in the modindex package
-// to avoid import loops
-
-// TODO(adonovan): this code is only used by a test in this package.
-// Can we delete it? Or is there a plan to call NewIndexSource from
-// cmd/goimports?
-
-// implements Source using modindex, so only for module cache.
-//
-// this is perhaps over-engineered. A new Index is read at first use.
-// And then Update is called after every 15 minutes, and a new Index
-// is read if the index changed. It is not clear the Mutex is needed.
-type IndexSource struct {
-	modcachedir string
-	mu          sync.Mutex
-	index       *modindex.Index // (access via getIndex)
-	expires     time.Time
-}
-
-// create a new Source. Called from NewView in cache/session.go.
-func NewIndexSource(cachedir string) *IndexSource {
-	return &IndexSource{modcachedir: cachedir}
-}
-
-func (s *IndexSource) LoadPackageNames(ctx context.Context, srcDir string, paths []ImportPath) (map[ImportPath]PackageName, error) {
-	/// This is used by goimports to resolve the package names of imports of the
-	// current package, which is irrelevant for the module cache.
-	return nil, nil
-}
-
-func (s *IndexSource) ResolveReferences(ctx context.Context, filename string, missing References) ([]*Result, error) {
-	index, err := s.getIndex()
-	if err != nil {
-		return nil, err
-	}
-	var cs []modindex.Candidate
-	for pkg, nms := range missing {
-		for nm := range nms {
-			x := index.Lookup(pkg, nm, false)
-			cs = append(cs, x...)
-		}
-	}
-	found := make(map[string]*Result)
-	for _, c := range cs {
-		var x *Result
-		if x = found[c.ImportPath]; x == nil {
-			x = &Result{
-				Import: &ImportInfo{
-					ImportPath: c.ImportPath,
-					Name:       "",
-				},
-				Package: &PackageInfo{
-					Name:    c.PkgName,
-					Exports: make(map[string]bool),
-				},
-			}
-			found[c.ImportPath] = x
-		}
-		x.Package.Exports[c.Name] = true
-	}
-	var ans []*Result
-	for _, x := range found {
-		ans = append(ans, x)
-	}
-	return ans, nil
-}
-
-func (s *IndexSource) getIndex() (*modindex.Index, error) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	// (s.index = nil => s.expires is zero,
-	// so the first condition is strictly redundant.
-	// But it makes the postcondition very clear.)
-	if s.index == nil || time.Now().After(s.expires) {
-		index, err := modindex.Update(s.modcachedir)
-		if err != nil {
-			return nil, err
-		}
-		s.index = index
-		s.expires = index.ValidAt.Add(15 * time.Minute) // (refresh period)
-	}
-	// Inv: s.index != nil
-
-	return s.index, nil
-}
diff --git a/vendor/golang.org/x/tools/internal/modindex/directories.go b/vendor/golang.org/x/tools/internal/modindex/directories.go
deleted file mode 100644
index 9a963744b..000000000
--- a/vendor/golang.org/x/tools/internal/modindex/directories.go
+++ /dev/null
@@ -1,131 +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 modindex
-
-import (
-	"fmt"
-	"log"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-	"sync"
-	"time"
-
-	"golang.org/x/mod/semver"
-	"golang.org/x/tools/internal/gopathwalk"
-)
-
-type directory struct {
-	path       string // relative to GOMODCACHE
-	importPath string
-	version    string // semantic version
-}
-
-// bestDirByImportPath returns the best directory for each import
-// path, where "best" means most recent semantic version. These import
-// paths are inferred from the GOMODCACHE-relative dir names in dirs.
-func bestDirByImportPath(dirs []string) (map[string]directory, error) {
-	dirsByPath := make(map[string]directory)
-	for _, dir := range dirs {
-		importPath, version, err := dirToImportPathVersion(dir)
-		if err != nil {
-			return nil, err
-		}
-		new := directory{
-			path:       dir,
-			importPath: importPath,
-			version:    version,
-		}
-		if old, ok := dirsByPath[importPath]; !ok || compareDirectory(new, old) < 0 {
-			dirsByPath[importPath] = new
-		}
-	}
-	return dirsByPath, nil
-}
-
-// compareDirectory defines an ordering of path@version directories,
-// by descending version, then by ascending path.
-func compareDirectory(x, y directory) int {
-	if sign := -semver.Compare(x.version, y.version); sign != 0 {
-		return sign // latest first
-	}
-	return strings.Compare(string(x.path), string(y.path))
-}
-
-// modCacheRegexp splits a relpathpath into module, module version, and package.
-var modCacheRegexp = regexp.MustCompile(`(.*)@([^/\\]*)(.*)`)
-
-// dirToImportPathVersion computes import path and semantic version
-// from a GOMODCACHE-relative directory name.
-func dirToImportPathVersion(dir string) (string, string, error) {
-	m := modCacheRegexp.FindStringSubmatch(string(dir))
-	// m[1] is the module path
-	// m[2] is the version major.minor.patch(-<pre release identifier)
-	// m[3] is the rest of the package path
-	if len(m) != 4 {
-		return "", "", fmt.Errorf("bad dir %s", dir)
-	}
-	if !semver.IsValid(m[2]) {
-		return "", "", fmt.Errorf("bad semantic version %s", m[2])
-	}
-	// ToSlash is required to convert Windows file paths
-	// into Go package import paths.
-	return filepath.ToSlash(m[1] + m[3]), m[2], nil
-}
-
-// findDirs returns an unordered list of relevant package directories,
-// relative to the specified module cache root. The result includes only
-// module dirs whose mtime is within (start, end).
-func findDirs(root string, start, end time.Time) []string {
-	var (
-		resMu sync.Mutex
-		res   []string
-	)
-
-	addDir := func(root gopathwalk.Root, dir string) {
-		// TODO(pjw): do we need to check times?
-		resMu.Lock()
-		defer resMu.Unlock()
-		res = append(res, relative(root.Path, dir))
-	}
-
-	skipDir := func(_ gopathwalk.Root, dir string) bool {
-		// The cache directory is already ignored in gopathwalk.
-		if filepath.Base(dir) == "internal" {
-			return true
-		}
-
-		// Skip toolchains.
-		if strings.Contains(dir, "toolchain@") {
-			return true
-		}
-
-		// Don't look inside @ directories that are too old/new.
-		if strings.Contains(filepath.Base(dir), "@") {
-			st, err := os.Stat(dir)
-			if err != nil {
-				log.Printf("can't stat dir %s %v", dir, err)
-				return true
-			}
-			mtime := st.ModTime()
-			return mtime.Before(start) || mtime.After(end)
-		}
-
-		return false
-	}
-
-	// TODO(adonovan): parallelize this. Even with a hot buffer cache,
-	//   find $(go env GOMODCACHE) -type d
-	// can easily take up a minute.
-	roots := []gopathwalk.Root{{Path: root, Type: gopathwalk.RootModuleCache}}
-	gopathwalk.WalkSkip(roots, addDir, skipDir, gopathwalk.Options{
-		ModulesEnabled: true,
-		Concurrency:    1, // TODO(pjw): adjust concurrency
-		// Logf: log.Printf,
-	})
-
-	return res
-}
diff --git a/vendor/golang.org/x/tools/internal/modindex/index.go b/vendor/golang.org/x/tools/internal/modindex/index.go
deleted file mode 100644
index c41d1dd90..000000000
--- a/vendor/golang.org/x/tools/internal/modindex/index.go
+++ /dev/null
@@ -1,287 +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 modindex
-
-import (
-	"bufio"
-	"crypto/sha256"
-	"encoding/csv"
-	"fmt"
-	"io"
-	"log"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"testing"
-	"time"
-)
-
-/*
-The on-disk index ("payload") is a text file.
-The first 3 lines are header information containing CurrentVersion,
-the value of GOMODCACHE, and the validity date of the index.
-(This is when the code started building the index.)
-Following the header are sections of lines, one section for each
-import path. These sections are sorted by package name.
-The first line of each section, marked by a leading :, contains
-the package name, the import path, the name of the directory relative
-to GOMODCACHE, and its semantic version.
-The rest of each section consists of one line per exported symbol.
-The lines are sorted by the symbol's name and contain the name,
-an indication of its lexical type (C, T, V, F), and if it is the
-name of a function, information about the signature.
-
-The fields in the section header lines are separated by commas, and
-in the unlikely event this would be confusing, the csv package is used
-to write (and read) them.
-
-In the lines containing exported names, C=const, V=var, T=type, F=func.
-If it is a func, the next field is the number of returned values,
-followed by pairs consisting of formal parameter names and types.
-All these fields are separated by spaces. Any spaces in a type
-(e.g., chan struct{}) are replaced by $s on the disk. The $s are
-turned back into spaces when read.
-
-Here is an index header (the comments are not part of the index):
-0                                      // version (of the index format)
-/usr/local/google/home/pjw/go/pkg/mod  // GOMODCACHE
-2024-09-11 18:55:09                    // validity date of the index
-
-Here is an index section:
-:yaml,gopkg.in/yaml.v1,gopkg.in/yaml.v1@v1.0.0-20140924161607-9f9df34309c0,v1.0.0-20140924161607-9f9df34309c0
-Getter T
-Marshal F 2 in interface{}
-Setter T
-Unmarshal F 1 in []byte out interface{}
-
-The package name is yaml, the import path is gopkg.in/yaml.v1.
-Getter and Setter are types, and Marshal and Unmarshal are functions.
-The latter returns one value and has two arguments, 'in' and 'out'
-whose types are []byte and interface{}.
-*/
-
-// CurrentVersion tells readers about the format of the index.
-const CurrentVersion int = 0
-
-// Index is returned by [Read].
-type Index struct {
-	Version    int
-	GOMODCACHE string    // absolute path of Go module cache dir
-	ValidAt    time.Time // moment at which the index was up to date
-	Entries    []Entry
-}
-
-func (ix *Index) String() string {
-	return fmt.Sprintf("Index(%s v%d has %d entries at %v)",
-		ix.GOMODCACHE, ix.Version, len(ix.Entries), ix.ValidAt)
-}
-
-// An Entry contains information for an import path.
-type Entry struct {
-	Dir        string // package directory relative to GOMODCACHE; uses OS path separator
-	ImportPath string
-	PkgName    string
-	Version    string
-	Names      []string // exported names and information
-}
-
-// IndexDir is where the module index is stored.
-// Each logical index entry consists of a pair of files:
-//
-//   - the "payload" (index-VERSION-XXX), whose name is
-//     randomized, holds the actual index; and
-//   - the "link" (index-name-VERSION-HASH),
-//     whose name is predictable, contains the
-//     name of the payload file.
-//
-// Since the link file is small (<512B),
-// reads and writes to it may be assumed atomic.
-var IndexDir string = func() string {
-	var dir string
-	if testing.Testing() {
-		dir = os.TempDir()
-	} else {
-		var err error
-		dir, err = os.UserCacheDir()
-		// shouldn't happen, but TempDir is better than
-		// creating ./go/imports
-		if err != nil {
-			dir = os.TempDir()
-		}
-	}
-	dir = filepath.Join(dir, "goimports")
-	if err := os.MkdirAll(dir, 0777); err != nil {
-		log.Printf("failed to create modcache index dir: %v", err)
-	}
-	return dir
-}()
-
-// Read reads the latest version of the on-disk index
-// for the specified Go module cache directory.
-// If there is no index, it returns a nil Index and an fs.ErrNotExist error.
-func Read(gomodcache string) (*Index, error) {
-	gomodcache, err := filepath.Abs(gomodcache)
-	if err != nil {
-		return nil, err
-	}
-
-	// Read the "link" file for the specified gomodcache directory.
-	// It names the payload file.
-	content, err := os.ReadFile(filepath.Join(IndexDir, linkFileBasename(gomodcache)))
-	if err != nil {
-		return nil, err
-	}
-	payloadFile := filepath.Join(IndexDir, string(content))
-
-	// Read the index out of the payload file.
-	f, err := os.Open(payloadFile)
-	if err != nil {
-		return nil, err
-	}
-	defer f.Close()
-	return readIndexFrom(gomodcache, bufio.NewReader(f))
-}
-
-func readIndexFrom(gomodcache string, r io.Reader) (*Index, error) {
-	scan := bufio.NewScanner(r)
-
-	// version
-	if !scan.Scan() {
-		return nil, fmt.Errorf("unexpected scan error: %v", scan.Err())
-	}
-	version, err := strconv.Atoi(scan.Text())
-	if err != nil {
-		return nil, err
-	}
-	if version != CurrentVersion {
-		return nil, fmt.Errorf("got version %d, expected %d", version, CurrentVersion)
-	}
-
-	// gomodcache
-	if !scan.Scan() {
-		return nil, fmt.Errorf("scanner error reading module cache dir: %v", scan.Err())
-	}
-	// TODO(pjw): need to check that this is the expected cache dir
-	// so the tag should be passed in to this function
-	if dir := string(scan.Text()); dir != gomodcache {
-		return nil, fmt.Errorf("index file GOMODCACHE mismatch: got %q, want %q", dir, gomodcache)
-	}
-
-	// changed
-	if !scan.Scan() {
-		return nil, fmt.Errorf("scanner error reading index creation time: %v", scan.Err())
-	}
-	changed, err := time.ParseInLocation(time.DateTime, scan.Text(), time.Local)
-	if err != nil {
-		return nil, err
-	}
-
-	// entries
-	var (
-		curEntry *Entry
-		entries  []Entry
-	)
-	for scan.Scan() {
-		v := scan.Text()
-		if v[0] == ':' {
-			if curEntry != nil {
-				entries = append(entries, *curEntry)
-			}
-			// as directories may contain commas and quotes, they need to be read as csv.
-			rdr := strings.NewReader(v[1:])
-			cs := csv.NewReader(rdr)
-			flds, err := cs.Read()
-			if err != nil {
-				return nil, err
-			}
-			if len(flds) != 4 {
-				return nil, fmt.Errorf("header contains %d fields, not 4: %q", len(v), v)
-			}
-			curEntry = &Entry{
-				PkgName:    flds[0],
-				ImportPath: flds[1],
-				Dir:        relative(gomodcache, flds[2]),
-				Version:    flds[3],
-			}
-			continue
-		}
-		curEntry.Names = append(curEntry.Names, v)
-	}
-	if err := scan.Err(); err != nil {
-		return nil, fmt.Errorf("scanner failed while reading modindex entry: %v", err)
-	}
-	if curEntry != nil {
-		entries = append(entries, *curEntry)
-	}
-
-	return &Index{
-		Version:    version,
-		GOMODCACHE: gomodcache,
-		ValidAt:    changed,
-		Entries:    entries,
-	}, nil
-}
-
-// write writes the index file and updates the index directory to refer to it.
-func write(gomodcache string, ix *Index) error {
-	// Write the index into a payload file with a fresh name.
-	f, err := os.CreateTemp(IndexDir, fmt.Sprintf("index-%d-*", CurrentVersion))
-	if err != nil {
-		return err // e.g. disk full, or index dir deleted
-	}
-	if err := writeIndexToFile(ix, bufio.NewWriter(f)); err != nil {
-		_ = f.Close() // ignore error
-		return err
-	}
-	if err := f.Close(); err != nil {
-		return err
-	}
-
-	// Write the name of the payload file into a link file.
-	indexDirFile := filepath.Join(IndexDir, linkFileBasename(gomodcache))
-	content := []byte(filepath.Base(f.Name()))
-	return os.WriteFile(indexDirFile, content, 0666)
-}
-
-func writeIndexToFile(x *Index, w *bufio.Writer) error {
-	fmt.Fprintf(w, "%d\n", x.Version)
-	fmt.Fprintf(w, "%s\n", x.GOMODCACHE)
-	tm := x.ValidAt.Truncate(time.Second) // round the time down
-	fmt.Fprintf(w, "%s\n", tm.Format(time.DateTime))
-	for _, e := range x.Entries {
-		if e.ImportPath == "" {
-			continue // shouldn't happen
-		}
-		// PJW: maybe always write these headers as csv?
-		if strings.ContainsAny(string(e.Dir), ",\"") {
-			cw := csv.NewWriter(w)
-			cw.Write([]string{":" + e.PkgName, e.ImportPath, string(e.Dir), e.Version})
-			cw.Flush()
-		} else {
-			fmt.Fprintf(w, ":%s,%s,%s,%s\n", e.PkgName, e.ImportPath, e.Dir, e.Version)
-		}
-		for _, x := range e.Names {
-			fmt.Fprintf(w, "%s\n", x)
-		}
-	}
-	return w.Flush()
-}
-
-// linkFileBasename returns the base name of the link file in the
-// index directory that holds the name of the payload file for the
-// specified (absolute) Go module cache dir.
-func linkFileBasename(gomodcache string) string {
-	// Note: coupled to logic in ./gomodindex/cmd.go. TODO: factor.
-	h := sha256.Sum256([]byte(gomodcache)) // collision-resistant hash
-	return fmt.Sprintf("index-name-%d-%032x", CurrentVersion, h)
-}
-
-func relative(base, file string) string {
-	if rel, err := filepath.Rel(base, file); err == nil {
-		return rel
-	}
-	return file
-}
diff --git a/vendor/golang.org/x/tools/internal/modindex/lookup.go b/vendor/golang.org/x/tools/internal/modindex/lookup.go
deleted file mode 100644
index 0c011a99b..000000000
--- a/vendor/golang.org/x/tools/internal/modindex/lookup.go
+++ /dev/null
@@ -1,178 +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 modindex
-
-import (
-	"slices"
-	"strconv"
-	"strings"
-)
-
-type Candidate struct {
-	PkgName    string
-	Name       string
-	Dir        string
-	ImportPath string
-	Type       LexType
-	Deprecated bool
-	// information for Funcs
-	Results int16   // how many results
-	Sig     []Field // arg names and types
-}
-
-type Field struct {
-	Arg, Type string
-}
-
-type LexType int8
-
-const (
-	Const LexType = iota
-	Var
-	Type
-	Func
-)
-
-// LookupAll only returns those Candidates whose import path
-// finds all the names.
-func (ix *Index) LookupAll(pkgName string, names ...string) map[string][]Candidate {
-	// this can be made faster when benchmarks show that it needs to be
-	names = uniquify(names)
-	byImpPath := make(map[string][]Candidate)
-	for _, nm := range names {
-		cands := ix.Lookup(pkgName, nm, false)
-		for _, c := range cands {
-			byImpPath[c.ImportPath] = append(byImpPath[c.ImportPath], c)
-		}
-	}
-	for k, v := range byImpPath {
-		if len(v) != len(names) {
-			delete(byImpPath, k)
-		}
-	}
-	return byImpPath
-}
-
-// remove duplicates
-func uniquify(in []string) []string {
-	if len(in) == 0 {
-		return in
-	}
-	in = slices.Clone(in)
-	slices.Sort(in)
-	return slices.Compact(in)
-}
-
-// Lookup finds all the symbols in the index with the given PkgName and name.
-// If prefix is true, it finds all of these with name as a prefix.
-func (ix *Index) Lookup(pkgName, name string, prefix bool) []Candidate {
-	loc, ok := slices.BinarySearchFunc(ix.Entries, pkgName, func(e Entry, pkg string) int {
-		return strings.Compare(e.PkgName, pkgName)
-	})
-	if !ok {
-		return nil // didn't find the package
-	}
-	var ans []Candidate
-	// loc is the first entry for this package name, but there may be several
-	for i := loc; i < len(ix.Entries); i++ {
-		e := ix.Entries[i]
-		if e.PkgName != pkgName {
-			break // end of sorted package names
-		}
-		nloc, ok := slices.BinarySearchFunc(e.Names, name, func(s string, name string) int {
-			if strings.HasPrefix(s, name) {
-				return 0
-			}
-			if s < name {
-				return -1
-			}
-			return 1
-		})
-		if !ok {
-			continue // didn't find the name, nor any symbols with name as a prefix
-		}
-		for j := nloc; j < len(e.Names); j++ {
-			nstr := e.Names[j]
-			// benchmarks show this makes a difference when there are a lot of Possibilities
-			flds := fastSplit(nstr)
-			if !(flds[0] == name || prefix && strings.HasPrefix(flds[0], name)) {
-				// past range of matching Names
-				break
-			}
-			if len(flds) < 2 {
-				continue // should never happen
-			}
-			px := Candidate{
-				PkgName:    pkgName,
-				Name:       flds[0],
-				Dir:        string(e.Dir),
-				ImportPath: e.ImportPath,
-				Type:       asLexType(flds[1][0]),
-				Deprecated: len(flds[1]) > 1 && flds[1][1] == 'D',
-			}
-			if px.Type == Func {
-				n, err := strconv.Atoi(flds[2])
-				if err != nil {
-					continue // should never happen
-				}
-				px.Results = int16(n)
-				if len(flds) >= 4 {
-					sig := strings.Split(flds[3], " ")
-					for i := range sig {
-						// $ cannot otherwise occur. removing the spaces
-						// almost works, but for chan struct{}, e.g.
-						sig[i] = strings.Replace(sig[i], "$", " ", -1)
-					}
-					px.Sig = toFields(sig)
-				}
-			}
-			ans = append(ans, px)
-		}
-	}
-	return ans
-}
-
-func toFields(sig []string) []Field {
-	ans := make([]Field, len(sig)/2)
-	for i := range ans {
-		ans[i] = Field{Arg: sig[2*i], Type: sig[2*i+1]}
-	}
-	return ans
-}
-
-// benchmarks show this is measurably better than strings.Split
-// split into first 4 fields separated by single space
-func fastSplit(x string) []string {
-	ans := make([]string, 0, 4)
-	nxt := 0
-	start := 0
-	for i := 0; i < len(x); i++ {
-		if x[i] != ' ' {
-			continue
-		}
-		ans = append(ans, x[start:i])
-		nxt++
-		start = i + 1
-		if nxt >= 3 {
-			break
-		}
-	}
-	ans = append(ans, x[start:])
-	return ans
-}
-
-func asLexType(c byte) LexType {
-	switch c {
-	case 'C':
-		return Const
-	case 'V':
-		return Var
-	case 'T':
-		return Type
-	case 'F':
-		return Func
-	}
-	return -1
-}
diff --git a/vendor/golang.org/x/tools/internal/modindex/modindex.go b/vendor/golang.org/x/tools/internal/modindex/modindex.go
deleted file mode 100644
index 5fa285d98..000000000
--- a/vendor/golang.org/x/tools/internal/modindex/modindex.go
+++ /dev/null
@@ -1,119 +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 modindex contains code for building and searching an
-// [Index] of the Go module cache.
-package modindex
-
-// The directory containing the index, returned by
-// [IndexDir], contains a file index-name-<ver> that contains the name
-// of the current index. We believe writing that short file is atomic.
-// [Read] reads that file to get the file name of the index.
-// WriteIndex writes an index with a unique name and then
-// writes that name into a new version of index-name-<ver>.
-// (<ver> stands for the CurrentVersion of the index format.)
-
-import (
-	"maps"
-	"os"
-	"path/filepath"
-	"slices"
-	"strings"
-	"time"
-
-	"golang.org/x/mod/semver"
-)
-
-// Update updates the index for the specified Go
-// module cache directory, creating it as needed.
-// On success it returns the current index.
-func Update(gomodcache string) (*Index, error) {
-	prev, err := Read(gomodcache)
-	if err != nil {
-		if !os.IsNotExist(err) {
-			return nil, err
-		}
-		prev = nil
-	}
-	return update(gomodcache, prev)
-}
-
-// update builds, writes, and returns the current index.
-//
-// If old is nil, the new index is built from all of GOMODCACHE;
-// otherwise it is built from the old index plus cache updates
-// since the previous index's time.
-func update(gomodcache string, old *Index) (*Index, error) {
-	gomodcache, err := filepath.Abs(gomodcache)
-	if err != nil {
-		return nil, err
-	}
-	new, changed, err := build(gomodcache, old)
-	if err != nil {
-		return nil, err
-	}
-	if old == nil || changed {
-		if err := write(gomodcache, new); err != nil {
-			return nil, err
-		}
-	}
-	return new, nil
-}
-
-// build returns a new index for the specified Go module cache (an
-// absolute path).
-//
-// If an old index is provided, only directories more recent than it
-// that it are scanned; older directories are provided by the old
-// Index.
-//
-// The boolean result indicates whether new entries were found.
-func build(gomodcache string, old *Index) (*Index, bool, error) {
-	// Set the time window.
-	var start time.Time // = dawn of time
-	if old != nil {
-		start = old.ValidAt
-	}
-	now := time.Now()
-	end := now.Add(24 * time.Hour) // safely in the future
-
-	// Enumerate GOMODCACHE package directories.
-	// Choose the best (latest) package for each import path.
-	pkgDirs := findDirs(gomodcache, start, end)
-	dirByPath, err := bestDirByImportPath(pkgDirs)
-	if err != nil {
-		return nil, false, err
-	}
-
-	// For each import path it might occur only in
-	// dirByPath, only in old, or in both.
-	// If both, use the semantically later one.
-	var entries []Entry
-	if old != nil {
-		for _, entry := range old.Entries {
-			dir, ok := dirByPath[entry.ImportPath]
-			if !ok || semver.Compare(dir.version, entry.Version) <= 0 {
-				// New dir is missing or not more recent; use old entry.
-				entries = append(entries, entry)
-				delete(dirByPath, entry.ImportPath)
-			}
-		}
-	}
-
-	// Extract symbol information for all the new directories.
-	newEntries := extractSymbols(gomodcache, maps.Values(dirByPath))
-	entries = append(entries, newEntries...)
-	slices.SortFunc(entries, func(x, y Entry) int {
-		if n := strings.Compare(x.PkgName, y.PkgName); n != 0 {
-			return n
-		}
-		return strings.Compare(x.ImportPath, y.ImportPath)
-	})
-
-	return &Index{
-		GOMODCACHE: gomodcache,
-		ValidAt:    now, // time before the directories were scanned
-		Entries:    entries,
-	}, len(newEntries) > 0, nil
-}
diff --git a/vendor/golang.org/x/tools/internal/modindex/symbols.go b/vendor/golang.org/x/tools/internal/modindex/symbols.go
deleted file mode 100644
index 8e9702d84..000000000
--- a/vendor/golang.org/x/tools/internal/modindex/symbols.go
+++ /dev/null
@@ -1,244 +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 modindex
-
-import (
-	"fmt"
-	"go/ast"
-	"go/parser"
-	"go/token"
-	"go/types"
-	"iter"
-	"os"
-	"path/filepath"
-	"runtime"
-	"slices"
-	"strings"
-	"sync"
-
-	"golang.org/x/sync/errgroup"
-)
-
-// The name of a symbol contains information about the symbol:
-// <name> T for types, TD if the type is deprecated
-// <name> C for consts, CD if the const is deprecated
-// <name> V for vars, VD if the var is deprecated
-// and for funcs: <name> F <num of return values> (<arg-name> <arg-type>)*
-// any spaces in <arg-type> are replaced by $s so that the fields
-// of the name are space separated. F is replaced by FD if the func
-// is deprecated.
-type symbol struct {
-	pkg  string // name of the symbols's package
-	name string // declared name
-	kind string // T, C, V, or F, followed by D if deprecated
-	sig  string // signature information, for F
-}
-
-// extractSymbols returns a (new, unordered) array of Entries, one for
-// each provided package directory, describing its exported symbols.
-func extractSymbols(cwd string, dirs iter.Seq[directory]) []Entry {
-	var (
-		mu      sync.Mutex
-		entries []Entry
-	)
-
-	var g errgroup.Group
-	g.SetLimit(max(2, runtime.GOMAXPROCS(0)/2))
-	for dir := range dirs {
-		g.Go(func() error {
-			thedir := filepath.Join(cwd, string(dir.path))
-			mode := parser.SkipObjectResolution | parser.ParseComments
-
-			// Parse all Go files in dir and extract symbols.
-			dirents, err := os.ReadDir(thedir)
-			if err != nil {
-				return nil // log this someday?
-			}
-			var syms []symbol
-			for _, dirent := range dirents {
-				if !strings.HasSuffix(dirent.Name(), ".go") ||
-					strings.HasSuffix(dirent.Name(), "_test.go") {
-					continue
-				}
-				fname := filepath.Join(thedir, dirent.Name())
-				tr, err := parser.ParseFile(token.NewFileSet(), fname, nil, mode)
-				if err != nil {
-					continue // ignore errors, someday log them?
-				}
-				syms = append(syms, getFileExports(tr)...)
-			}
-
-			// Create an entry for the package.
-			pkg, names := processSyms(syms)
-			if pkg != "" {
-				mu.Lock()
-				defer mu.Unlock()
-				entries = append(entries, Entry{
-					PkgName:    pkg,
-					Dir:        dir.path,
-					ImportPath: dir.importPath,
-					Version:    dir.version,
-					Names:      names,
-				})
-			}
-
-			return nil
-		})
-	}
-	g.Wait() // ignore error
-
-	return entries
-}
-
-func getFileExports(f *ast.File) []symbol {
-	pkg := f.Name.Name
-	if pkg == "main" || pkg == "" {
-		return nil
-	}
-	var ans []symbol
-	// should we look for //go:build ignore?
-	for _, decl := range f.Decls {
-		switch decl := decl.(type) {
-		case *ast.FuncDecl:
-			if decl.Recv != nil {
-				// ignore methods, as we are completing package selections
-				continue
-			}
-			name := decl.Name.Name
-			dtype := decl.Type
-			// not looking at dtype.TypeParams. That is, treating
-			// generic functions just like non-generic ones.
-			sig := dtype.Params
-			kind := "F"
-			if isDeprecated(decl.Doc) {
-				kind += "D"
-			}
-			result := []string{fmt.Sprintf("%d", dtype.Results.NumFields())}
-			for _, x := range sig.List {
-				// This code creates a string representing the type.
-				// TODO(pjw): it may be fragile:
-				// 1. x.Type could be nil, perhaps in ill-formed code
-				// 2. ExprString might someday change incompatibly to
-				//    include struct tags, which can be arbitrary strings
-				if x.Type == nil {
-					// Can this happen without a parse error? (Files with parse
-					// errors are ignored in getSymbols)
-					continue // maybe report this someday
-				}
-				tp := types.ExprString(x.Type)
-				if len(tp) == 0 {
-					// Can this happen?
-					continue // maybe report this someday
-				}
-				// This is only safe if ExprString never returns anything with a $
-				// The only place a $ can occur seems to be in a struct tag, which
-				// can be an arbitrary string literal, and ExprString does not presently
-				// print struct tags. So for this to happen the type of a formal parameter
-				// has to be a explicit struct, e.g. foo(x struct{a int "$"}) and ExprString
-				// would have to show the struct tag. Even testing for this case seems
-				// a waste of effort, but let's remember the possibility
-				if strings.Contains(tp, "$") {
-					continue
-				}
-				tp = strings.Replace(tp, " ", "$", -1)
-				if len(x.Names) == 0 {
-					result = append(result, "_")
-					result = append(result, tp)
-				} else {
-					for _, y := range x.Names {
-						result = append(result, y.Name)
-						result = append(result, tp)
-					}
-				}
-			}
-			sigs := strings.Join(result, " ")
-			if s := newsym(pkg, name, kind, sigs); s != nil {
-				ans = append(ans, *s)
-			}
-		case *ast.GenDecl:
-			depr := isDeprecated(decl.Doc)
-			switch decl.Tok {
-			case token.CONST, token.VAR:
-				tp := "V"
-				if decl.Tok == token.CONST {
-					tp = "C"
-				}
-				if depr {
-					tp += "D"
-				}
-				for _, sp := range decl.Specs {
-					for _, x := range sp.(*ast.ValueSpec).Names {
-						if s := newsym(pkg, x.Name, tp, ""); s != nil {
-							ans = append(ans, *s)
-						}
-					}
-				}
-			case token.TYPE:
-				tp := "T"
-				if depr {
-					tp += "D"
-				}
-				for _, sp := range decl.Specs {
-					if s := newsym(pkg, sp.(*ast.TypeSpec).Name.Name, tp, ""); s != nil {
-						ans = append(ans, *s)
-					}
-				}
-			}
-		}
-	}
-	return ans
-}
-
-func newsym(pkg, name, kind, sig string) *symbol {
-	if len(name) == 0 || !ast.IsExported(name) {
-		return nil
-	}
-	sym := symbol{pkg: pkg, name: name, kind: kind, sig: sig}
-	return &sym
-}
-
-func isDeprecated(doc *ast.CommentGroup) bool {
-	if doc == nil {
-		return false
-	}
-	// go.dev/wiki/Deprecated Paragraph starting 'Deprecated:'
-	// This code fails for /* Deprecated: */, but it's the code from
-	// gopls/internal/analysis/deprecated
-	for line := range strings.SplitSeq(doc.Text(), "\n\n") {
-		if strings.HasPrefix(line, "Deprecated:") {
-			return true
-		}
-	}
-	return false
-}
-
-// return the package name and the value for the symbols.
-// if there are multiple packages, choose one arbitrarily
-// the returned slice is sorted lexicographically
-func processSyms(syms []symbol) (string, []string) {
-	if len(syms) == 0 {
-		return "", nil
-	}
-	slices.SortFunc(syms, func(l, r symbol) int {
-		return strings.Compare(l.name, r.name)
-	})
-	pkg := syms[0].pkg
-	var names []string
-	for _, s := range syms {
-		if s.pkg != pkg {
-			// Symbols came from two files in same dir
-			// with different package declarations.
-			continue
-		}
-		var nx string
-		if s.sig != "" {
-			nx = fmt.Sprintf("%s %s %s", s.name, s.kind, s.sig)
-		} else {
-			nx = fmt.Sprintf("%s %s", s.name, s.kind)
-		}
-		names = append(names, nx)
-	}
-	return pkg, names
-}
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 929b470be..000000000
--- 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 f0cabde96..000000000
--- 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 c0aba26c4..000000000
--- 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 c8a2796b5..000000000
--- 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 c17a12399..000000000
--- 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 654222745..000000000
--- 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 fcdfb97ca..000000000
--- 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 50534a295..000000000
--- 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 1520b73af..000000000
--- 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 582ad56d3..000000000
--- 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 53af9df22..000000000
--- a/vendor/golang.org/x/tools/internal/pkgbits/version.go
+++ /dev/null
@@ -1,85 +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
-
-	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
-
-	numFields = iota
-)
-
-// introduced is the version a field was added.
-var introduced = [numFields]Version{
-	Flags:               V1,
-	AliasTypeParamNames: V2,
-}
-
-// 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 96ad6c582..000000000
--- a/vendor/golang.org/x/tools/internal/stdlib/deps.go
+++ /dev/null
@@ -1,365 +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", "\x03k\x03E;\x01\n\x01$\x01\x01\x02\x05\b\x02\x01\x02\x02\f"},
-	{"archive/zip", "\x02\x04a\a\x03\x12\x021;\x01+\x05\x01\x0f\x03\x02\x0e\x04"},
-	{"bufio", "\x03k\x83\x01D\x14"},
-	{"bytes", "n*Y\x03\fG\x02\x02"},
-	{"cmp", ""},
-	{"compress/bzip2", "\x02\x02\xed\x01A"},
-	{"compress/flate", "\x02l\x03\x80\x01\f\x033\x01\x03"},
-	{"compress/gzip", "\x02\x04a\a\x03\x14lT"},
-	{"compress/lzw", "\x02l\x03\x80\x01"},
-	{"compress/zlib", "\x02\x04a\a\x03\x12\x01m"},
-	{"container/heap", "\xb3\x02"},
-	{"container/list", ""},
-	{"container/ring", ""},
-	{"context", "n\\m\x01\r"},
-	{"crypto", "\x83\x01nC"},
-	{"crypto/aes", "\x10\n\a\x93\x02"},
-	{"crypto/cipher", "\x03\x1e\x01\x01\x1e\x11\x1c+X"},
-	{"crypto/des", "\x10\x13\x1e-+\x9b\x01\x03"},
-	{"crypto/dsa", "A\x04)\x83\x01\r"},
-	{"crypto/ecdh", "\x03\v\f\x0e\x04\x15\x04\r\x1c\x83\x01"},
-	{"crypto/ecdsa", "\x0e\x05\x03\x04\x01\x0e\a\v\x05\x01\x04\f\x01\x1c\x83\x01\r\x05K\x01"},
-	{"crypto/ed25519", "\x0e\x1c\x11\x06\n\a\x1c\x83\x01C"},
-	{"crypto/elliptic", "0>\x83\x01\r9"},
-	{"crypto/fips140", " \x05"},
-	{"crypto/hkdf", "-\x13\x01-\x15"},
-	{"crypto/hmac", "\x1a\x14\x12\x01\x111"},
-	{"crypto/internal/boring", "\x0e\x02\rf"},
-	{"crypto/internal/boring/bbig", "\x1a\xe4\x01M"},
-	{"crypto/internal/boring/bcache", "\xb8\x02\x13"},
-	{"crypto/internal/boring/sig", ""},
-	{"crypto/internal/cryptotest", "\x03\r\n\x06$\x0e\x19\x06\x12\x12 \x04\a\t\x16\x01\x11\x11\x1b\x01\a\x05\b\x03\x05\v"},
-	{"crypto/internal/entropy", "F"},
-	{"crypto/internal/fips140", "?/\x15\xa7\x01\v\x16"},
-	{"crypto/internal/fips140/aes", "\x03\x1d\x03\x02\x13\x05\x01\x01\x05*\x92\x014"},
-	{"crypto/internal/fips140/aes/gcm", " \x01\x02\x02\x02\x11\x05\x01\x06*\x8f\x01"},
-	{"crypto/internal/fips140/alias", "\xcb\x02"},
-	{"crypto/internal/fips140/bigmod", "%\x18\x01\x06*\x92\x01"},
-	{"crypto/internal/fips140/check", " \x0e\x06\t\x02\xb2\x01Z"},
-	{"crypto/internal/fips140/check/checktest", "%\x85\x02!"},
-	{"crypto/internal/fips140/drbg", "\x03\x1c\x01\x01\x04\x13\x05\b\x01(\x83\x01\x0f7"},
-	{"crypto/internal/fips140/ecdh", "\x03\x1d\x05\x02\t\r1\x83\x01\x0f7"},
-	{"crypto/internal/fips140/ecdsa", "\x03\x1d\x04\x01\x02\a\x02\x068\x15nF"},
-	{"crypto/internal/fips140/ed25519", "\x03\x1d\x05\x02\x04\v8\xc6\x01\x03"},
-	{"crypto/internal/fips140/edwards25519", "%\a\f\x051\x92\x017"},
-	{"crypto/internal/fips140/edwards25519/field", "%\x13\x051\x92\x01"},
-	{"crypto/internal/fips140/hkdf", "\x03\x1d\x05\t\x06:\x15"},
-	{"crypto/internal/fips140/hmac", "\x03\x1d\x14\x01\x018\x15"},
-	{"crypto/internal/fips140/mlkem", "\x03\x1d\x05\x02\x0e\x03\x051"},
-	{"crypto/internal/fips140/nistec", "%\f\a\x051\x92\x01*\r\x14"},
-	{"crypto/internal/fips140/nistec/fiat", "%\x136\x92\x01"},
-	{"crypto/internal/fips140/pbkdf2", "\x03\x1d\x05\t\x06:\x15"},
-	{"crypto/internal/fips140/rsa", "\x03\x1d\x04\x01\x02\r\x01\x01\x026\x15nF"},
-	{"crypto/internal/fips140/sha256", "\x03\x1d\x1d\x01\x06*\x15}"},
-	{"crypto/internal/fips140/sha3", "\x03\x1d\x18\x05\x010\x92\x01K"},
-	{"crypto/internal/fips140/sha512", "\x03\x1d\x1d\x01\x06*\x15}"},
-	{"crypto/internal/fips140/ssh", "%^"},
-	{"crypto/internal/fips140/subtle", "#\x1a\xc3\x01"},
-	{"crypto/internal/fips140/tls12", "\x03\x1d\x05\t\x06\x028\x15"},
-	{"crypto/internal/fips140/tls13", "\x03\x1d\x05\b\a\t1\x15"},
-	{"crypto/internal/fips140cache", "\xaa\x02\r&"},
-	{"crypto/internal/fips140deps", ""},
-	{"crypto/internal/fips140deps/byteorder", "\x99\x01"},
-	{"crypto/internal/fips140deps/cpu", "\xae\x01\a"},
-	{"crypto/internal/fips140deps/godebug", "\xb6\x01"},
-	{"crypto/internal/fips140hash", "5\x1b3\xc8\x01"},
-	{"crypto/internal/fips140only", "'\r\x01\x01M3;"},
-	{"crypto/internal/fips140test", ""},
-	{"crypto/internal/hpke", "\x0e\x01\x01\x03\x053#+gM"},
-	{"crypto/internal/impl", "\xb5\x02"},
-	{"crypto/internal/randutil", "\xf1\x01\x12"},
-	{"crypto/internal/sysrand", "nn! \r\r\x01\x01\f\x06"},
-	{"crypto/internal/sysrand/internal/seccomp", "n"},
-	{"crypto/md5", "\x0e3-\x15\x16g"},
-	{"crypto/mlkem", "/"},
-	{"crypto/pbkdf2", "2\x0e\x01-\x15"},
-	{"crypto/rand", "\x1a\x06\a\x1a\x04\x01(\x83\x01\rM"},
-	{"crypto/rc4", "#\x1e-\xc6\x01"},
-	{"crypto/rsa", "\x0e\f\x01\t\x0f\r\x01\x04\x06\a\x1c\x03\x123;\f\x01"},
-	{"crypto/sha1", "\x0e\f'\x03*\x15\x16\x15R"},
-	{"crypto/sha256", "\x0e\f\x1aO"},
-	{"crypto/sha3", "\x0e'N\xc8\x01"},
-	{"crypto/sha512", "\x0e\f\x1cM"},
-	{"crypto/subtle", "8\x9b\x01W"},
-	{"crypto/tls", "\x03\b\x02\x01\x01\x01\x01\x02\x01\x01\x01\x02\x01\x01\a\x01\r\n\x01\t\x05\x03\x01\x01\x01\x01\x02\x01\x02\x01\x17\x02\x03\x12\x16\x15\b;\x16\x16\r\b\x01\x01\x01\x02\x01\r\x06\x02\x01\x0f"},
-	{"crypto/tls/internal/fips140tls", "\x17\xa1\x02"},
-	{"crypto/x509", "\x03\v\x01\x01\x01\x01\x01\x01\x01\x012\x05\x01\x01\x02\x05\x0e\x06\x02\x02\x03E\x038\x01\x02\b\x01\x01\x02\a\x10\x05\x01\x06\x02\x05\n\x01\x02\x0e\x02\x01\x01\x02\x03\x01"},
-	{"crypto/x509/pkix", "d\x06\a\x8d\x01G"},
-	{"database/sql", "\x03\nK\x16\x03\x80\x01\v\a\"\x05\b\x02\x03\x01\r\x02\x02\x02"},
-	{"database/sql/driver", "\ra\x03\xb4\x01\x0f\x11"},
-	{"debug/buildinfo", "\x03X\x02\x01\x01\b\a\x03e\x19\x02\x01+\x0f\x1f"},
-	{"debug/dwarf", "\x03d\a\x03\x80\x011\x11\x01\x01"},
-	{"debug/elf", "\x03\x06Q\r\a\x03e\x1a\x01,\x17\x01\x16"},
-	{"debug/gosym", "\x03d\n\xc2\x01\x01\x01\x02"},
-	{"debug/macho", "\x03\x06Q\r\ne\x1b,\x17\x01"},
-	{"debug/pe", "\x03\x06Q\r\a\x03e\x1b,\x17\x01\x16"},
-	{"debug/plan9obj", "g\a\x03e\x1b,"},
-	{"embed", "n*@\x19\x01S"},
-	{"embed/internal/embedtest", ""},
-	{"encoding", ""},
-	{"encoding/ascii85", "\xf1\x01C"},
-	{"encoding/asn1", "\x03k\x03\x8c\x01\x01'\r\x02\x01\x10\x03\x01"},
-	{"encoding/base32", "\xf1\x01A\x02"},
-	{"encoding/base64", "\x99\x01XA\x02"},
-	{"encoding/binary", "n\x83\x01\f(\r\x05"},
-	{"encoding/csv", "\x02\x01k\x03\x80\x01D\x12\x02"},
-	{"encoding/gob", "\x02`\x05\a\x03e\x1b\v\x01\x03\x1d\b\x12\x01\x0f\x02"},
-	{"encoding/hex", "n\x03\x80\x01A\x03"},
-	{"encoding/json", "\x03\x01^\x04\b\x03\x80\x01\f(\r\x02\x01\x02\x10\x01\x01\x02"},
-	{"encoding/pem", "\x03c\b\x83\x01A\x03"},
-	{"encoding/xml", "\x02\x01_\f\x03\x80\x014\x05\n\x01\x02\x10\x02"},
-	{"errors", "\xca\x01\x81\x01"},
-	{"expvar", "kK?\b\v\x15\r\b\x02\x03\x01\x11"},
-	{"flag", "b\f\x03\x80\x01,\b\x05\b\x02\x01\x10"},
-	{"fmt", "nE>\f \b\r\x02\x03\x12"},
-	{"go/ast", "\x03\x01m\x0e\x01q\x03)\b\r\x02\x01"},
-	{"go/build", "\x02\x01k\x03\x01\x02\x02\a\x02\x01\x17\x1f\x04\x02\t\x19\x13\x01+\x01\x04\x01\a\b\x02\x01\x12\x02\x02"},
-	{"go/build/constraint", "n\xc6\x01\x01\x12\x02"},
-	{"go/constant", "q\x0f}\x01\x024\x01\x02\x12"},
-	{"go/doc", "\x04m\x01\x05\t>31\x10\x02\x01\x12\x02"},
-	{"go/doc/comment", "\x03n\xc1\x01\x01\x01\x01\x12\x02"},
-	{"go/format", "\x03n\x01\v\x01\x02qD"},
-	{"go/importer", "s\a\x01\x01\x04\x01p9"},
-	{"go/internal/gccgoimporter", "\x02\x01X\x13\x03\x04\v\x01n\x02,\x01\x05\x11\x01\f\b"},
-	{"go/internal/gcimporter", "\x02o\x0f\x010\x05\x0e-,\x15\x03\x02"},
-	{"go/internal/srcimporter", "q\x01\x01\n\x03\x01p,\x01\x05\x12\x02\x14"},
-	{"go/parser", "\x03k\x03\x01\x02\v\x01q\x01+\x06\x12"},
-	{"go/printer", "q\x01\x02\x03\tq\f \x15\x02\x01\x02\v\x05\x02"},
-	{"go/scanner", "\x03n\x0fq2\x10\x01\x13\x02"},
-	{"go/token", "\x04m\x83\x01>\x02\x03\x01\x0f\x02"},
-	{"go/types", "\x03\x01\x06d\x03\x01\x03\b\x03\x02\x15\x1f\x061\x04\x03\t \x06\a\b\x01\x01\x01\x02\x01\x0f\x02\x02"},
-	{"go/version", "\xbb\x01z"},
-	{"hash", "\xf1\x01"},
-	{"hash/adler32", "n\x15\x16"},
-	{"hash/crc32", "n\x15\x16\x15\x89\x01\x01\x13"},
-	{"hash/crc64", "n\x15\x16\x9e\x01"},
-	{"hash/fnv", "n\x15\x16g"},
-	{"hash/maphash", "\x83\x01\x11!\x03\x93\x01"},
-	{"html", "\xb5\x02\x02\x12"},
-	{"html/template", "\x03h\x06\x18-;\x01\n!\x05\x01\x02\x03\f\x01\x02\f\x01\x03\x02"},
-	{"image", "\x02l\x1ee\x0f4\x03\x01"},
-	{"image/color", ""},
-	{"image/color/palette", "\x8c\x01"},
-	{"image/draw", "\x8b\x01\x01\x04"},
-	{"image/gif", "\x02\x01\x05f\x03\x1a\x01\x01\x01\vX"},
-	{"image/internal/imageutil", "\x8b\x01"},
-	{"image/jpeg", "\x02l\x1d\x01\x04a"},
-	{"image/png", "\x02\a^\n\x12\x02\x06\x01eC"},
-	{"index/suffixarray", "\x03d\a\x83\x01\f+\n\x01"},
-	{"internal/abi", "\xb5\x01\x96\x01"},
-	{"internal/asan", "\xcb\x02"},
-	{"internal/bisect", "\xaa\x02\r\x01"},
-	{"internal/buildcfg", "qGe\x06\x02\x05\n\x01"},
-	{"internal/bytealg", "\xae\x01\x9d\x01"},
-	{"internal/byteorder", ""},
-	{"internal/cfg", ""},
-	{"internal/cgrouptest", "q[Q\x06\x0f\x02\x01\x04\x01"},
-	{"internal/chacha8rand", "\x99\x01\x15\a\x96\x01"},
-	{"internal/copyright", ""},
-	{"internal/coverage", ""},
-	{"internal/coverage/calloc", ""},
-	{"internal/coverage/cfile", "k\x06\x16\x17\x01\x02\x01\x01\x01\x01\x01\x01\x01#\x02$,\x06\a\n\x01\x03\r\x06"},
-	{"internal/coverage/cformat", "\x04m-\x04O\v6\x01\x02\r"},
-	{"internal/coverage/cmerge", "q-_"},
-	{"internal/coverage/decodecounter", "g\n-\v\x02F,\x17\x17"},
-	{"internal/coverage/decodemeta", "\x02e\n\x16\x17\v\x02F,"},
-	{"internal/coverage/encodecounter", "\x02e\n-\f\x01\x02D\v!\x15"},
-	{"internal/coverage/encodemeta", "\x02\x01d\n\x12\x04\x17\r\x02D,."},
-	{"internal/coverage/pods", "\x04m-\x7f\x06\x05\n\x02\x01"},
-	{"internal/coverage/rtcov", "\xcb\x02"},
-	{"internal/coverage/slicereader", "g\n\x80\x01Z"},
-	{"internal/coverage/slicewriter", "q\x80\x01"},
-	{"internal/coverage/stringtab", "q8\x04D"},
-	{"internal/coverage/test", ""},
-	{"internal/coverage/uleb128", ""},
-	{"internal/cpu", "\xcb\x02"},
-	{"internal/dag", "\x04m\xc1\x01\x03"},
-	{"internal/diff", "\x03n\xc2\x01\x02"},
-	{"internal/exportdata", "\x02\x01k\x03\x02c\x1b,\x01\x05\x11\x01\x02"},
-	{"internal/filepathlite", "n*@\x1a@"},
-	{"internal/fmtsort", "\x04\xa1\x02\r"},
-	{"internal/fuzz", "\x03\nB\x18\x04\x03\x03\x01\v\x036;\f\x03\x1d\x01\x05\x02\x05\n\x01\x02\x01\x01\f\x04\x02"},
-	{"internal/goarch", ""},
-	{"internal/godebug", "\x96\x01!\x80\x01\x01\x13"},
-	{"internal/godebugs", ""},
-	{"internal/goexperiment", ""},
-	{"internal/goos", ""},
-	{"internal/goroot", "\x9d\x02\x01\x05\x12\x02"},
-	{"internal/gover", "\x04"},
-	{"internal/goversion", ""},
-	{"internal/itoa", ""},
-	{"internal/lazyregexp", "\x9d\x02\v\r\x02"},
-	{"internal/lazytemplate", "\xf1\x01,\x18\x02\f"},
-	{"internal/msan", "\xcb\x02"},
-	{"internal/nettrace", ""},
-	{"internal/obscuretestdata", "f\x8b\x01,"},
-	{"internal/oserror", "n"},
-	{"internal/pkgbits", "\x03L\x18\a\x03\x04\vq\r\x1f\r\n\x01"},
-	{"internal/platform", ""},
-	{"internal/poll", "nO\x1f\x159\r\x01\x01\f\x06"},
-	{"internal/profile", "\x03\x04g\x03\x80\x017\v\x01\x01\x10"},
-	{"internal/profilerecord", ""},
-	{"internal/race", "\x94\x01\xb7\x01"},
-	{"internal/reflectlite", "\x94\x01!9<!"},
-	{"internal/runtime/atomic", "\xb5\x01\x96\x01"},
-	{"internal/runtime/cgroup", "\x98\x01:\x02w"},
-	{"internal/runtime/exithook", "\xcb\x01\x80\x01"},
-	{"internal/runtime/gc", "\xb5\x01"},
-	{"internal/runtime/maps", "\x94\x01\x01 \v\t\a\x03x"},
-	{"internal/runtime/math", "\xb5\x01"},
-	{"internal/runtime/startlinetest", ""},
-	{"internal/runtime/strconv", "\xd0\x01"},
-	{"internal/runtime/sys", "\xb5\x01\x04"},
-	{"internal/runtime/syscall", "\xb5\x01\x96\x01"},
-	{"internal/runtime/wasitest", ""},
-	{"internal/saferio", "\xf1\x01Z"},
-	{"internal/singleflight", "\xb7\x02"},
-	{"internal/stringslite", "\x98\x01\xb3\x01"},
-	{"internal/sync", "\x94\x01!\x14o\x13"},
-	{"internal/synctest", "\x94\x01\xb7\x01"},
-	{"internal/syscall/execenv", "\xb9\x02"},
-	{"internal/syscall/unix", "\xaa\x02\x0e\x01\x12"},
-	{"internal/sysinfo", "\x02\x01\xab\x01C,\x18\x02"},
-	{"internal/syslist", ""},
-	{"internal/testenv", "\x03\na\x02\x01)\x1b\x10-+\x01\x05\a\n\x01\x02\x02\x01\v"},
-	{"internal/testhash", "\x03\x80\x01n\x118\v"},
-	{"internal/testlog", "\xb7\x02\x01\x13"},
-	{"internal/testpty", "n\x03\xac\x01"},
-	{"internal/trace", "\x02\x01\x01\x06]\a\x03t\x03\x03\x06\x03\t5\x01\x01\x01\x10\x06"},
-	{"internal/trace/internal/testgen", "\x03d\nr\x03\x02\x03\x011\v\r\x10"},
-	{"internal/trace/internal/tracev1", "\x03\x01c\a\x03z\x06\f5\x01"},
-	{"internal/trace/raw", "\x02e\nw\x03\x06C\x01\x12"},
-	{"internal/trace/testtrace", "\x02\x01k\x03r\x03\x05\x01\x057\n\x02\x01"},
-	{"internal/trace/tracev2", ""},
-	{"internal/trace/traceviewer", "\x02^\v\x06\x19=\x1c\a\a\x04\b\v\x15\x01\x05\a\n\x01\x02\x0e"},
-	{"internal/trace/traceviewer/format", ""},
-	{"internal/trace/version", "qw\t"},
-	{"internal/txtar", "\x03n\xac\x01\x18"},
-	{"internal/types/errors", "\xb4\x02"},
-	{"internal/unsafeheader", "\xcb\x02"},
-	{"internal/xcoff", "Z\r\a\x03e\x1b,\x17\x01"},
-	{"internal/zstd", "g\a\x03\x80\x01\x0f"},
-	{"io", "n\xc9\x01"},
-	{"io/fs", "n*+.1\x10\x13\x04"},
-	{"io/ioutil", "\xf1\x01\x01+\x15\x03"},
-	{"iter", "\xc9\x01a!"},
-	{"log", "q\x80\x01\x05'\r\r\x01\r"},
-	{"log/internal", ""},
-	{"log/slog", "\x03\nU\t\x03\x03\x80\x01\x04\x01\x02\x02\x03(\x05\b\x02\x01\x02\x01\r\x02\x02\x02"},
-	{"log/slog/internal", ""},
-	{"log/slog/internal/benchmarks", "\ra\x03\x80\x01\x06\x03:\x11"},
-	{"log/slog/internal/buffer", "\xb7\x02"},
-	{"log/syslog", "n\x03\x84\x01\x12\x16\x18\x02\x0e"},
-	{"maps", "\xf4\x01W"},
-	{"math", "\xae\x01RK"},
-	{"math/big", "\x03k\x03(\x15C\f\x03\x020\x02\x01\x02\x14"},
-	{"math/big/internal/asmgen", "\x03\x01m\x8f\x012\x03"},
-	{"math/bits", "\xcb\x02"},
-	{"math/cmplx", "\xfd\x01\x03"},
-	{"math/rand", "\xb6\x01G:\x01\x13"},
-	{"math/rand/v2", "n+\x03a\x03K"},
-	{"mime", "\x02\x01c\b\x03\x80\x01\v!\x15\x03\x02\x10\x02"},
-	{"mime/multipart", "\x02\x01H#\x03E;\v\x01\a\x02\x15\x02\x06\x0f\x02\x01\x16"},
-	{"mime/quotedprintable", "\x02\x01n\x80\x01"},
-	{"net", "\x04\ta*\x1e\a\x04\x05\x11\x01\x04\x15\x01%\x06\r\b\x05\x01\x01\f\x06\a"},
-	{"net/http", "\x02\x01\x04\x04\x02>\b\x13\x01\a\x03E;\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\r\x02\x02\x02\b\x01\x01\x01"},
-	{"net/http/cgi", "\x02Q\x1b\x03\x80\x01\x04\a\v\x01\x13\x01\x01\x01\x04\x01\x05\x02\b\x02\x01\x10\x0e"},
-	{"net/http/cookiejar", "\x04j\x03\x96\x01\x01\b\f\x16\x03\x02\x0e\x04"},
-	{"net/http/fcgi", "\x02\x01\nZ\a\x03\x80\x01\x16\x01\x01\x14\x18\x02\x0e"},
-	{"net/http/httptest", "\x02\x01\nF\x02\x1b\x01\x80\x01\x04\x12\x01\n\t\x02\x17\x01\x02\x0e\x0e"},
-	{"net/http/httptrace", "\rFnF\x14\n "},
-	{"net/http/httputil", "\x02\x01\na\x03\x80\x01\x04\x0f\x03\x01\x05\x02\x01\v\x01\x19\x02\x0e\x0e"},
-	{"net/http/internal", "\x02\x01k\x03\x80\x01"},
-	{"net/http/internal/ascii", "\xb5\x02\x12"},
-	{"net/http/internal/httpcommon", "\ra\x03\x9c\x01\x0e\x01\x17\x01\x01\x02\x1c\x02"},
-	{"net/http/internal/testcert", "\xb5\x02"},
-	{"net/http/pprof", "\x02\x01\nd\x18-\x11*\x04\x13\x14\x01\r\x04\x03\x01\x02\x01\x10"},
-	{"net/internal/cgotest", ""},
-	{"net/internal/socktest", "q\xc6\x01\x02"},
-	{"net/mail", "\x02l\x03\x80\x01\x04\x0f\x03\x14\x1a\x02\x0e\x04"},
-	{"net/netip", "\x04j*\x01$@\x034\x16"},
-	{"net/rpc", "\x02g\x05\x03\x0f\ng\x04\x12\x01\x1d\r\x03\x02"},
-	{"net/rpc/jsonrpc", "k\x03\x03\x80\x01\x16\x11\x1f"},
-	{"net/smtp", "\x19/\v\x13\b\x03\x80\x01\x16\x14\x1a"},
-	{"net/textproto", "\x02\x01k\x03\x80\x01\f\n-\x01\x02\x14"},
-	{"net/url", "n\x03\x8b\x01&\x10\x02\x01\x16"},
-	{"os", "n*\x01\x19\x03\b\t\x12\x03\x01\x05\x10\x018\b\x05\x01\x01\f\x06"},
-	{"os/exec", "\x03\naH%\x01\x15\x01+\x06\a\n\x01\x04\f"},
-	{"os/exec/internal/fdtest", "\xb9\x02"},
-	{"os/signal", "\r\x90\x02\x15\x05\x02"},
-	{"os/user", "\x02\x01k\x03\x80\x01,\r\n\x01\x02"},
-	{"path", "n*\xb1\x01"},
-	{"path/filepath", "n*\x1a@+\r\b\x03\x04\x10"},
-	{"plugin", "n"},
-	{"reflect", "n&\x04\x1d\b\f\x06\x04\x1b\x06\t-\n\x03\x10\x02\x02"},
-	{"reflect/internal/example1", ""},
-	{"reflect/internal/example2", ""},
-	{"regexp", "\x03\xee\x018\t\x02\x01\x02\x10\x02"},
-	{"regexp/syntax", "\xb2\x02\x01\x01\x01\x02\x10\x02"},
-	{"runtime", "\x94\x01\x04\x01\x03\f\x06\a\x02\x01\x01\x0f\x03\x01\x01\x01\x01\x01\x02\x01\x01\x04\x10c"},
-	{"runtime/coverage", "\xa0\x01Q"},
-	{"runtime/debug", "qUW\r\b\x02\x01\x10\x06"},
-	{"runtime/metrics", "\xb7\x01F-!"},
-	{"runtime/pprof", "\x02\x01\x01\x03\x06Z\a\x03#4)\f \r\b\x01\x01\x01\x02\x02\t\x03\x06"},
-	{"runtime/race", "\xb0\x02"},
-	{"runtime/race/internal/amd64v1", ""},
-	{"runtime/trace", "\ra\x03w\t9\b\x05\x01\r\x06"},
-	{"slices", "\x04\xf0\x01\fK"},
-	{"sort", "\xca\x0162"},
-	{"strconv", "n*@%\x03I"},
-	{"strings", "n&\x04@\x19\x03\f7\x10\x02\x02"},
-	{"structs", ""},
-	{"sync", "\xc9\x01\x10\x01P\x0e\x13"},
-	{"sync/atomic", "\xcb\x02"},
-	{"syscall", "n'\x03\x01\x1c\b\x03\x03\x06\vV\b\x05\x01\x13"},
-	{"testing", "\x03\na\x02\x01X\x14\x14\f\x05\x1b\x06\x02\x05\x02\x05\x01\x02\x01\x02\x01\r\x02\x02\x02"},
-	{"testing/fstest", "n\x03\x80\x01\x01\n&\x10\x03\b\b"},
-	{"testing/internal/testdeps", "\x02\v\xa7\x01-\x10,\x03\x05\x03\x06\a\x02\x0e"},
-	{"testing/iotest", "\x03k\x03\x80\x01\x04"},
-	{"testing/quick", "p\x01\x8c\x01\x05#\x10\x10"},
-	{"testing/slogtest", "\ra\x03\x86\x01.\x05\x10\v"},
-	{"testing/synctest", "\xda\x01`\x11"},
-	{"text/scanner", "\x03n\x80\x01,*\x02"},
-	{"text/tabwriter", "q\x80\x01X"},
-	{"text/template", "n\x03B>\x01\n \x01\x05\x01\x02\x05\v\x02\r\x03\x02"},
-	{"text/template/parse", "\x03n\xb9\x01\n\x01\x12\x02"},
-	{"time", "n*\x1e\"(*\r\x02\x12"},
-	{"time/tzdata", "n\xcb\x01\x12"},
-	{"unicode", ""},
-	{"unicode/utf16", ""},
-	{"unicode/utf8", ""},
-	{"unique", "\x94\x01!#\x01Q\r\x01\x13\x12"},
-	{"unsafe", ""},
-	{"vendor/golang.org/x/crypto/chacha20", "\x10W\a\x92\x01*&"},
-	{"vendor/golang.org/x/crypto/chacha20poly1305", "\x10W\a\xde\x01\x04\x01\a"},
-	{"vendor/golang.org/x/crypto/cryptobyte", "d\n\x03\x8d\x01' \n"},
-	{"vendor/golang.org/x/crypto/cryptobyte/asn1", ""},
-	{"vendor/golang.org/x/crypto/internal/alias", "\xcb\x02"},
-	{"vendor/golang.org/x/crypto/internal/poly1305", "R\x15\x99\x01"},
-	{"vendor/golang.org/x/net/dns/dnsmessage", "n"},
-	{"vendor/golang.org/x/net/http/httpguts", "\x87\x02\x14\x1a\x14\r"},
-	{"vendor/golang.org/x/net/http/httpproxy", "n\x03\x96\x01\x10\x05\x01\x18\x14\r"},
-	{"vendor/golang.org/x/net/http2/hpack", "\x03k\x03\x80\x01F"},
-	{"vendor/golang.org/x/net/idna", "q\x8c\x018\x14\x10\x02\x01"},
-	{"vendor/golang.org/x/net/nettest", "\x03d\a\x03\x80\x01\x11\x05\x16\x01\f\n\x01\x02\x02\x01\v"},
-	{"vendor/golang.org/x/sys/cpu", "\x9d\x02\r\n\x01\x16"},
-	{"vendor/golang.org/x/text/secure/bidirule", "n\xdb\x01\x11\x01"},
-	{"vendor/golang.org/x/text/transform", "\x03k\x83\x01X"},
-	{"vendor/golang.org/x/text/unicode/bidi", "\x03\bf\x84\x01>\x16"},
-	{"vendor/golang.org/x/text/unicode/norm", "g\n\x80\x01F\x12\x11"},
-	{"weak", "\x94\x01\x96\x01!"},
-}
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 f6909878a..000000000
--- a/vendor/golang.org/x/tools/internal/stdlib/import.go
+++ /dev/null
@@ -1,89 +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)
-	})
-}
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 c1faa50d3..000000000
--- a/vendor/golang.org/x/tools/internal/stdlib/manifest.go
+++ /dev/null
@@ -1,17726 +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, ""},
-		{"(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).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, ""},
-		{"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, ""},
-		{"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": {
-		{"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": {
-		{"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": {
-		{"(Hash).Available", Method, 0, ""},
-		{"(Hash).HashFunc", Method, 4, ""},
-		{"(Hash).New", Method, 0, ""},
-		{"(Hash).Size", Method, 0, ""},
-		{"(Hash).String", Method, 15, ""},
-		{"BLAKE2b_256", Const, 9, ""},
-		{"BLAKE2b_384", Const, 9, ""},
-		{"BLAKE2b_512", Const, 9, ""},
-		{"BLAKE2s_256", Const, 9, ""},
-		{"Decrypter", Type, 5, ""},
-		{"DecrypterOpts", Type, 5, ""},
-		{"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": {
-		{"(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(rand 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", Type, 20, ""},
-		{"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, rand 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(rand 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(rand 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", 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"},
-	},
-	"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/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, ""},
-		{"(*DecapsulationKey768).Bytes", Method, 24, ""},
-		{"(*DecapsulationKey768).Decapsulate", Method, 24, ""},
-		{"(*DecapsulationKey768).EncapsulationKey", Method, 24, ""},
-		{"(*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/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(rand 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)"},
-		{"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(rand 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, ""},
-		{"(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.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.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, ""},
-		{"QUICEvent", Type, 21, ""},
-		{"QUICEvent.Data", Field, 21, ""},
-		{"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, ""},
-		{"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, ""},
-		{"(HostnameError).Error", Method, 0, ""},
-		{"(InsecureAlgorithmError).Error", Method, 6, ""},
-		{"(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, ""},
-		{"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, ""},
-		{"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, ""},
-		{"Null.V", Field, 22, ""},
-		{"Null.Valid", Field, 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": {
-		{"(NotNull).ConvertValue", Method, 0, ""},
-		{"(Null).ConvertValue", Method, 0, ""},
-		{"(RowsAffected).LastInsertId", Method, 0, ""},
-		{"(RowsAffected).RowsAffected", 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, ""},
-		{"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_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_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_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_PC_HI20", Const, 20, ""},
-		{"R_LARCH_TLS_LE64_HI12", Const, 20, ""},
-		{"R_LARCH_TLS_LE64_LO20", Const, 20, ""},
-		{"R_LARCH_TLS_LE_HI20", Const, 20, ""},
-		{"R_LARCH_TLS_LE_LO12", Const, 20, ""},
-		{"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, ""},
-		{"(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", 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": {
-		{"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, ""},
-		{"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, ""},
-		{"(Number).Float64", Method, 1, ""},
-		{"(Number).Int64", Method, 1, ""},
-		{"(Number).String", Method, 1, ""},
-		{"(RawMessage).MarshalJSON", Method, 8, ""},
-		{"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, ""},
-		{"(ProcInst).Copy", Method, 0, ""},
-		{"(StartElement).Copy", Method, 0, ""},
-		{"(StartElement).End", Method, 2, ""},
-		{"(UnmarshalError).Error", Method, 0, ""},
-		{"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"},
-		{"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, ""},
-		{"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, ""},
-		{"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": {
-		{"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) 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, ""},
-		{"(*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, ""},
-		{"(ObjKind).String", 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.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, ""},
-		{"Decl", Type, 0, ""},
-		{"DeclStmt", Type, 0, ""},
-		{"DeclStmt.Decl", Field, 0, ""},
-		{"DeferStmt", Type, 0, ""},
-		{"DeferStmt.Call", Field, 0, ""},
-		{"DeferStmt.Defer", Field, 0, ""},
-		{"Ellipsis", Type, 0, ""},
-		{"Ellipsis.Ellipsis", Field, 0, ""},
-		{"Ellipsis.Elt", Field, 0, ""},
-		{"EmptyStmt", Type, 0, ""},
-		{"EmptyStmt.Implicit", Field, 5, ""},
-		{"EmptyStmt.Semicolon", Field, 0, ""},
-		{"Expr", Type, 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, ""},
-		{"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)"},
-		{"Spec", Type, 0, ""},
-		{"StarExpr", Type, 0, ""},
-		{"StarExpr.Star", Field, 0, ""},
-		{"StarExpr.X", Field, 0, ""},
-		{"Stmt", Type, 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, ""},
-		{"AndExpr", Type, 16, ""},
-		{"AndExpr.X", Field, 16, ""},
-		{"AndExpr.Y", Field, 16, ""},
-		{"Expr", Type, 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, ""},
-		{"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"},
-		{"Value", Type, 5, ""},
-	},
-	"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, ""},
-		{"Block", Type, 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, ""},
-		{"Text", Type, 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).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, ""},
-		{"(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, ""},
-		{"Object", 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", 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, ""},
-		{"(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, ""},
-		{"(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, ""},
-		{"(Gray).RGBA", Method, 0, ""},
-		{"(Gray16).RGBA", 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": {
-		{"(Op).Draw", Method, 2, ""},
-		{"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, ""},
-		{"(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, ""},
-		{"(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", 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, ""},
-		{"(FileMode).IsDir", Method, 16, ""},
-		{"(FileMode).IsRegular", Method, 16, ""},
-		{"(FileMode).Perm", Method, 16, ""},
-		{"(FileMode).String", Method, 16, ""},
-		{"(FileMode).Type", 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, ""},
-		{"(*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, ""},
-		{"(Kind).String", Method, 21, ""},
-		{"(Level).AppendText", Method, 24, ""},
-		{"(Level).Level", Method, 21, ""},
-		{"(Level).MarshalJSON", Method, 21, ""},
-		{"(Level).MarshalText", Method, 21, ""},
-		{"(Level).String", 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, ""},
-		{"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"},
-		{"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) (int float64, frac 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, ""},
-		{"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, ""},
-		{"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, ""},
-		{"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).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, ""},
-		{"(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, ""},
-		{"(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, ""},
-		{"(*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).RegisterProtocol", Method, 0, ""},
-		{"(*Transport).RoundTrip", Method, 0, ""},
-		{"(ConnState).String", Method, 3, ""},
-		{"(Dir).Open", 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, ""},
-		{"(Protocols).HTTP1", Method, 24, ""},
-		{"(Protocols).HTTP2", Method, 24, ""},
-		{"(Protocols).String", Method, 24, ""},
-		{"(Protocols).UnencryptedHTTP2", Method, 24, ""},
-		{"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, ""},
-		{"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.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, ""},
-		{"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", 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).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, ""},
-		{"(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", 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, ""},
-		{"(*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, ""},
-		{"(FileMode).IsDir", Method, 0, ""},
-		{"(FileMode).IsRegular", Method, 1, ""},
-		{"(FileMode).Perm", Method, 0, ""},
-		{"(FileMode).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, ""},
-		{"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, ""},
-		{"(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).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).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)"},
-		{"Type", Type, 0, ""},
-		{"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, ""},
-		{"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() []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, ""},
-		{"(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, ""},
-		{"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, ""},
-		{"(Errno).Error", Method, 0, ""},
-		{"(Errno).Is", Method, 13, ""},
-		{"(Errno).Temporary", Method, 0, ""},
-		{"(Errno).Timeout", Method, 0, ""},
-		{"(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, 0, ""},
-		{"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, ""},
-		{"Sockaddr", Type, 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).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).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).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, ""},
-		{"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, ""},
-		{"TB", Type, 2, ""},
-		{"Testing", Func, 21, "func() bool"},
-		{"Verbose", Func, 1, "func() bool"},
-	},
-	"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, ""},
-		{"(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, ""},
-		{"(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 e223e0f34..000000000
--- 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"
-)
-
-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 cdae2b8e8..000000000
--- 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 27a2b1792..000000000
--- a/vendor/golang.org/x/tools/internal/typeparams/coretype.go
+++ /dev/null
@@ -1,155 +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.
-//
-// See https://go.dev/ref/spec#Core_types for the definition of a core type.
-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) {
-		// https://go.dev/ref/spec#Core_types
-		// "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.
-	}
-	// https://go.dev/ref/spec#Core_types
-	// "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 709d2fc14..000000000
--- a/vendor/golang.org/x/tools/internal/typeparams/free.go
+++ /dev/null
@@ -1,131 +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"
-
-	"golang.org/x/tools/internal/aliases"
-)
-
-// 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 aliases.TypeParams(t).Len() > aliases.TypeArgs(t).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 f49802b8e..000000000
--- a/vendor/golang.org/x/tools/internal/typeparams/normalize.go
+++ /dev/null
@@ -1,218 +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 i := 0; i < u.NumEmbeddeds(); i++ {
-			embedded := u.EmbeddedType(i)
-			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 i := 0; i < u.Len(); i++ {
-			t := u.Term(i)
-			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 9bc29143f..000000000
--- 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 fa758cdc9..000000000
--- 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 3db2a135b..000000000
--- 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"
-)
-
-// 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 4957f0216..000000000
--- a/vendor/golang.org/x/tools/internal/typesinternal/element.go
+++ /dev/null
@@ -1,133 +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 i := 0; i < tmset.Len(); i++ {
-			sig := tmset.At(i).Type().(*types.Signature)
-			// 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(T)
-
-		default:
-			panic(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 235a6defc..000000000
--- 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 15ecf7c5d..000000000
--- 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 93acff217..000000000
--- a/vendor/golang.org/x/tools/internal/typesinternal/fx.go
+++ /dev/null
@@ -1,49 +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, *ast.ArrayType, *ast.StructType,
-			*ast.MapType, *ast.InterfaceType, *ast.KeyValueExpr:
-			// No effect
-		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() {
-				// TODO(adonovan): Add a case for built-in functions without side
-				// effects (by using callsPureBuiltin from tools/internal/refactor/inline)
-
-				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
-}
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 f2affec4f..000000000
--- 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.Type().(*types.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.Type().(*types.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 64f47919f..000000000
--- 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
-// [analysisinternal.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 8352ea761..000000000
--- 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 cc86487ea..000000000
--- 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 fef74a785..000000000
--- a/vendor/golang.org/x/tools/internal/typesinternal/types.go
+++ /dev/null
@@ -1,199 +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"
-	"reflect"
-	"unsafe"
-
-	"golang.org/x/tools/go/ast/inspector"
-	"golang.org/x/tools/internal/aliases"
-)
-
-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
-		}
-	}
-
-	addr := unsafe.Pointer(f.UnsafeAddr())
-	*(*bool)(addr) = 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 aliases.Origin(t)
-	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
-}
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 e5da04951..000000000
--- a/vendor/golang.org/x/tools/internal/typesinternal/varkind.go
+++ /dev/null
@@ -1,40 +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
-
-// TODO(adonovan): when CL 645115 lands, define the go1.25 version of
-// this API that actually does something.
-
-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 453bba2ad..000000000
--- 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 i := 0; i < t.Params().Len(); i++ {
-			params = append(params, &ast.Field{
-				Type: TypeExpr(t.Params().At(i).Type(), qual),
-				Names: []*ast.Ident{
-					{
-						Name: t.Params().At(i).Name(),
-					},
-				},
-			})
-		}
-		if t.Variadic() {
-			last := params[len(params)-1]
-			last.Type = &ast.Ellipsis{Elt: last.Type.(*ast.ArrayType).Elt}
-		}
-		var returns []*ast.Field
-		for i := 0; i < t.Results().Len(); i++ {
-			returns = append(returns, &ast.Field{
-				Type: TypeExpr(t.Results().At(i).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 i := range typeArgs.Len() {
-					indices = append(indices, TypeExpr(typeArgs.At(i), 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 b53f17861..000000000
--- a/vendor/golang.org/x/tools/internal/versions/features.go
+++ /dev/null
@@ -1,43 +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.
-
-// GoVersions that features in x/tools can be gated to.
-const (
-	Go1_18 = "go1.18"
-	Go1_19 = "go1.19"
-	Go1_20 = "go1.20"
-	Go1_21 = "go1.21"
-	Go1_22 = "go1.22"
-)
-
-// 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 bbabcd22e..000000000
--- 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 0fc10ce4e..000000000
--- 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 8d1f7453d..000000000
--- 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:]
-}