Professor GukiZ likes programming contests. He especially likes to rate his students on the contests he prepares. Now, he has decided to prepare a new contest. 

In total, n students will attend, and before the start, every one of them has some positive integer rating. Students are indexed from 1 to n. Let's denote the rating of i-th student as ai. After the contest ends, every student will end up with some positive integer position. GukiZ expects that his students will take places according to their ratings. 

He thinks that each student will take place equal to <image>. In particular, if student A has rating strictly lower then student B, A will get the strictly better position than B, and if two students have equal ratings, they will share the same position. 

GukiZ would like you to reconstruct the results by following his expectations. Help him and determine the position after the end of the contest for each of his students if everything goes as expected.

Input

The first line contains integer n (1 ≤ n ≤ 2000), number of GukiZ's students. 

The second line contains n numbers a1, a2, ... an (1 ≤ ai ≤ 2000) where ai is the rating of i-th student (1 ≤ i ≤ n).

Output

In a single line, print the position after the end of the contest for each of n students in the same order as they appear in the input.

Examples

Input

3
1 3 3


Output

3 1 1


Input

1
1


Output

1


Input

5
3 5 3 4 5


Output

4 1 4 3 1

Note

In the first sample, students 2 and 3 are positioned first (there is no other student with higher rating), and student 1 is positioned third since there are two students with higher rating.

In the second sample, first student is the only one on the contest.

In the third sample, students 2 and 5 share the first position with highest rating, student 4 is next with third position, and students 1 and 3 are the last sharing fourth position.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;

public class Solution {

//		public static final double eps = 1e-9;
//		public static final int mod = 1000000007;
//		public static final double pi = 3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679;
//		public static final int sievesize = (int) (1e7 + 10);
//		public static boolean[] prime;
//		public static final int dx[] = {1, -1, 0, 0};
//		public static final int dy[] = {0, 0, 1, -1};

	public static void main(String[] args) throws IOException {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		Task solver = new Task();
		solver.solve(1, in, out);
		out.close();
	}

	static class Task {
		
		public void solve(int testNumber, InputReader in, OutputWriter out) throws IOException {
	        int n = in.nextInt();
	        int[] arr = in.nextIntArray(n);
	        Map<Integer, ArrayList<Integer>> map = new HashMap<>();
	        for (int i = 0; i < arr.length; i++) {
	        	ArrayList<Integer> temp;
	        	if (!map.containsKey(arr[i])) temp = new ArrayList<>();
	        	else temp = map.get(arr[i]);
        		temp.add(i);
        		map.put(arr[i], temp);
	        }
	        Arrays.sort(arr);
	        int[] result = new int[n];
	        int pos = 1;
	        for (int i = n - 1; i >= 0;) {
	        	int count = 0;
	        	ArrayList<Integer> temp = map.get(arr[i]);
	        	while (!temp.isEmpty()) {
		        	result[temp.get(0)] = pos;
		        	temp.remove(0);
		        	i--;
		        	count++;
	        	}
	        	pos += count;
	        }
	        out.printIntArray(result);
		}

//		static class Node {
//			String name;
//			LinkedList<Node> list;
//			
//			public Node(String name) {
//				this.name = name;
//				list = new LinkedList<>();
//			}
//		}
//        
//		static class Pair implements Comparable<Pair> {
//		        	
//	      	int first, second;
//		        	
//		    public Pair(int first, int second) {
//	    		this.first = first;
//				this.second = second;
//			}
//		
//			@Override
//			public int compareTo(Pair o) {
//				return (int) (this.first - o.first);
//			}	
//	    }
	}

