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

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

        when:
        def directories = supplier.get()

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

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

package p

var _ = int8(4) * 300         // ERROR "overflows int8"
var _ = complex64(1) * 1e200  // ERROR "complex real part overflow|overflows complex64"

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

package cmplx

import "math"

// IsInf reports whether either real(x) or imag(x) is an infinity.
func IsInf(x complex128) bool {
	if math.IsInf(real(x), 0) || math.IsInf(imag(x), 0) {
		return true
	}
	return false
}

// Inf returns a complex infinity, complex(+Inf, +Inf).
func Inf() complex128 {
	inf := math.Inf(1)

            proxy_set_header Host $http_host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
            proxy_set_header X-NginX-Proxy true;

            # This is necessary to pass the correct IP to be hashed
            real_ip_header X-Real-IP;

            proxy_connect_timeout 300;
            

// Copyright 2022 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 p

func Real[P ~complex128](x P) {
	_ = real(x /* ERROR "not supported" */ )
}

func Imag[P ~complex128](x P) {
	_ = imag(x /* ERROR "not supported" */ )
}

func Complex[P ~float64](x P) {
	_ = complex(x /* ERROR "not supported" */ , 0)

	return C{&cx}
}

//go:noinline
func (c C) X() C {
	cx := complex(imag(*c.x), real(*c.x))
	return C{&cx}
}

//go:noinline
func (d D) X() C {
	cx := complex(float64(imag(d.x)), -float64(real(d.x)))
	return C{&cx}
}

//go:noinline
func (a A) X() C {
	cx := complex(-float64(imag(*a[0])), float64(real(*a[0])))
	return C{&cx}
}

//go:noinline
func (i I) id() I {
	return i
}