#include <cstdio>
#include <algorithm>
template < int xn, int xe > struct flow
{
int head[xn], next[xe], to[xe], fl[xe], N, E, q[xn + 1], dep[xn], cur[xn];
inline void add(int u, int v, int f)
{
next[E] = head[u], to[E] = v, fl[E] = f, head[u] = E++;
next[E] = head[v], to[E] = u, fl[E] = 0, head[v] = E++;
}
void clear(int n)
{
N = n, E = 0;
for (int i = 0; i < N; i++)
head[i] = -1;
}
bool BFS()
{
for (int i = 0; i < N; i++)
{
dep[i] = 0;
cur[i] = head[i];
}
int H = 0, T = 1, u;
q[1] = 0;
dep[0] = 1;
while (H < T)
for (int e = head[u = q[++H]]; ~e; e = next[e])
if (fl[e] && !dep[to[e]])
{
dep[q[++T] = to[e]] = dep[u] + 1;
if (to[e] == N - 1)
return true;
}
return false;
}
int DFS(int p, int f)
{
if (p == N - 1)
return f;
int u = 0, y;
for (int &e = cur[p]; ~e; e = next[e])
if (fl[e] && dep[to[e]] == dep[p] + 1)
if (y = DFS(to[e], std::min(f, fl[e])))
{
fl[e] -= y;
fl[e ^ 1] += y;
u += y;
f -= y;
if (!f)
return u;
}
if (!u)
dep[p] = 0;
return u;
}
int operator () ()
{
int r = 0;
while (BFS())
r += DFS(0, 1000000000);
return r;
}
};
flow < 100000, 1000000 > G;
int N;
std::pair < int, int > p[502];
int main()
{
scanf("%d", &N);
for (int i = 1; i <= N; i++)
{
scanf("%d", &p[i].first);
p[i].second = i;
}
p[N + 1] = { N * N + 1, 0 };
std::sort(p + 1, p + N + 1);
G.clear(1 + (2 * N) + (N + 1) + 1);
for (int i = 1; i <= N; i++)
{
G.add(0, i, p[i].second - 1);
G.add(0, N + i, N - p[i].second);
for (int j = 1; j <= i; j++)
G.add(i, N + N + j, 1000000000);
for (int j = i + 1; j <= N + 1; j++)
G.add(N + i, N + N + j, 1000000000);
}
for (int i = 1; i <= N + 1; i++)
G.add(N + N + i, G.N - 1, p[i].first - p[i - 1].first - 1);
if (G() != N * (N - 1))
{
puts("No");
return 0;
}
puts("Yes");
for (int i = 1; i <= N + 1; i++)
{
for (int e = G.head[N + N + i]; ~e; e = G.next[e])
if (1 <= G.to[e] && G.to[e] <= N + N)
{
int u = G.to[e] <= N ? G.to[e] : G.to[e] - N, f = G.fl[e];
while (f--)
printf("%d ", u);
}
if (i <= N)
printf("%d ", p[i].second);
}
puts("");
}