// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

using ll=long long;

using ld=long double;

using ull=unsigned long long;

using uint=unsigned int;

using pcc=pair<char,char>;

using pii=pair<int,int>;

using pll=pair<ll,ll>;

using pdd=pair<double,double>;

using tuplis=pair<ll,pll>;

using tuplis2=pair<pll,ll>;

template<class T> using pq=priority_queue<T,vector<T>,greater<T>>;

const ll LINF=0x1fffffffffffffff;

const ll MOD=1000000007;

const ll MODD=998244353;

const int INF=0x3fffffff;

const double DINF=numeric_limits<double>::infinity();

const vector<pii> four={{-1,0},{0,1},{1,0},{0,-1}};

#define _overload4(_1,_2,_3,_4,name,...) name

#define _overload3(_1,_2,_3,name,...) name

#define _rep1(n) for(ll i=0;i<n;++i)

#define _rep2(i,n) for(ll i=0;i<n;++i)

#define _rep3(i,a,b) for(ll i=a;i<b;++i)

#define _rep4(i,a,b,c) for(ll i=a;i<b;i+=c)

#define rep(...) _overload4(__VA_ARGS__,_rep4,_rep3,_rep2,_rep1)(__VA_ARGS__)

#define _rrep1(n) for(ll i=n-1;i>=0;i--)

#define _rrep2(i,n) for(ll i=n-1;i>=0;i--)

#define _rrep3(i,a,b) for(ll i=b-1;i>=a;i--)

#define _rrep4(i,a,b,c) for(ll i=a+(b-a-1)/c*c;i>=a;i-=c)

#define rrep(...) _overload4(__VA_ARGS__,_rrep4,_rrep3,_rrep2,_rrep1)(__VA_ARGS__)

#define each(i,a) for(auto& i:a)

#define sum(...) accumulate(range(__VA_ARGS__),0LL)

#define dsum(...) accumulate(range(__VA_ARGS__),double(0))

#define _range(i) (i).begin(),(i).end()

#define _range2(i,k) (i).begin(),(i).begin()+k

#define _range3(i,a,b) (i).begin()+a,(i).begin()+b

#define range(...) _overload3(__VA_ARGS__,_range3,_range2,_range)(__VA_ARGS__)

#define _rrange(i) (i).rbegin(),(i).rend()

#define _rrange2(i,k) (i).rbegin(),(i).rbegin()+k

#define _rrange3(i,a,b) (i).rbegin()+a,(i).rbegin()+b

#define rrange(...) _overload3(__VA_ARGS__,_rrange3,_rrange2,_rrange)(__VA_ARGS__)

#define yes(i) out(i?"yes":"no")

#define Yes(i) out(i?"Yes":"No")

#define YES(i) out(i?"YES":"NO")

#define Possible(i) out(i?"Possible":"Impossible")

#define elif else if

#define unless(a) if(!(a))

#define mp make_pair

#define mt make_tuple

#define INT(...) int __VA_ARGS__;in(__VA_ARGS__)

#define LL(...) ll __VA_ARGS__;in(__VA_ARGS__)

#define STR(...) string __VA_ARGS__;in(__VA_ARGS__)

#define CHR(...) char __VA_ARGS__;in(__VA_ARGS__)

#define DBL(...) double __VA_ARGS__;in(__VA_ARGS__)

#define vec(type,name,...) vector<type> name(__VA_ARGS__)

#define VEC(type,name,size) vector<type> name(size);in(name)

#define vv(type,name,h,...) vector<vector<type>>name(h,vector<type>(__VA_ARGS__))

#define VV(type,name,h,...) vector<vector<type>>name(h,vector<type>(__VA_ARGS__));in(name)

#define vvv(type,name,h,w,...) vector<vector<vector<type>>>name(h,vector<vector<type>>(w,vector<type>(__VA_ARGS__)))

__attribute__((constructor)) void SETTINGS(){cin.tie(0); cout.tie(0); ios::sync_with_stdio(0); cout<<fixed<<setprecision(20);};

inline constexpr ll gcd(ll a,ll b){if(!a||!b)return 0;if(a<b){ll c=a;a=b;b=c;}while(b){ll c=b;b=a%b;a=c;}return a;}

inline constexpr ll lcm(ll a,ll b){if(!a||!b)return 0;return a*b/gcd(a,b);}

template<class T>inline constexpr T min(vector<T>& v){return *min_element(range(v));}

inline char min(string& v){return *min_element(range(v));}

template<class T>inline constexpr T max(vector<T>& v){return *max_element(range(v));}

