#include<bits/stdc++.h>
/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
tree<long long,null_type,std::less<long long>,rb_tree_tag,tree_order_statistics_node_update> t;
*/
//*t.find_by_order(x) element number x.
//t.order_of_key(y) number of elements (x) where the compare function is true for x,y.
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;

//Below classes and functions are created by SPatrik.
ll good_rand()
{
    return rand()*RAND_MAX+rand(); //A rand that returns higher values.
}
ll high_rand()
{
    ll ran=rand()*RAND_MAX;
    ran*=RAND_MAX;
    ran+=rand()*RAND_MAX+rand();
    return ran; //A rand that returns even higher values.
}
template<class A> //Additional functions: Automatic resize of the vector in case of using index of element that is not part of the vector. Print and read functions, to make input and output faster
class myvector : public std::vector<A> //read function has 2 parameters. A template (n) (operator (int)<n must be defined) and a bool. If true we also cin>>n. If true, n must have defined cin>> If using print or read, the elements of the vector must have defined cin>> or cout<<
{
public:
    A& operator[](int pos)
    {
        if (pos<0) pos=0;
        while (this->size() <= pos)
        {
            this->push_back({});
        }
        return std::vector<A>::operator[](pos);
    }
    void print(bool b=false)
    {
        unsigned int si=this->size();
        if (b) std::cout<<si<<std::endl;
        for (unsigned int i = 0; i < si; ++i)
        {
            std::cout << this->operator[](i) << " ";
        }
    }
    void printendl(bool b=false)
    {
        print(b);
        std::cout << std::endl;
    }
    void good_random_shuffle()
    {
        unsigned int si=this->size();
        for (unsigned int i=0; i<si-1; ++i)
        {
            unsigned int j=good_rand()%(si-i);
            j+=i;
            swap(this->operator[](i), this->operator[](j));
        }
    }
    template<class B>
    void read(B &n, bool b=false)
    {
        if (b) std::cin>>n;
        for (int i=0; i<n; ++i)
        {
            std::cin>>this->operator[](i);
        }
    }
    void push_to(int pos, int val)
    {
        while (this->size()>pos)
        {
            int newval=this->operator[](pos);
            this->operator[](pos)=val;
            val=newval;
            ++pos;
        }
        this->operator[](pos)=val;
    }
};
template<class A>
class myqueue: public std::queue<A>
{
public:
    A front() const
    {
        if (this->empty()) return{};
        return std::queue<A>::front();
    }
    A top() const
    {
        return front();
    }
    void pop()
    {
        if (this->empty()) return;
        std::queue<A>::pop();
    }
    A take()
    {
        A a = this->front();
        this->pop();
        return a;
    }
    void print(bool b=false)
    {
        while(!this->empty())
        {
            std::cout<<take()<<" ";
        }
    }
    void printendl(bool b=false)
    {
        print(b);
        std::cout<<std::endl;
    }
};
template<class A, class B=std::less<typename std::vector<A>::value_type> >//1 or 2 arguments. Unlikely priority_queue, the second argument is the compare. If there are no elements of the priority_queue top() returns a default value (for example 0 if it is an int).
class mypriority_queue : public std::priority_queue<A, std::vector<A>, B>//take() returns the top() value and also runs the pop() function.
{
public:
    A top() const
    {
        if (this->empty()) return{};
        return std::priority_queue<A, std::vector<A>, B>::top();
    }
    void pop()
    {
        if (this->empty()) return;
        std::priority_queue<A, std::vector<A>, B>::pop();
    }
    A take()
    {
        A a = this->top();
        this->pop();
        return a;
    }
    void print(bool b=false)
    {
        while(!this->empty())
        {
            std::cout<<take()<<" ";
        }
    }
    void printendl(bool b=false)
    {
        print(b);
        std::cout<<std::endl;
    }
};