	//	public static int[] shuffle(int arr[], Random gen) {
	//		for(int i = 0, n = arr.length; i < n; i++)
	//		{
	//			int index = gen.nextInt(n - i) + i;
	//			int temp = arr[i];
	//			arr[i] = arr[index];
	//			arr[index] = temp;
	//		}
	//		return arr;
	//	}
	//
	//	public static boolean triangle(long a, long b, long c){
	//	    return ((a+b) > c && (b+c) >a && (a+c) > b);
	//	}
	//		
	//	public static boolean isPerfectSquare(long n){
	//		if (n < 0) 
	//	    	return false;
	//	    long test = (long) (Math.sqrt(n) + 0.5);
	//	    return test*test == n;
	//	}
	//		
	//	public static int isnum(char s){
	//		if(s=='1' || s=='2' || s=='3' || s=='4' || s=='5' || s=='6' || s=='7' || s=='8' || s=='9' || s=='0') 
	//	    	return 1; 
	//		return 0;
	//	}
	//		
	//	public static long nextPowerOf2(long n){
	//	    n--;
	//	    n |= n >> 1;
	//	    n |= n >> 2;
	//	    n |= n >> 4;
	//	    n |= n >> 8;
	//	    n |= n >> 16;
	//	    n++;
	//	    return n;
	//	}
	//		
		public static int gcd(int a, int b){
		    int t; 
		    while (b > 0){ 
		    	a = a % b; 
		    	t = a; 
		    	a = b; 
		    	b = t; 
	    	}
		    return a;
		}
	//		
	//	public static void sieve(int n){
	//		prime=new boolean[sievesize+1];
	//		Arrays.fill(prime, true);
	//	    long x, y; 
	//	    for(x = 2; x * x <= sievesize; x++)
	//	    { 
	//	    	if(prime[(int) x])
	//	    		for(y = x * 2; y <= sievesize; y += x) 
	//	    			prime[(int) y]=false; 
	//	    }
	//	}

	static class InputReader {
		public BufferedReader reader;
		public StringTokenizer tokenizer;

		public InputReader(InputStream stream) {
			reader = new BufferedReader(new InputStreamReader(stream), 32768);
			tokenizer = null;
		}

		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 int nextInt() {
			return Integer.parseInt(next());
		}

		public long nextLong() {
			return Long.parseLong(next());
		}
		
		public char nextChar() {
			return next().charAt(0);
		}
		
		public float nextFloat() {
			return Float.parseFloat(next());
		}
		
		public double nextDouble() {
			return Double.parseDouble(next());
		}

		public int[] nextIntArray(int size) {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			int[] arr=new int[size];
			for(int i = 0; i < size; i++) 
				arr[i] = Integer.parseInt(tokenizer.nextToken());
			return arr;
		}

		public long[] nextLongArray(int size) {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			long[] arr=new long[size];
			for(int i = 0; i < size; i++) 
				arr[i] = Long.parseLong(tokenizer.nextToken());
			return arr;
		}

		public double[] nextDoubleArray(int size) {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			double[] arr=new double[size];
			for(int i = 0; i < size; i++) 
				arr[i] = Double.parseDouble(tokenizer.nextToken());
			return arr;
		}

		public String[] nextStringArray(int size) throws IOException {
			String[] arr=new String[size];
			for(int i = 0; i < size; i++) 
				arr[i] = reader.readLine();
			return arr;
		}

		public char[] nextCharArray(int size) throws IOException {
			char[] arr=reader.readLine().toCharArray();
			return arr;
		}
	}

	static class OutputWriter {
		public PrintWriter pw;

		public OutputWriter(OutputStream stream) {
			pw = new PrintWriter(stream);
		}

		public void println(Object str) {
			pw.println(str);
		}

		public void print(Object str) {
			pw.print(str + " ");
		}

		public void close() {
			pw.close();
		}

		public void flush() {
			pw.flush();
		}

		public void printStringArray(String[] arr) {
			for(int i = 0; i < arr.length; i++)
				pw.println(arr[i]);
		}

		public void printIntArray(int[] arr) {
			for(int i = 0; i < arr.length; i++)
				pw.print(arr[i] + " ");
		}

		public void printLongArray(long[] arr) {
			for(int i = 0; i < arr.length; i++)
				pw.print(arr[i] + " ");
		}

		public void printCharArray(char[] arr) {
			for(int i = 0; i < arr.length; i++)
				pw.print(arr[i] + " ");
		}

		public void printFloatArray(float[] arr) {
			for(int i = 0; i < arr.length; i++)
				pw.print(arr[i] + " ");
		}

		public void printDoubleArray(double[] arr) {
			for(int i = 0; i < arr.length; i++)
				pw.print(arr[i] + " ");
		}
	}
}