*/
        public String getNameidNameQualifier() {
            return nameidNameQualifier;
        }

        /**
         * Gets the name ID SP name qualifier.
         * @return The name ID SP name qualifier.
         */
        public String getNameidSPNameQualifier() {
            return nameidSPNameQualifier;
        }

        @Override
        public String toString() {

R11, 328(SP) MOVQ R12, 336(SP) MOVQ R13, 344(SP) MOVQ 64(SP), R14 MOVQ 72(SP), R15 MOVQ 80(SP), DI MOVQ 88(SP), SI CALL p256MulInternal(SB) MOVQ R10, 224(SP) MOVQ R11, 232(SP) MOVQ R12, 240(SP) MOVQ R13, 248(SP) MOVQ 288(SP), R10 MOVQ 296(SP), R11 MOVQ 304(SP), R12 MOVQ 312(SP), R13 CALL p256MulInternal(SB) MOVQ 128(SP), R14 MOVQ 136(SP), R15 MOVQ 144(SP), DI MOVQ 152(SP), SI CALL p256MulInternal(SB) MOVQ R10, 256(SP) MOVQ R11, 264(SP) MOVQ R12, 272(SP) MOVQ R13, 280(SP) MOVQ 32(SP), R14 MOVQ 40(SP),...

	VRANGEPD $11, 17(SP)(BP*4), X31, K2, X12           // 6273850250a4ac110000000b
	VRANGEPD $11, X24, X23, K2, X16                    // 6283c50250c00b
	VRANGEPD $11, X14, X23, K2, X16                    // 62c3c50250c60b
	VRANGEPD $11, X0, X23, K2, X16                     // 62e3c50250c00b
	VRANGEPD $11, 17(SP)(BP*8), X23, K2, X16           // 62e3c5025084ec110000000b

	VGF2P8AFFINEQB $82, 17(SP)(BP*2), X21, K1, X15     // 6273d501cebc6c1100000052
	VGF2P8AFFINEQB $82, -7(DI)(R8*4), X21, K1, X15     // 6233d501cebc87f9ffffff52
	VGF2P8AFFINEQB $82, X22, X0, K1, X15               // 6233fd09cefe52
	VGF2P8AFFINEQB $82, X7, X0, K1, X15                // 6273fd09ceff52
	VGF2P8AFFINEQB $82, X19, X0, K1, X15               // 6233fd09cefb52

TEXT asmtest(SB),DUPOK|NOSPLIT,$0
	// Instructions that were encoded with BYTE sequences.
	// Included to simplify validation of CL that fixed that.
	MOVQ (AX), M0  // 0f6f00
	MOVQ M0, 8(SP) // 0f7f442408
	MOVQ 8(SP), M0 // 0f6f442408
	MOVQ M0, (AX)  // 0f7f00
	MOVQ M0, (BX)  // 0f7f03
	// On non-64bit arch, Go asm allowed uint32 offsets instead of int32.
	// These tests check that property for backwards-compatibility.

			nf, err = tryReadFull(zeroReader{}, bf)
		}
		b = b[nf:]
		sr.pos += int64(nf)
		if sr.pos >= holeEnd && len(sr.sp) > 1 {
			sr.sp = sr.sp[1:] // Ensure last fragment always remains
		}
	}

	n = len(b0) - len(b)
	switch {
	case err == io.EOF:
		return n, errMissData // Less data in dense file than sparse file
	case err != nil:
		return n, err

		return nil, err
	}
	return ekvs, nil
}

func readFromSecret(sp string) (string, error) {
	// Supports reading path from docker secrets, filename is
	// relative to /run/secrets/ position.
	if isFile(pathJoin("/run/secrets/", sp)) {
		sp = pathJoin("/run/secrets/", sp)
	}
	credBuf, err := os.ReadFile(sp)
	if err != nil {
		if os.IsNotExist(err) { // ignore if file doesn't exist.
			return "", nil

            if (paramList != null) {
                char sp;
                if (url.indexOf('?') == -1) {
                    sp = '?';
                } else {
                    sp = '&';
                }
                final StringBuilder urlBuf = new StringBuilder(100);
                for (final String param : paramList) {
                    urlBuf.append(sp).append(param);
                    if (sp == '?') {

	MOV	$8(SP), (X5)			// ERROR "address load must target register"
	MOVB	$8(SP), X5			// ERROR "unsupported address load"
	MOVH	$8(SP), X5			// ERROR "unsupported address load"
	MOVW	$8(SP), X5			// ERROR "unsupported address load"
	MOVF	$8(SP), X5			// ERROR "unsupported address load"
	MOV	$1234, 0(SP)			// ERROR "constant load must target register"
	MOV	$1234, 8(SP)			// ERROR "constant load must target register"

	VPLZCNTD 17(SP)(BP*8), K3, Z3                      // 62f27d4b449cec11000000
	VPLZCNTD 17(SP)(BP*4), K3, Z3                      // 62f27d4b449cac11000000
	VPLZCNTD Z21, K3, Z0                               // 62b27d4b44c5
	VPLZCNTD Z13, K3, Z0                               // 62d27d4b44c5
	VPLZCNTD 17(SP)(BP*8), K3, Z0                      // 62f27d4b4484ec11000000