//This class has a static const ll (the modulo we have to count, usually 10^9+7) and a ll (this is the value of the number) member.
//It counts the modvalue modulo mod. You can use basic operators (for example ++, -, ==, /=, * ...)
//Also there are extra functions:
//Static functions:
//  fastpow(ll z, ll u): returns modll z^u%mod in O(log(u)) time
//  modpow(ll z, ll u): returns ll z^u%mod in O(log(u)) time
//  fact(ll z) returns z!%mod in O(z) time.
//  choose(ll n, ll k) returns the number of possible ways to choose k items from n in O(k*log(mod)) time.
//Non static functions:
//  4 constructors. Default value of modvalue is 0, you can set it's value in the constructor with int, ll or modll.
//  getmodvalue(). The modvalue is a private member, you can only modify it with the operators and functions provided. Use this function to get the current value.
//  rec() returns 1/modvalue as ll in O(log(mod)) time
//  print(), printspace(), printendle(). Prints the current value to the console and a space or endl after it in the space and endl variants. You can also use std::cout<<x.getmodvalue();
class modll
{
    static const ll mod = 998244353;
    ll modvalue = 0;
public:
    modll()
    {
        this->modvalue = 0;
    }
    modll(int x)
    {
        this->modvalue = x%mod;
    }
    modll(ll x)
    {
        this->modvalue = x % mod;
    }
    modll(const modll &x)
    {
        this->modvalue=x.modvalue;
    }
    ll getmodvalue() const
    {
        return modvalue;
    }
    static ll modpow(ll z, ll u)
    {
        if (u == 0) return 1;
        if (u == 1) return z;
        if (u % 2 == 0)
        {
            ll sa = modpow(z, u / 2);
            return (sa*sa) % mod;
        }
        return (z * modpow(z, u - 1)) % mod;
    }
    static modll fastpow(ll z, ll u)
    {
        modll a=modpow(z, u);
        return a;
    }
    static modll fact(ll z)
    {
        modll a=1;
        for (ll i=2; i<=z; ++i)
        {
            a*=i;
        }
        return a;
    }
    static modll choose(ll n, ll k)
    {
        modll a=1;
        //if (k>n/2) return choose(n, n-k);
        for (ll i=n; n-i+1<=k; --i)
        {
            modll b=i;
            a=a*b;
        }
        for (ll i=2; i<=k; ++i)
        {
            modll b=i;
            a=a/b;
        }
        return a;
    }
    ll rec() const
    {
        return modll::modpow(modvalue, mod - 2);
    }
    modll operator+(const modll &x) const
    {
        modll a;
        a.modvalue=(this->modvalue + x.modvalue) % mod;
        return a;
    }
    modll operator-(const modll &x) const
    {
        modll a;
        a.modvalue = (mod + this->modvalue - x.modvalue) % mod;
        return a;
    }
    modll operator*(const modll &x) const
    {
        modll a;
        a.modvalue = (this->modvalue * x.modvalue) % mod;
        return a;
    }
    modll operator/(const modll &x) const
    {
        modll a;
        if (x.modvalue == 0) return a;
        a.modvalue = (this->modvalue * x.rec()) % mod;
        return a;
    }
    template<class A>
    modll operator+(A x) const
    {
        if (x<0) return this->operator-(-x);
        modll a;
        a.modvalue=(this->modvalue+x%mod)%mod;
        return a;
    }
    template<class A>
    modll operator-(A x) const
    {
        if (x<0) return this->operator+(-x);
        modll a;
        a.modvalue=(this->modvalue-(x%mod)+mod)%mod;
        return a;
    }
    template<class A>
    modll operator*(A x) const
    {
        if (x<0)
        {
            ll y=x/mod;
            y*=mod;
            y=x-y;
            x=y;
        }
        x%=mod;
        modll a;
        a.modvalue=(this->modvalue*x)%mod;
        return a;
    }
    template<class A>
    modll operator/(A x) const
    {
        if (x<0)
        {
            ll y=x/mod;
            y*=mod;
            y=x-y;
            x=y;
        }
        x%=mod;
        modll a;
        if (x==0) return a;
        modll b=x;
        a=*this/b;
        return a;
    }
    void operator=(modll x)
    {
        this->modvalue = x.modvalue;
    }
    template<class A>
    void operator=(A x)
    {
            this->modvalue = x % mod;
    }

    bool operator==(modll x) const
    {
        return (this->modvalue == x.modvalue);
    }

    template<class A>
    bool operator==(A x) const
    {
        return (this->modvalue == x);
    }

    bool operator<(modll x) const
    {
        return (this->modvalue < x.modvalue);
    }

    template<class A>
    bool operator<(A x) const
    {
        return (this->modvalue < x);
    }

