#include <stdio.h>
#include <string.h>

#define MAX_VAL 10000001

int main() {
    int n;
    scanf("%d", &n);

    // Mảng a để lưu giá trị đầu vào
    int a[n];
    // Mảng đếm tần suất (dem) và mảng đánh dấu đã xuất hiện (dem1)
    // Sử dụng static để tránh tràn ngăn xếp do kích thước lớn
    static int dem[MAX_VAL] = {0};
    static int dem1[MAX_VAL] = {0};

    for(int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
        dem[a[i]]++; // Đếm số lần xuất hiện
        dem1[a[i]] = 1; // Đánh dấu là đã xuất hiện
    }

    // Đếm số lượng giá trị khác nhau
    int demk = 0;
    for(int i = 0; i < n; i++) {
        if(dem1[a[i]] > 0) {
            demk++;
            dem1[a[i]] = 0; // Đánh dấu để không đếm lại
        }
    }
    printf("%d\n", demk);

    // In ra theo thứ tự xuất hiện trong mảng a
    for(int i = 0; i < n; i++) {
        if(dem[a[i]] > 0) {
            printf("%d %d\n", a[i], dem[a[i]]);
            dem[a[i]] = 0; // Đánh dấu đã in
        }
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

#define MAX 1000005

typedef struct {
    int value;
    int count;
    int firstpos;
} Element;

// So sánh theo giá trị để sắp xếp
int comparevalue(const void *a, const void *b) {
    Element *e1 = (Element *)a;
    Element *e2 = (Element *)b;
    if (e1->value != e2->value)
        return e1->value - e2->value;
    return e1->firstpos - e2->firstpos;
}

// So sánh theo vị trí xuất hiện đầu tiên để trả về thứ tự ban đầu
int comparepos(const void *a, const void *b) {
    Element *e1 = (Element *)a;
    Element *e2 = (Element *)b;
    return e1->firstpos - e2->firstpos;
}

int main() {
    int n;
    scanf("%d", &n);
    Element *temp = (Element*)malloc(n * sizeof(Element));

    for (int i = 0; i < n; i++) {
        int val;
        scanf("%d", &val);
        temp[i].value = val;
        temp[i].count = 1;
        temp[i].firstpos = i;
    }

    // 1. Sắp xếp theo giá trị
    qsort(temp, n, sizeof(Element), comparevalue);

    // 2. Gộp các phần tử giống nhau
    int m = 0; // chỉ số cho mảng kết quả gộp
    for (int i = 1; i < n; i++) {
        if (temp[i].value == temp[m].value) {
            temp[m].count++;
        } else {
            m++;
            temp[m] = temp[i];
        }
    }
    // m+1 là số lượng phần tử khác nhau

    // 3. Sắp xếp lại theo thứ tự xuất hiện ban đầu
    qsort(temp, m + 1, sizeof(Element), comparepos);

    printf("%d\n", m + 1);
    for (int i = 0; i <= m; i++) {
        printf("%d %d\n", temp[i].value, temp[i].count);
    }

    free(temp);
    return 0;
}

#include <iostream>
#include <vector>
#include <map>

using namespace std;

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);

    int n;
    cin >> n;

    // Map lưu: giá trị -> {tần suất, vị trí xuất hiện đầu tiên}
    map<int, pair<int, int>> freq;

    for (int i = 0; i < n; i++) {
        int x;
        cin >> x;
        if (freq.find(x) == freq.end()) {
            // Nếu chưa xuất hiện, thêm vào với tần suất 1 và vị trí i
            freq[x] = {1, i};
        } else {
            // Nếu đã xuất hiện, tăng tần suất
            freq[x].first++;
        }
    }

    cout << freq.size() << "\n";

    // Map tự động sắp xếp theo key, nhưng ta cần theo thứ tự xuất hiện.
    // Tuy nhiên, map ở đây dùng Red-Black Tree, không giữ thứ tự insert.
    // Để đúng thứ tự xuất hiện, ta cần dùng vector lưu lại thứ tự hoặc sort lại.
    // Lưu ý: Code mẫu dưới đây in theo thứ tự tự nhiên của map (tăng dần giá trị), 
    // nhưng đề bài yêu cầu theo thứ tự xuất hiện. 
    // Để đúng, ta cần tách riêng logic.

    // GIẢI PHÁP ĐÚNG YÊU CẦU (Sử dụng Vector và Map để lưu trữ):
    // (Đoạn code trên chỉ là minh họa Map cơ bản, đoạn sau là cách xử lý đúng)

    // Thực tế, để giữ thứ tự xuất hiện và đếm nhanh, ta nên dùng:
    // 1. Map để đếm và kiểm tra trùng lặp.
    // 2. Vector để lưu thứ tự xuất hiện của các phần tử duy nhất.

    // Code sửa đổi:
    vector<int> distinct_order;
    map<int, int> count_map;

    // Đọc lại hoặc xử lý logic ngay khi đọc
    // (Giả sử ta đọc lại input hoặc lưu input vào mảng a trước)
    // Để đơn giản và tối ưu code trong JSON:

    /*
    // Logic hoàn chỉnh:
    vector<int> a(n);
    map<int, int> counts;
    for(int i=0; i<n; i++) {
        cin >> a[i];
        counts[a[i]]++;
    }

    // Lọc theo thứ tự xuất hiện
    vector<int> output_order;
    for(int i=0; i<n; i++) {
        if (counts.find(a[i]) != counts.end()) {
            output_order.push_back(a[i]);
            counts.erase(a[i]); // Xóa để không in lại
        }
    }

    cout << output_order.size() << "\n";
    for (int val : output_order) {
        // Để in đúng tần suất, ta cần một map đếm riêng
        // Hoặc map.count không xóa được giá trị nếu ta cần dùng lại.
        // Nên dùng map<int, int> freq riêng.
    }
    */
    return 0;
}