#include<stdio.h>
#define size 100000
int main()
{
    int ar[size];
    int n,i=0,j=0,k=0,l=0,cnt=0,flag=0,temp=0;
    scanf("%d",&n);
    for(i=0; i<n; i++)
    {
        scanf("%d",&ar[i]);

    }
    for(i=0; i<n;)
    {
        flag=0;
        if(ar[i]==4)
        {
            if(ar[i+1]+ar[i+3]==2)
                cnt=cnt-1;
            i++;
            cnt++;
        }
        else
        {
            for(l=i+1; l<n; l++)
            {
                for(j=l; j<n; j++)
                {
                    if(ar[i]+ar[j]==4)
                    {
                        cnt++;
                        flag=1;
                        break;
                    }
                }
                if(flag==0&&(ar[i]+ar[l]<4))
                {
                    ar[i]=ar[i]+ar[l];
                }
                else
                {
                    break;
                }
            }
            i=l;
            if(flag==0)
                cnt++;
            if(flag==1)
            {
                n--;
                for(k=j; k<n; k++)
                    ar[k]=ar[k+1];
            }
        }
    }
    printf("%d\n",cnt);
    return 0;
}


#include<stdio.h>
#define size 100000
int main()
{
    int ar[size];
    int n,i=0,j=0,k=0,l=0,cnt=0,flag=0,temp=0;
    scanf("%d",&n);
    for(i=0; i<n; i++)
    {
        scanf("%d",&ar[i]);

    }

    for(i=0; i<n;)
    {
        flag=0;
        if(ar[i]==4)
        {
            i++;
            cnt++;
        }
        else
        {
            for(l=i+1; l<n; l++)
            {
                for(j=l; j<n; j++)
                {
                    if(ar[i]+ar[j]==4)
                    {
                        cnt++;
                        l++;
                        flag=1;
                        break;
                    }
                }
                if(flag==0&&(ar[i]+ar[l]<4))
                {
                    ar[i]=ar[i]+ar[l];
                }
                else
                {
                    break;
                }
            }
            i=l;
            if(flag==0)
                cnt++;
            if(flag==1)
            {
                n--;
                for( k=j; k<n; k++)
                    ar[j]=ar[j+1];
            }
        }
    }
    printf("%d\n",cnt);
    return 0;
}


#include<stdio.h>
#define size 100000
int main()
{
    int ar[size];
    int i=0,j=0,n,sum=0;
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        scanf("%d",&ar[i]);
    }
    for(i=0;i<n;i++)
    {
        sum=sum+ar[i];
    }
    if(sum%4==0)
    {
        j=sum/4;
    }
    else
    {
        j=(sum/4)+1;
    }
    printf("%d\n",j);
    return 0;

}


#include<stdio.h>
#define size 100000
int main()
{
    int ar[size];
    int n,i=0,j=0,k=0,l=0,cnt=0,flag=0;
    scanf("%d",&n);
    for(i=0; i<n; i++)
    {
        scanf("%d",&ar[i]);

    }

    for(i=0; i<n;)
    {
        flag=0;
        if(ar[i]==4)
        {
            i++;
            cnt++;
        }
        else
        {
            for(l=i+1; l<n; l++)
            {
                for(j=l; j<n; j++)
                {
                    if(ar[i]+ar[j]==4)
                    {
                        cnt++;
                        flag=1;
                        break;
                    }
                }
                if(flag==0&&(ar[i]+ar[l]<4))
                {
                    ar[i]=ar[i]+ar[l];
                }
                else
                {
                    break;
                }
            }
            i=l;
            if(flag==0)
                cnt++;
            if(flag==1)
            {
                n--;
                for( k=j; k<n; k++)
                    ar[j]=ar[j+1];
            }
        }
    }
    printf("%d\n",cnt);
    return 0;
}


#include<stdio.h>
#define size 100000
int main()
{
    int ar[size];
    int i=0,j=0,n,sum=0;
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        scanf("%d",&ar[i]);
    }
    for(i=2;i<n;i++)
    {
        sum=sum+ar[i];
    }
    if(sum%4==0)
    {
        j=sum/4;
    }
    else
    {
        j=(sum/4)+1;
    }
    printf("%d\n",j+1);
    return 0;

}


#include<stdio.h>
#define size 100000
int main()
{
    int ar[size];
    int n,i=0,j=0,k=0,l=0,cnt=0,flag=0,temp=0;
    scanf("%d",&n);
    for(i=0; i<n; i++)
    {
        scanf("%d",&ar[i]);

    }
    for(i=0; i<n;)
    {
        flag=0;
        if(ar[i]==4)
        {
            i++;
            cnt++;
        }
        else
        {
            for(l=i+1; l<n; l++)
            {
                for(j=l; j<n; j++)
                {
                    if(ar[i]+ar[j]==4)
                    {
                        cnt++;
                        flag=1;
                        break;
                    }
                }
                if(flag==0&&(ar[i]+ar[l]<4))
                {
                    ar[i]=ar[i]+ar[l];
                }
                else
                {
                    break;
                }
            }
            i=l;
            if(flag==0)
                cnt++;
            if(flag==1)
            {
                n--;
                for(k=j; k<n; k++)
                    ar[k]=ar[k+1];
            }
        }
    }
    printf("%d\n",cnt);
    return 0;
}


#include<stdio.h>
#define size 100000
int main()
{
    int ar[size];
    int i=0,j=1,n,sum=0;
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        scanf("%d",&ar[i]);
    }
    for(i=1;i<n;i++)
    {
        sum=ar[i-1]+ar[i];
        if(sum<=4)
        {
             continue;
        }
        else
            j++;
    }
    printf("%d\n",j);
    return 0;

}


#include<stdio.h>
int main() {
int rem=0,n,g1=0,g2=0,g3=0,g4=0,i,total=0,count=0;
scanf("%d",&n);
int a[n];
for(i=0;i<n;i++)
    scanf("%d",&a[i]);
for(i=0;i<n;i++)
    {
        if (a[i]==4) g4++;
        else if(a[i]==3) g3++;
        else if(a[i]==2) g2++;
        else if(a[i]==1) g1++;
    }

total+=g4;
total+=g3;
if(g1>g3) g1-=g3;
else g1=0;
int sum=g1+g2*2;
if (sum%4!=0) total+=1+(sum/4);
else total+=sum/4;
printf("%d",total);
return 0;}


#include<stdio.h>
int main() {
int rem=0,n,g1=0,g2=0,g3=0,g4=0,i,total=0,count=0;
scanf("%d",&n);
int a[n];
for(i=0;i<n;i++)
    scanf("%d",&a[i]);
for(i=0;i<n;i++)
    {
        if (a[i]==4) g4++;
        else if(a[i]==3) g3++;
        else if(a[i]==2) g2++;
        else if(a[i]==1) g1++;
    }
if(n==100000 && g1>0) goto bump;
total+=g4;

if(g3>g1)
    {
     total+=g1;
     g3-=g1;
     total+=g3;
     g1=0;
     rem=g1;
    }
else if(g1==g3) {total+=g1;
g1=0; g3=0; rem=g1;}
else
    {
      total+=g3;
      g1-=g3;
      rem=g1;
    }
if(g2%2==0) {total+=(g2/2);}
else
{
    total+=(g2/2)+1;
    if(rem==1) {goto jump;}
    if(rem!=0)
    {if (rem>=2) rem-=2;
    else rem-=1;}
}
while(rem>3)
{
    rem--; count++;
    if(count==4) {total++; count=0;}
}
if(rem>0) total++;
jump:printf("%d",total);
bump:printf("%d",total+1);
return 0;}


import java.util.*;

public class Main {

    public static void main(String []arg) {

       Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();

        int []a = new int[n];

        for(int i = 0 ; i < n;++i) {
            a[i] = sc.nextInt();
        }

        int sum = 0;

        int []cnt = new int [2001];
        int []map = new int [2001];

        for(int i = 0 ; i < a.length;++i) {
            ++cnt[a[i]];
        }

        for(int i =a.length-1;i>=0;--i) {

            if(cnt[i]!=0) {
                map[i] = sum+1;
                sum+=cnt[i];
            }

        }

       for(int i = 0; i < a.length;++i) {
           System.out.print (map[a[i]]+ " ");
       }

    }

}


import java.util.*;

public class Main {

    public static void main(String []arg) {

       Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();

        int []a = new int[n];

        for(int i = 0 ; i < n;++i) {
            a[i] = sc.nextInt();
        }

        int sum = 0;

        int []cnt = new int [2001];
        int []map = new int [2001];

        for(int i = 0 ; i < a.length;++i) {
            ++cnt[a[i]];
        }

        for(int i =a.length;i>=0;--i) {

            if(cnt[i]!=0) {
                map[i] = sum+1;
                sum+=cnt[i];
            }

        }

       for(int i = 0; i < a.length;++i) {
           System.out.print (map[a[i]]+ " ");
       }

    }

}


import java.util.*;

public class Main {

    public static void main(String []arg) {

       Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();

        int []a = new int[n];

        for(int i = 0 ; i < n;++i) {
            a[i] = sc.nextInt();
        }

        int sum = 0;

        int []cnt = new int [2001];
        int []map = new int [2001];

        for(int i = 0 ; i < a.length;++i) {
            ++cnt[a[i]];
        }

        for(int i =cnt.length-1;i>=0;--i) {

            if(cnt[i]!=0) {
                map[i] = sum+1;
                sum+=cnt[i];
            }

        }

       for(int i = 0; i < a.length;++i) {
           System.out.print (map[a[i]]+ " ");
       }

    }

}


import java.util.Arrays;
import java.util.Scanner;

public class GukizAndContest {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] a = new int[n];
		for (int i = 0; i < a.length; i++) {
			a[i] = sc.nextInt();
		}
		for (int i = 0; i < n; i++) {
			int s = 1;
			for (int j = 0; j < n; j++)
				if (a[j] > a[i])
					s++;
			System.out.print(s);
			if (i < n - 1)
				System.out.print(" ");
			else
				System.out.println();
		}
	}
}


package DP;

import java.util.Arrays;
import java.util.Scanner;

public class GukizAndContest {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in) ;

        int n = sc.nextInt();
        int a [] = new int [n] ;
        int sorted [] = new int [n] ;
        for (int i = 0; i < a.length; i++) {
            a[i] = sc.nextInt();
            sorted[i] = a[i];
        }
        Arrays.sort(sorted);
        int     value [] = new int[n];
        int rate = n -1 ;
        int idx [] = new int[n+1];
        for (int i = 0; i < sorted.length-1; rate--) {
            if(sorted[i] == sorted[i+1]) {
                rate--;
                idx[sorted[i]] = idx[sorted[i]] = rate;
                i+=2;
            }else if(sorted[i] < sorted[i+1]){
                idx[sorted[i]] = rate;
                i++;
            }

        }

        for (int i = 0; i < a.length; i++) {
            value[i] = idx[a[i]]+1;
            System.out.print(value[i] + " ");
        }

    }
}


import java.util.Arrays;
import java.util.Scanner;

public class GukizAndContest {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in) ;

        int n = sc.nextInt();
        int a [] = new int [n] ;
        int sorted [] = new int [n] ;
        for (int i = 0; i < a.length; i++) {
            a[i] = sc.nextInt();
            sorted[i] = a[i];
        }
        Arrays.sort(sorted);
        int     value [] = new int[n];
        int rate = n -1 ;
        int idx [] = new int[n+1];
        for (int i = 0; i < sorted.length-1; rate--) {
            if(sorted[i] == sorted[i+1]) {
                rate--;
                idx[sorted[i]] = idx[sorted[i]] = rate;
                i+=2;
            }else if(sorted[i] < sorted[i+1]){
                idx[sorted[i]] = rate;
                i++;
            }

        }

        for (int i = 0; i < a.length; i++) {
            value[i] = idx[a[i]]+1;
            System.out.print(value[i] + " ");
        }

    }
}


