package main

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

var nTest, n, k int
var t, a, b [200010]int

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	fmt.Fscan(in, &n, &k)
	both := []int{}
	alice := []int{}
	bob := []int{}

	for i := 0; i < n; i++ {
		fmt.Fscan(in, &t[i], &a[i], &b[i])

		if a[i] == 1 && b[i] == 1 {
			both = append(both, i)
		} else if a[i] == 1 {
			alice = append(alice, i)
		} else if b[i] == 1 {
			bob = append(bob, i)
		}
	}

	sort.Slice(both, func(i, j int) bool {
		return t[both[i]] < t[both[j]]
	})
	sort.Slice(alice, func(i, j int) bool {
		return t[alice[i]] < t[alice[j]]
	})
	sort.Slice(bob, func(i, j int) bool {
		return t[bob[i]] < t[bob[j]]
	})

	res := 0
	x := 0
	y := 0
	z := 0
	for i := 0; i < k; i++ {
		if x >= len(both) && (y >= len(alice) || z >= len(bob)) {
			fmt.Fprintln(out, -1)
			out.Flush()
			return
		}

		if x >= len(both) {
			res += t[alice[y]] + t[bob[z]]
			y++
			z++
		} else if y >= len(alice) || z >= len(bob) {
			res += t[both[x]]
			x++
		} else {
			if t[both[x]] <= t[alice[y]]+t[bob[z]] {
				res += t[both[x]]
				x++
			} else {
				res += t[alice[y]] + t[bob[z]]
				y++
				z++
			}
		}
	}

	fmt.Fprintln(out, res)
	out.Flush()
}

package main

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

const MAX_N int = 2e5 + 10

var read *bufio.Reader = bufio.NewReader(os.Stdin)
var write *bufio.Writer = bufio.NewWriter(os.Stdout)

var nAlice, nBob, nBoth int = 0, 0, 0
var alice, bob, both [MAX_N]int

func main() {
	defer write.Flush()
	var n, k int
	fmt.Fscan(read, &n, &k)
	for i := 0; i < n; i++ {
		var t, a, b int
		fmt.Fscan(read, &t, &a, &b)
		if a == 1 && b == 1 {
			both[nBoth] = t
			nBoth++
		} else if a == 1 {
			alice[nAlice] = t
			nAlice++
		} else if b == 1 {
			bob[nBob] = t
			nBob++
		}
	}
	sort.Ints(both[0 : nBoth])
	sort.Ints(alice[0 : nAlice])
	sort.Ints(bob[0 : nBob])
	if nAlice + nBoth < k || nBob + nBoth < k {
		fmt.Fprintln(write, -1)
	} else if nBoth >= k {
		var ans int = 0
		for i := 0; i < k; i++ {
			ans += both[i]
		}
		for i := 0; i < k && i < nAlice && i < nBob; i++ {
			if alice[i] + bob[i] < both[k - i - 1] {
				ans += alice[i] + bob[i] - both[k - i - 1]
			} else {
				break
			}
		}
		fmt.Fprintln(write, ans)
	} else {
		var ans int = 0
		for i := 0; i < nBoth; i++ {
			ans += both[i]
		}
		for i := 0; i < k - nBoth; i++ {
			ans += alice[i] + bob[i]
		}
		for i := k - nBoth; i < nAlice && i < nBob && i < k; i++ {
			if alice[i] + bob[i] < both[nBoth - i - 1 + k - nBoth] {
				ans += alice[i] + bob[i] - both[nBoth - i - 1 + k - nBoth]
			} else {
				break
			}
		}
		fmt.Fprintln(write, ans)
	}
}

package main

import (
	"bufio"
	"container/heap"
	"fmt"
	"os"
	"sort"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	tc := 1

	for tc > 0 {
		tc--
		n, k := readTwoNums(reader)
		books := make([][]int, n)
		for i := 0; i < n; i++ {
			books[i] = readNNums(reader, 3)
		}

		fmt.Println(solve(n, k, books))
	}
}

func readInt(bytes []byte, from int, val *int) int {
	i := from
	sign := 1
	if bytes[i] == '-' {
		sign = -1
		i++
	}
	tmp := 0
	for i < len(bytes) && bytes[i] >= '0' && bytes[i] <= '9' {
		tmp = tmp*10 + int(bytes[i]-'0')
		i++
	}
	*val = tmp * sign
	return i
}

func readNum(reader *bufio.Reader) (a int) {
	bs, _ := reader.ReadBytes('\n')
	readInt(bs, 0, &a)
	return
}

func readTwoNums(reader *bufio.Reader) (a int, b int) {
	res := readNNums(reader, 2)
	a, b = res[0], res[1]
	return
}

func readThreeNums(reader *bufio.Reader) (a int, b int, c int) {
	res := readNNums(reader, 3)
	a, b, c = res[0], res[1], res[2]
	return
}

func readNNums(reader *bufio.Reader, n int) []int {
	res := make([]int, n)
	x := 0
	bs, _ := reader.ReadBytes('\n')
	for i := 0; i < n; i++ {
		for x < len(bs) && (bs[x] < '0' || bs[x] > '9') && bs[x] != '-' {
			x++
		}
		x = readInt(bs, x, &res[i])
	}
	return res
}

func readUint64(bytes []byte, from int, val *uint64) int {
	i := from

	var tmp uint64
	for i < len(bytes) && bytes[i] >= '0' && bytes[i] <= '9' {
		tmp = tmp*10 + uint64(bytes[i]-'0')
		i++
	}
	*val = tmp

	return i
}

func solve(n, k int, books [][]int) int64 {

	sort.Sort(Books(books))

	var i int
	var k1, k2 int

	alice := make(IntHeap, 0, n)
	bob := make(IntHeap, 0, n)

	var tot int64
	for i < n && (k1 < k || k2 < k) {
		book := books[i]
		t, a, b := book[0], book[1], book[2]
		if a != 0 || b != 0 {
			tot += 2 * int64(t)
			if a == 1 {
				k1++
			}
			if b == 1 {
				k2++
			}
			if a == 0 {
				//only bob likes
				heap.Push(&bob, t)
			}
			if b == 0 {
				heap.Push(&alice, t)
			}
		}
		i++
	}

	for i < n && len(alice) > 0 && len(bob) > 0 {
		book := books[i]
		t, a, b := book[0], book[1], book[2]
		if a == 1 && b == 1 {
			tmp := 2*t - 2*alice[0] - 2*bob[0]

			if tmp < 0 {
				//good to replace it, for bob & alice
				heap.Pop(&alice)
				heap.Pop(&bob)
				tot += int64(tmp)
			}
		}

		i++
	}

	if k1 < k || k2 < k {
		return -1
	}

	for alice.Len() > 0 && k1 > k {
		t := heap.Pop(&alice).(int)
		k1--
		tot -= 2 * int64(t)
	}

	for bob.Len() > 0 && k2 > k {
		t := heap.Pop(&bob).(int)
		k2--
		tot -= 2 * int64(t)
	}

	return tot / 2
}

type Books [][]int

func (books Books) Len() int {
	return len(books)
}

func (books Books) Less(i, j int) bool {
	return books[i][0] < books[j][0]
}

func (books Books) Swap(i, j int) {
	books[i], books[j] = books[j], books[i]
}

// An IntHeap is a min-heap of ints.
type IntHeap []int

func (h IntHeap) Len() int           { return len(h) }
func (h IntHeap) Less(i, j int) bool { return h[i] > h[j] }
func (h IntHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }

func (h *IntHeap) Push(x interface{}) {
	// Push and Pop use pointer receivers because they modify the slice's length,
	// not just its contents.
	*h = append(*h, x.(int))
}

func (h *IntHeap) Pop() interface{} {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[0 : n-1]
	return x
}

package main

import (
	"bufio"
	"container/heap"
	"fmt"
	"math"
	"os"
	"sort"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	tc := 1

	for tc > 0 {
		tc--
		n, k := readTwoNums(reader)
		books := make([][]int, n)
		for i := 0; i < n; i++ {
			books[i] = readNNums(reader, 3)
		}

		fmt.Println(solve(n, k, books))
	}
}

func readInt(bytes []byte, from int, val *int) int {
	i := from
	sign := 1
	if bytes[i] == '-' {
		sign = -1
		i++
	}
	tmp := 0
	for i < len(bytes) && bytes[i] >= '0' && bytes[i] <= '9' {
		tmp = tmp*10 + int(bytes[i]-'0')
		i++
	}
	*val = tmp * sign
	return i
}

func readNum(reader *bufio.Reader) (a int) {
	bs, _ := reader.ReadBytes('\n')
	readInt(bs, 0, &a)
	return
}

func readTwoNums(reader *bufio.Reader) (a int, b int) {
	res := readNNums(reader, 2)
	a, b = res[0], res[1]
	return
}

func readThreeNums(reader *bufio.Reader) (a int, b int, c int) {
	res := readNNums(reader, 3)
	a, b, c = res[0], res[1], res[2]
	return
}

func readNNums(reader *bufio.Reader, n int) []int {
	res := make([]int, n)
	x := 0
	bs, _ := reader.ReadBytes('\n')
	for i := 0; i < n; i++ {
		for x < len(bs) && (bs[x] < '0' || bs[x] > '9') && bs[x] != '-' {
			x++
		}
		x = readInt(bs, x, &res[i])
	}
	return res
}

func readUint64(bytes []byte, from int, val *uint64) int {
	i := from

	var tmp uint64
	for i < len(bytes) && bytes[i] >= '0' && bytes[i] <= '9' {
		tmp = tmp*10 + uint64(bytes[i]-'0')
		i++
	}
	*val = tmp

	return i
}

func solve(n, k int, books [][]int) int64 {
	times := make([][]int, 4)
	sums := make([][]int64, 4)

	for i := 0; i < 4; i++ {
		times[i] = make([]int, 0, n)
		sums[i] = make([]int64, 0, n)
	}

	for _, book := range books {
		t, a, b := book[0], book[1], book[2]
		times[2*a+b] = append(times[2*a+b], t)
	}

	for i := 0; i < 4; i++ {
		sort.Ints(times[i])
		var cur int64
		sums[i] = append(sums[i], cur)
		for j := 0; j < len(times[i]); j++ {
			cur += int64(times[i][j])
			sums[i] = append(sums[i], cur)
		}
	}

	var best int64 = math.MaxInt64

	for cnt := 0; cnt < min(k+1, len(sums[3])); cnt++ {
		if k-cnt < len(sums[1]) && k-cnt < len(sums[2]) {
			tmp := sums[3][cnt] + sums[1][k-cnt] + sums[2][k-cnt]
			if tmp < best {
				best = tmp
			}
		}
	}

	if best == math.MaxInt64 {
		return -1
	}
	return best
}

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

func solve1(n, k int, books [][]int) int64 {

	sort.Sort(Books(books))

	var i int
	var k1, k2 int

	alice := make(IntHeap, 0, n)
	bob := make(IntHeap, 0, n)

	var tot int64
	for i < n && (k1 < k || k2 < k) {
		book := books[i]
		t, a, b := book[0], book[1], book[2]
		if a != 0 || b != 0 {
			tot += int64(t)
			if a == 1 {
				k1++
			}
			if b == 1 {
				k2++
			}
			if a == 0 {
				//only bob likes
				heap.Push(&bob, t)
			}
			if b == 0 {
				heap.Push(&alice, t)
			}
		}
		i++
	}

	for i < n && len(alice) > 0 && len(bob) > 0 {
		book := books[i]
		t, a, b := book[0], book[1], book[2]
		if a == 1 && b == 1 {
			tmp := t - alice[0] - bob[0]

			if tmp < 0 {
				//good to replace it, for bob & alice
				heap.Pop(&alice)
				heap.Pop(&bob)
				tot += int64(tmp)
			}
		}

		i++
	}

	if k1 < k || k2 < k {
		return -1
	}

	for alice.Len() > 0 && k1 > k {
		t := heap.Pop(&alice).(int)
		k1--
		tot -= int64(t)
	}

	for bob.Len() > 0 && k2 > k {
		t := heap.Pop(&bob).(int)
		k2--
		tot -= int64(t)
	}

	return tot
}

type Books [][]int

func (books Books) Len() int {
	return len(books)
}

func (books Books) Less(i, j int) bool {
	return books[i][0] < books[j][0]
}

func (books Books) Swap(i, j int) {
	books[i], books[j] = books[j], books[i]
}

// An IntHeap is a min-heap of ints.
type IntHeap []int

func (h IntHeap) Len() int           { return len(h) }
func (h IntHeap) Less(i, j int) bool { return h[i] > h[j] }
func (h IntHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }

func (h *IntHeap) Push(x interface{}) {
	// Push and Pop use pointer receivers because they modify the slice's length,
	// not just its contents.
	*h = append(*h, x.(int))
}

func (h *IntHeap) Pop() interface{} {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[0 : n-1]
	return x
}

package main

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

func main() {
	n, k := 0, 0
	bufIO := bufio.NewReader(os.Stdin)
	fmt.Fscanln(bufIO, &n, &k)

	books, ba, bb := []int{}, []int{}, []int{}
	for iBook := 0; iBook < n; iBook++ {
		t, a, b := 0, 0, 0
		fmt.Fscanln(bufIO, &t, &a, &b)
		if a == 0 && b == 0 {
			continue
		}
		if a != 0 && b != 0 {
			books = append(books, t)
		} else if b == 0 {
			ba = append(ba, t)
		} else {
			bb = append(bb, t)
		}
	}
	minLength := 0
	if len(ba) < len(bb) {
		minLength = len(ba)
	} else {
		minLength = len(bb)
	}

	if len(books)+minLength < k {
		fmt.Println(-1)
		return
	}

	sort.Ints(ba)
	sort.Ints(bb)
	for i := 0; i < minLength; i++ {
		books = append(books, ba[i]+bb[i])
	}
	sort.Ints(books)
	ans := 0
	for i := 0; i < k; i++ {
		ans += books[i]
	}
	fmt.Println(ans)
}

