```go
package main

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

const MOD = 1000000007

var child [][2]int32
var cnt []int32
var bitCnt [][30]int32

func count(X int, A []int) int64 {
	var total int64 = 0
	for _, a := range A {
		curr := int32(0)
		for bit := 29; bit >= 0; bit-- {
			bit_a := (a >> bit) & 1
			bit_X := (X >> bit) & 1
			if bit_X == 0 {
				child_1 := child[curr][1^bit_a]
				if child_1 != 0 {
					total += int64(cnt[child_1])
				}
				curr = child[curr][bit_a]
			} else {
				curr = child[curr][1^bit_a]
			}
			if curr == 0 {
				break
			}
		}
		if curr != 0 {
			total += int64(cnt[curr])
		}
	}
	return total / 2
}

func sumXOR(K int, m int64, A []int) int64 {
	var totalSum int64 = 0
	var totalCount int64 = 0

	for _, a := range A {
		curr := int32(0)
		for bit := 29; bit >= 0; bit-- {
			bit_a := (a >> bit) & 1
			bit_K := (K >> bit) & 1
			if bit_K == 0 {
				child_1 := child[curr][1^bit_a]
				if child_1 != 0 {
					totalCount += int64(cnt[child_1])
					for b := 0; b < 30; b++ {
						c := int64(bitCnt[child_1][b])
						if (a>>b)&1 == 1 {
							c = int64(cnt[child_1]) - c
						}
						term := (c % MOD) * int64(1<<b) % MOD
						totalSum = (totalSum + term) % MOD
					}
				}
				curr = child[curr][bit_a]
			} else {
				curr = child[curr][1^bit_a]
			}
			if curr == 0 {
				break
			}
		}
	}

	totalCount /= 2
	totalSum = (totalSum * 500000004) % MOD

	rem := m - totalCount
	remMod := rem % MOD
	if remMod < 0 {
		remMod += MOD
	}

	ans := (totalSum + remMod*(int64(K)%MOD)) % MOD
	return ans
}

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

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

	A := make([]int, n)
	for i := 0; i < n; i++ {
		scanner.Scan()
		A[i], _ = strconv.Atoi(scanner.Text())
	}

	if m == 0 {
		fmt.Println(0)
		return
	}

	capacity := n*30 + 1
	child = make([][2]int32, 1, capacity)
	cnt = make([]int32, 1, capacity)
	bitCnt = make([][30]int32, 1, capacity)

	for _, a := range A {
		curr := int32(0)
		cnt[curr]++
		for b := 0; b < 30; b++ {
			if (a>>b)&1 == 1 {
				bitCnt[curr][b]++
			}
		}
		for bit := 29; bit >= 0; bit-- {
			bit_a := (a >> bit) & 1
			if child[curr][bit_a] == 0 {
				child = append(child, [2]int32{0, 0})
				cnt = append(cnt, 0)
				bitCnt = append(bitCnt, [30]int32{})
				child[curr][bit_a] = int32(len(child) - 1)
			}
			curr = child[curr][bit_a]
			cnt[curr]++
			for b := 0; b < 30; b++ {
				if (a>>b)&1 == 1 {
					bitCnt[curr][b]++
				}
			}
		}
	}

	var low, high int = 0, (1 << 30) - 1
	var K int = 0
	for low <= high {
		mid := low + (high-low)/2
		if count(mid, A) >= m {
			K = mid
			low = mid + 1
		} else {
			high = mid - 1
		}
	}

	ans := sumXOR(K, m, A)
	fmt.Println(ans)
}
```