#include <bits/stdc++.h>

using namespace std;
using ll = long long;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, m;
    cin >> n >> m;

    vector<int> powers{1}, edgeCnt{0};

    while (powers.back() < n) {
        powers.push_back(powers.back() * 3);
        edgeCnt.push_back(edgeCnt.back() * 3 + 3);
    }

    if (powers.back() != n || edgeCnt.back() != m) {
        cout << "ne\n";
        return 0;
    }

    vector<vector<int>> adjR(n), adjL(n);
    vector<pair<int, int>> edges(m);
    vector<int> deg(n), used(n + m / 3, -1);

    for (int i = 0; i < m; ++i) {
        int x, y;
        cin >> x >> y;
        x -= 1, y -= 1;
        if (x > y) {
            swap(x, y);
        }
        edges[i] = {x, y};
        deg[x] += 1, deg[y] += 1;
    }

    for (int i = 0; i < m; ++i) {
        auto [x, y] = edges[i];
        if (deg[x] > deg[y]) {
            swap(x, y);
        }
        adjR[x].emplace_back(y);
        adjL[y].emplace_back(x);
    }

    vector<vector<int>> tree(n + m / 3);
    int top = n;

    auto addEdge = [&](int x, int y) {
        tree[x].push_back(y);
        tree[y].push_back(x);
    };

    for (int i = 0; i < n; ++i) {
        for (int to : adjL[i]) {
            used[to] = i;
        }
        for (int to : adjL[i]) {
            for (int k : adjR[to]) {
                if (used[k] == i) {
                    addEdge(top, i);
                    addEdge(top, to);
                    addEdge(top, k);
                    top += 1;
                }
            }
        }
    }

    if (top != n + m / 3) {
        cout << "ne\n";
        return 0;
    }

    auto isTree = [&](auto self, int v, int par) -> int {
        if (used[v]) {
            cout << "ne\n";
            exit(0);
        }
        used[v] = true;
        int siz = 1;
        for (int to : tree[v]) {
            if (to != par) {
                siz += self(self, to, v);
            }
        }
        return siz;
    };

    if (isTree(isTree, 0, -1) != n + m / 3) {
        cout << "ne\n";
        return 0;
    }

    vector<int> siz(n + m / 3);
    fill(used.begin(), used.end(), false);

    auto dfsSz = [&](auto self, int v, int par) -> void {
        siz[v] = 1;
        for (int to : tree[v]) {
            if (to != par && !used[to]) {
                self(self, to, v);
                siz[v] += siz[to];
            }
        }
    };

    auto centroid = [&](auto self, int v, int par, int x) -> int {
        for (int to : tree[v]) {
            if (to != par && !used[to] && siz[to] * 2 > x) {
                return self(self, to, v, x);
            }
        }
        return v;
    };

    auto check = [&](auto self, int v, int id) -> bool {
        used[v] = true;
        dfsSz(dfsSz, v, -1);
        if (v < n && siz[v] == 1 && id == 0) {
            return true;
        }
        if (powers[id] + edgeCnt[id] / 3 != siz[v] || v < n) {
            return false;
        }
        for (int to : tree[v]) {
            if (!used[to]) {
                if (!self(self, centroid(centroid, to, v, siz[to]), id - 1)) {
                    return false;
                }
            }
        }
        return true;
    };

    dfsSz(dfsSz, 0, -1);

    if (check(check, centroid(centroid, 0, -1, n + m / 3), size(powers) - 1)) {
        cout << "da\n";
    } else {
        cout << "ne\n";
    }

    return 0;
}