import java.util.*;
import java.io.*;

public class Lukas {
  static Kattio io = new Kattio(System.in, System.out);

  public static void main(String args[]) {
    int n = io.getInt();
    int m = io.getInt();

    int s = 1 << m;
    int[] distance = new int[s];
    Arrays.fill(distance, s);
    Queue<Integer> q = new ArrayDeque<Integer>();

    for (int i = 0; i < n; i++) {
      int num = Integer.parseInt(io.getWord(), 2);
      distance[num] = 0;
      q.add(num);
    }

    int last = 0;
    while (!q.isEmpty()) {
      int cur = q.remove();
      last = cur;
      for (int i = 0; i < m; i++) {
        int bit = 1 << i;
        if (distance[cur ^ bit] == s) {
          distance[cur ^ bit] = distance[cur] + 1;
          q.add(cur ^ bit);
        }
      }
    }

    String res = Integer.toBinaryString(last);
    String format = String.format("%%%ds", m);
    System.out.println(String.format(format, res).replace(' ', '0'));
  }
}

/** Simple yet moderately fast I/O routines.
 *
 * Example usage:
 *
 * Kattio io = new Kattio(System.in, System.out);
 *
 * while (io.hasMoreTokens()) {
 *    int n = io.getInt();
 *    double d = io.getDouble();
 *    double ans = d*n;
 *
 *    io.println("Answer: " + ans);
 * }
 *
 * io.close();
 *
 *
 * Some notes:
 *
 * - When done, you should always do io.close() or io.flush() on the
 *   Kattio-instance, otherwise, you may lose output.
 *
 * - The getInt(), getDouble(), and getLong() methods will throw an
 *   exception if there is no more data in the input, so it is generally
 *   a good idea to use hasMoreTokens() to check for end-of-file.
 *
 * @author: Kattis
 */

class Kattio extends PrintWriter {
  public Kattio(InputStream i) {
    super(new BufferedOutputStream(System.out));
    r = new BufferedReader(new InputStreamReader(i));
  }
  public Kattio(InputStream i, OutputStream o) {
    super(new BufferedOutputStream(o));
    r = new BufferedReader(new InputStreamReader(i));
  }

  public boolean hasMoreTokens() {
    return peekToken() != null;
  }

  public int getInt() {
    return Integer.parseInt(nextToken());
  }

  public double getDouble() {
    return Double.parseDouble(nextToken());
  }

  public long getLong() {
    return Long.parseLong(nextToken());
  }

  public String getWord() {
    return nextToken();
  }

  private BufferedReader r;
  private String line;
  private StringTokenizer st;
  private String token;

  private String peekToken() {
    if (token == null)
      try {
        while (st == null || !st.hasMoreTokens()) {
          line = r.readLine();
          if (line == null) return null;
          st = new StringTokenizer(line);
        }
        token = st.nextToken();
      } catch (IOException e) { }
    return token;
  }

  private String nextToken() {
    String ans = peekToken();
    token = null;
    return ans;
  }
}