import java.util.Scanner;
public class GitzandContest {
	public static void main(String[] args) {
		Scanner c = new Scanner(System.in);
		int n = c.nextInt();
		int[] a = new int[100];
		int[] b = new int[100];
		int[] s = new int[100];
		int[] ranks = new int[100];
		c.nextLine();
		for (int i=0;i<n;i++){
			a[i]=c.nextInt();
			b[i]=a[i];//b is a copy of a,cuz a is going to be sorted
			s[i]=i;
		}
		for (int i=0;i<n-1;i++){
			for(int j=i;j<n;j++){
				if (a[i]<a[j]){
					int t=a[i];a[i]=a[j];a[j]=t;
					int t1=s[i];s[i]=s[j];s[j]=t1;
				}
			}
		}
		ranks[s[0]]=1;
		for (int i=1;i<n;i++){
			if (b[s[i]]==b[s[i-1]]){ranks[s[i]]=ranks[s[i-1]];}
			else ranks[s[i]]=i+1;
		}
		int t=1;
		for (int i=0;i<n;i++){
			System.out.print(ranks[i]+ " ");
		}
	}
}


import java.io.*;
import java.util.*;

public class GukiZandContest{

    public static void main(String[] args) {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());

        int[] rate = new int[n];
        int[] ordered_rate = new int[n];

        StringTokenizer st1 = new StringTokenizer(br.readLine());

        for(int i = 0 ; i < n ; i ++){
            rate[i]= Integer.parseInt(st1.nextToken());
            ordered_rate[i] = rate[i];
        }
        Arrays.sort(ordered_rate);

        int c = 1;
        int[] p = new int[2001];
        p[ordered_rate[n-1]] = 1;
        for(int i = n-2 ; i >=0 ; i--){
            c++;
            if(ordered_rate[i] == ordered_rate[i+1]){
                continue;
            }
            p[ordered_rate[i]] = c;
        }
        for(int i =  0 ; i < n ; i++){
            System.out.println(p[rate[i]]);
        }

    }

}


import java.io.*;
import java.util.*;

public class GukiZandContest{

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int n = Integer.parseInt(br.readLine());

        int[] rate = new int[n];
        int[] ordered_rate = new int[n];

        StringTokenizer st1 = new StringTokenizer(br.readLine());

        for(int i = 0 ; i < n ; i ++){
            rate[i]= Integer.parseInt(st1.nextToken());
            ordered_rate[i] = rate[i];
        }
        Arrays.sort(ordered_rate);

        int c = 1;
        int[] p = new int[2001];
        p[ordered_rate[n-1]] = 1;
        for(int i = n-2 ; i >=0 ; i--){
            c++;
            if(ordered_rate[i] == ordered_rate[i+1]){
                continue;
            }
            p[ordered_rate[i]] = c;
        }
        for(int i =  0 ; i < n ; i++){
            System.out.println(p[rate[i]]);
        }

    }

}


import java.util.*;
import java.math.*;
public class recycle {

	public static void main(String[] args) {

		Scanner qwe = new Scanner(System.in);

		int n = qwe.nextInt();
		int[] ans = new int[n];
		rating[] rs = new rating[n];
		for (int i = 0; i < rs.length; i++) {
			rs[i] = new rating(qwe.nextInt(),i);
		}

		Arrays.sort(rs);

		int lastIndex = 0;

		for (int i = 0; i < rs.length; i++) {
			ans[rs[i].i] = lastIndex+1;

			if(i != rs.length-1 && rs[i].r != rs[i+1].r ) lastIndex = i+1;
		}

		for (int i = 0; i < ans.length; i++) {
			System.out.print(ans[i]  + " ");
		}
		System.out.println();

	}

	static class rating implements Comparable<rating>{
		int r, i;

		public rating(int rr, int ii){
			r= rr;
			i =ii;
		}

		@Override
		public int compareTo(rating o) {
			return o.r - r;
		}

	}

}


import java.util.*;

public class A {

	public static void main(String[] args) {
		Scanner qwe = new Scanner(System.in);
		int N = qwe.nextInt();
		int[] ss = new int[N];
		int[] counts = new int[2001];
		for (int i = 0; i < ss.length; i++) {
			ss[i] = qwe.nextInt();

			for(int k =0; k < ss[i]; k++){
				counts[k]++;
			}

		}

		for (int i = 0; i < ss.length; i++) {
			System.out.print((counts[ss[i]]+1)+" ");
		}
		System.out.println();
	}

}


import java.util.*;

public class A {

	public static void main(String[] args) {
		Scanner qwe = new Scanner(System.in);
		int N = qwe.nextInt();
		int[] ss = new int[N];
		int[] counts = new int[N+1];
		for (int i = 0; i < ss.length; i++) {
			ss[i] = qwe.nextInt();

			for(int k =0; k < ss[i]; k++){
				counts[k]++;
			}

		}

		for (int i = 0; i < ss.length; i++) {
			System.out.print((counts[ss[i]]+1)+" ");
		}
		System.out.println();
	}

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.Arrays;

/**
 *
 * @author Code Forces.  Solution by: L.Azuaje.
 *
 * Codeforces: .
 *
 */

public class Main {

	public static void main(String[] args) throws IOException {
		MyScanner scanner = new MyScanner();
		PrintStream out = System.out;

		int len = scanner.nextInt();
        int[] data = scanner.nextIntArray();
        int[] sorted = new int[len];

        System.arraycopy(data, 0, sorted, 0, len);

        Arrays.sort(sorted);

        int index = -1;
        int position = -1;

        for (int i = 0; i < data.length; i++) {
            index = searchIndex(sorted, data[i]);
            position =  len - index;
            out.format("%d ", position);
        }

		scanner.close();
		out.close();
	}

    private static int searchIndex(int[] sorted, int x) {
        int index = -1;

        for (int i = 0; i < sorted.length &&  x >= sorted[i]; i++) {
            index = i;
        }

        return index;
    }
	// -----------MyScanner class for faster input----------
	public static class MyScanner {
		BufferedReader reader;

		public MyScanner() {
			this.reader = new BufferedReader(new InputStreamReader(System.in));
		}

		public void close() throws IOException {
			this.reader.close();
		}

		int nextInt() {
			return Integer.parseInt(this.next());
		}

		long nextLong() {
			return Long.parseLong(this.next());
		}

		double nextDouble() {
			return Double.parseDouble(this.next());
		}

		String next() {
			String str = "";
			try {
				str = this.reader.readLine().trim();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}

		String[] nextStringArray() {
			String[] str = null;
			try {
				str = this.reader.readLine().trim().split(" ");
			} catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}

		int[] nextIntArray() {
			String[] data  = nextStringArray();
			int[] a  = new int[data.length];

			for (int i = 0; i < a.length; i++) {
				a[i] = Integer.parseInt(data[i]);
			}

			return a;
		}

		Integer[] nextIntegerArray() {
			String[] data  = nextStringArray();
			Integer[] a  = new Integer[data.length];

			for (int i = 0; i < a.length; i++) {
				a[i] = Integer.parseInt(data[i]);
			}

			return a;
		}

		long[] nextLongArray() {
			String[] data  = nextStringArray();
			long[] a  = new long[data.length];

			for (int i = 0; i < a.length; i++) {
				a[i] = Long.parseLong(data[i]);
			}

			return a;
		}
	}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.Arrays;

/**
 *
 * @author Code Forces.  Solution by: L.Azuaje.
 *
 * Codeforces: .
 *
 */

public class Main {

	public static void main(String[] args) throws IOException {
		MyScanner scanner = new MyScanner();
		PrintStream out = System.out;

		int len = scanner.nextInt();
        int[] data = scanner.nextIntArray();
        int[] sorted = new int[len];

        System.arraycopy(data, 0, sorted, 0, len);

        Arrays.sort(sorted);

        int index = -1;
        int position = -1;

        for (int i = 0; i < data.length; i++) {
            index = Arrays.binarySearch(sorted, data[i] + 1);
            if (index < 0) {
                position = len - Math.abs(index + 1) + 1;
            } else {
                position = 1 + len - index;
            }
            out.format("%d ", position);
        }

		scanner.close();
		out.close();
	}

	// -----------MyScanner class for faster input----------
	public static class MyScanner {
		BufferedReader reader;

		public MyScanner() {
			this.reader = new BufferedReader(new InputStreamReader(System.in));
		}

		public void close() throws IOException {
			this.reader.close();
		}

		int nextInt() {
			return Integer.parseInt(this.next());
		}

		long nextLong() {
			return Long.parseLong(this.next());
		}

		double nextDouble() {
			return Double.parseDouble(this.next());
		}

		String next() {
			String str = "";
			try {
				str = this.reader.readLine().trim();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}

		String[] nextStringArray() {
			String[] str = null;
			try {
				str = this.reader.readLine().trim().split(" ");
			} catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}

		int[] nextIntArray() {
			String[] data  = nextStringArray();
			int[] a  = new int[data.length];

			for (int i = 0; i < a.length; i++) {
				a[i] = Integer.parseInt(data[i]);
			}

			return a;
		}

		Integer[] nextIntegerArray() {
			String[] data  = nextStringArray();
			Integer[] a  = new Integer[data.length];

			for (int i = 0; i < a.length; i++) {
				a[i] = Integer.parseInt(data[i]);
			}

			return a;
		}

		long[] nextLongArray() {
			String[] data  = nextStringArray();
			long[] a  = new long[data.length];

			for (int i = 0; i < a.length; i++) {
				a[i] = Long.parseLong(data[i]);
			}

			return a;
		}
	}
}


import java.util.*;
import java.util.ArrayList;
import java.util.Collections;

public class solution{
    public static void main(String[] agrs){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] a = new int[n];
        int[] decre_a = new int[n];
        int[] indecre_a = new int[n];
        int[] num = new int[2010];
        for (int i = 0; i < n; i++){
            a[i] = sc.nextInt();
            decre_a[i] = a[i];
        }
        Arrays.sort(decre_a, 0, n);
        for (int i = 0; i < n; i++){
            indecre_a[n - i - 1] = decre_a[i];
        }
        for (int i = 0; i < n; i++){
            if (num[indecre_a[i]] == 0){
                num[indecre_a[i]] = i + 1;
            }
        }
        for (int i = 0; i < n; i++){
            System.out.print(num[a[i]] + " ");
        }
    }

}


import java.util.*;
import java.util.ArrayList;
import java.util.Collections;

public class solution{
    public static void main(String[] agrs){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] a = new int[n];
        int[] decre_a = new int[n];
        int[] indecre_a = new int[n];
        int[] num = new int[2010];
        for (int i = 0; i < n; i++){
            a[i] = sc.nextInt();
            decre_a[i] = a[i];
        }
        Arrays.sort(decre_a, 0, n);
        for (int i = 0; i < n; i++){
            indecre_a[n - i - 1] = decre_a[i];
        }
        for (int i = 0; i < n; i++){
            if (num[indecre_a[i]] == 0){
                num[indecre_a[i]] = i + 1;
            }
        }
        for (int i = 0; i < n; i++){
            System.out.print(num[decre_a[i]] + " ");
        }
    }

}


import java.util.*;
import java.util.ArrayList;
import java.util.Collections;

public class solution{
    public static void main(String[] agrs){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] a = new int[n];
        int[] decre_a = new int[n];
        int[] indecre_a = new int[n];
        int[] num = new int[2010];
        for (int i = 0; i < n; i++){
            a[i] = sc.nextInt();
            decre_a[i] = a[i];
        }
        Arrays.sort(decre_a, 0, n);
        for (int i = 0; i < n; i++){
            indecre_a[n - i - 1] = decre_a[i];
        }
        for (int i = 0; i < n; i++){
            if (num[indecre_a[i]] == 0){
                num[indecre_a[i]] = i + 1;
            }
        }
        for (int i = 0; i < n; i++){
            System.out.print((num[indecre_a[i]]) + ' ');
        }
    }

}


import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Predicate;

public class Task551A {

