}

func (ts *Instance) SeriesAsDurationSinceEpoch(epoch time.Time) (Data, []time.Duration) {
	ts.mutex.Lock()
	defer ts.mutex.Unlock()
	return ts.data.Copy(), ts.times.asDurationSinceEpoch(epoch)
}

type times []time.Time

func (t times) copy() times {
	out := make(times, 0, len(t))
	out = append(out, t...)
	return out
}

func (t times) asDurationSinceEpoch(epoch time.Time) []time.Duration {

     * Returns the time when the operation started its execution.
     *
     * @return The start time, in milliseconds since the epoch.
     */
    long getStartTime();

    /**
     * Returns the time when the operation finished its execution.
     *
     * @return The end time, in milliseconds since the epoch.
     */
    long getEndTime();

	// packet header view.
	// See https://svnweb.freebsd.org/base?view=revision&revision=254804.
	m := (*ifMsghdr)(unsafe.Pointer(any))
	p.Header.Data.Hwassist = uint32(m.Data.Hwassist)
	p.Header.Data.Epoch = m.Data.Epoch
	p.Header.Data.Lastchange = m.Data.Lastchange
	return &InterfaceMessage{Header: p.Header, Data: b[int(unsafe.Offsetof(p.Header.Data))+int(p.Header.Data.Datalen) : any.Msglen]}

    /**
     * Returns the time when this test started execution.
     *
     * @return The start time, in milliseconds since the epoch.
     */
    long getStartTime();

    /**
     * Returns the time when this test completed execution.
     *
     * @return The end t ime, in milliseconds since the epoch.
     */
    long getEndTime();

    /**

 * @since 8.0
 */
public class TimestampSuppliers {
    /**
     * Returns a supplier that calculates a timestamp exactly the given amount of time
     * prior to the current time, or 0 if the amount of time extends beyond the epoch.
     */
    public static Supplier<Long> inThePast(int value, TimeUnit timeUnit) {
        // This needs to be an anonymous inner class instead of a lambda for configuration cache compatibility

 */

package org.gradle.internal.time

import spock.lang.Specification

import java.util.concurrent.TimeUnit


class TimestampSuppliersTest extends Specification {
    def "timestamps earlier than the epoch evaluate to zero"() {
        expect:
        TimestampSuppliers.inThePast(Integer.MAX_VALUE, TimeUnit.HOURS).get() == 0

        and:
        TimestampSuppliers.daysAgo(Integer.MAX_VALUE).get() == 0
    }

// Crashes 6g, 8g
// https://golang.org/issue/238

package main

func main() {
	bar := make(chan bool);
	select {
	case _ = <-bar:
		return
	}
}

/*
6g bug218.go 
<epoch>: fatal error: dowidth: unknown type: blank

// license that can be found in the LICENSE file.

package main

// type T int

func main() {}

// issue 1474

// important: no newline on end of next line.
// 6g used to print <epoch> instead of bug332.go:111

TEXT time·now(SB),NOSPLIT,$0-24
	MOVD	$_INTERRUPT_TIME, R3
	MOVD	time_lo(R3), R0
	MOVD	$100, R1
	MUL	R1, R0
	MOVD	R0, mono+16(FP)

	MOVD	$_SYSTEM_TIME, R3
	MOVD	time_lo(R3), R0
	// convert to Unix epoch (but still 100ns units)
	#define delta 116444736000000000
	SUB	$delta, R0
	// Convert to nSec
	MOVD	$100, R1
	MUL	R1, R0

	// Code stolen from compiler output for:
	//
	//	var x uint64

	MOVL	DX, mono+16(FP)

wall:
	MOVL	(_SYSTEM_TIME+time_hi1), CX
	MOVL	(_SYSTEM_TIME+time_lo), AX
	MOVL	(_SYSTEM_TIME+time_hi2), DX
	CMPL	CX, DX
	JNE	wall

	// w = DX:AX
	// convert to Unix epoch (but still 100ns units)
	#define delta 116444736000000000
	SUBL	$(delta & 0xFFFFFFFF), AX
	SBBL $(delta >> 32), DX

	// nano/100 = DX:AX
	// split into two decimal halves by div 1e9.