import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Solver {

    StringTokenizer st;
    BufferedReader in;
    PrintWriter out;

    public static void main(String[] args) throws NumberFormatException,
            IOException {
        Solver solver = new Solver();
        solver.open();
        solver.solve();
        solver.close();
    }

    public void open() throws IOException {
        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
    }

    public String nextToken() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }

    public int nextInt() throws NumberFormatException, IOException {
        String token = nextToken();
        if (token.startsWith("+"))
            token = token.substring(1);
        return Integer.parseInt(token);
    }

    public long nextLong() throws NumberFormatException, IOException {
        return Long.parseLong(nextToken());
    }

    public double nextDouble() throws NumberFormatException, IOException {
        return Double.parseDouble(nextToken());
    }
    
    public enum State{
        TRUTH, LIE, NOT_DEFINED;
    }

    public void solve() throws NumberFormatException, IOException {
        int n = nextInt();
        int m = nextInt();
        
        int obv = 0;
        int opr = 0;
        
        int[] op = new int[n];
        int[] obvc = new int[n];
        int[] oprc = new int[n];
        State[] state = new State[n];
        for (int i=0;i<n;i++){
            state[i] = State.NOT_DEFINED;
        }
        
        for (int i=0;i<n;i++){
            int tmp = nextInt();
            op[i] = tmp;
            if (tmp>0){
                obv++;
                obvc[tmp-1]++;
            }else{
                opr++;
                oprc[-tmp-1]++;
            }
        }
        
        boolean[] canguilty = new boolean[n];
        
        int gc = 0;
        
        for (int guilty=0;guilty<n;guilty++){
            int right = obvc[guilty]+opr-oprc[guilty];
            if (right==m){
                canguilty[guilty] = true;
                gc++;
            }
        }
        
        for (int i=0;i<n;i++){
            if (op[i]>0){
                if(!canguilty[op[i]-1]){
                    state[i] = State.LIE;
                }else if(gc==1){
                    state[i] = State.TRUTH;
                }else{
                    state[i] = State.NOT_DEFINED;
                }
            }else{
                if(!canguilty[-op[i]-1]){
                    state[i] = State.TRUTH;
                }else if(gc==1){
                    state[i] = State.LIE;
                }else{
                    state[i] = State.NOT_DEFINED;
                }
            }
        }
        
        for (int i=0;i<n;i++){
            switch(state[i]){
            case LIE:
                out.println("Lie");
                break;
            case TRUTH:
                out.println("Truth");
                break;
            case NOT_DEFINED:
                out.println("Not defined");
                break;
            }
        }
    }

    public void close() {
        out.flush();
        out.close();
    }

}