#include <bits/stdc++.h>
using namespace std;
long long M = 998244353;
long long fact[300000 + 7];
long long sieve[1000000 + 6];
long long power(long long x, long long y) {
  if (y == 0) return 1;
  long long t = power(x, y / 2);
  t = ((t % M) * (t % M)) % M;
  if (y % 2 == 1) t = ((t % M) * (x % M)) % M;
  return t;
}
long long max(long long a, long long b) {
  if (a > b) return a;
  return b;
}
long long min(long long a, long long b) {
  if (a > b) return b;
  return a;
}
long long bfs(vector<long long> v[], long long n) {
  long long i;
  n = 100;
  long long dis[100 + 1] = {0};
  long long flg[100 + 1] = {0};
  priority_queue<long long> q;
  q.push(1);
  dis[1] = 0;
  while (!q.empty()) {
    long long u = q.top();
    q.pop();
    flg[u] = 1;
    for (i = 0; i < v[u].size(); i++) {
      long long ve = v[u][i];
      if (flg[ve] == 0) {
        q.push(ve);
        dis[ve] = dis[u] + 1;
      }
    }
  }
  return dis[n];
}
bool sortinrev(const pair<long long, long long> &a,
               const pair<long long, long long> &b) {
  return (a.first > b.first);
}
long long isPrime(long long x) {
  vector<long long> v;
  long long i;
  for (i = 1; i * i <= x; i++) {
    if (x % i == 0) {
      if (i * i == x)
        v.push_back(i);
      else {
        v.push_back(i);
        v.push_back(x / i);
      }
    }
  }
  return v.size() == 2;
}
long long binarySearch(vector<long long> arr, long long l, long long r,
                       long long x) {
  if (r >= l) {
    long long mid = l + (r - l) / 2;
    if (arr[mid] == x) return mid;
    if (arr[mid] > x) return binarySearch(arr, l, mid - 1, x);
    return binarySearch(arr, mid + 1, r, x);
  }
  return -1;
}
long long gcd(long long a, long long b) {
  if (b == 0) return a;
  return gcd(b, a % b);
}
long long phi(long long n) {
  long long result = n;
  for (long long p = 2; p * p <= n; ++p) {
    if (n % p == 0) {
      while (n % p == 0) n /= p;
      result -= result / p;
    }
  }
  if (n > 1) result -= result / n;
  return result;
}
void dfs(long long source, long long visited[], vector<long long> graph[],
         long long l) {
  visited[source] = l;
  long long i;
  for (i = 0; i < graph[source].size(); i++) {
    if (visited[graph[source][i]] == -1)
      dfs(graph[source][i], visited, graph, l);
  }
}
long long day(long long d, long long m, long long y) {
  static long long t[] = {0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4};
  y -= m < 3;
  return (y + y / 4 - y / 100 + y / 400 + t[m - 1] + d) % 7;
}
bool isPerfectSquare(long double x) {
  long double sr = sqrt(x);
  return ((sr - floor(sr)) == 0);
}
long long getMid(long long s, long long e) { return s + (e - s) / 2; }
long long getSumUtil(long long *st, long long ss, long long se, long long qs,
                     long long qe, long long si) {
  if (qs <= ss && qe >= se) return st[si];
  if (se < qs || ss > qe) return 0;
  long long mid = getMid(ss, se);
  return getSumUtil(st, ss, mid, qs, qe, 2 * si + 1) +
         getSumUtil(st, mid + 1, se, qs, qe, 2 * si + 2);
}
void updateValueUtil(long long *st, long long ss, long long se, long long i,
                     long long diff, long long si) {
  if (i < ss || i > se) return;
  st[si] = st[si] + diff;
  if (se != ss) {
    long long mid = getMid(ss, se);
    updateValueUtil(st, ss, mid, i, diff, 2 * si + 1);
    updateValueUtil(st, mid + 1, se, i, diff, 2 * si + 2);
  }
}
void updateValue(long long arr[], long long *st, long long n, long long i,
                 long long new_val) {
  if (i < 0 || i > n - 1) {
    cout << "Invalid Input";
    return;
  }
  long long diff = new_val - arr[i];
  arr[i] = new_val;
  updateValueUtil(st, 0, n - 1, i, diff, 0);
}
long long getSum(long long *st, long long n, long long qs, long long qe) {
  if (qs < 0 || qe > n - 1 || qs > qe) {
    cout << "Invalid Input";
    return -1;
  }
  return getSumUtil(st, 0, n - 1, qs, qe, 0);
}
long long constructSTUtil(long long arr[], long long ss, long long se,
                          long long *st, long long si) {
  if (ss == se) {
    st[si] = arr[ss];
    return arr[ss];
  }
  long long mid = getMid(ss, se);
  st[si] = constructSTUtil(arr, ss, mid, st, si * 2 + 1) +
           constructSTUtil(arr, mid + 1, se, st, si * 2 + 2);
  return st[si];
}
long long *constructST(long long arr[], long long n) {
  long long x = (long long)(ceil(log2(n)));
  long long max_size = 2 * (long long)pow(2, x) - 1;
  long long *st = new long long[max_size];
  constructSTUtil(arr, 0, n - 1, st, 0);
  return st;
}
bool comp(pair<long long, long long> p1, pair<long long, long long> p2) {
  return p1.second < p2.second;
}
vector<long long> maxSubArraySum(long long a[], long long size) {
  long long max_so_far = LONG_MIN, max_ending_here = 0, start = 0, end = 0,
            s = 0;
  for (long long i = 0; i < size; i++) {
    max_ending_here += a[i];
    if (max_so_far < max_ending_here) {
      max_so_far = max_ending_here;
      start = s;
      end = i;
    }
    if (max_ending_here < 0) {
      max_ending_here = 0;
      s = i + 1;
    }
  }
  vector<long long> v;
  v.push_back(max_so_far);
  v.push_back(start);
  v.push_back(end);
  return v;
}
vector<long long> smallestSumSubarr(long long arr[], long long n) {
  long long min_ending_here = 0;
  long long min_so_far = LONG_MAX, start = 0, end = 0, s = 0;
  for (long long i = 0; i < n; i++) {
    min_ending_here += arr[i];
    if (min_so_far > min_ending_here) {
      min_so_far = min_ending_here;
      start = s;
      end = i;
    }
    if (min_ending_here > 0) {
      min_ending_here = 0;
      s = i + 1;
    }
  }
  vector<long long> v;
  v.push_back(min_so_far);
  v.push_back(start);
  v.push_back(end);
  return v;
}
void bfs(vector<long long> g[], long long dist[], bool v[], long long u) {
  queue<long long> q;
  q.push(u);
  v[u] = true;
  dist[u] = 0;
  while (!q.empty()) {
    long long f = q.front();
    q.pop();
    for (auto i = g[f].begin(); i != g[f].end(); i++) {
      if (!v[*i]) {
        q.push(*i);
        v[*i] = true;
        dist[*i] = dist[f] + 1;
      }
    }
  }
}
class DisjSet {
  long long *rank, *parent, n;