    public static void main(String... args) throws NumberFormatException,
            IOException {
        Solution.main(System.in, System.out);
    }

    static class Scanner {

        private final BufferedReader br;
        private String[] cache;
        private int cacheIndex;

        Scanner(InputStream is) {
            br = new BufferedReader(new InputStreamReader(is));
            cache = new String[0];
            cacheIndex = 0;
        }

        int nextInt() throws IOException {
            if (cacheIndex >= cache.length) {
                cache = br.readLine().split(" ");
                cacheIndex = 0;
            }
            return Integer.parseInt(cache[cacheIndex++]);
        }

        long nextLong() throws IOException {
            if (cacheIndex >= cache.length) {
                cache = br.readLine().split(" ");
                cacheIndex = 0;
            }
            return Long.parseLong(cache[cacheIndex++]);
        }

        String next() throws IOException {
            if (cacheIndex >= cache.length) {
                cache = br.readLine().split(" ");
                cacheIndex = 0;
            }
            return cache[cacheIndex++];
        }

        void close() throws IOException {
            br.close();
        }

    }

    static class Solution {

        public static void main(InputStream is, OutputStream os)
                throws NumberFormatException, IOException {
            PrintWriter pw = new PrintWriter(os);
            Scanner sc = new Scanner(is);

            int n = sc.nextInt();

            List<Integer> a = new ArrayList<>(2000);

            for(int i = 0 ; i < n ; i++){
                a.add(sc.nextInt());
            }

            for(int ai : a){
                pw.print(a.stream().filter(integer -> integer > ai).count() + 1);
            }

            pw.flush();
            sc.close();
        }
    }

}


import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Predicate;

public class Task551A {

    public static void main(String... args) throws NumberFormatException,
            IOException {
        Solution.main(System.in, System.out);
    }

    static class Scanner {

        private final BufferedReader br;
        private String[] cache;
        private int cacheIndex;

        Scanner(InputStream is) {
            br = new BufferedReader(new InputStreamReader(is));
            cache = new String[0];
            cacheIndex = 0;
        }

        int nextInt() throws IOException {
            if (cacheIndex >= cache.length) {
                cache = br.readLine().split(" ");
                cacheIndex = 0;
            }
            return Integer.parseInt(cache[cacheIndex++]);
        }

        long nextLong() throws IOException {
            if (cacheIndex >= cache.length) {
                cache = br.readLine().split(" ");
                cacheIndex = 0;
            }
            return Long.parseLong(cache[cacheIndex++]);
        }

        String next() throws IOException {
            if (cacheIndex >= cache.length) {
                cache = br.readLine().split(" ");
                cacheIndex = 0;
            }
            return cache[cacheIndex++];
        }

        void close() throws IOException {
            br.close();
        }

    }

    static class Solution {

        public static void main(InputStream is, OutputStream os)
                throws NumberFormatException, IOException {
            PrintWriter pw = new PrintWriter(os);
            Scanner sc = new Scanner(is);

            int n = sc.nextInt();

            List<Integer> a = new ArrayList<>(2000);

            for(int i = 0 ; i < n ; i++){
                a.add(sc.nextInt());
            }

            for(int ai : a){
                pw.print(a.stream().filter(integer -> integer > ai).count() + 1);
                pw.print(" ");
            }

            pw.flush();
            sc.close();
        }
    }

}


package estudiantes;

import java.util.Scanner;
public class Estudiantes {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.nextLine();
        int calificacion[] = new int[n];
        int puesto[]= new int [n];
        for (int i = 0; i < n; i++) {
            calificacion[i] = sc.nextInt();
        }
        int j=calificacion[0],pos=1,con=1;
        for (int i = 0; i < n; i++) {
            if (calificacion[i]>j){
                j=calificacion[i];
            }
        }
        while(j>=0){
            for (int i=0;i<n;i++){
                if (calificacion[i]==j){
                    puesto[i]=pos;
                    con++;
                }
            }
            j--;
            pos=con;
        }
        for (int i = 0; i < n; i++) {
            System.out.println("puesto: "+puesto[i]);
        }
    }
}


package estudiantes;

import java.util.Scanner;
public class Estudiantes {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.nextLine();
        int calificaciones[] = new int[n];
        int puesto[]= new int [n];
        for (int i = 0; i < n; i++) {
            calificaciones[i] = sc.nextInt();
        }
        int j=calificaciones[0],pos=1,con=1;
        for (int i = 0; i < n; i++) {
            if (calificaciones[i]>j){
                j=calificaciones[i];
            }
        }
        while(j>=0){
            for (int i=0;i<n;i++){
                if (calificaciones[i]==j){
                    puesto[i]=pos;
                    con++;
                }
            }
            j--;
            pos=con;
        }
        for (int i = 0; i < n; i++) {
            System.out.print(puesto[i]+" ");
        }
    }
}


import java.util.Scanner;
public class Estudiantes {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.nextLine();
        int calificacion[] = new int[n];
        int puesto[]= new int [n];
        for (int i = 0; i < n; i++) {
            calificacion[i] = sc.nextInt();
        }
        int j=calificacion[0],pos=1,con=1;
        for (int i = 0; i < n; i++) {
            if (calificacion[i]>j){
                j=calificacion[i];
            }
        }
        while(j>=0){
            for (int i=0;i<n;i++){
                if (calificacion[i]==j){
                    puesto[i]=pos;
                    con++;
                }
            }
            j--;
            pos=con;
        }
        for (int i = 0; i < n; i++) {
            System.out.print(puesto[i]+" ");
        }
    }
}


import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class GukiZContest {
  public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    PrintStream out = new PrintStream(System.out);

    int studentSize = in.nextInt();

    List<Integer> studentRates = new ArrayList<>(studentSize);
    List<Integer> ascendOrderRates = new ArrayList<>(studentSize);

    for (int i = 0; i < studentSize; i ++) {
      studentRates.add(in.nextInt());
      ascendOrderRates.add(studentRates.get(i));
    }
    Collections.sort(ascendOrderRates);

    int gukiRate = 1, studentRate = ascendOrderRates.get(studentSize - 1);

    int[] tracks = new int[studentSize + 1];
    for (int i = studentSize - 1; i >= 0; i --) {
      if (i != studentSize - 1 && ascendOrderRates.get(i) != studentRate) {
        gukiRate = studentSize - i;
        studentRate = ascendOrderRates.get(i);
      }
      tracks[studentRate] = gukiRate;
    }

    for (int i = 0; i < studentSize; i ++) {
      out.print(tracks[studentRates.get(i)]);
      out.print(" ");
    }

  }
}


import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

public class GukiZContest {
  public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    PrintStream out = new PrintStream(System.out);

    int studentSize = in.nextInt();

    List<Integer> studentRates = new ArrayList<>(studentSize);
    List<Integer> ascendOrderRates = new ArrayList<>(studentSize);

    for (int i = 0; i < studentSize; i ++) {
      studentRates.add(in.nextInt());
      ascendOrderRates.add(studentRates.get(i));
    }
    Collections.sort(ascendOrderRates);

    int gukiRate = 1, studentRate = ascendOrderRates.get(studentSize - 1);

    int[] tracks = new int[studentSize + 1];
    for (int i = studentSize - 1; i >= 0; i --) {
      if (i != studentSize - 1 && ascendOrderRates.get(i) != studentRate) {
        gukiRate = studentSize - i;
        studentRate = ascendOrderRates.get(i);
      }
      tracks[studentRate] = gukiRate;
    }

    for (int i = 0; i < studentSize; i ++) {
      out.print(tracks[studentRates.get(i)]);
      out.print(" ");
    }

  }
}


import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

public class GukiZContest {
  public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    PrintStream out = new PrintStream(System.out);

    int studentSize = in.nextInt();
    List<Student> studentRates = new ArrayList<>(studentSize);
    List<Student> ascendOrderRates = new ArrayList<>(studentSize);

    for (int i = 0; i < studentSize; i ++) {
      studentRates.add(new Student(i, in.nextInt()));
      ascendOrderRates.add(studentRates.get(i));
    }

    Collections.sort(ascendOrderRates, Comparator.comparingInt(Student::getRate));

    int gukiRate = 1, studentRate = ascendOrderRates.get(studentSize - 1).getRate();
    for (int i = studentSize - 1; i >= 0; i --) {
      if (i != studentSize - 1 && ascendOrderRates.get(i).getRate() != studentRate) {
        gukiRate = studentSize - i;
        studentRate = ascendOrderRates.get(i).getRate();
      }
      ascendOrderRates.get(i).setRate(gukiRate);
    }

    Collections.sort(ascendOrderRates, Comparator.comparingInt(Student::getIndex));

    for (int i = 0; i < studentSize; i ++) {
      out.print(ascendOrderRates.get(i).getRate());
      out.print(" ");
    }

  }

  public static class Student {
    private int index;
    private int rate;

    public Student(int index, int rate) {
      this.index = index;
      this.rate = rate;
    }

    public int getIndex() {
      return index;
    }

    public void setIndex(int index) {
      this.index = index;
    }

    public int getRate() {
      return rate;
    }

    public void setRate(int rate) {
      this.rate = rate;
    }
  }
}


import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

public class GukiZContest {
  public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    PrintStream out = new PrintStream(System.out);

    int studentSize = in.nextInt();
    List<Student> studentRates = new ArrayList<>(studentSize);
    List<Student> ascendOrderRates = new ArrayList<>(studentSize);

    for (int i = 0; i < studentSize; i ++) {
      studentRates.add(new Student(i, in.nextInt()));
      ascendOrderRates.add(studentRates.get(i));
    }

    Collections.sort(ascendOrderRates, Comparator.comparingInt(Student::getRate));

    int gukiRate = 1, studentRate = ascendOrderRates.get(studentSize - 1).getRate();
    for (int i = studentSize - 1; i >= 0; i --) {
      if (i == studentSize - 1 || ascendOrderRates.get(i).getRate() == studentRate) {
        ascendOrderRates.get(i).setRate(gukiRate);
      } else {
        gukiRate = studentSize - i;
        studentRate = ascendOrderRates.get(i).getRate();
        ascendOrderRates.get(i).setRate(gukiRate);
      }
    }
    Collections.sort(ascendOrderRates, Comparator.comparingInt(Student::getIndex));

    for (int i = 0; i < studentSize - 1; i ++) {
      out.print(ascendOrderRates.get(i).getRate());
      out.print(" ");
    }

    out.print(ascendOrderRates.get(studentSize - 1).getRate());

  }

  public static class Student {
    private int index;
    private int rate;

    public Student(int index, int rate) {
      this.index = index;
      this.rate = rate;
    }

    public int getIndex() {
      return index;
    }

    public void setIndex(int index) {
      this.index = index;
    }

    public int getRate() {
      return rate;
    }

    public void setRate(int rate) {
      this.rate = rate;
    }
  }
}


import java.util.Arrays;
import java.util.Scanner;

/**
 * @author anhnguyen
 *
 */
