import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class con110_D {

    public static void main( final String[] args ) throws Exception {
        final BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) );
        final String[] parts = br.readLine().split( " " );
        final int n = Integer.parseInt( parts[ 0 ] );
        final int m = Integer.parseInt( parts[ 1 ] );
        final int[] a = new int[n];
        for ( int i = 0; i < n; ++i ) {
            final String line = br.readLine();
            a[ i ] = Integer.parseInt( line.substring( 1 ) );
            if ( line.charAt( 0 ) == '-' ) a[ i ] *= -1;

        }
        final String[] res = solve( a, m );
        for ( final String r : res ) {
            System.out.println( r );
        }
    }

    private static String[] solve( final int[] a, final int m ) {
        final int n = a.length;
        final Map<Integer, Set<Integer>> plusMap = new HashMap<Integer, Set<Integer>>();
        final Map<Integer, Set<Integer>> minusMap = new HashMap<Integer, Set<Integer>>();
        int ms = 0;
        for ( int i = 1; i <= n; ++i ) {
            plusMap.put( i, new HashSet<Integer>() );
            minusMap.put( i, new HashSet<Integer>() );
        }
        for ( int i = 0; i < n; ++i ) {
            if ( a[ i ] > 0 ) {
                final Set<Integer> val = plusMap.get( a[ i ] );
                val.add( a[ i ] );
            } else {
                final Set<Integer> val = minusMap.get( -a[ i ] );
                val.add( -a[ i ] );
                ++ms;
            }
        }

        final Set<Integer> und = new HashSet<Integer>();
        for ( int i = 0; i < n; ++i ) {
            und.add( i );
        }
        final Set<Integer> t = new HashSet<Integer>();
        final Set<Integer> f = new HashSet<Integer>();
        final Set<Integer> na = new HashSet<Integer>();
        for ( int s = 1; s <= n; ++s ) { // 100.000-times
            final int pc = plusMap.get( s ).size();
            final int mc = minusMap.get( s ).size();
            if ( pc + ms - mc == m ) { // guaranteed that at least one suspect exists
                if ( !und.isEmpty() ) { // first time here
                    final Set<Integer> uRemove = new HashSet<Integer>();
                    for ( final int u : und ) {
                        if ( ( a[ u ] > 0 && a[ u ] == s ) || ( a[ u ] < 0 && -a[ u ] != s ) ) {
                            t.add( u );
                        } else {
                            f.add( u );
                        }
                        uRemove.add( u );
                    }
                    und.removeAll( uRemove );
                } else {
                    final Set<Integer> tRemove = new HashSet<Integer>();
                    for ( final int ti : t ) {
                        // ti tvrdil doteraz pravdu
                        // ak ale teraz pravdu nema, oznacil niekoho ineho
                        if ( a[ ti ] > 0 && a[ ti ] != s ) {
                            tRemove.add( ti );
                            na.add( ti );
                        }
                        // alebo povedal, že tento to nie je
                        if ( a[ ti ] < 0 && -a[ ti ] == s ) {
                            tRemove.add( ti );
                            na.add( ti );
                        }
                    }
                    t.removeAll( tRemove );
                    final Set<Integer> fRemove = new HashSet<Integer>();
                    for ( final int fi : f ) {
                        // fi doteraz klamal
                        // fi tvrdi, ze a[fi] to bol a mal pravdu
                        if ( a[ fi ] > 0 && a[ fi ] == s ) {
                            fRemove.add( fi );
                            na.add( fi );
                        }
                        // fi tvrdi, ze a[fi] to nebol
                        if ( a[ fi ] < 0 && -a[ fi ] != s ) {
                            fRemove.add( fi );
                            na.add( fi );
                        }
                    }
                    f.removeAll( fRemove );
                }
            }
        }
        final String[] res = new String[n];
        for ( int i = 0; i < n; ++i ) {
            if ( na.contains( i ) ) {
                res[ i ] = "Not defined";
            } else {
                if ( t.contains( i ) ) {
                    res[ i ] = "Truth";
                } else {
                    res[ i ] = "Lie";
                }
            }
        }
        return res;
    }

}
