#include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using ulint = unsigned long long int;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
struct fast_ios {
  fast_ios() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(20);
  };
} fast_ios_;
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
  for (auto &v : vec) is >> v;
  return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
  os << "[";
  for (auto v : vec) os << v << ",";
  os << "]";
  return os;
}
template <typename T>
ostream &operator<<(ostream &os, const deque<T> &vec) {
  os << "deq[";
  for (auto v : vec) os << v << ",";
  os << "]";
  return os;
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &vec) {
  os << "{";
  for (auto v : vec) os << v << ",";
  os << "}";
  return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_set<T> &vec) {
  os << "{";
  for (auto v : vec) os << v << ",";
  os << "}";
  return os;
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &vec) {
  os << "{";
  for (auto v : vec) os << v << ",";
  os << "}";
  return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_multiset<T> &vec) {
  os << "{";
  for (auto v : vec) os << v << ",";
  os << "}";
  return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &pa) {
  os << "(" << pa.first << "," << pa.second << ")";
  return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const map<TK, TV> &mp) {
  os << "{";
  for (auto v : mp) os << v.first << "=>" << v.second << ",";
  os << "}";
  return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const unordered_map<TK, TV> &mp) {
  os << "{";
  for (auto v : mp) os << v.first << "=>" << v.second << ",";
  os << "}";
  return os;
}
template <typename T>
void ndarray(vector<T> &vec, int len) {
  vec.resize(len);
}
template <typename T, typename... Args>
void ndarray(vector<T> &vec, int len, Args... args) {
  vec.resize(len);
  for (auto &v : vec) ndarray(v, args...);
}
template <typename T>
bool mjjj(T &m, const T q) {
  if (m < q) {
    m = q;
    return true;
  } else
    return false;
}
template <typename T>
bool mmin(T &m, const T q) {
  if (m > q) {
    m = q;
    return true;
  } else
    return false;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) {
  return make_pair(l.first + r.first, l.second + r.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) {
  return make_pair(l.first - r.first, l.second - r.second);
}
template <typename T>
struct edge {
  int src, to;
  T cost;
  edge(int to, T cost) : src(-1), to(to), cost(cost) {}
  edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}
  edge &operator=(const int &x) {
    to = x;
    return *this;
  }
  operator int() const { return to; }
};
template <typename T>
using Edges = vector<edge<T>>;
template <typename T>
using WeightedGraph = vector<Edges<T>>;
using UnWeightedGraph = vector<vector<lint>>;
template <typename T>
using Matrix = vector<vector<T>>;
using P = pair<lint, lint>;
lint V;
vector<edge<lint>> G[100000];
lint d[100000];
const lint mod = 1000000007;
struct mint {
  lint x;
  mint(lint x = 0) : x((x % mod + mod) % mod) {}
  mint &operator+=(const mint a) {
    if ((x += a.x) >= mod) x -= mod;
    return *this;
  }
  mint &operator-=(const mint a) {
    if ((x += mod - a.x) >= mod) x -= mod;
    return *this;
  }
  mint &operator*=(const mint a) {
    (x *= a.x) %= mod;
    return *this;
  }
  mint operator+(const mint a) const {
    mint res(*this);
    return res += a;
  }
  mint operator-(const mint a) const {
    mint res(*this);
    return res -= a;
  }
  mint operator*(const mint a) const {
    mint res(*this);
    return res *= a;
  }
  mint pow(lint t) const {
    if (!t) return 1;
    mint a = pow(t >> 1);
    a *= a;
    if (t & 1) a *= *this;
    return a;
  }
  mint inv() const { return pow(mod - 2); }
  mint &operator/=(const mint a) { return (*this) *= a.inv(); }
  mint operator/(const mint a) const {
    mint res(*this);
    return res /= a;
  }
};
map<lint, lint> prime_factor(lint n) {
  map<lint, lint> ret;
  for (lint i = 2; i * i <= n; i++) {
    while (n % i == 0) {
      ret[i]++;
      n /= i;
    }
  }
  if (n != 1) ret[n] = 1;
  return ret;
}
lint MAX = 1000000000;
vector<lint> co;
bool dfs(lint from, lint to, lint par = -1) {
  if (from == to) {
    return true;
  }
  for (edge<lint> v : G[from]) {
    if (v.to == par) continue;
    if (dfs(v.to, to, from)) {
      co.push_back(v.cost);
      return true;
    }
  }
  return false;
}
lint digit(lint a, lint b) {
  lint ad = 1, bd = 1;
  while (a > 9) {
    ad++;
    a /= 10;
  }
  while (b > 9) {
    bd++;
    b /= 10;
  }
  return max(ad, bd);
}
int main() {
  int n, m;
  cin >> n >> m;
  vector<int> s(n);
  for (int i = (0), i_end_ = (n); i < i_end_; i++) {
    s[i] = -1;
  }
  for (int i = (0), i_end_ = (m); i < i_end_; i++) {
    int ss, cc;
    cin >> ss >> cc;
    ss--;
    if (s[ss] != -1 && s[ss] != cc) {
      cout << -1;
      return 0;
    }
    if (ss == 0 && cc == 0 && n > 1) {
      cout << -1;
      return 0;
    }
    s[ss + 3 - n] = cc;
  }
  if (m == 0) {
    int ans = 1;
    for (int i = (0), i_end_ = (n - 1); i < i_end_; i++) {
      ans *= 10;
    }
    if (ans == 1) ans--;
    cout << ans;
    return 0;
  } else {
    int dig0 = 0, dig1 = 0, dig2 = 0;
    if (s[0] != -1) dig0 = s[0] * 100;
    if (s[1] != -1) {
      dig1 = s[1] * 10;
    } else {
      dig1 = 0;
    };
    if (s[2] != -1) dig2 = s[2];
    if (n == 1) {
      cout << dig2;
      return 0;
    }
    if (n == 2) {
      if (dig1 == 0) dig1 = 10;
      cout << dig1 + dig2;
      return 0;
    }
    if (n == 3) {
      if (dig0 == 0) dig0 = 100;
      cout << dig0 + dig1 + dig2;
      return 0;
    }
  }
}
lint gcd(lint a, lint b) {
  if (a < b) {
    a ^= b;
    b ^= a;
    a ^= b;
  }
  return b ? gcd(b, a % b) : a;
}
lint lcm(lint a, lint b) { return a * b / gcd(a, b); }
