#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};

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

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

    vector<vector<pair<int, int>>> adj(n);
    vector<pair<int, int>> edges(m);
    vector<bool> deleted(m);
    vector<int> deg(n), used(n);

    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};
    }

    sort(edges.begin(), edges.end());

    for (int i = 0; i < m; ++i) {
        auto [x, y] = edges[i];
        deg[x] += 1, deg[y] += 1;
        adj[x].emplace_back(y, i);
        adj[y].emplace_back(x, i);
    }

    auto findEdge = [&](int x, int y) {
        if (x > y) {
            swap(x, y);
        }
        auto it = lower_bound(edges.begin(), edges.end(), pair(x, y));
        return it == edges.end() || *it != pair(x, y) ? -1 : it - edges.begin();
    };

    int T = 0;

    auto check = [&](auto self, int source, vector<int> nt) -> bool {
        vector<int> ord;
        T += 1;
        auto dfs = [&](auto dfs, int v) -> void {
            ord.push_back(v);
            used[v] = T;
            for (auto [to, i] : adj[v]) {
                if (used[to] != T && !deleted[i]) {
                    dfs(dfs, to);
                }
            }
        };
        dfs(dfs, source);
        if (size(ord) == 1) {
            return true;
        }
        for (int x : nt) {
            if (find(ord.begin(), ord.end(), x) != ord.end()) {
                return false;
            }
        }
        if (!binary_search(powers.begin(), powers.end(), size(ord))) {
            return false;
        }
        nth_element(ord.begin(), ord.begin() + 3, ord.end(), [&](int x, int y) { return deg[x] > deg[y]; });
        int a = ord[0], b = ord[1], c = ord[2];
        int ab = findEdge(a, b), bc = findEdge(b, c), ac = findEdge(a, c);
        if (ab == -1 || bc == -1 || ac == -1) {
            return false;
        }
        deleted[ab] = deleted[bc] = deleted[ac] = true;
        deg[a] -= 1, deg[b] -= 1, deg[c] -= 1;
        return self(self, a, {b, c}) && self(self, b, {a, c}) && self(self, c, {a, b});
    };

    if (check(check, 0, {})) {
        cout << "da\n";
    } else {
        cout << "ne\n";
    }

    return 0;
}