struct Chunk {
	val string
}

struct Kkk {
	q []Chunk
}

const (
	c_n = 5
)

struct Coord {
	x int
	y int
	z int
}

struct Numbers {
	odds  []int
	evens []int
}

struct Person {
	name string
	nums []int
	kv   map[string]string
}

// test array add in function with mut argument
fn add_nums(mut arr []int) {
	arr << 4
}

const (
	grid_size_1 = 2
	grid_size_2 = 3
	grid_size_3 = 4
	cell_value  = 123
)

struct User {
	age  int
	name string
}

struct Foo {
mut:
	bar []int
}

fn array_in_mut(mut a []int) {
	if 1 in a {
		a[0] = 2
	}
}

fn mut_arr_with_eq_in_fn(mut a []int) {
	if a == [1, 2, 3, 4] {
		a[0] = 0
	}
	if [0, 2, 3, 4] == a {
		a[1] = 0
	}
	if !(a != [0, 0, 3, 4]) {
		a[2] = 0
	}
	if !([0, 0, 0, 4] != a) {
		a[3] = 0
	}
}

fn map_test_helper_1(i int) int {
	return i * i
}

fn map_test_helper_2(i int, b string) int {
	return i + b.len
}

fn map_test_helper_3(i int, b []string) int {
	return i + b.map(it.len)[i % b.len]
}

fn filter_test_helper_1(a int) bool {
	return a > 3
}

fn sum(prev int, curr int) int {
	return prev + curr
}

fn sub(prev int, curr int) int {
	return prev - curr
}

struct Foooj {
	a [5]int // c_n
}

fn double_up(mut a []int) {
	for i := 0; i < a.len; i++ {
		a[i] = a[i] * 2
	}
}

fn double_up_v2(mut a []int) {
	for i, _ in a {
		a[i] = a[i] * 2 // or val*2, doesn't matter
	}
}

fn modify(mut numbers []int) {
	numbers[0] = 777
}

