Problem:
Score : 1200 points

Problem Statement

One day Mr. Takahashi picked up a dictionary containing all of the N! permutations of integers 1 through N.
The dictionary has N! pages, and page i (1 ≤ i ≤ N!) contains the i-th permutation in the lexicographical order.

Mr. Takahashi wanted to look up a certain permutation of length N in this dictionary, but he forgot some part of it.

His memory of the permutation is described by a sequence P_1, P_2, ..., P_N.
If P_i = 0, it means that he forgot the i-th element of the permutation; otherwise, it means that he remembered the i-th element of the permutation and it is P_i.

He decided to look up all the possible permutations in the dictionary.
Compute the sum of the page numbers of the pages he has to check, modulo 10^9 + 7.

Constraints

1 ≤ N ≤ 500000

0 ≤ P_i ≤ N

P_i ≠ P_j if i ≠ j (1 ≤ i, j ≤ N), P_i ≠ 0 and P_j ≠ 0.

Partial Score

In test cases worth 500 points, 1 ≤ N ≤ 3000.

Input

The input is given from Standard Input in the following format:

N
P_1 P_2 ... P_N

Output

Print the sum of the page numbers of the pages he has to check, as modulo 10^9 + 7.

Sample Input 1

4
0 2 3 0

Sample Output 1

23

The possible permutations are [1, 2, 3, 4] and [4, 2, 3, 1].
Since the former is on page 1 and the latter is on page 22, the answer is 23.

Sample Input 2

3
0 0 0

Sample Output 2

21

Since all permutations of length 3 are possible, the answer is 1 + 2 + 3 + 4 + 5 + 6 = 21.

Sample Input 3

5
1 2 3 5 4

Sample Output 3

2

Mr. Takahashi remembered all the elements of the permutation.

Sample Input 4

1
0

Sample Output 4

1

The dictionary consists of one page.

Sample Input 5

10
0 3 0 0 1 0 4 0 0 0

Sample Output 5

953330050

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

/*
*/

//#pragma comment(linker, "/STACK:16777216")
#define _CRT_SECURE_NO_WARNINGS

#include <fstream>
#include <iostream>
#include <string>
#include <complex>
#include <math.h>
#include <set>
#include <vector>
#include <map>
#include <queue>
#include <stdio.h>
#include <stack>
#include <algorithm>
#include <list>
#include <ctime>
#include <memory.h>
#include <assert.h>

#define y0 sdkfaslhagaklsldk
#define y1 aasdfasdfasdf
#define yn askfhwqriuperikldjk
#define j1 assdgsdgasghsf
#define tm sdfjahlfasfh
#define lr asgasgash
#define norm asdfasdgasdgsd
#define have adsgagshdshfhds

#define eps 1e-9
#define M_PI 3.141592653589793
#define bs 1000000007
#define bsize 350

using namespace std;

const int INF = 1e9;
const int N = 200031;

long long n, ar[N];
int zeros;
long long fact[N];
int used[N];
long long ohead[N];

int brute()
{
	vector<int> order;
	for (int i = 0; i < n; i++)
	{
		order.push_back(i+1);
	}

	int ans = 0;

	int cnt = 0;

	do
	{
		++cnt;
		int ok = 1;
		for (int i = 0; i < n; i++)
		{
			if (ar[i] != 0 && order[i] != ar[i])
				ok = 0;
		}
		if (ok)
			ans += cnt;

	} while (next_permutation(order.begin(), order.end()));

	return ans;
}

int main(){
	//freopen("fabro.in","r",stdin);
	//freopen("fabro.out","w",stdout);
	//freopen("F:/in.txt", "r", stdin);
	//freopen("F:/output.txt", "w", stdout);
	ios_base::sync_with_stdio(0);
	//cin.tie(0);

	cin >> n;
	for (int i = 0; i < n; i++)
	{
		cin >> ar[i];
		if (ar[i] == 0)
			++zeros;
		else
			used[ar[i]] = 1;
	}
	
	int unus_sum = 0;

	for (int i = 1; i <= n; i++)
	{
		if (used[i] == 0)
			unus_sum = unus_sum + i-1;
		unus_sum %= bs;
	}

	fact[0] = 1;
	for (int i = 1; i < N; i++)
	{
		fact[i] = fact[i - 1] * i%bs;
	}
	
	int cur_ohead_sum = 0;
	int total_ohead_sum = 0;

	for (int i = n; i; --i)
	{
		if (used[i] == 0)
		{
			total_ohead_sum += cur_ohead_sum;
			if (total_ohead_sum >= bs)
				total_ohead_sum %= bs;
			cur_ohead_sum += 1;
			cur_ohead_sum %= bs;
		}
		else
		{
			ohead[i] = cur_ohead_sum;
		}
	}

	long long ans = 0;

	//cout << unus_sum << endl;

	for (int i = 0; i < n; i++)
	{
		if (ar[i] != 0)// easy part
		{
			int unus = 0;
			for (int q = 1; q <= n; q++)
			{
				if (used[q])
					continue;
				if (q>ar[i])
					continue;
				unus++;
			}

			ans += (ar[i]-1) * fact[zeros] % bs*fact[n - i - 1] % bs;
			ans %= bs;
			for (int j = 0; j < i; j++)
			{
				if (ar[j] != 0 && ar[j] < ar[i])
				{
					ans -= fact[zeros]*fact[n-i-1]%bs;
					if (ans < 0)
						ans += bs;
				}
				if (ar[j] == 0)
				{
					ans -= fact[zeros - 1] * unus%bs*fact[n - i - 1] % bs;
					if (ans < 0)
						ans += bs;
				}
			}
		}
		else // shit happens
		{
			ans += unus_sum * fact[zeros-1] % bs*fact[n - i - 1] % bs;
		//	cout << ans << endl;
			ans %= bs;
			for (int j = 0; j < i; j++)
			{
				if (ar[j] != 0) // fixed
				{
					int possibilities = ohead[ar[j]];
					ans -= fact[zeros - 1] * fact[n - i - 1] % bs*possibilities%bs;
					if (ans < 0)
						ans += bs;
				}
				else // ? vs ?
				{
				//	continue;
				//	cout << "$" << i << " " << j << " " << total_ohead_sum << " " << fact[n - i - 1] << endl;

					ans -= total_ohead_sum*fact[n - i - 1] % bs*fact[zeros - 2] % bs;
					if (ans < 0)
						ans += bs;
				}
			}
		}
	}

//	cout << total_ohead_sum << endl;

	ans += fact[zeros];
	ans %= bs;

	cout << ans << endl;

//	cout << brute() << endl;

	cin.get(); cin.get();
	return 0;
}