// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

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

// Test nil.

package main

import (
	"fmt"
	"time"
)

type T struct {
	i int
}

type IN interface{}

func main() {
	var i *int
	var f *float32
	var s *string
	var m map[float32]*int
	var c chan int
	var t *T
	var in IN
	var ta []IN

	i = nil
	f = nil

*/

package watch_test

import (
	"fmt"
	"io"
	"reflect"
	"testing"
	"time"

	"k8s.io/apimachinery/pkg/runtime"
	. "k8s.io/apimachinery/pkg/watch"
)

type fakeDecoder struct {
	items chan Event
	err   error
}

func (f fakeDecoder) Decode() (action EventType, object runtime.Object, err error) {
	if f.err != nil {
		return "", nil, f.err
	}
	item, open := <-f.items
	if !open {

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

}

func ChainMulBytes(a, b, c byte) byte {
	return a*(a*(a*(a*(a*(a*(a*(a*(a*b+c)+c)+c)+c)+c)+c)+c)+c) + c
}

func ChainCap() {
	select {
	case <-make(chan int, cap(make(chan int, cap(make(chan int, cap(make(chan int, cap(make(chan int))))))))):
	default:
	}

// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package f1

type Foo struct {
	doneChan chan bool
	Name     string
	fOO      int
	hook     func()
}

func (f *Foo) Exported() {
}

func (f *Foo) unexported() {

// compile

// Copyright 2024 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

const run = false

func f() {
	if !run {
		return
	}

	messages := make(chan struct{}, 1)
main:
	for range messages {
		break main
	}

package bpool

import "github.com/klauspost/reedsolomon"

// BytePoolCap implements a leaky pool of []byte in the form of a bounded channel.
type BytePoolCap struct {
	c    chan []byte
	w    int
	wcap int
}

// NewBytePoolCap creates a new BytePool bounded to the given maxSize, with new
// byte arrays sized based on width.

// compile

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

func f[T ~chan E, E any](e E) T {
	ch := make(T)
	go func() {
		defer close(ch)
		ch <- e
	}()
	return ch

// compile

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package bug071

type rat struct  {
	den  int;
}

func (u *rat) pr() {
}

type dch struct {
	dat chan  *rat;
}

func dosplit(in *dch){
	dat := <-in.dat;
	_ = dat;