OR	$4096, R4		// 3e00001484781500
	OR	$-1, R4, R5		// 1efcbf0285781500
	OR	$-1, R4			// 1efcbf0284781500
	XOR	$65536, R4, R5		// 1e02001485f81500
	XOR	$4096, R4, R5		// 3e00001485f81500
	XOR	$65536, R4		// 1e02001484f81500
	XOR	$4096, R4		// 3e00001484f81500
	XOR	$-1, R4, R5		// 1efcbf0285f81500
	XOR	$-1, R4			// 1efcbf0284f81500

	// relocation instructions
	MOVW	R4, name(SB)		// 1e00001ac4038029

	OR	$74565, R4, R5			// 5e020014de178d0385781500
	OR	$4097, R4			// 3e000014de07800384781500
	OR	$4097, R4, R5			// 3e000014de07800385781500
	XOR	$74565, R4			// 5e020014de178d0384f81500
	XOR	$74565, R4, R5			// 5e020014de178d0385f81500
	XOR	$4097, R4			// 3e000014de07800384f81500
	XOR	$4097, R4, R5			// 3e000014de07800385f81500

	MOVWP	R5, -32768(R4)			// 1efcff13de931000c5038025
	MOVWP	R5, 32768(R4)			// 1e000010de931000c5038025

	ORW	$65536, R1            // a51a0001
	ORW	$-2, R1               // c01dfffffffe
	XOR	R1, R2                // b9820021
	XOR	R1, R2, R3            // b9e72031
	XOR	$1, R1                // c01700000001
	XOR	$131071, R1           // c0170001ffff
	XOR	$65536, R1            // c01700010000
	XOR	$-2, R1               // c0a1fffffffeb982001a
	XORW	R1, R2                // 1721
	XORW	R1, R2, R3            // b9f72031

X6; \ XOR f, g, X5; \ XOR X8, X6; \ AND e, X5; \ ADD X6, h; \ XOR g, X5; \ ADD h, X5 // Calculate T2 in X6. // T2 = BIGSIGMA0(a) + Maj(a, b, c) // BIGSIGMA0(x) = ROTR(2,x) XOR ROTR(13,x) XOR ROTR(22,x) // Maj(x, y, z) = (x AND y) XOR (x AND z) XOR (y AND z) // = ((y XOR z) AND x) XOR (y AND z) #define SHA256T2(a, b, c) \ RORW $2, a, X6; \ RORW $13, a, X7; \ RORW $22, a, X8; \ XOR X7, X6; \ XOR b, c, X9; \ AND b, c, X7; \ AND a, X9; \ XOR X8, X6; \ XOR X7, X9; \ ADD X9, X6 // Calculate T1 and T2, then...

f, g, X5; \ XOR X8, X6; \ AND e, X5; \ ADD X6, h; \ XOR g, X5; \ ADD h, X5 // Calculate T2 in X6. // T2 = BIGSIGMA0(a) + Maj(a, b, c) // BIGSIGMA0(x) = ROTR(28,x) XOR ROTR(34,x) XOR ROTR(39,x) // Maj(x, y, z) = (x AND y) XOR (x AND z) XOR (y AND z) // = ((y XOR z) AND x) XOR (y AND z) #define SHA512T2(a, b, c) \ ROR $28, a, X6; \ ROR $34, a, X7; \ ROR $39, a, X8; \ XOR X7, X6; \ XOR b, c, X9; \ AND b, c, X7; \ AND a, X9; \ XOR X8, X6; \ XOR X7, X9; \ ADD X9, X6 // Calculate T1 and T2, then e = d +...

	AND	$1, X5					// 93f21200
	OR	X6, X5, X7				// b3e36200
	OR	X5, X6					// 33635300
	OR	$1, X5, X6				// 13e31200
	OR	$1, X5					// 93e21200
	XOR	X6, X5, X7				// b3c36200
	XOR	X5, X6					// 33435300
	XOR	$1, X5, X6				// 13c31200
	XOR	$1, X5					// 93c21200

	AUIPC	$0, X10					// 17050000
	AUIPC	$0, X11					// 97050000
	AUIPC	$1, X10					// 17150000
	AUIPC	$-524288, X15				// 97070080

        assertEquals(sampleSize, uniqueCounters.size(), "All nonces should have unique values");

        // Verify that nonces have good entropy (not predictable)
        // With SecureRandom + counter XOR, they should all be different
        Set<String> uniqueNonces = new HashSet<>();
        for (byte[] nonce : nonces) {
            uniqueNonces.add(bytesToHex(nonce));
        }

		Certs:      []madmin.TLSCert{},
	}

	if globalIsTLS {
		for _, c := range globalPublicCerts {
			check := xxh3.Hash(c.RawIssuer)
			check ^= xxh3.Hash(c.RawSubjectPublicKeyInfo)
			// We XOR, so order doesn't matter.
			for _, v := range c.DNSNames {
				check ^= xxh3.HashString(v)
			}
			for _, v := range c.EmailAddresses {
				check ^= xxh3.HashString(v)
			}

/    quotient               integers, floats, complex values
%    remainder              integers

&    bitwise AND            integers
|    bitwise OR             integers
^    bitwise XOR            integers
&^   bit clear (AND NOT)    integers

<<   left shift             integer << integer >= 0
>>   right shift            integer >> integer >= 0
</pre>