inline char max(string& v){return *max_element(range(v));}

inline constexpr ll intpow(const ll&a,const ll&b){if(b==0)return 1;ll ans=intpow(a,b/2);return ans*ans*(b&1?a:1);}

inline constexpr ll modpow(const ll&a,const ll&b,const ll&mod=MOD){if(b==0)return 1;ll ans=modpow(a,b/2,mod);ans=ans*ans%mod;if(b&1)ans=ans*a%mod;return ans;}

template<typename T>

inline constexpr bool update_min(T& mn,const T& cnt){if(mn>cnt){mn=cnt;return 1;}else return 0;}

template<typename T>

inline constexpr bool update_max(T& mx,const T& cnt){if(mx<cnt){mx=cnt;return 1;}else return 0;}

inline void in() {}

template<class T>

istream& operator >> (istream& is, vector<T>& vec);

template<class T,size_t size>

istream& operator >> (istream& is, array<T,size>& vec);

template<class T,class L>

istream& operator >> (istream& is, pair<T,L>& p);

template<class T>

ostream& operator << (ostream& os, vector<T>& vec);

template<class T,class L>

ostream& operator << (ostream& os, pair<T,L>& p);

template<class T>

istream& operator >> (istream& is, vector<T>& vec){for(T& x: vec) is >> x;return is;}

template<class T,class L>

istream& operator >> (istream& is, pair<T,L>& p){is >> p.first;is >> p.second;return is;}

template<class T>

ostream& operator << (ostream& os, vector<T>& vec){os << vec[0];rep(i,1,vec.size()){os << ' ' << vec[i];}return os;}

template<class T>

ostream& operator << (ostream& os, deque<T>& deq){os << deq[0];rep(i,1,deq.size()){os << ' ' << deq[i];}return os;}

template<class T,class L>

ostream& operator << (ostream& os, pair<T,L>& p){os << p.first << " " << p.second;return os;}

template<class T,class L>

pair<T,L> operator + (pair<T,L> a, pair<T,L> b){return {a.first + b.first, a.second + b.second};}

template <class Head, class... Tail>

inline void in(Head&& head,Tail&&... tail){cin>>head;in(move(tail)...);}

template <class T>

inline bool out(T t){cout<<t<<'\n';return 0;}

inline bool out(){cout<<'\n';return 0;}

template <class Head, class... Tail>

inline bool out(Head head,Tail... tail){cout<<head<<' ';out(move(tail)...);return 0;}

template <class T>

inline void err(T t){cerr<<t<<'\n';}

inline void err(){cerr<<'\n';}

template <class Head, class... Tail>

inline void err(Head head,Tail... tail){cerr<<head<<' ';out(move(tail)...);}







signed main(){

    LL(n);

    VEC(ll,c,n);

    each(i,c)i--;

    vector<ll>next(n,-1),at(200000,-1);

    rrep(n){

        if(at[c[i]]!=-1)next[i]=at[c[i]];

        at[c[i]]=i;

    }

    vector<ll>dp(n+1);

    dp[0]=1;

    rep(n){

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

        dp[i+1]%=MOD;

        if(next[i]>i+1){

            dp[next[i]]+=dp[i];

            dp[next[i]]%=MOD;

        }

    }

    out(dp[n]);

}










// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

using namespace std;

using ll = long long;

using ld = long double;

using ull = unsigned long long;

using uint = unsigned int;

using pcc = pair<char, char>;

using pii = pair<int, int>;

using pll = pair<ll, ll>;

using pdd = pair<double, double>;

using tuplis = array<ll, 3>;

template<class T> using pq = priority_queue<T, vector<T>, greater<T>>;

const ll LINF=0x1fffffffffffffff;

const ll MINF=0x7fffffffffff;

const int INF=0x3fffffff;

const int MOD=1000000007;

const int MODD=998244353;

const ld DINF=numeric_limits<ld>::infinity();

const ld EPS=1e-9;

const ld PI=3.1415926535897932;

const ll four[] = {0, 1, 0, -1, 0};

const ll eight[] = {0, 1, 1, 0, -1, -1, 1, -1, 0};

#define overload4(_1,_2,_3,_4,name,...) name

#define overload3(_1,_2,_3,name,...) name

#define rep1(n) for(ll i=0;i<n;++i)

#define rep2(i,n) for(ll i=0;i<n;++i)

#define rep3(i,a,b) for(ll i=a;i<b;++i)

#define rep4(i,a,b,c) for(ll i=a;i<b;i+=c)

