#include<bits/stdc++.h>
using namespace std;
#ifdef DEB
#define D if(1)
#else
#define D if(0)
#endif

using ll = long long;

using func = std::function<char & (int,int)>;
#define F(IN) [&](int a,int b)->char&{return IN;}

// Tuto konstrukci využiji pro určování pozice, kam daný objekt vygeneruji.
// Její výhoda je ve snadném převracení a otáčení výstupu
// Každá funkce na generování bere jako parametr funkci, která pro dvojici čísel
// (souřadnici) určí místo v paměti, tak danou polohu zapsat
// První z předešlých řádku je definice typu takovéto funkce
// Druhý je zkratková konstrukce pro generování lambda funkcí.
// Stačí jen napsat její tělo s použitím a a b jako vstupních souřadnic

int n,m;
char out[13245][12345];
int solveOut[13245][12345];

void setSize(int N,int M)
{
	n=N;m=M;
	for(int i=0;i<n;i++)
		for(int j=0;j<m;j++)
			out[i][j] = ' ';
}
const int cross_size=21;
void hline(func out,int x,int a,int b)
{ // koridor šířky 3  ve směru druhé souřadnice
	if(a>b)
		hline(out,x,b,a);
	for(int y=a-1;y<=b+1;y++)
	{
		out(x-1,y)='.';
		out(x,y)='.';
		out(x+1,y)='.';
	}
}
void vline(func out,int a,int b,int y)
{ // a ve směru první souřadnice
	if(a>b)
		vline(out,b,a,y);
	for(int x=a-1;x<=b+1;x++)
	{
		out(x,y-1)='.';
		out(x,y)='.';
		out(x,y+1)='.';
	}
}
void line(func out,vector<pair<int,int>> route)
{// vezme seznam bodů a mezi nimi nakreslí koridor
// Nutně musí být sousední body s alespoň jednou stejnou souřadnicí
	for(int i=0;i<(int)route.size()-1;i++)
	{
		if(route[i].first == route[i+1].first)
		{
			hline(out,route[i].first,route[i].second,route[i+1].second);
		}
		else
		if(route[i].second == route[i+1].second)
		{
			vline(out,route[i].first,route[i+1].first,route[i].second);
		}
		else assert(0);
	}
}
void drawCross(func out)
{// křížení koridorů
	const int size = cross_size;
	char  a [size][size+1] = {
"XXXXXXXXXXXXXXX...XXX",
"XXXXXXX...........XXX",
"XXXXXXX...........XXX",
"XXXXXXX..............",
"XXXXXXX...XXXXXXX....",
"XXXXXXX.....XXXXX....",
"XXXXXXX.....XXXXX...X",
"X...........XXXXX...X",
"X.......X...XXXXX...X",
"X...............X...X",
"X...X...........X...X",
"X...X...............X",
"X...XXXXX...X.......X",
"X...XXXXX...........X",
"X...XXXXX.....XXXXXXX",
"....XXXXX.....XXXXXXX",
"....XXXXXXX...XXXXXXX",
"..............XXXXXXX",
"XXX...........XXXXXXX",
"XXX...........XXXXXXX",
"XXX...XXXXXXXXXXXXXXX"
	};
	for(int i=0;i<size;i++)
		for(int j=0;j<size;j++)
			out(i,j)=a[i][j];
}
const int neg_sizeX = 30;
const int neg_sizeY = 30;
void drawNeg(func out)
{// Obalené křížení koridorů do tvaru negace se standardní polohou vstupu a výstupu
	for(int i=0;i<neg_sizeX;i++)
		for(int j=0;j<neg_sizeY;j++)
			out(i,j)='Y';
	drawCross(F(out(a+4,b+4)));
	line(out,{{11,1},{11,2},{2,2},{2,4+cross_size-5}});
	line(out,{{18,1},{18,2},{4+cross_size-5,2}});
	line(out,{{11,neg_sizeY-2},{11,4+cross_size+1},{4+4,4+cross_size+1}});
	line(out,{{18,neg_sizeY-2},{18,neg_sizeY-3},{4+cross_size+1,neg_sizeY-3},{4+cross_size+1,4+4}});
}
const int touch_sizeX = 30;
const int touch_sizeY = 11;
void drawTouch(func out)
{ // Dotyk koridoru s horním koridorem se standardním vstupem/výstupem
	for(int i=0;i<touch_sizeX;i++)
		for(int j=0;j<touch_sizeY;j++)
			out(i,j)='Y';
	line(out,{{11,1},{11,2},{14,2},{14,8},{11,8},{11,touch_sizeY-2}});
	line(out,{{18,1},{18,touch_sizeY-2}});
	line(out,{{1,3},{10,3},{10,7},{1,7}});
}
void drawTouchDown(func out)
{// to samé opačně
	drawTouch(F(out(touch_sizeX-1-a,b)));
}