package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	buffer := make([]byte, 1024*1024)
	scanner.Buffer(buffer, 3*1024*1204)
	scanner.Split(bufio.ScanWords)

	input := func() int64 {
		scanner.Scan()
		i, _ := strconv.ParseInt(scanner.Text(), 10, 64)
		return i
	}

	min := func(i, j int64) int64 {
		if i < j {
			return i
		}

		return j
	}

	n, k := input(), input()

	a := make([][]int64, 4)
	for i := range a {
		a[i] = make([]int64, 0)
	}

	var i, cnt int64

	for i = 0; i < n; i++ {
		val := input()
		cat := input()*2 + input()
		a[cat] = append(a[cat], val)
	}

	s := make([][]int64, 4)
	for i := range s {
		s[i] = make([]int64, 1)
		s[i][0] = 0
	}

	for i := range a {
		sort.Slice(a[i], func(l, m int) bool {
			return a[i][l] < a[i][m]
		})
		for j := range a[i] {
			s[i] = append(s[i], s[i][j]+a[i][j])
		}
	}

	ans := int64(math.MaxInt64)

	for cnt = 0; cnt < min(k+1, int64(len(s[3]))); cnt++ {
		if k-cnt < min(int64(len(s[1])), int64(len(s[2]))) {
			ans = min(ans, s[3][cnt]+s[2][k-cnt]+s[1][k-cnt])
		}
	}

	if ans == math.MaxInt64 {
		fmt.Println(-1)
	} else {
		fmt.Println(ans)
	}

}

// --- In the name of Allah ---

package main
import(
	"fmt"
	"bufio"
	"os"
	"strconv"
	//"math"
	"sort"

)
func main(){
	n, k:= InputInt(), InputInt();
	var fst, scd, bth []int;
	for i:=0; i<n; i++{
		var t, a, b = InputInt(), InputInt(), InputInt();
		if( a == 1 && b == 1){
			bth = append(bth, t);
		}else if( a == 1 ){
			fst = append(fst, t);
		}else if( b == 1 ){
			scd = append(scd, t);
		}
	}
	sort.Ints(fst);
	sort.Ints(bth);
	sort.Ints(scd);
	var ans, sum1, sum2 int64;
	for len(fst)<k{
		fst = append( fst, 2e9 );
	}
	for len(scd)<k{
		scd = append( scd, 2e9 );
	}
	for i:= 0; i < k; i ++ {
		sum1 += int64(fst[i]);
		sum2 += int64(scd[i]);
	}
	ans = sum1+sum2;

	for i:= 0; i < len(bth); i++ {
		if( i == k ){
			break;
		}
		sum1 -= int64(fst[k-i-1]);
		sum1 += int64(bth[i]);
		sum2 -= int64(scd[k-i-1]);
		ans = min( ans, sum1+sum2);
	}
	if( ans > 2e9 ){
		fmt.Println(-1);
	}else{
		fmt.Println(ans);
	}

}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
func min(a int64, b int64)int64{
	if( a < b ){
		return a;
	}
	return b;
}
var Scanner = bufio.NewScanner(os.Stdin);
func init(){
	Scanner.Buffer(make([]byte,256), 1e9);
	Scanner.Split(bufio.ScanWords);
}
func Input() string{
	Scanner.Scan();
	return Scanner.Text();
}
func InputInt()int{
	i, err := strconv.Atoi(Input());
	if err != nil {
		panic(err);
	}
	return i;
}

package main

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

type book struct {
	ai int64
	bi int64
	ti int64
}

func main() {
	var n, k int64
	fmt.Scanf("%d %d\n", &n, &k)
	reader := bufio.NewReader(os.Stdin)
	times := make([][]int, 0)
	sum := make([][]int64, 0)
	for i := 0; i < 4; i++ {
		ts := make([]int, 0)
		times = append(times, ts)
		ss := make([]int64, 1)
		sum = append(sum, ss)
	}
	for i := int64(0); i < n; i++ {
		var ti, ai, bi int
		line := readLine(reader)
		sss := strings.Split(string(line), " ")
		ti, _ = strconv.Atoi(sss[0])
		ai, _ = strconv.Atoi(sss[1])
		bi, _ = strconv.Atoi(sss[2])
		if ai == 0 && bi == 0 {
			continue
		}
		times[ai+bi*2] = append(times[ai+bi*2], ti)
	}
	for i := 1; i < 4; i++ {
		sort.Ints(times[i])
		for j := 0; j < len(times[i]); j++ {
			sum[i] = append(sum[i], int64(times[i][j])+sum[i][len(sum[i])-1])
		}
	}
	// fmt.Println(times)
	// fmt.Println(sum)
	ans := int64(math.MaxInt64)
	for ab := int64(0); ab <= k && ab <= int64(len(times[3])); ab++ {
		if int64(len(times[1])) >= k-ab && int64(len(times[2])) >= (k-ab) {
			ans = min(ans, sum[3][ab] + sum[1][k-ab]+sum[2][k-ab])
		}
	}
	if ans == math.MaxInt64 {
		ans = -1
	}
	fmt.Println(ans)
}

func min(a,b int64) int64 {
	if a > b {
		return b
	}
	return a
}

func main2() {
	var n, k int64
	fmt.Scanf("%d %d\n", &n, &k)
	books := make([]book, n)
	reader := bufio.NewReader(os.Stdin)
	for i := int64(0); i < n; i++ {
		var ti, ai, bi int64
		line := readLine(reader)
		sss := strings.Split(string(line), " ")
		ti, _ = strconv.ParseInt(sss[0], 10, 64)
		ai, _ = strconv.ParseInt(sss[1], 10, 64)
		bi, _ = strconv.ParseInt(sss[2], 10, 64)
		// fmt.Scanf("%d %d %d\n", &ti, &ai, &bi)
		if n == 200000 {
			fmt.Println(line)
		}
		b := book{
			ti: ti,
			ai: ai,
			bi: bi,
		}
		books[i] = b
	}
	sort.Slice(books, func(i, j int) bool {
		return books[i].ti < books[j].ti
	})
	sum := int64(0)
	AAndB := make([]int64, 0)
	onlyA, onlyB := make([]int64, 0), make([]int64, 0)
	countA, countB := int64(0), int64(0)
	for i := int64(0); i < n; i++ {
		if books[i].ai == 0 && books[i].bi == 0 {
			continue
		}
		if countA >= k && countB >= k {
			// 从后面找两个都是一样的，并且去除A和B
			if len(onlyA) == 0 || len(onlyB) == 0 {
				continue
			}
			if books[i].ai == 0 || books[i].bi == 0 {
				continue
			}
			if books[i].ti > onlyA[len(onlyA)-1]+onlyB[len(onlyB)-1] {
				break
			}
			sum += books[i].ti - onlyA[len(onlyA)-1] - onlyB[len(onlyB)-1]
			onlyA = onlyA[:len(onlyA)-1]
			onlyB = onlyB[:len(onlyB)-1]
			AAndB = append(AAndB, books[i].ti)
		}
		// 填充A和B
		if books[i].ai == 1 && books[i].bi == 1 {
			// 共同爱好，那么需要去除之前多余的
			AAndB = append(AAndB, books[i].ti)
			if countA >= k {
				sum += books[i].ti - onlyA[len(onlyA)-1]
				onlyA = onlyA[:len(onlyA)-1]
				countB++
			} else if countB >= k {
				sum += books[i].ti - onlyB[len(onlyB)-1]
				onlyB = onlyB[:len(onlyB)-1]
				countA++
			} else {
				countA++
				countB++
				sum += books[i].ti
			}
		} else if books[i].ai == 1 {
			if countA >= k {
				continue
			}
			sum += books[i].ti
			onlyA = append(onlyA, books[i].ti)
			countA++
		} else {
			if countB >= k {
				continue
			}
			sum += books[i].ti
			onlyB = append(onlyB, books[i].ti)
			countB++
		}
	}
	if countA < k || countB < k {
		fmt.Println(-1)
		return
	}
	fmt.Println(sum)
}

func readLine(reader *bufio.Reader) []byte {
	result := make([]byte, 0)
	for {
		s, isPrefix, err := reader.ReadLine()
		if err != nil {
			fmt.Printf("error=%+v\n", err)
			break
		}
		result = append(result, s...)
		if !isPrefix {
			break
		}
	}
	return result
}

package main

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

func min(a, b int) int {
	return int(math.Min(float64(a), float64(b)))
}

func max(a, b int) int {
	return int(math.Max(float64(a), float64(b)))
}

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()
	var n, k, ans, two int
	fmt.Fscanf(in, "%v %v\n", &n, &k)
	a := make([]int, 0, n)
	b := make([]int, 0, n)
	ab := make([]int, 0, n)
	for i := 0;i < n;i++ {
		var t, x, y int
		fmt.Fscanf(in, "%v %v %v\n", &t, &x, &y)
		if (x == 1) && (y == 1) {
			ab = append(ab, t)
		} else if x == 1 {
			a = append(a, t)
		} else if y == 1 {
			b = append(b, t)
		}
	}
	sort.Ints(a)
	sort.Ints(b)
	sort.Ints(ab)
	//fmt.Fprintln(out, a)
	//fmt.Fprintln(out, b)
	//fmt.Fprintln(out, ab)

	if min(len(a), len(b)) + len(ab) < k {
		fmt.Fprintln(out, -1)
		return
	} else{
		var ia, ib, iab int
		mn := min(len(a), len(b))

		for two = 0;two < k;two++ {
			if iab < len(ab){
				if ia < mn && ib < mn {
					if a[ia] + b[ib] < ab[iab] {
						ans += a[ia] + b[ib]
						ia++
						ib++
					} else {
						ans += ab[iab]
						iab++
					}
				} else {
					ans += ab[iab]
					iab++
				}
			} else if ia < mn && ib < mn {
				ans += a[ia] + b[ib]
				ia++
				ib++
			} else{
				break
			}

		}
	}
	fmt.Fprintln(out, ans)
	return
}

package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)

	var n, k int

	fmt.Fscanf(reader, "%d %d\n", &n, &k)

	aa := make([]int, 0, n)
	bb := make([]int, 0, n)
	cc := make([]int, 0, n)

	var t, a, b int
	for i := 1; i <= n; i++ {
		fmt.Fscanf(reader, "%d %d %d\n", &t, &a, &b)

		if a == 1 && b == 1 {
			cc = append(cc, t)
			continue
		}

		if a == 1 {
			aa = append(aa, t)
			continue
		}

		if b == 1 {
			bb = append(bb, t)
		}
	}

	if len(aa)+len(cc) < k || len(bb)+len(cc) < k {
		fmt.Println(-1)
		return
	}

	sort.Ints(aa)
	sort.Ints(bb)
	sort.Ints(cc)

	sum := int64(0)
	abi := 0
	ci := 0
	for i := 0; i < k; i++ {
		if abi >= len(aa) || abi >= len(bb) ||
			(ci < len(cc) && aa[abi]+bb[abi] > cc[ci]) {
			sum += int64(cc[ci])
			ci++
		} else {
			sum += int64(aa[abi] + bb[abi])
			abi++
		}
	}

	fmt.Println(sum)
}

package main

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

const INF = int(2e9+300)

func main() {
	n, k := NextInt(), NextInt()

	bothLikes := make([]int, 0)
	aLikes := make([]int, 0)
	bLikes := make([]int, 0)
	t := make([]int, n)
	a := make([]int, n)
	b := make([]int, n)
	for i := 0; i < n; i++ {
		t[i] = NextInt()
		a[i] = NextInt()
		b[i] = NextInt()
		if a[i] + b[i] == 2 {
			bothLikes = append(bothLikes, t[i])
		} else if a[i] == 1 {
			aLikes = append(aLikes, t[i])
		} else if b[i] == 1 {
			bLikes = append(bLikes, t[i])
		}
	}

	sort.Slice(bothLikes, func(i, j int) bool {
		return bothLikes[i] < bothLikes[j]
	})
	sort.Slice(aLikes, func(i, j int) bool {
		return aLikes[i] < aLikes[j]
	})
	sort.Slice(bLikes, func(i, j int) bool {
		return bLikes[i] < bLikes[j]
	})

	left := 0
	right := len(bothLikes)
	for right - left > 10 {
		m1 := left + (right-left) / 3
		m2 := right - (right-left) / 3

		if can(m1, k, bothLikes, aLikes, bLikes) >= can(m2, k, bothLikes, aLikes, bLikes) {
			left = m1
		} else {
			right = m2
		}
	}

	ans := INF
	for i := left; i <= right; i++ {
		if can(i, k, bothLikes, aLikes, bLikes) < ans {
			ans = can(i, k, bothLikes, aLikes, bLikes)
		}
	}

	if ans == INF {
		ans = -1
	}
	fmt.Println(ans)
}

func can(both int, k int, bothLikes []int, aLikes[]int, bLikes[]int) int {
	if len(aLikes) < k - both || len(bLikes) < k - both {
		return INF
	}

	sum := 0
	for i := 0; i < both; i++ {
		sum += bothLikes[i]
	}

	for i := 0; i < k-both; i++ {
		sum += aLikes[i]
	}
	for i := 0; i < k-both; i++ {
		sum += bLikes[i]
	}

	return sum
}

