// Sqrt returns the square root of x.
// The result r is chosen so that real(r) ≥ 0 and imag(r) has the same sign as imag(x).
func Sqrt(x complex128) complex128 {
	if imag(x) == 0 {
		// Ensure that imag(r) has the same sign as imag(x) for imag(x) == signed zero.
		if real(x) == 0 {
			return complex(0, imag(x))
		}
		if real(x) < 0 {
			return complex(0, math.Copysign(math.Sqrt(-real(x)), imag(x)))
		}
		return complex(math.Sqrt(real(x)), imag(x))

	}
	// Add real server to the virtual server
	for i := range rss {
		if err = fake.AddRealServer(vs, rss[i]); err != nil {
			t.Errorf("Fail to add real server, error: %v", err)
		}
	}
	// Delete a real server of the virtual server
	// Make sure any position of the list can be real deleted
	rssLen := len(rss)
	for i := range rss {
		// List all real servers of the virtual server

func Sin(x complex128) complex128 {
	switch re, im := real(x), imag(x); {
	case im == 0 && (math.IsInf(re, 0) || math.IsNaN(re)):
		return complex(math.NaN(), im)
	case math.IsInf(im, 0):
		switch {
		case re == 0:
			return x
		case math.IsInf(re, 0) || math.IsNaN(re):
			return complex(math.NaN(), im)
		}
	case re == 0 && math.IsNaN(im):
		return x
	}
	s, c := math.Sincos(real(x))
	sh, ch := sinhcosh(imag(x))

	times := make(chan time.Time, batchSize+1)
	try := func(abs, strict bool, d time.Duration) {
		f := func(u time.Time) {
			realD := ec.Since(now)
			atomic.AddInt32(&numDone, 1)
			times <- u
			if realD < d || strict && strictable && realD > d+fuzz {
				t.Errorf("Asked for %v, got %v", d, realD)
			}
		}
		if abs {
			ec.EventAfterTime(f, now.Add(d))
		} else {
			ec.EventAfterDuration(f, d)
		}
	}

	defer make(map[string]int) // ERROR "defer discards result of make|is not used"
	defer new(int) // ERROR "defer discards result of new|is not used"
	defer real(1i) // ERROR "defer discards result of real|is not used"
	defer real(c) // ERROR "defer discards result of real|is not used"
	defer append(x, 1) // ERROR "defer discards result of append|is not used"
	defer append(x, 1) // ERROR "defer discards result of append|is not used"

type I interface {
	cplx() complex128
}

func main() {

	var t T

	if v := real(t.cplx()); v != 1 {
		panic("not-inlined complex call failed")
	}
	_ = imag(t.cplx())

	_ = real(t.cplx2())
	if v := imag(t.cplx2()); v != 1 {
		panic("potentially inlined complex call failed")
	}

	var i I
	i = t
	if v := real(i.cplx()); v != 1 {
		panic("potentially inlined complex call failed")
	}
	_ = imag(i.cplx())

	GetVirtualServers() ([]*VirtualServer, error)
	// AddRealServer creates the specified real server for the specified virtual server.
	AddRealServer(*VirtualServer, *RealServer) error
	// GetRealServers returns all real servers for the specified virtual server.
	GetRealServers(*VirtualServer) ([]*RealServer, error)
	// DeleteRealServer deletes the specified real server from the specified virtual server.
	DeleteRealServer(*VirtualServer, *RealServer) error

	doprint(c1, "(5.000000+6.000000i)")

	// 128
	c2 := complex128(C1)
	s = fmt.Sprintf("%G", c2)
	want(s, "(5+6i)")

	// real, imag, complex
	c3 := complex(real(c2)+3, imag(c2)-5) + c2
	s = fmt.Sprintf("%G", c3)
	want(s, "(13+7i)")

	// compiler used to crash on nested divide
	c4 := complex(real(c3/2), imag(c3/2))
	if c4 != c3/2 {
		fmt.Printf("BUG: c3 = %G != c4 = %G\n", c3, c4)
		panic(0)
	}

func Tan(x complex128) complex128 {
	switch re, im := real(x), imag(x); {
	case math.IsInf(im, 0):
		switch {
		case math.IsInf(re, 0) || math.IsNaN(re):
			return complex(math.Copysign(0, re), math.Copysign(1, im))
		}
		return complex(math.Copysign(0, math.Sin(2*re)), math.Copysign(1, im))
	case re == 0 && math.IsNaN(im):
		return x
	}
	d := math.Cos(2*real(x)) + math.Cosh(2*imag(x))
	if math.Abs(d) < 0.25 {

package main

// Trivial interface call devirtualization test.

type real struct {
	value int
}

func (r *real) Value() int { return r.value }

type Valuer interface {
	Value() int
}

type indirectiface struct {
	a, b, c int
}

func (i indirectiface) Value() int {
	return i.a + i.b + i.c
}

func main() {
	var r Valuer
	rptr := &real{value: 3}
	r = rptr