import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Scanner;



public class dijkstra {
	static int N = 2023;
	static int INF = 0x3f3f3f3f;
	static int[][]g = new int[N][N];
	static int []dist = new int[N];
	static boolean[]flag = new boolean[N];
	static int n,m; //顶点和边数
	static int gcd(int a,int b) {
		return b==0?a:gcd(b, a%b);
	}
	
	static class Node implements Comparable<Node>{
		int v,dis; //节点的权值
		
		public Node(int idx, int i) {
			// TODO Auto-generated constructor stub
			this.v=idx;
			this.dis=i;
		}

		@Override
		public int compareTo(Node o) {
			// TODO Auto-generated method stub
			return this.dis-o.dis;
		}
	}
	//idx 为源点
	public static void dij(int idx) {
		PriorityQueue<Node> queue= new PriorityQueue<>();
		Arrays.fill(dist, 0,n+1,INF);
		Arrays.fill(flag, false);
		dist[idx]=0;
		
		queue.offer(new Node(idx,0));
		while(!queue.isEmpty()) {
			Node cur = queue.poll();
			int t = cur.v;
			if(flag[t]) continue;
			flag[t]=true; //该节点未被遍历
			for (int j = 1; j <= n; j++) {
				if(flag[j]==false&&dist[j]>dist[t]+g[t][j]) {
					dist[j]=dist[t]+g[t][j];
	
					//只要是大于当前距离的都放进去
					queue.offer(new Node(j,dist[j]));
				}
			}
		}
	}
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		n = scanner.nextInt();
		m = scanner.nextInt();
		
		//初始化邻接矩阵
		for (int i = 0; i <=n; i++) {
			Arrays.fill(g[i], INF);
			//对于自己 距离为0
			g[i][i]=0;
		}
		
		//输入边
//		for (int i = 0; i < m; i++) {
//			int u = scanner.nextInt();
//			int v = scanner.nextInt();
//			int w = scanner.nextInt();
//			g[u][v]=Math.min(g[u][v], w);
//		}
		for (int i = 1; i <= 2021; i++) {
			for (int j = 1; j <= 2021; j++) {
				if(Math.abs(i-j)>21) {
					g[i][j]=INF;
				}else {
					int gong = i/gcd(i, j)*j;
					g[i][j]=gong;
				}
				
			}
		}
		
		int st =1;
		dij(st);
		if(dist[n] == INF) {
		    System.out.println(-1); // 到达不了终点
		} else {
		    System.out.println(dist[n]); // 输出源点1到终点n的最短路径
		}
	}
}