}
		case "u":
			z.lastUpdate, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "lastUpdate")
				return
			}
		case "b":
			z.bucket, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "bucket")
				return
			}
		case "flt":
			z.filter, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "filter")
				return
			}
		case "id":

                case ServerMessageBlock.SMB_COM_TRANSACTION2:
                    switch (((SmbComTransaction) request).subCommand & 0xFF) {
                    case SmbComTransaction.NET_SHARE_ENUM:
                    case SmbComTransaction.NET_SERVER_ENUM2:
                    case SmbComTransaction.NET_SERVER_ENUM3:
                    case SmbComTransaction.TRANS_PEEK_NAMED_PIPE:

		}
	case config.DriveSubSys:
		if _, err := drive.LookupConfig(s[config.DriveSubSys][config.Default]); err != nil {
			return err
		}
	case config.PolicyOPASubSys:
		// In case legacy OPA config is being set, we treat it as if the
		// AuthZPlugin is being set.
		subSys = config.PolicyPluginSubSys
		fallthrough
	case config.PolicyPluginSubSys:

            }
            break;
        case ERR_SSN_SRVC:
            result.append("ERR_SSN_SRVC/");
            switch (errorCode) {
            case CONNECTION_REFUSED:
                result.append("Connection refused");
                break;
            case NOT_LISTENING_CALLED:
                result.append("Not listening on called name");
                break;
            case NOT_LISTENING_CALLING:

		case header == nil:
			continue
		}

		name := header.Name
		switch path.Clean(name) {
		case ".", slashSeparator:
			continue
		}

		switch header.Typeflag {
		case tar.TypeDir: // = directory
			if o.ignoreDirs {
				continue
			}
			name = trimLeadingSlash(pathJoin(name, slashSeparator))

	switch tier.Type {
	case madmin.S3:
		d, err = newWarmBackendS3(*tier.S3, tier.Name)
	case madmin.Azure:
		d, err = newWarmBackendAzure(*tier.Azure, tier.Name)
	case madmin.GCS:
		d, err = newWarmBackendGCS(*tier.GCS, tier.Name)
	case madmin.MinIO:
		d, err = newWarmBackendMinIO(*tier.MinIO, tier.Name)
	default:

	switch serviceCode {
	case "ContainerNotFound", "ContainerBeingDeleted":
		err = BucketNotFound{Bucket: bucket}
	case "ContainerAlreadyExists":
		err = BucketExists{Bucket: bucket}
	case "InvalidResourceName":
		err = BucketNameInvalid{Bucket: bucket}
	case "RequestBodyTooLarge":
		err = PartTooBig{}
	case "InvalidMetadata":
		err = UnsupportedMetadata{}
	case "BlobAccessTierNotSupportedForAccountType":

			return
		}
		switch msgp.UnsafeString(field) {
		case "OrgNum":
			z.OrgNum, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "OrgNum")
				return
			}
		case "OrgString":
			z.OrgString, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "OrgString")
				return
			}
		case "Embedded":
			var zb0002 uint32
			zb0002, err = dc.ReadMapHeader()

func ChecksumStringToType(alg string) ChecksumType {
	switch strings.ToUpper(alg) {
	case "CRC32":
		return ChecksumCRC32
	case "CRC32C":
		return ChecksumCRC32C
	case "SHA1":
		return ChecksumSHA1
	case "SHA256":
		return ChecksumSHA256
	case "CRC64NVME":
		// AWS seems to ignore full value, and just assume it.
		return ChecksumCRC64NVME
	case "":
		return ChecksumNone
	}
	return ChecksumInvalid
}

			return
		}
		switch msgp.UnsafeString(field) {
		case "Algorithm":
			z.Algorithm, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Algorithm")
				return
			}
		case "DataBlocks":
			z.DataBlocks, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "DataBlocks")
				return
			}
		case "ParityBlocks":
			z.ParityBlocks, err = dc.ReadInt()