fn main() {
	{
		// test pointer
		mut arr := []&int{}
		a := 1
		b := 2
		c := 3
		arr << &a
		arr << &b
		arr << &c
		assert *arr[0] == 1
		arr[1] = &c
		assert *arr[1] == 3
		mut d_arr := [arr] // [][]&int
		d_arr << arr
		println(*d_arr[0][1]) // 3
		println(*d_arr[1][0]) // 1
	}
	{
		// test assign
		mut arr := [2, 4, 8, 16, 32, 64, 128]
		arr[0] = 2
		arr[1] &= 255
		arr[2] |= 255
		arr[3] <<= 4
		arr[4] >>= 4
		arr[5] %= 5
		arr[6] ^= 3
		println(arr[0])
		println(arr[1])
		println(arr[2])
		println(arr[3])
		println(arr[4])
		println(arr[5])
		println(arr[6])
	}
	{
		// test ints
		mut a := [1, 5, 2, 3]
		println(a.len) // 4
		println(a[0])
		println(a[2])
		println(a.last())

		a << 4
		println(a.len)
		println(a[4])
		println(a.last())

		s := a.str()
		println(s)
		println(a[1])
		println(a.last())
	}
	{
		// test deleting
		mut a := [1, 5, 2, 3, 4]

		println(a.len)
		println(a.str())

		a.delete(0)

		println(a.str())
		println(a.len) // 4

		a.delete(1)

		println(a.str())
		println(a.len)
		a.delete(a.len - 1)

		println(a.str())
		println(a.len)
	}
	{
		// test slice delete
		mut a := [1.5, 2.5, 3.25, 4.5, 5.75]
		b := a[2..4]
		a.delete(0)
		// assert a == [2.5, 3.25, 4.5, 5.75]
		// assert b == [3.25, 4.5]
		println(a)
		println(a == [2.5, 3.25, 4.5, 5.75])
		println(b == [3.25, 4.5])
		a = [3.75, 4.25, -1.5, 2.25, 6.0]
		c := a[..3]
		a.delete(2)
		println(a == [3.75, 4.25, 2.25, 6.0])
		println(c == [3.75, 4.25, -1.5])
	}
	{
		// test delete many
		mut a := [1, 2, 3, 4, 5, 6, 7, 8, 9]
		b := a[2..6]
		a.delete_many(4, 3)
		println(a == [1, 2, 3, 4, 8, 9])
		println(b == [3, 4, 5, 6])

		c := a[..a.len]
		a.delete_many(2, 0) // this should just clone
		a[1] = 17

		println(a == [1, 17, 3, 4, 8, 9])
		println(c == [1, 2, 3, 4, 8, 9])
		a.delete_many(0, a.len)
		println(a == []int{})
	}
	{
		// test short
		a := [1, 2, 3]
		println(a.len == 3)
		println(a.cap == 3)
		println(a[0])
		println(a[1])
		println(a[2])
	}
	{
		// test large
		mut a := [0].repeat(0)
		for i in 0 .. 10000 {
			a << i
		}
		println(a.len)
		println(a[234])
	}
	{
		// test empty
		mut chunks := []Chunk{}
		a := Chunk{}
		println(chunks.len)
		chunks << a
		println(chunks.len)
		chunks = []
		println(chunks.len)
		chunks << a
		println(chunks.len)
	}
	{
		// test push
		mut a := []int{}
		a << 1
		a << 3
		println(a[1])
		println(a.str())
	}
	{
		// test insert
		mut a := [1, 2]
		a.insert(0, 3)
		println(a[0])
		println(a[2])
		println(a.len)
		a.insert(1, 4)
		println(a[1])
		println(a[2])
		println(a.len)
		a.insert(4, 5)
		println(a[4])
		println(a[3])
		println(a.len)
		mut b := []f64{}
		println(b.len)
		b.insert(0, f64(1.1))
		println(b.len)
		println(b[0])
	}
	{
		// test insert many
		mut a := [3, 4]
		a.insert(0, [1, 2])
		println(a)

		b := [5, 6]
		a.insert(1, b)
		println(a)
	}
	{
		// test prepend
		mut a := []int{}
		println(a.len)
		a.prepend(1)
		println(a.len)
		println(a[0])
		mut b := []f64{}

		println(b.len)

		b.prepend(f64(1.1))

		println(b.len)

		println(b[0])
	}
	{
		// test prepend many
		mut a := [3, 4]
		a.prepend([1, 2])
		println(a)
		b := [5, 6]
		a.prepend(b)
		println(a)
	}
	{
		// test repeat
		{
			a := [0].repeat(5)
			println(a.len)
			println(a[0] == 0 && a[1] == 0 && a[2] == 0 && a[3] == 0 && a[4] == 0)
		}
		{
			a := [1.1].repeat(10)
			println(a[0])
			println(a[5])
			println(a[9])
		}
		{
			a := [i64(-123)].repeat(10)
			println(a[0])
			println(a[5])
			println(a[9])
		}
		{
			a := [u64(123)].repeat(10)
			println(a[0])
			println(a[5])
			println(a[9])
		}
		{
			a := [1.1].repeat(10)
			println(a[0])
			println(a[5])
			println(a[9])
		}
		{
			a := [1, 2].repeat(2)
			println(a[0])
			println(a[1])
			println(a[2])
			println(a[3])
		}
		{
			a := ['1', 'abc'].repeat(2)
			println(a[0])
			println(a[1])
			println(a[2])
			println(a[3])
		}
		{
			mut a := ['1', 'abc'].repeat(0)
			println(a.len)
			a << 'abc'
			println(a[0])
		}
	}
	{
		// todo(playX): deep repeat does not yet work.
		/*
		// test deep repeat
		mut a3 := [[[1, 1], [2, 2], [3, 3]], [[4, 4], [5, 5], [6, 6]]]
		r := a3.repeat(3)
		a3[1][1][0] = 17
		print(r)
		assert r == [
			[[1, 1], [2, 2], [3, 3]],
			[[4, 4], [5, 5], [6, 6]],
			[[1, 1], [2, 2], [3, 3]],
			[[4, 4], [5, 5], [6, 6]],
			[[1, 1], [2, 2], [3, 3]],
			[[4, 4], [5, 5], [6, 6]],
		]
		assert a3 == [[[1, 1], [2, 2], [3, 3]], [[4, 4], [17, 5],
			[6, 6],
		]]
		*/
	}
	{
		// test right
		a := [1, 2, 3, 4]
		c := a[1..a.len]
		d := a[1..]
		println(c[0])
		println(c[1])
		println(d[0])
		println(d[1])
	}
	{
		// test left
		a := [1, 2, 3]
		c := a[0..2]
		d := a[..2]
		println(c[0])
		println(c[1])
		println(d[0])
		println(d[1])
	}
	{
		// test slice
		a := [1, 2, 3, 4]
		b := a[2..4]
		println(b.len)
		println(a[1..2].len)
		println(a.len)
	}
	{
		// test push many
		mut a := [1, 2, 3]
		b := [4, 5, 6]
		a << b
		println(a.len)
		println(a[0])
		println(a[3])
		println(a[5])
	}
	{
		// test reverse
		a := [1, 2, 3, 4]
		b := ['test', 'array', 'reverse']
		c := a.reverse()
		println(c)
		d := b.reverse()
		for i, _ in c {
			println(c[i] == a[a.len - i - 1])
		}
		for i, _ in d {
			println(d[i] == b[b.len - i - 1])
		}
		e := []int{}
		f := e.reverse()
		println(f.len)
	}
	{
		// test fixed
		mut nums := [4]int{}
		// x := nums[1..3]
		// assert x.len == 2

		println(nums)
		nums[1] = 7
		println(nums)
		nums2 := [5]int{} // c_n
		println(nums2[c_n - 1])
	}
	{
		// test mut slice
		/*
		todo(playX): slices do not work yet. We have to implement custom wrapper for them.
		mut n := [1, 2, 3]
		// modify(mut n)
		modify(mut n[..2])
		assert n[0] == 777
		modify(mut n[2..])
		assert n[2] == 777
		println(n)
		*/
	}
	{
		// test mut arg
		mut arr := [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
		double_up(mut arr)
		println(arr.str())
		arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
		double_up_v2(mut arr)
		println(arr.str())
	}
	{
		// test doubling
		mut nums := [1, 2, 3, 4, 5]
		for i in 0 .. nums.len {
			nums[i] *= 2
		}
		println(nums.str())
	}
	{
		// test single element

		mut a := [1]
		a << 2
		println(a.len)
		assert a[0] == 1
		assert a[1] == 2
		println(a)
	}
	{
		// test find index

		// string
		a := ['v', 'is', 'great']
		println(a.index('v'))
		println(a.index('is'))
		println(a.index('gre'))
		// int
		b := [1, 2, 3, 4]
		println(b.index(1))
		println(b.index(4))
		println(b.index(5))
		// byte
		c := [0x22, 0x33, 0x55]
		println(c.index(0x22))
		println(c.index(0x55))
		println(c.index(0x99))
		// char
		d := [`a`, `b`, `c`]
		println(d.index(`b`))
		println(d.index(`c`))
		println(d.index(`u`))
	}
	{
		// test multi

		a := [[1, 2, 3], [4, 5, 6]]
		println(a.len)
		println(a[0].len)
		println(a[0][0])
		println(a[0][2])
		println(a[1][2])
	}
	{
		// test in
		a := [1, 2, 3]
		println(1 in a)
		println(2 in a)
		println(3 in a)
		println(4 !in a)
		println(0 !in a)
		println(0 !in a)
		println(4 !in a)
		b := [1, 4, 0]
		c := [3, 6, 2, 0]
		println(0 in b)
		println(0 in c)
	}
	{
		// test reduce
		a := [1, 2, 3, 4, 5]
		b := a.reduce(sum, 0)
		c := a.reduce(sum, 5)
		d := a.reduce(sum, -1)
		println(b)
		println(c)
		println(d)
		e := [1, 2, 3]
		f := e.reduce(sub, 0)
		g := e.reduce(sub, -1)
		println(f)
		println(g)
	}
	{
		a := [1, 2, 3, 4, 5, 6]
		b := a.filter(it % 2 == 0)
		println(b)

		c := ['v', 'is', 'awesome']
		d := c.filter(it.len > 1)
		println(d)
		assert d[0] == 'is'
		assert d[1] == 'awesome'
		////////
		arr := [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
		println(arr.filter(it % 2 == 0 || it % 3 == 0))

		mut mut_arr := [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
		mut_arr = mut_arr.filter(it < 4)
		assert mut_arr.len == 3
		println(a.filter(filter_test_helper_1))
		println([1, 5, 10].filter(filter_test_helper_1))
	}
	{
		// test anon fn filter
		filter_num := fn (i int) bool {
			return i % 2 == 0
		}
		println([1, 2, 3, 4, 5].filter(filter_num))
	}
	{
		a := [1, 2, 3, 4].filter(fn (i int) bool {
			return i % 2 == 0
		})
		println(a)
	}
	{
		// test map
		nums := [1, 2, 3, 4, 5, 6]
		strs := ['v', 'is', 'awesome']
		// assert nums.map() == <error>
		// assert nums.map(it, 'excessive') == <error>
		// identity
		println(nums.map(it))
		println(strs.map(it))
		println(nums.map(it - it))
		println(nums.map(it - it)[0])
		// type switch
		println(nums.map(it * 10))
		println(nums.map(it * it))
		println(nums.map('$it'))
		println(nums.map(it % 2 == 0))
		println(strs.map(it.to_upper()))
		println(strs.map(it == 'awesome'))
		println(strs.map(it.len in nums))
		println(strs.map(int(7)))
		// external func
		println(nums.map(map_test_helper_1(it)))
		println(nums.map(map_test_helper_2(it, 'bb')))
		println(nums.map(map_test_helper_3(it, strs)))
		// empty array as input
		println([]int{len: 0}.map(it * 2))
		// nested maps (where it is of same type)
		println(nums.map(strs.map(int(7)) == [7, 7, 7]))
		println(nums.map('$it' + strs.map('a')[0]))
		// assert nums.map(it + strs.map(int(7))[0]) == [8, 9, 10, 11, 12, 13]
		println(nums.map(it + strs.map(it.len)[0]))
		println(strs.map(it.len + strs.map(it.len)[0]))
		// nested (different it types)
		// todo(playX): this one produces invalid JS code.
		// assert strs.map(it[nums.map(it - it)[0]]) == [byte(`v`), `i`, `a`]
		println(nums[0..3].map('$it' + strs.map(it)[it - 1]))
		println(nums.map(map_test_helper_1))
		println([1, 5, 10].map(map_test_helper_1))
		println(nums)
		println(strs)
	}
	{
		// test anon fn map
		add_num := fn (i int) int {
			return i + 1
		}
		println([1, 2, 3].map(add_num))
	}
	{
		// test multi anon fn map
		a := [1, 2, 3].map(fn (i int) int {
			return i + 1
		})
		b := [1, 2, 3].map(fn (i int) int {
			return i + 2
		})
		println(a)
		println(b)
	}
	{
		// test anon fn arg map
		a := [1, 2, 3].map(fn (i int) int {
			return i + 1
		})
		println(a)
	}
	{
		// test anon fn arg different type map
		i_to_str := fn (i int) string {
			return i.str()
		}
		a := [1, 2, 3].map(i_to_str)
		println(a)
	}
	{
		// test anon fn inline different type map
		a := [1, 2, 3].map(fn (i int) string {
			return i.str()
		})
		println(a)
	}
	{
		// test array str

		numbers := [1, 2, 3]
		assert numbers == [1, 2, 3]
		numbers2 := [numbers, [4, 5, 6]] // dup str() bug
		println(numbers2)
		assert true
		assert numbers.str() == '[1, 2, 3]'
	}
	{
		// test eq
		println([5, 6, 7] != [6, 7])
		println([`a`, `b`] == [`a`, `b`])
		println([User{
			age: 22
			name: 'bob'
		}] == [User{
			age: 22
			name: 'bob'
		}])
		// todo(playX): map cmp does not work yet
		/*
		assert [map{
			'bob': 22
		}, map{
			'tom': 33
		}] == [map{
			'bob': 22
		}, map{
			'tom': 33
		}]*/
		println([[1, 2, 3], [4]] == [[1, 2, 3], [4]])
	}
	{
		// test fixed array eq
		a1 := [1, 2, 3]!
		println(a1 == [1, 2, 3]!)
		println(a1 != [2, 3, 4]!)

		a2 := [[1, 2]!, [3, 4]!]!
		println(a2 == [[1, 2]!, [3, 4]!]!)
		println(a2 != [[3, 4]!, [1, 2]!]!)

		a3 := [[1, 2], [3, 4]]!
		println(a3 == [[1, 2], [3, 4]]!)
		println(a3 != [[1, 1], [2, 2]]!)

		a4 := [[`a`, `b`], [`c`, `d`]]!
		println(a4 == [[`a`, `b`], [`c`, `d`]]!)
		println(a4 != [[`c`, `a`], [`a`, `b`]]!)

		a5 := [['aaa', 'bbb'], ['ccc', 'ddd']]!
		println(a5 == [['aaa', 'bbb'], ['ccc', 'ddd']]!)
		println(a5 != [['abc', 'def'], ['ccc', 'ddd']]!)

		a6 := [['aaa', 'bbb']!, ['ccc', 'ddd']!]!
		println(a6 == [['aaa', 'bbb']!, ['ccc', 'ddd']!]!)
		println(a6 != [['aaa', 'bbb']!, ['aaa', 'ddd']!]!)

		a7 := [[1, 2]!, [3, 4]!]
		println(a7 == [[1, 2]!, [3, 4]!])
		println(a7 != [[2, 3]!, [1, 2]!])

		a8 := [['aaa', 'bbb']!, ['ccc', 'ddd']!]
		println(a8 == [['aaa', 'bbb']!, ['ccc', 'ddd']!])
		println(a8 != [['bbb', 'aaa']!, ['cccc', 'dddd']!])
	}
	{
		// test fixed array literal eq
		println([1, 2, 3]! == [1, 2, 3]!)
		println([1, 1, 1]! != [1, 2, 3]!)

		println([[1, 2], [3, 4]]! == [[1, 2], [3, 4]]!)
		println([[1, 1], [2, 2]]! != [[1, 2], [3, 4]]!)

		println([[1, 1]!, [2, 2]!]! == [[1, 1]!, [2, 2]!]!)
		println([[1, 1]!, [2, 2]!]! != [[1, 2]!, [2, 3]!]!)

		println([[1, 1]!, [2, 2]!] == [[1, 1]!, [2, 2]!])
		println([[1, 1]!, [2, 2]!] != [[1, 2]!, [2, 3]!])
	}
	{
		// test sort
		mut a := ['hi', '1', '5', '3']
		a.sort()
		println(a)

		mut nums := [67, -3, 108, 42, 7]
		nums.sort()
		println(nums)
		assert nums[0] == -3
		assert nums[1] == 7
		assert nums[2] == 42
		assert nums[3] == 67
		assert nums[4] == 108
		// todo(playX): add codegen for comparator fn passed
		/*
		nums.sort(a < b)
		assert nums[0] == -3
		assert nums[1] == 7
		assert nums[2] == 42
		assert nums[3] == 67
		assert nums[4] == 108

		mut users := [User{22, 'Peter'}, User{20, 'Bob'}, User{25, 'Alice'}]
		users.sort(a.age < b.age)
		assert users[0].age == 20
		assert users[1].age == 22
		assert users[2].age == 25
		assert users[0].name == 'Bob'
		assert users[1].name == 'Peter'
		assert users[2].name == 'Alice'

		users.sort(a.age > b.age)
		assert users[0].age == 25
		assert users[1].age == 22
		assert users[2].age == 20

		users.sort(a.name < b.name) // Test sorting by string fields
		*/
	}
	{
		/*
		// test rune sort
		mut bs := [`f`, `e`, `d`, `b`, `c`, `a`]
		bs.sort()
		println(bs)*/

		/*
		bs.sort(a > b)
		println(bs)
		assert '$bs' == '[`f`, `e`, `d`, `c`, `b`, `a`]'

		bs.sort(a < b)
		println(bs)
		assert '$bs' == '[`a`, `b`, `c`, `d`, `e`, `f`]'
		*/
	}
	{
		// test f32 sort
		mut f := [f32(50.0), 15, 1, 79, 38, 0, 27]
		f.sort()
		println(f[0])
		println(f[1])
		println(f[6])
	}
	{
		// test f64 sort
		mut f := [50.0, 15, 1, 79, 38, 0, 27]
		f.sort()
		println(f)
		assert f[0] == 0.0
		assert f[1] == 1.0
		assert f[6] == 79.0
	}
	{
		// test i64 sort
		mut f := [i64(50), 15, 1, 79, 38, 0, 27]
		f.sort()
		println(f)
		assert f[0] == 0
		assert f[1] == 1
		assert f[6] == 79
	}
	{
		// test in struct

		mut baz := Foo{
			bar: [0, 0, 0]
		}
		baz.bar[0] += 2
		baz.bar[0]++
		println(baz.bar[0])
	}
	{
		// test direct modification
		mut foo := [2, 0, 5]
		foo[1] = 3
		foo[0] *= 7
		foo[1]--
		foo[2] -= 2
		println(foo)
	}
	{
		// test bools
		println('test b')
		mut a := [true, false]
		a << true
		println(a)
	}
	{
		// test push many self
		mut actual_arr := [1, 2, 3, 4]
		actual_arr << actual_arr
		expected_arr := [1, 2, 3, 4, 1, 2, 3, 4]
		assert actual_arr.len == expected_arr.len
		for i in 0 .. actual_arr.len {
			print(actual_arr[i])
			print(',')
			println(expected_arr[i])
		}
	}
	{
		// test for
		nums := [1, 2, 3]
		mut sum := 0
		for num in nums {
			sum += num
		}
		println(sum)
	}
	{
		// test left shift precedence

		mut arr := []int{}
		arr << 1 + 1
		arr << 1 - 1
		arr << 2 / 1
		arr << 2 * 1
		println(arr)
	}
	{
		// todo(playX): what we should do with cap on the JS backend?
		/*
		// test array with cap
		a4 := []int{len: 1, cap: 10}
		println(a4.cap)
		assert a4.len == 1
		assert a4.cap == 10
		a5 := []int{len: 1, cap: 10}
		assert a5.len == 1
		assert a5.cap == 10
		*/
	}
	{
		// test multi array index
		mut a := [][]int{len: 2, init: []int{len: 3, init: 0}}
		a[0][0] = 1
		println('$a')
		mut b := [[0].repeat(3)].repeat(2)
		b[0][0] = 1
		println('$b')
	}
	{
		// test plus assign string
		mut a := ['']
		a[0] += 'abc'

		println(a)
	}
	{
		// test mut arr with eq in fn
		mut a := [1, 2, 3, 4]
		mut_arr_with_eq_in_fn(mut a)
		println(a)
	}
	{
		// test array in mut
		mut a := [1, 2]
		array_in_mut(mut a)
		println(a)
	}
	{
		mut nums := [1, 2, 3]
		add_nums(mut nums)
		println(nums)
	}
	{
		// test reverse in place
		mut a := [1, 2, 3, 4]
		a.reverse_in_place()
		println(a)
		mut b := ['a', 'b', 'c']
		b.reverse_in_place()
		println(b)
		mut c := [[1, 2], [3, 4], [5, 6]]
		c.reverse_in_place()
		println(c)
	}
	{
		// test array int pop
		mut a := [1, 2, 3, 4, 5]
		assert a.len == 5
		x := a.last()
		y := a.pop()
		println('$x,$y')
		assert a.len == 4
		z := a.pop()
		assert a.len == 3
		println(z)
		a.pop()
		a.pop()
		final := a.pop()
		println(final)
	}
	{
		// test array string pop
		mut a := ['abc', 'def', 'xyz']
		assert a.len == 3
		println(a.pop())
		println(a.pop())
		println(a.pop())
		assert a.len == 0
	}
	{
		// test array first
		a := [3]
		println(a.first())
		b := [1, 2, 3, 4]
		println(b.first())
		c := ['abc', 'def']
		println(c.first())
		// todo(playX): we should implement byte str cmp

		s := [Chunk{'a'}]
		println(s.first().val)
	}
	{
		// test array last
		a := [3]
		println(a.last())
		b := [1, 2, 3, 4]
		println(b.last())
		c := ['abc', 'def']
		println(c.last())
		s := [Chunk{'a'}]
		println(s.last().val)
	}
	{
		// test direct array access
		mut a := [11, 22, 33, 44]
		println(a[0])
		println(a[2])
		x := a[0]
		a[0] = 21
		a[1] += 2
		a[2] = x + 3
		a[3] -= a[1]
		println(a)
	}
	{
		// test multidimensional array initialization with consts
		mut data := [][][]int{len: grid_size_1, init: [][]int{len: grid_size_2, init: []int{len: grid_size_3, init: cell_value}}}
		println(data.len)
		println(data[0].len)
		println(data[0][0].len)
		println(data[0][0][0])
		println(data[1][1][1])
	}
	{
		// test multi array prepend
		mut a := [][]int{}
		a.prepend([1, 2, 3])
		println(a)
		mut b := [][]int{}
		b.prepend([[1, 2, 3]])
		println(b)
	}
	{
		// test multi array insert
		mut a := [][]int{}
		a.insert(0, [1, 2, 3])
		println(a)
		mut b := [][]int{}
		b.insert(0, [[1, 2, 3]])
		println(b)
	}
	{
		// test multi array in
		a := [[1]]
		println([1] in a)
	}
	{
		// test any type array contains
		a := [true, false]
		println(a.contains(true))
		println(true in a)
		println(a.contains(false))
		println(false in a)
		b := [i64(2), 3, 4]
		println(b.contains(i64(3)))
		println(5 !in b)
		c := [[1], [2]]
		println(c.contains([1]))
		println([2] in c)
		println([3] !in c)
	}
	{
		// test struct array of multi type in
		ivan := Person{
			name: 'ivan'
			nums: [1, 2, 3]
			kv: {
				'aaa': '111'
			}
		}
		people := [
			Person{
				name: 'ivan'
				nums: [1, 2, 3]
				kv: {
					'aaa': '111'
				}
			},
			Person{
				name: 'bob'
				nums: [2]
				kv: {
					'bbb': '222'
				}
			},
		]
		println(ivan in people)
	}
	{
		// test struct array of multi type index
		ivan := Person{
			name: 'ivan'
			nums: [1, 2, 3]
			kv: {
				'aaa': '111'
			}
		}
		people := [
			Person{
				name: 'ivan'
				nums: [1, 2, 3]
				kv: {
					'aaa': '111'
				}
			},
			Person{
				name: 'bob'
				nums: [2]
				kv: {
					'bbb': '222'
				}
			},
		]
		println(people.index(ivan))
		assert people.index(ivan) == 0
	}
	{
		// test array struct contains

		mut coords := []Coord{}
		coord_1 := Coord{
			x: 1
			y: 2
			z: -1
		}
		coords << coord_1
		exists := coord_1 in coords
		not_exists := coord_1 !in coords
		println('`exists`: $exists and `not exists`: $not_exists')
		assert exists == true
		assert not_exists == false
	}
	{
		// test array of array append
		mut x := [][]int{len: 4}
		println(x) // OK
		x[2] << 123 // RTE
		println(x)
	}
	{
		// test array of map insert
		mut x := []map[string]int{len: 4}
		println(x) // OK
		x[2]['123'] = 123 // RTE
		println(x)
	}
	{
		// todo(playX): does not work
		/*
		// test multi fixed array init
		a := [3][3]int{}
		println(a)
		*/
	}
	{
		// test array of multi filter
		arr := [1, 2, 3, 4, 5]
		nums := Numbers{
			odds: arr.filter(it % 2 == 1)
			evens: arr.filter(it % 2 == 0)
		}
		println(nums)
		assert nums.odds == [1, 3, 5]
		assert nums.evens == [2, 4]
	}
	{
		// test array of multi map
		arr := [1, 3, 5]
		nums := Numbers{
			odds: arr.map(it + 2)
			evens: arr.map(it * 2)
		}
		println(nums)
		assert nums.odds == [3, 5, 7]
		assert nums.evens == [2, 6, 10]
	}
	{
		// test multi fixed array with default init
		a := [3][3]int{init: [3]int{init: 10}}
		println(a)
		assert a == [[10, 10, 10]!, [10, 10, 10]!, [10, 10, 10]!]!
	}
}