// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

type S1 struct {
	s2 S2
}

type S2 struct{}

func (S2) Make() S2 {
	return S2{}
}

func (S1) Make() S1 {
	return S1{s2: S2{}.Make()}
}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

func f() {
	var i int
	var b *bool
	var s0, s1, s2 string

	if *b {
		s2 = s2[:1]
		i = 1
	}
	s1 = s1[i:-i+i] + s1[-i+i:i+2]
	s1 = s0[i:-i]

		t0 = xk[k+0] ^ te0[uint8(s0>>24)] ^ te1[uint8(s1>>16)] ^ te2[uint8(s2>>8)] ^ te3[uint8(s3)]
		t1 = xk[k+1] ^ te0[uint8(s1>>24)] ^ te1[uint8(s2>>16)] ^ te2[uint8(s3>>8)] ^ te3[uint8(s0)]
		t2 = xk[k+2] ^ te0[uint8(s2>>24)] ^ te1[uint8(s3>>16)] ^ te2[uint8(s0>>8)] ^ te3[uint8(s1)]
		t3 = xk[k+3] ^ te0[uint8(s3>>24)] ^ te1[uint8(s0>>16)] ^ te2[uint8(s1>>8)] ^ te3[uint8(s2)]
		k += 4
		s0, s1, s2, s3 = t0, t1, t2, t3
	}

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

package p1

import "./p0"

type T1 interface {
	p0.T0
	m1()
}

type S1 struct {
	p0.S0
}

func (S1) m1() {}

func NewT0() p0.T0 {
	return S1{}
}

func NewT1() T1 {
	return S1{}

	s := f
	f = math.Copysign(f, 1)
	u := math.Floor(f)
	return &S{
		u: int64(math.Copysign(u, s)),
		n: int32(math.Copysign((f-u)*1e9, s)),
	}
}

func main() {
	s1 := F1(-1)
	s2 := F2(-1)
	if *s1 != *s2 {
		println("F1:", s1.u, s1.n)
		println("F2:", s2.u, s2.n)
		panic("different")
	}

package main

import "reflect"

type S1 struct{}

func (S1) Fix() string {
	type s struct {
		f int
	}
	return reflect.TypeOf(s{}).Field(0).Name
}

type S2 struct{}

func (S2) Fix() string {
	type s struct {
		g bool
	}
	return reflect.TypeOf(s{}).Field(0).Name
}

func main() {
	f1 := S1{}.Fix()
	f2 := S2{}.Fix()
	if f1 != "f" || f2 != "g" {
		panic(f1 + f2)

		fail++
	}
}

type I1 interface { Get() int; Put(int) }

type S1 struct { i int }
func (p S1) Get() int { return p.i }
func (p S1) Put(i int) { p.i = i }

func f1() {
	s := S1{1}
	var i I1 = s
	i.Put(2)
	check(i.Get() == 1, "f1 i")
	check(s.i == 1, "f1 s")
}

func f2() {
	s := S1{1}
	var i I1 = &s
	i.Put(2)
	check(i.Get() == 1, "f2 i")
	check(s.i == 1, "f2 s")
}

	}

	// Create a pod with some configMaps.
	s1 := configMapsToAttach{
		containerEnvConfigMaps: []envConfigMaps{
			{envVarNames: []string{"s1"}},
			{envFromNames: []string{"s20"}},
		},
		volumes: []string{"s2"},
	}
	manager.RegisterPod(podWithConfigMaps("ns1", "name1", s1))
	manager.RegisterPod(podWithConfigMaps("ns2", "name2", s1))
	// Update the pod with a different configMaps.

func tUPiSPa() {
	s1 := "ant"
	s2 := "bat" // ERROR "moved to heap: s2$"
	s3 := "cat" // ERROR "moved to heap: s3$"
	s4 := "dog" // ERROR "moved to heap: s4$"
	s5 := "emu" // ERROR "moved to heap: s5$"
	s6 := "fox" // ERROR "moved to heap: s6$"
	ps2 := &s2
	ps4 := &s4 // ERROR "moved to heap: ps4$"
	ps6 := &s6 // ERROR "moved to heap: ps6$"
	u1 := U{&s1, &ps2}

func tUPiSPa() {
	s1 := "ant"
	s2 := "bat" // ERROR "moved to heap: s2$"
	s3 := "cat" // ERROR "moved to heap: s3$"
	s4 := "dog" // ERROR "moved to heap: s4$"
	s5 := "emu" // ERROR "moved to heap: s5$"
	s6 := "fox" // ERROR "moved to heap: s6$"
	ps2 := &s2
	ps4 := &s4 // ERROR "moved to heap: ps4$"
	ps6 := &s6 // ERROR "moved to heap: ps6$"
	u1 := U{&s1, &ps2}