package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
)

type Element struct {
	val int
	id  int
}

var A []Element
var ans []byte

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func max3(a, b, c int) int {
	return max(a, max(b, c))
}

func min4(a, b, c, d int) int {
	return min(min(a, b), min(c, d))
}

func maxK(S []Element) int {
	if len(S) == 3 {
		a, b, c := S[0].val, S[1].val, S[2].val
		return max3(a^b, b^c, c^a)
	}
	if len(S) == 4 {
		a, b, c, d := S[0].val, S[1].val, S[2].val, S[3].val
		t1 := max3(a^b, b^c, c^a)
		t2 := max3(a^b, b^d, d^a)
		t3 := max3(a^c, c^d, d^a)
		t4 := max3(b^c, c^d, d^b)
		return min4(t1, t2, t3, t4)
	}
	return 1 << 30
}

func findSplit(l, r, d int) int {
	low, high := l, r
	for low < high {
		mid := int(uint(low+high) >> 1)
		if (A[mid].val & (1 << d)) == 0 {
			low = mid + 1
		} else {
			high = mid
		}
	}
	return low
}

func solve(l, r, d int) int {
	if r-l <= 2 {
		return 1 << 30
	}
	if d < 0 {
		return 0
	}
	m := findSplit(l, r, d)
	if m == l || m == r {
		return solve(l, r, d-1)
	}
	if m-l <= 2 && r-m <= 2 {
		return maxK(A[l:r])
	}
	return min(solve(l, m, d-1), solve(m, r, d-1))
}

func colorSmallGraph(l, r, K int) {
	S := r - l
	adj := make([][]int, S)
	for i := 0; i < S; i++ {
		for j := i + 1; j < S; j++ {
			if (A[l+i].val^A[l+j].val) < K {
				adj[i] = append(adj[i], j)
				adj[j] = append(adj[j], i)
			}
		}
	}

	color := make([]int, S)
	for i := 0; i < S; i++ {
		color[i] = -1
	}

	for i := 0; i < S; i++ {
		if color[i] == -1 {
			color[i] = 0
			q := []int{i}
			for len(q) > 0 {
				u := q[0]
				q = q[1:]
				for _, v := range adj[u] {
					if color[v] == -1 {
						color[v] = 1 - color[u]
						q = append(q, v)
					}
				}
			}
		}
	}

	for i := 0; i < S; i++ {
		ans[A[l+i].id] = byte(color[i] + '0')
	}
}

func colorAll(l, r, d, K int) {
	if r-l <= 4 {
		colorSmallGraph(l, r, K)
		return
	}
	m := findSplit(l, r, d)
	if m == l || m == r {
		colorAll(l, r, d-1, K)
	} else {
		colorAll(l, m, d-1, K)
		colorAll(m, r, d-1, K)
	}
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())
	A = make([]Element, n)
	for i := 0; i < n; i++ {
		scanner.Scan()
		val, _ := strconv.Atoi(scanner.Text())
		A[i] = Element{val, i}
	}

	sort.Slice(A, func(i, j int) bool {
		return A[i].val < A[j].val
	})

	ans = make([]byte, n)
	K_opt := solve(0, n, 29)
	colorAll(0, n, 29, K_opt)

	fmt.Println(string(ans))
}