/*

Author:		MARCO CARLETTI
Id:			id369018

IDEA:

- si effettua una fase preliminare in cui si azzerano nel buffer i settori
che sono identici a stomp;

- si contano gli 1 rimasti;
- si calcola una prima soluzione basandosi sulla prima riga di stomp;
- si fa nuovamente il conto ma rispetto alla seconda;

- si confrontano le 3 soluzioni e si sceglie la migliore;

*/

#include <iostream>
#include <fstream>
#include <cassert>

using namespace std;

#define N_MAX 1000000

int N;
int stomp[2][3];
int buffer[2][N_MAX]; // buffer di lavoro
int tmp[2][N_MAX]; // buffer in input
int SOL = 0;

int conta()
{
	int res = 0;
	for(int i=0; i<2; i++)
		for(int j=0; j<N; j++)
			res += buffer[i][j];
			
	return res;
}

void cercaStomps(int i)
{
	if(N-i < 3)
		return;

	if(
		tmp[0][i  ] == stomp[0][0] &&
		tmp[0][i+1] == stomp[0][1] &&
		tmp[0][i+2] == stomp[0][2] &&
		tmp[1][i  ] == stomp[1][0] &&
		tmp[1][i+1] == stomp[1][1] &&
		tmp[1][i+2] == stomp[1][2]
	)
		tmp[0][i]=tmp[0][i+1]=tmp[0][i+2]=tmp[1][i]=tmp[1][i+1]=tmp[1][i+2]=0;
		
	cercaStomps(i+1);
}

inline void inverti(int line, int i)
{
	if(stomp[line][0] == 1)
		buffer[line][i  ] = !(buffer[line][i  ]);
	if(stomp[line][1] == 1)
		buffer[line][i+1] = !(buffer[line][i+1]);
	if(stomp[line][2] == 1)
		buffer[line][i+2] = !(buffer[line][i+2]);
}

void searchSolution(int line, int i)
{
	if(N-i == 3)
	{
		// conviene invertire?
		
		// originale
		int sum = 0;
		for(int j=0; j<2; j++)
			sum += (buffer[j][i]+buffer[j][i+1]+buffer[j][i+2]);
			
		int inv = 0;
		
		// inverto
		inverti(0,i);
		inverti(1,i);
			
		for(int j=0; j<2; j++)
			inv += (buffer[j][i]+buffer[j][i+1]+buffer[j][i+2]);
	
		// e nel caso reverto
		if(inv > sum)
		{
			inverti(0,i);
			inverti(1,i);
		}
	}
	else
	if(buffer[line][i] == 1)
	{	
		inverti(line,i);
		
		if(line == 0) inverti(1,i);
		else inverti(0,i);
		
		searchSolution(line, i+1);
	}
	else
		searchSolution(line, i+1);
}

int main()
{
	// dati: N, STOMP, BUFFER
	// soluzione: SOL
	
	// input
	ifstream fin("input.txt");
	fin >> N;
	for(int i=0; i<2; i++)
		for(int j=0; j<3; j++)
			fin >> stomp[i][j];

	for(int i=0; i<2; i++)
		for(int j=0; j<N; j++)
		{
			fin >> tmp[i][j];
		}
	fin.close();
	
	// fase preliminare: elimino gli stomp uguali dal buffer
	cercaStomps(0);
	
	// inizializzo il buffer di lavoro
	for(int i=0; i<2; i++)
		for(int j=0; j<N; j++)
			buffer[i][j] = tmp[i][j];
			
	int sol_noStom = conta(); // PRIMA SOLUZIONE

	// calcolo la soluzione basata sulla prima riga di stomp
	int sol0 = 0;
	searchSolution(0,0);
	sol0 = conta(); // SECONDA SOLUZIONE
	
	// ripristino il buffer di lavoro
	for(int i=0; i<2; i++)
		for(int j=0; j<N; j++)
			buffer[i][j] = tmp[i][j];
	
	// calcolo la soluzione basata sulla seconda riga di stomp
	int sol1 = 0;
	searchSolution(1,0);
	sol1 = conta(); // TERZA SOLUZIONE

	// prendo la soluzione migliore (più piccola)
	if(sol_noStom > sol0 || sol_noStom > sol1)
		if(sol0 < sol1)
			SOL = sol0;
		else
			SOL = sol1;
	else
		SOL = sol_noStom;

	// output
	ofstream fout("output.txt");
	fout << SOL << endl;
	fout.close();

	return 0;
}