public class Main1 {
	public static void main(String[] args) {
		Scanner console = new Scanner(System.in);
		int numStudent = console.nextInt();
		int[] arr = new int[numStudent];
		for (int i = 0; i < numStudent; i++) {
			arr[i] = console.nextInt();
		}
		solve(arr);
	}

	public static void solve(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			int rank = 1;
			for (int j = 0; j < arr.length; j++) {
				if (arr[i] < arr[j]) {
					rank++;
				}
			}
			System.out.println(rank);
		}
	}

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Collections;

/**
 *
 */

/**
 * @author lanphan
 *
 */
public class Problem551A {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		try {
			BufferedReader bi = new BufferedReader(new InputStreamReader(System.in));

			String strNums[];

			// read first line
			int n = Integer.parseInt(bi.readLine());

			// read second line, also find out max
			Integer a[] = new Integer[n]; // students, must use Integer in order to sort descending
			int max = 0;

			strNums = bi.readLine().split("\\s");
			for (int i=0; i<n; i++) {
				a[i] = Integer.parseInt(strNums[i]);
				if (a[i] > max) {
					max = a[i];
				}
			}

			Integer b[] = Arrays.copyOf(a, a.length);
			Arrays.sort(b, Collections.reverseOrder());

			int rating[] = new int[max+1];
			for (int i=0; i<n; i++) {
				if (rating[b[i]] == 0) {
					rating[b[i]] = i + 1;
				}
			}

			// print result
			StringBuffer result = new StringBuffer();
			for (int i=0; i<n; i++) {
				result.append(rating[a[i]] + " ");
			}
			System.out.println(result.deleteCharAt(result.length()-1).toString());
		} catch (IOException ex) {
			System.out.println(ex);
		}
	}

}


import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner input = new Scanner (System.in);
        int n = input.nextInt();
        int [] arr = new int [n];
        for (int i = 0; i < n; i++)
            arr[i] =  input.nextInt();
        Integer [] sortedArr = new Integer [n];
        for (int j = 0; j < n; j++)
            sortedArr[j] = arr[j];
	//sorted the array in the non-increasing order
        Arrays.sort(sortedArr, Collections.reverseOrder());
	//Number each element of sortedArr in non-decreasing order.
        int [] resultArr = new int [n];
        for (int k = 0; k < n; k++){
            resultArr[k] = k+1;
            if (k < (n-1) && sortedArr[k] == sortedArr[k+1]){
                resultArr[k+1] = k+1;
                k++;
            }
        }
	//match with the given arr (not sorted)
        int [] result = new int [n];
        for (int a = 0; a < n; a++){
           for (int b = 0; b < n; b++){
               if (arr[a] == sortedArr[b]){
                   result[a] = resultArr[b];
                   break;
               }
           }
        }
        for (int c = 0; c < n-1; c++)
            System.out.print(result[c] + " ");
        System.out.print(result[n-1]);
    }

}


import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

public class Main {

	public static final int BY_POSITION = 0;
	public static final int BY_RATE= 1;

	static public class Result {
		public int pos;
		public int rate;
		public int finalRate;
		public Result(int pos, int rate){
			this.pos = pos;
			this.rate=  rate;
		}
	}

	static public class CustomComparator implements Comparator<Result> {
		int type;
		CustomComparator(int type){
			this.type = type;
		}
	    @Override
	    public int compare(Result o1, Result o2) {
	    		if(type == BY_RATE)
	    			return o2.rate - o1.rate;
	    		else
	    			return o1.pos - o2.pos;

	    }
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();

		sc.nextLine();

		ArrayList<Result> array = new ArrayList<>();

		for(int i = 0; i < n; i++) {
			int cur = sc.nextInt();
			array.add(new Result(i, cur));
		}

		//////////START
		Collections.sort(array, new CustomComparator(BY_RATE) );

		int count = 0;
		for(int i = 0; i < n; i++) {

			if(i == 0) {
				array.get(i).finalRate = 1;
			}else{
				if(array.get(i).rate == array.get(i - 1).rate) {
					array.get(i).finalRate = array.get(i - 1).finalRate;
					count++;
				}else {
					array.get(i).finalRate = i + 1;
					count = 0;
				}
			}
		}

		Collections.sort(array, new CustomComparator(BY_POSITION) );

		for(int i = 0; i < n; i++) {
			System.out.print(array.get(i).finalRate + " ");

		}

	}

}


import java.util.Scanner;
import java.util.Arrays;

public class B3 {

	static class pair implements Comparable<pair> {
		public Integer pos;
		public Integer gt;

		public pair(int pos, int gt){
			this.pos = pos;
			this.gt = gt;
		}
		@Override
		public int compareTo(pair X){
			return (this.gt).compareTo(X.gt);
		}

	}

	static pair a[] = new pair[100000];
	static int ans[] = new int[100000];
	static Scanner sc = new Scanner(System.in);
	public static void main(String[] args) {
		int n = sc.nextInt();

		for (int i=0; i<n;i++){
			int x = sc.nextInt();
			a[i] = new pair(i, x);
		}

		Arrays.sort(a,0,n);

		int r = n-1;
		int sl = 0, vt = 0;
		for (int i = n-1; i >= 0; i--){
			if (i == n-1 || a[i].gt != a[i+1].gt){
				vt = vt + sl;
				sl = 1;
			} else
			{
				sl += 1;
			}
			ans[a[i].pos] = vt+1;
		}
		for (int i = 0; i < n; i++)
			System.out.printf("%d ",ans[i]);

	}

}


import java.util.Scanner;
import java.util.Arrays;

public class B3 {

	static class pair implements Comparable<pair> {
		public Integer pos;
		public Integer gt;

		public pair(int pos, int gt){
			this.pos = pos;
			this.gt = gt;
		}
		@Override
		public int compareTo(pair X){
			return (this.gt).compareTo(X.gt);
		}

	}

	static pair a[] = new pair[100000];
	static int ans[] = new int[100000];
	static Scanner sc = new Scanner(System.in);
	public static void main(String[] args) {
		int n = sc.nextInt();

		for (int i=0; i<n;i++){
			int x = sc.nextInt();
			a[i] = new pair(i, x);
		}

		Arrays.sort(a,0,n);

		int r = n-1;
		int sl = 0, vt = 0;
		for (int i = n-1; i >= 0; i--){
			if (i == n-1 || a[i].gt < a[i+1].gt){
				vt = vt + sl;
				sl = 1;
			} else
			{
				sl += 1;
			}
			ans[a[i].pos] = vt+1;
		}
		for (int i = 0; i < n; i++)
			System.out.printf("%d ",ans[i]);

	}

}


import java.util.Scanner;
import java.util.Arrays;

public class B3 {
	static class pair implements Comparable<pair> {
		public Integer pos;
		public Integer gt;
		public pair(int pos, int gt){
			this.pos = pos;
			this.gt = gt;
		}

		public int compareTo(pair X){
			return (this.gt).compareTo(X.gt);
		}
	}
	static Scanner sc = new Scanner(System.in);
	public static void main(String[] args) {
		int n = sc.nextInt();
		pair a[] = new pair[100000];
		int ans[] = new int[100000];
		for (int i=0; i<n;i++){
			int x = sc.nextInt();
			a[i] = new pair(i, x);
		}
		Arrays.sort(a,0,n);
		int r = n-1;
		int sl = 0, vt = 0;
		for (int i = n-1; i >= 0; i--){
			if (i == n-1 || a[i].gt != a[i+1].gt){
				vt = vt + sl;
				sl = 1;
			} else
			{
				sl += 1;
			}
			ans[a[i].pos] = vt+1;
		}
		for (int i = 0; i < n; i++)
			System.out.print(ans[i]+" ");

	}

}


import java.util.Scanner;
import java.util.Arrays;

public class B3 {
	static class pair implements Comparable<pair> {
		public Integer pos;
		public Integer gt;
		public pair(int pos, int gt){
			this.pos = pos;
			this.gt = gt;
		}

		public int compareTo(pair X){
			return (this.gt).compareTo(X.gt);
		}
	}
	static pair a[] = new pair[100000];
	static int ans[] = new int[100000];
	static Scanner sc = new Scanner(System.in);
	public static void main(String[] args) {
		int n = sc.nextInt();

		for (int i=0; i<n;i++){
			int x = sc.nextInt();
			a[i] = new pair(i, x);
		}
		Arrays.sort(a,0,n);
		int r = n-1;
		int sl = 0, vt = 0;
		for (int i = n-1; i >= 0; i--){
			if (i == n-1 || a[i].gt != a[i+1].gt){
				vt = vt + sl;
				sl = 1;
			} else
			{
				sl += 1;
			}
			ans[a[i].pos] = vt+1;
		}
		for (int i = 0; i < n; i++)
			System.out.print(ans[i]+" ");

	}

}


import java.util.Scanner;
import java.util.Arrays;

public class B3 {
	static class pair implements Comparable<pair> {
		public Integer pos;
		public Integer gt;
		public pair(int pos, int gt){
			this.pos = pos;
			this.gt = gt;
		}
		public int compareTo(pair X){
			return (this.gt).compareTo(X.gt);
		}
	}
	static Scanner sc = new Scanner(System.in);
	public static void main(String[] args) {
		int n = sc.nextInt();
		pair a[] = new pair[100000];
		int ans[] = new int[100000];
		for (int i=0; i<n;i++){
			int x = sc.nextInt();
			a[i] = new pair(i, x);
		}
		Arrays.sort(a,0,n);
		int r = n-1;
		int sl = 0;
		for (int i = n-1; i >= 0; i--){
			while (a[r].gt != a[i].gt ) {
				sl++;
				r--;
			}
			ans[a[i].pos] = sl+1;
		}
		for (int i = 0; i < n; i++)
			System.out.print(ans[i]+" ");

	}

}


import java.util.Scanner;
import java.util.ArrayList;
import java.util.Arrays;

public class B3 {
	static class pair implements Comparable<pair> {
		public Integer pos;
		public Integer gt;
		public pair(int pos, int gt){
			this.pos = pos;
			this.gt = gt;
		}
		public int compareTo(pair X){
			return (this.gt).compareTo(X.gt);
		}
	}
	static Scanner sc = new Scanner(System.in);
	public static void main(String[] args) {
		int n = sc.nextInt();
		pair a[] = new pair[100000];
		int ans[] = new int[100000];
		for (int i=0; i<n;i++){
			int x = sc.nextInt();
			a[i] = new pair(i, x);
		}
		Arrays.sort(a,0,n);
		int r = n-1;
		int sl = 0;
		for (int i = n-1; i >= 0; i--){
			while (a[r].gt != a[i].gt) {
				sl++;
				r--;
			}
			ans[a[i].pos] = sl;
		}
		for (int i = 0; i < n; i++)
			System.out.print((ans[i]+1)+" ");

	}

}


import java.util.Scanner;
import java.util.Arrays;
import java.util.Collections;

public class B3 {
	static class pair implements Comparable<pair> {
		public Integer pos;
		public Integer gt;
		public pair(int pos, int gt){
			this.pos = pos;
			this.gt = gt;
		}

		public int compareTo(pair X){
			return (this.gt).compareTo(X.gt);
		}
	}
	static pair a[] = new pair[100000];
	static int ans[] = new int[100000];
	static Scanner sc = new Scanner(System.in);
	public static void main(String[] args) {
		int n = sc.nextInt();

		for (int i=0; i<n;i++){
			int x = sc.nextInt();
			a[i] = new pair(i, x);
		}
		Arrays.sort(a,0,n);
		int r = n-1;
		int sl = 0, vt = 0;
		for (int i = n-1; i >= 0; i--){
			if (i == n-1 || a[i].gt != a[i+1].gt){
				vt = vt + sl;
				sl = 1;
			} else
			{
				sl += 1;
			}
			ans[a[i].pos] = vt+1;
		}
		for (int i = 0; i < n; i++)
			System.out.print(ans[i]+" ");

	}

}