 public:
  DisjSet(long long n) {
    rank = new long long[n];
    parent = new long long[n];
    this->n = n;
    makeSet();
  }
  void makeSet() {
    for (long long i = 0; i < n; i++) {
      parent[i] = i;
    }
    for (long long i = 0; i < n; i++) {
      rank[i] = i;
    }
  }
  long long find(long long x) {
    if (parent[x] != x) {
      parent[x] = find(parent[x]);
    }
    return parent[x];
  }
  bool Union(long long x, long long y) {
    long long xset = find(x);
    long long yset = find(y);
    if (xset == yset) return false;
    if (rank[xset] < rank[yset]) {
      parent[xset] = yset;
    } else if (rank[xset] > rank[yset]) {
      parent[yset] = xset;
    } else {
      parent[yset] = xset;
      rank[xset] = rank[xset] + 1;
    }
  }
};
bool isPali(string s) {
  long long st = 0, ed = s.size() - 1;
  while (st <= ed && s[st] == s[ed]) {
    st++;
    ed--;
  }
  if (st > ed) return true;
  return false;
}
long long findSplitPoint(long long arr[], long long n) {
  long long leftSum = 0;
  for (long long i = 0; i < n; i++) leftSum += arr[i];
  long long rightSum = 0;
  for (long long i = n - 1; i >= 0; i--) {
    rightSum += arr[i];
    leftSum -= arr[i];
    if (rightSum == leftSum) return i;
  }
  return -1;
}
void printTwoParts(long long arr[], long long n) {
  long long splitPoint = findSplitPoint(arr, n);
  if (splitPoint == -1 || splitPoint == n) {
    cout << "NO\n";
    return;
  }
  cout << "YES\n";
}
bool findPartiion(long long arr[], long long n) {
  long long sum = 0;
  long long i, j;
  for (i = 0; i < n; i++) sum += arr[i];
  if (sum % 2 != 0) return false;
  bool part[sum / 2 + 1][n + 1];
  for (i = 0; i <= n; i++) part[0][i] = true;
  for (i = 1; i <= sum / 2; i++) part[i][0] = false;
  for (i = 1; i <= sum / 2; i++) {
    for (j = 1; j <= n; j++) {
      part[i][j] = part[i][j - 1];
      if (i >= arr[j - 1])
        part[i][j] = part[i][j] || part[i - arr[j - 1]][j - 1];
    }
  }
  return part[sum / 2][n];
}
long long computeXOR(const long long n) {
  switch (n & 3) {
    case 0:
      return n;
    case 1:
      return 1;
    case 2:
      return n + 1;
    case 3:
      return 0;
  }
}
long long sp[100007];
void siev() {
  sp[1] = 1;
  for (long long i = 2; i < 100001; i++) sp[i] = i;
  for (long long i = 4; i < 100001; i += 2) sp[i] = 2;
  for (long long i = 3; i * i < 100001; i++) {
    if (sp[i] == i) {
      for (long long j = i * i; j < 100001; j += i)
        if (sp[j] == j) sp[j] = i;
    }
  }
}
vector<long long> getFactorization(long long x) {
  vector<long long> ret;
  while (x != 1) {
    ret.push_back(sp[x]);
    x = x / sp[x];
  }
  return ret;
}
long long p[1000004];
long long findlcm(long long arr[], long long n) {
  long long ans = arr[0];
  for (long long i = 1; i < n; i++)
    ans = (((arr[i] * ans)) / (gcd(arr[i], ans)));
  return ans;
}
void output() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  long long n;
  cin >> n;
  long long i = 1;
  vector<long long> v;
  if (n % 2 == 0) {
    while (n % 2 == 0) {
      v.push_back(2);
      n = n / 2;
    }
  }
  for (i = 3; i * i <= n; i++) {
    if (sp[i] == i) {
      while (n % i == 0) {
        v.push_back(i);
        n = n / i;
      }
    }
  }
  if (n > 2) v.push_back(n);
  sort(v.begin(), v.end());
  for (i = 0; i < v.size(); i++) cout << v[i];
  cout << endl;
}
int main(int argc, const char *argv[]) {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  long long t;
  t = 1;
  long long i;
  siev();
  p[0] = 1;
  while (t--) {
    output();
  }
  return 0;
}

