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:
#include<bits/stdc++.h>

#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)

using namespace std;

typedef pair<int,int> ii;

int H,W;
int G[11][11],INDEX[11][11],ep_bitmask,sp,V;
int dx[] = {0,1,0,-1};
int dy[] = {1,0,-1,0};
vector<int> edges[25][4];
//map<ii,int> memo;

bool isValid(int x,int y) { return 0 <= x && x < W && 0 <= y && y < H; }

inline void INIT(){
  //memo.clear();
  ep_bitmask = 0, sp = -1;
  rep(i,11) rep(j,11) INDEX[i][j] = -1;
  rep(i,25) rep(j,4) edges[i][j].clear();
}

inline void make_edges(){
  rep(i,H) rep(j,W) if( G[i][j] != 0 ) {
    int x = j, y = i;
    rep(k,4){
      int nx = x + dx[k], ny = y + dy[k];
      while( isValid(nx,ny) ){
        if( G[ny][nx] == 1 ) edges[INDEX[i][j]][k].push_back(INDEX[ny][nx]);
        nx += dx[k], ny += dy[k];
      }
    }
  }
}

inline void calc_last_point(int x,int y){
  rep(i,4) {
    int nx = x + dx[i], ny = y + dy[i];
    while( isValid(nx,ny) ){
      if( G[ny][nx] == 1 ) {
        ep_bitmask |= (1<<INDEX[ny][nx]);
        //break;
      }
      nx += dx[i], ny += dy[i];
    }
  }
}

int dfs(int cur,int visited,int remain,int ep_remain){

  if( ep_remain == 0 && remain != 0 ) return 0;

  if( remain <= 0 ) return ( (ep_bitmask>>cur) & 1 );

  int ret = 0;
  rep(k,4){
    rep(i,edges[cur][k].size()){
      int next = edges[cur][k][i];
      if( (visited>>next) & 1 ) continue;
      ret += dfs(next,visited|(1<<next),remain-1,ep_remain-((ep_bitmask>>next)&1));
      break;
    }
  }

  return ret;
}

int main(){
  while( cin >> W >> H, H|W ){
    INIT();
    int idx = 0,remain = 0,sx,sy;
    rep(i,H) rep(j,W) {
      cin >> G[i][j];
      if( G[i][j] == 1 ) INDEX[i][j] = idx++, remain++;
      if( G[i][j] == 2 ) sx = j, sy = i;
    }
    sp = INDEX[sy][sx] = idx++;
    make_edges();

    calc_last_point(sx,sy);
    assert(remain <= 23);
    V = remain;
    cout << dfs(sp,0,remain,__builtin_popcount(ep_bitmask)) << endl;

  }
  return 0;
}