err = dc.ReadNil()
				if err != nil {
					err = msgp.WrapError(err, "DeleteMarker")
					return
				}
				z.DeleteMarker = nil
			} else {
				if z.DeleteMarker == nil {
					z.DeleteMarker = new(xlMetaV2DeleteMarker)
				}
				err = z.DeleteMarker.DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "DeleteMarker")
					return
				}
			}
			zb0001Mask |= 0x4
		case "v":

			// on the pool being batch replicated from source.
			Versioned:          true,
			MTime:              srcObjInfo.ModTime,
			DeleteMarker:       srcObjInfo.DeleteMarker,
			ReplicationRequest: true,
		})
		return err
	}

	opts := ObjectOptions{
		VersionID:    srcObjInfo.VersionID,
		MTime:        srcObjInfo.ModTime,
		PreserveETag: srcObjInfo.ETag,

			case replication.Replica:
				ventry.DeleteMarker.MetaSys[ReservedMetadataPrefixLower+ReplicaStatus] = []byte(fi.ReplicationState.ReplicaStatus)
				ventry.DeleteMarker.MetaSys[ReservedMetadataPrefixLower+ReplicaTimestamp] = []byte(fi.ReplicationState.ReplicaTimeStamp.UTC().Format(time.RFC3339Nano))
			default:

		//
		// Regression introduced by #14555 was reintroduced in #15564
		if versionFound {
			if !goi.VersionPurgeStatus.Empty() {
				deleteMarker = false
			} else if !goi.DeleteMarker { // implies a versioned delete of object
				deleteMarker = false
			}
		}
	}

	modTime := opts.MTime
	if opts.MTime.IsZero() {
		modTime = UTCNow()
	}
	fvID := mustGetUUID()

		case "ReplicaStatus":
			err = z.ReplicaStatus.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "ReplicaStatus")
				return
			}
		case "DeleteMarker":
			z.DeleteMarker, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "DeleteMarker")
				return
			}
		case "ReplicationTimeStamp":
			z.ReplicationTimeStamp, err = dc.ReadTime()
			if err != nil {

			z.IsLatest, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "IsLatest")
				return
			}
		case "DeleteMarker":
			z.DeleteMarker, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "DeleteMarker")
				return
			}
		case "TransitionedObject":
			bts, err = z.TransitionedObject.UnmarshalMsg(bts)
			if err != nil {

		}

		// No object exists or its a delete marker,
		// check objInfo to confirm.
		if pinfo.ObjInfo.DeleteMarker && pinfo.ObjInfo.Name != "" {
			return pinfo, noReadQuorumPools, nil
		}
	}
	if opts.ReplicationRequest && opts.DeleteMarker && defPool.Index >= 0 {
		// If the request is a delete marker replication request, return a default pool
		// in cases where the object does not exist.

		},
		{
			IsTruncated: false,
			Objects: []ObjectInfo{
				{
					Name:         "unique/folder/",
					DeleteMarker: true,
				},
				{
					Name:         "unique/folder/",
					DeleteMarker: false,
				},
				{
					Name:         "unique/folder/1.txt",
					DeleteMarker: false,
				},
			},
		},
	}

	testCases := []struct {
		// Inputs to ListObjects.
		bucketName string

		}

		eventName := event.ObjectRemovedDelete
		objInfo := ObjectInfo{
			Name:         dobj.ObjectName,
			VersionID:    dobj.VersionID,
			DeleteMarker: dobj.DeleteMarker,
		}

		if objInfo.DeleteMarker {
			objInfo.VersionID = dobj.DeleteMarkerVersionID
			eventName = event.ObjectRemovedDeleteMarkerCreated
		}

		sendEvent(eventArgs{
			EventName:    eventName,

			objPresent = true
			if oi.DeleteMarker {
				sizeS.deleteMarkers++
			}
			if oi.VersionID != "" && sz == actualSz {
				sizeS.versions++
			}
			sizeS.totalSize += sz

			// Skip tier accounting if object version is a delete-marker or a free-version
			// tracking deleted transitioned objects
			switch {
			case oi.DeleteMarker, oi.TransitionedObject.FreeVersion:
				return
			}