const (
	a = 1
	b = iota << a
	c = iota << b
	d
)

const (
	i = (a << iota) + (b * iota)
	j
	k
	l
)

const (
	m = iota == 0
	n
)

const (
	p = float32(iota)
	q
	r
)

const (
	s = string(iota + 'a')
	t
)

const (
	abit, amask = 1 << iota, 1<<iota - 1
	bbit, bmask = 1 << iota, 1<<iota - 1
	cbit, cmask = 1 << iota, 1<<iota - 1
)

func main() {

package foo_test

const (
	a = iota
	b
)

const (
	c = 3
	d = 4
)

const (
	e = iota
	f
)

// The example refers to only one of the constants in the iota group, but we
// must keep all of them because of the iota. The second group of constants can
// be trimmed. The third has an iota, but is unused, so it can be eliminated.

func Example() {
	_ = b
	_ = d

-- .Play --
package main

import ()

const (
	a = iota
	b
)

const d = 4

func main() {
	_ = b
	_ = d
}
-- 2.Play --
package main

import ()

func main() {

		_ = unsafe.Sizeof(func() { type _ [iota]byte })
		_ = unsafe.Sizeof(func() { func() int { return iota }() })
	)

	const (
		zero = iota
		one  = iota
		_    = unsafe.Sizeof(func() {
			var x [iota]int // [2]int
			var y [iota]int // [2]int
			const (
				Zero = iota
				One
				Two
				_ = unsafe.Sizeof([iota - 1]int{} == x) // assert types are equal

	const (
		zero	os.FileMode	= 0
		M1
		M2
		M3
	)

	// Package constants. 
	const (
		_	int	= iota
		I1
		I2
	)

	// Unexported constants counting from blank iota. See issue 9615. 
	const (
		_	= iota
		one	= iota + 1
	)


VARIABLES
	// 
	var _ = T(55)


FUNCTIONS
	// 
	func _()


TYPES
	// S has a padding field. 

type _ [iota /* ERROR "iota outside constant decl" */ ]byte
var _ = iota /* ERROR "iota outside constant decl" */
func _() {
	_ = iota /* ERROR "iota outside constant decl" */
	const _ = iota
	_ = iota /* ERROR "iota outside constant decl" */
}

func _() {
	iota := 123
	const x = iota /* ERROR "is not constant" */
	var y = iota
	_ = y
}

const (
	c = len([1 - iota]int{})
	d
	e // ERROR "invalid array length"
	f // ERROR "invalid array length"
)

// Test that identifiers in implicit (omitted) RHS
// expressions of constant declarations are resolved
// in the correct context; see issues #49157, #53585.
const X = 2

func _() {
	const (
		A    = iota // 0
		iota = iota // 1
		B           // 1 (iota is declared locally on prev. line)

package main

const X = 2

func main() {
	const (
		A    = iota // 0
		iota = iota // 1
		B           // 1 (iota is declared locally on prev. line)
		C           // 1
	)
	if A != 0 || B != 1 || C != 1 {
		println("got", A, B, C, "want 0 1 1")
		panic("FAILED")
	}

	const (
		X = X + X
		Y
		Z = iota
	)
	if X != 4 || Y != 8 || Z != 1 {
		println("got", X, Y, Z, "want 4 8 1")

// issue 1662
// iota inside var

package main

var (
	a = iota  // ERROR "undefined: iota|iota is only defined in const|cannot use iota outside constant declaration"
	b = iota  // ERROR "undefined: iota|iota is only defined in const|cannot use iota outside constant declaration"
	c = iota  // ERROR "undefined: iota|iota is only defined in const|cannot use iota outside constant declaration"

      return false;
    }
  }
  return true;
}

// It returns "true" when Value $iota is obtained from the following mlir code:
//
// $iota = "mhlo.iota"(){iota_dimension = $dimensions[0]},
//
// where $dimensions must have size 1 and iota can have rank>=1.
// It usually used for matching rank 1 iota since the iotaOp will be folded to
// IotaOp + BroadCastInDimOp except for the case when result shape is rank 1.