var x50 [10<<20]byte
	var x51 [10<<20]byte
	var x52 [10<<20]byte
	var x53 [10<<20]byte
	var x54 [10<<20]byte
	var x55 [10<<20]byte
	var x56 [10<<20]byte
	var x57 [10<<20]byte
	var x58 [10<<20]byte
	var x59 [10<<20]byte
	var x60 [10<<20]byte
	var x61 [10<<20]byte
	var x62 [10<<20]byte
	var x63 [10<<20]byte
	var x64 [10<<20]byte
	var x65 [10<<20]byte
	var x66 [10<<20]byte
	var x67 [10<<20]byte
	var x68 [10<<20]byte

var copy_f1 = f1

// var copy_gx = gx
var copy_g0 = g0
var copy_g1 = g1

// var copy_ix = ix
var copy_i0 = i0
var copy_i1 = i1

// var copy_jx = jx
var copy_j0 = j0
var copy_j1 = j1

// var copy_cx = cx
var copy_c0 = c0
var copy_c1 = c1

// var copy_dx = dx
var copy_d0 = d0
var copy_d1 = d1

// var copy_sx = sx
var copy_s0 = s0
var copy_s1 = s1

// var copy_ax = ax

local var = g.dashboard.variable;

{
  datasource:
    var.datasource.new('datasource', 'prometheus'),

  cluster:
    var.query.new('cluster')
    + var.query.withDatasourceFromVariable(self.datasource)
    + var.query.queryTypes.withLabelValues(
      'cluster',
      'process_cpu_seconds_total',
    )
    + var.query.withRefresh('time')
    + var.query.selectionOptions.withMulti()

var c8 <- chan <- chan chan int = (<-chan (<-chan (chan int)))(nil)
var c9 <- chan chan <- chan int = (<-chan (chan<- (chan int)))(nil)
var c10 chan <- <- chan chan int = (chan<- (<-chan (chan int)))(nil)
var c11 chan <- chan <- chan int = (chan<- (chan<- (chan int)))(nil)
var c12 chan chan <- <- chan int = (chan (chan<- (<-chan int)))(nil)
var c13 chan chan <- chan <- int = (chan (chan<- (chan<- int)))(nil)

var r1 chan<- (chan int) = (chan <- chan int)(nil)

var _, _ = 1, 2
var _ = 1, 2 /* ERROR "extra init expr 2" */
var _, _ = 1 /* ERRORx `assignment mismatch: [1-9]+ variables but.*[1-9]+ value(s)?` */
var _, _, _ /* ERROR "missing init expr for _" */ = 1, 2

var _ = g /* ERROR "multiple-value g" */ ()
var _, _ = g()
var _, _, _ = g /* ERRORx `assignment mismatch: [1-9]+ variables but.*[1-9]+ value(s)?` */ ()

var _ = m["foo"]
var _, _ = m["foo"]

var Cham <type 1>;
var Cherokee <type 1>;
var Co <type 1>;
var Common <type 1>;
var Coptic <type 1>;
var Cs <type 1>;
var Cuneiform <type 1>;
var Cypriot <type 1>;
var Cyrillic <type 1>;
var Dash <type 1>;
var Deprecated <type 1>;
var Deseret <type 1>;
var Devanagari <type 1>;
var Diacritic <type 1>;
var Digit <type 1>;
var Duployan <type 1>;
var Egyptian_Hieroglyphs <type 1>;
var Elbasan <type 1>;

// Export internal functions and variable for testing.
var Log10NoVec = log10
var CosNoVec = cos
var CoshNoVec = cosh
var SinNoVec = sin
var SinhNoVec = sinh
var TanhNoVec = tanh
var Log1pNovec = log1p
var AtanhNovec = atanh
var AcosNovec = acos
var AcoshNovec = acosh
var AsinNovec = asin
var AsinhNovec = asinh
var ErfNovec = erf
var ErfcNovec = erfc
var AtanNovec = atan
var Atan2Novec = atan2
var CbrtNovec = cbrt

}

type T2 struct {
	w, z int
}

var _ = [42]T{
	{},
	{1, 2},
	{3, 4},
}

var _ = [...]T{
	{},
	{1, 2},
	{3, 4},
}

var _ = []T{
	{},
	{1, 2},
	{3, 4},
}

var _ = []T{
	{},
	10: {1, 2},
	20: {3, 4},
}

var _ = []struct {
	x, y int
}{
	{},
	10: {1, 2},
	20: {3, 4},
}

var _ = []interface{}{
	T{},
	10: T{1, 2},
	20: T{3, 4},

var bad5 = "a" + 'a' // ERROR "literals|incompatible|convert|invalid"

var bad6 int = 1.5       // ERROR "convert|truncate"
var bad7 int = 1e100     // ERROR "overflow|truncated to int|truncated"
var bad8 float32 = 1e200 // ERROR "overflow"

// but these implicit conversions are okay
var good1 string = "a"
var good2 int = 1.0
var good3 int = 1e9
var good4 float64 = 1e20

// explicit conversion of string is okay

package main

var m0 map[string]int
var m1 *map[string]int
var m2 *map[string]int = &m0
var m3 map[string]int = map[string]int{"a": 1}
var m4 *map[string]int = &m3

var s0 string
var s1 *string
var s2 *string = &s0
var s3 string = "a"
var s4 *string = &s3

var a0 [10]int
var a1 *[10]int
var a2 *[10]int = &a0

var b0 []int
var b1 *[]int
var b2 *[]int = &b0
var b3 []int = []int{1, 2, 3}