* If some versioned directories of the JAR haven't been processed, then these directories must contain presiding (overriding) resource with the same name but with
     * {@code NOT_TRANSFORMED.asBytes()} as body.
     * <p>

	keyPEM, kerr := p.currentKeyContent()
	if kerr != nil {
		return nil, kerr
	}
	currCA := p.caValue.Load().(*authority.CertificateAuthority)
	if bytes.Equal(currCA.RawCert, certPEM) && bytes.Equal(currCA.RawKey, keyPEM) {
		return currCA, nil
	}

	// the bytes weren't equal, so we have to set and then load
	if err := p.setCA(); err != nil {
		return currCA, err
	}

		}
		// When enforcing quotas are enabled, we'll condition this
		// on their being disabled also.
		fsbytes := ibytes
		if fsbytes > 0 {
			fsbytes = -1
		}
		if err = setQuotaOnDir(path, id, fsbytes); err == nil {
			quotaPodMap[id] = internalPodUid
			quotaSizeMap[id] = ibytes
			podQuotaMap[internalPodUid] = id
			dirQuotaMap[path] = id
			dirPodMap[path] = internalPodUid

	HASHUPDATEPARITY

	VADD	V18.S4, V6.S4, V16.S4
	HASHUPDATEPARITY

	VADD	V18.S4, V7.S4, V16.S4
	HASHUPDATEPARITY

	SUB	$64, R3, R3                                  // message length - 64bytes, then compare with 64bytes
	VADD	V2.S4, V0.S4, V0.S4
	VADD	V1.S4, V20.S4, V20.S4
	CBNZ	R3, blockloop

sha1ret:

	VST1.P	[V0.S4], 16(R0)                               // store hash value H(dcba)

            if (hasUnsupportedVersionInJar()) {
                // Every Java version starting from lowestUnsupportedVersion should see this jar as unsupported.
                builder.put(JarUtil.toVersionedPath(lowestUnsupportedVersionInJar, MarkerResource.RESOURCE_NAME), MarkerResource.NOT_TRANSFORMED.asBytes());
            }
        }
    }

		out[i] = left | right
		last = out[i]
	}
	return
}

// creates 16 56-bit subkeys from the original key.
func (c *desCipher) generateSubkeys(keyBytes []byte) {
	feistelBoxOnce.Do(initFeistelBox)

	// apply PC1 permutation to key
	key := byteorder.BeUint64(keyBytes)
	permutedKey := permuteBlock(key, permutedChoice1[:])

	// rotate halves of permuted key according to the rotation schedule

			c := cipherSuitesTLS13[0]
			if got := c.extract(tt.args.newSecret, tt.args.currentSecret); !bytes.Equal(got, tt.want) {
				t.Errorf("cipherSuiteTLS13.extract() = % x, want % x", got, tt.want)
			}
		})
	}
}

func TestKyberDecapsulate(t *testing.T) {
	// From https://pq-crystals.org/kyber/data/kyber-submission-nist-round3.zip

    };


 /// Squash bytes down to ints.
    public static void squashBytesToInts( byte[] inBytes, int inOff, int[] outInts,
                                           int outOff, int intLen ) {

        for ( int i = 0; i < intLen; ++i )
            outInts[outOff + i] =
                ( ( inBytes[inOff + i * 4    ] & 0xff ) << 24 ) |
                ( ( inBytes[inOff + i * 4 + 1] & 0xff ) << 16 ) |

Brian Avery <******@****.***> 1620951743 -0400

// mutate performs several mutations on the provided values.
func (m *mutator) mutate(vals []any, maxBytes int) {
	// TODO(katiehockman): pull some of these functions into helper methods and
	// test that each case is working as expected.
	// TODO(katiehockman): perform more types of mutations for []byte.

	// maxPerVal will represent the maximum number of bytes that each value be
	// allowed after mutating, giving an equal amount of capacity to each line.