#include <iostream>
#include <string.h>
#include <list>
#include <set>
#include <assert.h>
//cache[day][pos][pat]
int schedule[366];

inline int patternOnPosition(int pos){
  int t = (1 << pos);
  if(pos % 4 < 3){
    t += (1 << (pos + 1));
  }
  if(pos + 4 < 16){
    t += (1 << (pos + 4));
  }
  if(pos + 5 < 16 && pos % 4 < 3){
    t += (1 << (pos + 5));
  }
  //return (1 << pos) + (1 << (pos + 1)) + (1 << (pos + 4)) + (1 << (pos + 5));
  return t;
}

#if 0
typedef int State;
inline int patternOf(State s){return s & 65535;}
inline int dayOf(State s){return s >> 22;}
inline int positionOf(State s){return (s >> 16) & 15;}
State makeState(int day, int position, int pattern){
  return (day << 22) + (position << 16) + pattern;
}


void addNewState(std::set<State> & states, State s){
  int pos = positionOf(s);
  for(int newPos = 0; newPos < 12; newPos++){
    if(newPos % 4 == 3){continue;}
    if(newPos / 4 == pos / 4 && abs(newPos - pos) <= 2 || 
       newPos % 4 == pos % 4 && abs(newPos / 4 - pos / 4) <= 2){
      int newDay = dayOf(s) + 1;
      int pattern = patternOnPosition(newPos);
      if((pattern & schedule[newDay]) == 0){
	pattern = (newDay % 7 == 6 ? 0: patternOf(s)) | pattern;
	states.insert(makeState(newDay, newPos, pattern));
      }
    }
  }
}


bool test(int n){
  State s;
  std::set<State> states;
  states.insert(State());
  if(patternOnPosition(5) & schedule[0]){return false;}
  while(!states.empty()){
    State s = *states.begin();
    states.erase(states.begin());

    if(dayOf(s) == n - 1){return true;}
    if(dayOf(s) % 7 == 5 && patternOf(s) != 65535){continue;}
    if(dayOf(s) < n - 1){addNewState(states, s);}
  }
  return false;
}




#else
struct State{
  int day;
  int pos;
  int rain[16];
  
  State(){
    for(int i = 0; i < 16; i++){rain[i] = -1;}
    pos = 5;
    day = 0;
    rain[5] = rain[6] = rain[9] = rain[10] = 0;
  }
  State(int d, int p, const State & s){
    for(int i = 0; i < 16; i++){rain[i] = s.rain[i];}
    rain[p] = d;
    if(p % 4 < 3){rain[p + 1] = d;}
    if(p + 4 < 16){rain[p + 4] = d;}
    if(p + 5 < 16 && p % 4 < 3){rain[p + 5] = d;}
    day = d;
    pos = p;
  }
  bool operator < (const State & s)const{
    if(day != s.day){return day < s.day;}
    if(pos != s.pos){return pos < s.pos;}
    for(int i = 0; i < 16; i++){
      if(rain[i] != s.rain[i]){return rain[i] < s.rain[i];}
    }
    return false;
  }

  bool isValid() const {
    for(int i = 0; i < 16; i++){
      if(rain[i] < day - 6){return false;}
    }
    return true;
  }
};


void addNewState(std::set<State> & states, const State & s){
  for(int newPos = 0; newPos < 12; newPos++){
    if(newPos % 4 == 3){continue;}
    if(newPos / 4 == s.pos / 4 && abs(newPos - s.pos) <= 2 || 
       newPos % 4 == s.pos % 4 && abs(newPos / 4 - s.pos / 4) <= 2){
      int newDay = s.day + 1;
      if((patternOnPosition(newPos) & schedule[newDay]) == 0){
	State t(newDay, newPos, s);
	if(t.isValid()){states.insert(t);}
      }
    }
  }
}

bool test(int n){
  std::set<State> states;
  states.insert(State());
  if(patternOnPosition(5) & schedule[0]){return false;}
  while(!states.empty()){
    State s = *states.begin();
    states.erase(states.begin());
    if(s.day == n - 1){return true;}
    addNewState(states, s);
  }
  return false;
}
#endif

int main(){
  //std::cout << patternOnPosition(15) << std::endl;
  while(true){
    int N;
    std::cin >> N;
    if(N == 0){break;}
    for(int i = 0; i < N; i++){
      schedule[i] = 0;
      for(int j = 0; j < 16; j++){
	int k;
	std::cin >> k;
	if(k != 0){
	  schedule[i] |= (1 << j);
	}
      }
    }
    if(test(N)){std::cout << "1" << std::endl;}
    else{std::cout << "0" << std::endl;}
  }
}