/*
TASK:brkclk
LANG:C++
*/

#include <stdio.h>
//#include <stdlib.h>

const int DIGIT_SEGMENT_COUNT = 7;
const int SEGMENT_OFF  = 0;
const int SEGMENT_ON   = 1;
const int SEGMENT_DEAD = -1;
const int MINUTES_PER_DAY = 1440;
const int INF             = 1000000;

/*
 0
1 2
 3
4 5
 6
*/

char font[][DIGIT_SEGMENT_COUNT] = {
	{1,1,1,0,1,1,1}, // 0
	{0,0,1,0,0,1,0}, // 1
	{1,0,1,1,1,0,1}, // 2
	{1,0,1,1,0,1,1}, // 3
	{0,1,1,1,0,1,0}, // 4
	{1,1,0,1,0,1,1}, // 5
	{1,1,0,1,1,1,1}, // 6
	{1,0,1,0,0,1,0}, // 7
	{1,1,1,1,1,1,1}, // 8
	{1,1,1,1,0,1,1}, // 9	
	{0,0,0,0,0,0,0}, // empty digit ( leading zero )
};	


class Time {
	int hour;
	int min;
public:
	Time() {
		hour = -1;
		min  = -1;
	}
	Time(int hour,int min) {
		set(hour,min);
	}
	inline bool operator == ( const Time &t) {
		return hour == t.hour && min == t.min;
	}
	inline void set(int hour,int min)
	{
		this->hour = hour;
		this->min  = min;
	}
	void increment() {
		if ( min < 59 ) {
			min++;
			return;
		} else {
			if ( hour < 23 ) {
				min = 0;
				hour++;
				return;
			} else {
				min = 0;
				hour = 0;
			}
		}
	}
	void print() {
		printf("%d:%d\n",hour,min);
	}
	inline int get_hour_major() {
		return hour / 10;
	}
	inline int get_hour_minor() {
		return hour % 10;
	}
	inline int get_minute_major() {
		return min / 10;
	}
	inline int get_minute_minor() {
		return min % 10;
	}
	bool in_the_future_of(Time t) {
		//assuming the date is the same :)
		if (hour > t.hour)
			return true;
		if (hour < t.hour)
			return false;
		if (min > t.min)
			return true;
		if (min < t.min)
			return false;

		//unimportant. Should not be called if times are equal 
		return true;
	}
};

class SetOfPossibleTimes {
	Time possible_times[MINUTES_PER_DAY + 20];
	int possible_times_count;
public:
	SetOfPossibleTimes() {
		possible_times_count = 0;
	}
	void add(Time t) {
		possible_times[possible_times_count] = t;
		possible_times_count++;
	}
	Time get(int i) {
		return possible_times[i];
	}
	int count() {
		return possible_times_count;
	}	
	void print() {
		for (int i=0;i<possible_times_count;i++)
			possible_times[i].print();
	}
};

char input[4][DIGIT_SEGMENT_COUNT];
SetOfPossibleTimes initialaly_possible_times;


void load()
{
	FILE *fin;

	fin = stdin;
	//fin = fopen("brkclk.in","r");

	char line[4];

	int digit;	
	
	//line 1
	for (digit = 0;digit < 4;digit++) {
		fscanf(fin,"%s",&line);
		if (line[1] == '=' || line[1] == '#')
			input[digit][0] = SEGMENT_ON;
		if (line[1] == '-' || line[1] == '|')
			input[digit][0] = SEGMENT_OFF;
		if (line[1] == '.')
			input[digit][0] = SEGMENT_DEAD;
	}

	//line 2
	for (digit = 0;digit < 4;digit++) {
		fscanf(fin,"%s",&line);
		if (line[0] == '=' || line[0] == '#')
			input[digit][1] = SEGMENT_ON;
		if (line[0] == '-' || line[0] == '|')
			input[digit][1] = SEGMENT_OFF;
		if (line[0] == '.')
			input[digit][1] = SEGMENT_DEAD;

		if (line[2] == '=' || line[2] == '#')
			input[digit][2] = SEGMENT_ON;
		if (line[2] == '-' || line[2] == '|')
			input[digit][2] = SEGMENT_OFF;
		if (line[2] == '.')
			input[digit][2] = SEGMENT_DEAD;
	}

	//line 3
	for (digit = 0;digit < 4;digit++) {
		fscanf(fin,"%s",&line);
		if (line[1] == '=' || line[1] == '#')
			input[digit][3] = SEGMENT_ON;
		if (line[1] == '-' || line[1] == '|')
			input[digit][3] = SEGMENT_OFF;
		if (line[1] == '.')
			input[digit][3] = SEGMENT_DEAD;
	}
	
	//line 4
	for (digit = 0;digit < 4;digit++) {
		fscanf(fin,"%s",&line);
		if (line[0] == '=' || line[0] == '#')
			input[digit][4] = SEGMENT_ON;
		if (line[0] == '-' || line[0] == '|')
			input[digit][4] = SEGMENT_OFF;
		if (line[0] == '.')
			input[digit][4] = SEGMENT_DEAD;

		if (line[2] == '=' || line[2] == '#')
			input[digit][5] = SEGMENT_ON;
		if (line[2] == '-' || line[2] == '|')
			input[digit][5] = SEGMENT_OFF;
		if (line[2] == '.')
			input[digit][5] = SEGMENT_DEAD;
	}

	//line 5
	for (digit = 0;digit < 4;digit++) {
		fscanf(fin,"%s",&line);
		if (line[1] == '=' || line[1] == '#')
			input[digit][6] = SEGMENT_ON;
		if (line[1] == '-' || line[1] == '|')
			input[digit][6] = SEGMENT_OFF;
		if (line[1] == '.')
			input[digit][6] = SEGMENT_DEAD;
	}

	fclose(fin);
}