    bool operator>(modll x) const
    {
        return (this->modvalue > x.modvalue);
    }
    template<class A>
    bool operator>(A x)
    {
        return (this->modvalue > x);
    }

    bool operator<=(modll x) const
    {
        return (this->modvalue <= x.modvalue);
    }

    template<class A>
    bool operator<=(A x) const
    {
        return (this->modvalue <= x);
    }

    bool operator>=(modll x) const
    {
        return (this->modvalue >= x.modvalue);
    }

    template<class A>
    bool operator>=(A x) const
    {
        return (this->modvalue >= x);
    }

    void operator+=(const modll &x)
    {
        this->modvalue += x.modvalue;
        this->modvalue %= mod;
    }

    template<class A>
    void operator+=(A x)
    {
        if (x < 0) this->operator+=(-1 * x);
        this->modvalue += x%mod;
        if (modvalue < 0)
        {
            this->modvalue *= -1;
            if (modvalue%mod == 0) modvalue = 0;
            else modvalue = mod-(modvalue % mod);
        }
        this->modvalue %= mod;
    }

    void operator-=(const modll &x)
    {
        this->modvalue -= x.modvalue;
        while (this->modvalue < 0) this->modvalue += mod;
        this->modvalue %= mod;
    }

    template<class A>
    void operator-=(A x)
    {
        if (x < 0) this->operator+=(-1 * x);
        this->modvalue -= x % mod;
        if (modvalue < 0)
        {
            this->modvalue *= -1;
            if (modvalue%mod == 0) modvalue = 0;
            else modvalue = mod - (modvalue % mod);
        }
        this->modvalue %= mod;
    }

    void operator*=(const modll &x)
    {
        this->modvalue *= x.modvalue;
        this->modvalue %= mod;
    }

    template<class A>
    void operator*=(A x)
    {
        bool neg = false;
        if (x < 0)
        {
            neg = true;
            x *= -1;
        }
        this->modvalue *= x % mod;
        if (modvalue < 0)
        {
            this->modvalue *= -1;
            if (modvalue%mod == 0) modvalue = 0;
            else modvalue = mod - (modvalue % mod);
        }
        this->modvalue %= mod;
        if (neg)
        {
            this->modvalue = mod - modvalue;
            this->modvalue %= mod;
        }
    }

    void operator/=(const modll &x)
    {
        if (x.modvalue == 0)
        {
            this->modvalue = 0;
            return;
        }
        this->modvalue = this->modvalue/x.modvalue;
        this->modvalue %= mod;
    }

    template<class A>
    void operator/=(A x)
    {
        bool neg = false;
        if (x < 0)
        {
            neg = true;
            x *= -1;
        }
        modll se = x%mod;
        this->operator/=(se);
        if (modvalue < 0)
        {
            this->modvalue *= -1;
            if (modvalue%mod == 0) modvalue = 0;
            else modvalue = mod - (modvalue % mod);
        }
        this->modvalue %= mod;
        if (neg)
        {
            this->modvalue = mod - modvalue;
            this->modvalue %= mod;
        }
    }

    modll operator++()
    {
        modvalue++;
        if (modvalue==mod) modvalue=0;
    }

    modll operator--()
    {
        modvalue--;
        if (modvalue<0) modvalue+=mod;
    }

    void print() const
    {
        std::cout << this->modvalue;
    }
    void printspace() const
    {
        std::cout << this->modvalue << " ";
    }
    void printendl() const
    {
        std::cout << this->modvalue <<std::endl;
    }
};
string yes="YES\n";
string no="NO\n";






myvector<ll>v[105];

ll rc[105];
ll l[105];
ll attacked;


ll n, m, k;
mypriority_queue<ll, std::greater<ll>>pq;
myqueue<ll>q;
myvector<ll>e[105];
bool used[105];
bool usedb[105];
ll a[105];
ll p[105];
ll defendedb[105];
ll cnt;
ll ans;
ll cc[105];
myvector<ll>d;
ll defenders;

myvector<ll>path;

bool defended[105];
ll defendcnt[105];

void dfs(ll z)
{
    used[z]=true;
    for (auto s: e[z])
    {
        if (!used[s])
        {
            p[s]=z;
            ++a[z];
            l[s]=l[z]+1;
            dfs(s);
        }
    }
}

