You are given an undirected graph without self-loops or multiple edges which consists of n vertices and m edges. Also you are given three integers n_1, n_2 and n_3.

Can you label each vertex with one of three numbers 1, 2 or 3 in such way, that: 

  1. Each vertex should be labeled by exactly one number 1, 2 or 3; 
  2. The total number of vertices with label 1 should be equal to n_1; 
  3. The total number of vertices with label 2 should be equal to n_2; 
  4. The total number of vertices with label 3 should be equal to n_3; 
  5. |col_u - col_v| = 1 for each edge (u, v), where col_x is the label of vertex x. 



If there are multiple valid labelings, print any of them.

Input

The first line contains two integers n and m (1 ≤ n ≤ 5000; 0 ≤ m ≤ 10^5) — the number of vertices and edges in the graph.

The second line contains three integers n_1, n_2 and n_3 (0 ≤ n_1, n_2, n_3 ≤ n) — the number of labels 1, 2 and 3, respectively. It's guaranteed that n_1 + n_2 + n_3 = n.

Next m lines contan description of edges: the i-th line contains two integers u_i, v_i (1 ≤ u_i, v_i ≤ n; u_i ≠ v_i) — the vertices the i-th edge connects. It's guaranteed that the graph doesn't contain self-loops or multiple edges.

Output

If valid labeling exists then print "YES" (without quotes) in the first line. In the second line print string of length n consisting of 1, 2 and 3. The i-th letter should be equal to the label of the i-th vertex.

If there is no valid labeling, print "NO" (without quotes).

Examples

Input


6 3
2 2 2
3 1
5 4
2 5


Output


YES
112323


Input


5 9
0 2 3
1 2
1 3
1 5
2 3
2 4
2 5
3 4
3 5
4 5


Output


NO
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Mufaddal Naya
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        EGraphColoring solver = new EGraphColoring();
        solver.solve(1, in, out);
        out.close();
    }

    static class EGraphColoring {
        ArrayList<Integer>[] adj;
        HashSet<Integer>[] bip;
        int[] clr;
        boolean ok = true;

        public void solve(int testNumber, InputReader c, OutputWriter w) {
            int n = c.readInt(), m = c.readInt();
            int n1 = c.readInt(), n2 = c.readInt(), n3 = c.readInt();
            adj = c.readGraph(n, m);
            ArrayList<HashSet<Integer>> cmp[] = new ArrayList[2];
            cmp[0] = new ArrayList<>();
            cmp[1] = new ArrayList<>();
            clr = new int[n];
            Arrays.fill(clr, -1);
            ArrayList<Pair<Integer, Integer>> pp = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                if (clr[i] == -1) {
                    bip = new HashSet[2];
                    bip[0] = new HashSet<>();
                    bip[1] = new HashSet<>();
                    clr[i] = 0;
                    dfs(i);
                    if (ok) {
                        pp.add(new Pair<>(bip[0].size(), bip[1].size()));
                        cmp[0].add(bip[0]);
                        cmp[1].add(bip[1]);
                    } else {
                        w.printLine("NO");
                        return;
                    }
                }
            }

            int k = pp.size();
            boolean dp[][] = new boolean[k + 1][n2 + 1];
            dp[0][0] = true;

            for (int i = 1; i <= k; i++) {
                int t = pp.get(i - 1).first, q = pp.get(i - 1).second;
                for (int j = t; j <= n2; j++) {
                    dp[i][j] = dp[i - 1][j - t];
                }
                for (int j = q; j <= n2; j++) {
                    dp[i][j] = dp[i][j] | dp[i - 1][j - q];
                }
            }
            if (!dp[k][n2]) {
                w.printLine("NO");
                return;
            }

            int res[] = new int[k + 1];
            int j = n2;
            for (int i = k; i > 0; i--) {
                int t = pp.get(i - 1).first, q = pp.get(i - 1).second;
                if (j - t >= 0 && dp[i - 1][j - t]) {
                    res[i] = 0;
                    j = j - t;
                } else {
                    res[i] = 1;
                    j = j - q;
                }
            }
            char ans[] = new char[n];
            for (int i = 1; i <= k; i++) {
                for (int xx : cmp[res[i]].get(i - 1)) {
                    ans[xx] = '2';
                }
            }
            for (int i = 0; i < n; i++) {
                if (ans[i] != '2') {
                    if (n1 > 0) {
                        ans[i] = '1';
                        n1--;
                    } else {
                        ans[i] = '3';
                    }
                }
            }
            w.printLine("YES");
            w.printLine(new String(ans));

        }

        private void dfs(int v) {
            bip[clr[v]].add(v);
            for (int u : adj[v]) {
                if (clr[u] == -1) {
                    clr[u] = clr[v] ^ 1;
                    dfs(u);
                } else if (clr[u] == clr[v]) {
                    ok = false;
                }
            }
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public ArrayList<Integer>[] readGraph(int n, int m) {
            ArrayList<Integer>[] adj = new ArrayList[n];
            for (int i = 0; i < n; i++) {
                adj[i] = new ArrayList<>();
            }
            for (int i = 0; i < m; i++) {
                int u = readInt() - 1, v = readInt() - 1;
                adj[u].add(v);
                adj[v].add(u);
            }
            return adj;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void printLine(Object... objects) {
            print(objects);
            writer.println();
        }

        public void close() {
            writer.close();
        }

    }

    static class Pair<U, V> implements Comparable<Pair<U, V>> {
        public final U first;
        public final V second;

        public Pair(U first, V second) {
            this.first = first;
            this.second = second;
        }

        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }

            Pair pair = (Pair) o;

            return !(first != null ? !first.equals(pair.first) : pair.first != null) &&
                    !(second != null ? !second.equals(pair.second) : pair.second != null);
        }

        public int hashCode() {
            int result = first != null ? first.hashCode() : 0;
            result = 31 * result + (second != null ? second.hashCode() : 0);
            return result;
        }

        public String toString() {
            return "(" + first + "," + second + ")";
        }

        public int compareTo(Pair<U, V> o) {
            int value = ((Comparable<U>) first).compareTo(o.first);
            if (value != 0) {
                return value;
            }
            return ((Comparable<V>) second).compareTo(o.second);
        }

    }
}