var sc = bufio.NewScanner(os.Stdin)

func init() {
	sc.Buffer(make([]byte, 256), 1e9)
	sc.Split(bufio.ScanWords)
}

func Next() string {
	sc.Scan()
	return sc.Text()
}

func NextInt() int {
	i, err := strconv.Atoi(Next())
	if err != nil {
		panic(err)
	}
	return i
}

func NextDouble() float64 {
	f, err := strconv.ParseFloat(Next(), 64)
	if err != nil {
		panic(err)
	}
	return f
}

package main

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

var in *bufio.Reader
var out *bufio.Writer

func printf(x string, a ...interface{}) (n int, err error) {
	return fmt.Fprintf(out, x, a...)
}

func scanf(x string, a ...interface{}) (n int, err error) {
	return fmt.Fscanf(in, x, a...)
}

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

func main() {
	out = bufio.NewWriterSize(os.Stdout, 8192)
	defer out.Flush()
	if false {
		file, err := os.Open("in.txt")
		if err != nil {
			log.Fatal(err)
		}
		in = bufio.NewReaderSize(file, 8192)
	} else {
		in = bufio.NewReaderSize(os.Stdin, 8192)
	}

	var n, k int
	scanf("%d %d", &n, &k)

	nums := [2][2][]int{{[]int{}, []int{}}, {[]int{}, []int{}}}

	for i := 0; i < n; i++ {
		var v, a, b int
		scanf("\n%d %d %d", &v, &a, &b)
		nums[a][b] = append(nums[a][b], v)
	}

	if min(len(nums[0][1]), len(nums[1][0]))+len(nums[1][1]) < k {
		printf("-1\n")
		return
	}

	sort.Ints(nums[0][1])
	sort.Ints(nums[1][0])
	sort.Ints(nums[1][1])

	curr, num := 0, min(len(nums[1][1]), k)

	for i := 0; i < num; i++ {
		curr += nums[1][1][i]
	}

	for i := 0; i < k-num; i++ {
		curr += nums[0][1][i] + nums[1][0][i]
	}

	res := curr
	for ; num > 0 && k-num < min(len(nums[0][1]), len(nums[1][0])); num-- {
		curr += nums[0][1][k-num] + nums[1][0][k-num] - nums[1][1][num-1]
		res = min(res, curr)
	}

	printf("%d\n", res)
}

package main

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

var in *bufio.Reader
var out *bufio.Writer

func printf(x string, a ...interface{}) (n int, err error) {
	return fmt.Fprintf(out, x, a...)
}

func scanf(x string, a ...interface{}) (n int, err error) {
	return fmt.Fscanf(in, x, a...)
}

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

func main() {
	out = bufio.NewWriterSize(os.Stdout, 8192)
	defer out.Flush()
	if false {
		file, err := os.Open("in.txt")
		if err != nil {
			log.Fatal(err)
		}
		in = bufio.NewReaderSize(file, 8192)
	} else {
		in = bufio.NewReaderSize(os.Stdin, 8192)
	}

	var n, k int
	scanf("%d %d", &n, &k)

	nums := [2][2][]int{{[]int{}, []int{}}, {[]int{}, []int{}}}

	for i := 0; i < n; i++ {
		var v, a, b int
		scanf("\n%d %d %d", &v, &a, &b)
		nums[a][b] = append(nums[a][b], v)
	}

	if min(len(nums[0][1]), len(nums[1][0]))+len(nums[1][1]) < k {
		printf("-1\n")
		return
	}

	sort.Ints(nums[0][1])
	sort.Ints(nums[1][0])
	sort.Ints(nums[1][1])

	curr, num := 0, min(len(nums[1][1]), k)

	for i := 0; i < num; i++ {
		curr += nums[1][1][i]
	}

	for i := 0; i < k-num; i++ {
		curr += nums[0][1][i] + nums[1][0][i]
	}

	res := curr
	for ; num > 0 && k-num < min(len(nums[0][1]), len(nums[1][0])); num-- {
		curr += nums[0][1][k-num] + nums[1][0][k-num] - nums[1][1][num]
		res = min(res, curr)
	}

	printf("%d\n", res)
}

package main

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

const MAX_N int = 2e5 + 10

var read *bufio.Reader = bufio.NewReader(os.Stdin)
var write *bufio.Writer = bufio.NewWriter(os.Stdout)

var nAlice, nBob, nBoth int = 0, 0, 0
var alice, bob, both [MAX_N]int

func main() {
	defer write.Flush()
	var n, k int
	fmt.Fscan(read, &n, &k)
	for i := 0; i < n; i++ {
		var t, a, b int
		fmt.Fscan(read, &t, &a, &b)
		if a == 1 && b == 1 {
			both[nBoth] = t
			nBoth++
		} else if a == 1 {
			alice[nAlice] = t
			nAlice++
		} else if b == 1 {
			bob[nBob] = t
			nBob++
		}
	}
	sort.Ints(both[0 : nBoth])
	sort.Ints(alice[0 : nAlice])
	sort.Ints(bob[0 : nBob])
	if nAlice + nBoth < k || nBob + nBoth < k {
		fmt.Fprintln(write, -1)
	} else if nBoth >= k {
		var ans int = 0
		for i := 0; i < k; i++ {
			ans += both[i]
		}
		for i := 0; i < k && i < nAlice && i < nBob; i++ {
			if alice[i] + bob[i] < both[k - i - 1] {
				ans += alice[i] + bob[i] - both[k - i - 1]
			} else {
				break
			}
		}
		fmt.Fprintln(write, ans)
	} else {
		var ans int = 0
		for i := 0; i < nBoth; i++ {
			ans += both[i]
		}
		for i := 0; i < k - nBoth; i++ {
			ans += alice[i] + bob[i]
		}
		for i := k - nBoth; i < nAlice && i < nBob && i < nBoth; i++ {
			if alice[i] + bob[i] < both[nBoth - i - 1 + k - nBoth] {
				ans += alice[i] + bob[i] - both[nBoth - i - 1 + k - nBoth]
			} else {
				break
			}
		}
		fmt.Fprintln(write, ans)
	}
}

package main

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

func main() {
	n, k := 0, 0
	bufIO := bufio.NewReader(os.Stdin)
	fmt.Fscanln(bufIO, &n, &k)

	books := [][]int{}
	for iBook := 0; iBook < n; iBook++ {
		t, a, b := 0, 0, 0
		fmt.Fscanln(bufIO, &t, &a, &b)
		if a == 0 && b == 0 {
			continue
		}

		books = append(books, []int{t, a, b})
	}

	sort.Slice(books, func(i, j int) bool {
		iScore := books[i][0] / (books[i][1] + books[i][2])
		jScore := books[j][0] / (books[j][1] + books[j][2])
		return iScore < jScore
	})
	//fmt.Println(books)

	bookA, bookB := []int{}, []int{}
	nBookA, nBookB := 0, 0
	ans := 0
	for i := range books {
		nBookA += books[i][1]
		nBookB += books[i][2]
		ans += books[i][0]

		if books[i][1] != 0 && books[i][2] != 0 {
			continue
		}
		if books[i][1] != 0 {
			bookA = append(bookA, i)
		}
		if books[i][2] != 0 {
			bookB = append(bookB, i)
		}
		if nBookA >= k && nBookB >= k {
			break
		}
	}
	//fmt.Println(bookA, bookB)

	if nBookA < k || nBookB < k {
		fmt.Println(-1)
		return
	}

	if nBookA > k {
		for i := len(bookA) - 1; i >= 0 && nBookA > k; i-- {
			ans -= books[bookA[i]][0]
			nBookA--
		}
	} else {
		for i := len(bookB) - 1; i >= 0 && nBookB > k; i-- {
			ans -= books[bookB[i]][0]
			nBookB--
		}
	}
	fmt.Println(ans)
}

package main

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

func main() {
	n, k := 0, 0
	bufIO := bufio.NewReader(os.Stdin)
	fmt.Fscanln(bufIO, &n, &k)

	books := [][]int{}
	for iBook := 0; iBook < n; iBook++ {
		t, a, b := 0, 0, 0
		fmt.Fscanln(bufIO, &t, &a, &b)
		if a == 0 && b == 0 {
			continue
		}

		books = append(books, []int{t, a, b})
	}

	sort.Slice(books, func(i, j int) bool {
		iScore := float64(books[i][0]) / float64(books[i][1]+books[i][2])
		jScore := float64(books[j][0]) / float64(books[j][1]+books[j][2])
		if iScore == jScore {
			return books[i][1]+books[i][2] > books[j][1]+books[j][2]
		}
		return iScore < jScore
	})
	//fmt.Println(books)

	bookA, bookB := []int{}, []int{}
	nBookA, nBookB := 0, 0
	ans := 0
	for i := 0; i < len(books) && (nBookA < k || nBookB < k); i++ {
		nBookA += books[i][1]
		nBookB += books[i][2]
		ans += books[i][0]

		if books[i][1] != 0 && books[i][2] != 0 {
			continue
		}
		if books[i][1] != 0 {
			bookA = append(bookA, i)
		}
		if books[i][2] != 0 {
			bookB = append(bookB, i)
		}
		if nBookA >= k && nBookB >= k {
			break
		}
	}
	//fmt.Println(bookA, bookB)

	if nBookA < k || nBookB < k {
		fmt.Println(-1)
		return
	}

	if nBookA > k {
		for i := len(bookA) - 1; i >= 0 && nBookA > k; i-- {
			ans -= books[bookA[i]][0]
			nBookA--
		}
	} else {
		for i := len(bookB) - 1; i >= 0 && nBookB > k; i-- {
			ans -= books[bookB[i]][0]
			nBookB--
		}
	}
	fmt.Println(ans)
}

package main

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

func main() {
	n, k := 0, 0
	bufIO := bufio.NewReader(os.Stdin)
	fmt.Fscanln(bufIO, &n, &k)

	books := [][]int{}
	for iBook := 0; iBook < n; iBook++ {
		t, a, b := 0, 0, 0
		fmt.Fscanln(bufIO, &t, &a, &b)
		if a == 0 && b == 0 {
			continue
		}

		books = append(books, []int{t, a, b})
	}

	sort.Slice(books, func(i, j int) bool {
		iScore := float64(books[i][0]) / float64(books[i][1]+books[i][2])
		jScore := float64(books[j][0]) / float64(books[j][1]+books[j][2])
		if iScore == jScore {
			return books[i][1]+books[i][2] < books[j][1]+books[j][2]
		}
		return iScore < jScore
	})
	//fmt.Println(books)

	bookA, bookB := []int{}, []int{}
	nBookA, nBookB := 0, 0
	ans := 0
	for i := range books {
		nBookA += books[i][1]
		nBookB += books[i][2]
		ans += books[i][0]

		if books[i][1] != 0 && books[i][2] != 0 {
			continue
		}
		if books[i][1] != 0 {
			bookA = append(bookA, i)
		}
		if books[i][2] != 0 {
			bookB = append(bookB, i)
		}
		if nBookA >= k && nBookB >= k {
			break
		}
	}
	//fmt.Println(bookA, bookB)

	if nBookA < k || nBookB < k {
		fmt.Println(-1)
		return
	}

	if nBookA > k {
		for i := len(bookA) - 1; i >= 0 && nBookA > k; i-- {
			ans -= books[bookA[i]][0]
			nBookA--
		}
	} else {
		for i := len(bookB) - 1; i >= 0 && nBookB > k; i-- {
			ans -= books[bookB[i]][0]
			nBookB--
		}
	}
	fmt.Println(ans)
}

package main

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

type book struct {
	ai int
	bi int
	ti int
}

func main() {
	var n, k int64
	fmt.Scanf("%d %d\n", &n, &k)
	books := make([]book, n)
	reader := bufio.NewReader(os.Stdin)
	for i := int64(0); i < n; i++ {
		var ti, ai, bi int
		line := readLine(reader)
		sss := strings.Split(string(line), " ")
		ti, _ = strconv.Atoi(sss[0])
		ai, _ = strconv.Atoi(sss[1])
		bi, _ = strconv.Atoi(sss[2])
		// fmt.Scanf("%d %d %d\n", &ti, &ai, &bi)
		b := book{
			ti: ti,
			ai: ai,
			bi: bi,
		}
		books[i] = b
	}
	sort.Slice(books, func(i, j int) bool {
		return books[i].ti < books[j].ti
	})
	sum := 0
	AAndB := make([]int, 0)
	onlyA, onlyB := make([]int, 0), make([]int, 0)
	countA, countB := int64(0), int64(0)
	for i := int64(0); i < n; i++ {
		if books[i].ai == 0 && books[i].bi == 0 {
			continue
		}
		if countA >= k && countB >= k {
			// 从后面找两个都是一样的，并且去除A和B
			if len(onlyA) == 0 || len(onlyB) == 0 {
				break
			}
			if books[i].ai == 0 || books[i].bi == 0 {
				continue
			}
			if books[i].ti > onlyA[len(onlyA)-1]+onlyB[len(onlyB)-1] {
				break
			}
			sum += books[i].ti - onlyA[len(onlyA)-1] - onlyB[len(onlyB)-1]
			onlyA = onlyA[:len(onlyA)-1]
			onlyB = onlyB[:len(onlyB)-1]
			AAndB = append(AAndB, books[i].ti)

		}
		// 填充A和B
		if books[i].ai == 1 && books[i].bi == 1 {
			// 共同爱好，那么需要去除之前多余的
			AAndB = append(AAndB, books[i].ti)
			if countA >= k {
				sum += books[i].ti - onlyA[len(onlyA)-1]
				onlyA = onlyA[:len(onlyA)-1]
				countB++
			} else if countB >= k {
				sum += books[i].ti - onlyB[len(onlyB)-1]
				onlyB = onlyB[:len(onlyB)-1]
				countA++
			} else {
				countA++
				countB++
				sum += books[i].ti
			}
		} else if books[i].ai == 1 {
			if countA >= k {
				continue
			}
			sum += books[i].ti
			onlyA = append(onlyA, books[i].ti)
			countA++
		} else {
			if countB >= k {
				continue
			}
			sum += books[i].ti
			onlyB = append(onlyB, books[i].ti)
			countB++
		}
	}
	if countA < k || countB < k {
		fmt.Println(-1)
		return
	}
	fmt.Println(sum)
}

