golang
diff --git a/‎api/next/61716.txt
-1 b/‎api/next/61716.txt
-1
diff --git a/‎src/math/rand/v2/auto_test.go
+1-1 b/‎src/math/rand/v2/auto_test.go
+1-1
diff --git a/‎src/math/rand/v2/example_test.go
+13-13 b/‎src/math/rand/v2/example_test.go
+13-13
diff --git a/‎src/math/rand/v2/gen_cooked.go
-89 b/‎src/math/rand/v2/gen_cooked.go
-89
diff --git a/‎src/math/rand/v2/rand.go
+1-15 b/‎src/math/rand/v2/rand.go
+1-15
diff --git a/‎src/math/rand/v2/rand_test.go
+12-12 b/‎src/math/rand/v2/rand_test.go
+12-12
@@ -10,7 +10,6 @@ pkg math/rand/v2, func IntN(int) int #61716
 pkg math/rand/v2, func N[$0 intType]($0) $0 #61716
 pkg math/rand/v2, func New(Source) *Rand #61716
 pkg math/rand/v2, func NewPCG(uint64, uint64) *PCG #61716
-pkg math/rand/v2, func NewSource(int64) Source #61716
 pkg math/rand/v2, func NewZipf(*Rand, float64, float64, uint64) *Zipf #61716
 pkg math/rand/v2, func NormFloat64() float64 #61716
 pkg math/rand/v2, func Perm(int) []int #61716
 
