EmptyMap map[string]Small
	NilMap   map[string]Small

	Slice   []Small
	SliceP  []*Small
	PSlice  *[]Small
	PSliceP *[]*Small

	EmptySlice []Small
	NilSlice   []Small

	StringSlice []string
	ByteSlice   []byte

	Small   Small
	PSmall  *Small
	PPSmall **Small

	Interface  any
	PInterface *any

	unexported int
}

type Small struct {

		if !fullWildcardFound {
			chain.sniHosts = append([]string{}, chain.sniHosts...)
			sort.Stable(sort.StringSlice(chain.sniHosts))
			match.ServerNames = chain.sniHosts
		}
	}
	if len(chain.destinationCIDRs) > 0 {
		chain.destinationCIDRs = append([]string{}, chain.destinationCIDRs...)
		sort.Stable(sort.StringSlice(chain.destinationCIDRs))
		for _, d := range chain.destinationCIDRs {
			cidr := util.ConvertAddressToCidr(d)

		{"(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},
		{"Float64Slice", Type, 0},
		{"Float64s", Func, 0},
		{"Float64sAreSorted", Func, 0},

		return "", errInvalidPath
	}
	return path, nil
}

// IsAbs reports whether the path is absolute.
func IsAbs(path string) bool {
	return stringslite.HasPrefix(path, "/") || stringslite.HasPrefix(path, "#")
}

// volumeNameLen returns length of the leading volume name on Windows.
// It returns 0 elsewhere.
func volumeNameLen(path string) int {
	return 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.

//go:build unix

package runtime

import (
	"internal/stringslite"
)

func secure() {
	initSecureMode()

	if !isSecureMode() {
		return
	}

	// When secure mode is enabled, we do one thing: enforce specific

// 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 strings

import (
	"internal/stringslite"
)

// Clone returns a fresh copy of s.
// It guarantees to make a copy of s into a new allocation,
// which can be important when retaining only a small substring
// of a much larger string. Using Clone can help such programs

			const wantFile = "symtabinl_test.go"
			if !stringslite.HasSuffix(file, wantFile) {
				t.Errorf("tiuTest+%#x: want file ...%s, got %s", pc-pc1, wantFile, file)
			}

			sf := u.srcFunc(uf)

			name := sf.name()
			const namePrefix = "runtime."
			if stringslite.HasPrefix(name, namePrefix) {
				name = name[len(namePrefix):]
			}
			if !stringslite.HasPrefix(name, "tiu") {

		if s[i] == t[0] && stringslite.HasPrefix(s[i:], t) {
			return i
		}
	}
	return -1
}

func atolwhex(p string) int64 {
	for stringslite.HasPrefix(p, " ") || stringslite.HasPrefix(p, "\t") {
		p = p[1:]
	}
	neg := false
	if stringslite.HasPrefix(p, "-") || stringslite.HasPrefix(p, "+") {
		neg = p[0] == '-'
		p = p[1:]

				switch {
				case stringslite.HasPrefix(s, "ndots:"):
					n, _, _ := dtoi(s[6:])
					if n < 0 {
						n = 0
					} else if n > 15 {
						n = 15
					}
					conf.ndots = n
				case stringslite.HasPrefix(s, "timeout:"):
					n, _, _ := dtoi(s[8:])
					if n < 1 {
						n = 1
					}
					conf.timeout = time.Duration(n) * time.Second
				case stringslite.HasPrefix(s, "attempts:"):

	// Since this is an internal package, testing that this isn't used on the
	// other operating systems should suffice to catch any mistakes.
	if !stringslite.HasSuffix(name, "_test") && !stringslite.HasSuffix(name, ".test") && name != "NaClMain" && name != "" {
		panic("fipstls: invalid use of Abandon in " + name)
	}
	required.Store(false)
}

// provided by runtime