/* 
 *     Author:  srtry
 *     Created: 2025-10-17T21:49:35+09:00
 *     Coding:  utf-8-unix
 */

use proconio::input;
use std::collections::{HashSet, HashMap};
use std::iter;
use std::io::{stdout,Write,BufWriter};

const big:usize = 200001;

fn primes_leq(&n:&usize) -> Vec<usize> {
    let mut primes:Vec<usize> = Vec::new();
    let mut is_prime:Vec<bool> = vec![true;n+1];
    is_prime[0] = false;
    is_prime[1] = false;
    let limit:usize = (n as f64).sqrt() as usize;
    for i in 2..=limit {
        if is_prime[i] {            
            for j in i..=n/i {
                is_prime[i*j] = false;
            }
        }
    }
    primes = is_prime
        .iter()
        .enumerate()
        .filter(|(e_k,&e_v)| e_v)
        .map(|(e_k,e_v)| e_k)
        .collect();
    return primes;
}

fn main() {
    input!{
        k:usize,
        n:usize
    }

    let out = stdout();
    let mut out = BufWriter::new(out.lock());
    
    let primes:Vec<(usize,usize)> = primes_leq(&n)
        .iter()
        .filter(|&e| e>=&k)
        .map(|&e| (e, {if e==0 {9} else {(e-1)%9+1}}))
        .collect();
    let mut ans = primes[0].0;

    if primes.len()==1 {
        write!(out, "{}", ans).unwrap();
        return;
    }

    let mut max_len = 1;
    let mut r = 0;
    let mut l= 0;
    let mut mem:usize = 1<<(primes[0].1);
    loop {
        if r-l+1 >= max_len {
            max_len = r-l+1;
            ans = primes[l].0;
        }
        if r==primes.len()-1 {
            break;
        }
        match (mem&(1<<primes[r+1].1)==0, l==r, primes[r].1==primes[r+1].1) {
            (false,false,_) => {
                mem ^= 1<<primes[l].1;
                l += 1;
            }
            (_,true,true) => {
                r += 1;
                l += 1;
            }
            _ => {
                r += 1;
                mem |= 1<<primes[r].1;
            }
        }
    }

    write!(out, "{}", ans).unwrap();
}