Leha like all kinds of strange things. Recently he liked the function F(n, k). Consider all possible k-element subsets of the set [1, 2, ..., n]. For subset find minimal element in it. F(n, k) — mathematical expectation of the minimal element among all k-element subsets.

But only function does not interest him. He wants to do interesting things with it. Mom brought him two arrays A and B, each consists of m integers. For all i, j such that 1 ≤ i, j ≤ m the condition Ai ≥ Bj holds. Help Leha rearrange the numbers in the array A so that the sum <image> is maximally possible, where A' is already rearranged array.

Input

First line of input data contains single integer m (1 ≤ m ≤ 2·105) — length of arrays A and B.

Next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 109) — array A.

Next line contains m integers b1, b2, ..., bm (1 ≤ bi ≤ 109) — array B.

Output

Output m integers a'1, a'2, ..., a'm — array A' which is permutation of the array A.

Examples

Input

5
7 3 5 3 4
2 1 3 2 3


Output

4 7 3 5 3


Input

7
4 6 5 8 8 2 6
2 1 2 2 1 1 2


Output

2 6 4 5 8 8 6
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Comparator;
import java.util.InputMismatchException;
import java.util.TreeMap;

	 
	public class Solution123 implements Runnable
	{
		static final int MAX = 1000000007;
		static class InputReader
		{
			private InputStream stream;
			private byte[] buf = new byte[1024];
			private int curChar;
			private int numChars;
			private SpaceCharFilter filter;
			private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	
			public InputReader(InputStream stream)
			{
				this.stream = stream;
			}
			
			public int read()
			{
				if (numChars==-1) 
					throw new InputMismatchException();
				
				if (curChar >= numChars)
				{
					curChar = 0;
					try 
					{
						numChars = stream.read(buf);
					}
					catch (IOException e)
					{
						throw new InputMismatchException();
					}
					
					if(numChars <= 0)				
						return -1;
				}
				return buf[curChar++];
			}
		 
			public String nextLine()
			{
				String str = "";
	            try
	            {
	                str = br.readLine();
	            }
	            catch (IOException e)
	            {
	                e.printStackTrace();
	            }
	            return str;
			}
			public int nextInt()
			{
				int c = read();
				
				while(isSpaceChar(c)) 
					c = read();
				
				int sgn = 1;
				
				if (c == '-') 
				{
					sgn = -1;
					c = read();
				}
				
				int res = 0;
				do 
				{
					if(c<'0'||c>'9') 
						throw new InputMismatchException();
					res *= 10;
					res += c - '0';
					c = read();
				}
				while (!isSpaceChar(c)); 
				
				return res * sgn;
			}
			
			public long nextLong() 
			{
				int c = read();
				while (isSpaceChar(c))
					c = read();
				int sgn = 1;
				if (c == '-') 
				{
					sgn = -1;
					c = read();
				}
				long res = 0;
				
				do 
				{
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					res *= 10;
					res += c - '0';
					c = read();
				}
				while (!isSpaceChar(c));
					return res * sgn;
			}
			
			public double nextDouble() 
			{
				int c = read();
				while (isSpaceChar(c))
					c = read();
				int sgn = 1;
				if (c == '-') 
				{
					sgn = -1;
					c = read();
				}
				double res = 0;
				while (!isSpaceChar(c) && c != '.') 
				{
					if (c == 'e' || c == 'E')
						return res * Math.pow(10, nextInt());
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					res *= 10;
					res += c - '0';
					c = read();
				}
				if (c == '.') 
				{
					c = read();
					double m = 1;
					while (!isSpaceChar(c)) 
					{
						if (c == 'e' || c == 'E')
							return res * Math.pow(10, nextInt());
						if (c < '0' || c > '9')
							throw new InputMismatchException();
						m /= 10;
						res += (c - '0') * m;
						c = read();
					}
				}
				return res * sgn;
			}
			
			public String readString() 
			{
				int c = read();
				while (isSpaceChar(c))
					c = read();
				StringBuilder res = new StringBuilder();
				do 
				{
					res.appendCodePoint(c);
					c = read();
				} 
				while (!isSpaceChar(c));
				
				return res.toString();
			}
		 
			public boolean isSpaceChar(int c) 
			{
				if (filter != null)
					return filter.isSpaceChar(c);
				return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
			}
		 
			public String next() 
			{
				return readString();
			}
			
			public interface SpaceCharFilter 
			{
				public boolean isSpaceChar(int ch);
			}
		}
	 	
		public static void main(String args[]) throws Exception
		{
			new Thread(null, new Solution123(),"Solution123",1<<26).start();
		}	
		public void run()
		{
			InputReader sc= new InputReader(System.in);
			PrintWriter w= new PrintWriter(System.out);
			int n = sc.nextInt();
			int[] arr = new int[n];
			int[][] arr2 = new int[n][2];
			int[] arr3 = new int[n];
			for(int i = 0;i < n;i++){
				arr[i] = sc.nextInt();
			}
			for(int i = 0;i < n;i++){
				arr2[i][0] = sc.nextInt();
				arr2[i][1] = i;
			}
			arr2 = comparator2(arr2);
			Arrays.sort(arr);
			for(int i = 0;i < n;i++){
				arr3[arr2[i][1]] = arr[i];
			}
			for(int i = 0;i < n;i++){
				w.print(arr3[i] + " ");
			}
			w.close();
		}	
		public static int[][] comparator2(int[][] arr){
			Arrays.sort(arr, new Comparator<int[]>() {
	            @Override
	            public int compare(int[] a,int[] b) {
	                Integer a1 = a[0];
	                Integer b1 = b[0];
	            	return b1.compareTo(a1);
	            }
	        });
			return arr;
		}
		static int cost(String s1,String s2,int cost1,int cost2){
			int[][] dp = new int [s1.length()+1][s2.length()+1];
			for(int i = 0;i <= s1.length();i++){
				for(int j = 0;j <= s2.length();j++){
					if(i == 0 && j == 0){
						continue;
					}
					if(i == 0){
						dp[i][j] = dp[i][j-1] + cost2;
					}else if(j == 0){
						dp[i][j] = dp[i-1][j] + cost1;
					}else if(s1.charAt(i-1) == s2.charAt(j-1)){
						dp[i][j] = dp[i-1][j-1];
					}else{
						dp[i][j] = Math.min(dp[i-1][j] + cost1,dp[i][j-1] + cost2);
					}
				}
			}
			return dp[s1.length()][s2.length()];
		}
		class Pair implements Comparable<Pair>{
			int number;
			Long max;
			Long num;
			Pair(int number,long max,long num){
				this.number = number;
				this.max = max;
				this.num = num;
			}
			@Override
			public int compareTo(Pair p){
				return p.max.compareTo(this.max);
			}
		}
	}