validations:
      required: true
  - type: input
    id: user-agent
    attributes:
      label: "What is your user agent?"
      description: "You can find your user agent here: https://www.google.com/search?q=what+is+my+user+agent"
    validations:
      required: true
  - type: textarea
    id: screenshot
    attributes:
      label: "Screenshot"
      description: "Please paste a screenshot of the page."

pkg debug/macho, type FatArchHeader struct, Size uint32
pkg debug/macho, type FatArchHeader struct, SubCpu uint32
pkg debug/macho, type FatFile struct
pkg debug/macho, type FatFile struct, Arches []FatArch
pkg debug/macho, type FatFile struct, Magic uint32
pkg debug/macho, var ErrNotFat *FormatError
pkg debug/pe, type DataDirectory struct
pkg debug/pe, type DataDirectory struct, Size uint32

Suppose a function <code>G</code> defers a function <code>D</code> that calls
<code>recover</code> and a panic occurs in a function on the same goroutine in which <code>G</code>
is executing.
When the running of deferred functions reaches <code>D</code>,
the return value of <code>D</code>'s call to <code>recover</code> will be the value passed to the call of <code>panic</code>.
If <code>D</code> returns normally, without starting a new

pkg syscall (darwin-arm64), const SYS_REVOKE ideal-int
pkg syscall (darwin-arm64), const SYS_RMDIR = 137
pkg syscall (darwin-arm64), const SYS_RMDIR ideal-int
pkg syscall (darwin-arm64), const SYS_SEARCHFS = 225
pkg syscall (darwin-arm64), const SYS_SEARCHFS ideal-int
pkg syscall (darwin-arm64), const SYS_SELECT = 93
pkg syscall (darwin-arm64), const SYS_SELECT ideal-int
pkg syscall (darwin-arm64), const SYS_SELECT_NOCANCEL = 407

// non-pointers in this type.
// TODO: Currently our best solution is to find these manually and list them as
// they come up. A better solution is desired.
// Note: DEPRECATED. There is now a better solution. Search for incomplete in this file.
func (c *typeConv) badPointerTypedef(dt *dwarf.TypedefType) bool {
	if c.badCFType(dt) {
		return true
	}
	if c.badJNI(dt) {
		return true
	}
	if c.badEGLType(dt) {

pkg sort, method (Float64Slice) Less(int, int) bool
pkg sort, method (Float64Slice) Search(float64) int
pkg sort, method (Float64Slice) Sort()
pkg sort, method (Float64Slice) Swap(int, int)
pkg sort, method (IntSlice) Len() int
pkg sort, method (IntSlice) Less(int, int) bool
pkg sort, method (IntSlice) Search(int) int
pkg sort, method (IntSlice) Sort()
pkg sort, method (IntSlice) Swap(int, int)

			return &files[i]
		}
	}
	return nil
}

func (r *Reader) openReadDir(dir string) []fileListEntry {
	files := r.fileList
	i := sort.Search(len(files), func(i int) bool {
		idir, _, _ := split(files[i].name)
		return idir >= dir
	})
	j := sort.Search(len(files), func(j int) bool {
		jdir, _, _ := split(files[j].name)
		return jdir > dir
	})
	return files[i:j]
}

type openDir struct {

	if bytes.Equal(a, b) {
		// a equal b
	}
	if !bytes.Equal(a, b) {
		// a not equal b
	}
}

func ExampleCompare_search() {
	// Binary search to find a matching byte slice.
	var needle []byte
	var haystack [][]byte // Assume sorted
	i := sort.Search(len(haystack), func(i int) bool {
		// Return haystack[i] >= needle.
		return bytes.Compare(haystack[i], needle) >= 0
	})

	a[0] = b
	for i, l := 1, len(a); i < l; i *= 2 {
		copy(a[i:], a[:i])
	}
}

func (r *rleBuffer) ReadAt(p []byte, off int64) (n int, err error) {
	if len(p) == 0 {
		return
	}
	skipParts := sort.Search(len(r.buf), func(i int) bool {
		part := &r.buf[i]
		return part.off+part.n > off
	})
	parts := r.buf[skipParts:]
	if len(parts) > 0 {
		skipBytes := off - parts[0].off
		for _, part := range parts {

// point in common.
func IndexAny(s []byte, chars string) int {
	if chars == "" {
		// Avoid scanning all of s.
		return -1
	}
	if len(s) == 1 {
		r := rune(s[0])
		if r >= utf8.RuneSelf {
			// search utf8.RuneError.
			for _, r = range chars {
				if r == utf8.RuneError {
					return 0
				}
			}
			return -1
		}
		if bytealg.IndexByteString(chars, s[0]) >= 0 {
			return 0
		}