```go
package main

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

// FastScanner handles input parsing
type FastScanner struct {
	r *bufio.Reader
}

func NewFastScanner(r io.Reader) *FastScanner {
	return &FastScanner{r: bufio.NewReaderSize(r, 1<<20)}
}

func (s *FastScanner) ReadInt() int {
	var v int
	var c byte
	var err error
	for {
		c, err = s.r.ReadByte()
		if err != nil {
			return 0
		}
		if c > ' ' {
			break
		}
	}
	v = int(c - '0')
	for {
		c, err = s.r.ReadByte()
		if err != nil {
			break
		}
		if c <= ' ' {
			break
		}
		v = v*10 + int(c-'0')
	}
	return v
}

// Data structures for sorting
type item struct {
	id  int
	val float64
}

type Items []item

func (a Items) Len() int           { return len(a) }
func (a Items) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a Items) Less(i, j int) bool { return a[i].val > a[j].val } // Descending

type sumItem struct {
	id  int
	sum int
}

type SumItems []sumItem

func (a SumItems) Len() int           { return len(a) }
func (a SumItems) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a SumItems) Less(i, j int) bool { return a[i].sum > a[j].sum } // Descending

func main() {
	scanner := NewFastScanner(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	n := scanner.ReadInt()

	const maxM = 200005
	reqs := make([][]int, maxM)
	var activeMsgs []int
	seen := make([]bool, maxM)

	for i := 0; i < n; i++ {
		m := scanner.ReadInt()
		k := scanner.ReadInt()
		reqs[m] = append(reqs[m], k)
		if !seen[m] {
			seen[m] = true
			activeMsgs = append(activeMsgs, m)
		}
	}

	numActive := len(activeMsgs)
	bestT := 1
	maxExpected := -1.0

	// Strategy 1: Small t (1 to 19)
	limitSmall := 19
	if numActive < 19 {
		limitSmall = numActive
	}

	items := make(Items, numActive)

	for t := 1; t <= limitSmall; t++ {
		// Calculate weights for each message for current t
		for i, mid := range activeMsgs {
			w := 0.0
			for _, k := range reqs[mid] {
				if t <= k {
					w += 1.0
				} else {
					w += float64(k) / float64(t)
				}
			}
			items[i] = item{id: mid, val: w}
		}

		// Sort to find best t messages
		sort.Sort(items)

		currentSum := 0.0
		for i := 0; i < t; i++ {
			currentSum += items[i].val
		}

		if currentSum > maxExpected {
			maxExpected = currentSum
			bestT = t
		}
	}

	// Strategy 2: Large t (20 to numActive)
	if numActive >= 20 {
		sums := make(SumItems, numActive)
		for i, mid := range activeMsgs {
			s := 0
			for _, k := range reqs[mid] {
				s += k
			}
			sums[i] = sumItem{id: mid, sum: s}
		}

		sort.Sort(sums)

		currentTotalK := 0
		for i := 0; i < numActive; i++ {
			currentTotalK += sums[i].sum
			t := i + 1
			if t >= 20 {
				expected := float64(currentTotalK) / float64(t)
				if expected > maxExpected {
					maxExpected = expected
					bestT = t
				}
			}
		}
	}

	// Output result
	fmt.Fprintln(writer, bestT)

	// Reconstruct the set of messages for bestT
	resIds := make([]int, 0, bestT)
	
	if bestT < 20 {
		// Recalculate weights for bestT
		for i, mid := range activeMsgs {
			w := 0.0
			for _, k := range reqs[mid] {
				if bestT <= k {
					w += 1.0
				} else {
					w += float64(k) / float64(bestT)
				}
			}
			items[i] = item{id: mid, val: w}
		}
		sort.Sort(items)
		for i := 0; i < bestT; i++ {
			resIds = append(resIds, items[i].id)
		}
	} else {
		// Recalculate based on sum K
		sums := make(SumItems, numActive)
		for i, mid := range activeMsgs {
			s := 0
			for _, k := range reqs[mid] {
				s += k
			}
			sums[i] = sumItem{id: mid, sum: s}
		}
		sort.Sort(sums)
		for i := 0; i < bestT; i++ {
			resIds = append(resIds, sums[i].id)
		}
	}

	for i, id := range resIds {
		if i > 0 {
			fmt.Fprint(writer, " ")
		}
		fmt.Fprint(writer, id)
	}
	fmt.Fprintln(writer)
}
```