// for more details.
// No argsize here, gc generates argsize info at call site.
TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$20
	NO_LOCAL_POINTERS
	MOVL	DX, 0(SP)
	LEAL	argframe+0(FP), CX
	MOVL	CX, 4(SP)
	MOVB	$0, 16(SP)
	LEAL	16(SP), AX
	MOVL	AX, 8(SP)
	MOVL	$0, 12(SP)
	CALL	·callReflect(SB)
	RET

// methodValueCall is the code half of the function returned by makeMethodValue.

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

	MOVL	$0xf1, 0xf1		// crash
	RET

TEXT sigreturn_tramp<>(SB),NOSPLIT,$0
	LEAL	140(SP), AX		// Load address of ucontext
	MOVL	AX, 4(SP)
	MOVL	$SYS_setcontext, AX
	INT	$0x80
	MOVL	$-1, 4(SP)		// Something failed...
	MOVL	$SYS_exit, AX
	INT	$0x80

TEXT runtime·sigaction(SB),NOSPLIT,$24
	LEAL	sig+0(FP), SI
	LEAL	4(SP), DI
	CLD
	MOVSL				// arg 1 - sig
	MOVSL				// arg 2 - act

// For generalized compatibility with [math.Pow]:
//
//	Pow(0, ±0) returns 1+0i
//	Pow(0, c) for real(c)<0 returns Inf+0i if imag(c) is zero, otherwise Inf+Inf i.
func Pow(x, y complex128) complex128 {
	if x == 0 { // Guaranteed also true for x == -0.
		if IsNaN(y) {
			return NaN()
		}
		r, i := real(y), imag(y)
		switch {
		case r == 0:
			return 1
		case r < 0:
			if i == 0 {

        given:
        def real = candidates.createDir("installs/java/11.0.6.hs-adpt")
        def symlink = candidates.file("installs/java/symlink").createLink(real)

        when:
        def directories = supplier.get()

        then:
        directories.size() == 2
        directories*.location.containsAll(real, symlink)
        directories*.source.unique() == ["asdf-vm"]

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

// This is a test case for issue 788.

package main

func main() {
	var a [1]complex64

	t := a[0]
	_ = real(t) // this works

	_ = real(a[0]) // this doesn't
}

) : DelegatingSocketFactory(getDefault()) {
  private val hostMapping = mutableMapOf<InetAddress, InetSocketAddress>()

  /** Sets the [real] address for [requested].  */
  operator fun set(
    requested: InetAddress,
    real: InetSocketAddress,
  ) {
    hostMapping[requested] = real
  }

  override fun createSocket(): Socket {
    return object : Socket() {
      override fun connect(
        endpoint: SocketAddress?,

	ADDL	$7, AX
	MOVW	AX, GS
	RET

TEXT i386_set_ldt<>(SB),NOSPLIT,$16
	LEAL	args+0(FP), AX	// 0(FP) == 4(SP) before SP got moved
	MOVL	$0, 0(SP)	// syscall gap
	MOVL	$1, 4(SP)
	MOVL	AX, 8(SP)
	MOVL	$SYS_sysarch, AX
	INT	$0x80
	JAE	2(PC)
	INT	$3
	RET

TEXT runtime·sysctl(SB),NOSPLIT,$28
	LEAL	mib+0(FP), SI
	LEAL	4(SP), DI
	CLD
	MOVSL				// arg 1 - name
	MOVSL				// arg 2 - namelen

        Did you *actually* encounter the need for this enhancement in a real-world scenario, or does
        it just seem like a sensible behavior for the feature to have?


        Before we make significant changes to existing features in Guava, we really want to be sure
        that it's for a use case that actually comes up in the real world. We want to hear the