Alice has a birthday today, so she invited home her best friend Bob. Now Bob needs to find a way to commute to the Alice's home.

In the city in which Alice and Bob live, the first metro line is being built. This metro line contains n stations numbered from 1 to n. Bob lives near the station with number 1, while Alice lives near the station with number s. The metro line has two tracks. Trains on the first track go from the station 1 to the station n and trains on the second track go in reverse direction. Just after the train arrives to the end of its track, it goes to the depot immediately, so it is impossible to travel on it after that.

Some stations are not yet open at all and some are only partially open — for each station and for each track it is known whether the station is closed for that track or not. If a station is closed for some track, all trains going in this track's direction pass the station without stopping on it.

When the Bob got the information on opened and closed stations, he found that traveling by metro may be unexpectedly complicated. Help Bob determine whether he can travel to the Alice's home by metro or he should search for some other transport.

Input

The first line contains two integers n and s (2 ≤ s ≤ n ≤ 1000) — the number of stations in the metro and the number of the station where Alice's home is located. Bob lives at station 1.

Next lines describe information about closed and open stations.

The second line contains n integers a_1, a_2, …, a_n (a_i = 0 or a_i = 1). If a_i = 1, then the i-th station is open on the first track (that is, in the direction of increasing station numbers). Otherwise the station is closed on the first track.

The third line contains n integers b_1, b_2, …, b_n (b_i = 0 or b_i = 1). If b_i = 1, then the i-th station is open on the second track (that is, in the direction of decreasing station numbers). Otherwise the station is closed on the second track.

Output

Print "YES" (quotes for clarity) if Bob will be able to commute to the Alice's home by metro and "NO" (quotes for clarity) otherwise.

You can print each letter in any case (upper or lower).

Examples

Input

5 3
1 1 1 1 1
1 1 1 1 1


Output

YES


Input

5 4
1 0 0 0 1
0 1 1 1 1


Output

YES


Input

5 2
0 1 1 1 1
1 1 1 1 1


Output

NO

Note

In the first example, all stations are opened, so Bob can simply travel to the station with number 3.

In the second example, Bob should travel to the station 5 first, switch to the second track and travel to the station 4 then.

