// Less is part of sort.Interface interface. It should compare too elements of the array.
192920
func (array orderTabletsForSwap) Less(i, j int) bool {
	return tabletSortIndex(&array[i]) < tabletSortIndex(&array[j])
}
504800
func (sa *SuffixArrayZ) less(i, j, d int64) bool {
	if i == j {
		return false
	}
	i = i + d
	j = j + d
	for i < sa.n && j < sa.n {
		if sa.input[i] < sa.input[j] {
			return true
		}
		if sa.input[i] > sa.input[j] {
			return false
		}
		i++
		j++
	}
	return i > j
}
260346
func (declarations DeclarationsByProperty) Less(i, j int) bool {
	return declarations[i].Property < declarations[j].Property
}
1002476
func (s Float32Slice) Less(i, j int) bool {
	return s[i] < s[j]
}
12141
func (t byTime) Less(i, j int) bool {
	return t[i].Time.Before(t[j].Time)
}
1231184
func (p *pathHeap) Less(i, j int) bool {
	return p.paths[i].dist < p.paths[j].dist
}
507312
func (a *IntsRef) Less(other *IntsRef) bool {
	if a == other {
		return false
	}

	aInts := a.Ints
	aUpto := a.Offset
	bInts := other.Ints
	bUpto := other.Offset

	var aStop int
	if a.Length < other.Length {
		aStop = aUpto + a.Length
	} else {
		aStop = aUpto + other.Length
	}

	for aUpto < aStop {
		aInt := aInts[aUpto]
		aUpto++
		bInt := bInts[bUpto]
		bUpto++
		if aInt > bInt {
			return false
		} else if aInt < bInt {
			return true
		}
	}

	// one is a prefix of the other, or, they are equal:
	return a.Length < other.Length
}
391974
func (s SortAccept) Less(i, j int) bool {
	switch {
	case s.specs[i].Q == s.specs[j].Q:
		return indexOf(s.prefs, s.specs[i].Value) < indexOf(s.prefs, s.specs[j].Value)
	default:
		return s.specs[i].Q > s.specs[j].Q
	}
}
111109
func (v ValidatorUpdates) Less(i, j int) bool {
	return bytes.Compare(v[i].PubKey.Data, v[j].PubKey.Data) <= 0
}
117423
func (r Responses) Less(i, j int) bool {
	if r[i].Status == r[j].Status {
		return r[i].Name < r[j].Name
	}
	return r[i].Status < r[j].Status
}
1097558
func (i Interval) Less(other Interval) bool {
	return i.latest.Sub(other.earliest) < 0
}
675085
func (p PendingEvaluations) Less(i, j int) bool {
	if p[i].JobID != p[j].JobID && p[i].Priority != p[j].Priority {
		return !(p[i].Priority < p[j].Priority)
	}
	return p[i].CreateIndex < p[j].CreateIndex
}
866387
func (SW *sortWrapper) Less(i, j int) bool {
	x := SW.WordIndex[i]
	y := SW.WordIndex[j]
	a := SW.Words[x]
	b := SW.Words[y]
	pa := SW.SuffixIndex[i]
	pb := SW.SuffixIndex[j]
	na := len(a)
	nb := len(b)
	for pa < na && pb < nb {
		wa := a[pa]
		wb := b[pb]
		if wa < wb {
			return true
		}
		if wb < wa {
			return false
		}
		pa++
		pb++
	}
	return pa == na
}
1087304
func (s Uint8Slice) Less(i, j int) bool {
	return s[i] < s[j]
}
1111573
func (it Items) Less(i, j int) bool {
	return it[i].Key < it[j].Key
}
1136330
func Less(orders []Order, a, b Entry) bool {
	for _, cmp := range orders {
		switch cmp.Compare(a, b) {
		case 0:
		case -1:
			return true
		case 1:
			return false
		}
	}

	// This gives us a *stable* sort for free. We don't care
	// preserving the order from the underlying datastore
	// because it's undefined.
	return a.Key < b.Key
}
1152287
func (a *aclIterator) Less(i, j int) bool {
	return a.acls[i].ID < a.acls[j].ID
}