const int split_sizeX = 60;
const int split_sizeY = 82;
void drawSplit(func out)
{// Vynucená rovnost dvou signálů
	for(int i=0;i<split_sizeX;i++)
		for(int j=0;j<split_sizeY;j++)
			out(i,j)='Y';
	line(out,{{11,1},{11,split_sizeY-2}});
	int y=0;
	drawTouch(F(out(a+30,b+y)));
	line(out,{{18,y+1},{18,y+3},{29,y+3}});
	line(out,{{18,y+9},{18,y+7},{29,y+7}});
	y+=touch_sizeY;
	drawNeg(F(out(a,b+y)));
	drawNeg(F(out(a+30,b+y)));
	y+=neg_sizeY;
	drawTouch(F(out(a+30,b+y)));
	line(out,{{18,y+1},{18,y+3},{29,y+3}});
	line(out,{{18,y+9},{18,y+7},{29,y+7}});
	y+=touch_sizeY;
	drawNeg(F(out(a,b+y)));
	drawNeg(F(out(a+30,b+y)));
	y+=neg_sizeY;
}

const int coder_sizeX = 77;
const int coder_sizeY = 106;
void drawCoder(func out)
{// Kódovač
	int x = 0;
	int y =2;
	line(out,{{11,1},{11,y-1}});
	line(out,{{18,1},{18,y-1}});
	drawTouchDown(F(out(a+x,b+y)));
	line(out,{{x+31,1},{x+31,y+3}});
	drawCross(F(out(a+x+35,b+y)));
	line(out,{{x+31,y+7},{x+33,y+7},{x+33,y+16}});
	line(out,{{x+35+16,y},{x+35+16,1}});
	int endYC1 = y+4;
	int endYC2 = y+22;
	y+=touch_sizeY;
	drawNeg(F(out(a+x,b+y)));
	y+=neg_sizeY;
	drawTouchDown(F(out(a+x,b+y)));
	line(out,{{x+35+4,endYC2},{x+31,endYC2},{x+31,y+3}});
	drawCross(F(out(a+x+35,b+y-9)));
	line(out,{{x+35+20,y-11},{x+35+16,y-11}});
	drawCross(F(out(a+x+35+22,b+y-9-18)));
	line(out,{{x+31,y+7},{x+34,y+7}});
	line(out,{{x+35+22,endYC1},{x+35+22+16,endYC1},{x+35+22+16,y-26}});
	endYC1 = endYC2 = y-5;
	y+=touch_sizeY;
	drawTouchDown(F(out(a+x,b+y)));
	line(out,{{x+35+4,y+2},{x+35+4,y+3},{x+31,y+3}});
	drawCross(F(out(a+x+30,-b+y+25)));
	int endYC3 = y+21;
	int endYC4 = y+27;
	line(out,{{x+28,y+9},{x+28,y+7}});
	y+=touch_sizeY;
	drawNeg(F(out(a+x,b+y)));
	y+=neg_sizeY;
	drawTouchDown(F(out(a+x,b+y)));
	line(out,{{x+30+16,endYC4},{x+30+16,y+3},{x+30,y+3}});
	endYC4 = y+7;
	y+=touch_sizeY;
	line(out,{{x+35+26,endYC1},{x+35+26,y-2}}); // 11
	line(out,{{x+35+22,endYC2},{x+35+22,y-2}}); // 01
	line(out,{{x+35+17,endYC3},{x+35+17,y-2}}); // 00
	line(out,{{x+31,endYC4},{x+31,y-2}}); // 00

}

