// o4-mini

#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;

int n, m;
vector<vector<int>> A;
vector<vector<int>> fixed_mask;      // -1 = not fixed yet, otherwise 0..15
vector<vector<vector<int>>> domain;  // only for rotatables: list of possible masks

// 方向：0=上,1=右,2=下,3=左
int di[4] = { -1, 0, 1, 0 }, dj[4] = { 0, 1, 0, -1 };

// 把 4bit mask b 顺时针旋转 r*90°，r mod 4
int rot_mask(int b, int r) {
    int nb = 0;
    for (int d = 0; d < 4; d++) {
        if (b & (1 << d)) {
            int d2 = (d + r) & 3;
            nb |= 1 << d2;
        }
    }
    return nb;
}

// 判断边 (i,j) 朝 d 方向上的连通性：1 或 0
inline int getBit(int mask, int d) { return (mask >> d) & 1; }

// 如果 u 已经 fixed，向它的某个可旋转邻居 v 传播约束
bool propagate(int ui, int uj, int vi, int vj, queue<pii>& q) {
    int um = fixed_mask[ui][uj];
    // v → u 的方向是 d_vu
    int d_vu = -1;
    for (int d = 0; d < 4; d++) {
        if (ui == vi + di[d] && uj == vj + dj[d]) {
            d_vu = d;
            break;
        }
    }
    int d_uv = (d_vu + 2) & 3;
    int need = getBit(um, d_uv);
    auto& dom = domain[vi][vj];
    vector<int> nd;
    nd.reserve(dom.size());
    for (int x : dom) {
        if (getBit(x, d_vu) == need)
            nd.push_back(x);
    }
    if (nd.empty())
        return false;
    if (nd.size() == dom.size())
        return true;
    dom.swap(nd);
    if ((int)dom.size() == 1) {
        fixed_mask[vi][vj] = dom[0];
        q.emplace(vi, vj);
    }
    return true;
}

// 从所有“初始固定”格子开始的 BFS 约束传播
bool initial_bfs() {
    queue<pii> q;
    // 把度数 !=2（即 0,1,3,4）的一律当成“固定”
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++) {
            int deg = __builtin_popcount(A[i][j]);
            if (deg != 2) {
                fixed_mask[i][j] = A[i][j];
                q.emplace(i, j);
            }
        }
    while (!q.empty()) {
        auto [i, j] = q.front();
        q.pop();
        int um = fixed_mask[i][j];
        for (int d = 0; d < 4; d++) {
            int ni = i + di[d], nj = j + dj[d];
            // 边界当成“虚拟固定 0”
            if (ni < 0 || ni >= n || nj < 0 || nj >= m) {
                if (getBit(um, d))
                    return false;
                continue;
            }
            if (fixed_mask[ni][nj] >= 0) {
                // 邻居也是固定，直接检查
                int vm = fixed_mask[ni][nj];
                if (getBit(um, d) != getBit(vm, (d + 2) & 3))
                    return false;
            } else {
                // 邻居可旋转，过滤它的域
                if (!propagate(i, j, ni, nj, q))
                    return false;
            }
        }
    }
    return true;
}

