import java.lang.reflect.*;
import java.io.*;
import java.util.*;

public class StressTest {
    static final int MAX_COORD = 10000;
    static boolean validateRawInput(int[] rawInput) {
        for (int offset = 0; offset < 18; offset += 9) {
            for (int l = 0; l < 2; ++l) {
                int xl = rawInput[offset + 3 * l];
                int yl = rawInput[offset + 3 * l + 1];
                int rl = rawInput[offset + 3 * l + 2];
                for (int r = l + 1; r < 3; ++r) {
                    int xr = rawInput[offset + 3 * r];
                    int yr = rawInput[offset + 3 * r + 1];
                    int rr = rawInput[offset + 3 * r + 2];
                    if ((xl - xr) * (xl - xr) + (yl - yr) * (yl - yr) <= (rl + rr) * (rl + rr)) {
                        return false;
                    }
                }
            }
        }
        return true;
    }

    static void printTest(int[] rawInput) {
        for (int i = 0; i < rawInput.length; ++i) {
            System.out.print(" ");
            System.out.print(rawInput[i]);
            if (i % 3 == 2 && i + 1 < rawInput.length) {
                System.out.print(" ");
            }
        }
        System.out.println();
    }

    static class Invoker {
        final String name;
        final Method method;

        Invoker(String className) throws Exception {
            this.name = className;
            Class<?> clazz = Class.forName(className);
            this.method = clazz.getMethod("match", int[].class);
        }

        boolean run(int[] rawInput) throws Exception {
            Object result = method.invoke(null, rawInput);
            return result != null;
        }

        public String toString() {
            return name;
        }
    }

    static Boolean runAllInvokers(int[] rawInput, Invoker[] invokers) {
        boolean firstResponse;
        try {
            firstResponse = invokers[0].run(rawInput);
        } catch (Exception ex) {
            printTest(rawInput);
            System.out.println("Failure of the first invoker (" + invokers[0] + ")!");
            ex.printStackTrace();
            System.exit(1);
            return null;
        }
        boolean testPrinted = false;
        for (int i = 1; i < invokers.length; ++i) {
            try {
                boolean ithResponse = invokers[i].run(rawInput);
                if (ithResponse != firstResponse) {
                    if (!testPrinted) {
                        testPrinted = true;
                        printTest(rawInput);
                    }
                    System.out.println("  Wrong answer by " + invokers[i]);
                }
            } catch (Exception ex) {
                if (!testPrinted) {
                    testPrinted = true;
                    printTest(rawInput);
                }
                System.out.println("  Failure answer by " + invokers[i]);
            }
        }
        return testPrinted ? null : firstResponse;
    }

    static void findDifference(Invoker[] invokers, Random random) {
        long nTries = 0;
        while (true) {
            int[] rawInput = new int[18];
            for (int i = 0; i < rawInput.length; ++i) {
                rawInput[i] = random.nextInt(MAX_COORD) + 1;
            }
            if (!validateRawInput(rawInput)) {
                continue;
            }
            runAllInvokers(rawInput, invokers);
            if (++nTries % 10000 == 0) {
                System.out.println(nTries + "...");
            }
        }
    }

    static void findExtended(Invoker[] invokers, Random random) {
        while (true) {
            int[] rawInput = new int[18];
            for (int i = 0; i < rawInput.length; ++i) {
                rawInput[i] = random.nextInt(MAX_COORD) + 1;
            }
            if (!validateRawInput(rawInput)) {
                continue;
            }
            Boolean firstRun = runAllInvokers(rawInput, invokers);
            if (firstRun == null) {
                return;
            }
            if (firstRun) {
                System.out.println("'Yes' found, extending...");
                int nTries = 0;
                while (true) {
                    int index = random.nextInt(3);
                    if (rawInput[2 + 3 * index] < MAX_COORD) {
                        ++rawInput[2 + 3 * index];
                    } else {
                        ++nTries;
                        if (nTries > 100) {
                            break;
                        } else {
                            continue;
                        }
                    }
                    nTries = 0;
                    Boolean nextRun = runAllInvokers(rawInput, invokers);
                    if (nextRun == null) {
                        return;
                    }
                    if (!nextRun) {
                        System.out.println(" 'No' found");
                        System.out.print(" First No:");
                        printTest(rawInput);
                        System.out.print(" Last Yes:");
                        --rawInput[2 + 3 * index];
                        printTest(rawInput);
                        break;
                    }
                }
            }
        }
    }

    public static void main(String[] args) throws Exception {
        String mode = args[0];
        long seed = Long.parseLong(args[1]);
        Invoker[] invokers = new Invoker[args.length - 2];
        for (int i = 2; i < args.length; ++i) {
            invokers[i - 2] = new Invoker(args[i]);
        }
        Random random = new Random(seed);
        switch (mode) {
            case "difference":
                findDifference(invokers, random);
                break;
            case "extended":
                findExtended(invokers, random);
                break;
        }
    }
}