using namespace std;
int clamp(int x) { return max(0, min(x, 9)); }
int main(void)
{
    int m, s;
    cin >> m >> s;
    int minv[m];
    int maxv[m];
    int temp_sum = s;
    int v;
    for (int i = 0; i < m; ++i)
    {
        v = clamp(temp_sum);
        temp_sum -= v;
        maxv[i] = v;
    }
    temp_sum = s - 1;
    for (int i = m - 1; i > 0; --i)
    {
        v = clamp(temp_sum);
        temp_sum -= v;
        minv[i] = v;
    }
    minv[0] = temp_sum + 1;
    if ((minv[0] == 0 and not(s == 0 and m == 1)) or minv[0] > 9)
        cout << "-1 -1\n";
    else
    {
        for (int i = 0; i < m; ++i)
            cout << minv[i];
        cout << " ";
        for (int i = 0; i < m; ++i)
            cout << maxv[i];
        cout << endl;
    }
    return 0;
}

using namespace std;
using ll = long long;
using ii = pair<int, int>;
using vi = vector<int>;
int const NMAX = 21;
int n;
char table[NMAX][NMAX];
bool vis[NMAX][NMAX];
vector<ii> directions = {
    {-1, 0}, {-1, 1}, {0, 1}, {1, 1}, {1, 0}, {1, -1}, {0, -1}, {-1, -1}};
bool cmp(string const &a, string const &b)
{
    if ((int)a.size() == (int)b.size())
        return a < b;
    else
        return (int)a.size() < (int)b.size();
};
set<string, decltype(cmp) *> unique_words(cmp);
inline bool in_bounds(int r, int c)
{
    return 0 <= r and r < n and 0 <= c and c < n;
}
vector<ii> neighbors(int r, int c)
{
    vector<ii> ans;
    for (auto [dr, dc] : directions)
        if (in_bounds(r + dr, c + dc) and table[r + dr][c + dc] > table[r][c])
            ans.emplace_back(r + dr, c + dc);
    return ans;
}
void backtrack(int r, int c, string s = "")
{
    vis[r][c] = true;
    s += table[r][c];
    if ((int)s.size() >= 3)
        unique_words.emplace(s);
    for (auto [rr, cc] : neighbors(r, c))
    {
        if (vis[rr][cc])
            continue;
        backtrack(rr, cc, s);
    }
    vis[r][c] = false;
}
int main(void)
{
    int t;
    cin >> t;
    while (t--)
    {
        cin >> n;
        unique_words.clear();
        for (int r = 0; r < n; ++r)
            for (int c = 0; c < n; ++c)
                cin >> table[r][c];
        for (int r = 0; r < n; ++r)
            for (int c = 0; c < n; ++c)
                backtrack(r, c);
        for (auto s : unique_words)
            cout << s << endl;
        if (t > 0)
            cout << endl;
    }
    return 0;
}

using namespace std;
const int NMAX = 1e5 + 11;
const int ALPHA_SZ = 2;
int n, a[NMAX];
struct tnode
{
    int val;
    tnode *children[ALPHA_SZ];
    tnode()
    {
        this->val = -1;
        for (int i = 0; i < ALPHA_SZ; ++i)
            this->children[i] = nullptr;
    }
    ~tnode()
    {
        for (int i = 0; i < ALPHA_SZ; ++i)
        {
            if (this->children[i] != nullptr)
                delete (this->children[i]);
            this->children[i] = nullptr;
        }
        val = 0;
    }
};
void insert(tnode *root, int key)
{
    tnode *v = root;
    for (int i = 31; i >= 0; --i)
    {
        int ix = (key >> i) & 1;
        if (v->children[ix] == nullptr)
            v->children[ix] = new tnode();
        v = v->children[ix];
    }
    v->val = key;
}
int query(tnode *root, int key)
{
    tnode *v = root;
    for (int i = 31; i >= 0; --i)
    {
        int ix = !((key >> i) & 1);
        if (v->children[ix] != nullptr)
            v = v->children[ix];
        else
            v = v->children[1 - ix];
    }
    return v->val;
}
int main(void)
{
    int t, ans, acc;
    cin >> t;
    while (t--)
    {
        cin >> n;
        for (int i = 0; i < n; ++i)
            cin >> a[i];
        acc = ans = 0;
        tnode *root = new tnode();
        insert(root, acc);
        for (int i = 0; i < n; ++i)
        {
            acc = acc ^ a[i];
            ans = max(ans, acc ^ query(root, acc));
            insert(root, acc);
        }
        cout << ans << endl;
        delete (root);
    }
    return 0;
}

using namespace std;
using ll = long long;
using vll = vector<ll>;
int n;
vll psum;
ll solve(void)
{
    if (n < 3 or psum[n] % 3 != 0)
        return 0;
    ll target = psum[n] / 3;
    vll ix[3];
    for (int i = 1; i <= n; ++i)
        for (int k = 1; k <= 3; ++k)
            if (psum[i] == k * target)
                ix[k - 1].push_back(i);
    ll ans = 0;
    for (auto i0 : ix[0])
    {
        auto it1 = upper_bound(ix[1].begin(), ix[1].end(), i0);
        ans += max((ll)distance(it1, ix[1].end()) - (target == 0), 0LL);
    }
    return ans;
}
int main(void)
{
    cin >> n;
    psum.resize(n + 1, 0);
    for (int i = 1; i <= n; ++i)
        cin >> psum[i], psum[i] += psum[i - 1];
    cout << solve() << endl;
    return 0;
}

