#pragma comment(linker, "/STACK:102400000,102400000")

#include <cstdio>
#include <cstring>
#include <cctype>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <deque>
#include <vector>
#include <queue>
#include <string>
#include <map>
#include <stack>
#include <set>
#include <list>
#include <bitset>
#include <numeric>
#include <sstream>
#include <iomanip>
#include <limits>
/**/

#include <unordered_map>

using namespace std;  

namespace Dup4
{
	typedef long long ll;
	typedef long double ld;
	typedef long double ld;
	typedef unsigned long long ull;
	typedef pair <int, int> pii;
	typedef pair <ll, ll> pll;
	typedef pair <ll, int> pli;
	typedef pair <int, double> pid;
	typedef vector <int> vi;
	typedef vector <ll> vll;
	typedef vector < vi > vvi;

	#define fi first
	#define se second
	#define pb push_back
	#define gc getchar
	#define pc putchar
	#define p32 pc(' ')
	#define p10 pc('\n')
	#define L(on) ((on)<<1)
	#define R(on) (L(on) | 1)
	#define lowbit(x) ((x)&(-x))
	#define mkp(a, b) make_pair(a, b)
	#define all(x) x.begin(), x.end()
	#define rall(x) x.rbegin(), x.rend()
	#define CLR(a, b) memset(a, (b), sizeof(a));
	#define random(a,b) ((a)+rand()%((b)-(a)+1))
	#define close() ios::sync_with_stdio(false); cin.tie(0);
	#define F(i, a, b) for (register int i = (a); i <= (b); ++i)
	#define FF(i, a, b) for (register int i = (a); i >= (b); --i)

	inline int read() 
	{
		int x = 0, f = 1; char c = gc();
		for (; !isdigit(c); c = gc()) f ^= (c == '-');
		for (; isdigit(c); c = gc()) x = x * 10 + (c - '0');
		return x * (f ? 1 : -1);
	}

	template <typename T>
	inline void read(T &x)
	{
		x = 0; int f = 1; char c = gc();
		for (; !isdigit(c); c = gc()) f ^= (c == '-');
		for (; isdigit(c); c = gc()) x = x * 10 + (c - '0');
		x *= f ? 1 : -1;
	}

	template <typename T>
	inline void write(T x)
	{
		if (!x) { pc(48); return; }
		if (x < 0) x = -x, pc('-');
		int bit[20], i, p = 0;
		for (; x; x /= 10) bit[++p] = x % 10;
		for (i = p; i; --i) pc(bit[i] + 48);
	}

	//仅限于正整数读入

	inline char nc()  
	{
		static char buf[100000], *i = buf, *j = buf;
		return i == j && (j = (i = buf) + fread(buf, 1, 100000, stdin), i == j) ? EOF : *i++;
	}

	template <typename T>
	inline void _read(T &sum)
	{
		char ch = nc(); sum = 0;
		while (!(ch >= '0' && ch <= '9')) ch = nc();
		while (ch >= '0' && ch <= '9') sum = sum * 10 + ch - 48, ch = nc();
	}

	template <typename T>
	inline T gcd(T a, T b)
	{
		while (b ^= a ^= b ^= a %= b);
		return a;
	}

	#ifdef LOCAL
		#define gets gets_s
		#define sp system("pause");
		#define bug puts("***bug***");
	#endif

	#ifdef ONLINE_JUDGE
		#define sp
		#define bug
	#endif

	const double PI = acos(-1.0);
	const double EI = exp(1.0);
	const double eps = 1e-8;

	const int INF = 0x3f3f3f3f;
	const ll INFLL = 0x3f3f3f3f3f3f3f3fll;
}

using namespace Dup4; 

namespace FastIO
{
	// 只可读入 整数，单字符
	#define BUF_SIZE 10000005
	bool IOerror = false;
	inline char NC()
	{
		static char buf[BUF_SIZE], *p1 = buf + BUF_SIZE, *pend = buf + BUF_SIZE;
		if (p1 == pend)
		{
			p1 = buf;
			pend = buf + fread(buf, 1, BUF_SIZE, stdin);
			if (pend == p1)
			{
				IOerror = true;
				return -1;
			}
		}
		return *p1++;
	}

	inline bool blank(char ch)
	{
		return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
	}

