#include <bits/stdc++.h>
using namespace std;
 
int main() {
    vector<int> numbers = {5, 7, 9, 11, 15, 23};
    int evenCount = 0;
 
    // Count even numbers
    for (int num : numbers) {
        if (num % 2 == 0) {
            evenCount++;
        }
    }
 
    if (evenCount >= 2) {
        int result = 0;
        cout << result << endl;
    } 
    else if (evenCount == 1) {
        int result = 1;
        cout << result << endl;
    } 
    else {
        int result = 2;
        int maxDivisor = 1;
        unordered_map<int, int> divisorCount;
 
        // Count all divisors for each element
        for (int num : numbers) {
            for (int d = 1; d * d <= num; d++) {
                if (num % d == 0) {
                    if (d == num / d) {
                        divisorCount[d]++;
                    } else {
                        divisorCount[d]++;
                        divisorCount[num / d]++;
                    }
                }
            }
        }
 
        // Check for common divisors
        for (auto &entry : divisorCount) {
            if (entry.second > 1 && entry.first > maxDivisor) {
                maxDivisor = entry.first;
            }
        }
 
        if (maxDivisor > 1) {
            result = 0;
            cout << result << endl;
        } 
        else {
            for (int num : numbers) {
                // Remove divisors of num temporarily
                for (int d = 1; d * d <= num; d++) {
                    if (num % d == 0) {
                        if (divisorCount[d] == 1) divisorCount.erase(d);
                        else divisorCount[d]--;
 
                        if (d != num / d) {
                            int other = num / d;
                            if (divisorCount[other] == 1) divisorCount.erase(other);
                            else divisorCount[other]--;
                        }
                    }
                }
 
                // Check if num+1 shares a divisor > 1
                bool found = false;
                for (int d = 1; d * d <= num + 1; d++) {
                    if ((num + 1) % d == 0) {
                        if ((divisorCount.count(d) && d > 1) || 
                            (divisorCount.count((num + 1) / d) && (num + 1) / d > 1)) {
                            result = 1;
                            found = true;
                            break;
                        }
                    }
                }
 
                if (found) {
                    cout << result << endl;
                    return 0;
                }
 
                // Reinsert divisors back
                for (int d = 1; d * d <= num; d++) {
                    if (num % d == 0) {
                        divisorCount[d]++;
                        if (d != num / d)
                            divisorCount[num / d]++;
                    }
                }
            }
 
            if (result == 2) {
                cout << result << endl;
            }
        }
    }
    return 0;
}