func readLine(reader *bufio.Reader) []byte {
	result := make([]byte, 0)
	for {
		s, isPrefix, err := reader.ReadLine()
		if err != nil {
			fmt.Printf("error=%+v\n", err)
			break
		}
		result = append(result, s...)
		if !isPrefix {
			break
		}
	}
	return result
}

package main

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

type book struct {
	ai int64
	bi int64
	ti int64
}

func main() {
	var n, k int64
	fmt.Scanf("%d %d\n", &n, &k)
	books := make([]book, n)
	reader := bufio.NewReader(os.Stdin)
	for i := int64(0); i < n; i++ {
		var ti, ai, bi int64
		line := readLine(reader)
		sss := strings.Split(string(line), " ")
		ti, _ = strconv.ParseInt(sss[0], 10, 64)
		ai, _ = strconv.ParseInt(sss[1], 10, 64)
		bi, _ = strconv.ParseInt(sss[2], 10, 64)
		// fmt.Scanf("%d %d %d\n", &ti, &ai, &bi)
		b := book{
			ti: ti,
			ai: ai,
			bi: bi,
		}
		books[i] = b
	}
	sort.Slice(books, func(i, j int) bool {
		return books[i].ti < books[j].ti
	})
	sum := int64(0)
	AAndB := make([]int64, 0)
	onlyA, onlyB := make([]int64, 0), make([]int64, 0)
	countA, countB := int64(0), int64(0)
	for i := int64(0); i < n; i++ {
		if books[i].ai == 0 && books[i].bi == 0 {
			continue
		}
		if countA >= k && countB >= k {
			// 从后面找两个都是一样的，并且去除A和B
			if len(onlyA) == 0 || len(onlyB) == 0 {
				break
			}
			if books[i].ai == 0 || books[i].bi == 0 {
				continue
			}
			if books[i].ti > onlyA[len(onlyA)-1]+onlyB[len(onlyB)-1] {
				break
			}
			sum += books[i].ti - onlyA[len(onlyA)-1] - onlyB[len(onlyB)-1]
			onlyA = onlyA[:len(onlyA)-1]
			onlyB = onlyB[:len(onlyB)-1]
			AAndB = append(AAndB, books[i].ti)

		}
		// 填充A和B
		if books[i].ai == 1 && books[i].bi == 1 {
			// 共同爱好，那么需要去除之前多余的
			AAndB = append(AAndB, books[i].ti)
			if countA >= k {
				sum += books[i].ti - onlyA[len(onlyA)-1]
				onlyA = onlyA[:len(onlyA)-1]
				countB++
			} else if countB >= k {
				sum += books[i].ti - onlyB[len(onlyB)-1]
				onlyB = onlyB[:len(onlyB)-1]
				countA++
			} else {
				countA++
				countB++
				sum += books[i].ti
			}
		} else if books[i].ai == 1 {
			if countA >= k {
				continue
			}
			sum += books[i].ti
			onlyA = append(onlyA, books[i].ti)
			countA++
		} else {
			if countB >= k {
				continue
			}
			sum += books[i].ti
			onlyB = append(onlyB, books[i].ti)
			countB++
		}
	}
	if countA < k || countB < k {
		fmt.Println(-1)
		return
	}
	fmt.Println(sum)
}

func readLine(reader *bufio.Reader) []byte {
	result := make([]byte, 0)
	for {
		s, isPrefix, err := reader.ReadLine()
		if err != nil {
			fmt.Printf("error=%+v\n", err)
			break
		}
		result = append(result, s...)
		if !isPrefix {
			break
		}
	}
	return result
}

package main

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

type book struct {
	ai int64
	bi int64
	ti int64
}

func main() {
	var n, k int64
	fmt.Scanf("%d %d\n", &n, &k)
	books := make([]book, n)
	reader := bufio.NewReader(os.Stdin)
	for i := int64(0); i < n; i++ {
		var ti, ai, bi int64
		line := readLine(reader)
		sss := strings.Split(string(line), " ")
		ti, _ = strconv.ParseInt(sss[0], 10, 64)
		ai, _ = strconv.ParseInt(sss[1], 10, 64)
		bi, _ = strconv.ParseInt(sss[2], 10, 64)
		// fmt.Scanf("%d %d %d\n", &ti, &ai, &bi)
		if n == 200000 {
			fmt.Println(line)
		}
		b := book{
			ti: ti,
			ai: ai,
			bi: bi,
		}
		books[i] = b
	}
	sort.Slice(books, func(i, j int) bool {
		return books[i].ti < books[j].ti
	})
	sum := int64(0)
	AAndB := make([]int64, 0)
	onlyA, onlyB := make([]int64, 0), make([]int64, 0)
	countA, countB := int64(0), int64(0)
	for i := int64(0); i < n; i++ {
		if books[i].ai == 0 && books[i].bi == 0 {
			continue
		}
		if countA >= k && countB >= k {
			// 从后面找两个都是一样的，并且去除A和B
			if len(onlyA) == 0 || len(onlyB) == 0 {
				continue
			}
			if books[i].ai == 0 || books[i].bi == 0 {
				continue
			}
			if books[i].ti > onlyA[len(onlyA)-1]+onlyB[len(onlyB)-1] {
				break
			}
			sum += books[i].ti - onlyA[len(onlyA)-1] - onlyB[len(onlyB)-1]
			onlyA = onlyA[:len(onlyA)-1]
			onlyB = onlyB[:len(onlyB)-1]
			AAndB = append(AAndB, books[i].ti)

		}
		// 填充A和B
		if books[i].ai == 1 && books[i].bi == 1 {
			// 共同爱好，那么需要去除之前多余的
			AAndB = append(AAndB, books[i].ti)
			if countA >= k {
				sum += books[i].ti - onlyA[len(onlyA)-1]
				onlyA = onlyA[:len(onlyA)-1]
				countB++
			} else if countB >= k {
				sum += books[i].ti - onlyB[len(onlyB)-1]
				onlyB = onlyB[:len(onlyB)-1]
				countA++
			} else {
				countA++
				countB++
				sum += books[i].ti
			}
		} else if books[i].ai == 1 {
			if countA >= k {
				continue
			}
			sum += books[i].ti
			onlyA = append(onlyA, books[i].ti)
			countA++
		} else {
			if countB >= k {
				continue
			}
			sum += books[i].ti
			onlyB = append(onlyB, books[i].ti)
			countB++
		}
	}
	if countA < k || countB < k {
		fmt.Println(-1)
		return
	}
	fmt.Println(sum)
}

func readLine(reader *bufio.Reader) []byte {
	result := make([]byte, 0)
	for {
		s, isPrefix, err := reader.ReadLine()
		if err != nil {
			fmt.Printf("error=%+v\n", err)
			break
		}
		result = append(result, s...)
		if !isPrefix {
			break
		}
	}
	return result
}

package main

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

var nTest, n, k int
var t, a, b [200010]int

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	fmt.Fscan(in, &n, &k)
	both := []int{}
	alice := []int{}
	bob := []int{}

	for i := 0; i < n; i++ {
		fmt.Fscan(in, &t[i], &a[i], &b[i])

		if a[i] == 1 && b[i] == 1 {
			both = append(both, i)
		} else if a[i] == 1 {
			alice = append(alice, i)
		} else if b[i] == 1 {
			bob = append(bob, i)
		}
	}

	sort.Slice(both, func(i, j int) bool {
		return t[both[i]] < t[both[j]]
	})
	sort.Slice(alice, func(i, j int) bool {
		return t[alice[i]] < t[alice[j]]
	})
	sort.Slice(bob, func(i, j int) bool {
		return t[bob[i]] < t[bob[j]]
	})

	res := 0
	x := 0
	y := 0
	z := 0
	for i := 0; i < k; i++ {
		if x >= len(both) && (y >= len(alice) || z >= len(bob)) {
			fmt.Println(out, -1)
			out.Flush()
			return
		}

		if x >= len(both) {
			res += t[alice[y]] + t[bob[z]]
			y++
			z++
		} else if y >= len(alice) || z >= len(bob) {
			res += t[both[x]]
			x++
		} else {
			if t[both[x]] <= t[alice[y]]+t[bob[z]] {
				res += t[both[x]]
				x++
			} else {
				res += t[alice[y]] + t[bob[z]]
				y++
				z++
			}
		}
	}

	fmt.Fprintln(out, res)
	out.Flush()
}

package main

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

const INF = int(2e9)

func main() {
	n, k := NextInt(), NextInt()

	bothLikes := make([]int, 0)
	aLikes := make([]int, 0)
	bLikes := make([]int, 0)
	t := make([]int, n)
	a := make([]int, n)
	b := make([]int, n)
	for i := 0; i < n; i++ {
		t[i] = NextInt()
		a[i] = NextInt()
		b[i] = NextInt()
		if a[i] + b[i] == 2 {
			bothLikes = append(bothLikes, t[i])
		} else if a[i] == 1 {
			aLikes = append(aLikes, t[i])
		} else if b[i] == 1 {
			bLikes = append(bLikes, t[i])
		}
	}

	sort.Slice(bothLikes, func(i, j int) bool {
		return bothLikes[i] < bothLikes[j]
	})
	sort.Slice(aLikes, func(i, j int) bool {
		return aLikes[i] < aLikes[j]
	})
	sort.Slice(bLikes, func(i, j int) bool {
		return bLikes[i] < bLikes[j]
	})

	left := 0
	right := len(bothLikes)
	for right - left > 3 {
		m1 := left + (right-left) / 3
		m2 := right - (right-left) / 3

		if can(m1, k, bothLikes, aLikes, bLikes) >= can(m2, k, bothLikes, aLikes, bLikes) {
			left = m1
		} else {
			right = m2
		}
	}

	ans := INF
	for i := left; i <= right; i++ {
		if can(i, k, bothLikes, aLikes, bLikes) < ans {
			ans = can(i, k, bothLikes, aLikes, bLikes)
		}
	}

	if ans == INF {
		ans = -1
	}
	fmt.Println(ans)
}

func can(both int, k int, bothLikes []int, aLikes[]int, bLikes[]int) int {
	if len(aLikes) < k - both || len(bLikes) < k - both {
		return INF
	}

	sum := 0
	for i := 0; i < both; i++ {
		sum += bothLikes[i]
	}

	for i := 0; i < k-both; i++ {
		sum += aLikes[i]
	}
	for i := 0; i < k-both; i++ {
		sum += bLikes[i]
	}

	return sum
}

var sc = bufio.NewScanner(os.Stdin)

func init() {
	sc.Buffer(make([]byte, 256), 1e9)
	sc.Split(bufio.ScanWords)
}

func Next() string {
	sc.Scan()
	return sc.Text()
}

func NextInt() int {
	i, err := strconv.Atoi(Next())
	if err != nil {
		panic(err)
	}
	return i
}

func NextDouble() float64 {
	f, err := strconv.ParseFloat(Next(), 64)
	if err != nil {
		panic(err)
	}
	return f
}

package main

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

const INF = int(2e9)

func main() {
	n, k := NextInt(), NextInt()

	bothLikes := make([]int, 0)
	aLikes := make([]int, 0)
	bLikes := make([]int, 0)
	t := make([]int, n)
	a := make([]int, n)
	b := make([]int, n)
	for i := 0; i < n; i++ {
		t[i] = NextInt()
		a[i] = NextInt()
		b[i] = NextInt()
		if a[i] + b[i] == 2 {
			bothLikes = append(bothLikes, t[i])
		} else if a[i] == 1 {
			aLikes = append(aLikes, t[i])
		} else if b[i] == 1 {
			bLikes = append(bLikes, t[i])
		}
	}

	sort.Slice(bothLikes, func(i, j int) bool {
		return bothLikes[i] < bothLikes[j]
	})
	sort.Slice(aLikes, func(i, j int) bool {
		return aLikes[i] < aLikes[j]
	})
	sort.Slice(bLikes, func(i, j int) bool {
		return bLikes[i] < bLikes[j]
	})

	left := 0
	right := len(bothLikes)
	for right - left > 10 {
		m1 := left + (right-left) / 3
		m2 := right - (right-left) / 3

		if can(m1, k, bothLikes, aLikes, bLikes) >= can(m2, k, bothLikes, aLikes, bLikes) {
			left = m1
		} else {
			right = m2
		}
	}

	ans := INF
	for i := left; i <= right; i++ {
		if can(i, k, bothLikes, aLikes, bLikes) < ans {
			ans = can(i, k, bothLikes, aLikes, bLikes)
		}
	}

	if ans == INF {
		ans = -1
	}
	fmt.Println(ans)
}

func can(both int, k int, bothLikes []int, aLikes[]int, bLikes[]int) int {
	if len(aLikes) < k - both || len(bLikes) < k - both {
		return INF
	}

	sum := 0
	for i := 0; i < both; i++ {
		sum += bothLikes[i]
	}

	for i := 0; i < k-both; i++ {
		sum += aLikes[i]
	}
	for i := 0; i < k-both; i++ {
		sum += bLikes[i]
	}

	return sum
}

