// String returns the string representation of the range.
517362
func (r Range) String() string {
	return fmt.Sprintf("(%v,%v)", r.Start, r.End)
}
89218
func (s *AtomicSequence) String() string {
	d := fmt.Sprintf("incremented by %d between %d and %d", atomic.LoadUint64(&s.increment),
		atomic.LoadUint64(&s.minvalue), atomic.LoadUint64(&s.maxvalue))
	if !s.IsStarted() {
		return fmt.Sprintf("Unstarted Sequence %s", d)
	}
	return fmt.Sprintf("Sequence at %d, %s", atomic.LoadUint64(&s.current), d)
}
673283
func (p *parser) String(i int, context string) string {
	if p.err != nil {
		return ""
	}
	if i < 0 || i >= len(p.Fields) {
		p.SetErr(context, "index out of range")
		return ""
	}
	return p.Fields[i]
}
1206181
func (exp *KeyValueExpr) String() string {
	return fmt.Sprintf("%s: %s", exp.Key, exp.Value)
}
435841
func (vec *T) String() string {
	return fmt.Sprint(vec[0], vec[1], vec[2], vec[3])
}
341173
func (o *UlimitOpt) String() string {
	var out []string
	for _, v := range *o.values {
		out = append(out, v.String())
	}

	return fmt.Sprintf("%v", out)
}
446584
func (c *Capture) String() string {
	return string(c.text[c.Index : c.Index+c.Length])
}
560745
func (i Format) String() string {
	switch i {
	case FormatInvalid:
		return "FormatInvalid"
	case FormatARGB32:
		return "FormatARGB32"
	case FormatRGB24:
		return "FormatRGB24"
	case FormatA8:
		return "FormatA8"
	case FormatA1:
		return "FormatA1"
	case FormatRGB16565:
		return "FormatRGB16565"
	case FormatRGB30:
		return "FormatRGB30"
	default:
		return fmt.Sprintf("Format(%d)", i)
	}
}
538422
func (self *Constraint) String() string {
	return strings.Trim(self.operator+" "+self.version, " ")
}
500741
func (a Fields) String() string {
	var str []string
	for _, f := range a {
		str = append(str, f.String())
	}
	return strings.Join(str, ", ")
}
1281788
func (ci CellID) String() string {
	if !ci.IsValid() {
		return "Invalid: " + strconv.FormatInt(int64(ci), 16)
	}
	var b bytes.Buffer
	b.WriteByte("012345"[ci.Face()]) // values > 5 will have been picked off by !IsValid above
	b.WriteByte('/')
	for level := 1; level <= ci.Level(); level++ {
		b.WriteByte("0123"[ci.ChildPosition(level)])
	}
	return b.String()
}
858123
func (s *set) String() string {
	t := make([]string, 0, len(s.List()))
	for _, item := range s.List() {
		t = append(t, fmt.Sprintf("%v", item))
	}

	return fmt.Sprintf("[%s]", strings.Join(t, ", "))
}
749367
func (l *RangeList) String() string {
	rangeStrings := []string{}
	for _, r := range *l {
		rangeStrings = append(rangeStrings, r.String())
	}
	return strings.Join(rangeStrings, ",")
}
1373768
func (x duration) String() string {
	ms, ok := x.Int64()
	if !ok {
		return "<invalid-duration>" // probably very-very large
	}
	return (time.Duration(ms) * time.Millisecond).String()
}
423131
func (v *Value) String() string {
	return fmt.Sprintf("count:%d bytes:%d", v.Count, v.Bytes)
}
1256948
func (s Stack) String() string {
	var result string
	for _, value := range s {
		result += fmt.Sprintf("%s  |  ", value)
	}
	return result
}
583849
func (s CPUSet) String() string {
	if s.IsEmpty() {
		return ""
	}

	elems := s.ToSlice()

	type rng struct {
		start int
		end   int
	}

	ranges := []rng{{elems[0], elems[0]}}

	for i := 1; i < len(elems); i++ {
		lastRange := &ranges[len(ranges)-1]
		// if this element is adjacent to the high end of the last range
		if elems[i] == lastRange.end+1 {
			// then extend the last range to include this element
			lastRange.end = elems[i]
			continue
		}
		// otherwise, start a new range beginning with this element
		ranges = append(ranges, rng{elems[i], elems[i]})
	}

	// construct string from ranges
	var result bytes.Buffer
	for _, r := range ranges {
		if r.start == r.end {
			result.WriteString(strconv.Itoa(r.start))
		} else {
			result.WriteString(fmt.Sprintf("%d-%d", r.start, r.end))
		}
		result.WriteString(",")
	}
	return strings.TrimRight(result.String(), ",")
}