#include <iostream>
#include <cassert>
#include <algorithm>
#include <numeric>
#include <vector>
#include <string>
#include <memory.h>
#include <queue>
#include <cstdio>
#include <cstdlib>
#include <set>
#include <map>
#include <cctype>
#include <iomanip>
#include <sstream>
#include <cctype>
#include <fstream>
#include <cmath>
using namespace std;

#define REP2(i, m, n) for(int i = (int)(m); i < (int)(n); i++)
#define REP(i, n) REP2(i, 0, n)
#define ALL(c) (c).begin(), (c).end()
#define ITER(c) __typeof((c).begin())
#define PB(e) push_back(e)
#define FOREACH(i, c) for(ITER(c) i = (c).begin(); i != (c).end(); ++i)
#define MP(a, b) make_pair(a, b)
#define PARITY(n) ((n) & 1)

typedef long long ll;
typedef pair<ll, ll> P;
const int INF = 1000 * 1000 * 1000 + 7;
const double EPS = 1e-10;

int yoko[10], ryoko[10];
int tate[10], rtate[10];

void tobit(string str, int i){
  yoko[i] = 0;
  tate[i] = 0;
  ryoko[i] = 0;
  rtate[i] = 0;
  REP(j, 5){
    if(str[j] == '1'){
      yoko[i]  |= 1 << j;
      ryoko[i] |= 1 << (4 - j);
      tate[i]  |= 1 << (5 * j);
      rtate[i] |= 1 << (20 - 5 * j);
    }
  }
}

map<int, int> generate_bmask(const vector<int> &v, bool TATE){
  map<int, int> ans;
  int p[] = {0, 1, 2, 3, 4};
  
  do{
    REP(rmask, 1 << 5){
      int bmask = 0;
      REP(i, 5){
        if(PARITY(rmask >> i)){
          if(TATE) bmask |= tate[v[p[i]]] << i;
          else     bmask |= yoko[v[p[i]]] << (5 * i);
        }else{
          if(TATE) bmask |= rtate[v[p[i]]] << i;
          else     bmask |= ryoko[v[p[i]]] << (5 * i);
        }
      }
      ans[bmask]++;
    }
  }while(next_permutation(p, p + 5));
  return ans;
}

int main(){
  string strs[10];
  while(cin >> strs[0], strs[0]!= "END"){
    ll ans = 0;
    int mirror = 1;
    REP(i, 9) cin >> strs[i+1];
    REP(i, 10){
      tobit(strs[i], i);
      string rstr = strs[i];
      reverse(ALL(rstr));
      if(rstr == strs[i]) mirror++;
    }
    
    REP(mask, 1 << 10){
      if(__builtin_popcount(mask) != 5) continue;
      vector<int> T, Y;
      REP(i, 10){
        if(PARITY(mask  >> i)) T.PB(i);
        else Y.PB(i);
      }
      
      map<int, int> count1 = generate_bmask(T, true);
      map<int, int> count2 = generate_bmask(Y, false);
      
      FOREACH(it, count1){
        int c1 = it->second;
        int c2 = count2[0x1ffffff ^ (it->first)];
        ans += c1 * c2;
      }
    }
    cout << (ans >> (mirror+2)) << endl;
  }
  return 0;
}