var sc = bufio.NewScanner(os.Stdin)

func init() {
	sc.Buffer(make([]byte, 256), 1e9)
	sc.Split(bufio.ScanWords)
}

func Next() string {
	sc.Scan()
	return sc.Text()
}

func NextInt() int {
	i, err := strconv.Atoi(Next())
	if err != nil {
		panic(err)
	}
	return i
}

func NextDouble() float64 {
	f, err := strconv.ParseFloat(Next(), 64)
	if err != nil {
		panic(err)
	}
	return f
}

package main

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

const INF = int(2e9)

func main() {
	n, k := NextInt(), NextInt()

	bothLikes := make([]int, 0)
	aLikes := make([]int, 0)
	bLikes := make([]int, 0)
	t := make([]int, n)
	a := make([]int, n)
	b := make([]int, n)
	for i := 0; i < n; i++ {
		t[i] = NextInt()
		a[i] = NextInt()
		b[i] = NextInt()
		if a[i] + b[i] == 2 {
			bothLikes = append(bothLikes, t[i])
		} else if a[i] == 1 {
			aLikes = append(aLikes, t[i])
		} else if b[i] == 1 {
			bLikes = append(bLikes, t[i])
		}
	}

	sort.Slice(bothLikes, func(i, j int) bool {
		return bothLikes[i] < bothLikes[j]
	})
	sort.Slice(aLikes, func(i, j int) bool {
		return aLikes[i] < aLikes[j]
	})
	sort.Slice(bLikes, func(i, j int) bool {
		return bLikes[i] < bLikes[j]
	})

	left := 0
	right := len(bothLikes)
	for right - left > 5 {
		m1 := left + (right-left) / 3
		m2 := right - (right-left) / 3

		if can(m1, k, bothLikes, aLikes, bLikes) >= can(m2, k, bothLikes, aLikes, bLikes) {
			left = m1
		} else {
			right = m2
		}
	}

	ans := INF
	for i := left; i <= right; i++ {
		if can(i, k, bothLikes, aLikes, bLikes) < ans {
			ans = can(i, k, bothLikes, aLikes, bLikes)
		}
	}

	if ans == INF {
		ans = -1
	}
	fmt.Println(ans)
}

func can(both int, k int, bothLikes []int, aLikes[]int, bLikes[]int) int {
	if len(aLikes) < k - both || len(bLikes) < k - both {
		return INF
	}

	sum := 0
	for i := 0; i < both; i++ {
		sum += bothLikes[i]
	}

	for i := 0; i < k-both; i++ {
		sum += aLikes[i]
	}
	for i := 0; i < k-both; i++ {
		sum += bLikes[i]
	}

	return sum
}

var sc = bufio.NewScanner(os.Stdin)

func init() {
	sc.Buffer(make([]byte, 256), 1e9)
	sc.Split(bufio.ScanWords)
}

func Next() string {
	sc.Scan()
	return sc.Text()
}

func NextInt() int {
	i, err := strconv.Atoi(Next())
	if err != nil {
		panic(err)
	}
	return i
}

func NextDouble() float64 {
	f, err := strconv.ParseFloat(Next(), 64)
	if err != nil {
		panic(err)
	}
	return f
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)
var wrtr = bufio.NewWriterSize(os.Stdout, 10_000_000)
var rdr = bufio.NewScanner(os.Stdin)
func gs() string  { rdr.Scan(); return rdr.Text() }
func gi() int     { i,e := strconv.Atoi(gs()); if e != nil {panic(e)}; return i }
func gis(n int) []int  { res := make([]int,n); for i:=0;i<n;i++ { res[i] = gi() }; return res }
func main() {
	//f1, _ := os.Create("cpu.prof"); pprof.StartCPUProfile(f1); defer pprof.StopCPUProfile()
	defer wrtr.Flush()
	infn := ""; if infn == "" && len(os.Args) > 1 {	infn = os.Args[1] }
	if infn != "" {	f, e := os.Open(infn); if e != nil { panic(e) }; rdr = bufio.NewScanner(f) }
	rdr.Split(bufio.ScanWords); rdr.Buffer(make([]byte,1024),1_000_000_000)
	// PROGRAM STARTS HERE
	T := gi()
	for tt:=1;tt<=T;tt++ {
		N := gi(); A := gis(N)
		ans := 0
		for i:=N-2;i>=0;i-- {
			if A[i+1] == 0 { ans = -1; break }
			for A[i] >= A[i+1] { ans++; A[i] /= 2 }
		}
		fmt.Fprintln(wrtr,ans)
	}
}

package main

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

func main() {
	in, out := bufio.NewReader(os.Stdin), bufio.NewWriter(os.Stdout)
	defer out.Flush()
	var t int
	fmt.Fscan(in, &t)

	for ii := 0; ii < t; ii++ {
		var n int
		fmt.Fscan(in, &n)
		nums := make([]int, n)
		for i := 0; i < n; i++ {
			fmt.Fscan(in, &nums[i])
		}
		ans := 0
	out:
		for i := n - 2; i >= 0; i-- {
			for nums[i] >= nums[i+1] {
				if nums[i] == 0 {
					ans = -1
					break out
				}
				ans++
				nums[i] >>= 1
			}
		}
		fmt.Fprintln(out, ans)
	}
}

package main

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

var in = bufio.NewReader(os.Stdin)
var tc = 1
var DEBUG = os.Getenv("DEBUG") != ""

func solve() {
	var n int
	scan(&n)
	a := make([]int, n)
	for i := range a {
		scan(&a[i])
	}
	ret := 0
	for i := n - 2; i >= 0; i-- {
		if a[i+1] == 0 {
			printf("-1\n")
			return
		}
		for a[i] >= a[i+1] {
			a[i] /= 2
			ret++
		}
	}
	printf("%d\n", ret)
}

func main() {
	var T int
	scan(&T)
	for ; T > 0; T-- {
		solve()
		tc++
	}
}

func ys(b bool) string      { return map[bool]string{true: "YES", false: "NO"}[b] }
func scan(a ...interface{}) { fmt.Fscan(in, a...) }
func printf(format string, a ...interface{}) {
	if DEBUG {
		format = fmt.Sprintf("Test #%d: %s", tc, format)
	}
	fmt.Printf(format, a...)
}

func gcd(a, b int) int {
	for b != 0 {
		a, b = b, a%b
	}
	return a
}

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

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

package main

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

func main() {
	var (
		t int
	)

	reader := bufio.NewReader(os.Stdin)
	fmt.Scanf("%d\n", &t)

	for t > 0 {
		t--

		text, _ := reader.ReadString('\n')
		ninps := strings.Fields(text)
		n, _ := strconv.Atoi(ninps[0])

		x := make([]int, n)
		//y := make([]int, n)

		text, _ = reader.ReadString('\n')
		ninps = strings.Fields(text)
		for i := 0; i < n; i++ {
			x[i], _ = strconv.Atoi(ninps[i])
		}

		cnt := 0
		fail := false
		for i := 0; i < n-1; i++ {
			if x[i] >= x[i+1] {
				for j := i; j >= 0; j-- {
					for x[j] >= x[j+1] {
						x[j] /= 2
						cnt++
						if x[j] == 0 && x[j+1] == 0 {
							fail = true
							break
						}
					}
					//fmt.Println(x)
					if fail {
						break
					}
				}
			}
			if fail {
				break
			}
		}
		if fail {
		        fmt.Println(-1)
		} else {
			fmt.Println(cnt)
		}
	}
}

// https://codeforces.com/problemset/problem/1675/B

// 1675B - Make It Increasing

// Given n integers a1,a2,…,an. You can perform the following operation on them:
//  • select any element ai (1≤i≤n) and divide it by 2 (round down). In other words, you can replace any selected element ai with the value ⌊ai2⌋ (where ⌊x⌋ is – round down the real number x).
// Output the minimum number of operations that must be done for a sequence of integers to become strictly increasing (that is, for the condition a1<a2<⋯<an to be satisfied). Or determine that it is impossible to obtain such a sequence. Note that elements cannot be swapped. The only possible operation is described above.

// For example, let n=3 and a sequence of numbers [3,6,5] be given. Then it is enough to perform two operations on it:
//  • Write the number ⌊62⌋=3 instead of the number a2=6 and get the sequence [3,3,5];
//  • Then replace a1=3 with ⌊32⌋=1 and get the sequence [1,3,5].
// The resulting sequence is strictly increasing because 1<3<5.

// Input
// The first line of the input contains an integer t (1≤t≤10^4) — the number of test cases in the input.
// The descriptions of the test cases follow.
// The first line of each test case contains a single integer n (1≤n≤30).
// The second line of each test case contains exactly n integers a1,a2,…,an (0≤ai≤2⋅10^9).

// Output
// For each test case, print a single number on a separate line — the minimum number of operations to perform on the sequence to make it strictly increasing. If a strictly increasing sequence cannot be obtained, print "-1".

// Example
// input
// 7
// 3
// 3 6 5
// 4
// 5 3 2 1
// 5
// 1 2 3 4 5
// 1
// 1000000000
// 4
// 2 8 7 5
// 5
// 8 26 5 21 10
// 2
// 5 14
// output
// 2
// -1
// 0
// 0
// 4
// 11
// 0

// Note

// The first test case is analyzed in the statement.
// In the second test case, it is impossible to obtain a strictly increasing sequence.
// In the third test case, the sequence is already strictly increasing.

// Tutorial

// We will process the elements of the sequence starting from the end of the sequence. Each element ai (1≤i≤n−1) will be divided by 2 until it is less than ai+1. If at some point it turns out that ai+1=0, it is impossible to obtain the desired sequence.

package main

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

func main() {
	var reader = bufio.NewReader(os.Stdin)
	var writer = bufio.NewWriter(os.Stdout)
	var c int
	var t, n, i, ans uint
	var a []uint
	var flag bool

	for c, _ = fmt.Fscan(reader, &t); c == 1; c, _ = fmt.Fscan(reader, &t) {
		for ; t > 0; t-- {
			fmt.Fscan(reader, &n)
			a = make([]uint, n)

			for i = 0; i < n; i++ {
				fmt.Fscan(reader, &a[i])
			}

			for i, flag, ans = n-1, true, 0; i > 0 && flag; i-- {
				for a[i] <= a[i-1] && flag {
					a[i-1] >>= 1
					ans++

					if a[i] == 0 {
						flag = false
					}
				}
			}

			if flag {
				fmt.Fprintln(writer, ans)
			} else {
				fmt.Fprintln(writer, -1)
			}
		}
	}

	writer.Flush()
}

// 00
package main

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

func main() {
	var T int
	reader := bufio.NewReader(os.Stdin)
	fmt.Fscan(reader, &T)
	for t := 1; t <= T; t++ {
		var n int
		fmt.Fscan(reader, &n)
		a := make([]int, n)
		for i := 0; i < n; i++ {
			fmt.Fscan(reader, &a[i])
		}
		ans := 0
		ok := true
		for i := n - 1; i > 0; i-- {
			if a[i] == 0 {
				ok = false
				break
			}
			if a[i-1] >= a[i] {
				for a[i-1] >= a[i] {
					a[i-1] = a[i-1] / 2
					ans++
				}
			}
		}
		if ok {
			fmt.Println(ans)
		} else {
			fmt.Println(-1)
		}
	}
}

package main

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

var wr = bufio.NewWriter(os.Stdout)
var rd = bufio.NewScanner(os.Stdin)

func nextInt() int {
	rd.Scan()
	if n, err := strconv.Atoi(rd.Text()); err == nil {
		return n
	}
	return 0
}
func Max(a,b int)int{
	if a>b {
		return a
	}else{
		return b
	}
}
func main() {
	defer wr.Flush()
	rd.Buffer(make([]byte, 0), 1000000009)
	rd.Split(bufio.ScanWords)
	T := nextInt()
	for Case := 0; Case < T; Case++ {
		solve()
	}
}
func solve() {
	n:=nextInt()
	a:=make([]int,n,n)
	for i :=0;i<n;i++{
		a[i]=nextInt()
	}
	res:=0
	for i:=n-2;i>=0;i--{
		for a[i]>=a[i+1]{
			if(a[i]==0){
				fmt.Fprint(wr,"-1\n")
				return
			}else{
				a[i]/=2
				res++
			}
		}
	}
	fmt.Fprint(wr,res,"\n")
}

package main

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

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var T int
	fmt.Fscan(in, &T)
	for t := 0; t < T; t++ {
		var n int
		fmt.Fscan(in, &n)

		arr := make([]int64, n)
		var idx int
		for i := 0; i < n; i++ {
			fmt.Fscan(in, &arr[i])

			if i > 0 && arr[i] <= arr[i-1] {
				idx = i
			}
		}

		var tot int
		f := true
		for i := idx - 1; i >= 0; i-- {
			if arr[i+1] == 0 {
				f = false
				break
			}

			for arr[i] >= arr[i+1] {
				if arr[i] == 0 {
					break
				}

				arr[i] /= 2
				tot++
			}
		}

		if !f {
			fmt.Fprintln(out, -1)
		} else {
			fmt.Fprintln(out, tot)
		}
	}
}

package main

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

func main() {
	r, w := bufio.NewReader(os.Stdin), bufio.NewWriter(os.Stdout)
	defer w.Flush()
	var n int
	Fscan(r, &n)
	t := 0
	var q int
	for t < n {
		t++
		Fscan(r, &q)
		aa := make([]int, q)
		for i := range aa {
			Fscan(r, &aa[i])
		}
		k := 0
		for i := q - 2; i >= 0; i--{
			if aa[i+1] == 0{
				k = -1
				break
			}
			for aa[i] >= aa[i+1]{
				aa[i] /= 2
				k++
			}
		}
		Fprintln(w, k)
	}
}

