package main

import (
	"io"
	"os"
)

type DSU struct {
	p  []int
	sz []int
}

func NewDSU(n int) *DSU {
	p := make([]int, n+1)
	sz := make([]int, n+1)
	for i := 1; i <= n; i++ {
		p[i] = i
		sz[i] = 1
	}
	return &DSU{p: p, sz: sz}
}

func (d *DSU) Find(x int) int {
	for d.p[x] != x {
		d.p[x] = d.p[d.p[x]]
		x = d.p[x]
	}
	return x
}

func (d *DSU) Union(a, b int) bool {
	ra := d.Find(a)
	rb := d.Find(b)
	if ra == rb {
		return false
	}
	if d.sz[ra] < d.sz[rb] {
		ra, rb = rb, ra
	}
	d.p[rb] = ra
	d.sz[ra] += d.sz[rb]
	return true
}

type Fenwick struct {
	n      int
	maxPow int
	bit    []int
}

func NewFenwick(n int) *Fenwick {
	mp := 1
	for (mp << 1) <= n {
		mp <<= 1
	}
	return &Fenwick{
		n:      n,
		maxPow: mp,
		bit:    make([]int, n+1),
	}
}

func (f *Fenwick) Add(i, delta int) {
	for i <= f.n {
		f.bit[i] += delta
		i += i & -i
	}
}

func (f *Fenwick) Sum(i int) int {
	res := 0
	for i > 0 {
		res += f.bit[i]
		i -= i & -i
	}
	return res
}

func (f *Fenwick) Kth(k int) int {
	idx := 0
	b := f.maxPow
	for b > 0 {
		next := idx + b
		if next <= f.n && f.bit[next] < k {
			idx = next
			k -= f.bit[next]
		}
		b >>= 1
	}
	return idx + 1
}

func nextInt(data []byte, idx *int) int {
	n := len(data)
	for *idx < n && (data[*idx] < '0' || data[*idx] > '9') {
		*idx++
	}
	val := 0
	for *idx < n && data[*idx] >= '0' && data[*idx] <= '9' {
		val = val*10 + int(data[*idx]-'0')
		*idx++
	}
	return val
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0
	n := nextInt(data, &idx)
	m := 2 * n

	l := make([]int, n+1)
	r := make([]int, n+1)
	event := make([]int, m+1)

	for i := 1; i <= n; i++ {
		li := nextInt(data, &idx)
		ri := nextInt(data, &idx)
		l[i] = li
		r[i] = ri
		event[li] = i
		event[ri] = -i
	}

	dsu := NewDSU(n)
	fw := NewFenwick(m)
	active := make([]int, m+1)
	edges := 0

	for pos := 1; pos <= m; pos++ {
		id := event[pos]
		if id > 0 {
			ri := r[id]
			cnt := fw.Sum(ri - 1)
			if edges+cnt > n-1 {
				os.Stdout.WriteString("NO")
				return
			}
			for k := 1; k <= cnt; k++ {
				rp := fw.Kth(k)
				other := active[rp]
				if !dsu.Union(id, other) {
					os.Stdout.WriteString("NO")
					return
				}
				edges++
			}
			fw.Add(ri, 1)
			active[ri] = id
		} else {
			id = -id
			ri := r[id]
			fw.Add(ri, -1)
			active[ri] = 0
		}
	}

	if edges == n-1 {
		os.Stdout.WriteString("YES")
	} else {
		os.Stdout.WriteString("NO")
	}
}