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

type Ordered interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 |
		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
		~float32 | ~float64 |
		~string
}

// List is a linked list of ordered values of type T.
type List[T Ordered] struct {
	Next *List[T]

}

func CheckPtrStringFail() {
	p := new(byte)
	sink2 = p
	sink2 = unsafe.String(p, 100)
}

func CheckPtrAlignmentNested() {
	s := make([]int8, 100)
	p := unsafe.Pointer(&s[0])
	n := 9
	_ = ((*[10]int8)(unsafe.Pointer((*[10]int64)(unsafe.Pointer(&p)))))[:n:n]

		Data: unsafe.Pointer(&b[0]),
		Len:  n,
		Cap:  cap(b) * int(scale),
	}
	return *(*[]int8)(unsafe.Pointer(&s))
}
func (c *Cache) freeInt8Slice(s []int8) {
	var base int64
	var derived int8
	scale := unsafe.Sizeof(base) / unsafe.Sizeof(derived)
	b := unsafeheader.Slice{
		Data: unsafe.Pointer(&s[0]),
		Len:  int((uintptr(len(s)) + scale - 1) / scale),
		Cap:  int((uintptr(cap(s)) + scale - 1) / scale),

// RegEx matches only numeric values
var numericPlaceholderRe = regexp.MustCompile(`\$\d+\$`)

func isNumeric(k reflect.Kind) bool {
	switch k {
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return true
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		return true
	case reflect.Float32, reflect.Float64:
		return true
	default:

			in: `go test fuzz v1
int()`,
			reject: true,
		},
		{
			desc: "negative uint",
			in: `go test fuzz v1
uint(-32)`,
			reject: true,
		},
		{
			desc: "int8 too large",
			in: `go test fuzz v1
int8(1234456)`,
			reject: true,
		},
		{
			desc: "multiplication in int value",
			in: `go test fuzz v1
int(20*5)`,
			reject: true,
		},
		{
			desc: "double negation",

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

package types

import "cmd/compile/internal/base"

// AlgKind describes the kind of algorithms used for comparing and
// hashing a Type.
type AlgKind int8

//go:generate stringer -type AlgKind -trimprefix A alg.go

const (
	AUNK   AlgKind = iota
	ANOEQ          // Types cannot be compared
	ANOALG         // implies ANOEQ, and in addition has a part that is marked Noalg

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

package poll

import (
	"syscall"
	"unsafe"
)

func newIovecWithBase(base *byte) syscall.Iovec {
	return syscall.Iovec{Base: (*int8)(unsafe.Pointer(base))}

	D = nil // ERROR "cannot use nil"
	X = nil // ERROR "cannot use nil"
}

// "x is an untyped constant representable by a value of type T"
func _[
	Int8 ~int8,
	Int16 ~int16,
	Int32 ~int32,
	Int64 ~int64,
	Int8_16 ~int8 | ~int16,
](
	i8 Int8,
	i16 Int16,
	i32 Int32,
	i64 Int64,
	i8_16 Int8_16,
) {
	b = 42
	b = 42.0
	// etc.

	i8 = -1 << 7
	i8 = 1<<7 - 1

package linalg

// Numeric is type bound that matches any numeric type.
// It would likely be in a constraints package in the standard library.
type Numeric interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 |
		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
		~float32 | ~float64 |
		~complex64 | ~complex128
}

func DotProduct[T Numeric](s1, s2 []T) T {
	if len(s1) != len(s2) {

		s = strings.Replace(s, "MKPOSTIFIPAD", "X__ifi_pad", 1)
		s = strings.Replace(s, "MKPOSTSYSINFOTF", "X_f", 1)

		// Force the type of RawSockaddr.Data to [14]int8 to match
		// the existing gccgo API.
		re = regexp.MustCompile("(Data\\s+\\[14\\])uint8")
		s = re.ReplaceAllString(s, "${1}int8")

	case goos == "freebsd":
		// Keep pre-FreeBSD 10 / non-POSIX 2008 names for timespec fields
		re := regexp.MustCompile("(A|M|C|Birth)tim\\s+Timespec")