select {
	case c <- 1:
	}
}

func send3(recv func(<-chan int)) {
	c := make(chan int)
	go recv(c)
	runtime.Gosched()
	c2 := make(chan int)
	select {
	case c <- 1:
	case c2 <- 1:
	}
}

func main() {
	send1(recv1)
	send2(recv1)
	send3(recv1)
	send1(recv2)
	send2(recv2)
	send3(recv2)
	send1(recv3)
	send2(recv3)
	send3(recv3)

					panic("fail")
				}
				sleep()
			}
		}
		<-sync

		go i32sender(c32, sync)
		if buffer > 0 {
			<-sync
		}
		try = 0
	Recv32:
		for {
			select {
			case i32 = <-c32:
				break Recv32
			default:
				try++
				if try > maxTries {
					println("i32sender buffer=", buffer)
					panic("fail")
				}
				sleep()
			}
		}
		if i32 != 234 {

package main

type Recv <-chan int

type sliceOf[E any] interface {
	~[]E
}

func _Append[S sliceOf[T], T any](s S, t ...T) S {
	return append(s, t...)
}

func main() {
	recv := make(Recv)
	a := _Append([]Recv{recv}, recv)
	if len(a) != 2 || a[0] != recv || a[1] != recv {
		panic(a)
	}

	recv2 := make(chan<- int)
	a2 := _Append([]chan<- int{recv2}, recv2)

// channel, but this doesn't actually trigger the bug.
func mux(out chan<- int, in <-chan int, done chan<- bool) {
	for v := range in {
		out <- v
	}
	done <- true
}

// recver gets a steam of values from the four mux's and checks for duplicates.
func recver(in <-chan int) {
	seen := make(map[int]bool)

	for v := range in {
		if _, ok := seen[v]; ok {
			println("got duplicate value: ", v)
			panic("fail")
		}

	"golang.org/x/tools/internal/aliases"
)

// ReceiverNamed returns the named type (if any) associated with the
// type of recv, which may be of the form N or *N, or aliases thereof.
// It also reports whether a Pointer was present.
func ReceiverNamed(recv *types.Var) (isPtr bool, named *types.Named) {
	t := recv.Type()
	if ptr, ok := aliases.Unalias(t).(*types.Pointer); ok {
		isPtr = true
		t = ptr.Elem()
	}

	if x := c.Recv(); x != 1 {
		println("testasync1: Recv did not get 1:", x, c.Impl())
		failed = true
	}

	test1(c)
}

func testasync2(c Chan) {
	// should be able to get the last value via Recv2
	if x, ok := c.Recv2(); x != 1 || !ok {
		println("testasync1: Recv did not get 1, true:", x, ok, c.Impl())
		failed = true
	}

	test1(c)
}

func testasync3(c Chan) {

// Issue 2232.

package main

func recv(c chan interface{}) struct{} {
	return (<-c).(struct{})
}

var m = make(map[interface{}]int)

func recv1(c chan interface{}) {
	defer rec()
	m[(<-c).(struct{})] = 0
}

func rec() {
	recover()
}

func main() {
	c := make(chan interface{})
	go recv(c)
	c <- struct{}{}
	go recv1(c)
	c <- struct{}{}

	}

	// run the select
	base.Pos = sellineno
	chosen := typecheck.TempAt(base.Pos, ir.CurFunc, types.Types[types.TINT])
	recvOK := typecheck.TempAt(base.Pos, ir.CurFunc, types.Types[types.TBOOL])
	r := ir.NewAssignListStmt(base.Pos, ir.OAS2, nil, nil)
	r.Lhs = []ir.Node{chosen, recvOK}
	fn := typecheck.LookupRuntime("selectgo")
	var fnInit ir.Nodes

  RecvTPUEmbeddingActivationsOp recv_op;
  if (failed(GetOp(region, &recv_op))) return failure();

  SendTPUEmbeddingGradientsOp send_op;
  if (failed(GetOp(region, &send_op))) return failure();

  // No TPU embedding ops.
  if (!recv_op && !send_op) return success();

  Location loc = recv_op ? recv_op.getLoc() : send_op.getLoc();
  StringRef config = recv_op ? recv_op.getConfig() : send_op.getConfig();

	} else {
		m.send(message{Op: OpDisconnectClientMux, MuxID: m.ID})
	}
	// Unlock, since we are calling deleteMux, which will call close - which will lock recvMu.
	if locked {
		m.recvMu.Unlock()
		defer m.recvMu.Lock()
	}
	m.parent.deleteMux(true, m.ID)
}

func (m *muxServer) send(msg message) {
	m.sendMu.Lock()
	defer m.sendMu.Unlock()
	msg.MuxID = m.ID
	msg.Seq = m.SendSeq