@@ -26,7 +26,7 @@ func TestAuto(t *testing.T) {
 	// Strictly speaking, we should look for them in order,
 	// but this is good enough and not significantly more
 	// likely to have a false positive.
-	r := New(NewSource(1))
+	r := New(NewPCG(1, 0))
 	found := 0
 	for i := 0; i < 1000; i++ {
 		x := r.Int64()
 
@@ -46,9 +46,9 @@ func Example() {
 // The use of the global functions is the same, without the receiver.
 func Example_rand() {
 	// Create and seed the generator.
-	// Typically a non-fixed seed should be used, such as time.Now().UnixNano().
+	// Typically a non-fixed seed should be used, such as Uint64(), Uint64().
 	// Using a fixed seed will produce the same output on every run.
-	r := rand.New(rand.NewSource(99))
+	r := rand.New(rand.NewPCG(1, 2))
 
 	// The tabwriter here helps us generate aligned output.
 	w := tabwriter.NewWriter(os.Stdout, 1, 1, 1, ' ', 0)
@@ -83,17 +83,17 @@ func Example_rand() {
 	// Perm generates a random permutation of the numbers [0, n).
 	show("Perm", r.Perm(5), r.Perm(5), r.Perm(5))
 	// Output:
-	// Float32     0.73793465           0.38461488          0.9940225
-	// Float64     0.6919607852308565   0.29140004584133117 0.2262092163027547
-	// ExpFloat64  0.27263589649304043  1.3214739789908194  2.223639057715668
-	// NormFloat64 -0.09361151905162404 -1.3531915625472757 0.03212053591352371
-	// Int32       1824388269           1817075958          91420417
-	// Int64       3546343826724305832  5724354148158589552 5239846799706671610
-	// Uint32      1380114714           2295813601          961197529
-	// IntN(10)    8                    4                   5
-	// Int32N(10)  1                    8                   5
-	// Int64N(10)  4                    2                   6
-	// Perm        [0 2 4 3 1]          [0 4 2 3 1]         [2 1 3 0 4]
+	// Float32     0.95955694          0.8076733            0.8135684
+	// Float64     0.4297927436037299  0.797802349388613    0.3883664855410056
+	// ExpFloat64  0.43463410545541104 0.5513632046504593   0.7426404617374481
+	// NormFloat64 -0.9303318111676635 -0.04750789419852852 0.22248301107582735
+	// Int32       2020777787          260808523            851126509
+	// Int64       5231057920893523323 4257872588489500903  158397175702351138
+	// Uint32      314478343           1418758728           208955345
+	// IntN(10)    6                   2                    0
+	// Int32N(10)  3                   7                    7
+	// Int64N(10)  8                   9                    4
+	// Perm        [0 3 1 4 2]         [4 1 2 0 3]          [4 3 2 0 1]
 }
 
 func ExamplePerm() {
 
@@ -30,20 +30,6 @@ type Source interface {
 	Uint64() uint64
 }
 
-// NewSource returns a new pseudo-random Source seeded with the given value.
-// Unlike the default Source used by top-level functions, this source is not
-// safe for concurrent use by multiple goroutines.
-// The returned Source implements Source64.
-func NewSource(seed int64) Source {
-	return newSource(seed)
-}
-
-func newSource(seed int64) *rngSource {
-	var rng rngSource
-	rng.Seed(seed)
-	return &rng
-}
-
 // A Rand is a source of random numbers.
 type Rand struct {
 	src Source
@@ -273,7 +259,7 @@ func fastrand64() uint64
 type fastSource struct{}
 
 func (*fastSource) Int64() int64 {
-	return int64(fastrand64() & rngMask)
+	return int64(fastrand64() << 1 >> 1)
 }
 
 func (*fastSource) Uint64() uint64 {
 
@@ -46,7 +46,7 @@ func nearEqual(a, b, closeEnough, maxError float64) bool {
 	return absDiff/max(math.Abs(a), math.Abs(b)) < maxError
 }
 
-var testSeeds = []int64{1, 1754801282, 1698661970, 1550503961}
+var testSeeds = []uint64{1, 1754801282, 1698661970, 1550503961}
 
 // checkSimilarDistribution returns success if the mean and stddev of the
 // two statsResults are similar.
@@ -104,16 +104,16 @@ func checkSampleSliceDistributions(t *testing.T, samples []float64, nslices int,
 // Normal distribution tests
 //
 
-func generateNormalSamples(nsamples int, mean, stddev float64, seed int64) []float64 {
-	r := New(NewSource(seed))
+func generateNormalSamples(nsamples int, mean, stddev float64, seed uint64) []float64 {
+	r := New(NewPCG(seed, seed))
 	samples := make([]float64, nsamples)
 	for i := range samples {
 		samples[i] = r.NormFloat64()*stddev + mean
 	}
 	return samples
 }
 
-func testNormalDistribution(t *testing.T, nsamples int, mean, stddev float64, seed int64) {
+func testNormalDistribution(t *testing.T, nsamples int, mean, stddev float64, seed uint64) {
 	//fmt.Printf("testing nsamples=%v mean=%v stddev=%v seed=%v\n", nsamples, mean, stddev, seed);
 
 	samples := generateNormalSamples(nsamples, mean, stddev, seed)
@@ -161,16 +161,16 @@ func TestNonStandardNormalValues(t *testing.T) {
 // Exponential distribution tests
 //
 
-func generateExponentialSamples(nsamples int, rate float64, seed int64) []float64 {
-	r := New(NewSource(seed))
+func generateExponentialSamples(nsamples int, rate float64, seed uint64) []float64 {
+	r := New(NewPCG(seed, seed))
 	samples := make([]float64, nsamples)
 	for i := range samples {
 		samples[i] = r.ExpFloat64() / rate
 	}
 	return samples
 }
 
-func testExponentialDistribution(t *testing.T, nsamples int, rate float64, seed int64) {
+func testExponentialDistribution(t *testing.T, nsamples int, rate float64, seed uint64) {
 	//fmt.Printf("testing nsamples=%v rate=%v seed=%v\n", nsamples, rate, seed);
 
 	mean := 1 / rate
@@ -398,7 +398,7 @@ func encodePerm(s []int) int {
 
 // TestUniformFactorial tests several ways of generating a uniform value in [0, n!).
 func TestUniformFactorial(t *testing.T) {
-	r := New(NewSource(testSeeds[0]))
+	r := New(NewPCG(1, 2))
 	top := 6
 	if testing.Short() {
 		top = 3
@@ -436,8 +436,8 @@ func TestUniformFactorial(t *testing.T) {
 					// See https://en.wikipedia.org/wiki/Pearson%27s_chi-squared_test and
 					// https://www.johndcook.com/Beautiful_Testing_ch10.pdf.
 					nsamples := 10 * nfact
-					if nsamples < 500 {
-						nsamples = 500
+					if nsamples < 1000 {
+						nsamples = 1000
 					}
 					samples := make([]float64, nsamples)
 					for i := range samples {
@@ -476,11 +476,11 @@ func TestUniformFactorial(t *testing.T) {
 var Sink uint64
 
 func testRand() *Rand {
-	return New(NewSource(1))
+	return New(NewPCG(1, 2))
 }
 
 func BenchmarkSourceUint64(b *testing.B) {
-	s := NewSource(1)
+	s := NewPCG(1, 2)
 	var t uint64
 	for n := b.N; n > 0; n-- {
 		t += s.Uint64()