Problem: problem

Santa Claus came from the sky to JOI town this year as well. Since every house in JOI has children, this Santa Claus must give out presents to every house in JOI. However, this year the reindeer I am carrying is a little deaf and I can only get off the top of the building, so it seems that I have to devise a little route to distribute gifts to all the houses.

JOI Town is divided into north, south, east and west, and each section is a house, a church, or a vacant lot. There is only one church in JOI town. According to the following rules, Santa Claus and reindeer depart from the church, give out one gift to every house, and then return to the church.

* This year's reindeer is a little deaf, so it can only fly straight in either the north, south, east, or west, and cannot change direction in the air.
* You can pass freely over the house where you haven't handed out the presents yet. You can get off at a house that hasn't given out presents yet. Whenever I get home, I give out presents and then take off in either direction of north, south, east or west.
* At the house in JOI town, I spend Christmas night without the fireplace until Santa Claus arrives, but after Santa Claus takes off, I turn on the fireplace. When you turn on the fireplace, smoke comes out of the chimney, so you can't pass over the house where you've finished giving out presents.
* You can pass freely over the church. However, since worship is held in the church, you cannot go down to the church until you have distributed all the presents.
* You can pass freely over the vacant lot, but you cannot get off at the vacant lot.


Create a program that asks how many directions Santa Claus and reindeer can give gifts to, given the structure of the town as input.

input

The input consists of multiple datasets. Each dataset is given in the following format.

Each dataset has n + 1 rows. On the first line, the integer m (1 ≤ m ≤ 10) and the integer n (1 ≤ n ≤ 10) are written separated by a space. In each line from the 2nd line to the n + 1th line, m of 0, 1, or 2 are written, separated by a blank, and each represents the state of each section. If we write the i-th section from the north and the j-th section from the west as (i, j) (1 ≤ i ≤ n, 1 ≤ j ≤ m), the j-th value on the i + 1 line is If the lot (i, j) is a vacant lot, it will be 0, if it is a house, it will be 1, and if it is a church, it will be 2. The number of churches is 1, and the number of houses is 1 or more and 23 or less. However, in the input data for scoring, the number of directions to be distributed does not exceed 2000000.

When both m and n are 0, it indicates the end of input. The number of data sets does not exceed 5.

Input / output example

Input example


3 2
1 0 1
1 0 2
3 3
1 1 1
1 0 1
1 1 2
0 0


Output example


2
6


<image>


Figure: All 6 directions to the second input example (numbers indicate the order of distribution)

The above question sentences and the data used for the automatic referee are the question sentences created and published by the Japan Committee for Information Olympics and the test data for scoring.



output

For each dataset, an integer indicating how many directions to distribute gifts is output on one line.

Example

Input

3 2
1 0 1
1 0 2
3 3
1 1 1
1 0 1
1 1 2
0 0


Output

2
6

Solution (in CPP):

Solution:
// #define _GLIBCXX_DEBUG // for STL debug (optional)
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <cfloat>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <fstream>
#include <functional>
#include <bitset>
using namespace std;
using ll = long long int;
using int64 = long long int;
 
template<typename T> void chmax(T &a, T b) {a = max(a, b);}
template<typename T> void chmin(T &a, T b) {a = min(a, b);}
template<typename T> void chadd(T &a, T b) {a = a + b;}
 
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
const int INF = 1LL << 29;
const ll LONGINF = 1LL << 60;
const ll MOD = 1000000007LL;

const int MAXN = 25;
vector< pair<int, int> > rows[MAXN], cols[MAXN];
int board[MAXN][MAXN], pos_r[MAXN], pos_c[MAXN], rec_r[MAXN], rec_c[MAXN];
int sx, sy, c;
map< pair<int, int>, int > mp;

int dfs(int bit, int k) {
    if(bit == 0) {
        return 1;
    }
    if(mp.count(make_pair(bit, k))) return mp[make_pair(bit, k)];
    
    int x = rec_r[k], y = rec_c[k];
    int xi = pos_r[k], xj = pos_c[k];

    int res = 0, b = __builtin_popcount(bit);
    for(int i=xi+1; i<(int)rows[x].size(); i++) {
        int id = rows[x][i].second;
        if(b > 1 and id == c-1) continue;
        if(bit >> id & 1) {
            int nbit = bit ^ (1 << id);
            res += dfs(nbit, id);
            break;
        }
    }
    for(int i=xi-1; i>=0; i--) {
        int id = rows[x][i].second;
        if(b > 1 and id == c-1) continue;
        if(bit >> id & 1) {
            int nbit = bit ^ (1 << id);
            res += dfs(nbit, id);
            break;
        }
    }
    for(int j=xj+1; j<(int)cols[y].size(); j++) {
        int id = cols[y][j].second;
        if(b > 1 and id == c-1) continue;
        if(bit >> id & 1) {
            int nbit = bit ^ (1 << id);
            res += dfs(nbit, id);
            break;
        }
    }
    for(int j=xj-1; j>=0; j--) {
        int id = cols[y][j].second;
        if(b > 1 and id == c-1) continue;
        if(bit >> id & 1) {
            int nbit = bit ^ (1 << id);
            res += dfs(nbit, id);
            break;
        }
    }
    return mp[make_pair(bit, k)] = res;
}

int solve_testcase() {
    int H, W; scanf("%d%d", &W, &H);
    if(H == 0 and W == 0) return 1;
    mp.clear();
    
    for(int i=0; i<MAXN; i++) {
        rows[i].clear();
        cols[i].clear();
    }

    c = 0;
    for(int i=0; i<H; i++) {
        for(int j=0; j<W; j++) {
            scanf("%d", &board[i][j]);
            if(board[i][j] == 1) {
                rows[i].emplace_back(j, c);
                cols[j].emplace_back(i, c);
                rec_r[c] = i;
                rec_c[c] = j;
                ++c;
            }
            if(board[i][j] == 2) {
                sx = i, sy = j;
            }
        }
    }

    {
        rows[sx].emplace_back(sy, c);
        cols[sy].emplace_back(sx, c);
        rec_r[c] = sx;
        rec_c[c] = sy;
        ++c;
    }
    
    for(int i=0; i<15; i++) {
        sort(rows[i].begin(), rows[i].end());
        sort(cols[i].begin(), cols[i].end());

        for(size_t k=0; k<rows[i].size(); k++) {
            int idx = rows[i][k].second;
            pos_r[idx] = k;
        }
        for(size_t k=0; k<cols[i].size(); k++) {
            int idx = cols[i][k].second;
            pos_c[idx] = k;
        }
    }
    
    int ans = dfs((1<<c)-1, c-1);
    printf("%d\n", ans);
    return 0;
}

int main() {
    while(!solve_testcase());
    return 0;
}