// https://www.youtube.com/watch?v=CrymicX875M
// Angel of mercy
// How did you move me
// Why am I on my feet again

#ifndef ONLINE_JUDGE
#include "templates/debug.hpp"
#else
#define debug(...)
#endif

#include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
using u64 = uint64_t;

// #define int i64
void solve() {
    int n, m; cin >> n >> m;
    vector<vector<int>> adj(n);
    for (int e = 0; e < m; e++) {
        int u, v; cin >> u >> v;
        u--, v--;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }
    if (m != n - 1) {
        cout << "NIE\n";
        return;
    }
    for (int u = 0; u < n; u++) {
        if (adj[u].size() > 3) {
            cout << "NIE\n";
            return;
        }
    }
    vector<vector<int>> sons(n);
    constexpr int W = 32;
    // sum when root val is 1
    struct Node {
        i64 sum{}, weight{};
        i64 dep{};
        bool valid = true;

        Node grow() {
            Node res = *this;
            res.sum += res.weight;
            res.weight *= 2;
            res.dep++;
            if (res.dep >= W) res.valid = false;
            return res;
        }

        void update(i64 &ans) {
            if (valid) ans = min(ans, sum);
        }
    };

    auto from_son = [](Node a) {
        Node res = a.grow();
        res.sum++, res.weight++;
        if (res.dep >= W) res.valid = false;
        return res;
    };

    auto merge = [](Node a, Node b) {
        Node res; res.valid = a.valid && b.valid;
        res.sum += min(a.weight, b.weight);
        a = a.grow(), b = b.grow();
        res.sum += a.sum + b.sum;
        res.weight = a.weight + b.weight;
        res.sum++, res.weight++;
        res.dep = max(a.dep, b.dep);
        if (res.dep >= W) res.valid = false;
        return res;
    };

    vector<Node> dp(n);
    function<void(int, int)> pre_calc = [&](int u, int p) {
        vector<Node> children;
        for (int v : adj[u]) {
            if (v == p) continue;
            pre_calc(v, u);
            children.push_back(dp[v]);
            sons[u].push_back(v);
        }
        if (children.empty()) {
            dp[u] = {1, 1, 1, true};
        } else if (children.size() == 1) {
            dp[u] = children[0].grow();
            dp[u].sum++, dp[u].weight++;
        } else if (children.size() == 2) {
            dp[u] = merge(children[0], children[1]);
        }
    };
    pre_calc(0, -1);
    i64 ans = 1e18;
    if (sons[0].size() == 1) {
        dp[sons[0][0]].update(ans);
    } else if (sons[0].size() == 2) {
        merge(dp[sons[0][0]], dp[sons[0][1]]).update(ans);
    }

    function<void(int, int, Node)> reroot = [&](int u, int p, Node from_fa) {
        if (p != -1) {
            if (sons[u].empty()) {
                from_fa.update(ans);
            } else if (sons[u].size() == 1) { 
                merge(from_fa, dp[sons[u][0]]).update(ans);
            }
        }
        
        int m = sons[u].size();
        if (p == -1) {
            if (m == 1) {
                reroot(sons[u][0], u, {1, 1});
            } else if (m == 2) {
                reroot(sons[u][0], u, from_son(dp[sons[u][1]]));
                reroot(sons[u][1], u, from_son(dp[sons[u][0]]));
            } else if (m == 3) {
                reroot(sons[u][0], u, merge(dp[sons[u][1]], dp[sons[u][2]]));
                reroot(sons[u][1], u, merge(dp[sons[u][0]], dp[sons[u][2]]));
                reroot(sons[u][2], u, merge(dp[sons[u][0]], dp[sons[u][1]]));
            }
        } else {
            if (m == 1) {
                reroot(sons[u][0], u, from_son(from_fa));
            } else if (m == 2) {
                reroot(sons[u][0], u, merge(from_fa, dp[sons[u][1]]));
                reroot(sons[u][1], u, merge(from_fa, dp[sons[u][0]]));
            }
        }
    };

    reroot(0, -1, Node{0, 0});
    if (ans == 1e18) cout << "NIE\n";
    else cout << ans << "\n";
}
#undef int

// Make bold hypotheses and verify carefully
int main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int t = 1;
    // cin >> t;
    while (t--) {
        solve();
    };
}