#include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 60;
const double DINF = 1e30;
const long long mod = 1000000007;
const long long dx[4] = {1, 0, -1, 0};
const long long dy[4] = {0, -1, 0, 1};
const complex<double> I = complex<double>(0, 1);
const double EPS = 1e-10;
const long long NCK_MAX = 510000;
long long gcd(long long a, long long b) {
  if (b == 0) return a;
  return gcd(b, a % b);
}
long long extgcd(long long a, long long b, long long& x, long long& y) {
  if (b == 0) {
    x = 1, y = 0;
    return a;
  }
  long long q = a / b, g = extgcd(b, a - q * b, x, y);
  long long z = x - q * y;
  x = y;
  y = z;
  return g;
}
long long invmod(long long a, long long m) {
  long long x, y;
  extgcd(a, m, x, y);
  x %= m;
  if (x < 0) x += m;
  return x;
}
long long *fac, *finv, *inv;
void nCk_init(long long mod) {
  fac = new long long[NCK_MAX];
  finv = new long long[NCK_MAX];
  inv = new long long[NCK_MAX];
  fac[0] = fac[1] = 1;
  finv[0] = finv[1] = 1;
  inv[1] = 1;
  for (long long i = 2; i < NCK_MAX; i++) {
    fac[i] = fac[i - 1] * i % mod;
    inv[i] = mod - inv[mod % i] * (mod / i) % mod;
    finv[i] = finv[i - 1] * inv[i] % mod;
  }
}
long long nCk(long long n, long long k, long long mod) {
  if (fac == NULL) nCk_init(mod);
  if (n < k) return 0;
  if (n < 0 || k < 0) return 0;
  return fac[n] * (finv[k] * finv[n - k] % mod) % mod;
}
template <typename T>
class Zip {
  vector<T> d;
  bool flag;
  void init() {
    sort(d.begin(), d.end());
    d.erase(unique(d.begin(), d.end()), d.end());
    flag = false;
  }

 public:
  Zip() { flag = false; }
  void add(T x) {
    d.push_back(x);
    flag = true;
  }
  long long getNum(T x) {
    if (flag) init();
    return lower_bound(d.begin(), d.end(), x) - d.begin();
  }
  long long size() {
    if (flag) init();
    return (long long)d.size();
  }
};
class UnionFind {
  vector<long long> par, rank;

 public:
  UnionFind(long long n) : par(n, 1), rank(n, 0) {}
  long long getSize(long long x) { return par[find(x)]; }
  long long find(long long x) {
    if (par[x] > 0) return x;
    return -(par[x] = -find(-par[x]));
  }
  void merge(long long x, long long y) {
    x = find(x);
    y = find(y);
    if (x == y) return;
    if (rank[x] < rank[y]) {
      par[y] += par[x];
      par[x] = -y;
    } else {
      par[x] += par[y];
      par[y] = -x;
      if (rank[x] == rank[y]) rank[x]++;
    }
  }
  bool isSame(long long x, long long y) { return find(x) == find(y); }
};
template <typename T>
class SegmentTree {
  long long n;
  vector<T> node;
  function<T(T, T)> fun, fun2;
  bool customChange;
  T outValue, initValue;

 public:
  void init(long long num, function<T(T, T)> resultFunction, T init, T out,
            function<T(T, T)> changeFunction = NULL) {
    fun = resultFunction;
    fun2 = changeFunction;
    customChange = changeFunction != NULL;
    n = 1;
    while (n < num) n *= 2;
    node.resize(2 * n - 1);
    fill(node.begin(), node.end(), init);
    outValue = out;
    initValue = init;
  }
  void valueChange(long long num, T value) {
    num += n - 1;
    if (customChange)
      node[num] = fun2(value, node[num]);
    else
      node[num] = value;
    while (num > 0)
      num = (num - 1) / 2,
      node[num] = fun(node[num * 2 + 1], node[num * 2 + 2]);
  }
  T rangeQuery(long long a, long long b, long long l = 0, long long r = -1,
               long long k = 0) {
    if (r == -1) r = n;
    if (a <= l && r <= b) return node[k];
    if (b <= l || r <= a) return outValue;
    long long mid = (l + r) / 2;
    return fun(rangeQuery(a, b, l, mid, 2 * k + 1),
               rangeQuery(a, b, mid, r, 2 * k + 2));
  }
};
template <typename T>
class Graph {
  struct edge {
    long long to;
    T cost;
  };
  struct edge_data {
    long long from, to;
    T cost;
  };
  long long v;
  vector<vector<edge>> e, re;
  vector<edge_data> ed;
  vector<bool> used;
  vector<long long> vs, cmp;
  bool isDirected, isMinasEdge;

