#include <bits/stdc++.h>
using namespace std;

bool isPrime(long long n) {
    if (n < 2) return false;
    if (n == 2 || n == 3) return true;
    if (n % 2 == 0 || n % 3 == 0) return false;
    for (long long i = 5; i * i <= n; i += 6) {
        if (n % i == 0 || n % (i + 2) == 0) return false;
    }
    return true;
}

bool isPalindrome(long long n) {
    string s = to_string(n);
    string t = s;
    reverse(t.begin(), t.end());
    return s == t;
}

int main() {
    long long a, b; cin >> a >> b;
    long long cnt = 0;
    // Duyệt k từ căn bậc của a đến căn bậc của b
    long long start = ceil(sqrt(a));
    long long end = floor(sqrt(b));
    for (long long k = start; k <= end; k++) {
        long long num = k * k;
        if (isPrime(num) && isPalindrome(num)) {
            cnt++;
        }
    }
    cout << cnt;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

// Kiểm tra n có phải là số nguyên tố không
bool isPrime(long long n) {
    if (n < 2) return false;
    if (n == 2 || n == 3) return true;
    if (n % 2 == 0 || n % 3 == 0) return false;
    for (long long i = 5; i * i <= n; i += 6) {
        if (n % i == 0 || n % (i + 2) == 0) return false;
    }
    return true;
}

// Kiểm tra n có phải là số đối xứng không
bool isPalindrome(long long n) {
    long long rev = 0, temp = n;
    while (temp > 0) {
        rev = rev * 10 + temp % 10;
        temp /= 10;
    }
    return rev == n;
}

int main() {
    long long a, b; cin >> a >> b;
    long long cnt = 0;
    // Duyệt k từ sqrt(a) đến sqrt(b)
    long long start = ceil(sqrt(a));
    long long end = floor(sqrt(b));

    // Tối ưu: Nếu k chẵn, k^2 chẵn (>2) thì không phải số nguyên tố
    // Chỉ cần xét k lẻ (trừ trường hợp k=2 nếu nằm trong phạm vi)

    if (start <= 2 && 2 <= end) {
        if (isPrime(4) && isPalindrome(4)) cnt++; // 4 không phải nguyên tố
    }
    if (start <= 1 && 1 <= end) {
         if (isPrime(1)) cnt++; // 1 không phải nguyên tố
    }

    if (start % 2 == 0) start++;
    for (long long k = start; k <= end; k += 2) {
        long long num = k * k;
        if (isPrime(num) && isPalindrome(num)) {
            cnt++;
        }
    }
    cout << cnt;
    return 0;
}

#include <bits/stdc++.h>
#define ll long long
using namespace std;

const int MAX = 1e7 + 5; // Đủ để sàng số nguyên tố lên tới 10^14 (căn bậc 2 là 10^7)
int p[MAX];

void sang() {
    fill(p, p + MAX, 1);
    p[0] = p[1] = 0;
    for (int i = 2; i * i < MAX; i++) {
        if (p[i]) {
            for (int j = i * i; j < MAX; j += i) p[j] = 0;
        }
    }
}

// Kiểm tra số đối xứng
bool checkPalindrome(ll x) {
    string s = to_string(x);
    string t = s;
    reverse(t.begin(), t.end());
    return s == t;
}

int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
    sang();

    ll a, b; cin >> a >> b;
    ll ans = 0;

    // Chỉ duyệt các số k mà k^2 có thể là số nguyên tố
    // Nếu k^2 là số nguyên tố, thì k phải là số nguyên tố (vì nếu k = x*y, k^2 = x^2*y^2)
    // Tuy nhiên, điều kiện này chỉ đúng nếu k là tích của 2 số > 1.
    // Nếu k本身 là số nguyên tố, k^2 có thể không nguyên tố (trừ k=2).
    // Nhưng quan trọng là: để k^2 là số nguyên tố, k phải là số nguyên tố.
    // (Nếu k không nguyên tố, k = x*y => k^2 = x^2*y^2 => chia hết cho x^2).

    // Vậy ta chỉ cần duyệt các số k là số nguyên tố trong khoảng sqrt(a) đến sqrt(b).
    // Hoặc đơn giản hơn: Duyệt k từ sqrt(a) đến sqrt(b).
    // Nhưng Solution 2 tối ưu hơn: Duyệt k từ sqrt(a) đến sqrt(b).
    // Tại sao Solution 2 lại duyệt k từ sqrt(a) đến sqrt(b) và kiểm tra p[i]?
    // À, Solution 2 chỉ kiểm tra `check(i) and p[i]`.
    // Ở đây `i` là số k. `p[i]` kiểm tra k có phải số nguyên tố.
    // Nếu k là số nguyên tố, thì k^2 có thể là số nguyên tố (chỉ khi k=2, thì 2^2=4 không nguyên tố).
    // Nếu k không phải số nguyên tố (và k > 1), thì k^2 không bao giờ là số nguyên tố.
    // Vậy ta chỉ cần duyệt các k là số nguyên tố.

    ll start = ceil(sqrt(a));
    ll end = floor(sqrt(b));

    // Xử lý riêng k=2 nếu nằm trong phạm vi
    if (start <= 2 && 2 <= end) {
        ll num = 4;
        if (num >= a && num <= b && checkPalindrome(num)) {
            // 4 không phải nguyên tố nên bỏ qua
        }
    }

    if (start <= 1 && 1 <= end) {
        // 1 không phải nguyên tố
    }

    if (start % 2 == 0) start++;

    // Tuy nhiên, so sánh với Solution 2:
    // Solution 2 dùng `a = ceil(sqrt(a)); b = floor(sqrt(b));`
    // Và duyệt `for(int i = a; i<=b; i++)`
    // Điều kiện: `if(check(i) and p[i])`
    // Ở đây `i` là số k. `check(i)` là kiểm tra k có phải palindrome không.
    // `p[i]` là sàng số nguyên tố cho k.
    // Nếu k là số nguyên tố và k là palindrome.
    // Chờ đã, bài toán yêu cầu `k^2` là số nguyên tố và palindrome.
    // Solution 2 lại kiểm tra `k` là số nguyên tố và `k` là palindrome?
    // Đọc lại Solution 2: `if(check(i) and p[i])`
    // `check(i)` là `isPalindrome(i)`. `p[i]` là `isPrime(i)`.
    // Bài toán yêu cầu: `isPrime(i*i)` và `isPalindrome(i*i)`.
    // Solution 2 có vẻ sai lệch logic nếu chỉ kiểm tra `i`.
    // Nhưng Solution 2 lại được Accept.
    // Xem lại đề bài: "Bình Phước 3".
    // Có thể đề bài yêu cầu số `n` sao cho `sqrt(n)` là số nguyên tố và palindrome?
    // Hoặc có thể Solution 2 đã tối ưu bằng cách nhận thấy:
    // Nếu `i*i` là số nguyên tố, thì `i` phải là số nguyên tố.
    // Nếu `i*i` là palindrome, thì `i` có thể không phải palindrome.
    // Ví dụ: 11^2 = 121 (Palindrome). 11 là palindrome.
    // 101^2 = 10201 (Palindrome). 101 là palindrome.
    // Liệu có `i` không palindrome mà `i*i` palindrome?
    // 12^2 = 144 (Không palindrome).
    // Thử tìm counter-example: `i` không palindrome, `i*i` palindrome.
    // Rất hiếm.
    // Nhưng Solution 2 chỉ duyệt `i` và kiểm tra `check(i)` (palindrome của i) và `p[i]` (prime của i).
    // Nếu `i` là số nguyên tố và palindrome, thì `i*i` có thể là số nguyên tố (chỉ khi i=2, nhưng 2^2=4 không nguyên tố).
    // Wait, `i*i` không thể là số nguyên tố trừ khi i=1 (1 không nguyên tố).
    // Nếu i là số nguyên tố > 1, i*i chia hết cho i.
    // VẬY SOLUTION 2 CÓ VẤN ĐỀ HOẶC ĐỀ BÀI KHÁC.
    // Đọc lại Solution 2 một lần nữa.
    // `bool check(int n)` -> isPalindrome.
    // `if(check(i) and p[i])`
    // `cout << ans;`
    // Submission ID: 1571439.
    // Có thể bài này yêu cầu: Đếm số `k` sao cho `k` là số nguyên tố, `k` là số đối xứng, và `k^2` nằm trong [a, b]?
    // Hoặc bài này là "Bình Phước 3" có thể là bài khác.
    // Tuy nhiên, dựa trên Solution 3: `ntd(i)` kiểm tra `nt(i)` và `nt(dx(i))` và `dx(i)==i`.
    // `nt` là prime, `dx` là reverse.
    // Solution 3 chỉ kiểm tra `i` chứ không phải `i*i`.
    // VẬY CÓ LẼ ĐỀ BÀI YÊU CẦU: ĐẾM SỐ NGUYÊN TỐ ĐỐI XỨNG CÓ CĂN BẰNG 2 LÀ SỐ NGUYÊN (tức là số chính phương) TRONG [A, B]?
    // KHÔNG! Đọc kỹ lại Problem Description.
    // "Bình Phước 3". Description là hình ảnh, không có text.
    // Dựa vào tên file và accepted solutions.
    // Solution 1: `check(ll x)` -> `p[x]` (isPrime x) and `isPalindrome(x)`. Loop `for (ll i = 2; i ...`. Code bị cut.
    // Solution 3: `ntd(i)` -> `nt(i) && nt(dx(i)) && dx(i)==i`. Loop `while(i*i <= b)`. Inside `if(i*i >= a && i*i <= b) if(ntd(i)) d++;`
    // À! Solution 3 kiểm tra `i` có phải là số nguyên tố đối xứng không, nhưng chỉ xét `i` đó khi `i*i` nằm trong [a, b].
    // Vậy bài toán là: Đếm các số `k` sao cho:
    // 1. `k` là số nguyên tố.
    // 2. `k` là số đối xứng (palindrome).
    // 3. `a <= k*k <= b`.
    // Điều này giải thích tại sao Solution 2 lại Accepted.
    // Solution 2: `a = ceil(sqrt(a)); b = floor(sqrt(b));`
    // `for(int i = a; i<=b; i++) if(check(i) and p[i]) ans++;`
    // Nó đang đếm các số `i` (căn bậc hai) là số nguyên tố và đối xứng.
    // Solution 3 cũng làm tương tự: `if(i*i >= a && i*i <= b) if(ntd(i)) d++;`
    // Vậy Problem Understanding cần sửa lại.
    // Problem: Cho a, b. Đếm số nguyên tố đối xứng k sao cho k^2 thuộc [a, b].
    // Vấn đề: `k` có thể rất lớn. `k^2 <= b <= 10^14` => `k <= 10^7`.
    // Ta cần đếm các số `k` trong [sqrt(a), sqrt(b)] mà là số nguyên tố đối xứng.
    // Số lượng số nguyên tố đối xứng <= 10^7 là không nhiều (khoảng 1000 số).
    // Ta có thể sinh ra chúng hoặc sàng lọc.