bool dfs2(ll z)
{
    used[z]=true;
    if (z==attacked)
    {
        path.push_back(z);
        return true;
    }

    for (auto s: e[z])
    {
        if (!used[s] && (s==attacked || defended[s]))
        {
            if (dfs2(s))
            {
                path.push_back(z);
                return true;
            }
        }
    }
    return false;
}

int main()
{
    std::ios_base::sync_with_stdio(false);
    cin>>n>>m;

    for (int i=0; i<n-1; ++i)
    {
        ll uu, vv;
        cin>>uu>>vv;
        e[uu].push_back(vv);
        e[vv].push_back(uu);
    }

    p[0]=0;
    dfs(0);

    for (int i=0; i<n; ++i)
    {
        if (e[i].size()>1)
        {
            ++ans;
        }
    }

    ++ans;

    /*
    cout<<ans<<endl;
    cout<<cnt<<endl;
    for (int i=0; i<cnt; ++i)
    {
        v[i].printendl();
    }
    */

    if (false && m>=ans)
    {
        cout<<"DEFEND"<<endl;
        ll ed=0;
        for (int i=0; i<n; ++i)
        {
            if (e[i].size()>1)
            {
                d.push_back(i);
                defended[i]=true;
            }
        }

        for (int i=0; i<n; ++i)
        {
            if (!defended[i] && d.size()<m)
            {
                ed=i;
                d.push_back(i);
                defended[i]=true;
            }
        }

        d.printendl();

        while (1)
        {
            cin>>attacked;
            if (attacked==-1)
            {
                return 0;
            }
            if (defended[attacked])
            {
                cout<<0<<endl;
                continue;
            }

            for (int i=0; i<n; ++i)
            {
                used[i]=false;
            }

            path.clear();
            dfs2(ed);

            cout<<path.size()-1<<" ";
            for (int i=path.size()-1; i>0; --i)
            {
                cout<<path[i]<<" "<<path[i-1]<<" ";
            }
            cout<<endl;

            defended[ed]=false;
            defended[attacked]=true;
            ed=attacked;

        }

    }
    else{

        ans=0;

        for (int j=0; j<n+3; ++j)
        {
            ll ml=0;
            for (int i=0; i<n; ++i)
            {
                if (!usedb[i])
                {
                    ml=max(ml, l[i]);
                }
            }
            for (int i=0; i<n; ++i)
            {
                if (a[i]==0 && !usedb[i] && !usedb[p[i]] && l[i]==ml)
                {
                    //cerr<<i<<endl;
                    if (i==0)
                    {
                        usedb[0]=true;
                        v[cnt].push_back(0);
                        rc[cnt]=0;
                        ++cnt;
                        continue;
                    }
                    if (a[p[i]]==1)
                    {
                        usedb[p[i]]=true;
                        v[cnt].push_back(p[i]);

                        usedb[i]=true;
                        v[cnt].push_back(i);

                        rc[cnt]=0;
                        ++cnt;
                        if (p[i]!=0)
                        {
                            --a[p[p[i]]];
                        }
                    }
                    else{
                        usedb[p[i]]=true;
                        bool con=false;
                        ll con_to=0;
                        myvector<ll>ww;
                        ww.push_back(p[i]);

                        for (auto s: e[p[i]])
                        {
                            if (s!=p[p[i]])
                            {
                                if (!usedb[s])
                                {
                                    usedb[s]=true;
                                    ww.push_back(s);
                                }
                                else{
                                    ll idx=(-1);
                                    for (int j=0; j<cnt; ++j)
                                    {
                                        for (int jj=0; (jj<v[j].size() && jj<rc[j]); ++jj)
                                        {
                                            if (v[j][jj]==s)
                                            {
                                                idx=j;
                                                break;
                                            }
                                        }
                                    }
                                    if (idx>=0)
                                    {
                                        if (v[idx].size()>2)
                                        {
                                            con=true;
                                            con_to=idx;
                                        }
                                    }
                                }
                            }
                        }

                        if (con)
                        {
                            ll idx=con_to;
                            v[idx].push_to(rc[idx], p[i]);
                            ++rc[idx];
                            for (int i=1; i<ww.size(); ++i)
                            {
                                v[idx].push_back(ww[i]);
                            }
                        }
                        else{
                            v[cnt]=ww;
                            rc[cnt]=1;
                            ++cnt;
                        }


                        if (p[i]!=0)
                        {
                            --a[p[p[i]]];
                        }
                    }
                    a[p[i]]=0;
                    break;
                }
            }
        }

        for (int i=0; i<cnt; ++i)
        {
            ans+=rc[i]+1;
        }


        if (m>=ans)
        {
            cout<<"DEFEND"<<endl;
            for (int i=0; i<cnt; ++i)
            {
                for (int j=0; j<rc[i]+1; ++j)
                {
                    d.push_back(v[i][j]);
                    defended[v[i][j]]=true;
                }
            }

            for (int i=0; i<n; ++i)
            {
                if (!defended[i] && d.size()<m)
                {
                    d.push_back(i);
                    defended[i]=true;
                }
            }

            d.printendl();

            while (1)
            {
                for (int i=0; i<n; ++i)
                {
                    used[i]=false;
                }
                cin>>attacked;
                if (attacked==-1)
                {
                    return 0;
                }
                if (defended[attacked])
                {
                    cout<<0<<endl;
                    continue;
                }

                ll x=0;
                for (int i=0; i<cnt; ++i)
                {
                    for (int j=0; j<v[i].size(); ++j)
                    {
                        if (v[i][j]==attacked)
                        {
                            x=i;
                            break;
                        }
                    }
                }

                if (v[x].size()<=2)
                {
                    cout<<1<<" ";
                    if (v[x][0]==attacked)
                    {
                        cout<<v[x][1]<<" "<<v[x][0]<<endl;
                        defended[attacked]=true;
                        defended[v[x][1]]=false;
                    }
                    else{
                        cout<<v[x][0]<<" "<<v[x][1]<<endl;
                        defended[attacked]=true;
                        defended[v[x][0]]=false;
                    }
                }
                else{
                    ll y=1;
                    for (int i=rc[x]; i<v[x].size(); ++i)
                    {
                        if (defended[v[x][i]] && v[x][i]!=attacked)
                        {
                            y=i;
                            break;
                        }
                    }

                    path.clear();
                    dfs2(v[x][y]);

                    cout<<path.size()-1<<" ";
                    for (int i=path.size()-1; i>0; --i)
                    {
                        cout<<path[i]<<" "<<path[i-1]<<" ";
                    }
                    cout<<endl;
                    defended[attacked]=true;
                    defended[v[x][y]]=false;
                }
            }
        }
        else{
            cout<<"ATTACK"<<endl;
            for (int i=0; i<m; ++i)
            {
                ll dd;
                cin>>dd;
                defended[dd]=true;
                defendcnt[dd]+=1;
            }

            for (int day=1; day<=365; ++day)
            {
                /*
                while (day>=365)
                {
                    bool bad=true;
                }
                */

                for (int i=0; i<n; ++i)
                {
                    defendedb[i]=false;
                }
                for (int i=0; i<n; ++i)
                {
                    if (defended[i])
                    {
                        defendedb[i]=true;
                        for (auto s: e[i])
                        {
                            defendedb[s]=true;
                        }
                    }
                }

                attacked=(-1);
                for (int i=0; i<n; ++i)
                {
                    if (!defendedb[i])
                    {
                        attacked=i;
                        break;
                    }
                }

                if (attacked<0)
                {
                    myvector<ll>w;
                    for (int i=0; i<n; ++i)
                    {
                        if (!defended[i]) w.push_back(i);
                    }
                    attacked=w[rand()%w.size()];
                }

                while (attacked<0 || attacked>=n)
                {
                    bool messedUp=true;
                }

                cout<<attacked<<endl;


                for (int i=0; i<n; ++i)
                {
                    cc[i]=0;
                }
                cin>>k;
                for (int i=0; i<k; ++i)
                {
                    ll uu, vv;
                    cin>>uu>>vv;
                    --cc[uu];
                    ++cc[vv];
                }

                for (int i=0; i<n; ++i)
                {
                    if (cc[i]<0) defended[i]=false;
                    if (cc[i]>0) defended[i]=true;
                }


                ll cntd=0;
                for (int i=0; i<n; ++i)
                {
                    if (defended[i]) ++cntd;
                }

                while (cntd!=m)
                {
                    bool messedup=true;
                }

                while (!defended[attacked])
                {
                    cout<<-1<<endl;
                    return 0;
                }

            }
        }
    }

}