t1.Multiply(&t2, &t1)     // 2^200 - 1
	t1.Square(&t1)            // 2^201 - 2
	for i := 1; i < 50; i++ { // 2^250 - 2^50
		t1.Square(&t1)
	}
	t0.Multiply(&t1, &t0)     // 2^250 - 1
	t0.Square(&t0)            // 2^251 - 2
	t0.Square(&t0)            // 2^252 - 4
	return v.Multiply(&t0, x) // 2^252 - 3 -> x^(2^252-3)
}

// sqrtM1 is 2^((p-1)/4), which squared is equal to -1 by Euler's Criterion.

        given:
        buildFile << """
            task testGroovyVersion {
                doLast {
                    assert GroovySystem.version == "2.5.12"
                }
            }
        """

        when:
        def result = runner().withArguments("testGroovyVersion")
            .withGradleVersion("6.8.3")
            .build()

        then:

        "org.group" | "projectA" | "1.2"   | 'http://server/lookup/org/group/projectA/1.2/ivys/1.2/ivy.xml'
        "#?:%12"    | "projectA" | "1.2"   | 'http://server/lookup/%23%3F:%2512/projectA/1.2/ivys/1.2/ivy.xml'
    }

    def "substitutes attributes into pattern to determine version list pattern"() {

_Nothing has changed._

### Changed
_Nothing has changed._

### Removed
_Nothing has changed._



# v1.25.12


## Downloads for v1.25.12



### Source Code

filename | sha512 hash
-------- | -----------

			isErr:         false,
			expectedCurve: elliptic.P256(),
		},
		"ECDSA-P384": {
			key:           ecdsaPrivKeyP384,
			isErr:         false,
			expectedCurve: elliptic.P384(),
		},
		"ECDSA-P512": {
			key:           ecdsaPrivKeyP521,
			isErr:         false,
			expectedCurve: elliptic.P256(),
		},
		"ED25519": {
			key:           ed25519PrivKey,
			isErr:         true,
			expectedCurve: nil,

  %1 = "mhlo.slice"(%arg0) <{limit_indices = dense<[2, 1, 512]> : tensor<3xi64>, start_indices = dense<[1, 0, 0]> : tensor<3xi64>, strides = dense<1> : tensor<3xi64>}> : (tensor<3x1x512xf32>) -> tensor<1x1x512xf32>

			gcPercent:     100,
			memoryLimit:   512 << 20,
			globalsBytes:  32 << 10,
			nCores:        8,
			allocRate:     constant(33.0),
			scanRate:      constant(1024.0),
			growthRate:    constant(3.5).sum(ramp(-2.5, 12)),
			scannableFrac: constant(1.0),
			stackBytes:    constant(8192),
			length:        50,
			checker: func(t *testing.T, c []gcCycleResult) {
				n := len(c)
				if n > 12 {

==== Updates to bundled Gradle dependencies

- Ant has been updated to https://downloads.apache.org/ant/RELEASE-NOTES-1.10.8.html[1.10.8].
- Groovy has been updated to https://groovy-lang.org/changelogs/changelog-2.5.12.html[Groovy 2.5.12].

==== Dependency substitutions and variant aware dependency resolution

	/* x^101440 mod p(x), x^101376 mod p(x) */
DATA ·IEEEConst+2496(SB)/8,$0x00000001788b0504
DATA ·IEEEConst+2504(SB)/8,$0x0000000105abc27c

	/* x^100416 mod p(x), x^100352 mod p(x) */
DATA ·IEEEConst+2512(SB)/8,$0x0000000038385d02
DATA ·IEEEConst+2520(SB)/8,$0x00000000972e4a58

	/* x^99392 mod p(x), x^99328 mod p(x) */
DATA ·IEEEConst+2528(SB)/8,$0x00000001b6c83844
DATA ·IEEEConst+2536(SB)/8,$0x0000000183499a5e

		if size := data.ActualSize(); size > 0 && size < fi.Erasure.BlockSize {
			// Account for padding and forced compression overhead and encryption.
			buffer = make([]byte, data.ActualSize()+256+32+32, data.ActualSize()*2+512)
		} else {
			buffer = globalBytePoolCap.Load().Get()
			defer globalBytePoolCap.Load().Put(buffer)
		}
	case size >= fi.Erasure.BlockSize:
		buffer = globalBytePoolCap.Load().Get()