import java.util.Scanner;
import java.util.Arrays;

public class B3 {

	static class pair implements Comparable<pair> {
		public Integer pos;
		public Integer gt;

		public pair(int pos, int gt){
			this.pos = pos;
			this.gt = gt;
		}
		@Override
		public int compareTo(pair X){
			return (this.gt).compareTo(X.gt);
		}

	}

	static pair a[] = new pair[100000];
	static int ans[] = new int[100000];
	static Scanner sc = new Scanner(System.in);
	public static void main(String[] args) {
		int n = sc.nextInt();

		for (int i=0; i<n;i++){
			int x = sc.nextInt();
			a[i] = new pair(i, x);
		}

		Arrays.sort(a,0,n);

		int r = n-1;
		int sl = 0, vt = 0;
		for (int i = n-1; i >= 0; i--){
			if (i == n-1 || (int) a[i].gt != (int) a[i+1].gt){
				vt = vt + sl;
				sl = 1;
			} else
			{
				sl += 1;
			}
			ans[a[i].pos] = vt+1;
		}
		for (int i = 0; i < n; i++)
			System.out.printf("%d ",ans[i]);

	}

}


import java.util.Scanner;
import java.util.Arrays;
import java.util.Collections;

public class B3 {
	static class pair implements Comparable<pair> {
		public Integer pos;
		public Integer gt;

		public pair(int pos, int gt){
			this.pos = pos;
			this.gt = gt;
		}
		@Override
		public int compareTo(pair X){
			return (this.gt).compareTo(X.gt);
		}
	}
	static pair a[] = new pair[100000];
	static int ans[] = new int[100000];
	static Scanner sc = new Scanner(System.in);
	public static void main(String[] args) {
		int n = sc.nextInt();

		for (int i=0; i<n;i++){
			int x = sc.nextInt();
			a[i] = new pair(i, x);
		}
		Arrays.sort(a,0,n);
		int r = n-1;
		int sl = 0, vt = 0;
		for (int i = n-1; i >= 0; i--){
			if (i == n-1 || a[i].gt != a[i+1].gt){
				vt = vt + sl;
				sl = 1;
			} else
			{
				sl += 1;
			}
			ans[a[i].pos] = vt+1;
		}
		for (int i = 0; i < n; i++)
			System.out.print(ans[i]+" ");

	}

}


import java.util.*;
import static java.lang.System.*;

public class A551 {

	public static void main(String[]Kowalski)
	{

		Scanner in=new Scanner(System.in);
		int n=in.nextInt();
		LinkedHashMap<Integer,Integer>scores=new LinkedHashMap<>();
		int[]list=new int[n];
		int count=0;
		while(n-->0)
		{
			int num=in.nextInt();
			list[count++]=num;
		}

		for(int x:list)
		{
			int pos=1;//key is rating of a student
			for(int key:scores.keySet())
			{
				if(key>x)
				{
					pos++;
				}
				else if(key<x)
				{
					scores.put(key,scores.get(key)+1);
				}
			}

			scores.put(x, pos);
		}

		for(int x:list)
			out.print(scores.get(x)+" ");
	}
}


import java.util.*;
import static java.lang.System.*;

public class A551 {

	public static void main(String[]Kowalski)
	{

		Scanner in=new Scanner(System.in);
		int n=in.nextInt();
		LinkedHashMap<Integer,Integer>scores=new LinkedHashMap<>();
		int[]list=new int[n];
		int count=0;
		while(n-->0)
		{
			int num=in.nextInt();
			list[count++]=num;
		}

		for(int x:list)
		{
			int pos=1;

			for(int y:list)
			{
				if(y==x)
					continue;
				if(x<y)
					pos++;
			}

			scores.put(x,pos);

		}

		for(int x:list)
			out.print(scores.get(x)+" ");
	}
}


import java.util.*;
import static java.lang.System.*;

public class A551 {