package main

import (
	"bufio"
	"fmt"
	"io"
	"math"
	"os"
)

//goland:noinspection GoUnusedFunction
func min(a int, nums ...int) int {
	min := a

	for _, num := range nums {
		if num < min {
			min = num
		}
	}
	return min
}

//goland:noinspection GoUnusedFunction
func max(a int, nums ...int) int {
	max := a

	for _, num := range nums {
		if num > max {
			max = num
		}
	}
	return max
}

//goland:noinspection GoUnusedFunction
func FprintlnArr(w io.Writer, arr []int) {
	for _, val := range arr {
		fmt.Fprint(w, val, " ")
	}
	fmt.Fprintln(w)
}

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var t int
	for fmt.Fscan(in, &t); t > 0; t-- {
		var n int
		fmt.Fscan(in, &n)

		arr := make([]int, n)
		for i := 0; i < n; i++ {
			fmt.Fscan(in, &arr[i])
		}

		if n == 1 {
			fmt.Fprintln(out, 0)
			continue
		}

		cnt := 0
		ans := true
		for i := n - 2; i >= 0; i-- {
			for arr[i] > 0 && arr[i] >= arr[i+1] {
				arr[i] = int(math.Floor(float64(arr[i] / 2)))
				cnt++
			}
			if arr[i] == 0 && arr[i+1] == 0 {
				ans = false
				break
			}
		}

		if ans {
			fmt.Fprintln(out, cnt)
		} else {
			fmt.Fprintln(out, -1)
		}
	}
}

package main

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

func main_div3_787_B() {
	_in, _out := os.Stdin, os.Stdout
	in, out := bufio.NewReader(_in), bufio.NewWriter(_out)
	defer out.Flush()
	var cas int = 1
	Fscan(in, &cas)
	var sol func()
	// Coding...
	sol = func() {
		var n int
		Fscan(in, &n)
		arr := make([]int, n)
		var ans int
		for i := 0; i < n; i++ {
			Fscan(in, &arr[i])
		}
		for i := n - 2; i >= 0; i-- {
			for arr[i] > 0 && arr[i] >= arr[i+1] {
				ans++
				arr[i] >>= 1
			}
			if arr[i] >= arr[i+1] {
				Fprintln(out, -1)
				return
			}
		}
		Fprintln(out, ans)
	}
	for i := 0; i < cas; i++ {
		sol()
	}
}

func main() {
	main_div3_787_B()
}

package main

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

/*

 */

//goland:noinspection GoUnhandledErrorResult
func solve() {
	var n int
	scanf("%d\n", &n)

	a := make([]int, n)

	for i := range a {
		scanf("%d", &a[i])
	}
	scanf("\n")

	cnt := 0

	for i := n - 2; i >= 0; i-- {
		if a[i+1] == 0 {
			fmt.Fprintln(writer, -1)
			return
		}

		for a[i] >= a[i+1] {
			a[i] /= 2
			cnt++
		}
	}

	fmt.Fprintln(writer, cnt)
}

//goland:noinspection GoUnhandledErrorResult
func main() {
	defer writer.Flush()

	t := 1
	scanf("%d\n", &t)

	for ; t > 0; t-- {
		solve()
	}
}

const maxUint = ^uint(0)

//goland:noinspection GoUnusedConst
const minUint = 0
const maxInt = int(maxUint >> 1)

//goland:noinspection GoUnusedConst
const minInt = -maxInt - 1

var reader = bufio.NewReader(os.Stdin)
var writer = bufio.NewWriter(os.Stdout)

func scanf(f string, a ...interface{}) {
	if _, err := fmt.Fscanf(reader, f, a...); err != nil {
		panic(err)
	}
}

//goland:noinspection GoUnusedFunction
func reversed(s string) string {
	input := []rune(s)
	li := len(input)
	ret := make([]rune, li)
	for i, r := range input {
		ret[li-i-1] = r
	}
	return string(ret)
}

//goland:noinspection GoUnusedFunction
func divCeil(num, div int64) int64 {
	quot := num / div
	if num%div > 0 {
		quot++
	} else if num%div < 0 {
		quot--
	}
	return quot
}

//goland:noinspection GoUnusedFunction
func min(nums ...int) int {
	return nums[minIdx(nums...)]
}

//goland:noinspection GoUnusedFunction
func minIdx(nums ...int) int {
	minNumIdx := 0
	for i, num := range nums {
		if num < nums[minNumIdx] {
			minNumIdx = i
		}
	}

	return minNumIdx
}

//goland:noinspection GoUnusedFunction
func max(nums ...int) int {
	return nums[maxIdx(nums...)]
}

//goland:noinspection GoUnusedFunction
func maxIdx(nums ...int) int {
	maxNumIdx := 0
	for i, num := range nums {
		if num > nums[maxNumIdx] {
			maxNumIdx = i
		}
	}

	return maxNumIdx
}

//goland:noinspection GoUnusedFunction
func sum(nums ...int) (sum int) {
	for _, num := range nums {
		sum += num
	}
	return
}

//goland:noinspection GoUnusedFunction
func abs(num int) int {
	if num < 0 {
		return -num
	}
	return num
}

//goland:noinspection GoUnusedFunction
func isPrime(num int64) bool {
	if num == 2 || num == 3 {
		return true
	}

	if num <= 1 || num%2 == 0 || num%3 == 0 {
		return false
	}

	for i := int64(5); i*i <= num; i += 6 {
		if num%i == 0 || num%(i+2) == 0 {
			return false
		}
	}

	return true
}

//goland:noinspection GoUnusedFunction
func gcd(a, b int) int {
	for b != 0 {
		a, b = b, a%b
	}
	return a
}

//goland:noinspection GoUnusedFunction
func lcm(a, b int) int {
	return abs(a) / gcd(a, b) * abs(b)
}

// Examples:
//	digitAt(1234, -1) -> panic!
//	digitAt(1234, 0) -> 4
//	digitAt(1234, 1) -> 3
//	digitAt(1234, 2) -> 2
//	digitAt(1234, 3) -> 1
//	digitAt(1234, 4) -> panic!
//goland:noinspection GoUnusedFunction
func digitAt(num, pos int) int {
	if num == 0 {
		return 0
	}

	num = abs(num)

	lenNum := int(math.Log10(float64(num))) + 1
	if pos < 0 || pos >= lenNum {
		err := fmt.Sprintf("Out of bound access for digit. Position passed %d, number %d", pos, num)
		panic(err)
	}

	rem := num % int(math.Pow10(pos+1))
	return rem / int(math.Pow10(pos))
}

//goland:noinspection GoUnusedFunction
func factorize(num int64) []int64 {
	factors := make([]int64, 0)

	for ftr := int64(2); ftr*ftr <= num; ftr++ {
		for num%ftr == 0 {
			num /= ftr
			factors = append(factors, ftr)
		}
	}

	if num > 1 {
		factors = append(factors, num)
	}

	return factors
}

package main

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

var r = bufio.NewReader(os.Stdin)
var w = bufio.NewWriter(os.Stdout)

func slove(T int) {
	defer w.Flush()
	var n int
	fmt.Fscan(r, &n)
	nums := make([]int, n)
	for i:=0;i<n;i++ {
		fmt.Fscan(r, &nums[i])
	}
	ans := 0
	for i:=n-2;i>=0;i-- {
		for nums[i] != 0 && nums[i] >= nums[i+1] {
			nums[i]/=2
			ans++
		}
		if nums[i] >= nums[i+1] {
			fmt.Fprintln(w, "-1")
			return
		}
	}
	fmt.Fprintln(w, ans)
}

func main() {
	var n int
	fmt.Fscan(r, &n)
	for i:=1;i<=n;i++ {
		slove(i)
	}
}

package main

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

var in = bufio.NewReader(os.Stdin)
var tc = 1
var DEBUG = os.Getenv("DEBUG") != ""

func solve() {
	var n int
	scan(&n)
	a := make([]int, n)
	for i := range a {
		scan(&a[i])
	}
	ret := 0
	for i := n - 2; i >= 1; i-- {
		if a[i+1] == 0 {
			printf("-1\n")
			return
		}
		for a[i] >= a[i+1] {
			a[i] /= 2
			ret++
		}
	}
	printf("%d\n", ret)
}

func main() {
	var T int
	scan(&T)
	for ; T > 0; T-- {
		solve()
		tc++
	}
}

func ys(b bool) string      { return map[bool]string{true: "YES", false: "NO"}[b] }
func scan(a ...interface{}) { fmt.Fscan(in, a...) }
func printf(format string, a ...interface{}) {
	if DEBUG {
		format = fmt.Sprintf("Test #%d: %s", tc, format)
	}
	fmt.Printf(format, a...)
}

func gcd(a, b int) int {
	for b != 0 {
		a, b = b, a%b
	}
	return a
}

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

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

package main

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

func main() {
	var (
		t int
	)

	reader := bufio.NewReader(os.Stdin)
	fmt.Scanf("%d\n", &t)

	for t > 0 {
		t--

		text, _ := reader.ReadString('\n')
		ninps := strings.Fields(text)
		n, _ := strconv.Atoi(ninps[0])

		x := make([]int, n)
		//y := make([]int, n)

		text, _ = reader.ReadString('\n')
		ninps = strings.Fields(text)
		for i := 0; i < n; i++ {
			x[i], _ = strconv.Atoi(ninps[i])
		}

		cnt := 0
		fail := false
		for i := 0; i < n-1; i++ {
			if x[i] > x[i+1] {
				for j := i; j >= 0; j-- {
					for x[j] >= x[j+1] {
						x[j] /= 2
						cnt++
						if x[j] == 0 && x[j+1] == 0 {
							fail = true
							break
						}
					}
					if fail {
						break
					}
				}
			}
			if fail {
				break
			}
		}
		if fail {
		        fmt.Println(-1)
		} else {
			fmt.Println(cnt)
		}
	}
}


package main

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

func main() {
	in := bufio.NewReader(os.Stdin)

	var n int
	fmt.Fscan(in, &n)
	a := make([]int, n)
	for i := range a {
		fmt.Fscan(in, &a[i])
	}

	var u, d []int
	nxt := make([][]int, n)

	upd := func(i int, add func(int, int)) {
		for len(u) > 0 && a[u[len(u)-1]] < a[i] {
			u = u[:len(u)-1]
		}
		for len(d) > 0 && a[d[len(d)-1]] > a[i] {
			d = d[:len(d)-1]
		}
		if len(u) > 0 {
			add(u[len(u)-1], i)
		}
		if len(d) > 0 {
			add(d[len(d)-1], i)
		}
		u, d = append(u, i), append(d, i)
	}

	for i := 0; i < n; i++ {
		upd(i, func(i, j int) { nxt[i] = append(nxt[i], j) })
	}
	u, d = nil, nil
	for i := n - 1; i >= 0; i-- {
		upd(i, func(i, j int) { nxt[j] = append(nxt[j], i) })
	}

	dp := make([]int, n)
	for i := n - 2; i >= 0; i-- {
		dp[i] = math.MaxInt32
		for _, j := range nxt[i] {
			if dp[j]+1 < dp[i] {
				dp[i] = dp[j] + 1
			}
		}
	}

	fmt.Println(dp[0])
}

package main

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

func main() {
	in := bufio.NewReader(os.Stdin)

	var n int
	fmt.Fscan(in, &n)
	a := make([]int, n)
	for i := range a {
		fmt.Fscan(in, &a[i])
	}

	var u, d []int
	nxt := make([][]int, n)

	upd := func(i int, add func(int, int)) {
		for len(u) > 0 && a[u[len(u)-1]] < a[i] {
			u = u[:len(u)-1]
		}
		for len(d) > 0 && a[d[len(d)-1]] > a[i] {
			d = d[:len(d)-1]
		}
		if len(u) > 0 {
			add(u[len(u)-1], i)
		}
		if len(d) > 0 {
			add(d[len(d)-1], i)
		}
		u, d = append(u, i), append(d, i)
	}

	for i := 0; i < n; i++ {
		upd(i, func(i, j int) { nxt[i] = append(nxt[i], j) })
	}
	for i := n - 1; i >= 0; i-- {
		upd(i, func(i, j int) { nxt[j] = append(nxt[j], i) })
	}

	dp := make([]int, n)
	for i := n - 2; i >= 0; i-- {
		dp[i] = math.MaxInt32
		for _, j := range nxt[i] {
			if dp[j]+1 < dp[i] {
				dp[i] = dp[j] + 1
			}
		}
	}

	fmt.Println(dp[0])
}

package main

import (
	"bufio"
	"fmt"
	"io"
	"math"
	"os"
)

func main() {
	io := NewFastIO(os.Stdin, os.Stdout)
	defer io.Flush()

	n := io.NextInt()
	a := io.NextInts(n)

	dp := make([]int, n)
	uq, dq := []int{n - 1}, []int{n - 1}
	for i := n - 2; i >= 0; i-- {
		for len(uq) > 0 && a[uq[len(uq)-1]] < a[i] {
			uq = uq[:len(uq)-1]
		}
		for len(dq) > 0 && a[dq[len(dq)-1]] > a[i] {
			dq = dq[:len(dq)-1]
		}
		up, dn := math.MaxInt32, math.MaxInt32
		if len(uq) > 0 {
			up = dp[uq[len(uq)-1]]
		}
		if len(dq) > 0 {
			dn = dp[dq[len(dq)-1]]
		}
		dp[i] = up
		if dn < dp[i] {
			dp[i] = dn
		}
		dp[i]++
		uq, dq = append(uq, i), append(dq, i)
	}
	io.Println(dp[0])
}

