#include <cstdio>
#include <cstdarg>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <stack>
#include <string>
#include <iostream>
using namespace std;

#define NotVis 0
#define Finished 1
#define InStack -1

const int MAX_NODE = 50;

struct TopSort
{
	int N;
	bool HaveCircle;
	int MaxDist;

	struct Node
	{
		int Color;//0:NotVis 1:Finished -1:InStack
		int Dist;
		vector<Node*> Next;
	}_nodes[MAX_NODE];
	stack<Node*> St;

	void Dfs(Node *cur)
	{
		if (cur->Color == InStack)
		{
			HaveCircle = true;
			return;
		}
		if (cur->Color == Finished)
			return;
		cur->Color = InStack;
		for (int i = 0; i < cur->Next.size(); i++)
		{
			if (HaveCircle)
				return;
			Dfs(cur->Next[i]);
		}
		cur->Color = Finished;
		St.push(cur);
	}

	TopSort(int n):N(n){}

	void Build(int from, int to)
	{
		_nodes[from].Next.push_back(_nodes + to);
	}

	void Init()
	{
		MaxDist = -1;
		while (!St.empty())
			St.pop();
		HaveCircle = false;
		for (int i = 1; i <= N; i++)
			_nodes[i].Color = _nodes[i].Dist = 0;
	}

	void GetMaxDist()
	{
		if (HaveCircle)
		{
			MaxDist = -1;
			return;
		}
		stack<Node*> tempSt = St;
		while (!tempSt.empty())
		{
			Node *cur = tempSt.top();
			tempSt.pop();
			MaxDist = max(MaxDist, cur->Dist);
			for (int i = 0; i < cur->Next.size(); i++)
				cur->Next[i]->Dist = max(cur->Next[i]->Dist, cur->Dist + 1);
		}
	}

	void Proceed()
	{
		Init();
		for (int i = 1; i <= N; i++)
			Dfs(_nodes + i);
		GetMaxDist();
	}
};

int main()
{
	int totNode, opCnt;
	string s;
	cin >> totNode >> opCnt;
	static TopSort g(totNode);
	for (int i = 1; i <= opCnt; i++)
	{
		cin >> s;
		int a = s[0] - ‘A‘ + 1, b = s[2] - ‘A‘ + 1;
		if (s[1] == ‘>‘)
			swap(a, b);
		g.Build(a, b);
		g.Proceed();
		if (g.HaveCircle)
		{
			printf("Inconsistency found after %d relations.\n", i);
			return 0;
		}
		else if (g.MaxDist == totNode - 1)
		{
			printf("Sorted sequence determined after %d relations: ", i);
			stack<TopSort::Node*> temp = g.St;
			while (!temp.empty())
			{
				printf("%c", (int)(temp.top() - g._nodes) - 1 + ‘A‘);
				temp.pop();
			}
			printf(".\n");
			return 0;
		}
	}
	printf("Sorted sequence cannot be determined.\n");
	return 0;
}