Problem: Ivan is reading a book about tournaments. He knows that a tournament is an oriented graph with exactly one oriented edge between each pair of vertices. The score of a vertex is the number of edges going outside this vertex. 

Yesterday Ivan learned Landau's criterion: there is tournament with scores d1 ≤ d2 ≤ ... ≤ dn if and only if <image> for all 1 ≤ k < n and <image>.

Now, Ivan wanna solve following problem: given a set of numbers S = {a1, a2, ..., am}, is there a tournament with given set of scores? I.e. is there tournament with sequence of scores d1, d2, ..., dn such that if we remove duplicates in scores, we obtain the required set {a1, a2, ..., am}? 

Find a tournament with minimum possible number of vertices. 

Input

The first line contains a single integer m (1 ≤ m ≤ 31).

The next line contains m distinct integers a1, a2, ..., am (0 ≤ ai ≤ 30) — elements of the set S. It is guaranteed that all elements of the set are distinct.

Output

If there are no such tournaments, print string "=(" (without quotes).

Otherwise, print an integer n — the number of vertices in the tournament.

Then print n lines with n characters — matrix of the tournament. The j-th element in the i-th row should be 1 if the edge between the i-th and the j-th vertices is oriented towards the j-th vertex, and 0 otherwise. The main diagonal should contain only zeros.

Examples

Input

2
1 2


Output

4
0011
1001
0100
0010


Input

2
0 3


Output

