#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

string dp[1005][1005];
int a[1005][1005];

// Hàm so sánh xâu theo độ ưu tiên tìm số bát phân nhỏ nhất
// Ưu tiên: Xâu ngắn hơn > Xâu có ký tự nhỏ hơn ở vị trí đầu tiên khác
bool isSmaller(const string& s1, const string& s2) {
    if (s1.length() != s2.length()) {
        return s1.length() < s2.length();
    }
    return s1 < s2;
}

int main() {
    int n;
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= n; ++j) {
            cin >> a[i][j];
        }
    }

    // Khởi tạo
    for(int i=0; i<=n; i++) {
        for(int j=0; j<=n; j++) dp[i][j] = "|"; // Ký tự lớn nhất để so sánh
    }

    dp[1][1] = to_string(a[1][1]);

    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= n; ++j) {
            if (i == 1 && j == 1) continue;

            string s1 = (i > 1) ? dp[i-1][j] + to_string(a[i][j]) : "";
            string s2 = (j > 1) ? dp[i][j-1] + to_string(a[i][j]) : "";

            if (i == 1) dp[i][j] = s2;
            else if (j == 1) dp[i][j] = s1;
            else {
                dp[i][j] = (isSmaller(s1, s2) ? s1 : s2);
            }
        }
    }

    string bin = dp[n][n];

    // Chuyển đổi sang bát phân
    string oct = "";
    int len = bin.length();
    int pos = 0;

    // Bỏ qua các bit 0 đầu tiên nếu có
    while (pos < len && bin[pos] == '0') {
        oct += '0';
        pos++;
    }

    // Xử lý các bit còn lại theo nhóm 3
    while (pos < len) {
        int val = 0;
        for (int k = 0; k < 3; ++k) {
            val <<= 1;
            if (pos < len && bin[pos] == '1') val |= 1;
            pos++;
        }
        oct += to_string(val);
    }

    cout << (oct.empty() ? "0" : oct) << endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <string>
#include <queue>
#include <algorithm>
#include <set>

using namespace std;

struct State {
    int r, c;
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    cin >> n;
    vector<vector<int>> grid(n, vector<int>(n));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            cin >> grid[i][j];
        }
    }

    // Lớp 0: chỉ có ô (0,0)
    vector<State> current_layer;
    current_layer.push_back({0, 0});

    // Dùng mảng visited để tránh duyệt trùng trong cùng một lớp
    // Nếu đã duyệt qua (x,y) trong lớp hiện tại, ta chỉ cần giữ lại một đường (vì tất cả đều có độ dài bằng nhau)
    // Tuy nhiên, vì ta cần bit nhỏ nhất, ta phải xét tất cả.
    // Cách tốt hơn: Dùng set hoặc vector đánh dấu.

    string binary_path = "";

    for (int step = 1; step < 2*n - 1; ++step) {
        char min_bit = '2';

        // 1. Tìm bit nhỏ nhất có thể trong bước này
        for (const auto& state : current_layer) {
            // Thử xuống dưới
            if (state.r + 1 < n) {
                min_bit = min(min_bit, (char)('0' + grid[state.r + 1][state.c]));
            }
            // Thử sang phải
            if (state.c + 1 < n) {
                min_bit = min(min_bit, (char)('0' + grid[state.r][state.c + 1]));
            }
        }

        binary_path += min_bit;

        // 2. Lọc các ô có thể đến ở bước tiếp theo có bit bằng min_bit
        vector<State> next_layer;
        vector<vector<bool>> visited(n, vector<bool>(n, false));

        for (const auto& state : current_layer) {
            // Thử xuống dưới
            if (state.r + 1 < n && grid[state.r + 1][state.c] == (min_bit - '0')) {
                if (!visited[state.r + 1][state.c]) {
                    next_layer.push_back({state.r + 1, state.c});
                    visited[state.r + 1][state.c] = true;
                }
            }
            // Thử sang phải
            if (state.c + 1 < n && grid[state.r][state.c + 1] == (min_bit - '0')) {
                if (!visited[state.r][state.c + 1]) {
                    next_layer.push_back({state.r, state.c + 1});
                    visited[state.r][state.c + 1] = true;
                }
            }
        }
        current_layer = next_layer;
    }

    // Chuyển đổi sang bát phân
    // Logic chuyển đổi tương tự như trên
    string octal = "";
    int idx = 0;
    int len = binary_path.length();

    // Xử lý các bit 0 đầu tiên (tạo số 0 ở bát phân)
    while (idx < len && binary_path[idx] == '0') {
        octal += '0';
        idx++;
    }

    // Xử lý các nhóm 3 bit
    while (idx < len) {
        int val = 0;
        for (int k = 0; k < 3; ++k) {
            val <<= 1;
            if (idx < len && binary_path[idx] == '1') val |= 1;
            idx++;
        }
        octal += (char)('0' + val);
    }

    if (octal.empty()) octal = "0";
    cout << octal << endl;

    return 0;
}

#include <iostream>
#include <vector>
#include <string>

using namespace std;

int n;
int a[1005][1005];
int dp[1005][1005]; // 0: ngắn hơn, 1: dài hơn (hoặc không tối ưu)

// So sánh hai đường đi đến (i,j):
// Path 1: từ (i-1, j) + a[i][j]
// Path 2: từ (i, j-1) + a[i][j]
// So sánh theo độ dài, nếu bằng thì so sánh giá trị (từ đầu chuỗi)

string path[1005][1005]; // Cấu trúc này vẫn dùng xâu nên không tối ưu

// Chỉ lưu độ dài và bit đầu?
// Khó vì ta cần so sánh chuỗi.

// Giải pháp thay thế:
// Dùng thuật toán BFS ở trên là tối ưu nhất về độ phức tạp và dễ code.
// Hoặc dùng DP với Trie/Cấu trúc phức tạp.

int main() {
    // Code mẫu cho DP dạng xâu (như Approach 1 nhưng tối ưu hơn)
    // Tuy nhiên, do giới hạn output JSON, ta chỉ giải thích.
    return 0;
}