You're given a row with n chairs. We call a seating of people "maximal" if the two following conditions hold:

  1. There are no neighbors adjacent to anyone seated. 
  2. It's impossible to seat one more person without violating the first rule. 



The seating is given as a string consisting of zeros and ones (0 means that the corresponding seat is empty, 1 — occupied). The goal is to determine whether this seating is "maximal".

Note that the first and last seats are not adjacent (if n ≠ 2).

Input

The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of chairs.

The next line contains a string of n characters, each of them is either zero or one, describing the seating.

Output

Output "Yes" (without quotation marks) if the seating is "maximal". Otherwise print "No".

You are allowed to print letters in whatever case you'd like (uppercase or lowercase).

Examples

Input

3
101


Output

Yes


Input

4
1011


Output

No


Input

5
10001


Output

No

Note

In sample case one the given seating is maximal.

In sample case two the person at chair three has a neighbour to the right.

In sample case three it is possible to seat yet another person into chair three.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;


public class main {

    public static void main(String[] args) {        
        InputReader in = new InputReader(System.in);
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out); 
     
        int n = in.nextInt();
        String s = in.nextLine();
        boolean ans = true;
        for(int i=0;i<n-2;i++){
            char c1 = s.charAt(i);
            char c2 = s.charAt(i+1);
            char c3 = s.charAt(i+2);
            
            String sub = c1+""+c2+""+c3;
            
            if(sub.equals("000") || sub.equals("011") || sub.equals("110") || sub.equals("111") || (i==0 && c1=='0' && c2=='0') || (i==n-3 && c2=='0' && c3=='0')){
                ans = false;
                break;   
            }
            
            
        }
        if(s.equals("00") || s.equals("11") || s.equals("0"))
            ans = false;
        if(ans)
            System.out.println("YES");
        else
            System.out.println("NO");
            
        }
         

     
    public static void printArray(long[] a){
        for(int k=0;k<a.length;k++)
            System.out.print(a[k]+" ");
    }
    // print all prime numbers between l and r
    public static void segmentedSieve(int l, int r){
        ArrayList<Integer> prime = new ArrayList<Integer>();
        int limit = (int) Math.floor(Math.sqrt(r)) +1;
        
        prime = sieveOfEratosthenes(limit, prime);
        
        boolean mark[] = new boolean[r-l+1];
        for(int i=0;i<mark.length;i++){
            mark[i] = true;
        }
        
        for(int i=0;i<prime.size();i++){
            int loLim = (int) Math.floor(l/prime.get(i))*(prime.get(i));
            if(loLim<l){
                loLim+=prime.get(i);
            }
            
            for(int j=loLim;j<r;j+=prime.get(i)){             
                    mark[j-l] = false;
            }
        }          
        for(int i=l;i<r;i++){
            if(mark[i - l]==true){
                System.out.print(i+" ");
            }
        }    
    }
    
    public static ArrayList<Integer> sieveOfEratosthenes(int limit, ArrayList<Integer> prime){
        boolean isPrime[] = new boolean[limit];
        for(int i=0;i<limit;i++){
            isPrime[i] = true;
        }
        for(int p=2; p*p<limit; p++){
            if(isPrime[p] == true){
                for(int i=2*p; i<limit;i+=p){
                    isPrime[i] = false;
                }
            }    
        }
        for(int p=2; p<limit; p++){
            if(isPrime[p]==true){
                prime.add(p);
            }
        }        
        return prime;
    }
    public static int[] sieveOfEratosthenes(int limit, int[] isPrime){
        
        for(int i=0;i<limit;i++){
            isPrime[i] = 1;
        }
        for(int p=2; p*p<limit; p++){
            if(isPrime[p] == 1){
                for(int i=2*p; i<limit;i+=p){
                    isPrime[i] = 0;
                }
            }    
        }        
        return isPrime;
    }
    public static int KMP(String text, String pattern){
        int n = text.length();
        int m = pattern.length();
        if(m==0) return 0;
        int fail[] = computeFailArray(pattern);
        int i=0;
        int j=0;
        
        while(i<n){
            if(text.charAt(i)==pattern.charAt(j)){
                if(j==m-1)    
                    return i-j; 
                i++;
                j++;     
            }
            else if(j>0)
                j=fail[j-1];
            else
                i++;            
        }
        return -1;
    }

    public static int[] computeFailArray(String pattern){
        int m = pattern.length();
        int fail[] = new int[m];
        fail[0] = 0;
        int j=0;
        int i=1;
        while(i<m){
            if(pattern.charAt(j)==pattern.charAt(i)){
                fail[i]=j+1;
                j++;
                i++;
            }
            else if(j>0){
                j=fail[j-1];
            }
            else
                i++;
                
        }
        return fail;
    }
    public static void reverseArray(int a[], int start, int end){
        if(start>=end)
            return;
        int temp = a[start];
        a[start] = a[end];
        a[end] = temp;
        reverseArray(a, start+1, end-1);
    }
    
    public static long fib(long n){
        long F[][] = new long[][]{{1,1},{1,0}};
        if (n == 0)
            return 0;
        power(F, n-1);
      
        return F[0][0];
    }
    
    static void multiply(long F[][], long M[][]){
        long x =  (F[0][0]*M[0][0] + F[0][1]*M[1][0])%1000000007;
        long y =  (F[0][0]*M[0][1] + F[0][1]*M[1][1])%1000000007;
        long z =  (F[1][0]*M[0][0] + F[1][1]*M[1][0])%1000000007;
        long w =  (F[1][0]*M[0][1] + F[1][1]*M[1][1])%1000000007;
     
        F[0][0] = x;
        F[0][1] = y;
        F[1][0] = z;
        F[1][1] = w;
    }
      
    static void power(long F[][], long n){
        if( n == 0 || n == 1) 
            return;
        long M[][] = new long[][]{{1,1},{1,0}};
      
        power(F, n/2);
        multiply(F, F);
      
        if (n%2 != 0)
            multiply(F, M);
    }
   static boolean isPrime(int n)
    {
    // Corner cases
    if (n <= 1)  return false;
    if (n <= 3)  return true;
 
    // This is checked so that we can skip 
    // middle five numbers in below loop
    if (n%2 == 0 || n%3 == 0) return false;
 
    for (int i=5; i*i<=n; i=i+6)
        if (n%i == 0 || n%(i+2) == 0)
           return false;
 
    return true;
    }
    
    static class Pair implements Comparable<Pair> {
	int u;
	int v;
	BigInteger bi;
	public Pair(int u, int v) {
		this.u = u;
		this.v = v;
	}
 
	public int hashCode() {
		int hu = (int) (u ^ (u >>> 32));
		int hv = (int) (v ^ (v >>> 32));
		return 31 * hu + hv;
	}
 
	public boolean equals(Object o) {
		Pair other = (Pair) o;
		return u == other.u && v == other.v;
	}
 
	public int compareTo(Pair other) {
		return Long.compare(u, other.u) != 0 ? Long.compare(u, other.u) : Long.compare(v, other.v);
	}
 
	public String toString() {
		return "[u=" + u + ", v=" + v + "]";
	}
    }
 
    public static void debug(Object... o) {
            System.out.println(Arrays.deepToString(o));
    }
 
    static long modulo(long a,long b,long c) {
        long x=1;
        long y=a;
        while(b > 0){
                if(b%2 == 1){
                        x=(x*y)%c;
                }
                y = (y*y)%c; // squaring the base
                b /= 2;
        }
        return  x%c;
    }
    
    public static long getClosestK(long[] a, long x) {
 
        int low = 0;
        int high = a.length - 1;
 
        while (low <= high) {
            int mid = (low + high) / 2;
 
            // test lower case
            if (mid == 0) {
                if (a.length == 1) {
                    return a[0];
                }
 
                return Math.min(Math.abs(a[0] - x), Math.abs(a[1] - x)) + x;
            }
 
 
            // test upper case
            if (mid == a.length - 1) {
                return a[a.length - 1];
            }
 
            // test equality
            if (a[mid] == x || a[mid + 1] == x) {
                return x;
            }
 
 
            // test perfect range.
            if (a[mid] < x  && a[mid + 1] > x) {
                return Math.min(Math.abs(a[mid] - x), Math.abs(a[mid + 1] - x)) + x;
            }
 
            // keep searching.
            if (a[mid] < x) {
                low = mid + 1;
            } else { 
                high = mid;
            }
        }
        throw new IllegalArgumentException("The array cannot be empty");
    }
 
    long factorial(long n,long M) {
        long ans=1;
        while(n>=1)
        {
            ans=(ans*n)%M;
            n--;
        }
        return ans;
    }
 
    static long gcd(long x, long y){
	if(x==0)
		return y;
	if(y==0)
		return x;
	long r=0, a, b;
	a = (x > y) ? x : y; // a is greater number
	b = (x < y) ? x : y; // b is smaller number
	r = b;
	while(a % b != 0)
	{
		r = a % b;
		a = b;
		b = r;
	}
	return r;
    }
 
    static class InputReader {
	public BufferedReader reader;
	public StringTokenizer tokenizer;
 
	public InputReader(InputStream inputstream) {
		reader = new BufferedReader(new InputStreamReader(inputstream));
		tokenizer = null;
	}
        public  int[] readArr(int n) {
		int[] input = new int[n];
		for (int i = 0; i < n; i++) {
			input[i] = nextInt();
		}
		return input;
	}
 
	public String nextLine(){
		String fullLine=null;
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			try {
				fullLine=reader.readLine();
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
			return fullLine;
		}
		return fullLine;
	}
	public String next() {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			try {
				tokenizer = new StringTokenizer(reader.readLine());
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		return tokenizer.nextToken();
	}
	public long nextLong() {
		return Long.parseLong(next());
	}
	public int nextInt() {
		return Integer.parseInt(next());
	}
        
    }
}
