for i := range tagKeys {
		obj := ObjectOpts{
			Name:        "obj",
			VersionID:   verIDs[i],
			ModTime:     curModTime.Add(time.Duration(-i) * time.Second),
			UserTags:    fmt.Sprintf("%s=minio", tagKeys[i]),
			NumVersions: len(verIDs),
		}
		if i == 0 {
			obj.IsLatest = true
		} else {
			obj.SuccessorModTime = curModTime.Add(time.Duration(-i+1) * time.Second)
		}
		objs = append(objs, obj)
	}

			}
		} else {
			if !inclFreeVersions {
				fivs.Versions[n] = fi
			}
			n++
		}
	}
	if !inclFreeVersions {
		fivs.Versions = fivs.Versions[:n]
	}
	// Update numversions
	for i := range fivs.Versions {
		fivs.Versions[i].NumVersions = n
	}
	return fivs, nil
}

func getAllFileInfoVersions(xlMetaBuf []byte, volume, path string, allParts bool) (FileInfoVersions, error) {
	var versions []FileInfo
	var err error

			}
		case "no":
			z.NumObjects, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "NumObjects")
				return
			}
		case "nv":
			z.NumVersions, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "NumVersions")
				return
			}
		case "bs":
			z.Bytes, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "Bytes")
				return
			}

			Distribution: []int{1, 2, 3, 4, 5, 6, 7, 8},
			Checksums: []ChecksumInfo{{
				PartNumber: 1,
				Algorithm:  HighwayHash256S,
				Hash:       nil,
			}},
		},
		MarkDeleted:      false,
		NumVersions:      1,
		SuccessorModTime: time.Time{},
	}
	// Add a version with local content
	fatalErr(xl.AddVersion(fi))
	report()

	// Add null version with tiered content
	tierfi := fi
	tierfi.VersionID = ""

	for tier, st := range ats.Tiers {
		stats[tier] = madmin.TierStats{
			TotalSize:   st.TotalSize,
			NumVersions: st.NumVersions,
			NumObjects:  st.NumObjects,
		}
	}
}

// tierStats holds per-tier stats of a remote tier.
type tierStats struct {
	TotalSize   uint64 `msg:"ts"`
	NumVersions int    `msg:"nv"`
	NumObjects  int    `msg:"no"`
}

func (ts tierStats) add(u tierStats) tierStats {

type ObjectOpts struct {
	Name             string
	UserTags         string
	ModTime          time.Time
	Size             int64
	VersionID        string
	IsLatest         bool
	DeleteMarker     bool
	NumVersions      int
	SuccessorModTime time.Time
	TransitionStatus string
	RestoreOngoing   bool
	RestoreExpires   time.Time
	// to determine if object is locked due to retention
	UserDefined        map[string]string

	defer func() {
		if !ok {
			return
		}

		if lcEvent.Action != lifecycle.NoneAction {
			numVersions := uint64(1)
			if lcEvent.Action.DeleteAll() {
				numVersions = uint64(obj.NumVersions)
			}
			timeILM(numVersions)
		}
	}()

	dobj, err = objLayer.DeleteObject(ctx, obj.Bucket, encodeDirObject(obj.Name), opts)
	if err != nil {

				DeleteMarker:     tc.isDelMarker,
				IsLatest:         !tc.isNoncurrent,
				SuccessorModTime: tc.objectSuccessorModTime,
				VersionID:        tc.versionID,
			}
			opts.NumVersions = 1
			if tc.hasManyVersions {
				opts.NumVersions = 2 // at least one noncurrent version
			}
			if res := lc.Eval(opts); res.Action != tc.expectedAction {
				t.Fatalf("Expected action: `%v`, got: `%v`", tc.expectedAction, res.Action)
			}

			VariableLabels: map[string]string{"tier": tier},
		})
		metrics = append(metrics, MetricV2{
			Description:    getClusterTransitionedVersionsMD(),
			Value:          float64(st.NumVersions),
			VariableLabels: map[string]string{"tier": tier},
		})
	}

	return metrics

	return NewGetObjectReaderFromReader(io.LimitReader(r, length), ObjectInfo{
		Bucket:      bucket,
		Name:        object,
		Size:        r.Size(),
		IsLatest:    true,
		ContentType: string(mimeXML),
		NumVersions: 1,
		ETag:        etag,
		ModTime:     UTCNow(),
	}, opts)