package main

import (
	"bufio"
	"fmt"
	"math/big"
	"math/bits"
	"os"
	"strconv"
)

type Bitset [32]uint64

func (b *Bitset) Xor(other *Bitset) {
	for i := 0; i < 32; i++ {
		b[i] ^= other[i]
	}
}

func (b *Bitset) SetBit(i int) {
	b[i/64] |= 1 << (i % 64)
}

func (b *Bitset) GetBit(i int) int {
	return int((b[i/64] >> (i % 64)) & 1)
}

func (b *Bitset) HighBit() int {
	for i := 31; i >= 0; i-- {
		if b[i] != 0 {
			return i*64 + 63 - bits.LeadingZeros64(b[i])
		}
	}
	return -1
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)

	buf := make([]byte, 1024*1024)
	scanner.Buffer(buf, 1024*1024)

	if !scanner.Scan() {
		return
	}
	m, _ := strconv.Atoi(scanner.Text())

	var basisVal [2048]Bitset
	var basisRepr [2048]Bitset
	var hasBasis [2048]bool

	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	for i := 0; i < m; i++ {
		if !scanner.Scan() {
			break
		}
		s := scanner.Text()
		var x big.Int
		x.SetString(s, 10)

		var val Bitset
		for j := 0; j < x.BitLen(); j++ {
			if x.Bit(j) == 1 {
				val.SetBit(j)
			}
		}

		var repr Bitset
		repr.SetBit(i)

		for {
			hb := val.HighBit()
			if hb == -1 {
				break
			}
			if hasBasis[hb] {
				val.Xor(&basisVal[hb])
				repr.Xor(&basisRepr[hb])
			} else {
				hasBasis[hb] = true
				basisVal[hb] = val
				basisRepr[hb] = repr
				break
			}
		}

		if val.HighBit() == -1 {
			var indices []int
			for j := 0; j < i; j++ {
				if repr.GetBit(j) == 1 {
					indices = append(indices, j)
				}
			}
			fmt.Fprintf(out, "%d", len(indices))
			for _, idx := range indices {
				fmt.Fprintf(out, " %d", idx)
			}
			fmt.Fprintln(out)
		} else {
			fmt.Fprintln(out, "0")
		}
	}
}