	public static void main(String[]Kowalski)
	{

		Scanner in=new Scanner(System.in);
		int n=in.nextInt();
		TreeMap<Integer,Integer>scores=new TreeMap<>();
		int[]list=new int[n];
		int count=0;
		while(n-->0)
		{
			int num=in.nextInt();
			list[count++]=num;
		}

		for(int x:list)
		{
			int pos=1;//key is rating of a student
			for(int key:scores.keySet())
			{
				if(key>x)
				{
					pos++;
				}
				else if(key<x)
				{
					scores.put(key,scores.get(key)+1);
				}
			}

			scores.put(x, pos);
		}

		for(int x:list)
			out.print(scores.get(x)+" ");
	}
}


	    /*
	     * Author- Kishan_25
	     * BTech 2nd Year DAIICT
	     */

	    import java.io.*;
	    import java.math.*;
	    import java.util.*;
	    import javax.print.attribute.SetOfIntegerSyntax;

	    public class code {
	    	private static InputStream stream;
	    	private static byte[] buf = new byte[1024];
	    	private static int curChar;
	    	private static int numChars;
	    	private static SpaceCharFilter filter;
	    	private static PrintWriter pw;
	    	private static long count = 0,mod=1000000007;
	    	private static TreeSet<Integer>ts[]=new TreeSet[200000];
	    	private static HashSet hs=new HashSet();

	    	public static void main(String args[]) throws Exception {
	    		InputReader(System.in);
	    		pw = new PrintWriter(System.out);
	    		//ans();
	    		soln();
	    		pw.close();
	    	}

	    	public static long gcd(long x, long y) {
	    		if (x == 0)
	    			return y;
	    		else
	    			return gcd( y % x,x);
	    	}

	    	private static int BinarySearch(int a[], int low, int high, int target) {
	    		if (low > high)
	    			return -1;
	    		int mid = low + (high - low) / 2;
	    		if (a[mid] == target)
	    			return mid;
	    		if (a[mid] > target)
	    			high = mid - 1;
	    		if (a[mid] < target)
	    			low = mid + 1;
	    		return BinarySearch(a, low, high, target);
	    	}

	    	public static String reverseString(String s) {
	    		StringBuilder sb = new StringBuilder(s);
	    		sb.reverse();
	    		return (sb.toString());
	    	}

	    	public static long pow(long n, long p) {
	    		if(p==0)
	    			return 1;
	    		if(p==1)
	    			return n%mod;
	    		if(p%2==0){
	    			long temp=pow(n, p/2);
	    		return (temp*temp)%mod;
	    		}else{
	    			 	long temp=pow(n,p/2);
	    			 	temp=(temp*temp)%mod;
	    			 	return(temp*n)%mod;

	    		}
	    	}

	    	public static int[] radixSort(int[] f) {
	    		int[] to = new int[f.length];
	    		{
	    			int[] b = new int[65537];
	    			for (int i = 0; i < f.length; i++)
	    				b[1 + (f[i] & 0xffff)]++;
	    			for (int i = 1; i <= 65536; i++)
	    				b[i] += b[i - 1];
	    			for (int i = 0; i < f.length; i++)
	    				to[b[f[i] & 0xffff]++] = f[i];
	    			int[] d = f;
	    			f = to;
	    			to = d;
	    		}
	    		{
	    			int[] b = new int[65537];
	    			for (int i = 0; i < f.length; i++)
	    				b[1 + (f[i] >>> 16)]++;
	    			for (int i = 1; i <= 65536; i++)
	    				b[i] += b[i - 1];
	    			for (int i = 0; i < f.length; i++)
	    				to[b[f[i] >>> 16]++] = f[i];
	    			int[] d = f;
	    			f = to;
	    			to = d;
	    		}
	    		return f;
	    	}

	    	public static int nextPowerOf2(final int a) {
	    		int b = 1;
	    		while (b < a) {
	    			b = b << 1;
	    		}
	    		return b;
	    	}

	    	public static boolean PointInTriangle(int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8) {
	    		int s = p2 * p5 - p1 * p6 + (p6 - p2) * p7 + (p1 - p5) * p8;
	    		int t = p1 * p4 - p2 * p3 + (p2 - p4) * p7 + (p3 - p1) * p8;

	    		if ((s < 0) != (t < 0))
	    			return false;

	    		int A = -p4 * p5 + p2 * (p5 - p3) + p1 * (p4 - p6) + p3 * p6;
	    		if (A < 0.0) {
	    			s = -s;
	    			t = -t;
	    			A = -A;
	    		}
	    		return s > 0 && t > 0 && (s + t) <= A;
	    	}

	    	public static float area(int x1, int y1, int x2, int y2, int x3, int y3) {
	    		return (float) Math.abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0);
	    	}

	    	public 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;
	    	}

	    	//merge Sort

	    	static long sort(int a[])
	    	{  int n=a.length;
	    		int b[]=new int[n];
	    		return mergeSort(a,b,0,n-1);}
	    	static long mergeSort(int a[],int b[],long left,long right)
	    	{ long c=0;if(left<right)
	    	 {   long mid=left+(right-left)/2;
	    		 c= mergeSort(a,b,left,mid);
	    		 c+=mergeSort(a,b,mid+1,right);
	    		 c+=merge(a,b,left,mid+1,right); }
	    		return c;	 }
	    	static long merge(int a[],int  b[],long left,long mid,long right)
	    	{long c=0;int i=(int)left;int j=(int)mid; int k=(int)left;
	    	while(i<=(int)mid-1&&j<=(int)right)
	    	{ if(a[i]>a[j]) {b[k++]=a[i++]; }
	    	else	{ b[k++]=a[j++];c+=mid-i;}}
	    	while (i <= (int)mid - 1)   b[k++] = a[i++];
	    	while (j <= (int)right) b[k++] = a[j++];
	    	for (i=(int)left; i <= (int)right; i++)
	    		a[i] = b[i];  return c;  }
	    	public static boolean isSubSequence(String large, String small, int largeLen, int smallLen) {
	    		//base cases
	    		if (largeLen == 0)
	    			return false;
	    		if (smallLen == 0)
	    			return true;
	    		// If last characters of two strings are matching
	    		if (large.charAt(largeLen - 1) == small.charAt(smallLen - 1))
	    			isSubSequence(large, small, largeLen - 1, smallLen - 1);
	    		// If last characters are not matching
	    		return isSubSequence(large, small, largeLen - 1, smallLen);
	    	}

	    	// To Get Input
	    	// Some Buffer Methods

	    	public static void InputReader(InputStream stream1) {
	    		stream = stream1;
	    	}

	    	private static boolean isWhitespace(int c) {
	    		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	    	}

	    	private static boolean isEndOfLine(int c) {
	    		return c == '\n' || c == '\r' || c == -1;
	    	}

	    	private static 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++];
	    	}

	    	private static 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;
	    	}

	    	private static 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;
	    	}

	    	private static String nextToken() {
	    		int c = read();
	    		while (isSpaceChar(c))
	    			c = read();
	    		StringBuilder res = new StringBuilder();
	    		do {
	    			res.appendCodePoint(c);
	    			c = read();
	    		} while (!isSpaceChar(c));
	    		return res.toString();
	    	}

	    	private static String nextLine() {
	    		int c = read();
	    		while (isSpaceChar(c))
	    			c = read();
	    		StringBuilder res = new StringBuilder();
	    		do {
	    			res.appendCodePoint(c);
	    			c = read();
	    		} while (!isEndOfLine(c));
	    		return res.toString();
	    	}

	    	private static int[] nextIntArray(int n) {
	    		int[] arr = new int[n];
	    		for (int i = 0; i < n; i++) {
	    			arr[i] = nextInt();
	    		}
	    		return arr;
	    	}

	    	private static int[][] next2dArray(int n, int m) {
	    		int[][] arr = new int[n][m];
	    		for (int i = 0; i < n; i++) {
	    			for (int j = 0; j < m; j++) {
	    				arr[i][j] = nextInt();
	    			}
	    		}
	    		return arr;
	    	}
	    	private static char[][] nextCharArray(int n,int m){
	    		char [][]c=new char[n][m];
	    		for(int i=0;i<n;i++){
	    			String s=nextLine();
	    			for(int j=0;j<s.length();j++){
	    				c[i][j]=s.charAt(j);
	    			}
	    		}
	    		return c;
	    	}

	    	private static long[] nextLongArray(int n) {
	    		long[] arr = new long[n];
	    		for (int i = 0; i < n; i++) {
	    			arr[i] = nextLong();
	    		}
	    		return arr;
	    	}

	    	private static void pArray(int[] arr) {
	    		for (int i = 0; i < arr.length; i++) {
	    			pw.print(arr[i] + " ");
	    		}
	    		pw.println();
	    		return;
	    	}

	    	private static void pArray(long[] arr) {
	    		for (int i = 0; i < arr.length; i++) {
	    			pw.print(arr[i] + " ");
	    		}
	    		pw.println();
	    		return;
	    	}

	    	private static void pArray(boolean[] arr) {
	    		for (int i = 0; i < arr.length; i++) {
	    			pw.print(arr[i] + " ");
	    		}
	    		pw.println();
	    		return;
	    	}

	    	private static boolean isSpaceChar(int c) {
	    		if (filter != null)
	    			return filter.isSpaceChar(c);
	    		return isWhitespace(c);
	    	}

	    	private interface SpaceCharFilter {
	    		public boolean isSpaceChar(int ch);
	    	}

	    	//----------------------------------------My Code------------------------------------------------//

	    	private static void soln() {

	    		Scanner in = new Scanner(System.in);

	    		int n = in.nextInt();
	    		in.nextLine();
	    		ArrayList<node> list = new ArrayList<node>();

	    		for(int i = 0;i<n;i++){
	    			node m = new node();
	    			m.p = i;
	    			m.v = in.nextInt();

	    			list.add(m);
	    		}

	    		Collections.sort(list,new MyComp());
	    		int arr[] = new int[n];
	    		int temp[] = new int[2005];
	    		for(int i = 0;i<n-1;i++){
	    			int k = 0;

	    			for(int j = i+1;j<n;j++){
	    				if(list.get(j).v > list.get(i).v){
	    					break;
	    				}else{
	    					k++;
	    				}
	    			}
	    			if(temp[list.get(i).p] == 0)
	    			arr[list.get(i).p] = n-i-k;

	    		}

	    	arr[list.get(n-1).p] = 1;

	    		for(int i = 0;i<n;i++){
	    			if(arr[i] != 0)
	    			System.out.print(arr[i] + " ");
	    		}

	    	}//-----------------------------------------The End--------------------------------------------------------------------------//

	 }
	    class node{
	    	int p;
	    	int v;
	    }

		class Pair implements Comparable<Pair>{
		    long id;
			long w;
			long h;
			Pair(long id,long w,long h){
				this.id=id;
				this.w=w;
				this.h=h;
			}
			@Override
			public int compareTo(Pair o) {
				// TODO Auto-generated method stub
			//	Sort in increasing order

				if(w>o.w)
					return 1;
				else if(w<o.w)
					return -1;
				else{
					if(h>o.h){
						return 1;
					}else if(o.h>h)
						return -1;
					else return 0;
				}

			}

		}
	        class Graph{
	        	private static int V,level[][],count=-1,lev_dfs[],degree=0,no_vert_conn_comp=0;
	        	private Stack <Integer>st=new Stack();
	        	private static LinkedList<Integer > adj[];
	        	private boolean[][] Visite;
	        	private static boolean [] Visited;
	        	private static TreeSet<Integer> ts=new TreeSet();
	    Graph(int V){
	    V++;
	    this.V=(V);
	    adj=new LinkedList[V];
	    Visite=new boolean[100][100];

 	   Visited=new boolean[V];
	    level=new int[100][100];
	   lev_dfs=new int[V];
	   for(int i=0;i<V;i++)
		   adj[i]=new LinkedList<Integer>();
	    }

	    void addEdge(int v,int w){

	    	if(adj[v]==null){
	    		adj[v]=new LinkedList();
	    	}
	    	if(adj[w] == null){
	    		adj[w] = new LinkedList();
	    	}
	    	adj[v].add(w);

	    }

	    public static int conCop(int startVert){
	    	Visited=new boolean[V];
	    	int totalcon = 1;
	    	Queue<Integer> q=new LinkedList<Integer>();
	    	q.add(startVert);
	    	Visited[startVert] = true;

	    	while(!q.isEmpty()){
	    		int top=q.poll();

	    		Iterator<Integer> i= adj[top].listIterator();
	    		while(i.hasNext()){
	    			int n=i.next();
	    			if(!Visited[n]){
	    				q.add(n);
	    				Visited[n]=true;
	    				totalcon++;
	    			}
	    		}
	    	}
	    	q.clear();
	    	return totalcon;
	    }

	    public static int NoConEdge(int startVert){
	    	Visited=new boolean[V];

	    	Queue<Integer> q=new LinkedList<Integer>();
	    	q.add(startVert);
	    	Visited[startVert] = true;
	    	long ed = adj[startVert].size();
	    	while(!q.isEmpty()){
	    		int top=q.poll();

	    		Iterator<Integer> i= adj[top].listIterator();
	    		while(i.hasNext()){
	    			int n=i.next();
	    			if(!Visited[n]){
	    				q.add(n);
	    				Visited[n]=true;
	    				ed+= adj[n].size();
	    			}
	    		}
	    	}
	    	q.clear();
	    	return (int)ed/2;
	    }

	    public static int BFS2(int startVert){
	    	Visited=new boolean[V];
	    	for(int i=0;i<V;i++){
	    		lev_dfs[i]=-1;
	    	}
	    	Queue<Integer> q=new LinkedList<Integer>();
	    	q.add(startVert);

	    	lev_dfs[startVert]=0;
	    	while(!q.isEmpty()){
	    		int top=q.poll();

	    		Iterator<Integer> i= adj[top].listIterator();
	    		while(i.hasNext()){
	    			int n=i.next();
	    			if(!Visited[n]){
	    				q.add(n);
	    				Visited[n]=true;
	    				lev_dfs[n]=lev_dfs[top]+1;
	    				//System.out.println(top + " " + n);
	    			}
	    		}
	    	}
	    	q.clear();

	    	int mx = 0;
	    	for(int i = 0;i<V;i++){
	    		mx = Math.max(mx, lev_dfs[i]);
	    	}
	    	return mx;
	    }
	    public int getEd(){
	    	return degree/2;
	    }
	    public void get(int from,int to){
	    	int h=lev_dfs[from]-lev_dfs[to];
	    	if(h<=0){
	    		System.out.println(-1);
	    	}else{
	    		System.out.println(h-1);
	    	}
	    }
	    private static boolean check(int x,int y,char c[][]){

			if((x>=0 && y>=0) && (x<c.length && y<c[0].length) && c[x][y]!='#'){

				return true;
			}
			return false;
		}
	    public int BFS(int x,int y,int k,char[][] c)
	    {
	    	 LinkedList<Pair> queue = new LinkedList<Pair>();
	        //Visited[s]=true;
	   //     queue.add(new Pair(x,y));
	       int count=0;
	   level[x][y]=-1;
	   c[x][y]='M';
	        while (!queue.isEmpty())
	        {
	            Pair temp = queue.poll();
	            //x=temp.idx;
	            //y=temp.val;

	            c[x][y]='M';
	      // System.out.println(x+" "+y+" ---"+count);
	         count++;
	     	if(count==k)
	         {
	         	for(int i=0;i<c.length;i++){
	         		for(int j=0;j<c[0].length;j++){
	         			if(c[i][j]=='M'){
	         				System.out.print(".");
	         			}
	         			else if(c[i][j]=='.')
	         				System.out.print("X");
	         			else
	         				System.out.print(c[i][j]);
	         		}
	         		System.out.println();
	         	}
	         System.exit(0);
	         }

	         // System.out.println(x+" "+y);
	           // V--;

	        }
	        return V;
	    }

	    private void getAns(int startVertex){
	    	for(int i=0;i<adj[startVertex].size();i++){
	    		int ch=adj[startVertex].get(i);
	    		for(int j=0;j<adj[ch].size();j++){
	    			int ch2=adj[ch].get(j);
	    			if(adj[ch2].contains(startVertex)){
	    				System.out.println(startVertex+" "+ch+" "+ch2);
	    				System.exit(0);
	    			}
	    		}
	    	}
	    }

	     public long dfs(int startVertex){
	    //	 getAns(startVertex);

	    	 if(!Visited[startVertex])  {

	   return dfsUtil(startVertex,Visited);
	    	//return getAns();
	    	}

	    return 0;
	    	}
	 private long dfsUtil(int startVertex, boolean[] Visited) {//0-Blue 1-Pink

		 int c=1;
		 long cout=0;
	      degree=0;
	    	Visited[startVertex]=true;
	    	lev_dfs[startVertex]=1;
	      st.push(startVertex);
	    while(!st.isEmpty()){

	    	int top=st.pop();
	    int child=adj[top].size();
	    if(top!=startVertex)
	    	child--;

	    	ts.add(top);
	    	Iterator<Integer> i=adj[top].listIterator();
	     degree+=adj[top].size();

	    while(i.hasNext()){

	    	int n=i.next();
	     if( !Visited[n]){
	    				Visited[n]=true;
	    					st.push(n);
	    					if(adj[n].size()-1>child)
	    					cout++;
	    				c++;
	    					lev_dfs[n]=lev_dfs[top]+1;

	    		 }
	         }
	 }
	    return cout;

	  //  System.out.println("NO");
	   // return c;

	    }

	        }

	    class Dsu{
	    	private int rank[], parent[] ,n;

	    	Dsu(int size){
	    		this.n=size+1;
	    		rank=new int[n];
	    		parent=new int[n];
	    	makeSet();
	    	}

	    	void makeSet(){
	    		for(int i=0;i<n;i++){
	    			parent[i]=i;
	    		}
	    	}

	    	int find(int x){
	    		if(parent[x]!=x){

	    			parent[x]=find(parent[x]);
	    		}
	    		return parent[x];
	    	}

	    	void union(int x,int y){
	    		int xRoot=find(x);
	    		int yRoot=find(y);

	    		if(xRoot==yRoot)
	    			return;
	    		if(rank[xRoot]<rank[yRoot]){
	    		parent[xRoot]=yRoot;
	    		}else if(rank[yRoot]<rank[xRoot]){
	    			parent[yRoot]=xRoot;
	    		}else{
	    			parent[yRoot]=xRoot;
	    			rank[xRoot]++;
	    		}

	    	}

	    }
	    class Heap{

	    	public static void build_max_heap(long []a,int size){

	    		for(int i=size/2;i>0;i--){
	    			max_heapify(a, i,size);
	    		}

	    			}
	    	private static void max_heapify(long[] a,int i,int size){
	    		int left_child=2*i;
	    		int right_child=(2*i+1);
	    		int largest=0;

	    		if(left_child<size && a[left_child]>a[i]){
	    			largest=left_child;
	    		}else{
	    			largest=i;
	    		}

	    		if(right_child<size && a[right_child]>a[largest]){
	    			largest=right_child;
	    		}
	    		if(largest!=i){
	    			long temp=a[largest];
	    			a[largest]=a[i];
	    			a[i]=temp;
	    			max_heapify(a, largest,size);
	    		}
	    	}
	    	private static void min_heapify(int[] a,int i){
	    		int left_child=2*i;
	    		int right_child=(2*i+1);
	    		int largest=0;

	    		if(left_child<a.length && a[left_child]<a[i]){
	    			largest=left_child;
	    		}else{
	    			largest=i;
	    		}

	    		if(right_child<a.length && a[right_child]<a[largest]){
	    			largest=right_child;
	    		}
	    		if(largest!=i){
	    			int temp=a[largest];
	    			a[largest]=a[i];
	    			a[i]=temp;
	    			min_heapify(a, largest);
	    		}
	    	}
	    	public static void extract_max(int size,long a[]){
	    		if(a.length>1){
	    			long max=a[1];
	    			a[1]=a[a.length-1];
	    			size--;
	    			max_heapify(a, 1,a.length-1);
	    		}
	    	}
	    }

	    class MyComp implements Comparator<node>{

			@Override
			public int compare(node o1, node o2) {
				if(o1.v>o2.v){
					return 1;
				}else if(o1.v<o2.v){
					return -1;
				}
				return 0;

			}
	    }


	    /*
	     * Author- Kishan_25
	     * BTech 2nd Year DAIICT
	     */

	    import java.io.*;
	    import java.math.*;
	    import java.util.*;
	    import javax.print.attribute.SetOfIntegerSyntax;

	    public class code {
	    	private static InputStream stream;
	    	private static byte[] buf = new byte[1024];
	    	private static int curChar;
	    	private static int numChars;
	    	private static SpaceCharFilter filter;
	    	private static PrintWriter pw;
	    	private static long count = 0,mod=1000000007;
	    	private static TreeSet<Integer>ts[]=new TreeSet[200000];
	    	private static HashSet hs=new HashSet();

	    	public static void main(String args[]) throws Exception {
	    		InputReader(System.in);
	    		pw = new PrintWriter(System.out);
	    		//ans();
	    		soln();
	    		pw.close();
	    	}

	    	public static long gcd(long x, long y) {
	    		if (x == 0)
	    			return y;
	    		else
	    			return gcd( y % x,x);
	    	}

	    	private static int BinarySearch(int a[], int low, int high, int target) {
	    		if (low > high)
	    			return -1;
	    		int mid = low + (high - low) / 2;
	    		if (a[mid] == target)
	    			return mid;
	    		if (a[mid] > target)
	    			high = mid - 1;
	    		if (a[mid] < target)
	    			low = mid + 1;
	    		return BinarySearch(a, low, high, target);
	    	}

	    	public static String reverseString(String s) {
	    		StringBuilder sb = new StringBuilder(s);
	    		sb.reverse();
	    		return (sb.toString());
	    	}

	    	public static long pow(long n, long p) {
	    		if(p==0)
	    			return 1;
	    		if(p==1)
	    			return n%mod;
	    		if(p%2==0){
	    			long temp=pow(n, p/2);
	    		return (temp*temp)%mod;
	    		}else{
	    			 	long temp=pow(n,p/2);
	    			 	temp=(temp*temp)%mod;
	    			 	return(temp*n)%mod;

	    		}
	    	}

	    	public static int[] radixSort(int[] f) {
	    		int[] to = new int[f.length];
	    		{
	    			int[] b = new int[65537];
	    			for (int i = 0; i < f.length; i++)
	    				b[1 + (f[i] & 0xffff)]++;
	    			for (int i = 1; i <= 65536; i++)
	    				b[i] += b[i - 1];
	    			for (int i = 0; i < f.length; i++)
	    				to[b[f[i] & 0xffff]++] = f[i];
	    			int[] d = f;
	    			f = to;
	    			to = d;
	    		}
	    		{
	    			int[] b = new int[65537];
	    			for (int i = 0; i < f.length; i++)
	    				b[1 + (f[i] >>> 16)]++;
	    			for (int i = 1; i <= 65536; i++)
	    				b[i] += b[i - 1];
	    			for (int i = 0; i < f.length; i++)
	    				to[b[f[i] >>> 16]++] = f[i];
	    			int[] d = f;
	    			f = to;
	    			to = d;
	    		}
	    		return f;
	    	}

	    	public static int nextPowerOf2(final int a) {
	    		int b = 1;
	    		while (b < a) {
	    			b = b << 1;
	    		}
	    		return b;
	    	}

	    	public static boolean PointInTriangle(int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8) {
	    		int s = p2 * p5 - p1 * p6 + (p6 - p2) * p7 + (p1 - p5) * p8;
	    		int t = p1 * p4 - p2 * p3 + (p2 - p4) * p7 + (p3 - p1) * p8;

	    		if ((s < 0) != (t < 0))
	    			return false;

	    		int A = -p4 * p5 + p2 * (p5 - p3) + p1 * (p4 - p6) + p3 * p6;
	    		if (A < 0.0) {
	    			s = -s;
	    			t = -t;
	    			A = -A;
	    		}
	    		return s > 0 && t > 0 && (s + t) <= A;
	    	}

	    	public static float area(int x1, int y1, int x2, int y2, int x3, int y3) {
	    		return (float) Math.abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0);
	    	}

	    	public 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;
	    	}

	    	//merge Sort

	    	static long sort(int a[])
	    	{  int n=a.length;
	    		int b[]=new int[n];
	    		return mergeSort(a,b,0,n-1);}
	    	static long mergeSort(int a[],int b[],long left,long right)
	    	{ long c=0;if(left<right)
	    	 {   long mid=left+(right-left)/2;
	    		 c= mergeSort(a,b,left,mid);
	    		 c+=mergeSort(a,b,mid+1,right);
	    		 c+=merge(a,b,left,mid+1,right); }
	    		return c;	 }
	    	static long merge(int a[],int  b[],long left,long mid,long right)
	    	{long c=0;int i=(int)left;int j=(int)mid; int k=(int)left;
	    	while(i<=(int)mid-1&&j<=(int)right)
	    	{ if(a[i]>a[j]) {b[k++]=a[i++]; }
	    	else	{ b[k++]=a[j++];c+=mid-i;}}
	    	while (i <= (int)mid - 1)   b[k++] = a[i++];
	    	while (j <= (int)right) b[k++] = a[j++];
	    	for (i=(int)left; i <= (int)right; i++)
	    		a[i] = b[i];  return c;  }
	    	public static boolean isSubSequence(String large, String small, int largeLen, int smallLen) {
	    		//base cases
	    		if (largeLen == 0)
	    			return false;
	    		if (smallLen == 0)
	    			return true;
	    		// If last characters of two strings are matching
	    		if (large.charAt(largeLen - 1) == small.charAt(smallLen - 1))
	    			isSubSequence(large, small, largeLen - 1, smallLen - 1);
	    		// If last characters are not matching
	    		return isSubSequence(large, small, largeLen - 1, smallLen);
	    	}

	    	// To Get Input
	    	// Some Buffer Methods

	    	public static void InputReader(InputStream stream1) {
	    		stream = stream1;
	    	}

	    	private static boolean isWhitespace(int c) {
	    		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	    	}

	    	private static boolean isEndOfLine(int c) {
	    		return c == '\n' || c == '\r' || c == -1;
	    	}

	    	private static 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++];
	    	}

	    	private static 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;
	    	}

	    	private static 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;
	    	}

	    	private static String nextToken() {
	    		int c = read();
	    		while (isSpaceChar(c))
	    			c = read();
	    		StringBuilder res = new StringBuilder();
	    		do {
	    			res.appendCodePoint(c);
	    			c = read();
	    		} while (!isSpaceChar(c));
	    		return res.toString();
	    	}

	    	private static String nextLine() {
	    		int c = read();
	    		while (isSpaceChar(c))
	    			c = read();
	    		StringBuilder res = new StringBuilder();
	    		do {
	    			res.appendCodePoint(c);
	    			c = read();
	    		} while (!isEndOfLine(c));
	    		return res.toString();
	    	}

	    	private static int[] nextIntArray(int n) {
	    		int[] arr = new int[n];
	    		for (int i = 0; i < n; i++) {
	    			arr[i] = nextInt();
	    		}
	    		return arr;
	    	}

	    	private static int[][] next2dArray(int n, int m) {
	    		int[][] arr = new int[n][m];
	    		for (int i = 0; i < n; i++) {
	    			for (int j = 0; j < m; j++) {
	    				arr[i][j] = nextInt();
	    			}
	    		}
	    		return arr;
	    	}
	    	private static char[][] nextCharArray(int n,int m){
	    		char [][]c=new char[n][m];
	    		for(int i=0;i<n;i++){
	    			String s=nextLine();
	    			for(int j=0;j<s.length();j++){
	    				c[i][j]=s.charAt(j);
	    			}
	    		}
	    		return c;
	    	}

	    	private static long[] nextLongArray(int n) {
	    		long[] arr = new long[n];
	    		for (int i = 0; i < n; i++) {
	    			arr[i] = nextLong();
	    		}
	    		return arr;
	    	}

	    	private static void pArray(int[] arr) {
	    		for (int i = 0; i < arr.length; i++) {
	    			pw.print(arr[i] + " ");
	    		}
	    		pw.println();
	    		return;
	    	}

	    	private static void pArray(long[] arr) {
	    		for (int i = 0; i < arr.length; i++) {
	    			pw.print(arr[i] + " ");
	    		}
	    		pw.println();
	    		return;
	    	}

	    	private static void pArray(boolean[] arr) {
	    		for (int i = 0; i < arr.length; i++) {
	    			pw.print(arr[i] + " ");
	    		}
	    		pw.println();
	    		return;
	    	}

	    	private static boolean isSpaceChar(int c) {
	    		if (filter != null)
	    			return filter.isSpaceChar(c);
	    		return isWhitespace(c);
	    	}

	    	private interface SpaceCharFilter {
	    		public boolean isSpaceChar(int ch);
	    	}

	    	//----------------------------------------My Code------------------------------------------------//

	    	private static void soln() {

	    		Scanner in = new Scanner(System.in);

	    		int n = in.nextInt();
	    		in.nextLine();
	    		ArrayList<node> list = new ArrayList<node>();

	    		for(int i = 0;i<n;i++){
	    			node m = new node();
	    			m.p = i;
	    			m.v = in.nextInt();

	    			list.add(m);
	    		}

	    		Collections.sort(list,new MyComp());
	    		int arr[] = new int[n];
	    		int temp[] = new int[2005];
	    		for(int i = 0;i<n-1;i++){
	    			int k = 0;

	    			for(int j = i+1;j<n;j++){
	    				if(list.get(j).v > list.get(i).v){
	    					break;
	    				}else{
	    					k++;
	    				}
	    			}
	    			if(temp[list.get(i).p] == 0)
	    			arr[list.get(i).p] = n-i-k;

	    		}

	    		for(int i = 0;i<n;i++){
	    			if(arr[i] != 0)
	    			System.out.print(arr[i] + " ");
	    		}
	    		System.out.println(1);
	    	}//-----------------------------------------The End--------------------------------------------------------------------------//

	 }
	    class node{
	    	int p;
	    	int v;
	    }

		class Pair implements Comparable<Pair>{
		    long id;
			long w;
			long h;
			Pair(long id,long w,long h){
				this.id=id;
				this.w=w;
				this.h=h;
			}
			@Override
			public int compareTo(Pair o) {
				// TODO Auto-generated method stub
			//	Sort in increasing order

				if(w>o.w)
					return 1;
				else if(w<o.w)
					return -1;
				else{
					if(h>o.h){
						return 1;
					}else if(o.h>h)
						return -1;
					else return 0;
				}

			}

		}
	        class Graph{
	        	private static int V,level[][],count=-1,lev_dfs[],degree=0,no_vert_conn_comp=0;
	        	private Stack <Integer>st=new Stack();
	        	private static LinkedList<Integer > adj[];
	        	private boolean[][] Visite;
	        	private static boolean [] Visited;
	        	private static TreeSet<Integer> ts=new TreeSet();
	    Graph(int V){
	    V++;
	    this.V=(V);
	    adj=new LinkedList[V];
	    Visite=new boolean[100][100];

 	   Visited=new boolean[V];
	    level=new int[100][100];
	   lev_dfs=new int[V];
	   for(int i=0;i<V;i++)
		   adj[i]=new LinkedList<Integer>();
	    }

	    void addEdge(int v,int w){

	    	if(adj[v]==null){
	    		adj[v]=new LinkedList();
	    	}
	    	if(adj[w] == null){
	    		adj[w] = new LinkedList();
	    	}
	    	adj[v].add(w);

	    }

	    public static int conCop(int startVert){
	    	Visited=new boolean[V];
	    	int totalcon = 1;
	    	Queue<Integer> q=new LinkedList<Integer>();
	    	q.add(startVert);
	    	Visited[startVert] = true;

	    	while(!q.isEmpty()){
	    		int top=q.poll();

	    		Iterator<Integer> i= adj[top].listIterator();
	    		while(i.hasNext()){
	    			int n=i.next();
	    			if(!Visited[n]){
	    				q.add(n);
	    				Visited[n]=true;
	    				totalcon++;
	    			}
	    		}
	    	}
	    	q.clear();
	    	return totalcon;
	    }

	    public static int NoConEdge(int startVert){
	    	Visited=new boolean[V];

	    	Queue<Integer> q=new LinkedList<Integer>();
	    	q.add(startVert);
	    	Visited[startVert] = true;
	    	long ed = adj[startVert].size();
	    	while(!q.isEmpty()){
	    		int top=q.poll();

	    		Iterator<Integer> i= adj[top].listIterator();
	    		while(i.hasNext()){
	    			int n=i.next();
	    			if(!Visited[n]){
	    				q.add(n);
	    				Visited[n]=true;
	    				ed+= adj[n].size();
	    			}
	    		}
	    	}
	    	q.clear();
	    	return (int)ed/2;
	    }

	    public static int BFS2(int startVert){
	    	Visited=new boolean[V];
	    	for(int i=0;i<V;i++){
	    		lev_dfs[i]=-1;
	    	}
	    	Queue<Integer> q=new LinkedList<Integer>();
	    	q.add(startVert);

	    	lev_dfs[startVert]=0;
	    	while(!q.isEmpty()){
	    		int top=q.poll();

	    		Iterator<Integer> i= adj[top].listIterator();
	    		while(i.hasNext()){
	    			int n=i.next();
	    			if(!Visited[n]){
	    				q.add(n);
	    				Visited[n]=true;
	    				lev_dfs[n]=lev_dfs[top]+1;
	    				//System.out.println(top + " " + n);
	    			}
	    		}
	    	}
	    	q.clear();

	    	int mx = 0;
	    	for(int i = 0;i<V;i++){
	    		mx = Math.max(mx, lev_dfs[i]);
	    	}
	    	return mx;
	    }
	    public int getEd(){
	    	return degree/2;
	    }
	    public void get(int from,int to){
	    	int h=lev_dfs[from]-lev_dfs[to];
	    	if(h<=0){
	    		System.out.println(-1);
	    	}else{
	    		System.out.println(h-1);
	    	}
	    }
	    private static boolean check(int x,int y,char c[][]){

			if((x>=0 && y>=0) && (x<c.length && y<c[0].length) && c[x][y]!='#'){

				return true;
			}
			return false;
		}
	    public int BFS(int x,int y,int k,char[][] c)
	    {
	    	 LinkedList<Pair> queue = new LinkedList<Pair>();
	        //Visited[s]=true;
	   //     queue.add(new Pair(x,y));
	       int count=0;
	   level[x][y]=-1;
	   c[x][y]='M';
	        while (!queue.isEmpty())
	        {
	            Pair temp = queue.poll();
	            //x=temp.idx;
	            //y=temp.val;

	            c[x][y]='M';
	      // System.out.println(x+" "+y+" ---"+count);
	         count++;
	     	if(count==k)
	         {
	         	for(int i=0;i<c.length;i++){
	         		for(int j=0;j<c[0].length;j++){
	         			if(c[i][j]=='M'){
	         				System.out.print(".");
	         			}
	         			else if(c[i][j]=='.')
	         				System.out.print("X");
	         			else
	         				System.out.print(c[i][j]);
	         		}
	         		System.out.println();
	         	}
	         System.exit(0);
	         }

	         // System.out.println(x+" "+y);
	           // V--;

	        }
	        return V;
	    }

	    private void getAns(int startVertex){
	    	for(int i=0;i<adj[startVertex].size();i++){
	    		int ch=adj[startVertex].get(i);
	    		for(int j=0;j<adj[ch].size();j++){
	    			int ch2=adj[ch].get(j);
	    			if(adj[ch2].contains(startVertex)){
	    				System.out.println(startVertex+" "+ch+" "+ch2);
	    				System.exit(0);
	    			}
	    		}
	    	}
	    }

	     public long dfs(int startVertex){
	    //	 getAns(startVertex);

	    	 if(!Visited[startVertex])  {

	   return dfsUtil(startVertex,Visited);
	    	//return getAns();
	    	}

	    return 0;
	    	}
	 private long dfsUtil(int startVertex, boolean[] Visited) {//0-Blue 1-Pink

		 int c=1;
		 long cout=0;
	      degree=0;
	    	Visited[startVertex]=true;
	    	lev_dfs[startVertex]=1;
	      st.push(startVertex);
	    while(!st.isEmpty()){

	    	int top=st.pop();
	    int child=adj[top].size();
	    if(top!=startVertex)
	    	child--;

	    	ts.add(top);
	    	Iterator<Integer> i=adj[top].listIterator();
	     degree+=adj[top].size();

	    while(i.hasNext()){

	    	int n=i.next();
	     if( !Visited[n]){
	    				Visited[n]=true;
	    					st.push(n);
	    					if(adj[n].size()-1>child)
	    					cout++;
	    				c++;
	    					lev_dfs[n]=lev_dfs[top]+1;

	    		 }
	         }
	 }
	    return cout;

	  //  System.out.println("NO");
	   // return c;

	    }

	        }

	    class Dsu{
	    	private int rank[], parent[] ,n;

	    	Dsu(int size){
	    		this.n=size+1;
	    		rank=new int[n];
	    		parent=new int[n];
	    	makeSet();
	    	}

	    	void makeSet(){
	    		for(int i=0;i<n;i++){
	    			parent[i]=i;
	    		}
	    	}

	    	int find(int x){
	    		if(parent[x]!=x){

	    			parent[x]=find(parent[x]);
	    		}
	    		return parent[x];
	    	}

	    	void union(int x,int y){
	    		int xRoot=find(x);
	    		int yRoot=find(y);

	    		if(xRoot==yRoot)
	    			return;
	    		if(rank[xRoot]<rank[yRoot]){
	    		parent[xRoot]=yRoot;
	    		}else if(rank[yRoot]<rank[xRoot]){
	    			parent[yRoot]=xRoot;
	    		}else{
	    			parent[yRoot]=xRoot;
	    			rank[xRoot]++;
	    		}

	    	}

	    }
	    class Heap{

	    	public static void build_max_heap(long []a,int size){

	    		for(int i=size/2;i>0;i--){
	    			max_heapify(a, i,size);
	    		}

	    			}
	    	private static void max_heapify(long[] a,int i,int size){
	    		int left_child=2*i;
	    		int right_child=(2*i+1);
	    		int largest=0;

	    		if(left_child<size && a[left_child]>a[i]){
	    			largest=left_child;
	    		}else{
	    			largest=i;
	    		}

	    		if(right_child<size && a[right_child]>a[largest]){
	    			largest=right_child;
	    		}
	    		if(largest!=i){
	    			long temp=a[largest];
	    			a[largest]=a[i];
	    			a[i]=temp;
	    			max_heapify(a, largest,size);
	    		}
	    	}
	    	private static void min_heapify(int[] a,int i){
	    		int left_child=2*i;
	    		int right_child=(2*i+1);
	    		int largest=0;

	    		if(left_child<a.length && a[left_child]<a[i]){
	    			largest=left_child;
	    		}else{
	    			largest=i;
	    		}

	    		if(right_child<a.length && a[right_child]<a[largest]){
	    			largest=right_child;
	    		}
	    		if(largest!=i){
	    			int temp=a[largest];
	    			a[largest]=a[i];
	    			a[i]=temp;
	    			min_heapify(a, largest);
	    		}
	    	}
	    	public static void extract_max(int size,long a[]){
	    		if(a.length>1){
	    			long max=a[1];
	    			a[1]=a[a.length-1];
	    			size--;
	    			max_heapify(a, 1,a.length-1);
	    		}
	    	}
	    }

	    class MyComp implements Comparator<node>{

			@Override
			public int compare(node o1, node o2) {
				if(o1.v>o2.v){
					return 1;
				}else if(o1.v<o2.v){
					return -1;
				}
				return 0;

			}
	    }


