fn fixed() [4]int {
	return [1, 2, 3, 4]!
}

fn fixed_opt() ?[4]int {
	return [1, 2, 3, 4]!
}

fn multi_ret() ([4]int, bool) {
	return [1, 2, 3, 4]!, true
}

fn multi_ret_opt() (?[4]int, bool) {
	return [1, 2, 3, 4]!, true
}

fn multi_ret_opt_none() (?[4]int, bool) {
	return none, true
}

fn test_simple() {
	a := fixed()
	assert a.len == 4
}

fn test_simple_option() {
	b := fixed_opt()
	assert b?.len == 4
}

fn test_mr_fixed() {
	w, y := multi_ret()
	assert w.len == 4
	assert y == true
}

fn test_mr_fixed_opt() {
	w1, y1 := multi_ret_opt()
	assert w1?.len == 4
	assert y1 == true
}

fn test_mr_fixed_opt_none() {
	w2, y2 := multi_ret_opt_none()
	assert w2 == none
	assert y2 == true
}

fn four(a [4]int) [4]int {
	assert a.len == 4
	return a
}

fn test_passing_arg() {
	a := [1, 2, 3, 4]!
	b := four(a)
	assert b.len == 4
	c := four(b)
	assert c.len == 4
}

fn test_passing_opt_arg() {
	a := fixed_opt()
	four(a?)
}

fn test_assign() {
	mut a := [1, 2, 3, 4]!
	a = four(a)
	assert a.len == 4
	a = fixed_opt()?
	assert a.len == 4
	b := a
	assert b.len == 4
}

fn gn_fixed[T](a [4]T) [4]T {
	return a
}

fn test_generic() {
	b := [1, 2, 3, 4]!
	a := gn_fixed(b)
	c := gn_fixed(a)
}

fn test_inline() {
	mut a := [1, 2, 3, 4]!
	assert four(a)[1] == 2
}

fn f() [4]int {
	return [1, 2, 3, 4]!
}

fn test_simple_ret() {
	zzz := f()
	dump(zzz)
	dump(zzz[0])
}

fn g(a [4]int) {
}

fn test_arg_fixed() {
	zzz := f()
	g(zzz)
	g(f())
}

fn test_dump_ret() {
	zzz := f()
	a := dump(zzz)
	b := dump(zzz[0])
}