type FastIO struct {
	*bufio.Writer
	r    io.Reader
	buf  [8192]byte
	i, n int
}

func NewFastIO(r io.Reader, w io.Writer) *FastIO {
	return &FastIO{r: r, Writer: bufio.NewWriter(w)}
}

func (f *FastIO) readC() byte {
	if f.i == f.n {
		f.n, _ = f.r.Read(f.buf[:])
		if f.n == 0 {
			panic("EOF")
		}
		f.i = 0
	}
	f.i++
	return f.buf[f.i-1]
}

func (f *FastIO) NextInt() int {
	c := f.readC()
	for ; c <= ' '; c = f.readC() {
	}
	neg := false
	if c == '-' {
		neg = true
		c = f.readC()
	}
	n := 0
	for ; '0' <= c && c <= '9'; c = f.readC() {
		n = n*10 + int(c) - '0'
	}
	if neg {
		return -n
	}
	return n
}

func (f *FastIO) NextInts(n int) []int {
	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = f.NextInt()
	}
	return a
}

func (f *FastIO) Println(a ...interface{}) {
	fmt.Fprintln(f, a...)
}


package main

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

func main() {
	long := Line()
	short := Line()
	fmt.Printf("%v\n", Run(long, short))
}

func Run(long, short string) int {
	return strings.Count(long, short)
}

//
// Helpers
//

// Input

var read = bufio.NewReader(os.Stdin)

func Line() string {
	s, err := read.ReadString('\n')
	if err != nil {
		panic(err)
	}
	return strings.TrimSpace(s[:len(s)-1])
}

func ReadInts(line string) []int64 {
	scanner := bufio.NewScanner(strings.NewReader(line))
	scanner.Split(bufio.ScanWords)
	var nums []int64
	for scanner.Scan() {
		x := Int(scanner.Text())
		nums = append(nums, x)
	}
	return nums
}

// Conversions

func Int(nStr string) int64 {
	n, err := strconv.ParseInt(nStr, 10, 64)
	if err != nil {
		panic(err)
	}
	return n
}

package main

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

func main() {
    stin := bufio.NewReader(os.Stdin)
    aiName,_ := stin.ReadBytes('\n')
    phoneNumber,_ := stin.ReadBytes('\n')

    aiName = bytes.Trim(aiName,"\n\r ")
    phoneNumber = bytes.Trim(phoneNumber,"\n\r ")
    //fmt.Printf("%v\n%v\n", aiName, phoneNumber)

    n := len(aiName)
    p := len(phoneNumber)
    pCount := 0
    for i := 0; i < n-p+1; {
        if aiName[i] == phoneNumber[0] {
            isEqual := 1
            for j := 1; j < p; j++ {
                if aiName[i+j] != phoneNumber[j] {
                    isEqual = 0
                    break
                }
            }
            if isEqual == 1 {
                pCount += 1
                i += p
            } else {
                i += 1
            }
        } else {
            i += 1
        }
    }
    fmt.Printf("%v", pCount)
}

package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
	"regexp"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	re := regexp.MustCompile(`\r?\n`)

	var ai, phone string

	if s, err := reader.ReadString('\n'); err != nil {
		if err != io.EOF {
			return
		}
	} else {
		ai = re.ReplaceAllString(s, "")
	}
	if s, err := reader.ReadString('\n'); err != nil {
		if err != io.EOF {
			return
		}
	} else {
		phone = re.ReplaceAllString(s, "")
	}

	sharps := 0
	last_sharp_idx := -1

	pl := len(phone)
	for i := 0; i <= len(ai)-pl; i++ {
		sub := ai[i : i+pl]
		if sub == phone {
			if last_sharp_idx < 0 || i > last_sharp_idx {
				last_sharp_idx = i + pl - 1
				sharps += 1
			}
		}
	}

	fmt.Println(sharps)
}

package main

import (
	"fmt"
	"strings"
)

func main() {
	var s, sub string
	fmt.Scan(&s, &sub)

	ans := strings.Count(s, sub)
	fmt.Println(ans)
}

package main

import (
	"fmt"
)

func main() {
	var text, pattern string
	fmt.Scan(&text)
	fmt.Scan(&pattern)
	result := make([]byte, len(text))
	for i:=0;i<len(text);i++ {
		result[i] = text[i]
	}

	times := 0
	for i:=0; i<len(result);i++ {
		if len(result) - i >= len(pattern) {
			match := true
			for j:=0;j<len(pattern);j++ {
				if result[i+j] != pattern[j] {
					match = false
				}
			}
			if match {
				result[i+len(pattern)-1] = '#'
				times++
			}
		}
	}
	fmt.Println(times)
}

package main

import (
	"fmt"
)

func main() {
	var text, pattern string
	fmt.Scan(&text)
	fmt.Scan(&pattern)
	result := make([]byte, len(text))
	for i:=0;i<len(text);i++ {
		result[i] = text[i]
	}

	times := 0
	for i:=0; i<len(result);i++ {
		if len(result) - i - 1 >= len(pattern) {
			match := true
			for j:=0;j<len(pattern);j++ {
				if result[i+j] != pattern[j] {
					match = false
				}
			}
			if match {
				result[i+len(pattern)-1] = '#'
				times++
			}
		}
	}
	fmt.Println(times)
}

package main

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

func main() {
	long := Line()
	short := Line()
	fmt.Printf("%v\n", Run(long, short))
}

func Run(long, short string) int {
	return strings.Count(long, short)
}

//
// Helpers
//

// Input

var read = bufio.NewReader(os.Stdin)

func Line() string {
	s, err := read.ReadString('\n')
	if err != nil {
		panic(err)
	}
	return s[:len(s)-1]
}

func ReadInts(line string) []int64 {
	scanner := bufio.NewScanner(strings.NewReader(line))
	scanner.Split(bufio.ScanWords)
	var nums []int64
	for scanner.Scan() {
		x := Int(scanner.Text())
		nums = append(nums, x)
	}
	return nums
}

// Conversions

func Int(nStr string) int64 {
	n, err := strconv.ParseInt(nStr, 10, 64)
	if err != nil {
		panic(err)
	}
	return n
}


package main

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

var reader *bufio.Reader = bufio.NewReader(os.Stdin)
var writer *bufio.Writer = bufio.NewWriter(os.Stdout)

func printf(f string, a ...interface{}) { fmt.Fprintf(writer, f, a...) }
func scanf(f string, a ...interface{})  { fmt.Fscanf(reader, f, a...) }

func main() {
	var (
		n int
		m int
		v int
	)

	defer writer.Flush()

	scanf("%d %d\n", &n, &m)

	a := make([]int, 0, n)
	for i := 0; i < n; i++ {
		scanf("%d", &v)
		a = append(a, v)
	}

	scanf("\n")

	k := 0
	r := make([]int, n)
	u := make(map[int]bool)
	for i := n - 1; i >= 0; i-- {
		_, ok := u[a[i]]
		if !ok {
			u[a[i]] = true
			k += 1
		}
		r[i] = k
	}

	for i := 0; i < m; i++ {
		scanf("%d\n", &v)
		printf("%d\n", r[v-1])
	}
}

package main

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

func main()  {
	var n,m int
	fmt.Scan(&n,&m)
	a := make([]int,n)
	l := make([]int,m)
	valcntMap := make(map[int]int)
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	for i:=0; i < n; i++{
		scanner.Scan()
		//a[i],_ = strconv.Atoi(scanner.Text())
		a[i],_ = atoi(scanner.Bytes()) //faster than above
		valcntMap[a[i]]++ //count the number of elements in the map
	}

	for i:=0; i<m; i++{
		scanner.Scan()
		l[i],_ = atoi(scanner.Bytes())
		l[i]-- //start from 0
	}
	res := make([]int,n)
	for i:=0;i<n;i++{
		res[i] = len(valcntMap)
		if valcntMap[a[i]] == 1{
			delete(valcntMap,a[i])
		}else{
			valcntMap[a[i]]--
		}
	}
	for i:=0;i<m;i++{fmt.Printf("%d\n",res[l[i]])}
}

// atoi parses a buffer into an integer
// without overflow detection.
func atoi(b []byte) (int, error) {
	neg := false
	if b[0] == '+' {
		b = b[1:]
	} else if b[0] == '-' {
		neg = true
		b = b[1:]
	}
	n := 0
	for _, v := range b {
		if v < '0' || v > '9' {
			return 0, strconv.ErrSyntax
		}
		n = n*10 + int(v-'0')
	}
	if neg {
		return -n, nil
	}
	return n, nil
}

package main

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

func main()  {
	var n,m int
	fmt.Scan(&n,&m)
	a := make([]int,n)
	l := make([]int,m)
	valcntMap := make(map[int]int)
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	for i:=0; i < n; i++{
		scanner.Scan()
		a[i],_ = strconv.Atoi(scanner.Text())
		//a[i],_ = atoi(scanner.Bytes()) //faster than above
		valcntMap[a[i]]++ //count the number of elements in the map
	}

	for i:=0; i<m; i++{
		scanner.Scan()
		//l[i],_ = atoi(scanner.Bytes())
		l[i],_ = strconv.Atoi(scanner.Text())
		l[i]-- //start from 0
	}
	res := make([]int,n)
	for i:=0;i<n;i++{
		res[i] = len(valcntMap)
		if valcntMap[a[i]] == 1{
			delete(valcntMap,a[i])
		}else{
			valcntMap[a[i]]--
		}
	}
	for i:=0;i<m;i++{fmt.Printf("%d\n",res[l[i]])}
}

// atoi parses a buffer into an integer
// without overflow detection.
func atoi(b []byte) (int, error) {
	neg := false
	if b[0] == '+' {
		b = b[1:]
	} else if b[0] == '-' {
		neg = true
		b = b[1:]
	}
	n := 0
	for _, v := range b {
		if v < '0' || v > '9' {
			return 0, strconv.ErrSyntax
		}
		n = n*10 + int(v-'0')
	}
	if neg {
		return -n, nil
	}
	return n, nil
}

package main

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

func main() {
    //io
    scanner := bufio.NewReader(os.Stdin)
    writer := bufio.NewWriter(os.Stdout)
    //---
    var n, m int
    fmt.Fscan(scanner, &n, &m)
    var a, b [101000]int
    var used [101000]bool

    for i:= 0; i < n; i++ {
        fmt.Fscan(scanner, &a[i])
    }

    for i:= n - 1; i >= 0; i-- {
        if !used[a[i]] {
            used[a[i]] = true
            b[i] = b[i+1] + 1
        } else {
            b[i] = b[i+1]
        }
    }

    for i:= 0; i < m; i++ {
        fmt.Fscan(scanner, &n)
        //fmt.Println(b[n-1])
        writer.WriteString(strconv.Itoa(b[n-1]) + "\n")
    }
    writer.Flush()
}

package main

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

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    scanner.Split(bufio.ScanWords)
    writer := bufio.NewWriter(os.Stdout)
    var n,m int
    fmt.Scan(&n,&m)
    a := make([]int,n+1)
    for i := 1; i <= n; i++ {
        scanner.Scan()
        a[i], _ = strconv.Atoi(scanner.Text())
    }
    dp := make([]int,n+1)
    f := make(map[int]bool)
    for i := n; i > 0; i-- {
        if !f[a[i]] {
            dp[i]++
            f[a[i]] = true
        }
        if i != n { dp[i] += dp[i+1] }
    }
    for i := 0; i < m; i++ {
        scanner.Scan()
        l, _ := strconv.Atoi(scanner.Text())
        writer.WriteString(strconv.Itoa(dp[l])+"\n")
    }
    writer.Flush()
}

package main
import (
    "fmt"
    "bufio"
    "os"
)
func main() {
    var n, m int
    var _a [110000]int
    var _ans [110000]int
    bin := bufio.NewReader(os.Stdin)
    fmt.Fscan(bin, &n, &m)

    for i := 0; i < n;i++ {
        fmt.Fscan(bin, &_a[i])
    }
    a := _a[:n]
    ans := _ans[:n]
    var mp map[int]int
    mp = make(map[int]int)
    ans[n - 1] = 1
    mp[a[n-1]] = 1
    for i := n - 2; i >=0; i-- {
        v, ok := mp[a[i]]
        if ok {
            ans[i] = ans[i + 1]
        } else {
            ans[i] = ans[i + 1] + 1
            mp[a[i]] = 1 + v
        }
    }
    for i := 0; i < m; i ++ {
        var v int
        fmt.Fscan(bin, &v)
        fmt.Printf("%d\n", ans[v - 1])
    }
}

package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)

	var n, m int
	fmt.Fscan(reader, &n, &m)

	arr, dp, exist := make([]int, n+1), make([]int, n+2), make(map[int]bool)

	dp[n+1] = 0
	for i := 1; i <= n; i++ {
		fmt.Fscan(reader, &arr[i])
	}
	for i := n; i >= 1; i-- {
		dp[i] = dp[i+1]
		if !exist[arr[i]] {
			dp[i], exist[arr[i]] = dp[i]+1, true
		}
	}

	for m > 0 {
		var x int
		fmt.Fscan(reader, &x)

		fmt.Println(dp[x])
		m--
	}
}

package main

import(
	"fmt"
	"sort"
)

type IR struct{
	index int
	from int
}

type ByFrom []IR

func (f ByFrom) Len() int {return len(f)}
func (f ByFrom) Swap(i,j int) {f[i],f[j] = f[j],f[i]}
func (f ByFrom) Less(i,j int) bool {return f[i].from < f[j].from}

