func (s Src5[T]) Next() {
	var x interface{} = s
	_ = (x.(Src5[T]))()
}

func main() {
	var src1 Src1[int]
	src1.Next()

	var src2 Src2[int]
	src2.Next()

	var src3 Src3[string]
	src3.Next()

	var src4 Src4[int]
	src4.Next()

	var src5 Src5[int]
	src5.Next()

				})
			}
		}
		src = src1
	case color.GrayModel:
		src1 := image.NewGray(image.Rect(0, 0, srcw, srch))
		for y := 0; y < srch; y++ {
			for x := 0; x < srcw; x++ {
				src1.SetGray(x, y, color.Gray{
					uint8((11*x + 13*y) % 0x100),
				})
			}
		}
		src = src1
	case color.RGBAModel:
		src1 := image.NewRGBA(image.Rect(0, 0, srcw, srch))
		for y := 0; y < srch; y++ {
			for x := 0; x < srcw; x++ {

func TestCopyStrings(t *testing.T) {
	var src1 []string
	dest1 := CopyStrings(src1)

	if !reflect.DeepEqual(src1, dest1) {
		t.Errorf("%v and %v are not equal", src1, dest1)
	}

	src2 := []string{}
	dest2 := CopyStrings(src2)

	if !reflect.DeepEqual(src2, dest2) {
		t.Errorf("%v and %v are not equal", src2, dest2)
	}

	src3 := []string{"a", "c", "b"}
	dest3 := CopyStrings(src3)

	if !reflect.DeepEqual(src3, dest3) {

                        sources {
                            put("src1", Stub(LanguageSourceSet))
                            put("src2", Stub(LanguageSourceSet))
                        }
                    }
                    bin2(BinarySpec) {
                        sources {
                            put("src1", Stub(LanguageSourceSet))
                        }
                    }
                }

        }
        return getModelId() + " " + getLocation();
    }

    public static InputSource merge(InputSource src1, InputSource src2) {
        return new InputSource(Stream.concat(src1.sources(), src2.sources()).collect(Collectors.toSet()));
    }

		return s
	}

	b := []byte(s)
	dst, src := unescapeEntity(b, i, i)
	for len(s[src:]) > 0 {
		if s[src] == '&' {
			i = 0
		} else {
			i = strings.IndexByte(s[src:], '&')
		}
		if i < 0 {
			dst += copy(b[dst:], s[src:])
			break
		}

		if i > 0 {
			copy(b[dst:], s[src:src+i])
		}
		dst, src = unescapeEntity(b, dst+i, src+i)
	}
	return string(b[:dst])

    }

    def 'recompiles when moving class to another source file'() {
        given:
        File src1 = source('class A { }\n class B { }')
        File src2 = source('class C { }')

        outputs.snapshot { run 'compileGroovy' }

        when:
        src1.text = 'class A { }'
        src2.text = 'class C { } \n class B { }'
        run 'compileGroovy'

        then:

	"encoding/asn1"
	"errors"
	"fmt"
	"math/big"
)

const ecPrivKeyVersion = 1

// ecPrivateKey reflects an ASN.1 Elliptic Curve Private Key Structure.
// References:
//
//	RFC 5915
//	SEC1 - http://www.secg.org/sec1-v2.pdf
//
// Per RFC 5915 the NamedCurveOID is marked as ASN.1 OPTIONAL, however in
// most cases it is not.
type ecPrivateKey struct {
	Version       int
	PrivateKey    []byte

Rob Findley <******@****.***> 1616637349 -0400

Shinsuke Sugaya <******@****.***> 1419757266 +0900