/*
4
0110
1010
1101
0010

0 if they cannot reach each other, 1 if they can reach each other
 Create a similar grid, with [i][j] = 1 if there exists a
 hamiltonian path from i to j

 dp[mask][i] = true if there exists a path from 1 to i using
 mask bits, dp2[mask][i] = true if there exists a path from i
 to 1 using mask bits?
*/
#include <iostream>

using namespace std;
#define ll long long
const int maxn = 24;
const int max_mask = (1 << maxn);
int n;

int adj[maxn][2];
int dp[max_mask][2]; //0 for to 1, 1 for away from 1
int rt[maxn];

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin >> n;
    for(int a = 0; a < n; a++){
        string s; cin >> s;
        for(int b = 0; b < n; b++){
            if(s[b] == '1'){
                adj[a][0] |= (1 << b);
                adj[b][1] |= (1 << a);
            }
        }
    }

    dp[1][0] = dp[1][1] = 1;
    for(int typ = 0; typ < 2; typ++) {
        for (int mask = 1; mask < (1 << n); mask++) {
            for (int i = 0; i < n; i++){ //go to i from here, and adjacency list of i with all reached nodes
                if((mask & (1 << i)) <= 0 && (dp[mask][typ] & adj[i][typ]) > 0){
                    dp[mask|(1 << i)][typ] |= (1 << i);
                }
            }
        }
    }

    for(int mask = 0; mask < (1 << n); mask++){
        for(int i = 0; i < n; i++){
            if(((1 << i) & dp[mask][0]) > 0){
                rt[i] |= dp[((~mask)&((1<<n)-1))|1][1];
            }
        }
    }
    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++){
            cout << ((rt[i] & (1 << j))>0);
        } cout << "\n";
    }
}