#define rep(...) overload4(__VA_ARGS__,rep4,rep3,rep2,rep1)(__VA_ARGS__)

#define rrep1(n) for(ll i=(n)-1;i>=0;i--)

#define rrep2(i,n) for(ll i=(n)-1;i>=0;i--)

#define rrep3(i,a,b) for(ll i=(b)-1;i>=(a);i--)

#define rrep4(i,a,b,c) for(ll i=a+(b-a-1)/c*c;i>=a;i-=c)

#define rrep(...) overload4(__VA_ARGS__,rrep4,rrep3,rrep2,rrep1)(__VA_ARGS__)

#define each(i,a) for(auto&& i:a)

#define all1(i) begin(i),end(i)

#define all2(i,a) begin(i),begin(i)+a

#define all3(i,a,b) begin(i)+a,begin(i)+b

#define all(...) overload3(__VA_ARGS__,all3,all2,all1)(__VA_ARGS__)

#define rall1(i) (i).rbegin(),(i).rend()

#define rall2(i,k) (i).rbegin(),(i).rbegin()+k

#define rall3(i,a,b) (i).rbegin()+a,(i).rbegin()+b

#define rall(...) overload3(__VA_ARGS__,rall3,rall2,rall1)(__VA_ARGS__)

#define sum(...) accumulate(all(__VA_ARGS__),0LL)

#define dsum(...) accumulate(all(__VA_ARGS__),0.0L)

#define elif else if

#define unless(a) if(!(a))

#define mp make_pair

#define mt make_tuple

#define INT(...) int __VA_ARGS__;in(__VA_ARGS__)

#define LL(...) ll __VA_ARGS__;in(__VA_ARGS__)

#define ULL(...) ull __VA_ARGS__;in(__VA_ARGS__)

#define STR(...) string __VA_ARGS__;in(__VA_ARGS__)

#define CHR(...) char __VA_ARGS__;in(__VA_ARGS__)

#define DBL(...) double __VA_ARGS__;in(__VA_ARGS__)

#define LD(...) ld __VA_ARGS__;in(__VA_ARGS__)

#define vec(type,name,...) vector<type> name(__VA_ARGS__)

#define VEC(type,name,size) vector<type> name(size);in(name)

#define vv(type,name,h,...) vector<vector<type>>name(h,vector<type>(__VA_ARGS__))

#define VV(type,name,h,w) vector<vector<type>>name(h,vector<type>(w));in(name)

#define vvv(type,name,h,w,...) vector<vector<vector<type>>>name(h,vector<vector<type>>(w,vector<type>(__VA_ARGS__)))

template<class T> auto max(const T& a){ return *max_element(all(a)); }

template<class T> auto min(const T& a){ return *min_element(all(a)); }

ll gcd(ll a, ll b){ while(b){ ll c = b; b = a % b; a = c; } return a; }

ll lcm(ll a, ll b){ if(!a || !b) return 0; return a * b / gcd(a, b); }

ll intpow(ll a, ll b){ ll ans = 1; while(b){ if(b & 1) ans *= a; a *= a; b /= 2; } return ans; }

ll modpow(ll a, ll b, ll p){ ll ans = 1; while(b){ if(b & 1) (ans *= a) %= p; (a *= a) %= p; b /= 2; } return ans; }

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

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

vector<pll> factor(ull x){ vector<pll> ans; for(ll i = 2; i * i <= x; i++) if(x % i == 0){ ans.push_back({i, 1}); while((x /= i) % i == 0) ans.back().second++; } if(x != 1) ans.push_back({x, 1}); return ans; }

vector<ll> divisor(ull x){ vector<ll> ans; for(ll i = 1; i * i <= x; i++) if(x % i == 0) ans.push_back(i); rrep(ans.size() - (ans.back() * ans.back() == x)) ans.push_back(x / ans[i]); return ans; }

template<class T> unordered_map<T, ll> press(vector<T>& a){ auto b = a; sort(all(b)); b.erase(unique(all(b)), b.end()); unordered_map<T,ll> ans; rep(b.size()) ans[b[i]] = i; each(i, a) i = ans[i]; return ans; }

template<class T> map<T, ll> press_map(vector<T>& a){ auto b = a; sort(all(b)); b.erase(unique(all(b)), b.end()); map<T,ll> ans; rep(b.size()) ans[b[i]] = i; each(i, a) i = ans[i]; return ans; }

int scan(){ return getchar(); }

void scan(int& a){ scanf("%d", &a); }

void scan(unsigned& a){ scanf("%u", &a); }