### Prompt

Your task is to create a CPP solution to the following problem:

    There was once young lass called Mary,    
    Whose jokes were occasionally scary.    
    On this April's Fool    
    Fixed limerick rules    
    Allowed her to trip the unwary.  
      
    Can she fill all the lines  
    To work at all times?  
    On juggling the words  
    Right around two-thirds  
    She nearly ran out of rhymes.  
    

Input

The input contains a single integer a (4 ≤ a ≤ 998). Not every integer in the range is a valid input for the problem; you are guaranteed that the input will be a valid integer.

Output

Output a single number.

Examples

Input


35


Output


57


Input


57


Output


319


Input


391


Output


1723

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
long long M = 998244353;
long long fact[300000 + 7];
long long sieve[1000000 + 6];
long long power(long long x, long long y) {
  if (y == 0) return 1;
  long long t = power(x, y / 2);
  t = ((t % M) * (t % M)) % M;
  if (y % 2 == 1) t = ((t % M) * (x % M)) % M;
  return t;
}
long long max(long long a, long long b) {
  if (a > b) return a;
  return b;
}
long long min(long long a, long long b) {
  if (a > b) return b;
  return a;
}
long long bfs(vector<long long> v[], long long n) {
  long long i;
  n = 100;
  long long dis[100 + 1] = {0};
  long long flg[100 + 1] = {0};
  priority_queue<long long> q;
  q.push(1);
  dis[1] = 0;
  while (!q.empty()) {
    long long u = q.top();
    q.pop();
    flg[u] = 1;
    for (i = 0; i < v[u].size(); i++) {
      long long ve = v[u][i];
      if (flg[ve] == 0) {
        q.push(ve);
        dis[ve] = dis[u] + 1;
      }
    }
  }
  return dis[n];
}
bool sortinrev(const pair<long long, long long> &a,
               const pair<long long, long long> &b) {
  return (a.first > b.first);
}
long long isPrime(long long x) {
  vector<long long> v;
  long long i;
  for (i = 1; i * i <= x; i++) {
    if (x % i == 0) {
      if (i * i == x)
        v.push_back(i);
      else {
        v.push_back(i);
        v.push_back(x / i);
      }
    }
  }
  return v.size() == 2;
}
long long binarySearch(vector<long long> arr, long long l, long long r,
                       long long x) {
  if (r >= l) {
    long long mid = l + (r - l) / 2;
    if (arr[mid] == x) return mid;
    if (arr[mid] > x) return binarySearch(arr, l, mid - 1, x);
    return binarySearch(arr, mid + 1, r, x);
  }
  return -1;
}
long long gcd(long long a, long long b) {
  if (b == 0) return a;
  return gcd(b, a % b);
}
long long phi(long long n) {
  long long result = n;
  for (long long p = 2; p * p <= n; ++p) {
    if (n % p == 0) {
      while (n % p == 0) n /= p;
      result -= result / p;
    }
  }
  if (n > 1) result -= result / n;
  return result;
}
void dfs(long long source, long long visited[], vector<long long> graph[],
         long long l) {
  visited[source] = l;
  long long i;
  for (i = 0; i < graph[source].size(); i++) {
    if (visited[graph[source][i]] == -1)
      dfs(graph[source][i], visited, graph, l);
  }
}
long long day(long long d, long long m, long long y) {
  static long long t[] = {0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4};
  y -= m < 3;
  return (y + y / 4 - y / 100 + y / 400 + t[m - 1] + d) % 7;
}
bool isPerfectSquare(long double x) {
  long double sr = sqrt(x);
  return ((sr - floor(sr)) == 0);
}
long long getMid(long long s, long long e) { return s + (e - s) / 2; }
long long getSumUtil(long long *st, long long ss, long long se, long long qs,
                     long long qe, long long si) {
  if (qs <= ss && qe >= se) return st[si];
  if (se < qs || ss > qe) return 0;
  long long mid = getMid(ss, se);
  return getSumUtil(st, ss, mid, qs, qe, 2 * si + 1) +
         getSumUtil(st, mid + 1, se, qs, qe, 2 * si + 2);
}
void updateValueUtil(long long *st, long long ss, long long se, long long i,
                     long long diff, long long si) {
  if (i < ss || i > se) return;
  st[si] = st[si] + diff;
  if (se != ss) {
    long long mid = getMid(ss, se);
    updateValueUtil(st, ss, mid, i, diff, 2 * si + 1);
    updateValueUtil(st, mid + 1, se, i, diff, 2 * si + 2);
  }
}
void updateValue(long long arr[], long long *st, long long n, long long i,
                 long long new_val) {
  if (i < 0 || i > n - 1) {
    cout << "Invalid Input";
    return;
  }
  long long diff = new_val - arr[i];
  arr[i] = new_val;
  updateValueUtil(st, 0, n - 1, i, diff, 0);
}
long long getSum(long long *st, long long n, long long qs, long long qe) {
  if (qs < 0 || qe > n - 1 || qs > qe) {
    cout << "Invalid Input";
    return -1;
  }
  return getSumUtil(st, 0, n - 1, qs, qe, 0);
}
long long constructSTUtil(long long arr[], long long ss, long long se,
                          long long *st, long long si) {
  if (ss == se) {
    st[si] = arr[ss];
    return arr[ss];
  }
  long long mid = getMid(ss, se);
  st[si] = constructSTUtil(arr, ss, mid, st, si * 2 + 1) +
           constructSTUtil(arr, mid + 1, se, st, si * 2 + 2);
  return st[si];
}
long long *constructST(long long arr[], long long n) {
  long long x = (long long)(ceil(log2(n)));
  long long max_size = 2 * (long long)pow(2, x) - 1;
  long long *st = new long long[max_size];
  constructSTUtil(arr, 0, n - 1, st, 0);
  return st;
}
bool comp(pair<long long, long long> p1, pair<long long, long long> p2) {
  return p1.second < p2.second;
}
vector<long long> maxSubArraySum(long long a[], long long size) {
  long long max_so_far = LONG_MIN, max_ending_here = 0, start = 0, end = 0,
            s = 0;
  for (long long i = 0; i < size; i++) {
    max_ending_here += a[i];
    if (max_so_far < max_ending_here) {
      max_so_far = max_ending_here;
      start = s;
      end = i;
    }
    if (max_ending_here < 0) {
      max_ending_here = 0;
      s = i + 1;
    }
  }
  vector<long long> v;
  v.push_back(max_so_far);
  v.push_back(start);
  v.push_back(end);
  return v;
}
vector<long long> smallestSumSubarr(long long arr[], long long n) {
  long long min_ending_here = 0;
  long long min_so_far = LONG_MAX, start = 0, end = 0, s = 0;
  for (long long i = 0; i < n; i++) {
    min_ending_here += arr[i];
    if (min_so_far > min_ending_here) {
      min_so_far = min_ending_here;
      start = s;
      end = i;
    }
    if (min_ending_here > 0) {
      min_ending_here = 0;
      s = i + 1;
    }
  }
  vector<long long> v;
  v.push_back(min_so_far);
  v.push_back(start);
  v.push_back(end);
  return v;
}
void bfs(vector<long long> g[], long long dist[], bool v[], long long u) {
  queue<long long> q;
  q.push(u);
  v[u] = true;
  dist[u] = 0;
  while (!q.empty()) {
    long long f = q.front();
    q.pop();
    for (auto i = g[f].begin(); i != g[f].end(); i++) {
      if (!v[*i]) {
        q.push(*i);
        v[*i] = true;
        dist[*i] = dist[f] + 1;
      }
    }
  }
}
class DisjSet {
  long long *rank, *parent, n;

