func main() {
	klog.InitFlags(nil)
	pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
	pflag.Parse()

	pkgs, err := loadPkgs(pflag.Args()...)
	if err != nil {
		klog.Errorf("failed to load packages: %v", err)
	}

	pkgs = massage(pkgs)
	boss := newBoss(pkgs)

	var allErrs []error
	for _, pkg := range pkgs {
		if pkgErrs := boss.Verify(pkg); pkgErrs != nil {
			allErrs = append(allErrs, pkgErrs...)
		}
	}

        if (StringUtil.isEmpty(value)) {
            buf.append("org.codelibs.fess.net.protocol");
        } else if (!value.contains("org.codelibs.fess.net.protocol")) {
            buf.append("|org.codelibs.fess.net.protocol");
        }
        if (buf.length() > 0) {
            System.setProperty("java.protocol.handler.pkgs", buf.toString());
        }
    }

	X86HasFMA       *obj.LSym
	X86HasPOPCNT    *obj.LSym
	X86HasSSE41     *obj.LSym
	// Wasm
	WasmDiv *obj.LSym
	// Wasm
	WasmTruncS *obj.LSym
	// Wasm
	WasmTruncU *obj.LSym
}

// Pkgs holds known packages.
var Pkgs struct {
	Go       *types.Pkg
	Itab     *types.Pkg
	Runtime  *types.Pkg
	Coverage *types.Pkg

	}

	var mu sync.Mutex
	have := map[string]bool{
		"builtin": true, // ignore pseudo-package that exists only for documentation
	}
	addPkg := func(p string) {
		mu.Lock()
		m.Pkgs = append(m.Pkgs, p)
		mu.Unlock()
	}
	if !cfg.BuildContext.CgoEnabled {
		have["runtime/cgo"] = true // ignore during walk
	}

	type pruning int8
	const (
		pruneVendor = pruning(1 << iota)
		pruneGoMod
	)

	cmd.Env = append(cmd.Env, "GOOS=linux")
	cmd.Stderr = os.Stderr
	out, err := cmd.Output()
	if err != nil {
		log.Fatalf("loading package list: %v\n%s", err, out)
	}
	pkgs := strings.Split(strings.TrimSpace(string(out)), "\n")

	cmd = exec.Command(testenv.GoToolPath(t), "tool", "dist", "list")
	cmd.Stderr = os.Stderr
	out, err = cmd.Output()
	if err != nil {

		if !info.IsDir() {
			return nil
		}
		pkgs, err := parser.ParseDir(fset, path, isGoFile, parser.ParseComments)
		if err != nil {
			if *verbose {
				fmt.Fprintln(os.Stderr, err)
			}
			return nil
		}
		for _, pkg := range pkgs {
			d := doc.New(pkg, path, doc.Mode(0))
			list := appendHeadings(nil, d.Doc)
			for _, d := range d.Consts {

			}
		}

		mods, err := modload.ListModules(ctx, args, 0, "")
		if err != nil {
			base.Fatal(err)
		}

		byModule := make(map[string][]string)
		_, pkgs := modload.LoadPackages(ctx, loadOpts, "all")
		for _, path := range pkgs {
			m := modload.PackageModule(path)
			if m.Path != "" {
				byModule[m.Path] = append(byModule[m.Path], path)
			}
		}
		sep := ""
		for _, m := range mods {

	"go/token"
	"internal/diff"
	"testing"
)

func TestComment(t *testing.T) {
	fset := token.NewFileSet()
	pkgs, err := parser.ParseDir(fset, "testdata/pkgdoc", nil, parser.ParseComments)
	if err != nil {
		t.Fatal(err)
	}
	if pkgs["pkgdoc"] == nil {
		t.Fatal("missing package pkgdoc")
	}
	pkg := New(pkgs["pkgdoc"], "testdata/pkgdoc", 0)

	var (

}

func (mm *metaMerge) visitPackage(pd *decodemeta.CoverageMetaDataDecoder, pkgIdx uint32, pcombine bool) {
	p, ok := mm.pkm[pd.PackagePath()]
	if !ok {
		p = &pkstate{
			pkgIdx: uint32(len(mm.pkgs)),
		}
		mm.pkgs = append(mm.pkgs, p)
		mm.pkm[pd.PackagePath()] = p
		if pcombine {
			p.pcombinestate = new(pcombinestate)
			cmdb, err := encodemeta.NewCoverageMetaDataBuilder(pd.PackagePath(), pd.PackageName(), pd.ModulePath())

// first error encountered are returned.
func ParseDir(fset *token.FileSet, path string, filter func(fs.FileInfo) bool, mode Mode) (pkgs map[string]*ast.Package, first error) {
	list, err := os.ReadDir(path)
	if err != nil {
		return nil, err
	}

	pkgs = make(map[string]*ast.Package)
	for _, d := range list {
		if d.IsDir() || !strings.HasSuffix(d.Name(), ".go") {
			continue
		}