import java.io.*;

/**
 * Author: Vasiliy Homutov - vasiliy.homutov@gmail.com
 * Date:   02.05.12
 * See: http://codeforces.ru/problemset/problem/156/B
 */
public class Suspects {

    public enum State {

        TRUTH("Truth"), LIE("Lie"), NOT_DEFINED("Not defined");

        private String description;

        private State(String description) {
            this.description = description;
        }

        public String getDescription() {
            return description;
        }
    }

    public static class Sherlock {

        int n;

        int[] prosecutors;
        int[] justifiers;
        int justifiersNum;
        int[] claims;

        public Sherlock(int[] claims) {
            this.claims = claims;
            n = claims.length;

            prosecutors = new int[n];
            justifiers = new int[n];
            justifiersNum = 0;
            for (int claim : claims) {
                if (claim > 0) {
                    prosecutors[claim - 1]++;
                } else {
                    justifiers[-claim - 1]++;
                    justifiersNum++;
                }

            }
        }

        private int countTruth(int person) {
            return prosecutors[person] + justifiersNum - justifiers[person];
        }

        public State[] getStates(int m) {
            boolean[] suspects = new boolean[n];
            int truthCounter = 0;
            for (int person = 0; person < n; person++) {
                suspects[person] = (countTruth(person) == m);
                truthCounter += suspects[person] ? 1 : 0;
            }
            State[] result = new State[n];
            for (int person = 0; person < n; person++) {
                int claimPerson = Math.abs(claims[person]) - 1;
                if (!suspects[claimPerson]) {
                    if (claims[person] < 0) {
                        result[person] = State.TRUTH;
                    } else {
                        result[person] = State.LIE;
                    }
                } else if (truthCounter == 1) {
                    if (claims[person] < 0) {
                        result[person] = State.LIE;
                    } else {
                        result[person] = State.TRUTH;
                    }
                } else {
                    result[person] = State.NOT_DEFINED;
                }
            }
            return result;
        }
    }

    public static void process(InputStream input, OutputStream output)
            throws IOException {
        State[] states;
        try (BufferedReader reader =
                     new BufferedReader(new InputStreamReader(input))) {
            String[] ss = reader.readLine().split(" ");
            int n = Integer.parseInt(ss[0]);
            int m = Integer.parseInt(ss[1]);

            int[] claims = new int[n];
            for (int index = 0; index < n; index++) {
                claims[index] = Integer.parseInt(reader.readLine());
            }

            Sherlock sherlock = new Sherlock(claims);
            states = sherlock.getStates(m);
        }

        try (PrintWriter writer = new PrintWriter(output)) {
            for (State state : states) {
                writer.println(state.getDescription());
            }
        }
    }

    public static void main(String[] args) throws IOException {
        process(System.in, System.out);
    }
}