Память компьютера состоит из *n* ячеек, которые выстроены в ряд. Пронумеруем ячейки от 1 до *n* слева направо. Про каждую ячейку известно, свободна она или принадлежит какому-либо процессу (в таком случае известен процесс, которому она принадлежит).

Для каждого процесса известно, что принадлежащие ему ячейки занимают в памяти непрерывный участок. С помощью операций вида «переписать данные из занятой ячейки в свободную, а занятую теперь считать свободной» требуется расположить все принадлежащие процессам ячейки в начале памяти компьютера. Другими словами, любая свободная ячейка должна располагаться правее (иметь больший номер) любой занятой.

Вам необходимо найти минимальное количество операций переписывания данных из одной ячейки в другую, с помощью которых можно достичь описанных условий. Допустимо, что относительный порядок ячеек в памяти для каждого из процессов изменится после дефрагментации, но относительный порядок самих процессов должен остаться без изменений. Это значит, что если все ячейки, принадлежащие процессу *i*, находились в памяти раньше всех ячеек процесса *j*, то и после перемещений это условие должно выполняться.

Считайте, что номера всех процессов уникальны, хотя бы одна ячейка памяти занята каким-либо процессом.
В первой строке входных данных записано число *n* (1 ≤ *n* ≤ 200 000) — количество ячеек в памяти компьютера.

Во второй строке входных данных следуют *n* целых чисел *a*<sub class="lower-index">1</sub>, *a*<sub class="lower-index">2</sub>, ..., *a*<sub class="lower-index">*n*</sub> (1 ≤ *a*<sub class="lower-index">*i*</sub> ≤ *n*), где *a*<sub class="lower-index">*i*</sub> равно либо 0 (это означает, что *i*-я ячейка памяти свободна), либо номеру процесса, которому принадлежит *i*-я ячейка памяти. Гарантируется, что хотя бы одно значение *a*<sub class="lower-index">*i*</sub> не равно 0.

Процессы пронумерованы целыми числами от 1 до *n* в произвольном порядке. При этом процессы не обязательно пронумерованы последовательными числами.
В первом тестовом примере достаточно двух операций:
 1.  Переписать данные из третьей ячейки в первую. После этого память компьютера примет вид: 2 2 0 1. 1.  Переписать данные из четвертой ячейки в третью. После этого память компьютера примет вид: 2 2 1 0.
4
0 2 2 1
2
8
0 8 8 8 0 4 4 2
4
5
0 0 0 1 1
2
6
0 0 0 3 0 0
1
10
0 10 10 0 0 3 3 0 0 0
3
10
0 9 9 9 9 0 8 8 8 8
3
15
0 0 6 6 0 0 0 0 4 0 0 0 9 0 0
4
21
0 11 11 11 11 0 7 0 12 12 12 12 12 0 19 19 19 0 1 1 1
11
24
0 0 6 6 6 0 22 22 0 23 23 0 19 19 19 19 0 0 17 0 0 3 3 3
14
15
1 1 1 1 5 5 5 4 4 4 3 3 3 2 7
0
1
1
0
21
11 0 0 0 0 7 0 12 0 0 0 0 0 19 0 0 0 1 0 0 0
4
24
6 6 0 0 0 22 0 0 23 0 0 19 0 0 0 0 17 17 0 3 3 0 0 0
7
6
4 4 2 6 6 6
0
#define INF 9000000
#define INT_MAX 2000000000
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <set>
#include <vector>
#include <stack>
#include <unordered_map>
#include <sstream>
#include <cstring>
#include <time.h>
#include <random>
#include <algorithm>
#include <iomanip>
#include <map>
#include <queue>
#include <string>
#include <fstream>
using namespace std;
#define forn(b, c) for (int i = b; i < c; ++i)
#define forr(i, b, c) for (int i = c - 1; i > b; i--)
#define fore(i, a, b) for (int i = a; i < b; ++i)
#define sz(a) int(a.size())
#define pb(a) push_back(a)
#define mp(a, b) make_pair(a, b)
#define all(a) a.begin(), a.end()
typedef long double ld;
typedef long long ll;
void dfs(int v, vector<vector<bool>> &g, vector<bool> &visited) {
    
}
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int n;
    cin >> n;
    vector<int> a(n);
    forn (0, n)
    cin >> a[i];
    int ans = 0;
    vector<pair<int, int> > zip;
    forn (0, n) {
        if (zip.size() > 0 && a[i] == zip[sz(zip) - 1].first)
            zip[sz(zip) - 1].second = i;
        else if (a[i] != 0)
            zip.pb(mp(a[i], i));
    }
    int j = 0;
    forn (0, n) {
        if (a[i] == 0) {
            int p = j - 1;
            int b = -1;
            for (j; j < sz(zip); ++j) {
                if (zip[p].first == 0)
                    p = j;
                if (zip[j].first != zip[p].first) {
                    b = j;
                    break;
                }
            }
            if (b != -1 && (a[i] != 0 || zip[b - 1].first != 0)) {
                swap(a[i], a[zip[b - 1].second]);
                --zip[b - 1].second;
                ++ans;
            } else if (a[i] != 0 || a[n - 1] != 0) {
                swap(a[i], a[n - 1]);
                --zip[sz(zip) - 1].second;
                ++ans;
            }
        }
    }
    cout << ans;
    return 0;
}
