#include <bits/stdc++.h>

// #define int i64

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
// using i128 = __int128;
// using u128 = unsigned __int128;


inline void solve(){
    int n;
    std::cin >> n;
    std::vector<int> a(n + 1);
    int s = 0;
    bool ffg = 1;
    for (int i = 1; i <= n; i++) {
        std::cin >> a[i];
        s += a[i];
    }
    for (int i = 2; i <= n; i++) {
        ffg &= (a[i] <= a[i - 1]);
    }

    int maxn = (*std::max_element(a.begin() + 1, a.end()));
    int k = std::max(maxn, (s + 1) / 2);

    std::cout << k << '\n';
    
    std::map<int, int> cnt;
    std::set<int> S;

    for (int i = 1; i <= n; i++) {
        if (a[i] > 0) {
            cnt[a[i]]++;
            S.insert(i);
        }
    }

    auto del = [&](int v) {
        auto it = cnt.find(v);
        if (--it->second == 0) cnt.erase(it);
    };
    auto add = [&](int v) {
        cnt[v]++;
    };

    int cts = s;

    for (int sp = 1; sp <= k; sp++) {
        int res = k - sp;
        int i = (*S.begin());
        bool fg = 0;

        auto it = prev(cnt.end());
        int aa = it -> first, bb = 0;
        if (it != cnt.begin()) {
            auto itt = prev(it);
            bb = itt -> first;
        }

        int j = i;
        auto wk = [&](){
            int dw = (i == j ? 1 : 2);
            int ns = cts - dw;
            if (res < (ns + 1) / 2) return 0;

            int cA = it->second;
            int mx = cA - (a[i] == aa) - (j != i && a[j] == aa ? 1 : 0);

            int tmx = (mx > 0 ? aa : bb);
            
            int ni = a[i] - 1;
            tmx = std::max(tmx, ni);
            if (i ^ j){
                tmx = std::max(tmx, a[j] - 1);
            }

            if (res < tmx) return 0;

            std::cout << i << " " << j << "\n";
            del(a[i]);
            if (i == j) {
                a[i]--, cts--;
                if (a[i] > 0) {
                    add(a[i]);
                } else {
                    S.erase(i);
                }
            } else {
                del(a[j]);
                a[i]--, a[j]--;
                cts -= 2;
                if (a[i] > 0) {
                    add(a[i]);
                } else {
                    S.erase(i);
                }
                if (a[j] > 0) {
                    add(a[j]);
                } else {
                    S.erase(j);
                }
            }
            fg = 1;
            return 1;
        };
        if(!ffg){
            wk();
            for (auto it = S.upper_bound(i); it != S.end(); it++) {
                j = (*it);
                if (wk()) {
                    break;
                }
            }
        } else {

            std::vector<int> tp;

            tp.push_back(i);
            for (auto it = S.upper_bound(i); it != S.end(); it++) {
                tp.push_back(*it);
            }

            for (auto vv : tp) {
                j = vv;
                if (wk()) {
                    break;
                }
            }
        }
    }

}

signed main() {
    std::ios::sync_with_stdio(0);
    std::cin.tie(0), std::cout.tie(0);

    int t = 1;
    while(t--) solve();

    return 0;
}