// Arup Guha
// 5/3/2013
// Solution to 2013 UCF HS Contest Problem A: Slow

import java.util.*;
import java.io.*;

public class slow {

	final static int REG_LEN = 22;
	final static int SLOW_SPEED = 10;
	final static int FAST_SPEED = 20;
	final static int TIME_SLOW = 1;
	final static int TIME_PER_ENEMY = 3;
	final static int EXTRA_TIME_LAST = 8;

	public static void main(String[] args) throws Exception {

		Scanner fin = new Scanner(new File("slow.in"));

		// Go through each case.
		int numCases = fin.nextInt();
		for (int loop=1; loop<=numCases; loop++) {

			int numEpisodes = fin.nextInt();
			int numRooms = fin.nextInt();

			// Go through each room.
			double myTime = 0;
			int[] prevPos = new int[2];

			double curEpisodeTime = 0;
			int numEpisodesComplete = 0;

			// Will be true if Sonic can get out.
			boolean flag = true;

			// Will be set to true if we're on our last episode, in the last 8 minutes.
			boolean onLast = false;

			for (int i = 0; i<numRooms; i++) {

				int[] curPos = new int[2];
				curPos[0] = fin.nextInt();
				curPos[1] = fin.nextInt();
				int numEnemies = fin.nextInt();

				// Special case.
				if (i == 0)
					prevPos = curPos;

				// See if any episodes elapsed in traveling to the new place.
				// Update completed episodes and time left in current episode.
				curEpisodeTime += travelTime(prevPos, curPos);

				// Now, fight off enemies!
				curEpisodeTime += calculate(curEpisodeTime, numEnemies, numEpisodesComplete, numEpisodes);

				if (curEpisodeTime > REG_LEN) {
					int extraCompleted = ((int)(curEpisodeTime/REG_LEN));
					numEpisodesComplete += extraCompleted;
					curEpisodeTime -= (REG_LEN*extraCompleted);
				}

				// We completed an extra 22 minutes, easily over time!!!
				if (numEpisodesComplete > numEpisodes) flag = false;

				// Toggle this setting for the last 8 minutes of the last episode.
				else if (numEpisodesComplete == numEpisodes) onLast = true;

				// Just for the last episode!
				if (onLast && curEpisodeTime > EXTRA_TIME_LAST)
					flag = false;

				prevPos = curPos;
			}

			// Output result.
			if (flag)
				System.out.println("Simulation #"+loop+": Abort fortress!");
			else
				System.out.println("Simulation #"+loop+": You're too slow!");
		}

		fin.close();
	}

	public static double calculate(double curEpisodeTime, int numEnemies, int numEpisodesComplete, int numEpisodes) {

		// Trick case for last episode.
		int LEN = REG_LEN;
		if (numEpisodesComplete + 1 == numEpisodes)
			LEN = REG_LEN+EXTRA_TIME_LAST;

		// Take care of the enemies being beating by the end of this episode.
		double thisEpisode = curEpisodeTime - ((int)(curEpisodeTime/LEN)*LEN);
		int numBeat = (int)((LEN - thisEpisode)/TIME_PER_ENEMY);

		if (numBeat >= numEnemies) {
			return numEnemies*TIME_PER_ENEMY;
		}

		// Advance to the next episode.
		numEnemies -= numBeat;
		numEpisodesComplete++;
		double extraTime = LEN - thisEpisode;

		int BEAT_ONE_EPISODE = (REG_LEN/TIME_PER_ENEMY);

		// Simulate up until the last episode or when only one more is needed to beat the enemies.
		while (numEpisodesComplete < numEpisodes-1 && numEnemies > BEAT_ONE_EPISODE) {
			extraTime += REG_LEN;
			numEnemies -= BEAT_ONE_EPISODE;
			numEpisodesComplete++;
		}

		// Last episode case.
		if (numEpisodesComplete == numEpisodes-1) {

			// Accurate time.
			if (numEnemies <= (REG_LEN+EXTRA_TIME_LAST)/TIME_PER_ENEMY)
				return extraTime + numEnemies*TIME_PER_ENEMY;

			// This is a dummy return value that signifies that it takes too long to get out.
			else
				return extraTime + REG_LEN + EXTRA_TIME_LAST + 1;
		}

		// We can vanquish the enemies in this episode, and it's not the last.
		extraTime += (TIME_PER_ENEMY*(numEnemies%(REG_LEN/TIME_PER_ENEMY)));
		return extraTime;
	}

	// Returns the amount of time it takes to get from prev to cur.
	public static double travelTime(int[] prev, int[] cur) {

		double dist = getDist(prev, cur);

		if (dist < TIME_SLOW*SLOW_SPEED)
			return dist/TIME_SLOW;

		return TIME_SLOW + (dist - TIME_SLOW*SLOW_SPEED)/FAST_SPEED;
	}

	// Returns the distance between the points prev and cur.
	public static double getDist(int[] prev, int[] cur) {
		double sum = 0;
		for (int i=0; i<prev.length; i++)
			sum += Math.pow(prev[i]-cur[i],2);
		return Math.sqrt(sum);
	}
}