}
        } while (dr != start);
        throw last;
    }

    /**
     * @param loc
     * @param addr
     * @param trans
     * @param t
     * @throws CIFSException
     */
    private SmbTreeImpl connectTree(final SmbResourceLocatorImpl loc, final String addr, final String share,
            final SmbTransportInternal trans, final SmbTreeImpl t, final DfsReferralData referral) throws CIFSException {

		loaded = true
		for i := 0; i < v.Len(); i++ {
			if !loadOrStoreVisitMap(visitMap, v.Index(i)) {
				loaded = false
			}
		}
	case reflect.Struct, reflect.Interface:
		if v.CanAddr() {
			p := v.Addr()
			if _, ok := (*visitMap)[p]; ok {
				return true
			}
			(*visitMap)[p] = true
		}
	}

	return

pkg net/http, type Transport struct, HTTP2 *HTTP2Config #67813
pkg net/http, type Transport struct, Protocols *Protocols #67814
pkg net/netip, method (Addr) AppendBinary([]uint8) ([]uint8, error) #62384
pkg net/netip, method (Addr) AppendText([]uint8) ([]uint8, error) #62384
pkg net/netip, method (AddrPort) AppendBinary([]uint8) ([]uint8, error) #62384

	anonAddr := func(addr string) string {
		if anonParam != anonymizeStrict {
			return addr
		}
		newAddr, found := hostAnonymizer[addr]
		if found {
			return newAddr
		}

		// If we reach here, it means that the given addr doesn't contain any of the hosts.
		// Return it as is. Can happen for drive paths in non-distributed mode
		return addr
	}

		{"DATA", "·B(SB)/4,$0", ""},
		{"DATA", "·C(SB)/5,$0", "bad int size for DATA argument: 5"},
		{"DATA", "·D(SB)/5,$0.0", "bad float size for DATA argument: 5"},
		{"DATA", "·E(SB)/4,$·A(SB)", "bad addr size for DATA argument: 4"},
		{"DATA", "·F(SB)/8,$·A(SB)", ""},
		{"DATA", "·G(SB)/5,$\"abcde\"", ""},
		{"GLOBL", "", "expect two or three operands for GLOBL"},

    }

    @Override
    public int getLocalPort() {
        return super.getLocalPort();
    }

    @Override
    public String toString() {
        return "NbtSocket[addr=" + address + ",port=" + super.getPort() + ",localport=" + super.getLocalPort() + "]";
    }

    private void connect() throws IOException {
        final byte[] buffer = new byte[BUFFER_SIZE];
        int type;

	"W8":  loong64.ARNG_8W,
	"V4":  loong64.ARNG_4V,
	"Q2":  loong64.ARNG_2Q,
}

// Loong64RegisterExtension constructs an Loong64 register with extension or arrangement.
func Loong64RegisterExtension(a *obj.Addr, ext string, reg, num int16, isAmount, isIndex bool) error {
	var ok bool
	var arng_type int16
	var simd_type int16

	switch {
	case reg >= loong64.REG_V0 && reg <= loong64.REG_V31:
		simd_type = loong64.LSX

pkg net, type Listener interface { Accept, Addr, Close }
pkg net, type Listener interface, Accept() (Conn, error)
pkg net, type Listener interface, Addr() Addr
pkg net, type Listener interface, Close() error
pkg net, type MX struct
pkg net, type MX struct, Host string
pkg net, type MX struct, Pref uint16
pkg net, type OpError struct
pkg net, type OpError struct, Addr Addr
pkg net, type OpError struct, Err error

            bind.decode_out(mockBuffer);

            // Then
            verify(mockBuffer, times(5)).dec_ndr_short(); // max xmit, max recv, addr len, result, final short
            verify(mockBuffer).dec_ndr_long(); // assoc group
            verify(mockBuffer).advance(10); // secondary addr (length 10)
            verify(mockBuffer, times(2)).align(4); // alignment calls
            verify(mockBuffer).dec_ndr_small(); // num results

    static NbtAddress[] dc_list = null;
    static long dc_list_expiration;
    static int dc_list_counter;

    private static NtlmChallenge interrogate(final NbtAddress addr) throws SmbException {
        final UniAddress dc = new UniAddress(addr);
        final SmbTransport trans = SmbTransport.getSmbTransport(dc, 0);
        if (USERNAME == null) {
            trans.connect();
            if (LogStream.level >= 3) {