// statesNum: number of possibilities (empty, fill, exhange)*bunckets
const statesNum = 6
// State represents a bucket pair state.
type State [2]int

type States [][2]int

type States []State

	var discardState State // this represents the opposite starting bucket state

	var discardState [2]int // this represents the opposite starting bucket state

		discardState = [2]int{0, sizeBucketTwo}

		discardState = State{0, sizeBucketTwo}

		discardState = [2]int{sizeBucketOne, 0}

		discardState = State{sizeBucketOne, 0}

	stp++

	states[0] = [2]int{b1, b2}

	states[0] = State{b1, b2}
	stp++

		var childs States
		// log.Println(oldStatesSize)
		for _, st := range states[oldStatesSize:] {
			childs = append(childs, genStates(st[0], st[1], sizeBucketOne, sizeBucketTwo)...)

		// log.Println("states:\t", states)
		var childs = make(States, statesNum*(len(states[oldStatesSize:])))
		for i, st := range states[oldStatesSize:] {
			sts := genStates(st[0], st[1], sizeBucketOne, sizeBucketTwo)
			for j := 0; j < statesNum; j++ {
				// log.Printf("%d:%d:%v ", i, j, sts[j])
				childs[statesNum*i+j] = sts[j]
			}

		// log.Println(len(childs), childs)

		// log.Println("states:", states)

func (sts States) contains(s [2]int) bool {

func (sts States) contains(s State) bool {

func genStates(b1, b2, sizeBucketOne, sizeBucketTwo int) [statesNum]State {
	// log.Println("genStates input values (b1,b2,s1,s2): ", b1, b2, sizeBucketOne, sizeBucketTwo)

func genStates(b1, b2, sizeBucketOne, sizeBucketTwo int) States {
	// log.Println("genStates input values (b1,b2,s1,s2): ", b1, b2, sizeBucketOne, sizeBucketTwo)
	var sts States

	var sts [statesNum]State

	sts = append(sts, [2]int{b1, 0})
	sts = append(sts, [2]int{0, b2})

	sts[0] = State{b1, 0}
	sts[1] = State{0, b2}

	sts = append(sts, [2]int{b1, sizeBucketTwo})
	sts = append(sts, [2]int{sizeBucketOne, b2})
	var origb1 = b1
	var origb2 = b2

	sts[2] = State{b1, sizeBucketTwo}
	sts[3] = State{sizeBucketOne, b2}

	for b2 < sizeBucketTwo && b1 > 0 {
		b1--
		b2++

	if sizeBucketTwo-b2 >= b1 {
		sts[4] = State{0, b1 + b2}
	} else {
		sts[4] = State{b1 - (sizeBucketTwo - b2), b2 + (sizeBucketTwo - b2)}

	sts = append(sts, [2]int{b1, b2})

	// FIXME: this is quite lame way of going back to oringinal values
	b1 = origb1
	b2 = origb2

	for b1 < sizeBucketOne && b2 > 0 {
		b1++
		b2--

	if sizeBucketOne-b1 >= b2 {
		sts[5] = State{b1 + b2, 0}
	} else {
		sts[5] = State{b1 + (sizeBucketOne - b1), b2 - (sizeBucketOne - b1)}

	sts = append(sts, [2]int{b1, b2})

	// log.Println("generated states:", sts)

	// log.Println("gen:\t", sts)