type time.Time

516 uses

	time (current package)
		format.go#L546: func (t Time) String() string {
		format.go#L577: func (t Time) GoString() string {
		format.go#L639: func (t Time) Format(layout string) string {
		format.go#L655: func (t Time) AppendFormat(b []byte, layout string) []byte {
		format.go#L667: func (t Time) appendFormat(b []byte, layout string) []byte {
		format.go#L1023: func Parse(layout, value string) (Time, error) {
		format.go#L1038: func ParseInLocation(layout, value string, loc *Location) (Time, error) {
		format.go#L1048: func parse(layout, value string, defaultLocation, local *Location) (Time, error) {
		format.go#L1076: 			return Time{}, newParseError(alayout, avalue, prefix, value, "")
		format.go#L1080: 				return Time{}, newParseError(alayout, avalue, "", value, ": extra text: "+quote(value))
		format.go#L1328: 			return Time{}, newParseError(alayout, avalue, stdstr, value, ": "+rangeErrString+" out of range")
		format.go#L1331: 			return Time{}, newParseError(alayout, avalue, stdstr, hold, "")
		format.go#L1353: 			return Time{}, newParseError(alayout, avalue, "", value, ": day-of-year out of range")
		format.go#L1365: 			return Time{}, newParseError(alayout, avalue, "", value, ": day-of-year does not match month")
		format.go#L1369: 			return Time{}, newParseError(alayout, avalue, "", value, ": day-of-year does not match day")
		format.go#L1383: 		return Time{}, newParseError(alayout, avalue, "", value, ": day out of range")
		format_rfc3339.go#L18: func (t Time) appendFormatRFC3339(b []byte, nanos bool) []byte {
		format_rfc3339.go#L62: func (t Time) appendStrictRFC3339(b []byte) ([]byte, error) {
		format_rfc3339.go#L82: func parseRFC3339[bytes []byte | string](s bytes, local *Location) (Time, bool) {
		format_rfc3339.go#L105: 		return Time{}, false
		format_rfc3339.go#L114: 		return Time{}, false
		format_rfc3339.go#L132: 			return Time{}, false
		format_rfc3339.go#L137: 			return Time{}, false
		format_rfc3339.go#L155: func parseStrictRFC3339(b []byte) (Time, error) {
		format_rfc3339.go#L160: 			return Time{}, err
		format_rfc3339.go#L173: 			return Time{}, &ParseError{RFC3339, string(b), "15", string(b[len("2006-01-02T"):][:1]), ""}
		format_rfc3339.go#L175: 			return Time{}, &ParseError{RFC3339, string(b), ".", ",", ""}
		format_rfc3339.go#L179: 				return Time{}, &ParseError{RFC3339, string(b), "Z07:00", string(b[len(b)-len("Z07:00"):]), ": timezone hour out of range"}
		format_rfc3339.go#L181: 				return Time{}, &ParseError{RFC3339, string(b), "Z07:00", string(b[len(b)-len("Z07:00"):]), ": timezone minute out of range"}
		format_rfc3339.go#L184: 			return Time{}, &ParseError{RFC3339, string(b), RFC3339, string(b), ""}
		sleep.go#L22: func syncTimer(c chan Time) unsafe.Pointer {
		sleep.go#L90: 	C         <-chan Time
		sleep.go#L144: 	c := make(chan Time, 1)
		sleep.go#L187: 	case c.(chan Time) <- Now().Add(Duration(-delta)):
		sleep.go#L202: func After(d Duration) <-chan Time {
		tick.go#L17: 	C          <-chan Time // The channel on which the ticks are delivered.
		tick.go#L43: 	c := make(chan Time, 1)
		tick.go#L86: func Tick(d Duration) <-chan Time {
		time.go#L140: type Time struct {
		time.go#L176: func (t *Time) nsec() int32 {
		time.go#L181: func (t *Time) sec() int64 {
		time.go#L189: func (t *Time) unixSec() int64 { return t.sec() + internalToUnix }
		time.go#L192: func (t *Time) addSec(d int64) {
		time.go#L217: func (t *Time) setLoc(loc *Location) {
		time.go#L226: func (t *Time) stripMono() {
		time.go#L237: func (t *Time) setMono(m int64) {
		time.go#L253: func (t *Time) mono() int64 {
		time.go#L262: func (t Time) IsZero() bool {
		time.go#L267: func (t Time) After(u Time) bool {
		time.go#L277: func (t Time) Before(u Time) bool {
		time.go#L288: func (t Time) Compare(u Time) int {
		time.go#L312: func (t Time) Equal(u Time) bool {
		time.go#L765: func (t Time) absSec() absSeconds {
		time.go#L785: func (t Time) locabs() (name string, offset int, abs absSeconds) {
		time.go#L808: func (t Time) Date() (year int, month Month, day int) {
		time.go#L813: func (t Time) Year() int {
		time.go#L820: func (t Time) Month() Month {
		time.go#L827: func (t Time) Day() int {
		time.go#L834: func (t Time) Weekday() Weekday {
		time.go#L848: func (t Time) ISOWeek() (year, week int) {
		time.go#L866: func (t Time) Clock() (hour, min, sec int) {
		time.go#L881: func (t Time) Hour() int {
		time.go#L886: func (t Time) Minute() int {
		time.go#L891: func (t Time) Second() int {
		time.go#L897: func (t Time) Nanosecond() int {
		time.go#L903: func (t Time) YearDay() int {
		time.go#L1166: func (t Time) Add(d Duration) Time {
		time.go#L1194: func (t Time) Sub(u Time) Duration {
		time.go#L1223: func Since(t Time) Duration {
		time.go#L1233: func Until(t Time) Duration {
		time.go#L1258: func (t Time) AddDate(years int, months int, days int) Time {
		time.go#L1340: func Now() Time {
		time.go#L1343: 		return Time{uint64(nsec), sec + unixToInternal, Local}
		time.go#L1351: 		return Time{uint64(nsec), sec + minWall, Local}
		time.go#L1353: 	return Time{hasMonotonic | uint64(sec)<<nsecShift | uint64(nsec), mono, Local}
		time.go#L1356: func unixTime(sec int64, nsec int32) Time {
		time.go#L1357: 	return Time{uint64(nsec), sec + unixToInternal, Local}
		time.go#L1361: func (t Time) UTC() Time {
		time.go#L1367: func (t Time) Local() Time {
		time.go#L1377: func (t Time) In(loc *Location) Time {
		time.go#L1386: func (t Time) Location() *Location {
		time.go#L1396: func (t Time) Zone() (name string, offset int) {
		time.go#L1406: func (t Time) ZoneBounds() (start, end Time) {
		time.go#L1425: func (t Time) Unix() int64 {
		time.go#L1434: func (t Time) UnixMilli() int64 {
		time.go#L1443: func (t Time) UnixMicro() int64 {
		time.go#L1453: func (t Time) UnixNano() int64 {
		time.go#L1463: func (t Time) AppendBinary(b []byte) ([]byte, error) {
		time.go#L1510: func (t Time) MarshalBinary() ([]byte, error) {
		time.go#L1519: func (t *Time) UnmarshalBinary(data []byte) error {
		time.go#L1551: 	*t = Time{}
		time.go#L1571: func (t Time) GobEncode() ([]byte, error) {
		time.go#L1576: func (t *Time) GobDecode(data []byte) error {
		time.go#L1584: func (t Time) MarshalJSON() ([]byte, error) {
		time.go#L1597: func (t *Time) UnmarshalJSON(data []byte) error {
		time.go#L1611: func (t Time) appendTo(b []byte, errPrefix string) ([]byte, error) {
		time.go#L1623: func (t Time) AppendText(b []byte) ([]byte, error) {
		time.go#L1631: func (t Time) MarshalText() ([]byte, error) {
		time.go#L1637: func (t *Time) UnmarshalText(data []byte) error {
		time.go#L1648: func Unix(sec int64, nsec int64) Time {
		time.go#L1663: func UnixMilli(msec int64) Time {
		time.go#L1669: func UnixMicro(usec int64) Time {
		time.go#L1674: func (t Time) IsDST() bool {
		time.go#L1727: func Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time {
		time.go#L1775: func (t Time) Truncate(d Duration) Time {
		time.go#L1792: func (t Time) Round(d Duration) Time {
		time.go#L1807: func div(t Time, d Duration) (qmod2 int, r Duration) {
		time.go#L1924: func legacyTimeTimeAbs(t Time) uint64 {

	compress/gzip
		gunzip.go#L55: 	ModTime time.Time // modification time

	context
		context.go#L75: 	Deadline() (deadline time.Time, ok bool)
		context.go#L183: func (emptyCtx) Deadline() (deadline time.Time, ok bool) {
		context.go#L587: func (withoutCancelCtx) Deadline() (deadline time.Time, ok bool) {
		context.go#L616: func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {
		context.go#L623: func WithDeadlineCause(parent Context, d time.Time, cause error) (Context, CancelFunc) {
		context.go#L657: 	deadline time.Time
		context.go#L660: func (c *timerCtx) Deadline() (deadline time.Time, ok bool) {

	crypto/tls
		common.go#L552: 	Time func() time.Time
		common.go#L899: 	created time.Time
		common.go#L1100: func (c *Config) time() time.Time {
		conn.go#L145: func (c *Conn) SetDeadline(t time.Time) error {
		conn.go#L151: func (c *Conn) SetReadDeadline(t time.Time) error {
		conn.go#L158: func (c *Conn) SetWriteDeadline(t time.Time) error {

	crypto/x509
		parser.go#L170: func parseTime(der *cryptobyte.String) (time.Time, error) {
		parser.go#L171: 	var t time.Time
		parser.go#L187: func parseValidity(der cryptobyte.String) (time.Time, time.Time, error) {
		parser.go#L190: 		return time.Time{}, time.Time{}, err
		parser.go#L194: 		return time.Time{}, time.Time{}, err
		verify.go#L202: 	CurrentTime time.Time
		x509.go#L199: 	NotBefore, NotAfter time.Time
		x509.go#L704: 	NotBefore, NotAfter time.Time // Validity bounds.
		x509.go#L1834: func (c *Certificate) CreateCRL(rand io.Reader, priv any, revokedCerts []pkix.RevokedCertificate, now, expiry time.Time) (crlBytes []byte, err error) {
		x509.go#L2275: 	RevocationTime time.Time
		x509.go#L2345: 	ThisUpdate time.Time
		x509.go#L2349: 	NextUpdate time.Time
		x509.go#L2377: 	ThisUpdate          time.Time
		x509.go#L2378: 	NextUpdate          time.Time                 `asn1:"optional"`

	crypto/x509/pkix
		pkix.go#L295: func (certList *CertificateList) HasExpired(now time.Time) bool {
		pkix.go#L308: 	ThisUpdate          time.Time
		pkix.go#L309: 	NextUpdate          time.Time            `asn1:"optional"`
		pkix.go#L318: 	RevocationTime time.Time

	embed
		embed.go#L221: func (f *file) ModTime() time.Time         { return time.Time{} }

	encoding/asn1
		asn1.go#L334: func parseUTCTime(bytes []byte) (ret time.Time, err error) {
		asn1.go#L362: func parseGeneralizedTime(bytes []byte) (ret time.Time, err error) {
		asn1.go#L655: 	timeType             = reflect.TypeFor[time.Time]()
		asn1.go#L861: 	case *time.Time:
		marshal.go#L363: func outsideUTCRange(t time.Time) bool {
		marshal.go#L368: func makeUTCTime(t time.Time) (e encoder, err error) {
		marshal.go#L379: func makeGeneralizedTime(t time.Time) (e encoder, err error) {
		marshal.go#L390: func appendUTCTime(dst []byte, t time.Time) (ret []byte, err error) {
		marshal.go#L405: func appendGeneralizedTime(dst []byte, t time.Time) (ret []byte, err error) {
		marshal.go#L416: func appendTimeCommon(dst []byte, t time.Time) []byte {
		marshal.go#L463: 		t := value.Interface().(time.Time)
		marshal.go#L653: 		if params.timeType == TagGeneralizedTime || outsideUTCRange(v.Interface().(time.Time)) {

	github.com/robfig/cron/v3
		constantdelay.go#L25: func (schedule ConstantDelaySchedule) Next(t time.Time) time.Time {
		cron.go#L43: 	Next(time.Time) time.Time
		cron.go#L60: 	Next time.Time
		cron.go#L63: 	Prev time.Time
		cron.go#L317: func (c *Cron) now() time.Time {
		logger.go#L80: 		if t, ok := arg.(time.Time); ok {
		spec.go#L58: func (s *SpecSchedule) Next(t time.Time) time.Time {
		spec.go#L92: 		return time.Time{}
		spec.go#L179: func dayMatches(s *SpecSchedule, t time.Time) bool {

	go.pact.im/x/clock
		clock.go#L30: 	Schedule(d time.Duration, f func(now time.Time)) Event
		clock.go#L70: func (c *Clock) Schedule(d time.Duration, f func(now time.Time)) Event {
		now.go#L11: 	Now() time.Time
		now.go#L18: func (c *Clock) Now() time.Time {
		runtime.go#L29: func (c *runtimeClock) Schedule(d time.Duration, f func(now time.Time)) Event {
		runtime.go#L36: func (c *runtimeClock) Now() time.Time {
		runtime.go#L56: func (r runtimeTimer) C() <-chan time.Time {
		runtime.go#L71: func (r runtimeTicker) C() <-chan time.Time {
		ticker.go#L24: 	C() <-chan time.Time
		ticker.go#L60: 	c chan time.Time
		ticker.go#L75: 		c:      make(chan time.Time, 1),
		ticker.go#L84: func (t *eventTicker) C() <-chan time.Time {
		timer.go#L20: 	C() <-chan time.Time
		timer.go#L74: 	ch := make(chan time.Time, 1)
		timer.go#L75: 	event := s.Schedule(d, func(now time.Time) {
		timer.go#L90: 	c chan time.Time
		timer.go#L94: func (t *eventTimer) C() <-chan time.Time {

	go.pact.im/x/clock/fakeclock
		fakeclock.go#L23: 	next(now time.Time) (time.Duration, bool)
		fakeclock.go#L40: 	now   time.Time
		fakeclock.go#L41: 	sched map[moment]time.Time
		fakeclock.go#L66: func Time(now time.Time) *Clock {
		fakeclock.go#L69: 		sched: map[moment]time.Time{},
		fakeclock.go#L74: func (c *Clock) Now() time.Time {
		fakeclock.go#L85: func (c *Clock) Next() (time.Time, bool) {
		fakeclock.go#L97: func (c *Clock) Set(t time.Time) {
		fakeclock.go#L112: func (c *Clock) Add(d time.Duration) time.Time {
		fakeclock.go#L129: func (c *Clock) AddDate(years, months, days int) time.Time {
		fakeclock.go#L139: func (c *Clock) Schedule(d time.Duration, f func(now time.Time)) clock.Event {
		fakeclock.go#L152: 		ch: make(chan time.Time, 1),
		fakeclock.go#L167: 		ch: make(chan time.Time, 1),
		fakeclock.go#L200: func (c *Clock) schedule(m moment, when time.Time) bool {
		fakeclock.go#L202: 		c.sched = map[moment]time.Time{}
		fakeclock.go#L211: func (c *Clock) next(now time.Time) time.Time {
		fakeclock.go#L215: 	var next time.Time
		fakeclock.go#L233: func (c *Clock) advance(now time.Time) {
		fakeclock.go#L250: 	f func(time.Time)
		fakeclock.go#L264: func (t *event) next(now time.Time) (time.Duration, bool) {
		fakeclock.go#L272: 	ch chan time.Time
		fakeclock.go#L276: func (t *timer) C() <-chan time.Time {
		fakeclock.go#L291: func (t *timer) next(now time.Time) (time.Duration, bool) {
		fakeclock.go#L302: 	ch chan time.Time
		fakeclock.go#L307: func (t *ticker) C() <-chan time.Time {
		fakeclock.go#L325: func (t *ticker) next(now time.Time) (time.Duration, bool) {

	go.pact.im/x/clock/mockclock
		mockclock.go#L44: func (m *MockClock) Now() time.Time {
		mockclock.go#L47: 	ret0, _ := ret[0].(time.Time)
		mockclock.go#L58: func (m *MockClock) Schedule(d time.Duration, f func(time.Time)) clock.Event {
		ticker.go#L43: func (m *MockTicker) C() <-chan time.Time {
		ticker.go#L46: 	ret0, _ := ret[0].(<-chan time.Time)
		timer.go#L43: func (m *MockTimer) C() <-chan time.Time {
		timer.go#L46: 	ret0, _ := ret[0].(<-chan time.Time)

	go.pact.im/x/clock/observeclock
		observeclock.go#L44: func (c *Clock) Schedule(d time.Duration, f func(time.Time)) clock.Event {

	go.pact.im/x/flaky
		jitter.go#L85: func (j *jitterSchedule) Next(now time.Time) time.Time {
		schedule.go#L26: 	Next(now time.Time) time.Time
		schedule.go#L31: 	until time.Time
		schedule.go#L36: func Until(s Schedule, t time.Time) Schedule {
		schedule.go#L44: func (t *untilSchedule) Next(now time.Time) time.Time {
		schedule.go#L47: 		return time.Time{}
		schedule.go#L69: func (t *midnightSchedule) Next(now time.Time) time.Time {
		schedule.go#L101: func (t sleepSchedule) Next(now time.Time) time.Time {

	go.pact.im/x/goupdate
		tests.go#L22: 	Time    time.Time // encodes as an RFC3339-format string

	go.pact.im/x/zapjournal
		encoder.go#L202: func (e *varsEncoder) AddTime(key string, value time.Time) {
		json.go#L167: func (e *jsonEncoder) AddTime(k string, v time.Time) {
		json.go#L172: func (e *jsonEncoder) AppendTime(v time.Time) {
		json.go#L177: func (e *jsonEncoder) encodeTime(v time.Time) {

	go.pact.im/x/zapjournal/tests
		stubs.go#L22: 	now time.Time
		stubs.go#L25: func (c *fakeClock) Now() time.Time {

	go.uber.org/atomic
		time.go#L36: var _zeroTime time.Time
		time.go#L39: func NewTime(val time.Time) *Time {
		time.go#L48: func (x *Time) Load() time.Time {
		time.go#L53: func (x *Time) Store(val time.Time) {
		time_ext.go#L27: func packTime(t time.Time) interface{} {
		time_ext.go#L31: func unpackTime(v interface{}) time.Time {
		time_ext.go#L32: 	if t, ok := v.(time.Time); ok {
		time_ext.go#L35: 	return time.Time{}

	go.uber.org/zap
		array.go#L103: func Times(key string, ts []time.Time) Field {
		array.go#L259: type times []time.Time
		field.go#L346: func Time(key string, val time.Time) Field {
		field.go#L355: func Timep(key string, val *time.Time) Field {
		field.go#L528: 	case time.Time:
		field.go#L530: 	case *time.Time:
		field.go#L532: 	case []time.Time:
		time.go#L25: func timeToMillis(t time.Time) int64 {

	go.uber.org/zap/buffer
		buffer.go#L56: func (b *Buffer) AppendTime(t time.Time, layout string) {

	go.uber.org/zap/zapcore
		clock.go#L32: 	Now() time.Time
		clock.go#L42: func (systemClock) Now() time.Time {
		encoder.go#L93: type TimeEncoder func(time.Time, PrimitiveArrayEncoder)
		encoder.go#L97: func EpochTimeEncoder(t time.Time, enc PrimitiveArrayEncoder) {
		encoder.go#L105: func EpochMillisTimeEncoder(t time.Time, enc PrimitiveArrayEncoder) {
		encoder.go#L113: func EpochNanosTimeEncoder(t time.Time, enc PrimitiveArrayEncoder) {
		encoder.go#L117: func encodeTimeLayout(t time.Time, layout string, enc PrimitiveArrayEncoder) {
		encoder.go#L119: 		AppendTimeLayout(time.Time, string)
		encoder.go#L135: func ISO8601TimeEncoder(t time.Time, enc PrimitiveArrayEncoder) {
		encoder.go#L143: func RFC3339TimeEncoder(t time.Time, enc PrimitiveArrayEncoder) {
		encoder.go#L152: func RFC3339NanoTimeEncoder(t time.Time, enc PrimitiveArrayEncoder) {
		encoder.go#L159: 	return func(t time.Time, enc PrimitiveArrayEncoder) {
		encoder.go#L369: 	AddTime(key string, value time.Time)
		encoder.go#L396: 	AppendTime(time.Time)
		entry.go#L147: 	Time       time.Time
		field.go#L158: 		enc.AddTime(f.Key, f.Interface.(time.Time))
		json_encoder.go#L204: func (enc *jsonEncoder) AddTime(key string, val time.Time) {
		json_encoder.go#L303: func (enc *jsonEncoder) AppendTimeLayout(time time.Time, layout string) {
		json_encoder.go#L310: func (enc *jsonEncoder) AppendTime(val time.Time) {
		memory_encoder.go#L102: func (m MapObjectEncoder) AddTime(k string, v time.Time) { m.cur[k] = v }
		memory_encoder.go#L173: func (s *sliceArrayEncoder) AppendTime(v time.Time)         { s.elems = append(s.elems, v) }
		sampler.go#L65: func (c *counter) IncCheckReset(t time.Time, tick time.Duration) uint64 {

	golang.org/x/net/http2
		http2.go#L328: 		var now time.Time
		http2.go#L340: 			conn.SetWriteDeadline(time.Time{})
		http2.go#L426: 	Now() time.Time
		server.go#L191: func (s *Server) now() time.Time {
		server.go#L474: 		sc.conn.SetWriteDeadline(time.Time{})
		server.go#L1069: func (sc *serverConn) handlePingTimer(lastFrameReadTime time.Time) {
		server.go#L2120: 		sc.conn.SetReadDeadline(time.Time{})
		server.go#L2141: 		sc.conn.SetReadDeadline(time.Time{})
		server.go#L2825: func (w *responseWriter) SetReadDeadline(deadline time.Time) error {
		server.go#L2851: func (w *responseWriter) SetWriteDeadline(deadline time.Time) error {
		timer.go#L10: 	C() <-chan time.Time
		timer.go#L20: func (t timeTimer) C() <-chan time.Time { return t.Timer.C }
		transport.go#L205: func (t *Transport) now() time.Time {
		transport.go#L212: func (t *Transport) timeSince(when time.Time) time.Duration {
		transport.go#L390: 	lastActive       time.Time
		transport.go#L391: 	lastIdle         time.Time // time last idle
		transport.go#L1028: 	LastIdle time.Time
		transport.go#L1558: 	var respHeaderTimer <-chan time.Time
		transport.go#L1760: 		cc.lastIdle = time.Time{}

	golang.org/x/net/internal/timeseries
		timeseries.go#L76: 	Time() time.Time
		timeseries.go#L83: func (defaultClock) Time() time.Time { return time.Now() }
		timeseries.go#L91: 	end      time.Time         // end timestamp for this level
		timeseries.go#L100: 	l.end = time.Time{}
		timeseries.go#L127: 	lastAdd     time.Time         // time of last Observable tracked
		timeseries.go#L131: 	pendingTime time.Time         // what time are we keeping in pending
		timeseries.go#L157: 	ts.lastAdd = time.Time{}
		timeseries.go#L160: 	ts.pendingTime = time.Time{}
		timeseries.go#L174: func (ts *timeSeries) AddWithTime(observation Observable, t time.Time) {
		timeseries.go#L200: func (ts *timeSeries) mergeValue(observation Observable, t time.Time) {
		timeseries.go#L225: func (ts *timeSeries) advance(t time.Time) {
		timeseries.go#L333: func (ts *timeSeries) Range(start, finish time.Time) Observable {
		timeseries.go#L354: func (ts *timeSeries) ComputeRange(start, finish time.Time, num int) []Observable {
		timeseries.go#L394: func (ts *timeSeries) extract(l *tsLevel, start, finish time.Time, num int, results []Observable) {
		timeseries.go#L513: func minTime(a, b time.Time) time.Time {
		timeseries.go#L520: func maxTime(a, b time.Time) time.Time {

	golang.org/x/net/trace
		events.go#L190: func (f *eventFamily) Count(now time.Time, maxErrAge time.Duration) (n int) {
		events.go#L201: func (f *eventFamily) Copy(now time.Time, maxErrAge time.Duration) (els eventLogs) {
		events.go#L230: 	When    time.Time
		events.go#L255: 	Start time.Time
		events.go#L266: 	LastErrorTime time.Time
		events.go#L276: 	el.Start = time.Time{}
		events.go#L279: 	el.LastErrorTime = time.Time{}
		events.go#L284: func (el *eventLog) hasRecentError(now time.Time, maxErrAge time.Duration) bool {
		events.go#L296: func (el *eventLog) delta(t time.Time) (time.Duration, bool) {
		trace.go#L687: 	When       time.Time
		trace.go#L722: 	Start time.Time
		trace.go#L745: 	tr.Start = time.Time{}
		trace.go#L768: func (tr *trace) delta(t time.Time) (time.Duration, bool) {

	golang.org/x/sys/unix
		timestruct.go#L29: func TimeToTimespec(t time.Time) (Timespec, error) {

	golang.org/x/tools/go/packages
		packages.go#L546: 	Time      *time.Time   // time version was created

	golang.org/x/tools/internal/event/core
		event.go#L17: 	at time.Time
		event.go#L36: func (ev Event) At() time.Time { return ev.at }
		event.go#L82: func CloneEvent(ev Event, at time.Time) Event {

	golang.org/x/tools/internal/gocommand
		invoke.go#L427: func handleHangingGoCommand(start time.Time, cmd *exec.Cmd, resChan chan error) {
		vendor.go#L26: 	Time      *time.Time  // time version was created

	google.golang.org/grpc
		clientconn.go#L1326: func (ac *addrConn) tryAllAddrs(ctx context.Context, addrs []resolver.Address, connectDeadline time.Time) error {
		clientconn.go#L1364: func (ac *addrConn) createTransport(ctx context.Context, addr resolver.Address, copts transport.ConnectOptions, connectDeadline time.Time) error {
		rpc_util.go#L801: func outPayload(client bool, msg any, dataLength, payloadLength int, t time.Time) *stats.OutPayload {
		server.go#L974: 	rawConn.SetDeadline(time.Time{})
		stream.go#L420: 	var beginTime time.Time
		stream.go#L617: 	beginTime     time.Time

	google.golang.org/grpc/internal/channelz
		trace.go#L60: 	Timestamp time.Time
		trace.go#L89: 	CreationTime time.Time

	google.golang.org/grpc/internal/resolver/dns
		dns_resolver.go#L215: 		var nextResolutionTime time.Time

	google.golang.org/grpc/internal/resolver/dns/internal
		internal.go#L57: 	TimeAfterFunc func(time.Duration) <-chan time.Time
		internal.go#L62: 	TimeNowFunc func() time.Time
		internal.go#L68: 	TimeUntilFunc func(time.Time) time.Duration

	google.golang.org/grpc/internal/transport
		bdp_estimator.go#L51: 	sentAt time.Time
		bdp_estimator.go#L94: 		b.sentAt = time.Time{}
		http2_server.go#L95: 	lastPingAt time.Time
		http2_server.go#L121: 	idle time.Time
		http2_server.go#L619: 		t.idle = time.Time{}

	google.golang.org/grpc/stats
		stats.go#L50: 	BeginTime time.Time
		stats.go#L104: 	RecvTime time.Time
		stats.go#L174: 	SentTime time.Time
		stats.go#L233: 	BeginTime time.Time
		stats.go#L235: 	EndTime time.Time

	google.golang.org/protobuf/types/known/timestamppb
		timestamp.pb.go#L194: func New(t time.Time) *Timestamp {
		timestamp.pb.go#L199: func (x *Timestamp) AsTime() time.Time {

	internal/poll
		fd_poll_runtime.go#L132: func (fd *FD) SetDeadline(t time.Time) error {
		fd_poll_runtime.go#L137: func (fd *FD) SetReadDeadline(t time.Time) error {
		fd_poll_runtime.go#L142: func (fd *FD) SetWriteDeadline(t time.Time) error {
		fd_poll_runtime.go#L146: func setDeadlineImpl(fd *FD, t time.Time, mode int) error {

	io/fs
		fs.go#L162: 	ModTime() time.Time // modification time

	log
		log.go#L114: func formatHeader(buf *[]byte, t time.Time, prefix string, flag int, file string, line int) {

	net
		dial.go#L144: 	Deadline time.Time
		dial.go#L234: func minNonzeroTime(a, b time.Time) time.Time {
		dial.go#L250: func (d *Dialer) deadline(ctx context.Context, now time.Time) (earliest time.Time) {
		dial.go#L269: func partialDeadline(now, deadline time.Time, addrsRemaining int) (time.Time, error) {
		dial.go#L275: 		return time.Time{}, errTimeout
		dnsclient_unix.go#L361: 	lastChecked time.Time     // last time resolv.conf was checked
		dnsclient_unix.go#L415: 		var mtime time.Time
		dnsconfig.go#L41: 	mtime         time.Time     // time of resolv.conf modification
		fd_posix.go#L137: func (fd *netFD) SetDeadline(t time.Time) error {
		fd_posix.go#L141: func (fd *netFD) SetReadDeadline(t time.Time) error {
		fd_posix.go#L145: func (fd *netFD) SetWriteDeadline(t time.Time) error {
		hosts.go#L46: 	expire time.Time
		hosts.go#L48: 	mtime  time.Time
		interface.go#L194: 	lastFetched  time.Time      // last time routing information was fetched
		net.go#L166: 	SetDeadline(t time.Time) error
		net.go#L171: 	SetReadDeadline(t time.Time) error
		net.go#L178: 	SetWriteDeadline(t time.Time) error
		net.go#L246: func (c *conn) SetDeadline(t time.Time) error {
		net.go#L257: func (c *conn) SetReadDeadline(t time.Time) error {
		net.go#L268: func (c *conn) SetWriteDeadline(t time.Time) error {
		net.go#L366: 	SetDeadline(t time.Time) error
		net.go#L371: 	SetReadDeadline(t time.Time) error
		net.go#L378: 	SetWriteDeadline(t time.Time) error
		net.go#L526: 	noDeadline = time.Time{}
		nss.go#L27: 	lastChecked time.Time     // last time nsswitch.conf was checked
		nss.go#L64: 	var mtime time.Time
		nss.go#L97: 	mtime   time.Time              // time of nsswitch.conf modification
		parse.go#L67: func (f *file) stat() (mtime time.Time, size int64, err error) {
		parse.go#L70: 		return time.Time{}, 0, err
		parse.go#L83: func stat(name string) (mtime time.Time, size int64, err error) {
		parse.go#L86: 		return time.Time{}, 0, err
		pipe.go#L31: func (d *pipeDeadline) set(t time.Time) {
		pipe.go#L210: func (p *pipe) SetDeadline(t time.Time) error {
		pipe.go#L219: func (p *pipe) SetReadDeadline(t time.Time) error {
		pipe.go#L227: func (p *pipe) SetWriteDeadline(t time.Time) error {
		tcpsock.go#L406: func (l *TCPListener) SetDeadline(t time.Time) error {
		unixsock.go#L286: func (l *UnixListener) SetDeadline(t time.Time) error {

	net/http
		client.go#L174: func (c *Client) send(req *Request, deadline time.Time) (resp *Response, didTimeout func() bool, err error) {
		client.go#L192: func (c *Client) deadline() time.Time {
		client.go#L196: 	return time.Time{}
		client.go#L211: func send(ireq *Request, rt RoundTripper, deadline time.Time) (resp *Response, didTimeout func() bool, err error) {
		client.go#L307: func timeBeforeContextDeadline(t time.Time, ctx context.Context) bool {
		client.go#L351: func setRequestCancel(req *Request, rt RoundTripper, deadline time.Time) (stopTimer func(), didTimeout func() bool) {
		cookie.go#L30: 	Expires    time.Time // optional
		cookie.go#L180: 					c.Expires = time.Time{}
		cookie.go#L380: func validCookieExpires(t time.Time) bool {
		fs.go#L240: func ServeContent(w ResponseWriter, req *Request, name string, modtime time.Time, content io.ReadSeeker) {
		fs.go#L269: func serveContent(w ResponseWriter, r *Request, name string, modtime time.Time, sizeFunc func() (int64, error), content io.ReadSeeker) {
		fs.go#L508: func checkIfUnmodifiedSince(r *Request, modtime time.Time) condResult {
		fs.go#L557: func checkIfModifiedSince(r *Request, modtime time.Time) condResult {
		fs.go#L578: func checkIfRange(w ResponseWriter, r *Request, modtime time.Time) condResult {
		fs.go#L612: func isZeroTime(t time.Time) bool {
		fs.go#L616: func setLastModified(w ResponseWriter, modtime time.Time) {
		fs.go#L640: func checkPreconditions(w ResponseWriter, r *Request, modtime time.Time) (done bool, rangeHeader string) {
		h2_bundle.go#L3805: 		var now time.Time
		h2_bundle.go#L3817: 			conn.SetWriteDeadline(time.Time{})
		h2_bundle.go#L3924: 	Now() time.Time
		h2_bundle.go#L4238: func (s *http2Server) now() time.Time {
		h2_bundle.go#L4521: 		sc.conn.SetWriteDeadline(time.Time{})
		h2_bundle.go#L5120: func (sc *http2serverConn) handlePingTimer(lastFrameReadTime time.Time) {
		h2_bundle.go#L6171: 		sc.conn.SetReadDeadline(time.Time{})
		h2_bundle.go#L6192: 		sc.conn.SetReadDeadline(time.Time{})
		h2_bundle.go#L6921: func (w *http2responseWriter) SetReadDeadline(deadline time.Time) error {
		h2_bundle.go#L6947: func (w *http2responseWriter) SetWriteDeadline(deadline time.Time) error {
		h2_bundle.go#L7450: 	C() <-chan time.Time
		h2_bundle.go#L7460: func (t http2timeTimer) C() <-chan time.Time { return t.Timer.C }
		h2_bundle.go#L7627: func (t *http2Transport) now() time.Time {
		h2_bundle.go#L7634: func (t *http2Transport) timeSince(when time.Time) time.Duration {
		h2_bundle.go#L7811: 	lastActive       time.Time
		h2_bundle.go#L7812: 	lastIdle         time.Time // time last idle
		h2_bundle.go#L8450: 	LastIdle time.Time
		h2_bundle.go#L9032: 	var respHeaderTimer <-chan time.Time
		h2_bundle.go#L9221: 		cc.lastIdle = time.Time{}
		header.go#L129: func ParseTime(text string) (t time.Time, err error) {
		responsecontroller.go#L85: func (c *ResponseController) SetReadDeadline(deadline time.Time) error {
		responsecontroller.go#L89: 		case interface{ SetReadDeadline(time.Time) error }:
		responsecontroller.go#L105: func (c *ResponseController) SetWriteDeadline(deadline time.Time) error {
		responsecontroller.go#L109: 		case interface{ SetWriteDeadline(time.Time) error }:
		server.go#L325: 	rwc.SetDeadline(time.Time{})
		server.go#L496: func (c *response) SetReadDeadline(deadline time.Time) error {
		server.go#L500: func (c *response) SetWriteDeadline(deadline time.Time) error {
		server.go#L685: 	cr.conn.rwc.SetReadDeadline(time.Time{})
		server.go#L740: 	cr.conn.rwc.SetReadDeadline(time.Time{})
		server.go#L995: func appendTime(b []byte, t time.Time) []byte {
		server.go#L1025: 		wholeReqDeadline time.Time // or zero if none
		server.go#L1026: 		hdrDeadline      time.Time // or zero if none
		server.go#L1988: 			c.rwc.SetReadDeadline(time.Time{})
		server.go#L1989: 			c.rwc.SetWriteDeadline(time.Time{})
		server.go#L2109: 		c.rwc.SetWriteDeadline(time.Time{})
		server.go#L2130: 			c.rwc.SetReadDeadline(time.Time{})
		server.go#L2141: 		c.rwc.SetReadDeadline(time.Time{})
		socks_bundle.go#L23: 	socksnoDeadline   = time.Time{}
		transport.go#L1083: 				if w.tryDeliver(pconn, nil, time.Time{}) {
		transport.go#L1095: 				w.tryDeliver(pconn, nil, time.Time{})
		transport.go#L1168: 	var oldTime time.Time
		transport.go#L1320: 	idleAt time.Time
		transport.go#L1340: func (w *wantConn) tryDeliver(pc *persistConn, err error, idleAt time.Time) bool {
		transport.go#L1616: 	delivered := w.tryDeliver(pc, err, time.Time{})
		transport.go#L2093: 	idleAt    time.Time   // time it last become idle
		transport.go#L2821: 	var respHeaderTimer <-chan time.Time

	net/http/httputil
		dump.go#L49: func (c *dumpConn) SetDeadline(t time.Time) error      { return nil }
		dump.go#L50: func (c *dumpConn) SetReadDeadline(t time.Time) error  { return nil }
		dump.go#L51: func (c *dumpConn) SetWriteDeadline(t time.Time) error { return nil }

	os
		file.go#L657: func (f *File) SetDeadline(t time.Time) error {
		file.go#L665: func (f *File) SetReadDeadline(t time.Time) error {
		file.go#L675: func (f *File) SetWriteDeadline(t time.Time) error {
		file_posix.go#L179: func Chtimes(name string, atime time.Time, mtime time.Time) error {
		file_posix.go#L181: 	set := func(i int, t time.Time) {
		file_posix.go#L210: func (f *File) setDeadline(t time.Time) error {
		file_posix.go#L218: func (f *File) setReadDeadline(t time.Time) error {
		file_posix.go#L226: func (f *File) setWriteDeadline(t time.Time) error {
		stat_linux.go#L46: func atime(fi FileInfo) time.Time {
		types_unix.go#L19: 	modTime time.Time
		types_unix.go#L25: func (fs *fileStat) ModTime() time.Time { return fs.modTime }

	runtime/debug
		garbage.go#L15: 	LastGC         time.Time       // time of last collection
		garbage.go#L19: 	PauseEnd       []time.Time     // pause end times history, most recent first
		garbage.go#L57: 		stats.PauseEnd = make([]time.Time, 0, maxPause)

	runtime/pprof
		proto.go#L28: 	start      time.Time
		proto.go#L29: 	end        time.Time

	testing
		fuzz.go#L476: func runFuzzTests(deps testDeps, fuzzTests []InternalFuzzTarget, deadline time.Time) (ran, ok bool) {
		testing.go#L1302: 		start     time.Time
		testing.go#L1875: func (t *T) Deadline() (deadline time.Time, ok bool) {
		testing.go#L1884: 	deadline time.Time
		testing.go#L2236: 	var deadline time.Time
		testing.go#L2247: func runTests(matchString func(pat, str string) (bool, error), tests []InternalTest, deadline time.Time) (ran, ok bool) {
		testing.go#L2464: func (m *M) startAlarm() time.Time {
		testing.go#L2466: 		return time.Time{}
		testing_other.go#L20: 	now time.Time

	vendor/golang.org/x/crypto/cryptobyte
		asn1.go#L110: func (b *Builder) AddASN1GeneralizedTime(t time.Time) {
		asn1.go#L121: func (b *Builder) AddASN1UTCTime(t time.Time) {
		asn1.go#L492: func (s *String) ReadASN1GeneralizedTime(out *time.Time) bool {
		asn1.go#L513: func (s *String) ReadASN1UTCTime(out *time.Time) bool {