p0 = (*int)(p)
	p0 = (*int)(p1)
	p = P(p0)
	p = P(p1)
	p1 = P1(p0)
	p1 = P1(p)

	s0 = struct {
		X int
	}(s)
	s0 = struct {
		X int
	}(s1)
	s = S(s0)
	s = S(s1)
	s1 = S1(s0)
	s1 = S1(s)

	pa0 = (*[10]int)(pa)
	pa0 = (*[10]int)(pa1)
	pa = (*A)(pa0)
	pa = (*A)(pa1)
	pa1 = (*A1)(pa0)
	pa1 = (*A1)(pa)

	pb0 = (*[]int)(pb)
	pb0 = (*[]int)(pb1)

package main

type A1 = [0]int
type A2 = [1]int

type S1 struct{}

type S2 struct {
	x int
}

type S3 = struct{}

type S4 = struct{ x int }

type S struct {
	x int
	_ [0]int
	_ [1]int
	_ A1
	_ A2
	_ S1
	_ S2
	_ S3
	_ S4
	_ [1]S4
}

var s = S{1, [0]int{}, [1]int{1}, A1{}, A2{1}, S1{}, S2{1}, S3{}, S4{1}, [1]S4{}}

func main() {
	f1()
	mustPanic(f2)

// For example:
// s1 = {a1, a2, a3}
// s2 = {a1, a2, a4, a5}
// s1.SymmetricDifference(s2) = {a3, a4, a5}
// s2.SymmetricDifference(s1) = {a3, a4, a5}
func (s1 Set[T]) SymmetricDifference(s2 Set[T]) Set[T] {
	return s1.Difference(s2).Union(s2.Difference(s1))
}

// Union returns a new set which includes items in either s1 or s2.
// For example:
// s1 = {a1, a2}
// s2 = {a3, a4}

func update(d digest, p []byte) digest {
	s1, s2 := uint32(d&0xffff), uint32(d>>16)
	for len(p) > 0 {
		var q []byte
		if len(p) > nmax {
			p, q = p[:nmax], p[nmax:]
		}
		for len(p) >= 4 {
			s1 += uint32(p[0])
			s2 += s1
			s1 += uint32(p[1])
			s2 += s1
			s1 += uint32(p[2])
			s2 += s1
			s1 += uint32(p[3])
			s2 += s1
			p = p[4:]
		}
		for _, x := range p {
			s1 += uint32(x)

            new AmbiguousBindingReporter.Provider("s1", methodDescriptor(ProvidesStringOne, "s1").toString()),
        ]).asString()

        cause.message == message

        where:
        order << [ProvidesStringOne, ProvidesStringTwo, MutatesString].permutations()
    }

    static class MutatesS1AsInteger extends RuleSource {
        @Mutate
        void m(@Path("s1") Integer s1) {

        }
    }

// s2.SymmetricDifference(s1) = {a3, a4, a5}
func (s1 Byte) SymmetricDifference(s2 Byte) Byte {
	return Byte(cast(s1).SymmetricDifference(cast(s2)))
}

// Union returns a new set which includes items in either s1 or s2.
// For example:
// s1 = {a1, a2}
// s2 = {a3, a4}
// s1.Union(s2) = {a1, a2, a3, a4}
// s2.Union(s1) = {a1, a2, a3, a4}
func (s1 Byte) Union(s2 Byte) Byte {
	return Byte(cast(s1).Union(cast(s2)))
}

// s2.SymmetricDifference(s1) = {a3, a4, a5}
func (s1 Int64) SymmetricDifference(s2 Int64) Int64 {
	return Int64(cast(s1).SymmetricDifference(cast(s2)))
}

// Union returns a new set which includes items in either s1 or s2.
// For example:
// s1 = {a1, a2}
// s2 = {a3, a4}
// s1.Union(s2) = {a1, a2, a3, a4}
// s2.Union(s1) = {a1, a2, a3, a4}
func (s1 Int64) Union(s2 Int64) Int64 {
	return Int64(cast(s1).Union(cast(s2)))
}

// s2.SymmetricDifference(s1) = {a3, a4, a5}
func (s1 String) SymmetricDifference(s2 String) String {
	return String(cast(s1).SymmetricDifference(cast(s2)))
}

// Union returns a new set which includes items in either s1 or s2.
// For example:
// s1 = {a1, a2}
// s2 = {a3, a4}
// s1.Union(s2) = {a1, a2, a3, a4}
// s2.Union(s1) = {a1, a2, a3, a4}
func (s1 String) Union(s2 String) String {
	return String(cast(s1).Union(cast(s2)))
}

package main

var b[10] float32;

func
main() {
	var a[10] float32;

	for i:=int16(5); i<10; i=i+1 {
		a[i] = float32(i);
	}

	s1 := float32(0);
	for i:=5; i<10; i=i+1 {
		s1 = s1 + a[i];
	}

	if s1 != 35 { panic(s1); }

	for i:=int16(5); i<10; i=i+1 {
		b[i] = float32(i);
	}

	s2 := float32(0);
	for i:=5; i<10; i=i+1 {
		s2 = s2 + b[i];
	}

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

package p

type S1 struct{}
type S2 struct{}

func _[P *S1|*S2]() {
	_= []P{{ /* ERROR "invalid composite literal element type P (no core type)" */ }}
}

func _[P *S1|S1]() {
	_= []P{{ /* ERROR "invalid composite literal element type P (no core type)" */ }}