void scan(long& a){ scanf("%ld", &a); }

void scan(long long& a){ scanf("%lld", &a); }

void scan(unsigned long long& a){ scanf("%llu", &a); }

void scan(char& a){ do{ a = getchar(); }while(a == ' ' || a == '\n'); }

void scan(float& a){ scanf("%f", &a); }

void scan(double& a){ scanf("%lf", &a); }

void scan(long double& a){ scanf("%Lf", &a); }

void scan(vector<bool>& a){ for(unsigned i = 0; i < a.size(); i++) { int b; scan(b); a[i] = b; } }

void scan(char a[]){ scanf("%s", a); }

void scan(string& a){ cin >> a; }

template<class T> void scan(vector<T>&);

template<class T, size_t size> void scan(array<T, size>&);

template<class T, class L> void scan(pair<T, L>&);

template<class T, size_t size> void scan(T(&)[size]);

template<class T> void scan(vector<T>& a){ for(auto& i : a) scan(i); }

template<class T> void scan(deque<T>& a){ for(auto& i : a) scan(i); }

template<class T, size_t size> void scan(array<T, size>& a){ for(auto& i : a) scan(i); }

template<class T, class L> void scan(pair<T, L>& p){ scan(p.first); scan(p.second); }

template<class T, size_t size> void scan(T (&a)[size]){ for(auto& i : a) scan(i); }

template<class T> void scan(T& a){ cin >> a; }

void in(){}

template <class Head, class... Tail> void in(Head& head, Tail&... tail){ scan(head); in(tail...); }

void print(){ putchar(' '); }

void print(bool a){ printf("%d", a); }

void print(int a){ printf("%d", a); }

void print(unsigned a){ printf("%u", a); }

void print(long a){ printf("%ld", a); }

void print(long long a){ printf("%lld", a); }

void print(unsigned long long a){ printf("%llu", a); }

void print(char a){ printf("%c", a); }

void print(char a[]){ printf("%s", a); }

void print(const char a[]){ printf("%s", a); }

void print(float a){ printf("%.15f", a); }

void print(double a){ printf("%.15f", a); }

void print(long double a){ printf("%.15Lf", a); }

void print(const string& a){ for(auto&& i : a) print(i); }

template<class T> void print(const vector<T>&);

template<class T, size_t size> void print(const array<T, size>&);

template<class T, class L> void print(const pair<T, L>& p);

template<class T, size_t size> void print(const T (&)[size]);

template<class T> void print(const vector<T>& a){ if(a.empty()) return; print(a[0]); for(auto i = a.begin(); ++i != a.end(); ){ putchar(' '); print(*i); } }

template<class T> void print(const deque<T>& a){ if(a.empty()) return; print(a[0]); for(auto i = a.begin(); ++i != a.end(); ){ putchar(' '); print(*i); } }

template<class T, size_t size> void print(const array<T, size>& a){ print(a[0]); for(auto i = a.begin(); ++i != a.end(); ){ putchar(' '); print(*i); } }

template<class T, class L> void print(const pair<T, L>& p){ print(p.first); putchar(' '); print(p.second); }

template<class T, size_t size> void print(const T (&a)[size]){ print(a[0]); for(auto i = a; ++i != end(a); ){ putchar(' '); print(*i); } }

template<class T> void print(const T& a){ cout << a; }

int out(){ putchar('\n'); return 0; }

template<class T> int out(const T& t){ print(t); putchar('\n'); return 0; }

template<class Head, class... Tail> int out(const Head& head, const Tail&... tail){ print(head); putchar(' '); out(tail...); return 0; }

#ifdef DEBUG

void err(){ putchar('\n'); }

template<class T> void err(const T& t){ print(t); putchar('\n'); }

template<class Head, class... Tail> void err(const Head& head, const Tail&... tail){ print(head); putchar(' '); out(tail...); }

#else

template<class... T> void err(const T&...){}

#endif

int first(bool i = true){ return out(i?"first":"second"); }

int yes(bool i = true){ return out(i?"yes":"no"); }

int Yes(bool i = true){ return out(i?"Yes":"No"); }

int No(){ return out("No"); }

int YES(bool i = true){ return out(i?"YES":"NO"); }

int NO(){ return out("NO"); }

int Yay(bool i = true){ return out(i?"Yay!":":("); }

int possible(bool i = true){ return out(i?"possible":"impossible"); }

int Possible(bool i = true){ return out(i?"Possible":"Impossible"); }

int POSSIBLE(bool i = true){ return out(i?"POSSIBLE":"IMPOSSIBLE"); }