	inline void __read(char &x)
	{
		char ch;
		while (blank(ch = NC()));
		if (IOerror)
		{
			x = -1;
			return;
		}
		x = ch;
	}

	template <typename T>
	inline void __read(T &x)
	{
		char ch;
		while (blank(ch = NC()));
		if (IOerror)
		{
			x = -1;
			return;
		}
		bool flag = false;
		if (ch == '-')
		{
			flag = true;
			ch = NC();
		}
		if (!isdigit(ch)) while (!isdigit(ch = NC()));
		for (x = ch - '0'; isdigit(ch = NC()); x = x * 10 + ch - '0');
		if (flag)
			x *= -1;
	}
	#undef BUF_SIZE
}

using namespace FastIO; 

const int maxn = (int)1e5 + 10; 
const int Maxn = (int)1e6 + 10;
const int MOD = (int)1e9 + 9;  

int n, m;

int tot[2];
pii arr[maxn];
unordered_map <int, int> mp[2]; // - 0 + 1
 
inline bool Input()
{
	if (scanf("%d%d", &n, &m) == EOF) return false;
	char c; int id; mp[0].clear(), mp[1].clear(); CLR(tot, 0);
	F(i, 1, n)
	{
		scanf(" %c%d", &c, &id);
		int vis = c == '-' ? 0 : 1;
		arr[i].fi = vis, arr[i].se = id;
		mp[vis][id]++; 
		tot[vis]++;
	}
	return true;  
}

inline void Solve()
{
	int index = -1;
	F(i, 1, n)
	{
		if (mp[1][i] + tot[0] - mp[0][i] == m)
		{
			if (index == -1) index = i;
			else
			{
				index = -1;
				break;
			}
		}
	}
	if (index != -1) 
	{
		F(j, 1, n)
		{
			if (arr[j].se == index) puts(arr[j].fi ? "Truth" : "Lie");
			else puts(arr[j].fi ? "Lie" : "Truth"); 
		}
		return;
	}
	if (m == 0)
	{
		F(i, 1, n) puts("Lie");
		return;
	}
	if (m == n)
	{
		F(i, 1, n) puts("Truth"); 
		return;
	}
	if (tot[0] == n || tot[1] == n) 
	{
		if (tot[0] == n)
		{
			int tot = 0;
			for (auto it : mp[0]) if (it.se == (n - m)) tot++;
			if (tot == 1)
			{
				F(i, 1, n) puts(mp[0][arr[i].se] == (n - m) ? "Lie" : "Truth");
				return;
			}
			else
			{
				F(i, 1, n) puts(mp[0][arr[i].se] == (n - m) ? "Not defined" : "Truth");
				return;
			}

		}
		if (tot[1] == n)
		{
			int tot = 0; 
			for (auto it : mp[1]) if (it.se == m) tot++; 
			if (tot == 1)
			{
				F(i, 1, n) puts(mp[1][arr[i].se] == m ? "Truth" : "Lie");
				return;
			}
			else
			{
				F(i, 1, n) puts(mp[1][arr[i].se] == m ? "Not defined" : "Lie"); 
				return;
			}
		}
	}
	if (tot[0] >= m)
	{
		F(i, 1, n)
		{
			if (arr[i].first == 0 && mp[1][arr[i].se]) 
				puts("Truth");
			else puts(arr[i].fi ? "Lie" : "Not defined"); 
		}
		return; 
	}
	if (tot[0] < m)
	{
		int total = 0;
		F(i, 1, n) if (mp[1][i] == (n - m)) total++;
		if (total == 1)
		{
			F(i, 1, n)
			{
				if (arr[i].fi == 0) puts("Truth");
				else puts(mp[1][arr[i].se] == (n - m) ? "Truth" : "Lie");
			}
			return;
		}
		else
		{
			F(i, 1, n)
			{
				if (arr[i].fi == 0) puts("Truth");
				else puts(mp[1][arr[i].se] == (n - m) ? "Not defined" : "Lie");
			}
			return;
		}
	}
}

inline void Run()
{
	#ifdef LOCAL 
		freopen("Test.in", "r", stdin);
		//freopen("1.out", "w+", stdout); 
	#endif

	while (Input())
		Solve();

	#ifdef LOCAL
		fclose(stdin);
		//fclose(stdout); 
	#endif
}

int main()
{
	Run();
	return 0;
}

/*

*/