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 codechef; // don't place package name! */
  
  import java.util.*;
  import java.lang.*;
  import java.io.*;
  /* Name of the class has to be "Main" only if the class is public. */
  public class Codechef
  {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; 
          } 
      } 
  //    static int mod = 998244353 ;
  //    static int N = 200005;
  //    static long factorial_num_inv[] = new long[N+1];
  //    static long natual_num_inv[] = new long[N+1];
  //    static long fact[] = new long[N+1];
  //    static void InverseofNumber() 
  //{ 
  //    natual_num_inv[0] = 1;
  //    natual_num_inv[1] = 1; 
  //    for (int i = 2; i <= N; i++) 
  //        natual_num_inv[i] = natual_num_inv[mod % i] * (mod - mod / i) % mod; 
  //} 
  //static void InverseofFactorial() 
  //{ 
  //    factorial_num_inv[0] = factorial_num_inv[1] = 1; 
    
  //    for (int i = 2; i <= N; i++) 
  //        factorial_num_inv[i] = (natual_num_inv[i] * factorial_num_inv[i - 1]) % mod; 
  //} 
  //static long nCrModP(long N, long R) 
  //{ 
  //    long ans = ((fact[(int)N] * factorial_num_inv[(int)R]) % mod * factorial_num_inv[(int)(N - R)]) % mod; 
  //    return ans%mod; 
  //}
      //static boolean prime[];
      //static void sieveOfEratosthenes(int n)
      //{
      //    prime = new boolean[n+1];
          
      //    for (int i = 0; i <= n; i++)
      //        prime[i] = true;
   
      //    for (int p = 2; p * p <= n; p++)
      //    {
      //        // If prime[p] is not changed, then it is a
      //        // prime
      //        if (prime[p] == true)
      //        {
      //            // Update all multiples of p
      //            for (int i = p * p; i <= n; i += p)
      //                prime[i] = false;
      //        }
      //    }
   
          
      //}
      
      static int visited[];
  	public static void main (String[] args) throws java.lang.Exception
  	{
      //    InverseofNumber();
      //    InverseofFactorial();
      //   fact[0] = 1; 
      //   for (long i = 1; i <= 2*100000; i++)
      //   { 
      //       fact[(int)i] = (fact[(int)i - 1] * i) % mod; 
      //   }
      
  		FastReader scan = new FastReader();
  		PrintWriter pw = new PrintWriter(System.out);
          long x = scan.nextLong();
          long y = scan.nextLong();
          if(x==y)
          pw.println("YES");
          else if(y%2==0)
          pw.println("NO");
          else{
          StringBuilder strx = decimalTobinary(x);
          StringBuilder stry = decimalTobinary(y);
          int i=0;
          int n = strx.length();
          while(i<n && strx.charAt(i)=='0'){
              i++;
          }
          String strxx2 = strx.substring(i);
          String strxx3 = strx.toString();
          StringBuilder strx4 = new StringBuilder();
          strx4.append(strxx2);
          strx.reverse();
          strx4.reverse();    
          stry.reverse();
          String stryy = stry.toString();
          String strxx = strx.toString();
          String strxx4 = strx4.toString();
         
          boolean ans1 = fun(stryy,strxx);
          boolean ans2 = fun(stryy,strxx2);
          boolean ans3 = fun(stryy,strxx3);
          boolean ans4 = fun(stryy,strxx4);
         
          if(ans1|ans2|ans3|ans4)
          pw.println("YES");
          else
          pw.println("NO");}
              pw.flush();
          
              
      }
      static boolean fun(String stry,String strx){
          int len_stry = stry.length();
          int len_strx = strx.length();
          int start = -1;
          int end = -1;
        //  System.out.println(len_strx+" "+len_stry); 
  
          for(int i=0;i<len_stry;i++){  
            
              int count = 0;
              for(int j=0;j<len_strx;j++){
                  if(j+i>=len_stry)
                  break;
                  if(stry.charAt(i+j)==strx.charAt(j)){
                      count++;
                  }
                  else
                  break;
              }
              if(count==len_strx){
                  
                  start = i;
                  end = i+len_strx-1;
                  int k = 0;
                  for(k=0;k<len_stry;k++){
                      if((k<start || k>end) && stry.charAt(k)!='1')
                      break;
                  }
                  if(k!=len_stry)
                  return false;
                  else
                  return true;
              }
          }
          return false;
      }
      static StringBuilder decimalTobinary(long x){
          StringBuilder strx = new StringBuilder();
          while(x!=0){
              strx.append(x%2);
              x = x/2;
          }
          return strx;
      }
        
          //static long bin_exp_mod(long a,long n){
              
          //    long res = 1;
              
          //    if(a==0)
          //    return 0;
          //    while(n!=0){
          //        if(n%2==1){
          //            res = ((res)*(a));
          //        }
          //           n = n/2;
          //            a = ((a)*(a));
          //    }
             
          //    return res;
          //}
      //static long bin_exp_mod(long a,long n){
  	//    long mod = 998244353;
  	//    long res = 1;
  	//    a = a%mod;
  	//    if(a==0)
  	//    return 0;
  	//    while(n!=0){
  	//        if(n%2==1){
  	//            res = ((res%mod)*(a%mod))%mod;
  	//        }
  	//           n = n/2;
  	//            a = ((a%mod)*(a%mod))%mod;
  	//    }
  	//    res = res%mod;
  	//    return res;
  	//}
     static long gcd(long a,long b){
         if(a==0)
         return b;
         return gcd(b%a,a);
     }
  //   static long lcm(long a,long b){
  //       return (a/gcd(a,b))*b;
  //   }
  }
  //class Pair{
  //    int x,y;
  //    Pair(int x,int y){
  //        this.x = x;
  //        this.y = y;
  //    }
  //}
  //    public boolean equals(Object obj) {
  //        // TODO Auto-generated method stub
  //        if(obj instanceof Pair)
  //        {
  //            Pair temp = (Pair) obj;
  //            if(this.x.equals(temp.x) && this.y.equals(temp.y))
  //                return true;
  //        }
  //        return false;
  //    }
  
  //    @Override
  //    public int hashCode() {
  //        // TODO Auto-generated method stub
          
  //        return (this.x.hashCode() + this.y.hashCode());        
  //    }
  //}
  //class Compar implements Comparator<Pair>{
  //    public int compare(Pair p1,Pair p2){
  //        if(p1.y>p2.y)
  //        return 1;
  //        else
  //        return -1;
  //    }
  //}