#include <algorithm>
#include <cinttypes>
#include <cmath>
#include <cstdlib>
#include <cstdio>
#include <cstdint>
#include <deque>
#include <initializer_list>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>

using std::deque;
using std::initializer_list;
using std::make_pair;
using std::map;
using std::multiset;
using std::pair;
using std::priority_queue;
using std::reverse;
using std::set;
using std::sort;
using std::string;
using std::swap;
using std::unordered_map;
using std::unordered_set;
using std::vector;

typedef int8_t     int8;
typedef int16_t    int16;
typedef int32_t    int32;
typedef int64_t    int64;
typedef __int128_t int128;

template <typename T>
using priority_queue_max = std::priority_queue<T>;

template <typename T>
using priority_queue_min = std::priority_queue<T, std::vector<T>, std::greater<T>>;

const int32 oo = 1e9;
const int64 ooo = 1e18;

#define scan(args...) [&]{ return scanf(args); }();
#define elements(a) ((int32)(a).size())
#define TESTS  int32 _t; scan("%" SCNd32, &_t); while (_t--)

inline int64 castformorebits(int32 a)
{
    return (int64)a;
}

inline int128 castformorebits(int64 a)
{
    return (int128)a;
}

template <class INT>
inline INT abs(INT a)
{
    if (a >= 0) return a;
    return -a;
}

template <typename T>
T minimum(std::initializer_list<T>&& l)
{
    T answer = *(l.begin());

    for (auto a : l)
        if (a < answer)
            answer = a;

    return answer;
}

template <typename T>
T minimum(const vector<T>& l)
{
    T answer = *(l.begin());

    for (auto a : l)
        if (a < answer)
            answer = a;

    return answer;
}

template <typename T>
T maximum(std::initializer_list<T>&& l)
{
    T answer = *(l.begin());

    for (auto a : l)
        if (a > answer)
            answer = a;

    return answer;
}

template <typename T>
T maximum(const vector<T>& l)
{
    T answer = *(l.begin());

    for (auto a : l)
        if (a > answer)
            answer = a;

    return answer;
}

template <typename T>
inline void sort(T &data)
{
    sort(data.begin(), data.end());
}

template <typename T>
inline void reverse(T &data)
{
    reverse(data.begin(), data.end());
}

template <class INT>
INT fast_exponential(INT a, INT b, INT mod)
{
    INT result = 1;

    while (b > 0)
    {
        if (b % 2 == 1)
            result = (castformorebits(result) * a) % mod;
        a = (castformorebits(a) * a) % mod;
        b = b / 2;
    }

    return result;
}

// TODO: ++ --

struct int_mod
{
    int32 val;
    static int32 modulo;
    int_mod() : val(0) {}
    int_mod(int32 n) : val(n % modulo) {}

    int_mod& operator=(const int32& n)
    {
        val = n % modulo;
        return *this;
    }

    int_mod& operator+=(const int_mod &a)
    {
        val += a.val;
        if (val >= modulo)
            val -= modulo;
        return *this;
    }

    int_mod& operator-=(const int_mod &a)
    {
        val += modulo - a.val;
        if (val >= modulo)
            val -= modulo;
        return *this;
    }

    int_mod& operator*=(const int_mod &a)
    {
        val = (castformorebits(val) * a.val) % modulo;
        return *this;
    }

    int_mod& operator/=(const int_mod &a)
    {
        // Assume modulo is prime
        int32 inverse = fast_exponential(a.val, modulo-2, modulo);

        val = (castformorebits(val) * inverse) % modulo;
        return *this;
    }
};

int int_mod::modulo = 0;

inline int_mod operator+(const int_mod &a, const int_mod b)
{
    int_mod res;

    res.val = a.val + b.val;
    if (res.val >= int_mod::modulo)
        res.val -= int_mod::modulo;
    return res;
}

inline int_mod operator-(const int_mod &a, const int_mod &b)
{
    int_mod res;

    res.val = a.val - b.val + int_mod::modulo;
    if (res.val >= int_mod::modulo)
        res.val -= int_mod::modulo;
    return res;
}

inline int_mod operator*(const int_mod &a, const int_mod &b)
{
    int_mod res;

    res.val = (castformorebits(a.val) * b.val) % int_mod::modulo;

    return res;
}

inline int_mod operator/(const int_mod &a, const int_mod &b)
{
    // Assume modulo is prime
    int32 inverse = fast_exponential(b.val, int_mod::modulo-2, int_mod::modulo);

    return a * inverse;
}

inline void read(int_mod &a)
{
    scan("%" SCNd32, &a.val);
    a.val %= int_mod::modulo;
}