 public:
  Graph(long long _v, bool _isDirected = true, long long range_add = 0) {
    v = _v, isDirected = _isDirected;
    isMinasEdge = false;
    e.resize(v), re.resize(v);
  }
  void add_edge(long long s, long long t, T cost = 1) {
    e[s].push_back((edge){t, cost});
    if (!isDirected)
      e[t].push_back((edge){s, cost});
    else
      re[t].push_back((edge){s, cost});
    ed.push_back((edge_data){s, t, cost});
    if (cost < 0) isMinasEdge = true;
  }
  vector<T> dijkstra(long long s) {
    vector<T> d(v, INF);
    d[s] = 0;
    auto edge_cmp = [](const edge& a, const edge& b) {
      return a.cost > b.cost;
    };
    priority_queue<edge, vector<edge>, decltype(edge_cmp)> pq(edge_cmp);
    pq.push((edge){s, 0});
    while (!pq.empty()) {
      edge temp = pq.top();
      pq.pop();
      if (d[temp.to] < temp.cost) continue;
      for (const edge& next : e[temp.to]) {
        T cost = temp.cost + next.cost;
        if (d[next.to] > cost) {
          d[next.to] = cost;
          pq.push((edge){next.to, cost});
        }
      }
    }
    return d;
  }
  vector<T> bellmanford(long long s) {
    vector<T> d(v, INF);
    d[s] = 0;
    for (long long i = 0; i < v; i++) {
      for (const edge_data& temp : ed) {
        if (d[temp.from] != INF && d[temp.to] > d[temp.from] + temp.cost)
          d[temp.to] = d[temp.from] + temp.cost;
        if (!isDirected && d[temp.to] != INF &&
            d[temp.from] > d[temp.to] + temp.cost)
          d[temp.from] = d[temp.to] + temp.cost;
      }
    }
    for (long long i = 0; i < v; i++) {
      for (const edge_data& temp : ed) {
        if (d[temp.from] != INF && d[temp.to] > d[temp.from] + temp.cost)
          d[temp.to] = -INF;
        if (!isDirected && d[temp.to] != INF &&
            d[temp.from] > d[temp.to] + temp.cost)
          d[temp.from] = -INF;
      }
    }
    return d;
  }
  vector<T> shortest_path(long long s) {
    if (isMinasEdge)
      return bellmanford(s);
    else
      return dijkstra(s);
  }
  T kruskal() {
    UnionFind uf(v);
    auto edge_data_cmp = [](const edge_data& a, const edge_data& b) {
      return a.cost < b.cost;
    };
    sort(ed.begin(), ed.end(), edge_data_cmp);
    T ans = 0;
    for (const edge_data& temp : ed) {
      if (uf.isSame(temp.from, temp.to)) continue;
      uf.merge(temp.from, temp.to);
      ans += temp.cost;
    }
    return ans;
  }
  void scc_dfs(long long s) {
    used[s] = true;
    for (const edge& i : e[s])
      if (!used[i.to]) scc_dfs(i.to);
    vs.push_back(s);
  }
  void scc_rdfs(long long s, long long k) {
    used[s] = true;
    cmp[s] = k;
    for (const edge& i : re[s])
      if (!used[i.to]) scc_rdfs(i.to, k);
  }
  vector<long long> scc() {
    used.resize(v);
    fill(used.begin(), used.end(), false);
    cmp.resize(v);
    vs.clear();
    for (long long i = 0; i < v; i++)
      if (!used[i]) scc_dfs(i);
    used.resize(v);
    fill(used.begin(), used.end(), false);
    long long k = 0;
    for (long long i = vs.size() - 1; i >= 0; i--)
      if (!used[vs[i]]) scc_rdfs(vs[i], k++);
    return cmp;
  }
};
long long n, m, s, c, d[3];
int main() {
  scanf("%lld%lld", &n, &m);
  for (long long i = 0; i < n; i++) d[i] = -1;
  for (long long i = 0; i < m; i++) {
    scanf("%lld%lld", &s, &c);
    if (d[s - 1] != -1 && d[s - 1] != c) {
      printf("-1\n");
      return 0;
    }
    d[s - 1] = c;
  }
  if (n == 1) {
    printf("%lld\n", d[0]);
    return 0;
  }
  if (d[0] == 0) {
    printf("-1\n");
    return 0;
  }
  for (long long i = 0; i < n; i++) {
    if (i == 0 && d[i] == -1)
      printf("1");
    else if (d[i] == -1)
      printf("0");
    else
      printf("%lld", d[i]);
  }
  printf("\n");
}
