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.

_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>

==== 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()

	SYS_CATANH                          = 0x9CD // 2509
	SYS___CATANH_B                      = 0x9CE // 2510
	SYS___CATANH_H                      = 0x9CF // 2511
	SYS_CATANHF                         = 0x9D0 // 2512
	SYS___CATANHF_B                     = 0x9D1 // 2513
	SYS___CATANHF_H                     = 0x9D2 // 2514
	SYS_CATANHL                         = 0x9D3 // 2515
	SYS___CATANHL_B                     = 0x9D4 // 2516

	case ASHA1M:
		return 0x5E<<24 | 2<<12

	case ASHA1SU0:
		return 0x5E<<24 | 3<<12

	case ASHA256H:
		return 0x5E<<24 | 4<<12

	case ASHA256H2:
		return 0x5E<<24 | 5<<12

	case ASHA256SU1:
		return 0x5E<<24 | 6<<12

	case ASHA1H:
		return 0x5E<<24 | 2<<20 | 8<<16 | 0<<12 | 2<<10

	case ASHA1SU1:
		return 0x5E<<24 | 2<<20 | 8<<16 | 1<<12 | 2<<10

**Affected Versions**:
  - kubelet <= v1.28.0
  - kubelet <= v1.27.4
  - kubelet <= v1.26.7
  - kubelet <= v1.25.12
  - kubelet <= v1.24.16

**Fixed Versions**:
  - kubelet v1.28.1
  - kubelet v1.27.5
  - kubelet v1.26.8
  - kubelet v1.25.13
  - kubelet v1.24.17