bool digit_is_blank(char *digit_data)
{
	for (int i=0;i<DIGIT_SEGMENT_COUNT;i++)
		if (digit_data[i] != SEGMENT_OFF && digit_data[i] != SEGMENT_DEAD)
			return false;
	return true;
}

bool could_be_the_same_digit(char *digit_data1,char *digit_data2)
{
	for (int i=0;i<DIGIT_SEGMENT_COUNT;i++) {
		if (digit_data1[i] == SEGMENT_ON && digit_data2[i] == SEGMENT_OFF)
			return false;
		if (digit_data2[i] == SEGMENT_ON && digit_data1[i] == SEGMENT_OFF)
			return false;
	}
	return true;
}

void guess_digit(int digit,int *suggestion_list,int *suggestion_count,int first_guess = 0)
{
	for (int i=first_guess;i<10;i++) 
		if (could_be_the_same_digit(font[i],input[digit])) {
			suggestion_list[*suggestion_count] = i;
			(*suggestion_count)++;
		}
}

void guess_non_zero_digit(int digit,int *suggestion_list,int *suggestion_count)
{
	guess_digit(digit,suggestion_list,suggestion_count,1);
}

void build_initial_suggestion_list()
{
	int possible_digit1[15];
	int possible_digit1_count = 0;

	int possible_digit2[15];
	int possible_digit2_count = 0;

	int possible_digit3[15];
	int possible_digit3_count = 0;

	int possible_digit4[15];
	int possible_digit4_count = 0;

	if ( digit_is_blank(input[0]) ) {
		possible_digit1[possible_digit1_count] = 0;
		possible_digit1_count++;
	}
	guess_non_zero_digit(0,possible_digit1,&possible_digit1_count);
	
	guess_digit(1,possible_digit2,&possible_digit2_count);
	guess_digit(2,possible_digit3,&possible_digit3_count);
	guess_digit(3,possible_digit4,&possible_digit4_count);

	int hour_major;
	int hour_minor;
	int minute_major;
	int minute_minor;
	int hour;
	int minute;

	for (hour_major=0;hour_major<possible_digit1_count;hour_major++) 
		for (hour_minor=0;hour_minor<possible_digit2_count;hour_minor++) {
			hour = possible_digit1[hour_major]*10 + possible_digit2[hour_minor];
			if ( hour >= 24 )
				continue;
			for (minute_major=0;minute_major<possible_digit3_count;minute_major++)
				for (minute_minor=0;minute_minor<possible_digit4_count;minute_minor++) {
					minute = possible_digit3[minute_major]*10 + possible_digit4[minute_minor];
					if ( minute >= 60 )
						continue;
					initialaly_possible_times.add(Time(hour,minute));					
					//printf("Could be %d:%d\n",hour,minute);
				}
		}
	
}

inline int max(int i1,int i2)
{
	return i1 > i2 ? i1 : i2;
}

SetOfPossibleTimes *match_suggestion_lists(SetOfPossibleTimes *old_list,SetOfPossibleTimes *new_list) 
{
	SetOfPossibleTimes *result = new SetOfPossibleTimes();

	int old_list_iterator = 0;
	int new_list_iterator = 0;	

	for (new_list_iterator = 0;new_list_iterator < new_list->count(); new_list_iterator++)
		for (old_list_iterator = 0;old_list_iterator < old_list->count();old_list_iterator++) {			
			Time new_time = new_list->get(new_list_iterator);
			Time old_time = old_list->get(old_list_iterator);
			old_time.increment();			
			if ( new_time == old_time ) {
				result->add(new_time);
				break;
			}
			if (old_time.in_the_future_of(new_time)) {
				//test with the last, the only possible wrap-around value
				old_list_iterator = old_list->count()-1;
				
				old_time = old_list->get(old_list_iterator);
				old_time.increment();	
				if ( new_time == old_time ) 
					result->add(new_time);	
				
				break;
			}			
		}

	return result;
}

