description: You are given two positive integers x and y. You can perform the following operation with x: write it in its binary form without leading zeros, add 0 or 1 to the right of it, reverse the binary form and turn it into a decimal number which is assigned as the new value of x.
  
  For example: 
  
    * 34 can be turned into 81 via one operation: the binary form of 34 is 100010, if you add 1, reverse it and remove leading zeros, you will get 1010001, which is the binary form of 81. 
    * 34 can be turned into 17 via one operation: the binary form of 34 is 100010, if you add 0, reverse it and remove leading zeros, you will get 10001, which is the binary form of 17. 
    * 81 can be turned into 69 via one operation: the binary form of 81 is 1010001, if you add 0, reverse it and remove leading zeros, you will get 1000101, which is the binary form of 69. 
    * 34 can be turned into 69 via two operations: first you turn 34 into 81 and then 81 into 69. 
  
  
  
  Your task is to find out whether x can be turned into y after a certain number of operations (possibly zero).
  
  Input
  
  The only line of the input contains two integers x and y (1 ≤ x, y ≤ 10^{18}).
  
  Output
  
  Print YES if you can make x equal to y and NO if you can't.
  
  Examples
  
  Input
  
  
  3 3
  
  
  Output
  
  
  YES
  
  
  Input
  
  
  7 4
  
  
  Output
  
  
  NO
  
  
  Input
  
  
  2 8
  
  
  Output
  
  
  NO
  
  
  Input
  
  
  34 69
  
  
  Output
  
  
  YES
  
  
  Input
  
  
  8935891487501725 71487131900013807
  
  
  Output
  
  
  YES
  
  Note
  
  In the first example, you don't even need to do anything.
  
  The fourth example is described in the statement.