// Dále budu vytvářet bloky o velikosti 210x210, ze kterých už pak jen složím finální obvod
const int block_size = 210;
void blockGate(func out,vector<bool> type)
{// Blok hradla. Jako vstup bere jeho vstupy pro kombinace vstupů
	for(int i=0;i<block_size;i++)
		for(int j=0;j<block_size;j++)
			out(i,j)='Z';
	drawCoder(F(out(a+10,b+10)));
	line(out,{{1,101},{2,101},{2,2},{28,2},{28,10}});
	line(out,{{1,108},{6,108},{6,6},{21,6},{21,10}});
	line(out,{{101,1},{101,8},{35,8}});
	line(out,{{108,1},{108,30},{10+coder_sizeX+2,30}});

	line(out,{{28,10+coder_sizeY+1},{21,10+coder_sizeY+1},{21,block_size-3},{101,block_size-3},{101,block_size-2},{108,block_size-2}});
	int y=110;
	if(type[3])
		drawCross(F(out(a+120,b+y)));
	else
		line(out,{{121,y+1},{121,y+19}});
	line(out,{{71,10+coder_sizeY+1},{71,y+16},{120-2,y+16}});
	line(out,{{120+1,y+22},{120+16,y+22}});
	y+=24;
	if(type[1])
		drawCross(F(out(a+120,b+y)));
	else
		line(out,{{121,y+1},{121,y+19}});
	line(out,{{67,10+coder_sizeY+1},{67,y+16},{120-2,y+16}});
	line(out,{{120+1,y+22},{120+16,y+22}});
	y+=24;
	if(type[0])
		drawCross(F(out(a+120,b+y)));
	else
		line(out,{{121,y+1},{121,y+19}});
	line(out,{{62,10+coder_sizeY+1},{62,y+16},{120-2,y+16}});
	line(out,{{120+1,y+22},{120+16,y+22}});
	y+=24;
	if(type[2])
		drawCross(F(out(a+120,b+y)));
	else
		line(out,{{121,y+1},{121,y+19}});
	line(out,{{41,10+coder_sizeY+1},{41,y+16},{120-2,y+16}});

	line(out,{{142,y+4},{142,108},{block_size-2,108}});
	line(out,{{120+1,110-2},{136,110-2},{136,101},{block_size-2,101}});
}
void blockCross(func out)
{// Konečně křížení signálů!
	for(int i=0;i<block_size;i++)
		for(int j=0;j<block_size;j++)
			out(i,j)='Z';
	drawCoder(F(out(a+10,b+10)));
	drawCoder(F(out(a+120,-b+200)));
	line(out,{{1,101},{2,101},{2,2},{28,2},{28,10}});
	line(out,{{1,108},{6,108},{6,6},{21,6},{21,10}});
	line(out,{{101,1},{101,8},{35,8}});
	line(out,{{108,1},{108,30},{10+coder_sizeX+2,30}});

	line(out,{{block_size-2,108},{block_size-1-2,108},{block_size-1-2,200+2},{120+25,200+2}});
	line(out,{{block_size-1,101},{block_size-1-8,101},{block_size-1-8,135},{block_size-1-8,200-20},{120+coder_sizeX,200-20}});
	line(out,{{101,block_size-1-1},{101,201},{120+11,201}});
	line(out,{{108,block_size-1-1},{108,block_size-1-2},{120+18,block_size-1-2},{120+18,200+1}});

	line(out,{{120+18,200-coder_sizeY-1},{120-2,200-coder_sizeY-1},{120-2,200-3},{21,200-3},{21,10+coder_sizeY+1},{28,10+coder_sizeY+1}});

	line(out,{{165+11+1,50-3},{165+11+1,50+30-3},{165+11+1,200-coder_sizeY-1}});
	line(out,{{165+18,50+1},{165+18,50+30+1},{165+18-2,50+30+1},{165+18-2,200-coder_sizeY-1}});
	line(out,{{135+18,50+1},{135+18,50+30+1},{135+37,50+30+1},{135+37,200-coder_sizeY-1}});
	line(out,{{135+11,50+1},{135+11,50+30+1},{135+11,50+30+7},{135+16,50+30+7},{135+16,200-coder_sizeY-1}});
	drawNeg(F(out(a+150,b+50-33)));
	line(out,{{135+18,50-2},{150+11,50-2}});
	line(out,{{150+18,50-2},{165+11,50-2}});

	drawNeg(F(out(a+50,b+140)));
	line(out,{{50+11+1,10+coder_sizeY},{50+11+1,140+2}});
	line(out,{{50+18-1,10+coder_sizeY},{50+18-1,140+2}});

	drawCross(F(out(90+a,80+b)));

	line(out,{{50+11,170},{50+11,170+8},{90-2,170+8},{90-2,90}});
	line(out,{{50+18,170+1},{80+4,170+1},{80+4,60+4}});
	line(out,{{10+61,10+coder_sizeY},{80-2,10+coder_sizeY},{80-2,60-2}});
	line(out,{{10+31,10+coder_sizeY},{10+31,185},{90+4,185},{90+4,90+12}});

	line(out,{{80-2,60-2},{113,60-2},{113,3},{165+18,3},{165+18,50}});
	line(out,{{80+5,60+4},{118,60+4},{118,8},{150+18,8},{150+18,50-33}});
	line(out,{{90+10,80-2},{123,80-2},{123,13},{150+11,13},{150+11,50-33}});
	line(out,{{90+20,80+4},{128,80+4},{128,18},{135+11,18},{135+11,50}});
}
void blockSplit(func out)
{// Vynucená rovnost dvou signálů zabalená do bloku
	for(int i=0;i<block_size;i++)
		for(int j=0;j<block_size;j++)
			out(i,j)='Z';
	line(out,{{101,120},{101,block_size-2}});
	line(out,{{108,120},{108,block_size-2}});
	line(out,{{101,1},{101,8},{131,8},{131,110}});
	line(out,{{108,1},{108,2},{138,2},{138,110}});
	line(out,{{1,101},{108,101},{108,110}});
	line(out,{{1,108},{101,108},{101,110}});
	line(out,{{block_size-2,108},{207,108},{207,207},{131,207},{131,120}});
	line(out,{{block_size-2,101},{201,101},{201,201},{138,201},{138,120}});
	drawSplit(F(out(a+90,b+110)));

}
void blockPower(func out,bool a,bool b,bool c,bool d)
{// Blok propojky napájení
	for(int i=0;i<block_size;i++)
		for(int j=0;j<block_size;j++)
			out(i,j)='Z';
	auto tmpF = [](func out){
		line(out,{{101,1},{108,1},{108,104},{104,104}});
	};
	if(a)tmpF(F(out(a,b)));
	if(b)tmpF(F(out(b,block_size-1-a)));
	if(c)tmpF(F(out(block_size-1-a,block_size-1-b)));
	if(d)tmpF(F(out(block_size-1-b,a)));

}
void blockSignal(func out,bool a,bool b,bool c,bool d)
{// Blok propojky signálů
	for(int i=0;i<block_size;i++)
		for(int j=0;j<block_size;j++)
			out(i,j)='Z';
	auto tmpF = [](func out){
		line(out,{{101,1},{101,101}});
		line(out,{{108,1},{108,101}});
		for(int i=0;i<4;i++)
			for(int j=0;j<3;j++)
				out(i+103,j+100) = 'X';
	};
	line(out,{{101,101},{108,101},{108,108},{101,108},{101,101}});
	if(a)tmpF(F(out(a,b)));
	if(b)tmpF(F(out(b,block_size-1-a)));
	if(c)tmpF(F(out(block_size-1-a,block_size-1-b)));
	if(d)tmpF(F(out(block_size-1-b,a)));

}
void blockCrossRev(func out)
{
	blockCross(F(out(a,block_size-1-b)));
}
void blockSplitRev(func out)
{
	blockSplit(F(out(a,block_size-1-b)));
}


