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


class Point {
    final int row;
    final int col;

    public Point(int row, int col) {
        this.row = row;
        this.col = col;
    }
}

class FoundCharacterPoint {
    private final Character character;
    private final Point point;

    public FoundCharacterPoint(Character character, Point point) {
        this.character = character;
        this.point = point;
    }

    @Override
    public String toString() {
        return String.format("%s - (%s, %s)", character, point.row, point.col);
    }
}

class FindPointsTaskEntry {
    private int pointsToFind;
    private LinkedList<Point> pointList;

    public FindPointsTaskEntry(int pointsToFind) {
        this.pointsToFind = pointsToFind;
        this.pointList = new LinkedList<>();
    }

    public int getCountToFind() {
        return pointsToFind;
    }

    public void addPoint(Point point) {
        if (pointsToFind-- > 0) {
            pointList.add(point);
        }
    }

    public Point consumePoint() {
        return pointList.pollFirst();
    }
}

class FindPointsTask {
    private final Map<Character, FindPointsTaskEntry> taskData;

    public static FindPointsTask createFromSpec(Map<Character, Integer> taskSpec) {
        Map<Character, FindPointsTaskEntry> taskData = new HashMap<>();
        for (Map.Entry<Character, Integer> taskSpecEntry : taskSpec.entrySet()) {
            taskData.put(taskSpecEntry.getKey(), new FindPointsTaskEntry(taskSpecEntry.getValue()));
        }
        return new FindPointsTask(taskData);
    }

    private FindPointsTask(Map<Character, FindPointsTaskEntry> taskData) {
        this.taskData = taskData;
    }

    public Integer getTotalPointsToFind() {
        int totalPointsToFind = 0;
        for (FindPointsTaskEntry entry : taskData.values()) {
            totalPointsToFind += entry.getCountToFind();
        }
        return totalPointsToFind;
    }

    public boolean hasPointsToFind() {
        return getTotalPointsToFind() > 0;
    }

    public void tryAddPoint(Character character, Point point) {
        Character charInLowerCase = Character.toLowerCase(character);
        if (taskData.containsKey(charInLowerCase)) {
            taskData.get(charInLowerCase).addPoint(point);
        }
    }

    public  List<FoundCharacterPoint> prepareForTargetString(String targetString) {
        List<FoundCharacterPoint> characterPoints = new ArrayList<>();
        for (Character character : targetString.toLowerCase().toCharArray()) {
            FindPointsTaskEntry entry = taskData.get(Character.toLowerCase(character));
            characterPoints.add(new FoundCharacterPoint(character, entry.consumePoint()));
        }
        return characterPoints;
    }
}

interface TaskProcessor {
    void process(FindPointsTask findPointsTask);
}

class TaskProcessorImpl implements TaskProcessor {

    private final String filePath;

    public TaskProcessorImpl(String filePath) {
        this.filePath = filePath;
    }

    @Override
    public void process(FindPointsTask findPointsTask) {
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {

            // We don't really care about the matrix size
            reader.readLine();

            int currentRow = 0;
            int currentCol = 0;
            String nextLine;
            while ((nextLine = reader.readLine()) != null && findPointsTask.hasPointsToFind()) {
                for (Character character : nextLine.toCharArray()) {
                    findPointsTask.tryAddPoint(character, new Point(currentRow, currentCol++));
                }
                currentRow++;
                currentCol = 0;
            }

        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

class TaskSpecFactory {

    public static Map<Character, Integer> createTaskSpec(String targetString) {
        Map<Character, Integer> spec = new HashMap<>();
        for (Character ch : targetString.toLowerCase().toCharArray()) {
            if (spec.containsKey(ch)) {
                spec.put(ch, spec.get(ch) + 1);
            } else {
                spec.put(ch, 1);
            }
        }

        return spec;
    }
}

interface FindPointsTaskWriter {
    void write(FindPointsTask task);
}

class FindPointsTaskFileWriter implements FindPointsTaskWriter {

    private final String filePath;
    private final String targetString;

    public FindPointsTaskFileWriter(String filePath, String targetString) {
        this.filePath = filePath;
        this.targetString = targetString;
    }

    @Override
    public void write(FindPointsTask task) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath))) {
            if (!task.hasPointsToFind()) {
                for (FoundCharacterPoint fcp : task.prepareForTargetString(targetString)) {
                    writer.write(fcp.toString());
                    writer.newLine();
                }
            } else {
                writer.write("Impossible");
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

public class Main {

    private static final String INPUT_PATH = "/Users/dbychkov/input.txt";
    private static final String OUTPUT_PATH = "/Users/dbychkov/output.txt";
    private static final String TARGET_STRING = "OneTwoTrip";

    public static void main(String[] args) {
        FindPointsTask task = FindPointsTask.createFromSpec(TaskSpecFactory.createTaskSpec(TARGET_STRING));
        new TaskProcessorImpl(INPUT_PATH).process(task);
        new FindPointsTaskFileWriter(OUTPUT_PATH, TARGET_STRING).write(task);
    }
}