switch oid[3] {
			case 3:
				values = append(values, fmt.Sprintf("CN=%s", name.Value))
			case 6:
				values = append(values, fmt.Sprintf("C=%s", name.Value))
			case 8:
				values = append(values, fmt.Sprintf("ST=%s", name.Value))
			case 10:
				values = append(values, fmt.Sprintf("O=%s", name.Value))
			case 11:
				values = append(values, fmt.Sprintf("OU=%s", name.Value))
			default:

	if err != nil {
		return nil, err
	}

	if err = lockFile(syscall.Handle(f.Fd()), lockType); err != nil {
		f.Close()
		return nil, err
	}

	st, err := os.Stat(path)
	if err != nil {
		f.Close()
		return nil, err
	}

	if st.IsDir() {
		f.Close()
		return nil, &os.PathError{
			Op:   "open",
			Path: path,
			Err:  syscall.EISDIR,
		}
	}

	return &LockedFile{File: f}, nil
}

                resolveOrder[2] = RESOLVER_BCAST;
            }
        } else {
            int[] tmp = new int[3];
            StringTokenizer st = new StringTokenizer( RO, "," );
            int i = 0;
            while( st.hasMoreTokens() ) {
                String s = st.nextToken().trim();
                if( s.equalsIgnoreCase( "LMHOSTS" )) {
                    tmp[i++] = RESOLVER_LMHOSTS;

				err = msgp.WrapError(err, "JobID")
				return
			}
		case "jt":
			z.JobType, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "JobType")
				return
			}
		case "st":
			z.StartTime, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "StartTime")
				return
			}
		case "lu":
			z.LastUpdate, err = dc.ReadTime()
			if err != nil {

			peersLogOnceIf(logger.SetReqInfo(ctx, reqInfo), nErr.Err, nErr.Host.String())
		}
	}
	if st := globalReplicationStats.Load(); st != nil {
		bucketStats = append(bucketStats, BucketStats{
			ReplicationStats: st.Get(bucketName),
			QueueStats:       ReplicationQueueStats{Nodes: []ReplQNodeStats{st.getNodeQueueStats(bucketName)}},
			ProxyStats:       st.getProxyStats(bucketName),
		})
	}
	return bucketStats
}

                                  </ExcludedPrefixes>
                                  <ExcludedPrefixes>
                                    <Prefix>path/to/my/workload/_staging/st/</Prefix>
                                  </ExcludedPrefixes>
                                  <ExcludedPrefixes>
                                    <Prefix>path/to/my/workload/_staging/uv/</Prefix>

        try ( SmbSessionImpl sess = getSession();
              SmbTransportImpl transport = sess.getTransport() ) {
            synchronized ( transport ) {
                int st = this.connectionState.getAndSet(3);
                if ( st == 2 ) {
                    long l = this.usageCount.get();
                    if ( ( inUse && l != 1 ) || ( !inUse && l > 0 ) ) {

		return buf.Bytes(), nil
	}

	fmt.Println("{")

	hasWritten := false
	var r io.Reader
	var sz int64
	f, e := os.Open(downloadPath)
	if e != nil {
		return e
	}
	if st, e := f.Stat(); e == nil {
		sz = st.Size()
	}
	defer f.Close()
	r = f

	zr, e := zip.NewReader(r.(io.ReaderAt), sz)
	if e != nil {
		return e
	}
	for _, file := range zr.File {

./mc mb minio3/bucket --insecure
./mc cp --insecure --enc-kms minio3/bucket=minio3-default-key /tmp/data/encrypted minio3/bucket/x
sleep 10
st=$(./mc stat --json --no-list --insecure minio3/bucket/x | jq -r .replicationStatus)
if [ "${st}" != "FAILED" ]; then
	echo "BUG: Replication succeeded when kms key is different"
	exit_1
fi

	objInfo.ReplicationStatus = fi.ReplicationStatus()
	if objInfo.ReplicationStatus.Empty() { // overlay x-amx-replication-status if present for replicas
		if st, ok := fi.Metadata[xhttp.AmzBucketReplicationStatus]; ok && st == string(replication.Replica) {
			objInfo.ReplicationStatus = replication.StatusType(st)
		}
	}
	objInfo.VersionPurgeStatus = fi.VersionPurgeStatus()

	objInfo.TransitionedObject = TransitionedObject{