void print()
{// Vytiskne data do souboru "out"
	FILE * f = fopen("out","w");
	fprintf(f,"%d %d\n",n,m);
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m;j++)
			fprintf(f,"%c",solveOut[i][j]>0?'!':out[i][j]);
		fprintf(f,"\n");
	}
	fclose(f);
}


int solve(int x,int y,int i,int size)
{// Snaží se vyřešit vygenerovanou mapu randomizovaným algoritmem (rekurzivní funkce)
	if(x<0 || y<0 || x+size>n || y+size>m) return 0;
	for(int p=0;p<size;p++)
	for(int q=0;q<size;q++)
		if(out[x+p][y+q]!='.'|| (solveOut[x+p][y+q]!=i-1 && solveOut[x+p][y+q]>0) ) return 0;
	auto draw = [&](int what){
	for(int p=0;p<size;p++)
	for(int q=0;q<size;q++)
		solveOut[x+p][y+q] = what;
	};
	vector<pair<int,int>> next = {{x+1,y},{x-1,y},{x,y-1},{x,y+1}};
	random_shuffle(next.begin(),next.end());
	if(x+size==n) return -1;
	int maxBack=0;
	for(auto it : next)
	{
		draw(i);
		int out = solve(it.first,it.second,i+1,size);
		maxBack=max(maxBack,out);
		if(out==-1) return -1;
		draw(0);
		if(maxBack > 200) return maxBack+1;

	}
	return maxBack+1;
}
bool solve(int size=3)
{// Celé řešení (1000 krát spustí náhodný algoritmus)
	for(int i=0;i<1000;i++)
	{
		for(int y=0;y<m;y++)
			if(solve(0,y,1,size)==-1) return 1;
		fprintf(stderr,"S %d",i);
	}
	return 0;
}

