package a

import "go/build"

type (
	Float64 = float64
	Rune    = rune
)

type (
	Int       int
	IntAlias  = Int
	IntAlias2 = IntAlias
	S         struct {
		Int
		IntAlias
		IntAlias2
	}
)

type (
	Context = build.Context
)

type (
	I1 interface {
		M1(IntAlias2) Float64
		M2() Context
	}

	I2 = interface {
		M1(Int) float64
		M2() build.Context
	}
)

					m.Set(bucketReplProxiedHeadRequestsTotal, float64(s.ProxyStats.HeadTotal), labels...)
					m.Set(bucketReplProxiedPutTaggingRequestsFailures, float64(s.ProxyStats.PutTagFailedTotal), labels...)
					m.Set(bucketReplProxiedPutTaggingRequestsTotal, float64(s.ProxyStats.PutTagTotal), labels...)
					m.Set(bucketReplSentCount, float64(stat.ReplicatedCount), labels...)

)

//go:noinline
func fcmplt(a, b float64, x uint64) uint64 {
	if a < b {
		x = 0
	}
	return x
}

//go:noinline
func fcmple(a, b float64, x uint64) uint64 {
	if a <= b {
		x = 0
	}
	return x
}

//go:noinline
func fcmpgt(a, b float64, x uint64) uint64 {
	if a > b {
		x = 0
	}
	return x
}

//go:noinline
func fcmpge(a, b float64, x uint64) uint64 {
	if a >= b {
		x = 0

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

package b

import (
	"./a"
	. "go/build"
)

func F(x float64) a.Float64 {
	return x
}

type MyContext = Context // = build.Context

var C a.Context = Default

type S struct{}

func (S) M1(x a.IntAlias) float64 { return a.Float64(x) }
func (S) M2() Context             { return Default }

var _ a.I1 = S{}

	}
	if float64(u32) != du32 {
		t.Errorf("float64(u32) != du32")
	}
	if float64(u16) != du16 {
		t.Errorf("float64(u16) != du16")
	}
	if float64(u8) != du8 {
		t.Errorf("float64(u8) != du8")
	}
	if float64(i64) != di64 {
		t.Errorf("float64(i64) != di64")
	}
	if float64(i32) != di32 {
		t.Errorf("float64(i32) != di32")
	}
	if float64(i16) != di16 {
		t.Errorf("float64(i16) != di16")
	}

func (x myint) foo() int {return int(x)}

type myfloat float64
func (x myfloat) foo() float64 {return float64(x) }

func f[T any](i interface{}) {
	switch x := i.(type) {
	case interface { foo() T }:
		println("fooer", x.foo())
	default:
		println("other")
	}
}
func main() {
	f[int](myint(6))
	f[int](myfloat(7))
	f[float64](myint(8))
	f[float64](myfloat(9))

}

// Atan returns the arctangent, in radians, of x.
//
// Special cases are:
//
//	Atan(±0) = ±0
//	Atan(±Inf) = ±Pi/2
func Atan(x float64) float64 {
	if haveArchAtan {
		return archAtan(x)
	}
	return atan(x)
}

func atan(x float64) float64 {
	if x == 0 {
		return x
	}
	if x > 0 {
		return satan(x)
	}
	return -satan(-x)

	_ float32 = real(3.2i)

	_ float64 = real(1)
	_ float64 = real('a')
	_ float64 = real(2.1)
	_ float64 = real(3.2i)

	_ int = imag(1)
	_ int = imag('a')
	_ int = imag(2.1 + 3i)
	_ int = imag(3i)

	_ float32 = imag(1)
	_ float32 = imag('a')
	_ float32 = imag(2.1 + 3.1i)
	_ float32 = imag(3i)

	_ float64 = imag(1)
	_ float64 = imag('a')
	_ float64 = imag(2.1 + 3.1i)
	_ float64 = imag(3i)
)

package math

const haveArchFloor = false

func archFloor(x float64) float64 {
	panic("not implemented")
}

const haveArchCeil = false

func archCeil(x float64) float64 {
	panic("not implemented")
}

const haveArchTrunc = false

func archTrunc(x float64) float64 {
	panic("not implemented")

		Peak:    peak,
		Curr:    curr,
		measure: rx.measure,
		N:       rx.N + o.N,
	}
}

func calcAvg(x, y float64, n1, n2 int64) float64 {
	if n1+n2 == 0 {
		return 0
	}
	avg := (x*float64(n1) + y*float64(n2)) / float64(n1+n2)
	return avg
}

// Add a new transfer
func (rx *XferStats) addSize(sz int64, t time.Duration) {
	if rx.measure == nil {