source_code: import java.io.*;
  import java.util.*;
  
  public class B {
  
      void solve() throws IOException {
          in = new InputReader("__std");
          out = new OutputWriter("__std");
  
          int n = in.readInt();
          int a = in.readInt();
          int b = in.readInt();
          int ma = 0;
          int mb = 1;
          if (a < b) {
              int t = a; a = b; b = t;
              t = ma; ma = mb; mb = t;
          }
          final int[] p = new int[n];
          Integer id[] = new Integer[n];
          Map<Integer, Integer> pos = new HashMap<Integer, Integer>();
          for (int i = 0; i < n; ++i) {
              p[i] = in.readInt();
              id[i] = i;
              pos.put(p[i], i);
          }
          Arrays.sort(id, new Comparator<Integer>() {
              public int compare(Integer i, Integer j) {
                  return p[i] - p[j];
              }
          });
          int[] mask = new int[n];
          Arrays.fill(mask, -1);
          boolean flag = true;
          for (int i = 0; i < n && flag; ++i) {
              if (mask[id[i]] == -1) {
                  if (p[id[i]] < a) {
                      if (pos.containsKey(a - p[id[i]])) {
                          int j = pos.get(a - p[id[i]]);
                          if (mask[j] != mb) {
                              mask[id[i]] = mask[j] = ma;
                              continue;
                          }
                      }
                      if (p[id[i]] < b && pos.containsKey(b - p[id[i]])) {
                          int j = pos.get(b - p[id[i]]);
                          if (mask[j] != ma) {
                              mask[id[i]] = mask[j] = mb;
                              continue;
                          }
                      }
                  }
                  flag = false;
              }
          }
          if (flag) {
              out.println("YES");
              for (int m : mask) {
                  out.print(m + " ");
              }
          } else {
              out.println("NO");
          }
  
          exit();
      }
  
      void exit() {
          //System.err.println((System.currentTimeMillis() - startTime) + " ms");
          out.close();
          System.exit(0);
      }
  
      InputReader in;
      OutputWriter out;
  
      //long startTime = System.currentTimeMillis();
  
      public static void main(String[] args) throws IOException {
          new B().solve();
      }
  
      class InputReader {
  
          private InputStream stream;
  
          private byte[] buffer = new byte[1024];
          private int pos, len;
  
          private int cur;
  
          private StringBuilder sb = new StringBuilder(32);
  
          InputReader(String name) throws IOException {
              if (name.equals("__std")) {
                  stream = System.in;
              } else {
                  stream = new FileInputStream(name);
              }
              cur = read();
          }
  
          private int read() throws IOException {
              if (len == -1) {
                  throw new EOFException();
              }
              if (pos >= len) {
                  pos = 0;
                  len = stream.read(buffer);
                  if (len == -1) return -1;
              }
              return buffer[pos++];
          }
  
          char readChar() throws IOException {
              if (cur == -1) {
                  throw new EOFException();
              }
              char res = (char) cur;
              cur = read();
              return res;
          }
  
          int readInt() throws IOException {
              if (cur == -1) {
                  throw new EOFException();
              }
              while (whitespace()) {
                  cur = read();
              }
              if (cur == -1) {
                  throw new EOFException();
              }
              int sign = 1;
              if (cur == '-') {
                  sign = -1;
                  cur = read();
              }
              int res = 0;
              while (!whitespace()) {
                  if (cur < '0' || cur > '9') {
                      throw new NumberFormatException();
                  }
                  res *= 10;
                  res += cur - '0';
                  cur = read();
              }
              return res * sign;
          }
  
          long readLong() throws IOException {
              if (cur == -1) {
                  throw new EOFException();
              }
              return Long.parseLong(readToken());
          }
  
          double readDouble() throws IOException {
              if (cur == -1) {
                  throw new EOFException();
              }
              return Double.parseDouble(readToken());
          }
  
          String readLine() throws IOException {
              if (cur == -1) {
                  throw new EOFException();
              }
              sb.setLength(0);
              while (cur != -1 && cur != '\r' && cur != '\n') {
                  sb.append((char) cur);
                  cur = read();
              }
              if (cur == '\r') {
                  cur = read();
              }
              if (cur == '\n') {
                  cur = read();
              }
              return sb.toString();
          }
  
          String readToken() throws IOException {
              if (cur == -1) {
                  throw new EOFException();
              }
              while (whitespace()) {
                  cur = read();
              }
              if (cur == -1) {
                  throw new EOFException();
              }
              sb.setLength(0);
              while (!whitespace()) {
                  sb.append((char) cur);
                  cur = read();
              }
              return sb.toString();
          }
  
          boolean whitespace() {
              return cur == ' ' || cur == '\t' || cur == '\r' || cur == '\n' || cur == -1;
          }
  
          boolean eof() {
              return cur == -1;
          }
      }
  
      class OutputWriter {
  
          private PrintWriter writer;
  
          OutputWriter(String name) throws IOException {
              if (name.equals("__std")) {
                  writer = new PrintWriter(System.out);
              } else {
                  writer = new PrintWriter(name);
              }
          }
  
          void print(String format, Object ... args) {
              writer.print(new Formatter(Locale.US).format(format, args));
          }
  
          void println(String format, Object ... args) {
              writer.println(new Formatter(Locale.US).format(format, args));
          }
  
          void print(Object value) {
              writer.print(value);
          }
  
          void println(Object value) {
              writer.println(value);
          }
  
          void println() {
              writer.println();
          }
  
          void close() {
              writer.close();
          }
      }
  }
  