// Načítání vstupu
struct Gate
{
	int a,b,c;
	vector<bool> type;
};
vector<Gate> gates;
int variables=0;
vector<int> stackNum;
void loadInput(char * in)
{// z stringu parametru pomocí postfixové notace
// proměnné definujeme pomocí čísel od 0
// oddělovat je lze mezerami či operátory:
// & - and
// | - or
// ^ - xor
// = - ekvivalence
// ! - negace
	bool inNum=0;
	int num = 0;
	for(int i=0;;i++)
	{
		if('0'<=in[i] && in[i]<='9')
		{
			inNum=1;
			num=num*10+in[i]-'0';
		}
		else
		{
			if(inNum)
				variables=max(variables,num);
			num=inNum=0;
		}
		if(!in[i]) break;
	}
	variables++;
	for(int i=0;;i++)
	{
		if('0'<=in[i] && in[i]<='9')
		{
			inNum=1;
			num=num*10+in[i]-'0';
		}
		else
		{
			if(inNum)
				stackNum.push_back(num);
			num=inNum=0;
			if(!in[i]) break;
			if(in[i]=='!')
			{
				assert(stackNum.size()>=1);
				int a = *stackNum.rbegin();stackNum.pop_back();
				int c = variables++;stackNum.push_back(c);
				gates.push_back({a,a,c,{1,1,0,0}});
			}
			else
			if(in[i]!=' ')
			{
				assert(stackNum.size()>=2);
				int a = *stackNum.rbegin();stackNum.pop_back();
				int b = *stackNum.rbegin();stackNum.pop_back();
				int c = variables++;stackNum.push_back(c);
				if     (in[i]=='&') gates.push_back({a,b,c,{0,0,0,1}});
				else if(in[i]=='|') gates.push_back({a,b,c,{0,1,1,1}});
				else if(in[i]=='^') gates.push_back({a,b,c,{0,1,1,0}});
				else if(in[i]=='=') gates.push_back({a,b,c,{1,0,0,1}});
				else assert(0);
			}
		}
	}
	assert(stackNum.size()==1);
}

