t0 := time.Now()
	t1 := &delayTask{runAt: t0.Add(0)}
	t2 := &delayTask{runAt: t0.Add(1 * time.Hour)}
	t3 := &delayTask{runAt: t0.Add(2 * time.Hour)}
	t4 := &delayTask{runAt: t0.Add(3 * time.Hour)}
	sorted := []*delayTask{t1, t2, t3, t4}
	// fill in an unsorted order
	unsorted := []*delayTask{t4, t2, t3, t1}
	for _, task := range unsorted {
		heap.Push(pq, task)
	}

	// dequeue should be in order
	for i, task := range sorted {

  PrintTupleTo(t, os);
}

template <typename T1, typename T2, typename T3, typename T4>
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4>& t, ::std::ostream* os) {
  PrintTupleTo(t, os);
}

template <typename T1, typename T2, typename T3, typename T4, typename T5>
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5>& t,
             ::std::ostream* os) {
  PrintTupleTo(t, os);
}

	}()
	var i I = Tiny{}
	i.M()
}

// large receiver, so basic wrapper in i.M()
type T4 [2]string

func (T4) M() {
	mustRecoverBody(doubleRecover(), recover(), recover(), 12)
}

func test12() {
	var i I = T4{}
	defer i.M()
	panic(12)
}

func test12reflect1() {
	f := reflect.ValueOf(T4{}).Method(0).Interface().(func())
	defer f()
	panic(12)
}

func test12reflect2() {

func g[P interface{ m() P }](x P) { panic(0) }

// For now, a lone type parameter is not permitted as RHS in a type declaration (issue #45639).
// type T4[P any] P
// 
// func (_ T4[P]) m() T4[P]
// 
// func _[Q any](x Q) {
// 	g(T4[Q](x))
// }

// Another test case that caused  problems in the past

type T5[_ interface { a() }, _ interface{}] struct{}

type A[P any] struct{ x P }

func (t T) String() string { return fmt.Sprintf("T%d", int(t)) }

const (
	A T = 1 << (1 << iota)
	B
	C
	D
	E
)

func main() {
	s := fmt.Sprintf("%v %v %v %v %v", A, B, C, D, E)
	if s != "T2 T4 T16 T256 T65536" {
		println("type info didn't propagate in const: got", s)
		panic("fail")
	}
	x := uint(5)
	y := float64(uint64(1)<<x)	// used to fail to compile
	if y != 32 {
		println("wrong y", y)

// Helper function for implementing {EXPECT|ASSERT}_PRED4.  Don't use
// this in your code.
template <typename Pred,
          typename T1,
          typename T2,
          typename T3,
          typename T4>
AssertionResult AssertPred4Helper(const char* pred_text,
                                  const char* e1,
                                  const char* e2,
                                  const char* e3,

// CHECK-NEXT: %[[t3:.*]], %[[c3:.*]] = tfl.control_node controls "tfl.neg"(%[[t2]])
// CHECK-NEXT: %[[t4:.*]], %[[c4:.*]] = tfl.control_node(%[[c0]], %[[c1]], %[[c2]], %[[c3]]) controls "tfl.neg"(%[[t3]])

			Valu("t2", OpDiv64, c.config.Types.Int64, 0, nil, "t1", "v1"),
			Valu("t3", OpAdd64, c.config.Types.Int64, 0, nil, "t1", "t2"),
			Valu("t4", OpSub64, c.config.Types.Int64, 0, nil, "t3", "v2"),
			Valu("t5", OpMul64, c.config.Types.Int64, 0, nil, "t4", "v2"),
			Valu("t6", OpMod64, c.config.Types.Int64, 0, nil, "t5", "v2"),
			Valu("t7", OpAnd64, c.config.Types.Int64, 0, nil, "t6", "v2"),

  PrintTupleTo(t, os);
}

template <typename T1, typename T2, typename T3, typename T4>
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4>& t, ::std::ostream* os) {
  PrintTupleTo(t, os);
}

template <typename T1, typename T2, typename T3, typename T4, typename T5>
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5>& t,
             ::std::ostream* os) {
  PrintTupleTo(t, os);
}

// Methods with receiver base type declared in another file.
func (T3) m1() {}
func (*T3) m2() {}
func (x T3) m3() {}
func (x *T3) f /* ERROR "field and method" */ () {}

// Methods of non-struct type.
type T4 func()

func (self T4) m() func() { return self }

// Methods associated with an interface.
type T5 interface {
	m() int
}

func (T5 /* ERROR "invalid receiver" */ ) m1() {}