import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.util.Map;
import java.util.HashMap;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author ATailouloute
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        QuickScanner in = new QuickScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskB solver = new TaskB();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskB {
        public void solve(int testNumber, QuickScanner in, PrintWriter out) {
            int n = in.nextInt();
            int m = in.nextInt();
            int[] a = in.nextIntArray(n);
            int[] r = new int[n];
            int s = 0;
            boolean[] candidate = new boolean[n + 1];
            Counter<Integer> killers = new Counter<>();
            Counter<Integer> nonKillers = new Counter<>();

            for (int answer : a) {
                if (answer > 0) {
                    killers.increment(answer);
                } else {
                    nonKillers.increment(-answer);
                }
            }

            int cnt = 0;
            for (int i = 1; i <= n; i++) {
                int score = killers.count(i) + nonKillers.getTotal() - nonKillers.count(i);
                if (score == m) {
                    candidate[i] = true;
                    ++cnt;
                }
            }

            for (int i = 0; i < n; i++) {
                boolean isTrue = false;
                boolean isFalse = false;
                if (a[i] > 0) {
                    if (candidate[a[i]]) {
                        isTrue = true;
                        if (cnt > 1) {
                            isFalse = true;
                        }
                    } else {
                        isFalse = true;
                    }
                } else {
                    if (!candidate[-a[i]]) {
                        isTrue = true;
                    } else {
                        isFalse = true;
                        if (cnt > 1) {
                            isTrue = true;
                        }
                    }
                }
                if (isFalse && isTrue) out.println("Not defined");
                else out.println(isTrue ? "Truth" : "Lie");
            }
        }

    }

    static class Counter<T> {
        Map<T, Integer> data;
        int total;

        public Counter() {
            this.data = new HashMap<>();
        }

        public int count(T key) {
            return data.containsKey(key) ? data.get(key) : 0;
        }

        public void add(T key, int value) {
            set(key, count(key) + value);
            total += value;
        }

        public void increment(T key) {
            add(key, 1);
        }

        public int getTotal() {
            return total;
        }

        public void set(T key, int value) {
            data.put(key, value);
        }

    }

    static class QuickScanner {
        BufferedReader br;
        StringTokenizer st;
        InputStream is;

        public QuickScanner(InputStream stream) {
            is = stream;
            br = new BufferedReader(new InputStreamReader(stream), 32768);
        }

        String nextToken() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(nextToken());
        }

        int[] nextIntArray(int len) {
            int[] a = new int[len];
            for (int i = 0; i < len; i++) {
                a[i] = nextInt();
            }
            return a;
        }

    }
}