func main()  {
	var n,m int
	fmt.Scan(&n,&m)
	a := make([]int,n)
	valcntMap := make(map[int]int)
	for i:=0; i < n; i++{
		fmt.Scan(&a[i])
		if _,ok := valcntMap[a[i]]; !ok{ //not in the set
			valcntMap[a[i]] = 1
		}else{
			valcntMap[a[i]]++ //count the number of elements in the map
		}
	}
	bf := make(ByFrom,m)
	for i:=0; i<m; i++{
		fmt.Scan(&bf[i].from)
		bf[i].index = i
	}
	sort.Sort(bf) //sort by from
	res := make([]int,m)
	var idx int
	for i:=0;i<m;i++{
		for idx != bf[i].from{
			if valcntMap[a[idx]] == 1{
				delete(valcntMap,a[idx])
			}else{
				valcntMap[a[idx]]--
			}
			idx++
		}
		res[bf[i].index] = len(valcntMap)
	}
	fmt.Printf("%d",res[0])
	for i:=1;i<m;i++{fmt.Printf(" %d",res[i])}
}

package main

import(
	"fmt"
	"sort"
)

type IR struct{
	index int
	from int
}

type ByFrom []IR

func (f ByFrom) Len() int {return len(f)}
func (f ByFrom) Swap(i,j int) {f[i],f[j] = f[j],f[i]}
func (f ByFrom) Less(i,j int) bool {return f[i].from < f[j].from}

func main()  {
	var n,m int
	fmt.Scan(&n,&m)
	a := make([]int,n)
	valcntMap := make(map[int]int)
	for i:=0; i < n; i++{
		fmt.Scan(&a[i])
		if _,ok := valcntMap[a[i]]; !ok{ //not in the set
			valcntMap[a[i]] = 1
		}else{
			valcntMap[a[i]]++ //count the number of elements in the map
		}
	}
	bf := make(ByFrom,m)
	for i:=0; i<m; i++{
		fmt.Scan(&bf[i].from)
		bf[i].from--  //start from 0
		bf[i].index = i
	}
	sort.Sort(bf) //sort by from
	res := make([]int,m)
	var idx int
	for i:=0;i<m;i++{
		for idx != bf[i].from{
			if valcntMap[a[idx]] == 1{
				delete(valcntMap,a[idx])
			}else{
				valcntMap[a[idx]]--
			}
			idx++
		}
		res[bf[i].index] = len(valcntMap)
	}
	fmt.Printf("%d",res[0])
	for i:=1;i<m;i++{fmt.Printf(" %d",res[i])}
}

package main

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

var reader *bufio.Reader = bufio.NewReader(os.Stdin)
var writer *bufio.Writer = bufio.NewWriter(os.Stdout)

func printf(f string, a ...interface{}) { fmt.Fprintf(writer, f, a...) }
func scanf(f string, a ...interface{})  { fmt.Fscanf(reader, f, a...) }

func main() {
	var (
		n int
		m int
		v int
	)

	defer writer.Flush()

	scanf("%d %d\n", &n, &m)

	a := make([]int, 0, n)
	for i := 0; i < n; i++ {
		scanf("%d\n", &v)
		a = append(a, v)
	}

	k := 0
	r := make([]int, n)
	u := make(map[int]bool)
	for i := n - 1; i >= 0; i-- {
		_, ok := u[a[i]]
		if !ok {
			u[a[i]] = true
			k += 1
		}
		r[i] = k
	}

	for i := 0; i < m; i++ {
		scanf("%d", &v)
		printf("%d\n", r[v-1])
	}
}

package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)

	var n, m int
	fmt.Fscan(reader, &n, &m)

	arr, dp, exist := make([]int, n+1), make([]int, n+1), make(map[int]bool)
	dp[0] = 0

	for i := 1; i <= n; i++ {
		fmt.Fscan(reader, &arr[i])
		dp[i] = dp[i-1]
		if !exist[arr[i]] {
			dp[i], exist[arr[i]] = dp[i]+1, true
		}
	}

	for m > 0 {
		var x int
		fmt.Fscan(reader, &x)

		fmt.Println(dp[n] - dp[x] + 1)
		m--
	}
}


package main

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

var in *bufio.Reader
var out *bufio.Writer

func printf(x string, a ...interface{}) (n int, err error) {
	return fmt.Fprintf(out, x, a...)
}

func scanf(x string, a ...interface{}) (n int, err error) {
	return fmt.Fscanf(in, x, a...)
}

var err error

func next() (n string) {
	for {
		_, err = scanf("%v", &n)
		if err == nil {
			return n
		}
		if err.Error() == "EOF" {
			return ""
		}
	}
}

func nextInt() (n int) {
	for {
		_, err = scanf("%v", &n)
		if err == nil {
			return n
		}
		if err.Error() == "EOF" {
			return 0
		}
	}
}

func nextLong() (n int64) {
	for {
		_, err = scanf("%v", &n)
		if err == nil {
			return n
		}
		if err.Error() == "EOF" {
			return 0
		}
	}
}

func nextDouble() (n float64) {
	for {
		_, err = scanf("%v", &n)
		if err == nil {
			return n
		}
		if err.Error() == "EOF" {
			return 0
		}
	}
}

func Fill(a []int, v int) {
	for i := range a {
		a[i] = v
	}
}

func FillB(a []bool, v bool) {
	for i := range a {
		a[i] = v
	}
}

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 Abs(a int) int {
	if a < 0 {
		return -a
	}
	return a
}

const (
	oo  = 1000000
	mod = 1000000007
)

func mult(a, b int64) int64 {
	return (a * b) % mod
}
func add(a, b int64) int64 {
	return (a + b) % mod
}
func sub(a, b int64) int64 {
	return (a - b + mod) % mod
}

var (
	adj   [][]int
	depth []int
)

func solve() {
	n := nextInt()
	for i := 0; i < n; i++ {
		for j := 0; j < n; j++ {
			printf("%d ", int64(i%2)<<(i+j))
		}
		printf("\n")
	}
	out.Flush()
	q := nextInt()
	for tt := 0; tt < q; tt++ {
		k := nextLong()
		x, y := 0, 0
		printf("1 1\n")
		for i := 1; i < 2*n-1; i++ {
			if (k&(int64(1)<<i) == 0) != (x%2 == 0) {
				x++
			} else {
				y++
			}
			printf("%d %d\n", x+1, y+1)
		}
		out.Flush()
	}
}
func main() {
	in = bufio.NewReaderSize(os.Stdin, 8192)
	out = bufio.NewWriterSize(os.Stdout, 8192)
	if false {
		file1, err := os.Open("input.txt")
		if err != nil {
			log.Fatal(err)
		}
		file2, err := os.Create("output.txt")
		if err != nil {
			log.Fatal(err)
		}
		in = bufio.NewReaderSize(file1, 8192)
		out = bufio.NewWriterSize(file2, 8192)
	}
	defer out.Flush()

	// start := time.Now()

	// for t, i := nextInt(), 1; t > 0; t, i = t-1, i+1 {
	// printf("Case %d: ", i)
	solve()
	// }

	// printf("%v\n", time.Now().Sub(start))
}

package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)

	n := readNum(reader)

	solver := NewSolver(n)

	str := toString(solver.board)

	fmt.Print(str)

	q := readNum(reader)

	for q > 0 {
		q--
		var x uint64
		s, _ := reader.ReadBytes('\n')
		readUint64(s, 0, &x)
		ans := solver.Query(int64(x))

		fmt.Print(ans)
	}
}

func toString(arr [][]int64) string {
	var buf bytes.Buffer
	for i := 0; i < len(arr); i++ {
		for j := 0; j < len(arr[i]); j++ {
			buf.WriteString(fmt.Sprintf("%d ", arr[i][j]))
		}
		buf.WriteByte('\n')
	}
	return buf.String()
}

func readInt(bytes []byte, from int, val *int) int {
	i := from
	sign := 1
	if bytes[i] == '-' {
		sign = -1
		i++
	}
	tmp := 0
	for i < len(bytes) && bytes[i] >= '0' && bytes[i] <= '9' {
		tmp = tmp*10 + int(bytes[i]-'0')
		i++
	}
	*val = tmp * sign
	return i
}

func readNum(reader *bufio.Reader) (a int) {
	bs, _ := reader.ReadBytes('\n')
	readInt(bs, 0, &a)
	return
}

func readTwoNums(reader *bufio.Reader) (a int, b int) {
	res := readNNums(reader, 2)
	a, b = res[0], res[1]
	return
}

func readThreeNums(reader *bufio.Reader) (a int, b int, c int) {
	res := readNNums(reader, 3)
	a, b, c = res[0], res[1], res[2]
	return
}

func readNNums(reader *bufio.Reader, n int) []int {
	res := make([]int, n)
	x := 0
	bs, _ := reader.ReadBytes('\n')
	for i := 0; i < n; i++ {
		for x < len(bs) && (bs[x] < '0' || bs[x] > '9') && bs[x] != '-' {
			x++
		}
		x = readInt(bs, x, &res[i])
	}
	return res
}

func readUint64(bytes []byte, from int, val *uint64) int {
	i := from

	var tmp uint64
	for i < len(bytes) && bytes[i] >= '0' && bytes[i] <= '9' {
		tmp = tmp*10 + uint64(bytes[i]-'0')
		i++
	}
	*val = tmp

	return i
}

type Solver struct {
	n     int
	board [][]int64
}

func NewSolver(n int) Solver {
	board := make([][]int64, n)

	for i := 0; i < n; i++ {
		board[i] = make([]int64, n)

		for j := 0; j < n; j++ {
			if i == 0 && j == 0 {
				continue
			}
			if i == n-1 && j == n-1 {
				continue
			}

			if i%2 == 0 {
				board[i][j] = int64(1) << (i + j)
			}
		}
	}

	return Solver{n, board}
}

func (solver Solver) Query(q int64) string {
	var buf bytes.Buffer

	buf.WriteString(fmt.Sprintf("%d %d\n", 1, 1))

	n := solver.n
	B := solver.board
	var x, y int

	for x < n-1 || y < n-1 {
		if x == n-1 {
			y++
		} else if y == n-1 {
			x++
		} else {
			and := max(B[x+1][y], B[x][y+1])

			if q&and > 0 != (B[x+1][y] > 0) {
				y++
			} else {
				x++
			}
		}
		buf.WriteString(fmt.Sprintf("%d %d\n", x+1, y+1))
	}

	return buf.String()
}

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

package main

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

var in *bufio.Reader
var out *bufio.Writer

func printf(x string, a ...interface{}) (n int, err error) {
	return fmt.Fprintf(out, x, a...)
}

func scanf(x string, a ...interface{}) (n int, err error) {
	return fmt.Fscanf(in, x, a...)
}

var err error

func next() (n string) {
	for {
		_, err = scanf("%v", &n)
		if err == nil {
			return n
		}
		if err.Error() == "EOF" {
			return ""
		}
	}
}

func nextInt() (n int) {
	for {
		_, err = scanf("%v", &n)
		if err == nil {
			return n
		}
		if err.Error() == "EOF" {
			return 0
		}
	}
}

func nextLong() (n int64) {
	for {
		_, err = scanf("%v", &n)
		if err == nil {
			return n
		}
		if err.Error() == "EOF" {
			return 0
		}
	}
}

func nextDouble() (n float64) {
	for {
		_, err = scanf("%v", &n)
		if err == nil {
			return n
		}
		if err.Error() == "EOF" {
			return 0
		}
	}
}

func Fill(a []int, v int) {
	for i := range a {
		a[i] = v
	}
}

func FillB(a []bool, v bool) {
	for i := range a {
		a[i] = v
	}
}

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 Abs(a int) int {
	if a < 0 {
		return -a
	}
	return a
}

const (
	oo  = 1000000
	mod = 1000000007
)

func mult(a, b int64) int64 {
	return (a * b) % mod
}
func add(a, b int64) int64 {
	return (a + b) % mod
}
func sub(a, b int64) int64 {
	return (a - b + mod) % mod
}

var (
	adj   [][]int
	depth []int
)

func pow(a, b int64) int64 {
	if b == 0 {
		return 1
	}
	res := pow(a, b/2)
	res = mult(res, res)
	if b%2 == 1 {
		res = mult(res, a)
	}
	return res
}

func solve() {
	n := nextInt()
	for i := 0; i < n; i++ {
		for j := 0; j < n; j++ {
			printf("%d ", int64(1)<<(i*n+j))
		}
		printf("\n")
	}
	out.Flush()
	q := nextInt()
	for tt := 0; tt < q; tt++ {
		k := nextLong()
		for i := 0; i < n; i++ {
			for j := 0; j < n; j++ {
				if k&(int64(1)<<(i*n+j)) != 0 {
					printf("%d %d\n", i+1, j+1)
				}
			}
		}
		out.Flush()
	}
}
func main() {
	in = bufio.NewReaderSize(os.Stdin, 8192)
	out = bufio.NewWriterSize(os.Stdout, 8192)
	if false {
		file1, err := os.Open("input.txt")
		if err != nil {
			log.Fatal(err)
		}
		file2, err := os.Create("output.txt")
		if err != nil {
			log.Fatal(err)
		}
		in = bufio.NewReaderSize(file1, 8192)
		out = bufio.NewWriterSize(file2, 8192)
	}
	defer out.Flush()

	// start := time.Now()

	// for t, i := nextInt(), 1; t > 0; t, i = t-1, i+1 {
	// printf("Case %d: ", i)
	solve()
	// }

	// printf("%v\n", time.Now().Sub(start))
}