#include <bits/stdc++.h>
#define FOR(i, n) for(int i = 0; i < (n); ++i)
#define REP(i, a, b) for(int i = (a); i < (b); ++i)
#define TRAV(i, a) for(auto & i : (a))
#define SZ(x) ((int)(x).size())
#define X first
#define Y second
#define PR std::pair
#define MP std::make_pair
typedef long long ll;
typedef std::pair<int, int> PII;
typedef std::vector<int> VI;

int n, d;
std::vector<VI> g;

void attack(){
    std::cout << "ATTACK" << std::endl;

    std::vector<int> taken(n);
    FOR(i, d){
        int a;
        std::cin >> a;
        taken[a] = 1;
    }

    auto process = [&](){
        int x;
        if(std::cin >> x){

        }else{
            std::exit(0);
        }

        FOR(i, x){
            int a, b;
            std::cin >> a >> b;
            taken[a]--;
            taken[b]++;
        }
    };

    FOR(i, n){
        if(!taken[i] && SZ(g[i]) == 1){
            std::cout << i << std::endl;
            process();
            break;
        }
    }

    int my = -1;
    FOR(i, n) if(!taken[i] && SZ(g[i]) >= 3){
        my = i;
        break;
    }
    assert(my != -1);

    std::function<void(int, int)> rec = [&](int root, int ost){
        
        VI lis(n);
        VI zam(n);
        VI pp(n);
        VI sz(n);
        std::vector<VI> vec(n);
        VI all;
        int CUR;
        std::function<void(int, int)> dfs = [&](int v, int par){
            pp[v] = par;
            all.push_back(v);
            sz[v] = 1;
            if(SZ(g[v]) == 1){
                lis[v] = 1;
                vec[CUR].push_back(v);
            }
            zam[v] = taken[v];

            TRAV(ch, g[v]) if(ch != par){
                dfs(ch, v);
                lis[v] += lis[ch];
                sz[v] += sz[ch];
                zam[v] += zam[ch];
            }
        };

        TRAV(ch, g[root]) if(ch != ost){
            CUR = ch;
            all.clear();
            dfs(ch, root);
        }

        bool good = false;
        TRAV(ch, g[root]) if(ch != ost && sz[ch] - lis[ch] <= zam[ch]){

            int wyb = -1;
            TRAV(l, vec[ch]){
                if(!taken[l]){
                    wyb = l;
                    break;
                }
            }

            std::cout << wyb << std::endl;
            process();
            std::fill(lis.begin(), lis.end(), 0);
            std::fill(zam.begin(), zam.end(), 0);
            std::fill(sz.begin(), sz.end(), 0);

            all.clear();
            dfs(ch, root);

            TRAV(x, all){
                if(SZ(g[x]) > 1 && !taken[x] && sz[x] - lis[x] <= zam[x]){
                    rec(x, pp[x]);
                    std::exit(0);
                }
            }

            assert(false);
            // assert(wyb != -1);
            // good = true;
            // break;
        }
        // assert(good);
    };

    rec(my, -1);
}

void wyjeb(){
    int a = 0;
    while(true){
        a++;
    }
}

void defend(){
    std::cout << "DEFEND" << std::endl;

    std::vector<bool> leaf(n);
    std::function<void(int, int)> dfs = [&](int v, int par){
        if(SZ(g[v]) == 1){
            leaf[v] = true;
        }
        TRAV(ch, g[v]) if(ch != par) dfs(ch, v);
    };
    dfs(0, -1);

    std::vector<bool> taken(n);

    int my = -1;
    int have = d;
    FOR(i, n) if(!leaf[i]){
        taken[i] = true;
        have--;
    }

    assert(have > 0);
    wyjeb();
    FOR(i, n) if(leaf[i] && have > 0){
        have--;
        if(my == -1) my = i;
        taken[i] = true;
    }

    bool space = false;
    FOR(i, n){
        if(taken[i]){
            if(space) std::cout << " ";
            std::cout << i;
            space = true;
        }
    }
    std::cout << std::endl;

    while(true){
        int co;
        std::cin >> co;
        if(co == -1) break;

        if(taken[co]){
            std::cout << 0 << std::endl;
        }else{
            std::vector<int> stack;
            std::vector<PII> pr;
            std::function<void(int, int)> xd = [&](int v, int par){
                stack.push_back(v);
                if(v == co){
                    FOR(i, SZ(stack)-1){
                        pr.push_back(MP(stack[i], stack[i+1]));
                    }
                }
                TRAV(ch, g[v]) if(ch != par){
                    xd(ch, v);
                }
                stack.pop_back();
            };

            xd(my, -1);
            taken[my] = false;
            taken[co] = true;
            my = co;

            std::cout << SZ(pr);
            TRAV(x, pr){
                std::cout << " " << x.X << " " << x.Y;
            }
            std::cout << std::endl;
        }
    }
}

int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(0);

    std::cin >> n >> d;
    g.resize(n);

    FOR(i, n-1){
        int a, b;
        std::cin >> a >> b;
        g[a].push_back(b);
        g[b].push_back(a);
    }

    int l = 0;
    FOR(i, n) if(SZ(g[i]) == 1) l++;

    if(d >= n-l+1){
        defend();
    }else{
        attack();
    }

    return 0;
}