bool could_be_the_same_digit_assuming_time_is(char *font_data,char *input,int cur_time_digit)
{
	// cur_time_digit = the state of the non-font digit
	for (int i=0;i<DIGIT_SEGMENT_COUNT;i++) {
		char segment_state;

		if (input[i] == SEGMENT_DEAD) {
			segment_state = SEGMENT_DEAD;
			continue;
		}
		if (input[i] == SEGMENT_OFF || input[i] == SEGMENT_ON)
			segment_state = font[cur_time_digit][i];

		if (font_data[i] != segment_state)
			return false;		
	}
	return true;
}

void guess_digit_assuming_time_is(int digit,int *suggestion_list,int *suggestion_count,int cur_time_digit,int first_guess=0)
{
	// cur_time_digit = the state of the digit where are trying to guess in the currently assumed time

	for (int i=first_guess;i<10;i++) 
		if (could_be_the_same_digit_assuming_time_is(font[i],input[digit],cur_time_digit)) {
			suggestion_list[*suggestion_count] = i;
			(*suggestion_count)++;
		}
}

void guess_non_zero_digit_assuming_time_is(int digit,int *suggestion_list,int *suggestion_count,int cur_time_digit)
{
	 guess_digit_assuming_time_is(digit,suggestion_list,suggestion_count,cur_time_digit,1);	
}

void build_suggestion_list_assuming_time_is(SetOfPossibleTimes *list,Time cur_time)
{
	// Builds a new suggestion list assuming that the working segments of the input are
	// glowing as if it was cur_time o'clock

	int possible_digit1[10];
	int possible_digit1_count = 0;

	int possible_digit2[10];
	int possible_digit2_count = 0;

	int possible_digit3[10];
	int possible_digit3_count = 0;

	int possible_digit4[10];
	int possible_digit4_count = 0;

	if ( cur_time.get_hour_major() == 0 ) {
		possible_digit1[possible_digit1_count] = 0;
		possible_digit1_count++;
	} 
	guess_non_zero_digit_assuming_time_is(0,possible_digit1,&possible_digit1_count,cur_time.get_hour_major());
	
	guess_digit_assuming_time_is(1,possible_digit2,&possible_digit2_count,cur_time.get_hour_minor());
	guess_digit_assuming_time_is(2,possible_digit3,&possible_digit3_count,cur_time.get_minute_major());
	guess_digit_assuming_time_is(3,possible_digit4,&possible_digit4_count,cur_time.get_minute_minor());

	int hour_major;
	int hour_minor;
	int minute_major;
	int minute_minor;
	int hour;
	int minute;

	for (hour_major=0;hour_major<possible_digit1_count;hour_major++) 
		for (hour_minor=0;hour_minor<possible_digit2_count;hour_minor++) {
			hour = possible_digit1[hour_major]*10 + possible_digit2[hour_minor];
			if ( hour >= 24 )
				continue;
			for (minute_major=0;minute_major<possible_digit3_count;minute_major++)
				for (minute_minor=0;minute_minor<possible_digit4_count;minute_minor++) {
					minute = possible_digit3[minute_major]*10 + possible_digit4[minute_minor];
					if ( minute >= 60 )
						continue;
					list->add(Time(hour,minute));					
					//printf("Could be %d:%d\n",hour,minute);
				}
		}

}

int solve_assuming_time_is(Time time) 
{
	Time cur_time = time;
	int minutes_passed = 0;
	SetOfPossibleTimes *cur_suggestion_list = new SetOfPossibleTimes(initialaly_possible_times);

	do {
		if (cur_suggestion_list->count() == 1)
			return minutes_passed;
		minutes_passed++;
		//printf("%d\n",minutes_passed);
		cur_time.increment();
		//cur_time.print();
		SetOfPossibleTimes *new_suggestion_list = new SetOfPossibleTimes();		
		build_suggestion_list_assuming_time_is(new_suggestion_list,cur_time);
		SetOfPossibleTimes *next_suggestion_list = match_suggestion_lists(cur_suggestion_list,new_suggestion_list);
		delete cur_suggestion_list;
		delete new_suggestion_list;
		cur_suggestion_list = next_suggestion_list;
	} while (minutes_passed <= MINUTES_PER_DAY);
	delete cur_suggestion_list;

	return INF;
}

int solve()
{
	int result = 0;

	build_initial_suggestion_list();	
	for (int i=0;i<initialaly_possible_times.count();i++) {
		int new_result = solve_assuming_time_is(initialaly_possible_times.get(i));
		//printf("%d\n",new_result);
		result = max(result, new_result);
		if (result == INF)
			return -1;
	}

	return result;
}

void save(int result)
{
	printf("%d\n",result);
}

int main()
{
	load();
	save(solve());
	
	return 0;
}
