#include <bits/stdc++.h>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
#pragma GCC target("avx2")
#pragma GCC optimize("O3, bmi, unroll-loops")
#pragma GCC optimize("inline")

using namespace __gnu_pbds;
using namespace std;

template <class T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

typedef long long ll;
typedef long double ld;

//#define int ll
#define ALL(x) x.begin(), x.end()

const int MAXN = 15005;
const int INF = 1e9 + 7;
const int MOD = 1e9 + 7;

struct segmentTree
{
    vector<int> t;
    vector<int> lazy;
    int sz = 1;
    void build(int v, int l, int r)
    {
        if(r - l == 1)
        {
            t[v] = 0;
            return;
        }
        int m = (r + l) / 2;
        build(v * 2, l, m);
        build(v * 2 + 1, m, r);
        t[v] = t[v * 2] + t[v * 2 + 1];
    }
    segmentTree(int n)
    {
        sz = n;
        t.resize(sz * 4, 0);
        lazy.resize(sz * 4, 0);
        //build(1, 0, sz);
    }
    void push(int v, int l, int r)
    {
        int m = (l + r) / 2;
        t[v * 2] += lazy[v] * (m - l);
        t[v * 2 + 1] += lazy[v] * (r - m);
        lazy[v * 2] += lazy[v];
        lazy[v * 2 + 1] += lazy[v];
        lazy[v] = 0;
    }
    int get(int v, int l, int r, int L, int R)
    {
        if(r <= L || l >= R)
        {
            return 0;
        }
        if(L <= l && r <= R)
        {
            return t[v];
        }
        push(v, l, r);
        int m = (l + r) / 2;
        return get(v * 2, l, m, L, R) + get(v * 2 + 1, m, r, L, R);
    }
    int get(int l, int r)
    {
        return get(1, 0, sz, l, r);
    }

    void update(int v, int l, int r, int L, int R, int x)
    {
        if(r <= L || l >= R)
        {
            return;
        }
        if(L <= l && r <= R)
        {
            t[v] += x * (r - l);
            lazy[v] += x;
            return;
        }
        push(v, l, r);
        int m = (l + r) / 2;
        update(v * 2, l, m, L, R, x);
        update(v * 2 + 1, m, r, L, R, x);
        t[v] = t[v * 2] + t[v * 2 + 1];
    }

    void update(int l, int r, int x)
    {
        update(1, 0, sz, l, r, x);
    }
};

struct Vec
{
    int x, y;
    Vec()
    {

    }
    Vec(int a, int b)
    {
        x = a;
        y = b;
    }
    int operator %(Vec a)
    {
        return x * a.y - y * a.x;
    }
    int operator *(Vec a)
    {
        return x * a.x + y * a.y;
    }
    Vec operator -(Vec a)
    {
        return {x - a.x, y - a.y};
    }
    Vec operator +(Vec a)
    {
        return {x + a.x, y + a.y};
    }
    Vec operator *(int k)
    {
        return {x * k, y * k};
    }
    int len2(Vec a)
    {
        return (x - a.x) * (x - a.x) + (y - a.y) * (y - a.y);
    }
    ld len(Vec a)
    {
        return sqrtl(len2(a));
    }
};
istream& operator >>(istream& in, Vec& x)
{
    in >> x.x >> x.y;
    return in;
}

ostream& operator <<(ostream& out, Vec& x)
{
    out << x.x << ' ' << x.y;
    return out;
}

struct fenvik
{
    vector<int> fen;
    int sz = 0;
    fenvik(int n)
    {
        sz = n;
        fen.resize(n + 1, 0);
    }

    int get(int pos)
    {
        int ans = 0;
        for (int i = pos; i > 0; i -= i & -i)
        {
            ans += fen[i];
        }
        return ans;
    }

    void change(int pos, int x)
    {
        for (int i = pos; i <= sz; i += i & -i)
        {
            fen[i] += x;
        }
    }
};

int binpow(int base, int exp, int mod = MOD)
{
    if(exp == 0)
    {
        return 1;
    }
    if(exp % 2 == 0)
    {
        auto gg = binpow(base, exp / 2,  mod);
        return gg * gg % mod;
    }
    return base * binpow(base, exp - 1, mod) % mod;
}




