#include <bits/stdc++.h>
using namespace std;
using lint = long long;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
struct fast_ios {
  fast_ios() {
    cin.tie(nullptr), ios::sync_with_stdio(false),
        cout << fixed << setprecision(20);
  };
} fast_ios_;
template <typename T, typename V>
void ndarray(vector<T> &vec, const V &val, int len) {
  vec.assign(len, val);
}
template <typename T, typename V, typename... Args>
void ndarray(vector<T> &vec, const V &val, int len, Args... args) {
  vec.resize(len),
      for_each(begin(vec), end(vec), [&](T &v) { ndarray(v, val, args...); });
}
template <typename T>
bool chmax(T &m, const T q) {
  if (m < q) {
    m = q;
    return true;
  } else
    return false;
}
template <typename T>
bool chmin(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>
vector<T> sort_unique(vector<T> vec) {
  sort(vec.begin(), vec.end()),
      vec.erase(unique(vec.begin(), vec.end()), vec.end());
  return vec;
}
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, typename TH>
ostream &operator<<(ostream &os, const unordered_set<T, TH> &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, typename TH>
ostream &operator<<(ostream &os, const unordered_map<TK, TV, TH> &mp) {
  os << '{';
  for (auto v : mp) os << v.first << "=>" << v.second << ',';
  os << '}';
  return os;
}
void solve1(lint A) {
  string ret;
  while (A) {
    lint d = min(A, 9LL);
    ret += to_string(d);
    A -= d;
  }
  cout << ret << ' ' << ret << '\n';
  exit(0);
}
__int128 str2i128(std::string str) {
  __int128 ret = 0;
  bool minus = false;
  for (auto c : str) {
    if (c == '-')
      minus = true;
    else
      ret = ret * 10 + c - '0';
  }
  return minus ? -ret : ret;
}
std::istream &operator>>(std::istream &is, __int128 &x) {
  std::string s;
  return is >> s, x = str2i128(s), is;
}
std::ostream &operator<<(std::ostream &os, const __int128 &x) {
  __int128 tmp = x;
  if (tmp == 0) return os << 0;
  std::vector<int> ds;
  if (tmp < 0) {
    os << '-';
    while (tmp) {
      int d = tmp % 10;
      if (d > 0) d -= 10;
      ds.emplace_back(-d), tmp = (tmp - d) / 10;
    }
  } else {
    while (tmp) ds.emplace_back(tmp % 10), tmp /= 10;
  }
  std::reverse(ds.begin(), ds.end());
  for (auto i : ds) os << i;
  return os;
}
vector<__int128> DC;
vector<__int128> p10;
__int128 cnt(lint x) {
  __int128 ret = 0;
  for (int d = (p10.size()) - 1, d_begin_ = (0); d >= d_begin_; d--) {
    lint e = x / p10[d];
    if (e) {
      ret += DC[d] * e + p10[d] * e * (e - 1) / 2;
      x -= e * p10[d];
      ret += (x + 1) * e;
    }
  }
  return ret;
}
int single(lint A) {
  int ret = 0;
  while (A) {
    ret += A % 10;
    A /= 10;
  }
  return ret;
}
int main() {
  lint A;
  cin >> A;
  if (A <= 1800) solve1(A);
  DC.resize(18);
  p10.resize(18, 1);
  for (int i = (1), i_end_ = (p10.size()); i < i_end_; i++)
    p10[i] = p10[i - 1] * 10;
  for (int i = (1), i_end_ = (DC.size()); i < i_end_; i++) {
    DC[i] = 45 * i;
    for (int _ = (0), __end_ = (i - 1); _ < __end_; _++) DC[i] *= 10;
  }
  lint lo = 0, hi = 100000000000000000LL;
  while (hi - lo > 1) {
    lint c = (hi + lo) / 2;
    (cnt(c) >= A ? hi : lo) = c;
  }
  lint l = 1, r = hi;
  __int128 nb = cnt(hi);
  while (nb != A) {
    if (nb > A) {
      nb -= single(l);
      l++;
    } else {
      r++;
      nb += single(r);
    }
  }
  cout << l << ' ' << r << '\n';
}

### Prompt

Please create a solution in CPP to the following problem:

Little X has met the following problem recently. 

Let's define f(x) as the sum of digits in decimal representation of number x (for example, f(1234) = 1 + 2 + 3 + 4). You are to calculate <image>

Of course Little X has solved this problem quickly, has locked it, and then has tried to hack others. He has seen the following C++ code: 
    
    
      
        ans = solve(l, r) % a;  
        if (ans <= 0)  
          ans += a;  
      
    

This code will fail only on the test with <image>. You are given number a, help Little X to find a proper test for hack.

Input

The first line contains a single integer a (1 ≤ a ≤ 1018).

Output

Print two integers: l, r (1 ≤ l ≤ r < 10200) — the required test data. Leading zeros aren't allowed. It's guaranteed that the solution exists.

Examples

Input

46


Output

1 10


Input

126444381000032


Output

2333333 2333333333333

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
struct fast_ios {
  fast_ios() {
    cin.tie(nullptr), ios::sync_with_stdio(false),
        cout << fixed << setprecision(20);
  };
} fast_ios_;
template <typename T, typename V>
void ndarray(vector<T> &vec, const V &val, int len) {
  vec.assign(len, val);
}
template <typename T, typename V, typename... Args>
void ndarray(vector<T> &vec, const V &val, int len, Args... args) {
  vec.resize(len),
      for_each(begin(vec), end(vec), [&](T &v) { ndarray(v, val, args...); });
}
template <typename T>
bool chmax(T &m, const T q) {
  if (m < q) {
    m = q;
    return true;
  } else
    return false;
}
template <typename T>
bool chmin(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>
vector<T> sort_unique(vector<T> vec) {
  sort(vec.begin(), vec.end()),
      vec.erase(unique(vec.begin(), vec.end()), vec.end());
  return vec;
}
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, typename TH>
ostream &operator<<(ostream &os, const unordered_set<T, TH> &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, typename TH>
ostream &operator<<(ostream &os, const unordered_map<TK, TV, TH> &mp) {
  os << '{';
  for (auto v : mp) os << v.first << "=>" << v.second << ',';
  os << '}';
  return os;
}
void solve1(lint A) {
  string ret;
  while (A) {
    lint d = min(A, 9LL);
    ret += to_string(d);
    A -= d;
  }
  cout << ret << ' ' << ret << '\n';
  exit(0);
}
__int128 str2i128(std::string str) {
  __int128 ret = 0;
  bool minus = false;
  for (auto c : str) {
    if (c == '-')
      minus = true;
    else
      ret = ret * 10 + c - '0';
  }
  return minus ? -ret : ret;
}
std::istream &operator>>(std::istream &is, __int128 &x) {
  std::string s;
  return is >> s, x = str2i128(s), is;
}
std::ostream &operator<<(std::ostream &os, const __int128 &x) {
  __int128 tmp = x;
  if (tmp == 0) return os << 0;
  std::vector<int> ds;
  if (tmp < 0) {
    os << '-';
    while (tmp) {
      int d = tmp % 10;
      if (d > 0) d -= 10;
      ds.emplace_back(-d), tmp = (tmp - d) / 10;
    }
  } else {
    while (tmp) ds.emplace_back(tmp % 10), tmp /= 10;
  }
  std::reverse(ds.begin(), ds.end());
  for (auto i : ds) os << i;
  return os;
}
vector<__int128> DC;
vector<__int128> p10;
__int128 cnt(lint x) {
  __int128 ret = 0;
  for (int d = (p10.size()) - 1, d_begin_ = (0); d >= d_begin_; d--) {
    lint e = x / p10[d];
    if (e) {
      ret += DC[d] * e + p10[d] * e * (e - 1) / 2;
      x -= e * p10[d];
      ret += (x + 1) * e;
    }
  }
  return ret;
}
int single(lint A) {
  int ret = 0;
  while (A) {
    ret += A % 10;
    A /= 10;
  }
  return ret;
}
int main() {
  lint A;
  cin >> A;
  if (A <= 1800) solve1(A);
  DC.resize(18);
  p10.resize(18, 1);
  for (int i = (1), i_end_ = (p10.size()); i < i_end_; i++)
    p10[i] = p10[i - 1] * 10;
  for (int i = (1), i_end_ = (DC.size()); i < i_end_; i++) {
    DC[i] = 45 * i;
    for (int _ = (0), __end_ = (i - 1); _ < __end_; _++) DC[i] *= 10;
  }
  lint lo = 0, hi = 100000000000000000LL;
  while (hi - lo > 1) {
    lint c = (hi + lo) / 2;
    (cnt(c) >= A ? hi : lo) = c;
  }
  lint l = 1, r = hi;
  __int128 nb = cnt(hi);
  while (nb != A) {
    if (nb > A) {
      nb -= single(l);
      l++;
    } else {
      r++;
      nb += single(r);
    }
  }
  cout << l << ' ' << r << '\n';
}

```