 public:
  DisjSet(long long n) {
    rank = new long long[n];
    parent = new long long[n];
    this->n = n;
    makeSet();
  }
  void makeSet() {
    for (long long i = 0; i < n; i++) {
      parent[i] = i;
    }
    for (long long i = 0; i < n; i++) {
      rank[i] = i;
    }
  }
  long long find(long long x) {
    if (parent[x] != x) {
      parent[x] = find(parent[x]);
    }
    return parent[x];
  }
  bool Union(long long x, long long y) {
    long long xset = find(x);
    long long yset = find(y);
    if (xset == yset) return false;
    if (rank[xset] < rank[yset]) {
      parent[xset] = yset;
    } else if (rank[xset] > rank[yset]) {
      parent[yset] = xset;
    } else {
      parent[yset] = xset;
      rank[xset] = rank[xset] + 1;
    }
  }
};
bool isPali(string s) {
  long long st = 0, ed = s.size() - 1;
  while (st <= ed && s[st] == s[ed]) {
    st++;
    ed--;
  }
  if (st > ed) return true;
  return false;
}
long long findSplitPoint(long long arr[], long long n) {
  long long leftSum = 0;
  for (long long i = 0; i < n; i++) leftSum += arr[i];
  long long rightSum = 0;
  for (long long i = n - 1; i >= 0; i--) {
    rightSum += arr[i];
    leftSum -= arr[i];
    if (rightSum == leftSum) return i;
  }
  return -1;
}
void printTwoParts(long long arr[], long long n) {
  long long splitPoint = findSplitPoint(arr, n);
  if (splitPoint == -1 || splitPoint == n) {
    cout << "NO\n";
    return;
  }
  cout << "YES\n";
}
bool findPartiion(long long arr[], long long n) {
  long long sum = 0;
  long long i, j;
  for (i = 0; i < n; i++) sum += arr[i];
  if (sum % 2 != 0) return false;
  bool part[sum / 2 + 1][n + 1];
  for (i = 0; i <= n; i++) part[0][i] = true;
  for (i = 1; i <= sum / 2; i++) part[i][0] = false;
  for (i = 1; i <= sum / 2; i++) {
    for (j = 1; j <= n; j++) {
      part[i][j] = part[i][j - 1];
      if (i >= arr[j - 1])
        part[i][j] = part[i][j] || part[i - arr[j - 1]][j - 1];
    }
  }
  return part[sum / 2][n];
}
long long computeXOR(const long long n) {
  switch (n & 3) {
    case 0:
      return n;
    case 1:
      return 1;
    case 2:
      return n + 1;
    case 3:
      return 0;
  }
}
long long sp[100007];
void siev() {
  sp[1] = 1;
  for (long long i = 2; i < 100001; i++) sp[i] = i;
  for (long long i = 4; i < 100001; i += 2) sp[i] = 2;
  for (long long i = 3; i * i < 100001; i++) {
    if (sp[i] == i) {
      for (long long j = i * i; j < 100001; j += i)
        if (sp[j] == j) sp[j] = i;
    }
  }
}
vector<long long> getFactorization(long long x) {
  vector<long long> ret;
  while (x != 1) {
    ret.push_back(sp[x]);
    x = x / sp[x];
  }
  return ret;
}
long long p[1000004];
long long findlcm(long long arr[], long long n) {
  long long ans = arr[0];
  for (long long i = 1; i < n; i++)
    ans = (((arr[i] * ans)) / (gcd(arr[i], ans)));
  return ans;
}
void output() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  long long n;
  cin >> n;
  long long i = 1;
  vector<long long> v;
  if (n % 2 == 0) {
    while (n % 2 == 0) {
      v.push_back(2);
      n = n / 2;
    }
  }
  for (i = 3; i * i <= n; i++) {
    if (sp[i] == i) {
      while (n % i == 0) {
        v.push_back(i);
        n = n / i;
      }
    }
  }
  if (n > 2) v.push_back(n);
  sort(v.begin(), v.end());
  for (i = 0; i < v.size(); i++) cout << v[i];
  cout << endl;
}
int main(int argc, const char *argv[]) {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  long long t;
  t = 1;
  long long i;
  siev();
  p[0] = 1;
  while (t--) {
    output();
  }
  return 0;
}

```