/*namespace hld
{
    int tin[MAXN];
    int tout[MAXN];
    int timer = 0;
    int head[MAXN];
    int sz[MAXN];
    int pr[MAXN];
    vector<int> g[MAXN];

    bool isLca(int a, int b)
    {
        return tin[a] <= tin[b] && tout[b] <= tout[a];
    }

    void getSz(int x, int p)
    {
        sz[x] = 1;
        pr[x] = p;
        for (auto& i : g[x])
        {
            if(i != p)
            {
                getSz(i, x);
                sz[x] += sz[i];
                if(g[x][0] == p || sz[g[x][0]] < sz[i])
                {
                    swap(g[x][0], i);
                }
            }
        }
    }

    void dfs2(int x, int p)
    {
        tin[x] = timer++;
        for (auto i: g[x])
        {
            if(i != p)
            {
                if(i == g[x][0])
                {
                    head[i] = head[x];
                }
                else
                {
                    head[i] = i;
                }
                dfs2(i, x);
            }

        }
        tout[x] = timer;
    }
    int n;
    segmentTree st(n * 3);
    int getPath(int u, int v)
    {
        int ans = 0;
        while(!isLca(head[u], v))
        {
            ans += st.get(tin[head[u]], tin[v]); //!!!!не на полуинтервале а на отрезке!!!!
            u = pr[head[u]];
        }
        while(!isLca(head[v], u))
        {
            ans += st.get(tin[head[v]], tin[u]);   //!!!!не на полуинтервале а на отрезке!!!!
            v = pr[head[v]];
        }
        ans += st.get(tin[u], tin[v]);   //!!!!не на полуинтервале а на отрезке!!!!
        return ans;
    }

}

namespace centroid
{
    int sz[MAXN];
    vector<int> g[MAXN];
    bool used[MAXN];
    void getSz(int x, int p)
    {
        sz[x] = 1;
        for (auto& i : g[x])
        {
            if(i != p && !used[i])
            {
                getSz(i, x);
                sz[x] += sz[i];
                if(g[x][0] == p || sz[g[x][0]] < sz[i])
                {
                    swap(g[x][0], i);
                }
            }
        }
    }

    int findCentroid(int x, int p, int n)
    {
        for (auto& i : g[x])
        {
            if(i != p && !used[i])
            {
                if(sz[i] > n / 2)
                {
                    return findCentroid(i, x, n);
                }
            }
        }
        return x;
    }
}*/

//int dp[MAXN][MAXN];

vector<int> g[MAXN];
vector<int> gr[MAXN];

vector<int> topSort;

vector<int> comp[MAXN];
vector<int> comp1[MAXN];

int color[MAXN];

int color1[MAXN];

bool used[MAXN];
bool used1[MAXN];


void dfs(int x)
{
    used[x] = 1;
    for(auto i : g[x])
    {
        if(!used[i])
        {
            dfs(i);
        }
    }
    topSort.push_back(x);
}

void dfs1(int x, int c)
{
    color[x] = c;
    used1[x] = 1;
    for(auto i : gr[x])
    {
        if(!used1[i])
        {
            dfs1(i, c);
        }
    }
}

void dfs2(int x, int c)
{
    color1[x] = c;
    used1[x] = 1;
    for(auto i : gr[x])
    {
        if(!used1[i])
        {
            dfs2(i, c);
        }
    }
}

int cnt = 0;

int st = 0;

void dfs3(int x)
{
    used[x] = 1;
    for(auto i : g[x])
    {
        if(used[i] && x == st)
        {
            cnt++;
        }
        if(!used[i])
        {
            dfs3(i);
        }
    }
}

void solve()
{
    int n, m, gg;
    cin >> n >> m >> gg;
    
    cout << n - 1 << '\n' << 1;
}


int32_t main()
{
    cin.tie(0);
    ios_base::sync_with_stdio(0);
    int t = 1;
    //cin >> t;
    while (t--)
    {
        solve();
    }
}
