#include <iostream>
#include <vector>
#include <fstream>
#include <queue>
#include <climits>
using namespace std;

ifstream fin("maxflow.in");
ofstream fout("maxflow.out");

class graf {
    int nrN;
    int nrM;
    vector<vector<int>> matriceAd;

public:
    graf(int n, int m, vector<vector<int>> &mat) {
        nrN = n;
        nrM = m;
        matriceAd = mat;
    }

    graf(int n, int m) {
        nrN = n;
        nrM = m;
    }

//    void citire_neorientat() {
//        for (int i = 0; i < nrM; ++i) {
//            int x, y;
//            fin >> x >> y;
//            matriceAd[x].push_back(y);
//            matriceAd[y].push_back(x);
//        }
//    }
//
//    void citire_orientat() {
//        for (int i = 0; i < nrM; ++i) {
//            int x, y;
//            fin >> x >> y;
//            matriceAd[x].push_back(y);
//        }
//    }
//
//    void citire_sortaret(vector<int> &dep){
//        for (int i = 0; i < nrM; ++i) {
//            int x, y;
//            fin>>x>>y;
//            matriceAd[x].push_back(y);
//            dep[y]++;
//        }
//    }
//
//    void citire_dijkstra(vector<vector<int>>& mat){
//        int a, b, c;
//        for (int i = 0; i < nrM; ++i) {
//            fin>>a>>b>>c;
//            mat[a][b] = c;
//        }
//    }
//
//    void BFS(int S) {
//        queue<int> coada;
//        int x, y;
//        vector<int> cost(nrN + 1, -1);
//        cost[S] = 0;
//        coada.push(S);
//        while (!coada.empty()) {
//            x = coada.front();
//            coada.pop();
//            for (int i = 0; i < matriceAd[x].size(); ++i) {
//                if (cost[matriceAd[x][i]] == -1) {
//                    cost[matriceAd[x][i]] = cost[x] + 1;
//                    coada.push(matriceAd[x][i]);
//                }
//            }
//        }
//        for (int i = 1; i < nrN + 1; i++)
//            fout << cost[i] << " ";
//    }
//
//    void DFS() {
//        queue<int> coada;
//        vector<int> viz(nrN + 1, 0);
//        int conex = 0;
//        for (int i = 1; i <= nrN; ++i) {
//            if (viz[i] == 0) {
//                conex++;
//                coada.push(i);
//                while (!coada.empty()) {
//                    int x = coada.front();
//                    viz[x]++;
//                    coada.pop();
//                    for (int j = 1; j < matriceAd[x].size(); ++j) {
//                        if (viz[matriceAd[x][j]] == 0)
//                            coada.push(matriceAd[x][j]);
//                    }
//                }
//            }
//        }
//        fout << conex;
//    }
//
//    void sortaret(vector<int> &dep){
//        queue<int> coada;
//        vector<int> sortare;
//        for (int i = 1; i < nrN + 1; ++i) {
//            if (dep[i] == 0)
//                coada.push(i);
//        }
//        while (!coada.empty()){
//            int x = coada.front();
//            sortare.push_back(x);
//            coada.pop();
//            for (int i = 1; i < matriceAd[x].size(); ++i) {
//                dep[matriceAd[x][i]]--;
//                if (dep[matriceAd[x][i]] == 0)
//                    coada.push(matriceAd[x][i]);
//            }
//        }
//        for (int i = 0; i < nrN; ++i) {
//            fout<<sortare[i]<<" ";
//        }
//    }
//
//    int reprez(int& x, vector<int> tata){
//        while (tata[x] != 0)
//            x = tata[x];
//        return x;
//    }
//
//    void op1(vector<int>& tata, vector<int>& h, int x, int y){
//        int a = reprez(x, tata), b = reprez(y, tata);
//        if (h[a] > h[b])
//            tata[b] = a;
//        else {
//            tata[a] = b;
//            if (h[a] == h[b])
//                h[b]++;
//        }
//    }
//
//    void op2(int x, int y, vector<int> tata){
//        if (x == y)
//            fout<<"DA"<<endl;
//        else
//            fout<<"NU"<<endl;
//    }
//
//    void solveDisjoint(){
//        vector<int> tata(nrN + 1, 0), h(nrN + 1, 0);
//        int op, x, y;
//        for (int i = 0; i < nrM; ++i) {
//            fin>>op>>x>>y;
//            if (op == 1)
//                op1(tata, h, x, y);
//            else
//                op2(reprez(x, tata), reprez(y, tata), tata);
//        }
//    }
//
//    int minDist(vector<int>& dist, vector<bool>& SP){
//        int min = INT_MAX, j;
//        for (int i = 0; i < nrN; ++i) {
//            if (!SP[i] && dist[i] <= min) {
//                min = dist[i];
//                j = i;
//            }
//        }
//        return j;
//    }
//
//    void dijkstra(vector<vector<int>>& mat, int s){
//        vector<int> dist (nrN + 1, INT_MAX);
//        vector<bool> shortestPath (nrN + 1, false);
//        dist[s] = 0;
//        for (int i = 0; i < nrN - 1; ++i) {
//            int u = minDist(dist, shortestPath);
//            cout<<u;
//            shortestPath[u] = true;
//            for (int j = 1; j <= nrN; ++j) {
//                if (!shortestPath[j] && mat[u][j] && dist[u] != INT_MAX && dist[u] + mat[u][j] < dist[j])
//                    dist[j] = dist[u] + mat[u][j];
//            }
//        }
//        for (int i = 2; i <= nrN; ++i) {
//            fout<<dist[i]<<' ';
//        }
//    }

    void flux(){
        vector<vector<pair<int,int>>> capacitate, flux;
        capacitate[1].push_back(make_pair(1,2));
    };
};

///BFS
//int main(){
//    int n, m, S;
//    fin >> n >> m >> S;
//    vector<vector<int>> mat;
//    vector<int> aux(1,-1);
//    mat.resize(n+1, aux);
//    graf G(n, m, mat);
//    G.citire_orientat();
//    G.BFS(S);
//    return 0;
//}

///DFS
//int main(){
//    int n, m;
//    fin>>n>>m;
//    vector<vector<int>> mat;
//    vector<int> aux(1,-1);
//    mat.resize(n+1, aux);
//    graf G(n, m, mat);
//    G.citire_neorientat();
//    G.DFS();
//    return 0;
//}

///sortaret
//int main(){
//    int n, m;
//    fin>>n>>m;
//    vector<int> dep(n + 1, 0);
//    vector<vector<int>> mat;
//    vector<int> aux(1,-1);
//    mat.resize(n+1, aux);
//    graf G(n, m, mat);
//    G.citire_sortaret(dep);
//    G.sortaret(dep);
//    return 0;
//}

///disjoint
//int main(){
//    int n, m;
//    fin>>n>>m;
//    graf G(n , m);
//    G.solveDisjoint();
//    return 0;
//}

///dijkstra
//int main(){
//    int n, m;
//    fin>>n>>m;
//    graf G(n, m);
//    vector<vector<int>> matAd;
//    vector<int> sec(n + 1, 0);
//    matAd.resize(n + 1, sec);
//    G.citire_dijkstra(matAd);
//    G.dijkstra(matAd, 1);
//    return 0;
//}

/////maxflow
int main(){
    int n, m;
    fin>>n>>m;
    vector<vector<int>> mat;
    vector<int> aux(1,-1);
    mat.resize(n+1, aux);
    graf G(n, m, mat);
    G.flux();
    return 0;
}