Chilly Willy loves playing with numbers. He only knows prime numbers that are digits yet. These numbers are 2, 3, 5 and 7. But Willy grew rather bored of such numbers, so he came up with a few games that were connected with them.

Chilly Willy wants to find the minimum number of length n, such that it is simultaneously divisible by all numbers Willy already knows (2, 3, 5 and 7). Help him with that.

A number's length is the number of digits in its decimal representation without leading zeros.

Input

A single input line contains a single integer n (1 ≤ n ≤ 105).

Output

Print a single integer — the answer to the problem without leading zeroes, or "-1" (without the quotes), if the number that meet the problem condition does not exist.

Examples

Input

1


Output

-1


Input

5


Output

10080
#include <bits/stdc++.h>
using namespace std;
float PHI = 1.6180339;
const float PI_F = 3.14159265358979f;
long long modpow(long long x, long long n, long long m) {
  if (n == 0) return 1 % m;
  long long u = modpow(x, n / 2, m);
  u = (u * u) % m;
  if (n % 2 == 1) u = (u * x) % m;
  return u;
}
long long add(long long x, long long y) {
  x += y;
  if (x >= 1000000007) return x - 1000000007;
  return x;
}
long long sub(long long x, long long y) {
  x -= y;
  if (x < 0) return x + 1000000007;
  return x;
}
long long inv(long long a, long long m = 998244353) {
  return modpow(a, m - 2, m);
}
long long mul(long long a, long long b) { return (long long)a * b % 998244353; }
long long p, y;
long long isPrime(long long x) {
  for (long long i = 3; i <= min(p, (long long)sqrt(y)); i++)
    if (x % i == 0) return 0;
  return 1;
}
long long nCrModp(long long n, long long r, long long p) {
  long long C[r + 1];
  memset(C, 0, sizeof(C));
  C[0] = 1;
  for (long long i = 1; i <= n; i++) {
    for (long long j = min(i, r); j > 0; j--) C[j] = (C[j] + C[j - 1]) % p;
  }
  return C[r];
}
const long long mod = (long long)1000000007;
const long long BASE_DIGITS = 9;
const long long BASE = 1000000000;
struct BigInt {
  long long sign;
  vector<long long> a;
  BigInt() : sign(1) {}
  BigInt(long long v) { *this = v; }
  BigInt &operator=(long long v) {
    sign = 1;
    if (v < 0) {
      sign = -1;
      v = -v;
    }
    a.clear();
    for (; v > 0; v = v / BASE) a.push_back(v % BASE);
    return *this;
  }
  BigInt(const string &s) { read(s); }
  void read(const string &s) {
    sign = 1;
    a.clear();
    long long pos = 0;
    while (pos < (long long)s.size() && (s[pos] == '-' || s[pos] == '+')) {
      if (s[pos] == '-') sign = -sign;
      ++pos;
    }
    for (long long i = s.size() - 1; i >= pos; i -= BASE_DIGITS) {
      long long x = 0;
      for (long long j = max(pos, i - BASE_DIGITS + 1); j <= i; j++)
        x = x * 10 + s[j] - '0';
      a.push_back(x);
    }
    trim();
  }
  friend istream &operator>>(istream &stream, BigInt &v) {
    string s;
    stream >> s;
    v.read(s);
    return stream;
  }
  friend ostream &operator<<(ostream &stream, const BigInt &v) {
    if (v.sign == -1 && !v.isZero()) stream << '-';
    stream << (v.a.empty() ? 0 : v.a.back());
    for (long long i = (long long)v.a.size() - 2; i >= 0; --i)
      stream << setw(BASE_DIGITS) << setfill('0') << v.a[i];
    return stream;
  }
  bool operator<(const BigInt &v) const {
    if (sign != v.sign) return sign < v.sign;
    if (a.size() != v.a.size()) return a.size() * sign < v.a.size() * v.sign;
    for (long long i = ((long long)a.size()) - 1; i >= 0; i--)
      if (a[i] != v.a[i]) return a[i] * sign < v.a[i] * sign;
    return false;
  }
  bool operator>(const BigInt &v) const { return v < *this; }
  bool operator<=(const BigInt &v) const { return !(v < *this); }
  bool operator>=(const BigInt &v) const { return !(*this < v); }
  bool operator==(const BigInt &v) const {
    return !(*this < v) && !(v < *this);
  }
  bool operator!=(const BigInt &v) const { return *this < v || v < *this; }
  friend long long __compare_abs(const BigInt &x, const BigInt &y) {
    if (x.a.size() != y.a.size()) {
      return x.a.size() < y.a.size() ? -1 : 1;
    }
    for (long long i = ((long long)x.a.size()) - 1; i >= 0; --i) {
      if (x.a[i] != y.a[i]) {
        return x.a[i] < y.a[i] ? -1 : 1;
      }
    }
    return 0;
  }
  BigInt operator-() const {
    BigInt res = *this;
    if (isZero()) return res;
    res.sign = -sign;
    return res;
  }
  void __internal_add(const BigInt &v) {
    if (a.size() < v.a.size()) {
      a.resize(v.a.size(), 0);
    }
    for (long long i = 0, carry = 0;
         i < (long long)max(a.size(), v.a.size()) || carry; ++i) {
      if (i == (long long)a.size()) a.push_back(0);
      a[i] += carry + (i < (long long)v.a.size() ? v.a[i] : 0);
      carry = a[i] >= BASE;
      if (carry) a[i] -= BASE;
    }
  }
  void __internal_sub(const BigInt &v) {
    for (long long i = 0, carry = 0; i < (long long)v.a.size() || carry; ++i) {
      a[i] -= carry + (i < (long long)v.a.size() ? v.a[i] : 0);
      carry = a[i] < 0;
      if (carry) a[i] += BASE;
    }
    this->trim();
  }
  BigInt operator+=(const BigInt &v) {
    if (sign == v.sign) {
      __internal_add(v);
    } else {
      if (__compare_abs(*this, v) >= 0) {
        __internal_sub(v);
      } else {
        BigInt vv = v;
        swap(*this, vv);
        __internal_sub(vv);
      }
    }
    return *this;
  }
  BigInt operator-=(const BigInt &v) {
    if (sign == v.sign) {
      if (__compare_abs(*this, v) >= 0) {
        __internal_sub(v);
      } else {
        BigInt vv = v;
        swap(*this, vv);
        __internal_sub(vv);
        this->sign = -this->sign;
      }
    } else {
      __internal_add(v);
    }
    return *this;
  }
  template <typename L, typename R>
  typename std::enable_if<std::is_convertible<L, BigInt>::value &&
                              std::is_convertible<R, BigInt>::value &&
                              std::is_lvalue_reference<R &&>::value,
                          BigInt>::type friend
  operator+(L &&l, R &&r) {
    BigInt result(std::forward<L>(l));
    result += r;
    return result;
  }
  template <typename L, typename R>
  typename std::enable_if<std::is_convertible<L, BigInt>::value &&
                              std::is_convertible<R, BigInt>::value &&
                              std::is_rvalue_reference<R &&>::value,
                          BigInt>::type friend
  operator+(L &&l, R &&r) {
    BigInt result(std::move(r));
    result += l;
    return result;
  }
  template <typename L, typename R>
  typename std::enable_if<std::is_convertible<L, BigInt>::value &&
                              std::is_convertible<R, BigInt>::value,
                          BigInt>::type friend
  operator-(L &&l, R &&r) {
    BigInt result(std::forward<L>(l));
    result -= r;
    return result;
  }
  friend pair<BigInt, BigInt> divmod(const BigInt &a1, const BigInt &b1) {
    assert(b1 > 0);
    long long norm = BASE / (b1.a.back() + 1);
    BigInt a = a1.abs() * norm;
    BigInt b = b1.abs() * norm;
    BigInt q = 0, r = 0;
    q.a.resize(a.a.size());
    for (long long i = a.a.size() - 1; i >= 0; i--) {
      r *= BASE;
      r += a.a[i];
      long long s1 = r.a.size() <= b.a.size() ? 0 : r.a[b.a.size()];
      long long s2 = r.a.size() <= b.a.size() - 1 ? 0 : r.a[b.a.size() - 1];
      long long d = ((long long)BASE * s1 + s2) / b.a.back();
      r -= b * d;
      while (r < 0) {
        r += b, --d;
      }
      q.a[i] = d;
    }
    q.sign = a1.sign * b1.sign;
    r.sign = a1.sign;
    q.trim();
    r.trim();
    auto res = make_pair(q, r / norm);
    if (res.second < 0) res.second += b1;
    return res;
  }
  BigInt operator/(const BigInt &v) const {
    if (*this == 0) return BigInt(0);
    return divmod(*this, v).first;
  }
  BigInt operator%(const BigInt &v) const { return divmod(*this, v).second; }
  void operator/=(long long v) {
    assert(v > 0);
    if (llabs(v) >= BASE) {
      *this /= BigInt(v);
      return;
    }
    if (v < 0) sign = -sign, v = -v;
    for (long long i = (long long)a.size() - 1, rem = 0; i >= 0; --i) {
      long long cur = a[i] + rem * (long long)BASE;
      a[i] = (long long)(cur / v);
      rem = (long long)(cur % v);
    }
    trim();
  }
  BigInt operator/(long long v) const {
    assert(v > 0);
    if (llabs(v) >= BASE) {
      return *this / BigInt(v);
    }
    BigInt res = *this;
    res /= v;
    return res;
  }
  void operator/=(const BigInt &v) { *this = *this / v; }
  long long operator%(long long v) const {
    assert(v > 0);
    assert(v < BASE);
    long long m = 0;
    for (long long i = a.size() - 1; i >= 0; --i)
      m = (a[i] + m * (long long)BASE) % v;
    return m * sign;
  }
  void operator*=(long long v) {
    if (llabs(v) >= BASE) {
      *this *= BigInt(v);
      return;
    }
    if (v < 0) sign = -sign, v = -v;
    for (long long i = 0, carry = 0; i < (long long)a.size() || carry; ++i) {
      if (i == (long long)a.size()) a.push_back(0);
      long long cur = a[i] * (long long)v + carry;
      carry = (long long)(cur / BASE);
      a[i] = (long long)(cur % BASE);
    }
    trim();
  }
  BigInt operator*(long long v) const {
    if (llabs(v) >= BASE) {
      return *this * BigInt(v);
    }
    BigInt res = *this;
    res *= v;
    return res;
  }
  static vector<long long> convert_base(const vector<long long> &a,
                                        long long old_digits,
                                        long long new_digits) {
    vector<long long> p(max(old_digits, new_digits) + 1);
    p[0] = 1;
    for (long long i = 1; i < (long long)p.size(); i++) p[i] = p[i - 1] * 10;
    vector<long long> res;
    long long cur = 0;
    long long cur_digits = 0;
    for (long long i = 0; i < (long long)a.size(); i++) {
      cur += a[i] * p[cur_digits];
      cur_digits += old_digits;
      while (cur_digits >= new_digits) {
        res.push_back((long long)(cur % p[new_digits]));
        cur /= p[new_digits];
        cur_digits -= new_digits;
      }
    }
    res.push_back((long long)cur);
    while (!res.empty() && !res.back()) res.pop_back();
    return res;
  }
  void fft(vector<complex<double> > &a, bool invert) const {
    long long n = (long long)a.size();
    for (long long i = 1, j = 0; i < n; ++i) {
      long long bit = n >> 1;
      for (; j >= bit; bit >>= 1) j -= bit;
      j += bit;
      if (i < j) swap(a[i], a[j]);
    }
    for (long long len = 2; len <= n; len <<= 1) {
      double ang = 2 * 3.14159265358979323846 / len * (invert ? -1 : 1);
      complex<double> wlen(cos(ang), sin(ang));
      for (long long i = 0; i < n; i += len) {
        complex<double> w(1);
        for (long long j = 0; j < len / 2; ++j) {
          complex<double> u = a[i + j];
          complex<double> v = a[i + j + len / 2] * w;
          a[i + j] = u + v;
          a[i + j + len / 2] = u - v;
          w *= wlen;
        }
      }
    }
    if (invert)
      for (long long i = 0; i < n; ++i) a[i] /= n;
  }
  void multiply_fft(const vector<long long> &a, const vector<long long> &b,
                    vector<long long> &res) const {
    vector<complex<double> > fa(a.begin(), a.end());
    vector<complex<double> > fb(b.begin(), b.end());
    long long n = 1;
    while (n < (long long)max(a.size(), b.size())) n <<= 1;
    n <<= 1;
    fa.resize(n);
    fb.resize(n);
    fft(fa, false);
    fft(fb, false);
    for (long long i = 0; i < n; ++i) fa[i] *= fb[i];
    fft(fa, true);
    res.resize(n);
    long long carry = 0;
    for (long long i = 0; i < n; ++i) {
      long long t = (long long)(fa[i].real() + 0.5) + carry;
      carry = t / 1000;
      res[i] = t % 1000;
    }
  }
  BigInt mul_simple(const BigInt &v) const {
    BigInt res;
    res.sign = sign * v.sign;
    res.a.resize(a.size() + v.a.size());
    for (long long i = 0; i < (long long)a.size(); ++i)
      if (a[i])
        for (long long j = 0, carry = 0; j < (long long)v.a.size() || carry;
             ++j) {
          long long cur =
              res.a[i + j] +
              (long long)a[i] * (j < (long long)v.a.size() ? v.a[j] : 0) +
              carry;
          carry = (long long)(cur / BASE);
          res.a[i + j] = (long long)(cur % BASE);
        }
    res.trim();
    return res;
  }
  static vector<long long> karatsubaMultiply(const vector<long long> &a,
                                             const vector<long long> &b) {
    long long n = a.size();
    vector<long long> res(n + n);
    if (n <= 32) {
      for (long long i = 0; i < n; i++)
        for (long long j = 0; j < n; j++) res[i + j] += a[i] * b[j];
      return res;
    }
    long long k = n >> 1;
    vector<long long> a1(a.begin(), a.begin() + k);
    vector<long long> a2(a.begin() + k, a.end());
    vector<long long> b1(b.begin(), b.begin() + k);
    vector<long long> b2(b.begin() + k, b.end());
    vector<long long> a1b1 = karatsubaMultiply(a1, b1);
    vector<long long> a2b2 = karatsubaMultiply(a2, b2);
    for (long long i = 0; i < k; i++) a2[i] += a1[i];
    for (long long i = 0; i < k; i++) b2[i] += b1[i];
    vector<long long> r = karatsubaMultiply(a2, b2);
    for (long long i = 0; i < (long long)a1b1.size(); i++) r[i] -= a1b1[i];
    for (long long i = 0; i < (long long)a2b2.size(); i++) r[i] -= a2b2[i];
    for (long long i = 0; i < (long long)r.size(); i++) res[i + k] += r[i];
    for (long long i = 0; i < (long long)a1b1.size(); i++) res[i] += a1b1[i];
    for (long long i = 0; i < (long long)a2b2.size(); i++)
      res[i + n] += a2b2[i];
    return res;
  }
  BigInt mul_karatsuba(const BigInt &v) const {
    vector<long long> a6 = convert_base(this->a, BASE_DIGITS, 6);
    vector<long long> b6 = convert_base(v.a, BASE_DIGITS, 6);
    vector<long long> a(a6.begin(), a6.end());
    vector<long long> b(b6.begin(), b6.end());
    while (a.size() < b.size()) a.push_back(0);
    while (b.size() < a.size()) b.push_back(0);
    while (a.size() & (a.size() - 1)) a.push_back(0), b.push_back(0);
    vector<long long> c = karatsubaMultiply(a, b);
    BigInt res;
    res.sign = sign * v.sign;
    long long carry = 0;
    for (long long i = 0; i < (long long)c.size(); i++) {
      long long cur = c[i] + carry;
      res.a.push_back((long long)(cur % 1000000));
      carry = cur / 1000000;
    }
    res.a = convert_base(res.a, 6, BASE_DIGITS);
    res.trim();
    return res;
  }
  void operator*=(const BigInt &v) { *this = *this * v; }
  BigInt operator*(const BigInt &v) const {
    if (a.size() * v.a.size() <= 1000111) return mul_simple(v);
    if (a.size() > 500111 || v.a.size() > 500111) return mul_fft(v);
    return mul_karatsuba(v);
  }
  BigInt mul_fft(const BigInt &v) const {
    BigInt res;
    res.sign = sign * v.sign;
    multiply_fft(convert_base(a, BASE_DIGITS, 3),
                 convert_base(v.a, BASE_DIGITS, 3), res.a);
    res.a = convert_base(res.a, 3, BASE_DIGITS);
    res.trim();
    return res;
  }
  BigInt abs() const {
    BigInt res = *this;
    res.sign *= res.sign;
    return res;
  }
  void trim() {
    while (!a.empty() && !a.back()) a.pop_back();
    if (a.empty()) sign = 1;
  }
  bool isZero() const { return a.empty() || (a.size() == 1 && !a[0]); }
  friend BigInt gcd(const BigInt &a, const BigInt &b) {
    return b.isZero() ? a : gcd(b, a % b);
  }
  friend BigInt lcm(const BigInt &a, const BigInt &b) {
    return a / gcd(a, b) * b;
  }
  friend BigInt sqrt(const BigInt &a1) {
    BigInt a = a1;
    while (a.a.empty() || a.a.size() % 2 == 1) a.a.push_back(0);
    long long n = a.a.size();
    long long firstDigit =
        (long long)sqrt((double)a.a[n - 1] * BASE + a.a[n - 2]);
    long long norm = BASE / (firstDigit + 1);
    a *= norm;
    a *= norm;
    while (a.a.empty() || a.a.size() % 2 == 1) a.a.push_back(0);
    BigInt r = (long long)a.a[n - 1] * BASE + a.a[n - 2];
    firstDigit = (long long)sqrt((double)a.a[n - 1] * BASE + a.a[n - 2]);
    long long q = firstDigit;
    BigInt res;
    for (long long j = n / 2 - 1; j >= 0; j--) {
      for (;; --q) {
        BigInt r1 =
            (r - (res * 2 * BigInt(BASE) + q) * q) * BigInt(BASE) *
                BigInt(BASE) +
            (j > 0 ? (long long)a.a[2 * j - 1] * BASE + a.a[2 * j - 2] : 0);
        if (r1 >= 0) {
          r = r1;
          break;
        }
      }
      res *= BASE;
      res += q;
      if (j > 0) {
        long long d1 =
            res.a.size() + 2 < r.a.size() ? r.a[res.a.size() + 2] : 0;
        long long d2 =
            res.a.size() + 1 < r.a.size() ? r.a[res.a.size() + 1] : 0;
        long long d3 = res.a.size() < r.a.size() ? r.a[res.a.size()] : 0;
        q = ((long long)d1 * BASE * BASE + (long long)d2 * BASE + d3) /
            (firstDigit * 2);
      }
    }
    res.trim();
    return res / norm;
  }
};
using bi = BigInt;
int32_t main() {
  ios_base::sync_with_stdio(false);
  cin.tie();
  cout.tie();
  cout << fixed << setprecision(12);
  long long n;
  cin >> n;
  if (n <= 3) {
    if (n == 1 || n == 2)
      cout << "-1"
           << "\n";
    else
      cout << "210"
           << "\n";
    return 0;
  }
  string s = "1";
  for (long long i = 1; i < n; i++) {
    s += '0';
  }
  bi val = BigInt(s);
  bi rem = val % 210;
  bi ans = 210 - rem;
  bi dp = ans;
  long long cnt = 0;
  while (dp > 0) {
    ++cnt;
    dp /= 10;
  }
  for (long long i = 0; i < s.length() - cnt; i++) {
    cout << s[i];
  }
  cout << ans << "\n";
  return 0;
}
