if (dr != null) {
            String service = null;

            if (request != null) {
                switch( request.command ) {
                    case ServerMessageBlock.SMB_COM_TRANSACTION:
                    case ServerMessageBlock.SMB_COM_TRANSACTION2:
                        switch( ((SmbComTransaction)request).subCommand & 0xFF ) {
                            case SmbComTransaction.TRANS2_GET_DFS_REFERRAL:

    }
    public boolean equals( Object obj ) {
        return obj instanceof ServerMessageBlock && ((ServerMessageBlock)obj).mid == mid;
    }
    public String toString() {
        String c;
        switch( command ) {
            case SMB_COM_NEGOTIATE:
                c = "SMB_COM_NEGOTIATE";
                break;
            case SMB_COM_SESSION_SETUP_ANDX:
                c = "SMB_COM_SESSION_SETUP_ANDX";

        return obj instanceof ServerMessageBlock2 && ( (ServerMessageBlock2) obj ).mid == this.mid;
    }


    @Override
    public String toString () {
        String c;
        switch ( this.command ) {

        case SMB2_NEGOTIATE:
            c = "SMB2_NEGOTIATE";
            break;
        case SMB2_SESSION_SETUP:
            c = "SMB2_SESSION_SETUP";
            break;

	if len(pools) == 0 {
		return layout, errInvalidArgument
	}

	for _, list := range pools {
		var endpointsList endpointsList

		for _, arg := range list.args {
			switch {
			case ellipses.HasList(arg):
				patterns, err := ellipses.FindListPatterns(arg)
				if err != nil {
					return layout, err
				}
				for _, exp := range patterns.Expand() {
					for _, ep := range exp {

	}
}

func (p *proxyStatsCache) inc(bucket string, api replProxyAPI, isErr bool) {
	p.Lock()
	defer p.Unlock()
	v, ok := p.bucketStats[bucket]
	if !ok {
		v = ProxyMetric{}
	}
	switch api {
	case putObjectTaggingAPI:
		if !isErr {
			atomic.AddUint64(&v.PutTagTotal, 1)
			atomic.AddUint64(&p.srProxyStats.PutTagTotal, 1)
		} else {
			atomic.AddUint64(&v.PutTagFailedTotal, 1)

			// here if the connection is still alive.
			// note that unlike tcp connections, reading is a good enough test here.
			_, err := conn.readMessage(time.Second / 100)
			switch {
			case !errors.Is(err, os.ErrDeadlineExceeded):
				log.Debugf("ztunnel keepalive failed: %v", err)
				if errors.Is(err, io.EOF) {
					log.Debug("ztunnel EOF")
					return nil
				}
				return err

		return -1
	}
	keyCrc := crc32.Checksum([]byte(key), crc32.IEEETable)
	return int(keyCrc % uint32(cardinality))
}

func hashKey(algo string, key string, cardinality int, id [16]byte) int {
	switch algo {
	case formatErasureVersionV2DistributionAlgoV1:
		return crcHashMod(key, cardinality)
	case formatErasureVersionV3DistributionAlgoV2, formatErasureVersionV3DistributionAlgoV3:
		return sipHashMod(key, cardinality, id)

                        "To see the full stack trace of the errors, re-run Maven with the '{}' switch",
                        MessageUtils.builder().strong("-e"));
            }
            if (!slf4jLogger.isDebugEnabled()) {
                slf4jLogger.error(
                        "Re-run Maven using the '{}' switch to enable verbose output",
                        MessageUtils.builder().strong("-X"));
            }

	if err != nil {
		return err
	}

	cfReader := bytes.NewReader(rd)

	cv := config.ServerConfigVersion{}
	if err = yaml.Unmarshal(rd, &cv); err != nil {
		return err
	}

	switch cv.Version {
	case "v1", "v2":
	default:
		return fmt.Errorf("unexpected version: %s", cv.Version)
	}

	cfCommon := config.ServerConfigCommon{}
	if err = yaml.Unmarshal(rd, &cfCommon); err != nil {

    }

    default void setResultCollapsed(final boolean value) {
        setSystemPropertyAsBoolean(Constants.RESULT_COLLAPSED_PROPERTY, value);
    }

    default boolean isResultCollapsed() {
        return switch (getFesenType()) {
        case Constants.FESEN_TYPE_CLOUD, Constants.FESEN_TYPE_AWS -> false;
        default -> getSystemPropertyAsBoolean(Constants.RESULT_COLLAPSED_PROPERTY, false);
        };
    }