import std.conv, std.functional, std.range, std.stdio, std.string; import std.algorithm, std.array, std.bigint, std.bitmanip, std.complex, std.container, std.math, std.mathspecial, std.numeric, std.regex, std.typecons; import core.bitop; class EOFException : Throwable { this() { super("EOF"); } } string[] tokens; string readToken() { for (; tokens.empty; ) { if (stdin.eof) { throw new EOFException; } tokens = readln.split; } auto token = tokens.front; tokens.popFront; return token; } int readInt() { return readToken.to!int; } long readLong() { return readToken.to!long; } real readReal() { return readToken.to!real; } bool chmin(T)(ref T t, in T f) { if (t > f) { t = f; return true; } else { return false; } } bool chmax(T)(ref T t, in T f) { if (t < f) { t = f; return true; } else { return false; } } int binarySearch(alias pred, T)(in T[] as) { int lo = -1, hi = cast(int)(as.length); for (; lo + 1 < hi; ) { const mid = (lo + hi) >> 1; (unaryFun!pred(as[mid]) ? hi : lo) = mid; } return hi; } int lowerBound(T)(in T[] as, T val) { return as.binarySearch!(a => (a >= val)); } int upperBound(T)(in T[] as, T val) { return as.binarySearch!(a => (a > val)); } class MaxFlow(Capa) { enum Capa wEPS = 0; enum Capa wINF = 10^^9; int n, m; int[][] g; int[] zu; Capa[] capa; Capa tof; int[] lev, see, que; this(int n) { this.n = n; m = 0; g = new int[][n]; zu = []; capa = []; lev = new int[n]; see = new int[n]; que = new int[n]; } void addEdge(int u, int v, Capa w0, Capa w1 = 0) { g[u] ~= m; zu ~= v; capa ~= w0; ++m; g[v] ~= m; zu ~= u; capa ~= w1; ++m; } Capa augment(int src, int ink, Capa flo) { if (src == ink) return flo; foreach (i; g[src][see[src] .. $]) { if (capa[i] > wEPS && lev[src] < lev[zu[i]]) { Capa f = augment(zu[i], ink, min(flo, capa[i])); if (f > wEPS) { capa[i] -= f; capa[i ^ 1] += f; return f; } } ++see[src]; } return 0; } bool dinic(int src, int ink, Capa flo = wINF) { for (tof = 0; tof + wEPS < flo; ) { int qb, qe; lev[] = -1; dinicBFS: for (lev[src] = 0, que[qe++] = src; qb != qe; ) { const u = que[qb++]; foreach (i; g[u]) { const v = zu[i]; if (capa[i] > wEPS && lev[v] == -1) { lev[v] = lev[u] + 1; que[qe++] = v; if (v == ink) break dinicBFS; } } } if (lev[ink] == -1) return false; see[] = 0; for (; ; ) { Capa f = augment(src, ink, flo - tof); if (f <= wEPS) break; tof += f; } } return true; } } int H, W; int[] A, B; int K; int[] X, Y; char[][] solve() { auto ans = new char[][](H, W); foreach (x; 0 .. H) { ans[x][] = '.'; } auto axs = new Tuple!(int, int)[H]; foreach (x; 0 .. H) { axs[x] = tuple(A[x], x); } axs.sort; auto bs = B.dup; foreach_reverse (ax; axs) { const x = ax[1]; auto yss = new int[][H + 1]; foreach (y; 0 .. W) { yss[bs[y]] ~= y; } int a = A[x]; foreach_reverse (b; 1 .. H + 1) { foreach (y; yss[b]) { if (a > 0) { ans[x][y] = 'o'; --a; --bs[y]; } } } if (a != 0) { return null; } } if (!bs.all!"a == 0") { return null; } debug { writeln("ans = ", ans); } auto mf = new MaxFlow!(int)(2 + H + W); auto ex = new int[2 + H + W]; auto ids = new int[][](H, W); foreach (k; 0 .. K) { if (ans[X[k]][Y[k]] == 'o') { ex[2 + X[k]] += 1; ex[2 + H + Y[k]] -= 1; } ids[X[k]][Y[k]] = -1; ans[X[k]][Y[k]] = 'x'; } foreach (x; 0 .. H) foreach (y; 0 .. W) { if (ans[x][y] != 'x') { ids[x][y] = mf.m; if (ans[x][y] == 'o') { mf.addEdge(2 + H + y, 2 + x, 1); } else { mf.addEdge(2 + x, 2 + H + y, 1); } } } int flow; foreach (u; 2 .. 2 + H + W) { if (ex[u] > 0) { flow += ex[u]; mf.addEdge(0, u, ex[u]); } else if (ex[u] < 0) { mf.addEdge(u, 1, -ex[u]); } } const res = mf.dinic(0, 1, flow); if (!res) { return null; } foreach (x; 0 .. H) foreach (y; 0 .. W) { if (ans[x][y] != 'x') { if (mf.capa[ids[x][y]] == 0) { ans[x][y] ^= '.' ^ 'o'; } } } return ans; } void main() { try { for (; ; ) { H = readInt(); W = readInt(); A = new int[H]; foreach (x; 0 .. H) { A[x] = readInt(); } B = new int[W]; foreach (y; 0 .. W) { B[y] = readInt(); } K = readInt(); X = new int[K]; Y = new int[K]; foreach (k; 0 .. K) { X[k] = readInt() - 1; Y[k] = readInt() - 1; } const ans = solve(); if (ans) { writeln("Yay!"); foreach (x; 0 .. H) { writeln(ans[x]); } } else { writeln(":("); } } } catch (EOFException e) { } }