In the third example, Bob simply can't enter the train going in the direction of Alice's home.
    import java.io.*;
    import java.util.*;
    import java.math.*;
    import java.lang.*;
     
    import static java.lang.Math.*;
     
    public class train implements Runnable
    {
        static class InputReader
        {
            private InputStream stream;
            private byte[] buf = new byte[1024];
            private int curChar;
            private int numChars;
            private SpaceCharFilter filter;
            private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
     
            public InputReader(InputStream stream)
            {
                this.stream = stream;
            }
            
            public int read()
            {
                if (numChars==-1) 
                    throw new InputMismatchException();
                
                if (curChar >= numChars)
                {
                    curChar = 0;
                    try 
                    {
                        numChars = stream.read(buf);
                    }
                    catch (IOException e)
                    {
                        throw new InputMismatchException();
                    }
                    
                    if(numChars <= 0)               
                        return -1;
                }
                return buf[curChar++];
            }
         
            public String nextLine()
            {
                String str = "";
                try
                {
                    str = br.readLine();
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
                return str;
            }
            public int nextInt()
            {
                int c = read();
                
                while(isSpaceChar(c)) 
                    c = read();
                
                int sgn = 1;
                
                if (c == '-') 
                {
                    sgn = -1;
                    c = read();
                }
                
                int res = 0;
                do 
                {
                    if(c<'0'||c>'9') 
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = read();
                }
                while (!isSpaceChar(c)); 
                
                return res * sgn;
            }
            
            public long nextLong() 
            {
                int c = read();
                while (isSpaceChar(c))
                    c = read();
                int sgn = 1;
                if (c == '-') 
                {
                    sgn = -1;
                    c = read();
                }
                long res = 0;
                
                do 
                {
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = read();
                }
                while (!isSpaceChar(c));
                    return res * sgn;
            }
            
            public double nextDouble() 
            {
                int c = read();
                while (isSpaceChar(c))
                    c = read();
                int sgn = 1;
                if (c == '-') 
                {
                    sgn = -1;
                    c = read();
                }
                double res = 0;
                while (!isSpaceChar(c) && c != '.') 
                {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = read();
                }
                if (c == '.') 
                {
                    c = read();
                    double m = 1;
                    while (!isSpaceChar(c)) 
                    {
                        if (c == 'e' || c == 'E')
                            return res * Math.pow(10, nextInt());
                        if (c < '0' || c > '9')
                            throw new InputMismatchException();
                        m /= 10;
                        res += (c - '0') * m;
                        c = read();
                    }
                }
                return res * sgn;
            }
            
            public String readString() 
            {
                int c = read();
                while (isSpaceChar(c))
                    c = read();
                StringBuilder res = new StringBuilder();
                do 
                {
                    res.appendCodePoint(c);
                    c = read();
                } 
                while (!isSpaceChar(c));
                
                return res.toString();
            }
         
            public boolean isSpaceChar(int c) 
            {
                if (filter != null)
                    return filter.isSpaceChar(c);
                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
            }
         
            public String next() 
            {
                return readString();
            }
            
            public interface SpaceCharFilter 
            {
                public boolean isSpaceChar(int ch);
            }
        }
        
        public static void main(String args[]) throws Exception
        {
            new Thread(null, new train(),"train",1<<26).start();
        }
        /*class Wand {
            int ind;
            int val;
            Wand(int a, int b) {
                ind = a;
                val = b;
            }
        }*/ //(This statement shows how to make our own class)
        
        //to count no of 1 in binary form::
        long count_one (int n){
                long count=0;
                while(n>0)
                {
                   n = n&(n-1);
                   count++;
                }
                return count;
           }
        //To Find most significant setbit of a number::
        int Last_set_bit(int n){
            return (int)(Math.log(n)/Math.log(2));
        }   
        //power mod::
        static long powmod(long x, long n, long m) {
            if (n == 0) return 1;

            else if (n % 2 == 0) return powmod(((x % m) * (x % m)) % m, n / 2, m);

            else if (n % 2 == 1) return (((x % m) * powmod(((x % m) * (x % m)) % m, (n - 1) / 2, m)) % m);

            else return 0;
        }
        //binary expo::
        static long binaryexpo(long x, long n){
            if(n==0) return 1;
            if(n%2==0) return binaryexpo(x*x,n);
            else return x*binaryexpo(x*x,(n-1)%2);
        }
        //GCD od 2 nos::
        public static long gcd(long a, long b) {
            if(b==0) return a;
            return gcd(b%a,a);
        }
        //GCD of Array::
        public static long gcd(long[] input) {
            long result = input[0];
     
            for (int i = 1; i < input.length; i++) {
                result = gcd(result, input[i]);
            }
     
            return result;
        }
        //LCM of 2 nos::
        public static long lcm(long a, long b) {
            return a * (b / gcd(a, b));
        }
        //LCM of Array::
        public static long lcm(long[] input) {
            long result = input[0];
     
            for (int i = 1; i < input.length; i++) {
                result = lcm(result, input[i]);
            }
     
            return result;
        }
        //BINARY TREE::
        public class Node{
            int data;
            Node left,right;
            Node(int data){
                this.data = data;
                left = right = null;
            }

            public void insert(int value){
                if(value<=data){
                    if(left==null) left = new Node(value);
                    else left.insert(value);
                }
                else{
                    if(right==null) right = new Node(value);
                    else right.insert(value);
                }
            }  

            public boolean contains(int value){
               if(value==data) return true;
                else if(value<data){
                    if(left==null) return false;
                    else return left.contains(value);
                }
                else{
                    if(right==null) return false;
                    else return right.contains(value);
                }
            }
        }
        //FOR FINDING HEIGHT OF A TREE::
        public int maxht(Node root){
            if(root == null) return 0;
            else{
                int ld = maxht(root.left);
                int rd = maxht(root.right);
                
                if(ld>rd) return ld+1;
                else return rd+1;
            }
        }
        //Graph::
        public class graph{
            ArrayList<Integer> a;
            int d;
            boolean b;

            void graph(){
                this.d = 0;
                this.b = false;
            }
        }
        public void graphinit(graph g[]){
            for(int c=1;c<g.length;c++){
                g[c] = new graph();
                g[c].a = new ArrayList<>();
            }
        } 
        public void graphT(graph g[], graph gt[]){
            for(int c=1;c<g.length;c++){
                for(int d=0;d<g[c].a.size();d++){
                    gt[g[c].a.get(d)].a.add(c);
                }
            }
        } 
        //Code starts right here... 
        public void run()
        {
            InputReader sc = new InputReader(System.in);
            PrintWriter w = new PrintWriter(System.out);
            /*write your code here*/
            /*take input through sc.nextInt and all and output through w.print & w.println*/
            int n = sc.nextInt();
            int s = sc.nextInt();
            int a[] = new int[n];
            int b[] = new int[n];
            for(int c=0;c<n;c++) a[c] = sc.nextInt();
            for(int c=0;c<n;c++) b[c] = sc.nextInt();    
            if(a[0]==1){
                if(a[s-1]==1) w.println("YES");
                else if(a[s-1]==0 && b[s-1]==0) w.println("NO");
                else if(a[s-1]==0 && b[s-1]==1){
                    boolean bo = false;
                    for(int c=s;c<n;c++){
                        if(a[c]==1 && b[c]==1){
                            bo = true;
                            break;
                        }
                    }
                    if(bo) w.println("YES");
                    else w.println("NO");
                }
            }
            else w.println("NO");    
            w.close();
        }
        
    }