void Case(ll i){ printf("Case #%lld: ", i); }





constexpr uint mod = MOD;

struct Modint{

    uint num = 0;

    constexpr Modint(){}

    constexpr Modint(const Modint &x) : num(x.num){}

    inline constexpr operator ll() const { return num; }

    inline constexpr Modint& operator+=(Modint x){ num += x.num; if(num >= mod) num -= mod; return *this; }

    inline constexpr Modint& operator++(){ if(num == mod - 1) num = 0; else num++; return *this; }

    inline constexpr Modint operator++(int){ Modint ans(*this); operator++(); return ans; }

    inline constexpr Modint operator- () const { return Modint(0) -= *this; }

    inline constexpr Modint operator- (Modint x) const { return Modint(*this) -= x; }

    inline constexpr Modint& operator-=(Modint x){ if(num < x.num) num += mod; num -= x.num; return *this; }

    inline constexpr Modint& operator--(){ if(num == 0) num = mod - 1; else num--; return *this; }

    inline constexpr Modint operator--(int){ Modint ans(*this); operator--(); return ans; }

    inline constexpr Modint& operator*=(Modint x){ num = ull(num) * x.num % mod; return *this; }

    inline constexpr Modint& operator/=(Modint x){ return operator*=(x.inv()); }

    template<class T> constexpr Modint(T x){ x %= T(mod); if(x < 0) x += mod; num = uint(x); }

    template<class T> inline constexpr Modint operator+(T x) const { return Modint(*this) += x; }

    template<class T> inline constexpr Modint& operator+=(T x){ x %= mod; if(x < 0) x += mod; num += x; if(num >= mod) num -= mod; return *this; }

    template<class T> inline constexpr Modint operator- (T x) const { return Modint(*this) -= x; }

    template<class T> inline constexpr Modint& operator-=(T x){ return operator-=(Modint(x)); }

    template<class T> inline constexpr Modint operator* (T x) const { return Modint(*this) *= x; }

    template<class T> inline constexpr Modint& operator*=(T x){ return operator*=(Modint(x)); }

    template<class T> inline constexpr Modint operator/ (T x) const { return Modint(*this) /= x; }

    template<class T> inline constexpr Modint& operator/=(T x){ return operator/=(Modint(x)); }

    inline constexpr Modint inv() const { ll x = 0, y = 0; extgcd(num, mod, x, y); return x; }

    inline constexpr ll extgcd(ll a, ll b, ll &x, ll &y) const { ll g = a; x = 1; y = 0; if(b){ g = extgcd(b, a % b, y, x); y -= a / b * x; } return g; }

    inline constexpr Modint pow(ull x) const { Modint ans = 1, cnt = *this; while(x){ if(x & 1) ans *= cnt; cnt *= cnt; x /= 2; } return ans; }

};

std::istream& operator>>(std::istream& is, Modint& x) { ll a; in(a); x = a; return is; }

inline constexpr Modint operator""_M(ull x) { return Modint(x); }

std::vector<Modint> fac(1, 1), inv(1, 1);

inline void reserve(ll a){

    if(fac.size() >= a) return;

    if(a < fac.size() * 2) a = fac.size() * 2;

    if(a >= mod) a = mod;

    while(fac.size() < a) fac.push_back(fac.back() * Modint(fac.size()));

    inv.resize(fac.size());

    inv.back() = fac.back().inv();

    for(ll i = inv.size() - 1; !inv[i - 1]; i--) inv[i - 1] = inv[i] * i;

}

inline Modint fact(ll n){ if(n < 0) return 0; reserve(n + 1); return fac[n]; }

inline Modint perm(ll n, ll r){ if(r < 0 || n < r) return 0; reserve(n + 1); return fac[n] * inv[n - r]; }

inline Modint comb(ll n, ll r){ if(r < 0 || n < r) return 0; reserve(n + 1); return fac[n] * inv[r] * inv[n - r]; }

inline Modint Mcomb(ll n, ll r){ return comb(n + r - 1, n - 1); } // r個をn部屋に分ける

inline Modint catalan(ll n){ reserve(n * 2 + 1); return fac[n * 2] * inv[n] * inv[n + 1]; }

signed main(){

    LL(n);

    VEC(ll,a,n);

    a.insert(a.begin(),0);

    vec(Modint,dp,n+1);

    vec(Modint,color,200001);

    dp[0]=1;

    rep(n){

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

        if(a[i]!=a[i+1]){

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

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

        }

    }

    out(dp.back());

}

// Fastest known solution for this problem: