```go
package main

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

type SegTree struct {
	n    int
	max  []int
	pos  []int
	lazy []int
}

func NewSegTree(n int) *SegTree {
	if n == 0 {
		return &SegTree{}
	}
	st := &SegTree{
		n:    n,
		max:  make([]int, 4*n),
		pos:  make([]int, 4*n),
		lazy: make([]int, 4*n),
	}
	st.build(1, 0, n-1)
	return st
}

func (st *SegTree) build(idx, l, r int) {
	if l == r {
		st.pos[idx] = l
		return
	}
	mid := (l + r) >> 1
	st.build(idx<<1, l, mid)
	st.build(idx<<1|1, mid+1, r)
	st.pos[idx] = st.pos[idx<<1]
}

func (st *SegTree) apply(idx, val int) {
	st.max[idx] += val
	st.lazy[idx] += val
}

func (st *SegTree) push(idx int) {
	if st.lazy[idx] != 0 {
		st.apply(idx<<1, st.lazy[idx])
		st.apply(idx<<1|1, st.lazy[idx])
		st.lazy[idx] = 0
	}
}

func (st *SegTree) update(idx, l, r, ql, qr, val int) {
	if ql > r || qr < l {
		return
	}
	if ql <= l && r <= qr {
		st.apply(idx, val)
		return
	}
	st.push(idx)
	mid := (l + r) >> 1
	st.update(idx<<1, l, mid, ql, qr, val)
	st.update(idx<<1|1, mid+1, r, ql, qr, val)
	if st.max[idx<<1] >= st.max[idx<<1|1] {
		st.max[idx] = st.max[idx<<1]
		st.pos[idx] = st.pos[idx<<1]
	} else {
		st.max[idx] = st.max[idx<<1|1]
		st.pos[idx] = st.pos[idx<<1|1]
	}
}

func (st *SegTree) Update(l, r, val int) {
	if l > r || st.n == 0 {
		return
	}
	st.update(1, 0, st.n-1, l, r, val)
}

func (st *SegTree) query(idx, l, r, ql, qr int) (int, int) {
	if ql > r || qr < l {
		return -1, -1
	}
	if ql <= l && r <= qr {
		return st.max[idx], st.pos[idx]
	}
	st.push(idx)
	mid := (l + r) >> 1
	leftMax, leftPos := st.query(idx<<1, l, mid, ql, qr)
	rightMax, rightPos := st.query(idx<<1|1, mid+1, r, ql, qr)
	if leftMax >= rightMax {
		return leftMax, leftPos
	}
	return rightMax, rightPos
}

func (st *SegTree) Query(l, r int) (int, int) {
	if l > r || st.n == 0 {
		return -1, -1
	}
	return st.query(1, 0, st.n-1, l, r)
}

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

	var n, sX, sY int
	fmt.Fscan(reader, &n, &sX, &sY)

	type event struct {
		delta int
		y1    int
		y2    int
	}
	events := make(map[int][]event)
	xs := make([]int, 0, 2*n+1)
	ys := make([]int, 0, 2*n+1)
	ys = append(ys, sY)

	for i := 0; i < n; i++ {
		var x, y int
		fmt.Fscan(reader, &x, &y)

		L := x
		R := sX
		if x > sX {
			L = sX
			R = x
		}
		D := y
		U := sY
		if y > sY {
			D = sY
			U = y
		}

		events[L] = append(events[L], event{1, D, U})
		events[R+1] = append(events[R+1], event{-1, D, U})
		xs = append(xs, L, R+1)
		ys = append(ys, D, U)
	}

	xs = append(xs, sX)
	sort.Ints(xs)
	tmpX := xs[:0]
	for _, v := range xs {
		if len(tmpX) == 0 || tmpX[len(tmpX)-1] != v {
			tmpX = append(tmpX, v)
		}
	}
	xs = tmpX

	sort.Ints(ys)
	tmpY := ys[:0]
	for _, v := range ys {
		if len(tmpY) == 0 || tmpY[len(tmpY)-1] != v {
			tmpY = append(tmpY, v)
		}
	}
	ys = tmpY

	st := NewSegTree(len(ys))
	sYIdx := sort.Search(len(ys), func(i int) bool { return ys[i] >= sY })

	maxCount := 0
	bestX, bestY := -1, -1

	for _, x := range xs {
		if eList, ok := events[x]; ok {
			for _, e := range eList {
				l := sort.Search(len(ys), func(i int) bool { return ys[i] >= e.y1 })
				r := sort.Search(len(ys), func(i int) bool { return ys[i] >= e.y2 })
				st.Update(l, r, e.delta)
			}
		}

		if x < 0 || x > 1000000000 {
			continue
		}

		if x == sX {
			if sYIdx > 0 {
				cnt, pos := st.Query(0, sYIdx-1)
				if cnt > maxCount {
					maxCount = cnt
					bestX = x
					bestY = ys[pos]
				}
			}
			if sYIdx < len(ys)-1 {
				cnt, pos := st.Query(sYIdx+1, len(ys)-1)
				if cnt > maxCount {
					maxCount = cnt
					bestX = x
					bestY = ys[pos]
				}
			}
		} else {
			cnt, pos := st.Query(0, len(ys)-1)
			if cnt > maxCount {
				maxCount = cnt
				bestX = x
				bestY = ys[pos]
			}
		}
	}

	fmt.Fprintln(writer, maxCount)
	fmt.Fprintln(writer, bestX, bestY)
}
```