// Slower C++ solution:
#include<iostream>

#include<string>

#include<cstdio>

#include<cstring>

#include<vector>

#include<cmath>

#include<algorithm>

#include<functional>

#include<iomanip>

#include<queue>

#include<ciso646>

#include<random>

#include<map>

#include<set>

#include<complex>

#include<bitset>

#include<stack>

#include<unordered_map>

#include<utility>

#include<cassert>

using namespace std;



typedef long long ll;

typedef unsigned long long ul;

typedef unsigned int ui;

typedef long double ld;

const ll mod = 1000000007;

const ll INF = mod * mod;

#define rep(i,n) for(int i=0;i<n;i++)

#define per(i,n) for(int i=n-1;i>=0;i--)

#define Rep(i,sta,n) for(int i=sta;i<n;i++)

#define rep1(i,n) for(int i=1;i<=n;i++)

#define per1(i,n) for(int i=n;i>=1;i--)

#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)

typedef complex<ld> Point;

const ld eps = 1e-8;

const ld pi = acos(-1.0);

typedef pair<int, int> P;

typedef pair<ld, ld> LDP;

typedef pair<ll, ll> LP;

typedef vector<int> vec;

typedef vector<string> svec;

#define fr first

#define sc second

#define all(c) c.begin(),c.end()

#define pb push_back

//#define int long long



int n;

vector<int> places[200200];

ll dp[200200];



void add(ll &a, ll b) {a += b; if(a >= mod) a -= mod;}



void solve() {

    cin >> n;

    vector<int> c(n);

    rep(i, n) {

        cin >> c[i];

        places[c[i]].push_back(i);

    }

    dp[0] = 1LL;

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

        add(dp[i], dp[i - 1]);



        int color = c[i - 1];

        int it = lower_bound(all(places[color]), i - 1) - places[color].begin();

        if(it > 0) {

            int j = places[color][it - 1];

            if((i - 1) - j > 1) add(dp[i], dp[j + 1]);

        }

    }

    cout << dp[n] << endl;

}



signed main() {

	ios::sync_with_stdio(false);

	cin.tie(0);

	//cout << fixed << setprecision(10);

	//init();

	solve();

	//cout << "finish" << endl;

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.8876156349854751x):
/**

 *    author:  otera    

**/

#include<iostream>

#include<string>

#include<cstdio>

#include<cstring>

#include<vector>

#include<cmath>

#include<algorithm>

#include<functional>

#include<iomanip>

#include<queue>

#include<deque>

#include<ciso646>

#include<random>

#include<map>

#include<set>

#include<complex>

#include<bitset>

#include<stack>

#include<unordered_map>

#include<utility>

#include<cassert>

using namespace std;



//#define int long long

typedef long long ll;

typedef unsigned long long ul;

typedef unsigned int ui;

typedef long double ld;

const int inf=1e9+7;

const ll INF=1LL<<60 ;

const ll mod=1e9+7 ;

#define rep(i,n) for(int i=0;i<n;i++)

#define per(i,n) for(int i=n-1;i>=0;i--)

#define Rep(i,sta,n) for(int i=sta;i<n;i++)

#define rep1(i,n) for(int i=1;i<=n;i++)

#define per1(i,n) for(int i=n;i>=1;i--)

#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)

typedef complex<ld> Point;

const ld eps = 1e-8;

const ld pi = acos(-1.0);

typedef pair<int, int> P;

typedef pair<ld, ld> LDP;

typedef pair<ll, ll> LP;

#define fr first

#define sc second

#define all(c) c.begin(),c.end()

#define pb push_back

#define debug(x)  cerr << #x << " = " << (x) << endl;

template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }

template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }



template<int MOD> struct Fp {

    long long val;

    constexpr Fp(long long v = 0) noexcept : val(v % MOD) {

        if (val < 0) val += MOD;

    }

    constexpr int getmod() { return MOD; }

    constexpr Fp operator - () const noexcept {

        return val ? MOD - val : 0;

    }

    constexpr Fp operator + (const Fp& r) const noexcept { return Fp(*this) += r; }

    constexpr Fp operator - (const Fp& r) const noexcept { return Fp(*this) -= r; }

    constexpr Fp operator * (const Fp& r) const noexcept { return Fp(*this) *= r; }

    constexpr Fp operator / (const Fp& r) const noexcept { return Fp(*this) /= r; }

    constexpr Fp& operator += (const Fp& r) noexcept {

        val += r.val;

        if (val >= MOD) val -= MOD;

        return *this;

    }

    constexpr Fp& operator -= (const Fp& r) noexcept {

        val -= r.val;

        if (val < 0) val += MOD;

        return *this;

    }

    constexpr Fp& operator *= (const Fp& r) noexcept {

        val = val * r.val % MOD;

        return *this;

    }

    constexpr Fp& operator /= (const Fp& r) noexcept {

        long long a = r.val, b = MOD, u = 1, v = 0;

        while (b) {

            long long t = a / b;

            a -= t * b; swap(a, b);

            u -= t * v; swap(u, v);

        }

        val = val * u % MOD;

        if (val < 0) val += MOD;

        return *this;

    }

    constexpr bool operator == (const Fp& r) const noexcept {

        return this->val == r.val;

    }

    constexpr bool operator != (const Fp& r) const noexcept {

        return this->val != r.val;

    }

    friend constexpr ostream& operator << (ostream &os, const Fp<MOD>& x) noexcept {

        return os << x.val;

    }

    friend constexpr istream& operator >> (istream &is, Fp<MOD>& x) noexcept {

        return is >> x.val;

    }

    friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, long long n) noexcept {

        if (n == 0) return 1;

        auto t = modpow(a, n / 2);

        t = t * t;

        if (n & 1) t = t * a;

        return t;

    }

};

const int MOD = 1000000007;

//const int MOD = 998244353;

using mint = Fp<MOD>;



void solve() {

	int n; cin >> n;

    vector<int> c(n);

    rep(i, n) {

        cin >> c[i];

    }

    mint dp[200200];

    rep(i, 200200) {

        dp[i] = 0;

    }

    dp[0] = 1;

    vector<int> mp(200200, -1);

    rep(i, n) {

        dp[i + 1] += dp[i];

        if(mp[c[i]] != -1 && mp[c[i]] != i - 1) {

            dp[i + 1] += dp[mp[c[i]] + 1];

        }

        mp[c[i]] = i; 

    }

    cout << dp[n] << endl;

}



signed main() {

	ios::sync_with_stdio(false);

	cin.tie(0);

	//cout << fixed << setprecision(10);

	//int t; cin >> t; rep(i, t)solve();

	solve();

    return 0;

}