use itertools::Itertools;
use proconio::input;
const INF: usize = 1 << 60;
const DXY: [(usize, usize); 4] = [(!0, 0), (0, 1), (1, 0), (0, !0)];
fn solve() {
    input! {
        n: usize,
        lr: [(usize, usize); n],
    }
    let mut ans: usize = 0;
    'outer: for p in (0..n).permutations(n) {
        let mut a = 0;
        for &p in &p{
            if lr[p].1 < a{
                continue 'outer;
            }
            a.chmax(lr[p].0);
        }
        ans += 1;
    }
    println!("{}", ans);
}

fn main() {
    solve();
    // multi_solve();
}

fn yes_no(b: bool) {
    println!("{}", if b { "Yes" } else { "No" });
}

fn char_to_int(c: char) -> usize {
    (c as u8 - b'a') as usize
}

fn int_to_char(i: usize) -> char {
    (b'a' + i as u8) as char
}

fn multi_solve() {
    input! {
        t: usize,
    }
    for _ in 0..t {
        solve();
    }
}

#[derive(Clone, Debug)]
struct Compress<T> {
    vals: Vec<T>,
}

impl<T: Ord + Clone> Compress<T> {
    fn new(mut v: Vec<T>) -> Self {
        v.sort();
        v.dedup();
        Self { vals: v }
    }

    fn get(&self, x: T) -> usize {
        self.vals
            .binary_search(&x)
            .unwrap_or_else(|_| panic!("not in compress"))
    }

    fn rev(&self, i: usize) -> &T {
        &self.vals[i]
    }

    fn len(&self) -> usize {
        self.vals.len()
    }
}

trait ChangeMinMax {
    fn chmax(&mut self, x: Self) -> bool;
    fn chmin(&mut self, x: Self) -> bool;
}

impl<T: PartialOrd> ChangeMinMax for T {
    fn chmax(&mut self, x: Self) -> bool {
        if *self < x {
            *self = x;
            true
        } else {
            false
        }
    }

    fn chmin(&mut self, x: Self) -> bool {
        if *self > x {
            *self = x;
            true
        } else {
            false
        }
    }
}

#[macro_export]
macro_rules! vec2 {
    ($n: expr, $m: expr, $val: expr) => {
        vec![vec![$val; $m]; $n]
    };
}

#[macro_export]
macro_rules! vec3 {
    ($n: expr, $m: expr, $l: expr, $val: expr) => {
        vec![vec![vec![$val; $m]; $n]; $l]
    };
}