inline void write(const int_mod &b)
{
    printf("%" PRId32 " ", b.val);
}


inline void read(int32& val)
{
    scan("%" SCNd32, &val);
}

inline void read(int64& val)
{
    scan("%" SCNd64, &val);
}

inline void read(double& val)
{
    scan("%lf", &val);
}

inline void read(string& val, int length = 1e6)
{
    char tmp[length+1];

    scan("%s", tmp);

    val = tmp;
}

template <class S, class T>
inline void read(S& a, T& b)
{
    read(a);
    read(b);
}

template <class S>
inline void read(vector<S> &v, int n)
{
    v.resize(n);
    for (int i = 0; i < n; i++)
        read(v[i]);
}

template <class S, class T, class U>
inline void read(S& a, T& b, U& c)
{
    read(a);
    read(b);
    read(c);
}

template <class S, class T, class U, class V>
inline void read(S& a, T& b, U& c, V& d)
{
    read(a);
    read(b);
    read(c);
    read(d);
}

template <class S, class T, class U, class V, class W>
inline void read(S& a, T& b, U& c, V& d, W& e)
{
    read(a);
    read(b);
    read(c);
    read(d);
    read(e);
}

inline void write(int32 val)
{
    printf("%" PRId32 " ", val);
}

inline void write(int64 val)
{
    printf("%" PRId64 " ", val);
}

inline void write(double val)
{
    printf("%lf ", val);
}

inline void write(const string& val)
{
    printf("%s ", val.c_str());
}

template<class S>
inline void write(const vector<S>& val)
{
    for (S el : val)
        write(el);
}

template<class S>
inline void writeln(const S& a)
{
    write(a);
    printf("\n");
}

template<class S, class T>
inline void writeln(const S& a, const T& b)
{
    write(a);
    write(b);
    printf("\n");
}

template<class S, class T, class U>
inline void writeln(const S& a, const T& b, const U& c)
{
    write(a);
    write(b);
    write(c);
    printf("\n");
}

template<class S, class T, class U, class V>
inline void writeln(const S& a, const T& b, const U& c, const V& d)
{
    write(a);
    write(b);
    write(c);
    write(d);
    printf("\n");
}

template<class S, class T, class U, class V, class W>
inline void writeln(const S& a, const T& b, const U& c, const V& d, const W& e)
{
    write(a);
    write(b);
    write(c);
    write(d);
    write(e);
    printf("\n");
}

#ifdef PCL_DEBUG
    #define DBG_RED "\033[1;31m"
    #define DBG_YELLOW "\033[1;33m"
    #define DBG_BLUE "\033[1;34m"
    #define DBG_NC "\033[0m"

    #define debug(var) { printf("%s%s%s = ", DBG_RED, #var, DBG_NC); writeln(var); }
    #define break_point(str) { printf("%s%s%s\n", DBG_YELLOW, str, DBG_NC); }
#else
    #define debug(...)
    #define break_point(...)
#endif

vector<int> merge(vector<int>& l, vector<int>& r)
{
    vector<int> result;

    int i = 0;
    int j = 0;

    while (i < elements(l) and j < elements(r))
    {
        if (l[i] < r[j])
        {
            result.push_back(l[i]);
            i++;
        }
        else if (l[i] > r[j])
        {
            result.push_back(r[j]);
            j++;
        }
        else
        {
            result.push_back(l[i]);
            i++;
            j++;
        }
    }

    while (i < elements(l))
    {
        result.push_back(l[i]);
        i++;
    }

    while (j < elements(r))
    {
        result.push_back(r[j]);
        j++;
    }

    return result;
}

int main()
{
    int n;
    vector<int> l;
    vector<int> r;

    read(n);

    l.resize(n);
    r.resize(n);

    for (int i = 0; i < n; i++)
        read(l[i], r[i]);
    
    reverse(l);
    reverse(r);

    vector<vector<int>> pre_tap(n);

    for (int i = 0; i < n; i++)
        pre_tap[i].push_back(i);

    for (int i = 0; i < n; i++)
    {
        int j = i + 1;

        while (j < n and not (l[j] < l[i] and l[i] < r[j]))
            j++;
        
        if (j < n)
            pre_tap[j] = merge(pre_tap[j], pre_tap[i]);

        j = i + 1;

        while (j < n and not (l[j] < r[i] and r[i] < r[j]))
            j++;
        
        if (j < n)
            pre_tap[j] = merge(pre_tap[j], pre_tap[i]);
    }

    int_mod::modulo = 1e9 + 7;

    int_mod result = 0;

    for (int i = 0; i < n; i++)
        result += int_mod(1) / int_mod(elements(pre_tap[i]));

    writeln(result);

    return 0;
}