using namespace std;
using vi = vector<int>;
using ll = long long;
const int NMAX = 1e5 + 11;
const int MOD = 1e9 + 7;
int n;
bool black[NMAX];
vi g[NMAX];
ll B[NMAX], W[NMAX];
inline ll m(ll x, ll y) { return ((x % MOD) * (y % MOD)) % MOD; }
inline ll p(ll x, ll y) { return ((x % MOD) + (y % MOD)) % MOD; }
void dfs(int u, int parent)
{
    ll bu, wu;
    B[u] = (black[u]);
    W[u] = (!black[u]);
    for (auto v : g[u])
    {
        if (v == parent)
            continue;
        dfs(v, u);
        bu = B[u];
        wu = W[u];
        B[u] = W[u] = 0;
        W[u] = m(W[v], wu);
        B[u] = p(m(bu, W[v]), m(B[v], wu));
        W[u] = p(W[u], m(wu, B[v]));
        B[u] = p(B[u], m(bu, B[v]));
    }
}
int main(void)
{
    int pi, root;
    cin >> n;
    for (int i = 0; i < n - 1; ++i)
    {
        cin >> pi;
        g[pi].push_back(i + 1);
        g[i + 1].push_back(pi);
    }
    for (int i = 0; i < n; ++i)
    {
        cin >> black[i];
        if (black[i])
            root = i;
    }
    dfs(root, -1);
    cout << B[root] << endl;
    return 0;
}

using namespace std;
using ll = long long;
int n;
int a[300010];
ll solve(void)
{
    ll ans = 0;
    ll w = 2;
    sort(a, a + n);
    for (int i = 0; i < n - 1; ++i)
    {
        ans += w * a[i];
        ++w;
    }
    return ans + (w - 1) * a[n - 1];
}
int main(void)
{
    cin >> n;
    for (int i = 0; i < n; ++i)
        cin >> a[i];
    cout << solve() << endl;
    return 0;
}

using namespace std;
map<string, bool> was_already_collected;
int main(void)
{
    int n, counter = 0;
    string tree_kind;
    cin >> n;
    cin.ignore();
    while (n--)
    {
        getline(cin, tree_kind);
        if (not was_already_collected[tree_kind])
            ++counter;
        was_already_collected[tree_kind] = true;
    }
    cout << counter << endl;
    return 0;
}

using namespace std;
using ll = long long;
using ii = pair<int, int>;
using vi = vector<int>;
using predicate = function<bool(ll)>;
ll n, m, k;
ll n_smaller(ll x)
{
    ll ans = 0;
    for (int row = 1; row <= n; ++row)
        ans += min((x - 1) / row, m);
    return ans;
}
ll bs(ll lo, ll hi, predicate p)
{
    while (lo < hi)
    {
        ll mid = lo + (hi - lo + 1) / 2;
        if (p(mid))
            lo = mid;
        else
            hi = mid - 1;
    }
    return lo;
}
int main(void)
{
    cin >> n >> m >> k;
    cout << bs(1, 1e12, [](ll x) { return n_smaller(x) < k; }) << endl;
    return 0;
}

using namespace std;
using ll = long long;
using pqll = priority_queue<ll>;
const ll NMAX = 1e3 + 11;
const ll KMAX = 1e6 + 11;
ll n, m, k, p;
ll rowsum[NMAX], colsum[NMAX];
ll a[KMAX], b[KMAX];
pqll pqrow;
pqll pqcol;
ll solve(void)
{
    ll pleasure(0), maxrow(0), maxcol(0);
    a[0] = b[0] = 0;
    for (int i = 1; i <= k; ++i)
    {
        maxrow = pqrow.top();
        pqrow.pop();
        pqrow.push(maxrow - m * p);
        a[i] = a[i - 1] + maxrow;
        maxcol = pqcol.top();
        pqcol.pop();
        pqcol.push(maxcol - n * p);
        b[i] = b[i - 1] + maxcol;
    }
    pleasure = a[0] + b[k];
    for (ll i = 1; i <= k; ++i)
        pleasure = max(pleasure, a[i] + b[k - i] - (i * (k - i) * p));
    return pleasure;
}
int main(void)
{
    cin >> n >> m >> k >> p;
    ll x;
    for (int row = 0; row < n; ++row)
    {
        for (int col = 0; col < m; ++col)
        {
            cin >> x;
            rowsum[row] += x;
            colsum[col] += x;
        }
    }
    for (int row = 0; row < n; ++row)
        pqrow.push(rowsum[row]);
    for (int col = 0; col < m; ++col)
        pqcol.push(colsum[col]);
    cout << solve() << endl;
    return 0;
}

using namespace std;
using ll = long long;
using predicate = function<bool(int)>;
int const NMAX = 1e5 + 11;
int n, m, a[NMAX], b[NMAX];
ll cost(int x)
{
    ll ans = 0;
    for (int i = 0; i < n; ++i)
        ans += max(a[i], x) - a[i];
    for (int i = 0; i < m; ++i)
        ans += b[i] - min(b[i], x);
    return ans;
}
int bs(int l, int r, predicate p)
{
    while (l < r)
    {
        int mid = l + (r - l) / 2;
        if (p(mid))
            r = mid;
        else
            l = mid + 1;
    }
    return l;
}
int main(void)
{
    cin >> n >> m;
    for (int i = 0; i < n; ++i)
        cin >> a[i];
    for (int i = 0; i < m; ++i)
        cin >> b[i];
    int x = bs(0, *max_element(b, b + m), [](int x) {
        return (cost(x + 1) - cost(x)) >= 0;
    });
    cout << cost(x) << endl;
    return 0;
}