for j := 0; j < n; j++ {
			x1 := new(Rat).SetInt64(int64(i + j + 1))
			x2 := new(Rat).SetInt(new(Int).Binomial(int64(n+i), int64(n-j-1)))
			x3 := new(Rat).SetInt(new(Int).Binomial(int64(n+j), int64(n-i-1)))
			x4 := new(Rat).SetInt(new(Int).Binomial(int64(i+j), int64(i)))

			x1.Mul(x1, x2)
			x1.Mul(x1, x3)
			x1.Mul(x1, x4)
			x1.Mul(x1, x4)

			if (i+j)&1 != 0 {
				x1.Neg(x1)
			}

			a.set(i, j, x1)
		}

	JCS	2(PC)
loop:
	LOOP	loop // LOOP

	// Intel pseudonyms for our own renamings.
	PADDD	M2, M1 // PADDL M2, M1
	MOVDQ2Q	X1, M1 // MOVQ X1, M1
	MOVNTDQ	X1, (AX)	// MOVNTO X1, (AX)
	MOVOA	(AX), X1	// MOVO (AX), X1

// Tests for SP indexed addresses.
	MOVQ	foo(SP)(AX*1), BX		// 488b1c04
	MOVQ	foo+32(SP)(CX*2), DX		// 488b544c20
	MOVQ	foo+32323(SP)(R8*4), R9		// 4e8b8c84437e0000

  return o << x.get();
}

/** The overloaded addition operator. */
template <typename T1, typename T2>
inline auto operator+(const Scalar<T1>& x1, const Scalar<T2>& x2)
    -> Scalar<decltype(x1.get() + x2.get())> {
  using Ret = decltype(x1 + x2);  // Return type of this function.
  return Ret(x1.get() + x2.get());
}

using Int64 = Scalar<int64_t>;
using Float32 = Scalar<float>;

}  // namespace impl
}  // namespace libtf

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

package p

type T1 interface{ M() }

func F1() T1

var _ = F1().(*X1 /* ERROR "undefined: X1" */)

func _() {
	switch F1().(type) {
	case *X1 /* ERROR "undefined: X1" */ :
	}
}

type T2 interface{ M() }

func F2() T2

package main

import "fmt"

const (
	x1 = 1.1    // float
	x2 = 1e10   // float
	x3 = 0x1e10 // integer (e is a hex digit)
)

const x4 = 0x1p10 // valid hexadecimal float
const x5 = 1p10   // ERROR "'p' exponent requires hexadecimal mantissa|invalid prefix"
const x6 = 0P0    // ERROR "'P' exponent requires hexadecimal mantissa|invalid prefix"

func main() {
	fmt.Printf("%g %T\n", x1, x1)
	fmt.Printf("%g %T\n", x2, x2)

	P3 ~int|bool,
]() {
	var x1 P1
	_ = max(x1)
	_ = max(x1, x1)
	_ = max(1, x1, 2)
	const _ = max /* ERROR "max(1, x1, 2) (value of type P1 constrained by ~int | ~float64) is not constant" */ (1, x1, 2)

	var x2 P2
	_ = max(x2)
	_ = max(x2, x2)
	_ = max(1, 2 /* ERROR "cannot convert 2 (untyped int constant) to type P2" */, x2) // error at 2 because max is 2

	VGF2P8AFFINEQB $94, (R15), Z15, K1, Z30            // 62438549ce375e
	VGF2P8MULB X15, X1, K7, X7                         // 62d2750fcfff
	VGF2P8MULB X12, X1, K7, X7                         // 62d2750fcffc
	VGF2P8MULB X0, X1, K7, X7                          // 62f2750fcff8
	VGF2P8MULB 15(R8), X1, K7, X7                      // 62d2750fcfb80f000000
	VGF2P8MULB (BP), X1, K7, X7                        // 62f2750fcf7d00

   * {@code x} and {@code y} value pair.
   *
   * @since 20.0
   */
  public static final class LinearTransformationBuilder {

    private final double x1;
    private final double y1;

    private LinearTransformationBuilder(double x1, double y1) {
      this.x1 = x1;
      this.y1 = y1;
    }

    /**
     * Finish building an instance which also maps {@code x = x2} to {@code y = y2}. These values

func main() {
	F([10]int{1, 2, 3, 4, 5, 6}, [20]int{1, 2, 3, 4, 5, 6})
}

//go:noinline
func F(x, y interface{}) {
	x1 := x.([10]int)
	y1 := y.([20]int)
	for i := range y1 {
		if i < 6 {
			if x1[i] != i+1 || y1[i] != i+1 {
				panic("FAIL")
			}
		} else {
			if (i < len(x1) && x1[i] != 0) || y1[i] != 0 {
				panic("FAIL")
			}
		}
	}

	VRSQRT28SD X8, X1, K1, X6                          // 62d2f509cdf0 or 62d2f529cdf0 or 62d2f549cdf0
	VRSQRT28SD X6, X1, K1, X6                          // 62f2f509cdf6 or 62f2f529cdf6 or 62f2f549cdf6
	VRSQRT28SD X0, X1, K1, X6                          // 62f2f509cdf0 or 62f2f529cdf0 or 62f2f549cdf0