solution: //package currentContest;
  
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.util.ArrayDeque;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.Random;
  import java.util.StringTokenizer;
  
  
  public class P1 {
  	public static int sol(String bx,String by) {
  		int flag=bx.length();
  		for(int i=bx.length()-1;i>=0;i--) {
  			if(bx.charAt(i)=='0') {
  				flag=i;
  			}else {
  				break;
  			}
  		}
  		int keepflag=flag;
  		int lz=bx.length()-flag;
  		int find=by.indexOf(bx.substring(0,flag));
  		if(find!=-1) {
  			int end=by.length();
  			int ese=-1;
  			int req=0;
  			for(int i=find+bx.substring(0,flag).length();i<by.length();i++) {
  				if(by.charAt(i)=='0') {
  					ese=1;
  					req++;
  				}else {
  					end=i;
  					break;
  				}
  			}
  			boolean keep=true;
  			if(by.length()==end&ese==1)
  			keep =(bx.length()>=by.length());
  			if((lz==req||req==0)&&keep) {
  				for(int i=0;i<find;i++) {
  					if(by.charAt(i)=='0') {
  						end=-1;
  					}
  				}
  				if(end!=-1) {
  					for(int i=end;i<by.length();i++) {
  						if(by.charAt(i)=='0') {
  							flag=-1;
  						}
  					}
  					if(flag!=-1) {
  						return 1;
  					}
  				}
  			}
  		}
  		flag=keepflag;
  			find=by.indexOf(new StringBuilder(bx.substring(0,flag)).reverse().toString());
  			if(find!=-1) {
  				for(int i=0;i<find;i++) {
  					if(by.charAt(i)=='0') {
  						find=-1;
  					}
  				}
  				if(find!=-1) {
  					for(int i=find+bx.substring(0,flag).length();i<by.length();i++) {
  						if(by.charAt(i)=='0') {
  							find=-1;
  						}
  					}
  					if(find!=-1) {
  						return 1;
  					}
  				}
  			}
  			return -1;
  	}
  	public static void main(String[] args) {
  		// TODO Auto-generated method stub
  		FastReader sc=new FastReader();
  		int t=1;
  		StringBuilder st=new StringBuilder();
  		while(t--!=0){
  			long x=sc.nextLong();
  			long y=sc.nextLong();
  			String bx=Long.toBinaryString(x);
  			String by=Long.toBinaryString(y);
  			//System.out.println(bx+" "+by);
  			if(sol(bx, by)==1) {
  				st.append("YES\n");
  				continue;
  			}
  			if(sol(bx+"1", by)==1) {
  				st.append("YES\n");
  				continue;
  			}
  			st.append("NO\n");
  		}
  		System.out.println(st);
  	}
  	
  	static class DisjointUnionSets {
  		int[] rank, parent;
  		int n;
  		
  		// Constructor
  		public DisjointUnionSets(int n)
  		{
  			rank = new int[n];
  			parent = new int[n];
  			this.n = n;
  			makeSet();
  		}
  		
  		// Creates n sets with single item in each
  		void makeSet()
  		{
  			for (int i = 0; i < n; i++) {
  				// Initially, all elements are in
  				// their own set.
  				parent[i] = i;
  			}
  		}
  		
  		// Returns representative of x's set
  		int find(int x)
  		{
  			// Finds the representative of the set
  			// that x is an element of
  			if (parent[x] != x) {
  				// if x is not the parent of itself
  				// Then x is not the representative of
  				// his set,
  				parent[x] = find(parent[x]);
  				
  				// so we recursively call Find on its parent
  				// and move i's node directly under the
  				// representative of this set
  			}
  			
  			return parent[x];
  		}
  		
  		// Unites the set that includes x and the set
  		// that includes x
  		void union(int x, int y)
  		{
  			// Find representatives of two sets
  			int xRoot = find(x), yRoot = find(y);
  			
  			// Elements are in the same set, no need
  			// to unite anything.
  			if (xRoot == yRoot)
  				return;
  			
  			// If x's rank is less than y's rank
  			if (rank[xRoot] < rank[yRoot])
  				
  				// Then move x under y  so that depth
  				// of tree remains less
  				parent[xRoot] = yRoot;
  			
  			// Else if y's rank is less than x's rank
  			else if (rank[yRoot] < rank[xRoot])
  				
  				// Then move y under x so that depth of
  				// tree remains less
  				parent[yRoot] = xRoot;
  			
  			else // if ranks are the same
  			{
  				// Then move y under x (doesn't matter
  				// which one goes where)
  				parent[yRoot] = xRoot;
  				
  				// And increment the result tree's
  				// rank by 1
  				rank[xRoot] = rank[xRoot] + 1;
  			}
  		}
  	}
  
  	static FastReader sc = new FastReader();
  
  	public static void solvegraph() {
  		int n = sc.nextInt();
  
  		int edge[][] = new int[n - 1][2];
  		for (int i = 0; i < n - 1; i++) {
  			edge[i][0] = sc.nextInt() - 1;
  			edge[i][1] = sc.nextInt() - 1;
  		}
  		ArrayList<ArrayList<Integer>> ad = new ArrayList<>();
  		for (int i = 0; i < n; i++) {
  			ad.add(new ArrayList<Integer>());
  		}
  		for (int i = 0; i < n - 1; i++) {
  			ad.get(edge[i][0]).add(edge[i][1]);
  			ad.get(edge[i][1]).add(edge[i][0]);
  		}
  		int parent[] = new int[n];
  		Arrays.fill(parent, -1);
  		parent[0] = n;
  		ArrayDeque<Integer> queue = new ArrayDeque<>();
  		queue.add(0);
  		int child[] = new int[n];
  		Arrays.fill(child, 0);
  		ArrayList<Integer> lv = new ArrayList<Integer>();
  		while (!queue.isEmpty()) {
  			int toget = queue.getFirst();
  			queue.removeFirst();
  			child[toget] = ad.get(toget).size() - 1;
  			for (int i = 0; i < ad.get(toget).size(); i++) {
  				if (parent[ad.get(toget).get(i)] == -1) {
  					parent[ad.get(toget).get(i)] = toget;
  					queue.addLast(ad.get(toget).get(i));
  				}
  			}
  			lv.add(toget);
  		}
  
  		child[0]++;
  	}
  
  	static void sort(int[] A) {
  		int n = A.length;
  		Random rnd = new Random();
  		for (int i = 0; i < n; ++i) {
  			int tmp = A[i];
  			int randomPos = i + rnd.nextInt(n - i);
  			A[i] = A[randomPos];
  			A[randomPos] = tmp;
  		}
  		Arrays.sort(A);
  	}
  
  	static void sort(long[] A) {
  		int n = A.length;
  		Random rnd = new Random();
  		for (int i = 0; i < n; ++i) {
  			long tmp = A[i];
  			int randomPos = i + rnd.nextInt(n - i);
  			A[i] = A[randomPos];
  			A[randomPos] = tmp;
  		}
  		Arrays.sort(A);
  	}
  
  	static String sort(String s) {
  		Character ch[] = new Character[s.length()];
  		for (int i = 0; i < s.length(); i++) {
  			ch[i] = s.charAt(i);
  		}
  		Arrays.sort(ch);
  		StringBuffer st = new StringBuffer("");
  		for (int i = 0; i < s.length(); i++) {
  			st.append(ch[i]);
  		}
  		return st.toString();
  	}
  
  	public static long gcd(long a, long b) {
  		if (a == 0) {
  			return b;
  		}
  		return gcd(b % a, a);
  	}
  
  	static class FastReader {
  		BufferedReader br;
  		StringTokenizer st;
  
  		public FastReader() {
  			br = new BufferedReader(new InputStreamReader(System.in));
  		}
  
  		String next() {
  			while (st == null || !st.hasMoreElements()) {
  				try {
  					st = new StringTokenizer(br.readLine());
  				} catch (IOException e) {
  					e.printStackTrace();
  				}
  			}
  			return st.nextToken();
  		}
  
  		int nextInt() {
  			return Integer.parseInt(next());
  		}
  
  		long nextLong() {
  			return Long.parseLong(next());
  		}
  
  		double nextDouble() {
  			return Double.parseDouble(next());
  		}
  
  		String nextLine() {
  			String str = "";
  			try {
  				str = br.readLine();
  			} catch (IOException e) {
  				e.printStackTrace();
  			}
  			return str;
  		}
  	}
  }
  