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

package main

type T[A, B, C any] int

func (T[A, B, C]) m(x int) {
	if x <= 0 {
		return
	}
	T[B, C, A](0).m(x - 1)
}

func main() {
	T[int8, int16, int32](0).m(3)

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

package a

import (
	"math"
)

type Numeric interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 |
		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
		~float32 | ~float64 |
		~complex64 | ~complex128
}

// numericAbs matches a struct containing a numeric type that has an Abs method.

      "T: {bfloat16, half, float, double, int64, int32, uint8, uint16, "
      "uint32, uint64, int8, int16, complex64, complex128, qint8, quint8, "
      "qint16, quint16, qint32}");
  TF_OpDefinitionBuilderAddAttr(
      op_builder,
      "type: {bfloat16, half, float, double, int64, int32, uint8, uint16, "
      "uint32, uint64, int8, int16, complex64, complex128, qint8, quint8, "
      "qint16, quint16, qint32}");

	REGTMP  = REG_R30 // used by the assembler
	FREGRET = REG_F0  // not use
)

var LOONG64DWARFRegisters = map[int16]int16{}

func init() {
	// f assigns dwarfregisters[from:to] = (base):(to-from+base)
	f := func(from, to, base int16) {
		for r := int16(from); r <= to; r++ {
			LOONG64DWARFRegisters[r] = (r - from) + base
		}
	}
	f(REG_R0, REG_R31, 0)
	f(REG_F0, REG_F31, 32)

}

type keventt struct {
	ident  uint64
	filter int16
	flags  uint16
	fflags uint32
	data   int64
	udata  *byte
}

type pthread uintptr
type pthreadattr struct {
	X__sig    int64
	X__opaque [56]int8
}
type pthreadmutex struct {
	X__sig    int64
	X__opaque [56]int8
}
type pthreadmutexattr struct {
	X__sig    int64
	X__opaque [8]int8
}
type pthreadcond struct {
	X__sig    int64

Oliver Liu <******@****.***> 1520311744 -0800

			}
		})
	}
}

func TestToString(t *testing.T) {
	tests := []struct {
		name string
		in   interface{}
		out  string
	}{
		{"int", math.MaxInt64, "9223372036854775807"},
		{"int8", int8(math.MaxInt8), "127"},
		{"int16", int16(math.MaxInt16), "32767"},
		{"int32", int32(math.MaxInt32), "2147483647"},
		{"int64", int64(math.MaxInt64), "9223372036854775807"},

func _[T F | int](x T) {
	_ = x == 0 // don't crash when recording type of 0
}

// test case from issue

type FloatType { // ERRORx "expected type|type declaration"
	float32 | float64
} // ERRORx "expected declaration|non-declaration statement"

type IntegerType interface {
	int8 | int16 | int32 | int64 | int |
		uint8 | uint16 | uint32 | uint64 | uint
}

		state.encodeUint(bits)`,
	},
	{
		"int",
		"Int",
		"0",
		`state.encodeInt(int64(x))`,
	},
	{
		"int16",
		"Int16",
		"0",
		`state.encodeInt(int64(x))`,
	},
	{
		"int32",
		"Int32",
		"0",
		`state.encodeInt(int64(x))`,
	},
	{
		"int64",
		"Int64",
		"0",
		`state.encodeInt(x)`,
	},
	{
		"int8",
		"Int8",
		"0",
		`state.encodeInt(int64(x))`,
	},

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

package main

import "fmt"

type IntLike interface {
	~int | ~int64 | ~int32 | ~int16 | ~int8
}

func Reduce[T any, U any, Uslice ~[]U](function func(T, U) T, sequence Uslice, initial T) T {
	result := initial
	for _, x := range sequence {
		result = function(result, x)
	}
	return result