// 对某一路径内部的连通分量做“试根+局部BFS”
// comp: 这一个分量里所有(i,j)；visit 用来标记哪些格子已被整个问题“锁定”
bool solve_component(const vector<pii>& comp, vector<vector<bool>>& visit) {
    // 先抽出一个还没固定的作根
    int si = -1, sj = -1;
    for (auto& p : comp) {
        if (fixed_mask[p.first][p.second] < 0) {
            si = p.first;
            sj = p.second;
            break;
        }
    }
    if (si < 0)
        return true;  // 这一块全都 fixed 了

    // 保存原来的 domain 以便多次试
    unordered_map<int, vector<int>> saved;
    for (auto& p : comp) {
        int key = p.first * m + p.second;
        saved[key] = domain[p.first][p.second];
    }

    // 根的每种可能都试一遍
    auto& rootDom = domain[si][sj];
    for (int choice : rootDom) {
        // 先恢复所有域
        for (auto& p : comp) {
            int key = p.first * m + p.second;
            domain[p.first][p.second] = saved[key];
            fixed_mask[p.first][p.second] = -1;
        }
        // 把根定��
        domain[si][sj] = { choice };
        fixed_mask[si][sj] = choice;
        queue<pii> q;
        q.emplace(si, sj);
        bool ok = true;
        // 局部 BFS
        while (!q.empty() && ok) {
            auto [i, j] = q.front();
            q.pop();
            int um = fixed_mask[i][j];
            for (int d = 0; d < 4; d++) {
                int ni = i + di[d], nj = j + dj[d];
                if (ni < 0 || ni >= n || nj < 0 || nj >= m)
                    continue;
                if (fixed_mask[ni][nj] >= 0) {
                    // 已fixed: 检查
                    int vm = fixed_mask[ni][nj];
                    if (getBit(um, d) != getBit(vm, (d + 2) & 3)) {
                        ok = false;
                        break;
                    }
                } else if (!visit[ni][nj]) {
                    // 同一分量内部、还没fixed
                    if (!propagate(i, j, ni, nj, q)) {
                        ok = false;
                        break;
                    }
                }
            }
        }
        if (!ok)
            continue;

        // 剩下若干还没fixed的，直接随意从它们的 domain[.] 中取第一个
        for (auto& p : comp) {
            int i = p.first, j = p.second;
            if (fixed_mask[i][j] < 0) {
                fixed_mask[i][j] = domain[i][j][0];
            }
        }
        return true;
    }
    return false;
}

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

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

    fixed_mask.assign(n, vector<int>(m, -1));
    domain.assign(n, vector<vector<int>>(m, {}));

    // 初始化：给每个度=2 的格子列出它所有可旋转状态
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            int b = A[i][j];
            int deg = __builtin_popcount(b);
            if (deg == 2) {
                // 枚举 r=0..3，rot_mask(b,r)
                for (int r = 0; r < 4; r++) {
                    int mb = rot_mask(b, r);
                    // 同一模式可能多次出现，去重
                    if(domain[i][j].empty() ||
                       domain[i][j].back() != mb

/sandbox/1/a.cpp: In function 'int main()':
/sandbox/1/a.cpp:182:47: error: call of overloaded 'vector(int&, <brace-enclosed initializer list>)' is ambiguous
  182 |     domain.assign(n, vector<vector<int>>(m, {}));
      |                                               ^
In file included from /usr/include/c++/10/vector:67,
                 from /usr/include/c++/10/functional:62,
                 from /usr/include/c++/10/pstl/glue_algorithm_defs.h:13,
                 from /usr/include/c++/10/algorithm:74,
                 from /usr/include/x86_64-linux-gnu/c++/10/x32/bits/stdc++.h:65,
                 from /sandbox/1/a.cpp:3:
/usr/include/c++/10/bits/stl_vector.h:522:7: note: candidate: 'std::vector<_Tp, _Alloc>::vector(std::vector<_Tp, _Alloc>::size_type, const value_type&, const allocator_type&) [with _Tp = std::vector<int>; _Alloc = std::allocator<std::vector<int> >; std::vector<_Tp, _Alloc>::size_type = unsigned int; std::vector<_Tp, _Alloc>::value_type = std::vector<int>; std::vector<_Tp, _Alloc>::allocator_type = std::allocator<std::vector<int> >]'
  522 |       vector(size_type __n, const value_type& __value,
      |       ^~~~~~
/usr/include/c++/10/bits/stl_vector.h:510:7: note: candidate: 'std::vector<_Tp, _Alloc>::vector(std::vector<_Tp, _Alloc>::size_type, const allocator_type&) [with _Tp = std::vector<int>; _Alloc = std::allocator<std::vector<int> >; std::vector<_Tp, _Alloc>::size_type = unsigned int; std::vector<_Tp, _Alloc>::allocator_type = std::allocator<std::vector<int> >]'
  510 |       vector(size_type __n, const allocator_type& __a = allocator_type())
      |       ^~~~~~
/sandbox/1/a.cpp:195:49: error: expected ')' at end of input
  195 |                        domain[i][j].back() != mb
      |                                               ~~^
      |                                                 )
/sandbox/1/a.cpp:194:23: note: to match this '('
  194 |                     if(domain[i][j].empty() ||
      |                       ^
/sandbox/1/a.cpp:195:47: error: expected statement at end of input
  195 |                        domain[i][j].back() != mb
      |                                               ^~
/sandbox/1/a.cpp:195:47: error: expected '}' at end of input
/sandbox/1/a.cpp:191:37: note: to match this '{'
  191 |                 for(int r=0;r<4;r++){
      |                                     ^
/sandbox/1/a.cpp:195:47: error: expected '}' at end of input
  195 |                        domain[i][j].back() != mb
      |                                               ^~
/sandbox/1/a.cpp:189:23: note: to match this '{'
  189 |             if(deg==2){
      |                       ^
/sandbox/1/a.cpp:195:47: error: expected '}' at end of input
  195 |                        domain[i][j].back() != mb
      |                                               ^~
/sandbox/1/a.cpp:186:29: note: to match this '{'
  186 |         for(int j=0;j<m;j++){
      |                             ^
/sandbox/1/a.cpp:195:47: error: expected '}' at end of input
  195 |                        domain[i][j].back() != mb
      |                                               ^~
/sandbox/1/a.cpp:185:25: note: to match this '{'
  185 |     for(int i=0;i<n;i++){
      |                         ^
/sandbox/1/a.cpp:195:47: error: expected '}' at end of input
  195 |                        domain[i][j].back() != mb
      |                                               ^~
/sandbox/1/a.cpp:169:11: note: to match this '{'
  169 | int main(){
      |           ^