6
000111
100011
110001
011001
001101
000000

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class T>
using pq = priority_queue<T>;
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;
int scan() { return getchar(); }
template <class T>
void scan(T a) {
  cin >> a;
}
void scan(int &a) { cin >> a; }
void scan(long long &a) { cin >> a; }
void scan(char &a) { cin >> a; }
void scan(double &a) { cin >> a; }
void scan(long double &a) { cin >> a; }
void scan(char a[]) { scanf("%s", a); }
void scan(string &a) { cin >> a; }
template <class T>
void scan(vector<T> &);
template <class T, size_t size>
void scan(array<T, size> &);
template <class T, class L>
void scan(pair<T, L> &);
template <class T, size_t size>
void scan(T (&)[size]);
template <class T>
void scan(vector<T> &a) {
  for (auto &i : a) scan(i);
}
template <class T>
void scan(deque<T> &a) {
  for (auto &i : a) scan(i);
}
template <class T, size_t size>
void scan(array<T, size> &a) {
  for (auto &i : a) scan(i);
}
template <class T, class L>
void scan(pair<T, L> &p) {
  scan(p.first);
  scan(p.second);
}
template <class T, size_t size>
void scan(T (&a)[size]) {
  for (auto &i : a) scan(i);
}
template <class T>
void scan(T &a) {
  cin >> a;
}
void IN() {}
template <class Head, class... Tail>
void IN(Head &head, Tail &...tail) {
  scan(head);
  IN(tail...);
}
string stin() {
  string s;
  cin >> s;
  return s;
}
template <class T, class S>
inline bool chmax(T &a, S b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T, class S>
inline bool chmin(T &a, S b) {
  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}
vector<int> iota(int n) {
  vector<int> a(n);
  iota(begin(a), end(a), 0);
  return a;
}
template <class T>
void UNIQUE(vector<T> &x) {
  sort(begin(x), end(x));
  x.erase(unique(begin(x), end(x)), x.end());
}
int in() {
  int x;
  cin >> x;
  return x;
}
long long lin() {
  unsigned long long x;
  cin >> x;
  return x;
}
void print() { putchar(' '); }
void print(bool a) { cout << a; }
void print(int a) { cout << a; }
void print(long long a) { cout << a; }
void print(char a) { cout << a; }
void print(string &a) { cout << a; }
void print(double a) { cout << a; }
template <class T>
void print(const vector<T> &);
template <class T, size_t size>
void print(const array<T, size> &);
template <class T, class L>
void print(const pair<T, L> &p);
template <class T, size_t size>
void print(const T (&)[size]);
template <class T>
void print(const vector<T> &a) {
  if (a.empty()) return;
  print(a[0]);
  for (auto i = a.begin(); ++i != a.end();) {
    cout << " ";
    print(*i);
  }
  cout << endl;
}
template <class T>
void print(const deque<T> &a) {
  if (a.empty()) return;
  print(a[0]);
  for (auto i = a.begin(); ++i != a.end();) {
    cout << " ";
    print(*i);
  }
}
template <class T, size_t size>
void print(const array<T, size> &a) {
  print(a[0]);
  for (auto i = a.begin(); ++i != a.end();) {
    cout << " ";
    print(*i);
  }
}
template <class T, class L>
void print(const pair<T, L> &p) {
  cout << '(';
  print(p.first);
  cout << ",";
  print(p.second);
  cout << ')';
}
template <class T>
void print(set<T> &x) {
  for (auto e : x) print(e), cout << " ";
  cout << endl;
}
template <class T>
void print(multiset<T> &x) {
  for (auto e : x) print(e), cout << " ";
  cout << endl;
}
template <class T, size_t size>
void print(const T (&a)[size]) {
  print(a[0]);
  for (auto i = a; ++i != end(a);) {
    cout << " ";
    print(*i);
  }
}
template <class T>
void print(const T &a) {
  cout << a;
}
int out() {
  putchar('\n');
  return 0;
}
template <class T>
int out(const T &t) {
  print(t);
  putchar('\n');
  return 0;
}
template <class Head, class... Tail>
int out(const Head &head, const Tail &...tail) {
  print(head);
  putchar(' ');
  out(tail...);
  return 0;
}
long long gcd(long long a, long long b) {
  while (b) {
    long long c = b;
    b = a % b;
    a = c;
  }
  return a;
}
long long lcm(long long a, long long b) {
  if (!a || !b) return 0;
  return a * b / gcd(a, b);
}
vector<pair<long long, long long>> factor(long long x) {
  vector<pair<long long, long long>> ans;
  for (long long i = 2; i * i <= x; i++)
    if (x % i == 0) {
      ans.push_back({i, 1});
      while ((x /= i) % i == 0) ans.back().second++;
    }
  if (x != 1) ans.push_back({x, 1});
  return ans;
}
template <class T>
vector<T> divisor(T x) {
  vector<T> ans;
  for (T i = 1; i * i <= x; i++)
    if (x % i == 0) {
      ans.push_back(i);
      if (i * i != x) ans.push_back(x / i);
    }
  return ans;
}
template <typename T>
void zip(vector<T> &x) {
  vector<T> y = x;
  sort(begin(y), end(y));
  for (int i = 0; i < x.size(); ++i) {
    x[i] = distance((y).begin(), lower_bound(begin(y), end(y), (x[i])));
  }
}
int popcount(long long x) { return __builtin_popcountll(x); }
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int n) { return uniform_int_distribution<int>(0, n - 1)(rng); }
long long rndll(long long n) {
  return uniform_int_distribution<long long>(0, n - 1)(rng);
}
template <typename T>
void shuffle(vector<T> &v) {
  for (long long i = v.size() - 1; i >= 1; --i) {
    swap(v[i], v[rnd(i)]);
  }
}
vector<string> YES{"NO", "YES"};
vector<string> Yes{"No", "Yes"};
vector<string> yes{"no", "yes"};
template <class... T>
void err(const T &...) {}
template <typename T>
struct edge {
  int from, to;
  T cost;
  int id;
  edge(int to, T cost) : from(-1), to(to), cost(cost) {}
  edge(int from, int to, T cost) : from(from), to(to), cost(cost) {}
  edge(int from, int to, T cost, int id)
      : from(from), to(to), cost(cost), id(id) {}
  edge &operator=(const int &x) {
    to = x;
    return *this;
  }
  operator int() const { return to; }
};
template <typename T>
using Edges = vector<edge<T>>;
struct Graph : vector<vector<int>> {
  using vector<vector<int>>::vector;
  Graph(int n, int m) : vector(n) { read(m); }
  inline void add(int a, int b, bool directed = false) {
    (*this)[a].emplace_back(b);
    if (!directed) (*this)[b].emplace_back(a);
  }
  void read(int n = -1, int offset = 1, bool directed = false) {
    if (n == -1) n = this->size() - 1;
    int a, b;
    while (n--) {
      cin >> a >> b;
      Graph::add(a - offset, b - offset, directed);
    }
  }
};
template <typename T>
struct WeightedGraph : vector<Edges<T>> {
  using vector<Edges<T>>::vector;
  inline void add(int a, int b, T c, bool directed = false) {
    (*this)[a].emplace_back(b, c);
    if (!directed) (*this)[b].emplace_back(a, c);
  }
  void read(int n = -1, int offset = 1) {
    if (n == -1) n = this->size() - 1;
    int a, b;
    T c;
    while (n--) {
      cin >> a >> b >> c;
      WeightedGraph::add(a - offset, b - offset, c);
    }
  }
};
struct Setup_io {
  Setup_io() {
    ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cout << fixed << setprecision(15);
  }
} setup_io;
int main() {
  int n;
  IN(n);
  vector<int> a(n);
  IN(a);
  vector<vector<vector<bool>>> dp(
      n + 1, vector<vector<bool>>(100, vector<bool>(3000)));
  vector<vector<vector<pair<int, int>>>> pre(
      n + 1, vector<vector<pair<int, int>>>(100, vector<pair<int, int>>(3000)));
  dp[0][0][0] = 1;
  vector<int> tr(100);
  for (long long i = 1; i <= 98; ++i) tr[i + 1] = tr[i] + i;
  sort(begin(a), end(a));
  for (long long i = 0; i < n; ++i) {
    for (long long j = 0; j < a[i] * 2 + 2; ++j) {
      for (long long k = 0; k < 3000; ++k) {
        if (!dp[i][j][k]) continue;
        int jj = j + 1, kk = k + a[i];
        while (kk >= tr[jj]) {
          dp[i + 1][jj][kk] = true;
          pre[i + 1][jj][kk] = pair<int, int>(j, k);
          jj++, kk += a[i];
        }
      }
    }
  }
  int m = 0;
  vector<int> v;
  for (long long i = 1; i <= 64; ++i) {
    if (dp[n][i][tr[i]]) {
      m = i;
      int j = i, k = tr[i];
      int t = n;
      while (t > 0) {
        auto [jj, kk] = pre[t][j][k];
        for (long long _ = 0; _ < j - jj; ++_) v.emplace_back(a[t - 1]);
        t--, j = jj, k = kk;
      }
      break;
    }
  }
  if (!m) {
    cout << "=(" << '\n';
    return 0;
  }
  reverse(begin(v), end(v));
  cout << m << '\n';
  vector<vector<int>> g(m, vector<int>(m, -1));
  auto id = iota(m);
  for (long long i = m - 1; i >= 0; --i) {
    for (long long j = 0; j < v[id[i]]; ++j)
      g[id[i]][id[j]] = 1, g[id[j]][id[i]] = 0;
    for (long long j = v[id[i]]; j <= i - 1; ++j)
      g[id[i]][id[j]] = 0, g[id[j]][id[i]] = 1, v[id[j]]--;
    sort(id.begin(), id.begin() + i, [&](int a, int b) { return v[a] < v[b]; });
  }
  for (long long i = 0; i < m; ++i) g[i][i] = 0;
  for (long long i = 0; i < m; ++i) {
    for (long long j = 0; j < m; ++j) {
      cout << g[i][j];
    }
    cout << '\n';
  }
}