if ifNoneMatchETagHeader != "" {
		if isETagEqual(objInfo.ETag, ifNoneMatchETagHeader) {
			// Do not care If-Modified-Since, Because:
			// 1. If If-Modified-Since condition evaluates to true.
			//  If both of the If-None-Match and If-Modified-Since headers are present in the request as follows:
			// 	If-None-Match condition evaluates to false , and;
			//  If-Modified-Since condition evaluates to true ;

		if err != nil {
			return
		}
	} else {
		err = en.WriteBool(*z.Disable)
		if err != nil {
			err = msgp.WrapError(err, "Disable")
			return
		}
	}
	// write "Batch"
	err = en.Append(0xa5, 0x42, 0x61, 0x74, 0x63, 0x68)
	if err != nil {
		return
	}
	if z.Batch == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = en.WriteInt(*z.Batch)

func (r *metacacheReader) readN(n int, inclDeleted, inclDirs, inclVersions bool, prefix string) (metaCacheEntriesSorted, error) {
	r.checkInit()
	if n == 0 {
		return metaCacheEntriesSorted{}, nil
	}
	if r.err != nil {
		return metaCacheEntriesSorted{}, r.err
	}

	var res metaCacheEntries
	if n > 0 {
		res = make(metaCacheEntries, 0, n)
	}
	if prefix != "" {

	if err != nil {
		return
	}
	err = en.WriteFloat64(z.CurrentBandwidthInBytesPerSecond)
	if err != nil {
		err = msgp.WrapError(err, "CurrentBandwidthInBytesPerSecond")
		return
	}
	// write "lt"
	err = en.Append(0xa2, 0x6c, 0x74)
	if err != nil {
		return
	}
	if z.XferRateLrg == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {

	var zb0004 uint32
	zb0004, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if (*z) == nil {
		(*z) = make(localLockMap, zb0004)
	} else if len((*z)) > 0 {
		clear((*z))
	}
	var field []byte
	_ = field
	for zb0004 > 0 {
		zb0004--
		var zb0001 string
		zb0001, err = dc.ReadString()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}

	if err != nil {
		return
	}
	err = en.WriteTime(z.LastUpdate)
	if err != nil {
		err = msgp.WrapError(err, "LastUpdate")
		return
	}
	// write "dec"
	err = en.Append(0xa3, 0x64, 0x65, 0x63)
	if err != nil {
		return
	}
	if z.Decommission == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.Decommission.EncodeMsg(en)
		if err != nil {

	if err != nil {
		return
	}
	err = en.WriteString(z.APIVersion)
	if err != nil {
		err = msgp.WrapError(err, "APIVersion")
		return
	}
	// write "Bucket"
	err = en.Append(0xa6, 0x42, 0x75, 0x63, 0x6b, 0x65, 0x74)
	if err != nil {
		return
	}
	err = en.WriteString(z.Bucket)
	if err != nil {
		err = msgp.WrapError(err, "Bucket")
		return
	}

	if dir == "" {
		dir = getDefaultDir()
	}

	if dir == "" {
		if !dirSet {
			return nil, fmt.Errorf("missing option must be provided")
		}
		return nil, fmt.Errorf("provided option cannot be empty")
	}

	// Disallow relative paths, figure out absolute paths.
	dirAbs, err := filepath.Abs(dir)
	if err != nil {
		return nil, err
	}
	err = mkdirAllIgnorePerm(dirAbs)
	if err != nil {

	return func(db *gorm.DB) {
		if db.Error != nil {
			return
		}

		if db.Statement.Schema != nil {
			for _, c := range db.Statement.Schema.UpdateClauses {
				db.Statement.AddClause(c)
			}
		}

		if db.Statement.SQL.Len() == 0 {
			db.Statement.SQL.Grow(180)
			db.Statement.AddClauseIfNotExists(clause.Update{})
			if _, ok := db.Statement.Clauses["SET"]; !ok {

	}
}

func (ri *batchJobInfo) countItem(size int64, dmarker, success bool, attempt int) {
	if ri == nil {
		return
	}
	ri.Attempts++
	if success {
		if dmarker {
			ri.DeleteMarkers++
		} else {
			ri.Objects++
			ri.BytesTransferred += size
		}
		if attempt > 1 {
			if dmarker {
				ri.DeleteMarkersFailed--
			} else {
				ri.ObjectsFailed--
				ri.BytesFailed += size