int main(int argc,char ** argv)
{
// parametry:
// [1] vstupní řetězec
// [2] nepovinně semínko pro náhodné číslo generátoru (použito aktuálním časem)
	int sr = time(0)+(argc>2?atoi(argv[2]):0);
	printf("SR: %d\n",sr);
	srand(sr);
	loadInput(argv[1]);
	setSize(block_size*(variables+4),block_size*(2+gates.size()*4));
	for(int i=0;i<(int)gates.size();i++)
	{// generuje sloupce hradel
		for(int j=0;j<variables;j++)
			if(gates[i].a == j)
				blockSplit(F(out[a+block_size*(2+j)][b+block_size*(1+4*i+0)]));
			else
				blockCross(F(out[a+block_size*(2+j)][b+block_size*(1+4*i+0)]));
		for(int j=0;j<variables;j++)
			if(gates[i].b == j)
				blockSplit(F(out[a+block_size*(2+j)][b+block_size*(1+4*i+1)]));
			else
				blockCross(F(out[a+block_size*(2+j)][b+block_size*(1+4*i+1)]));
		for(int j=0;j<variables;j++)
				blockCrossRev(F(out[a+block_size*(2+j)][b+block_size*(1+4*i+2)]));
		for(int j=0;j<variables;j++)
			if(gates[i].c == j)
				blockSplitRev(F(out[a+block_size*(2+j)][b+block_size*(1+4*i+3)]));
			else
				blockCrossRev(F(out[a+block_size*(2+j)][b+block_size*(1+4*i+3)]));
		blockSignal(F(out[a+block_size*(2+variables)][b+block_size*(1+4*i+0)]),0,1,1,0);
		blockSignal(F(out[a+block_size*(2+variables+1)][b+block_size*(1+4*i+1)]),0,1,1,0);
		blockSignal(F(out[a+block_size*(2+variables+1)][b+block_size*(1+4*i+2)]),1,0,1,0);
		blockSignal(F(out[a+block_size*(2+variables+1)][b+block_size*(1+4*i+3)]),1,1,0,0);
		blockSignal(F(out[a+block_size*(2+variables+0)][b+block_size*(1+4*i+3)]),0,1,0,1);
		blockPower(F(out[a+block_size*(2+variables+0)][b+block_size*(1+4*i+2)]),1,1,0,0);
		blockGate(F(out[a+block_size*(2+variables+0)][b+block_size*(1+4*i+1)]),gates[i].type);
		blockPower(F(out[a+block_size*(0)][b+block_size*(1+4*i+0)]),1,0,1,0);
		blockPower(F(out[a+block_size*(0)][b+block_size*(1+4*i+1)]),1,0,0,1);
		blockPower(F(out[a+block_size*(1)][b+block_size*(1+4*i+1)]),0,1,0,1);
		blockPower(F(out[a+block_size*(1)][b+block_size*(1+4*i+2)]),0,1,0,1);
		blockPower(F(out[a+block_size*(0)][b+block_size*(1+4*i+2)]),0,0,1,1);
		blockPower(F(out[a+block_size*(0)][b+block_size*(1+4*i+3)]),1,0,1,0);
		blockPower(F(out[a+block_size*(1)][b+block_size*(1+4*i+0)]),1,0,0,1);
		blockPower(F(out[a+block_size*(1)][b+block_size*(1+4*i+3)]),0,0,1,1);
	}
	for(int i=0;i<variables+2;i++)
	{// napájení okolo
		if(i%2)
		{
			blockPower(F(out[a+block_size*(i)][b+block_size*(0)]),0,0,1,1);
			blockPower(F(out[a+block_size*(i)][b+block_size*(gates.size()*4+1)]),1,1,0,0);
		}
		else
		{
			blockPower(F(out[a+block_size*(i)][b+block_size*(0)]),0,1,1,0);
			blockPower(F(out[a+block_size*(i)][b+block_size*(gates.size()*4+1)]),1,0,0,1);
		}
	}
	if(variables%2)
	{
		blockPower(F(out[a+block_size*(2+variables+1)][b+block_size*(1+4*gates.size())]),0,1,0,1);
		blockPower(F(out[a+block_size*(2+variables)][b+block_size*(1+4*gates.size())]),0,1,0,1);
	}
	else
	{
		blockPower(F(out[a+block_size*(2+variables+1)][b+block_size*(0)]),0,1,0,1);
		blockPower(F(out[a+block_size*(2+variables)][b+block_size*(0)]),0,1,0,1);
	}
	out[block_size*(2+stackNum[0])+108][block_size*4*gates.size()+block_size-1]='Z';
	// uzavře LED

	print();// vytiskne výstup do souboru "out"
	if(solve(3))
	{
		printf("OK!!!!!!!!!!!!!\n");
		print();// a když najde řešení tak ještě jednou
	}
	return 0;
}