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

//go:build freebsd && (386 || arm || arm64 || riscv64)

#include <sys/types.h>
#include <sys/signalvar.h>
#include <machine/sysarch.h>
#include <pthread.h>
#include <signal.h>
#include <string.h>
#include "libcgo.h"
#include "libcgo_unix.h"

#ifdef ARM_TP_ADDRESS
// ARM_TP_ADDRESS is (ARM_VECTORS_HIGH + 0x1000) or 0xffff1000

	return Search(len(a), func(i int) bool { return a[i] >= x })
}

// Search returns the result of applying [SearchInts] to the receiver and x.
func (p IntSlice) Search(x int) int { return SearchInts(p, x) }

// Search returns the result of applying [SearchFloat64s] to the receiver and x.
func (p Float64Slice) Search(x float64) int { return SearchFloat64s(p, x) }

// maps in cmd/dist/build.go, then run 'go generate internal/platform'.

package platform

// List is the list of all valid GOOS/GOARCH combinations,
// including known-broken ports.
var List = []OSArch{
	{"aix", "ppc64"},
	{"android", "386"},
	{"android", "amd64"},
	{"android", "arm"},
	{"android", "arm64"},
	{"darwin", "amd64"},
	{"darwin", "arm64"},
	{"dragonfly", "amd64"},
	{"freebsd", "386"},

							<c:if test="${s.index < 3}">
								<la:link
									href="/search?q=${f:u(item)}${fe:facetQuery()}${fe:geoQuery()}">${f:h(item)}</la:link>
							</c:if>
							<c:if test="${3 <= s.index}">
								<la:link styleClass="d-none d-sm-inline"
									href="/search?q=${f:u(item)}${fe:facetQuery()}${fe:geoQuery()}">${f:h(item)}</la:link>
							</c:if>
						</c:forEach>
					</p>

							<c:if test="${s.index < 3}">
								<la:link
									href="/search?q=${f:u(item)}${fe:facetQuery()}${fe:geoQuery()}">${f:h(item)}</la:link>
							</c:if>
							<c:if test="${3 <= s.index}">
								<la:link styleClass="d-none d-sm-inline"
									href="/search?q=${f:u(item)}${fe:facetQuery()}${fe:geoQuery()}">${f:h(item)}</la:link>
							</c:if>
						</c:forEach>
					</p>

// against the standard library (std and cmd) in GOROOT/src.
func MatchInModule(ctx context.Context, pattern string, m module.Version, tags map[string]bool) *search.Match {
	match := search.NewMatch(pattern)
	if m == (module.Version{}) {
		matchPackages(ctx, match, tags, includeStd, nil)
	}

	LoadModFile(ctx) // Sets Target, needed by fetch and matchPackages.

package load

import (
	"path/filepath"
	"strings"

	"cmd/go/internal/search"
	"cmd/internal/pkgpattern"
)

// MatchPackage(pattern, cwd)(p) reports whether package p matches pattern in the working directory cwd.
func MatchPackage(pattern, cwd string) func(*Package) bool {
	switch {
	case search.IsRelativePath(pattern):
		// Split pattern into leading pattern-free directory path

# /etc/resolv.conf

domain localdomain
search test invalid

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package strings

// stringFinder efficiently finds strings in a source text. It's implemented
// using the Boyer-Moore string search algorithm:
// https://en.wikipedia.org/wiki/Boyer-Moore_string_search_algorithm
// https://www.cs.utexas.edu/~moore/publications/fstrpos.pdf (note: this aged
// document uses 1-based indexing)
type stringFinder struct {

Shinsuke Sugaya <******@****.***> 1680155124 +0900