// 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 a

type A interface {
	M(i interface{}) interface{}
}

var a1 A
var a2 A

func V(p A, k, v interface{}) A {
	defer func() { a1, a2 = a2, a1 }()
	return a1

	}
}

// Ranger returns a Sender and a Receiver. The Receiver provides a
// Next method to retrieve values. The Sender provides a Send method
// to send values and a Close method to stop sending values. The Next
// method indicates when the Sender has been closed, and the Send
// method indicates when the Receiver has been freed.
//
// This is a convenient way to exit a goroutine sending values when

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

package a

type A struct {
	x int
}

type AI interface {
	bar()
}

type AC int

func (ab AC) bar() {
}

const (
	ACC = AC(101)
)

//go:noinline
func W(a A, k, v interface{}) A {
	return A{3}

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

package a

type T struct{ p *int64 }

type i struct{}

func G() *T { return &T{nil} }

func (j i) F(a, b *T) *T {
	n := *a.p + *b.p
	return &T{&n}
}

func (j i) G() *T {
	return &T{}
}

type I[Idx any] interface {
	G() Idx
	F(a, b Idx) Idx
}

func Gen() I[*T] {
	return i{}

// 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

type S struct{}

type A = S

// 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 a

var A int

func init() {
	A = 1
}

// 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

type A struct{}

func (a *A) f() bool {
	return true

		}
	}
	return true
}

// A Set is a set of elements of some type.
type Set[Elem comparable] struct {
	m map[Elem]struct{}
}

// Make makes a new set.
func Make[Elem comparable]() Set[Elem] {
	return Set[Elem]{m: make(map[Elem]struct{})}
}

// Add adds an element to a set.
func (s Set[Elem]) Add(v Elem) {
	s.m[v] = struct{}{}
}

// Delete removes an element from a set. If the element is not present

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

package a

import (
	"fmt"
)

// Element is an element of a linked list.
type Element[T any] struct {
	// Next and previous pointers in the doubly-linked list of elements.
	// To simplify the implementation, internally a list l is implemented
	// as a ring, such that &l.root is both the next element of the last

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

package a

// A StoppableWaitGroup waits for a collection of goroutines to finish.
type StoppableWaitGroup struct {
	// i is the internal counter which can store tolerate negative values
	// as opposed the golang's library WaitGroup.
	i *int64
}

// NewStoppableWaitGroup returns a new StoppableWaitGroup. When the 'Stop' is