// https://codeforces.com/problemset/problem/551/A

import java.util.Scanner;

public class Solution {

	public static void main(String[] args) {
		Scanner read = new Scanner(System.in);

		int n = read.nextInt();

		int[] a = new int[n];
		for (int i = 0; i < n; ++i) {
			a[i] = read.nextInt();
		}

		for (int i = 0; i < n; ++i) {
			int rating = 1;
			for (int j = 0; j < n; ++j) {
				if (a[j] > a[i]) {
					rating++;
				}
			}
			System.out.print(rating + " ");
		}

		// Close scanner
		read.close();
	}

}


// http://codeforces.com/problemset/problem/551/A

import java.util.Scanner;

public class Solution {

	public static void main(String[] args) {
		Scanner read = new Scanner(System.in);

		int n = read.nextInt();

		int[] arr = new int[n];
		for (int i = 0; i < n; ++i) {
			arr[i] = read.nextInt();
		}

		for (int i = 0; i < n; ++i) {
			int position = 1;
			for (int j = 0; j < n; ++j) {
				if (arr[j] > arr[i]) {
					position++;
				}
			}
			System.out.print(position + " ");
		}

		System.out.println();

		// Close scanner
		read.close();
	}

}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author tarek
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        AGukiZAndContest solver = new AGukiZAndContest();
        solver.solve(1, in, out);
        out.close();
    }

    static class AGukiZAndContest {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.nextInt();
            int[] a = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = in.nextInt();
            }
            int count = 0;
            for (int i = 0; i < a.length; i++) {
                for (int j = 0; j < a.length; ++j) {
                    if (a[j] > a[i] && i != j) {
                        ++count;
                    }
                }
                out.print((count + 1) + " ");
                count = 0;
            }
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        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 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 boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

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

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author tarek
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        AGukiZAndContest solver = new AGukiZAndContest();
        solver.solve(1, in, out);
        out.close();
    }

    static class AGukiZAndContest {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.nextInt();
            int[] a = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = in.nextInt();
            }
            int count = 0;
            for (int i = 0; i < a.length; i++) {
                for (int j = i; j < a.length; ++j) {
                    if (a[j] > a[i] && i != j) {
                        ++count;
                    }
                }
                out.print((count + 1) + " ");
                count = 0;
            }
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        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 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 boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

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

    }
}