#include <iostream>
#include <vector>

using namespace std;

const int MOD = 1e9 + 7;

struct SegmentTree {
    int n;
    vector<long long> tree, lazy;

    SegmentTree(int n) : n(n), tree(4 * n + 5, 0), lazy(4 * n + 5, 0) {}

    // Đẩy giá trị lazy xuống các con
    void push(int node, int l, int r) {
        if (lazy[node] != 0) {
            int mid = (l + r) / 2;

            tree[2 * node] = (tree[2 * node] + lazy[node] * (mid - l + 1)) % MOD;
            lazy[2 * node] = (lazy[2 * node] + lazy[node]) % MOD;

            tree[2 * node + 1] = (tree[2 * node + 1] + lazy[node] * (r - mid)) % MOD;
            lazy[2 * node + 1] = (lazy[2 * node + 1] + lazy[node]) % MOD;

            lazy[node] = 0;
        }
    }

    // Cộng val vào đoạn [ql, qr]
    void update(int node, int l, int r, int ql, int qr, long long val) {
        if (ql > r || qr < l) return;
        if (ql <= l && r <= qr) {
            tree[node] = (tree[node] + val * (r - l + 1)) % MOD;
            lazy[node] = (lazy[node] + val) % MOD;
            return;
        }
        push(node, l, r);
        int mid = (l + r) / 2;
        update(2 * node, l, mid, ql, qr, val);
        update(2 * node + 1, mid + 1, r, ql, qr, val);
        tree[node] = (tree[2 * node] + tree[2 * node + 1]) % MOD;
    }

    // Truy vấn tổng trên đoạn [ql, qr]
    long long query(int node, int l, int r, int ql, int qr) {
        if (ql > r || qr < l) return 0;
        if (ql <= l && r <= qr) return tree[node];
        push(node, l, r);
        int mid = (l + r) / 2;
        return (query(2 * node, l, mid, ql, qr) + query(2 * node + 1, mid + 1, r, ql, qr)) % MOD;
    }
};

int main() {
    // Tối ưu I/O
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int n;
    if (!(cin >> n)) return 0;

    vector<int> a(n + 1);
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
    }

    SegmentTree st(n);
    vector<int> last(n + 1, 0); // Lưu vị trí xuất hiện gần nhất của giá trị v
    long long total_beauty = 0;

    for (int R = 1; R <= n; ++R) {
        int x = a[R];
        int prev_pos = last[x];

        // 1. Cộng 1 vào các L thuộc [prev_pos + 1, R]
        st.update(1, 1, n, prev_pos + 1, R, 1);

        // 2. Lấy tổng số phần tử phân biệt của mọi đoạn con kết thúc tại R
        long long current_sum = st.query(1, 1, n, 1, R);
        total_beauty = (total_beauty + current_sum) % MOD;

        // 3. Cập nhật vị trí xuất hiện mới nhất
        last[x] = R;
    }

    cout << (total_beauty % MOD + MOD) % MOD << "\n";

    return 0;
}