Problem: When Serezha was three years old, he was given a set of cards with letters for his birthday. They were arranged into words in the way which formed the boy's mother favorite number in binary notation. Serezha started playing with them immediately and shuffled them because he wasn't yet able to read. His father decided to rearrange them. Help him restore the original number, on condition that it was the maximum possible one. 

Input

The first line contains a single integer n (1 ⩽ n ⩽ 10^5) — the length of the string. The second line contains a string consisting of English lowercase letters: 'z', 'e', 'r', 'o' and 'n'.

It is guaranteed that it is possible to rearrange the letters in such a way that they form a sequence of words, each being either "zero" which corresponds to the digit 0 or "one" which corresponds to the digit 1.

Output

Print the maximum possible number in binary notation. Print binary digits separated by a space. The leading zeroes are allowed.

Examples

Input


4
ezor


Output


0 


Input


10
nznooeeoer


Output


1 1 0 

Note

In the first example, the correct initial ordering is "zero".

In the second example, the correct initial ordering is "oneonezero".

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.*;

import static java.util.Arrays.sort;
import static java.util.Collections.sort;
import static java.util.Arrays.fill;
import static java.util.Arrays.copyOfRange;
import static java.util.Arrays.binarySearch;
 
import static java.lang.Math.min;
import static java.lang.Math.max;

public class Main {
	
	public static void main(String[] args) throws IOException {
		int n = in.nextInt();
		char[] s = in.next().toCharArray();
		int cnt1 = 0;
		for(char ci : s)
			if(ci == 'n')
				cnt1 ++;
		StringBuilder ans = new StringBuilder();
		for(int j = 0; j < cnt1; j ++)
			ans.append("1 ");
		for(int j = 0; j < (n - cnt1 * 3) / 4; j ++)
			ans.append("0 ");
		System.out.println(ans);
	}
 
	public static FastReader in = new FastReader();
	public static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
	
	public static void gcj(int cn, Object ans) throws IOException {
		System.out.print("Case #" + cn + ": " + ans + "\n");
	}
	
	public static ArrayList <Integer>[] ALArrayI(int size) {
		ArrayList <Integer>[] l = new ArrayList[size];
		for(int i = 0; i < size; i ++)
			l[i] = new ArrayList <> ();
		return l;
	}
	
	public static ArrayList <Long>[] ALArrayL(int size) {
		ArrayList <Long>[] l = new ArrayList[size];
		for(int i = 0; i < size; i ++)
			l[i] = new ArrayList <> ();
		return l;
	}
	
	public static Integer[] integerList(int fi, int fo) {
		Integer[] l = new Integer[fo - fi];
		for(int i = 0; i < fo - fi; i ++)
			l[i] = fi + i;
		return l;
	}
}
 
class Graph {
	TreeSet <Integer>[] g;
	
	public Graph(int n) {
		g = new TreeSet[n];
		for(int i = 0; i < n; i ++)
			g[i] = new TreeSet <> ();
	}
	
	public void addEdge(int u, int v) {
		g[u].add(v);
	}
	
	public TreeSet <Integer> getAdj(int u) {
		return g[u];
	}
	
	public int nodes() {
		return g.length;
	}
}
 
class FastReader {
    BufferedReader br;
    StringTokenizer st;
 
    public FastReader() {
        br = new BufferedReader(new InputStreamReader(System.in));
    }
    
    public String next() {
        while (st == null || !st.hasMoreElements()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (IOException  e) {
                e.printStackTrace();
            }
        }
        return st.nextToken();
    }
 
    public char nextChar() {
    	return next().charAt(0);
    }
    
    public int nextInt() {
        return Integer.parseInt(next());
    }
 
    public long nextLong() {
        return Long.parseLong(next());
    }
 
    public double nextDouble() {
        return Double.parseDouble(next());
    }
 
    public String nextLine() {
        String str = "";
        try {
            str = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return str;
    }
    
    public int[] nextIntArray(int n) {
    	int[] a = new int[n];
    	for(int i = 0; i < n; i ++)
    		a[i] = nextInt();
    	return a;
    }
    
    public Integer[] nextIntegerArray(int n) {
    	Integer[] a = new Integer[n];
    	for(int i = 0; i < n; i ++)
    		a[i] = nextInt();
    	return a;
    }
    
    public long[] nextLongArray(int n) {
    	long[] a = new long[n];
    	for(int i = 0; i < n; i ++)
    		a[i] = nextLong();
    	return a;
    }
    
    public double[] nextDoubleArray(int n) {
    	double[] a = new double[n];
    	for(int i = 0; i < n; i ++)
    		a[i] = nextDouble();
    	return a;
    }
    
    public String[] nextStringArray(int n) {
    	String[] a = new String[n];
    	for(int i = 0; i < n; i ++)
    		a[i] = next();
    	return a;
    }
}