#include "validate.h"
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

bool read_solution(istream &in, int n, vector<string> &result, feedback_function feedback) {
    string first;
    if (!(in >> first)) {
        feedback("Failed to read first token");
    }
    transform(first.begin(), first.end(), first.begin(), ::tolower);
    if (first == "impossible")
        return false;

    result.resize(n);
    result[0] = first;
    for (int i = 1; i < n; ++i) {
        if (!(in >> result[i])) {
            feedback("First token not 'impossible' and failed to read token %d/%d", i+1, n);
        }
    }
    return true;
}

void check_solution(const vector<string> &A, // A = input sequence
                    const vector<string> &B, // B = proposed changed sequence
                    feedback_function feedback) {
    // assumes A.size() == B.size()
    int n = A.size(), diffs = 0;
    for (int i = 0; i < n; ++i) {
        if (B[i].length() != A[i].length())
            feedback("Changed length of %d'th number", i+1);
        if (B[i].length() > 1 && B[i][0] == '0')
            feedback("Added leading 0 to %d'th number", i+1);
        for (int j = 0; j < A[i].length(); ++j) {
            if (!isdigit(B[i][j])) {
                feedback("Non-digit character found in %d'th number", i+1);
            }
            if (A[i][j] != B[i][j]) {
                ++diffs;
            }
        }
    }
    if (diffs > 1) {
        feedback("Changed %d digits, too many", diffs);
    }

    // Check non-sorted
    for (int i = 1; i < n; ++i) {
        if (stol(B[i]) < stol(B[i-1]))
            return;
    }
    feedback("Resulting array is still sorted");
}

int main(int argc, char **argv) {
    init_io(argc, argv);

    // this validator assumes long is 64 bits
    assert(sizeof(long) == 8);

    int n;
    judge_in >> n;

    vector<string> A(n);
    for (string &x: A) judge_in >> x;

    vector<string> ans, out;
    bool judge_poss = read_solution(judge_ans, n, ans, judge_error);
    bool sol_poss = read_solution(cin, n, out, wrong_answer);

    if (sol_poss) {
        check_solution(A, out, wrong_answer);
        if (!judge_poss)
            judge_error("Output found a solution but answer file says impossible");
    } else { // output file says "impossible"
        if (judge_poss)
            wrong_answer("Solution claims impossible but solution exists");
    }

    string trash;
    if (cin >> trash) {
        wrong_answer("Correct solution but followed by trailing output");
    }

    accept();
}