```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

const MOD int64 = 1000000007

type FastReader struct {
	r *bufio.Reader
}

func NewFastReader() *FastReader {
	return &FastReader{r: bufio.NewReaderSize(os.Stdin, 1<<20)}
}

func (fr *FastReader) NextInt() int {
	sign := 1
	val := 0
	b, _ := fr.r.ReadByte()
	for (b < '0' || b > '9') && b != '-' {
		b, _ = fr.r.ReadByte()
	}
	if b == '-' {
		sign = -1
		b, _ = fr.r.ReadByte()
	}
	for b >= '0' && b <= '9' {
		val = val*10 + int(b-'0')
		b, _ = fr.r.ReadByte()
	}
	return val * sign
}

func main() {
	in := NewFastReader()
	n := in.NextInt()
	const N = 1000000
	cnt := make([]int, N)
	sum := make([]int64, N)
	sum2 := make([]int64, N)

	for i := 0; i < n; i++ {
		a := in.NextInt()
		cnt[a]++
		s := int64(a) % MOD
		sum[a] += s
		if sum[a] >= MOD {
			sum[a] -= MOD
		}
		ss := (s * s) % MOD
		sum2[a] += ss
		if sum2[a] >= MOD {
			sum2[a] -= MOD
		}
	}

	pw10 := [6]int{1, 10, 100, 1000, 10000, 100000}

	for p := 0; p < 6; p++ {
		step := pw10[p]
		block := step * 10
		for base := 0; base < N; base += block {
			for off := 0; off < step; off++ {
				for d := 8; d >= 0; d-- {
					i := base + off + d*step
					j := i + step
					cnt[i] += cnt[j]
					s := sum[i] + sum[j]
					if s >= MOD {
						s -= MOD
					}
					sum[i] = s
					t := sum2[i] + sum2[j]
					if t >= MOD {
						t -= MOD
					}
					sum2[i] = t
				}
			}
		}
	}

	pow2 := make([]int64, n+1)
	pow2[0] = 1
	for i := 1; i <= n; i++ {
		pow2[i] = (pow2[i-1] << 1) % MOD
	}
	inv2 := (MOD + 1) / 2

	F := make([]int64, N)
	for i := 0; i < N; i++ {
		c := cnt[i]
		if c == 0 {
			F[i] = 0
			continue
		}
		s := sum[i]
		q := sum2[i]
		var two int64
		if c == 1 {
			two = inv2
		} else {
			two = pow2[c-2]
		}
		s2 := (s * s) % MOD
		val := s2 + q
		if val >= MOD {
			val -= MOD
		}
		F[i] = (val * two) % MOD
	}

	for p := 0; p < 6; p++ {
		step := pw10[p]
		block := step * 10
		for base := 0; base < N; base += block {
			for off := 0; off < step; off++ {
				for d := 0; d <= 8; d++ {
					i := base + off + d*step
					j := i + step
					v := F[i] - F[j]
					if v < 0 {
						v += MOD
					}
					F[i] = v
				}
			}
		}
	}

	var ans uint64 = 0
	for x := 0; x < N; x++ {
		v := uint64(x) * uint64(F[x])
		ans ^= v
	}
	writer := bufio.NewWriter(os.Stdout)
	fmt.Fprintln(writer, ans)
	writer.Flush()
}
```