func (h *healSequence) hasEnded() bool {
	h.mutex.RLock()
	defer h.mutex.RUnlock()
	// background heal never ends
	if h.clientToken == bgHealingUUID {
		return false
	}
	return !h.endTime.IsZero()
}

// stops the heal sequence - safe to call multiple times.
func (h *healSequence) stop() {
	h.cancelCtx()
}

// pushHealResultItem - pushes a heal result item for consumption in

			}
		}
		if v, ok := h.PAXRecords[paxKey]; ok && v == strconv.FormatInt(n, 10) {
			paxHdrs[paxKey] = v
		}
	}
	verifyTime := func(ts time.Time, size int, name, paxKey string) {
		if ts.IsZero() {
			return // Always okay
		}
		if !fitsInBase256(size, ts.Unix()) {
			whyNoGNU = fmt.Sprintf("GNU cannot encode %s=%v", name, ts)
			format.mustNotBe(FormatGNU)
		}
		isMtime := paxKey == paxMtime

	if f.Name != ft.Name {
		t.Errorf("name=%q, want %q", f.Name, ft.Name)
	}
	if !ft.Modified.IsZero() && !equalTimeAndZone(f.Modified, ft.Modified) {
		t.Errorf("%s: Modified=%s, want %s", f.Name, f.Modified, ft.Modified)
	}
	if !ft.ModTime.IsZero() && !equalTimeAndZone(f.ModTime(), ft.ModTime) {
		t.Errorf("%s: ModTime=%s, want %s", f.Name, f.ModTime(), ft.ModTime)
	}

			ts := int64(fieldBuf.uint32()) // ModTime since Unix epoch
			modified = time.Unix(ts, 0)
		}
	}

	msdosModified := msDosTimeToTime(f.ModifiedDate, f.ModifiedTime)
	f.Modified = msdosModified
	if !modified.IsZero() {
		f.Modified = modified.UTC()

		// If legacy MS-DOS timestamps are set, we can use the delta between
		// the legacy and extended versions to estimate timezone offset.
		//

	}()

	var wg sync.WaitGroup
	diskMap := s.getDiskMap()
	for _, endpoint := range s.endpoints.Endpoints {
		cdisk := diskMap[endpoint]
		if cdisk != nil && cdisk.IsOnline() {
			if s.lastConnectDisksOpTime.IsZero() {
				continue
			}

			// An online-disk means its a valid disk but it may be a re-connected disk
			// we verify that here based on LastConn(), however we make sure to avoid

	return PolicyDoc{
		Version: 1,
		Policy:  p,
	}
}

func (d *PolicyDoc) update(p policy.Policy) {
	now := UTCNow().Round(time.Millisecond)
	d.UpdateDate = now
	if d.CreateDate.IsZero() {
		d.CreateDate = now
	}
	d.Policy = p
}

// parseJSON parses both the old and the new format for storing policy
// definitions.
//

// SUB(R<T-S1) // R = T-S1 p256SubInternal(RH,RL,T1,T0,S1H,S1L) // if R == 0 or R^P == 0 then ret=ret else ret=0 // clobbers T1H and T1L MOVD $0, ISZERO MOVD $1, TRUE VZERO ZER VO RL, RH, T1H VCEQGS ZER, T1H, T1H MOVDEQ TRUE, ISZERO VX RL, PL, T1L VX RH, PH, T1H VO T1L, T1H, T1H VCEQGS ZER, T1H, T1H MOVDEQ TRUE, ISZERO AND ret+24(FP), ISZERO MOVD ISZERO, ret+24(FP) // X=H ; Y=H ; MUL; T- // T1 = H*H VLR HL, X0 VLR HH, X1 VLR HL, Y0 VLR HH, Y1 CALL p256SqrInternal<>(SB) // X- ; Y=T ; MUL; T2=T // T2...

// SUB(R<T-S1) // R = T-S1 p256SubInternal(RH,RL,T1,T0,S1H,S1L) // if R == 0 or R^P == 0 then ret=ret else ret=0 // clobbers T1H and T1L MOVD $0, ISZERO MOVD $1, TRUE VZERO ZER VO RL, RH, T1H VCEQGS ZER, T1H, T1H MOVDEQ TRUE, ISZERO VX RL, PL, T1L VX RH, PH, T1H VO T1L, T1H, T1H VCEQGS ZER, T1H, T1H MOVDEQ TRUE, ISZERO AND ret+24(FP), ISZERO MOVD ISZERO, ret+24(FP) // X=H ; Y=H ; MUL; T- // T1 = H*H VLR HL, X0 VLR HH, X1 VLR HL, Y0 VLR HH, Y1 CALL p256SqrInternal<>(SB) // X- ; Y=T ; MUL; T2=T // T2...

}

// QueueReplicationHeal is a wrapper for queueReplicationHeal
func QueueReplicationHeal(ctx context.Context, bucket string, oi ObjectInfo, retryCount int) {
	// ignore modtime zero objects
	if oi.ModTime.IsZero() {
		return
	}
	rcfg, err := getReplicationConfig(ctx, bucket)
	if err != nil {
		replLogOnceIf(ctx, err, bucket)
		return
	}
	tgts, _ := globalBucketTargetSys.ListBucketTargets(ctx, bucket)

						ver.ObjectV2.MetaSys[k] = []byte(v)
					} else {
						ver.ObjectV2.MetaUser[k] = v
					}
				}
				if !fi.ModTime.IsZero() {
					ver.ObjectV2.ModTime = fi.ModTime.UnixNano()
				}
				return x.setIdx(i, *ver)
			}
		}
	}

	return errFileVersionNotFound
}

// AddVersion adds a new version