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.util.*;
import java.io.*;

/**
 * 18-Aug-2017
 * 9:04:33 PM
 * @author HulkBuster
 * 
 */
public class CF841C {
public static int mod = (int) (1e9 + 7);
public static InputReader in;
public static PrintWriter out;

public static void solve() throws FileNotFoundException {

	in = new InputReader(System.in);
	out = new PrintWriter(System.out);
	int m = in.ni();
	int arA[]= new int[m];
	int arB[]=new int[m];
	int arBB[]=new int[m];
	for(int i =0;i<m;i++){
		arA[i] = in.ni();
	}
	for(int i =0;i<m;i++){
		arB[i] = in.ni();
		arBB[i] = arB[i];
	}
	Arrays.sort(arA);
	Arrays.sort(arB);
	
	HashMap<Integer,Queue>hm = new HashMap<>();
	for(int i =0;i<m;i++){
		 Queue queue = new LinkedList<>() ;
		
		if(hm.containsKey(arB[i]))
			queue = hm.get(arB[i]);
		queue.add(arA[m-i-1]);
		hm.put(arB[i], queue);
	}
	for(int i =0;i<m;i++){
		Queue queue = hm.get(arBB[i]);
		out.print(queue.remove()+" ");
		hm.put(arBB[i],queue);
	}
	out.close();
}

public static void main(String[] args) {
	new Thread(null, new Runnable() {
		public void run() {
			try {
				solve();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}, "1", 1 << 26).start();
}

static class Pair implements Comparable<Pair> {

	int x, y, i;

	Pair(int x, int y, int i) {
		this.x = x;
		this.y = y;
		this.i = i;
	}

	Pair(int x, int y) {
		this.x = x;
		this.y = y;
	}

	public int compareTo(Pair o) {
		if (this.x != o.x)
			return Integer.compare(this.x, o.x);
		else
			return Integer.compare(this.y, o.y);
		//return 0;
	}

	public boolean equals(Object o) {
		if (o instanceof Pair) {
			Pair p = (Pair) o;
			return p.x == x && p.y == y && p.i == i;
		}
		return false;
	}

	public int hashCode() {
		return new Integer(x).hashCode() * 31 + new Integer(y).hashCode() + new Integer(i).hashCode() * 37;
	}

}

public static long add(long a, long b) {
	long x = (a + b);
	while (x >= mod)
		x -= mod;
	return x;
}

public static long sub(long a, long b) {
	long x = (a - b);
	while (x < 0)
		x += mod;
	return x;
}

public static long mul(long a, long b) {
	long x = (a * b);
	while (x >= mod)
		x -= mod;
	return x;
}

public static boolean isPal(String s) {
	for (int i = 0, j = s.length() - 1; i <= j; i++, j--) {
		if (s.charAt(i) != s.charAt(j))
			return false;
	}
	return true;
}

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

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

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

public static long gcdExtended(long a, long b, long[] x) {

	if (a == 0) {
		x[0] = 0;
		x[1] = 1;
		return b;
	}
	long[] y = new long[2];
	long gcd = gcdExtended(b % a, a, y);

	x[0] = y[1] - (b / a) * y[0];
	x[1] = y[0];

	return gcd;
}

public static long mulmod(long a, long b, long m) {
	if (m <= 1000000009)
		return a * b % m;

	long res = 0;
	while (a > 0) {
		if ((a & 1) != 0) {
			res += b;
			if (res >= m)
				res -= m;
		}
		a >>= 1;
		b <<= 1;
		if (b >= m)
			b -= m;
	}
	return res;
}

public static int abs(int a, int b) {
	return (int) Math.abs(a - b);
}

public static long abs(long a, long b) {
	return (long) Math.abs(a - b);
}

public static int max(int a, int b) {
	if (a > b)
		return a;
	else
		return b;
}

public static int min(int a, int b) {
	if (a > b)
		return b;
	else
		return a;
}

public static long max(long a, long b) {
	if (a > b)
		return a;
	else
		return b;
}

public static long min(long a, long b) {
	if (a > b)
		return b;
	else
		return a;
}

public static long pow(long n, long p, long m) {
	long result = 1;
	if (p == 0)
		return 1;
	if (p == 1)
		return n;
	while (p != 0) {
		if (p % 2 == 1)
			result *= n;
		if (result >= m)
			result %= m;
		p >>= 1;
		n *= n;
		if (n >= m)
			n %= m;
	}
	return result;
}

public static long pow(long n, long p) {
	long result = 1;
	if (p == 0)
		return 1;
	if (p == 1)
		return n;
	while (p != 0) {
		if (p % 2 == 1)
			result *= n;
		p >>= 1;
		n *= n;
	}
	return result;
}

public static void debug(Object... o) {
	System.out.println(Arrays.deepToString(o));
}

static class InputReader {
	private final InputStream stream;
	private final byte[] buf = new byte[8192];
	private int curChar, snumChars;
	private SpaceCharFilter filter;

	public InputReader(InputStream stream) {
		this.stream = stream;
	}

	public int snext() {
		if (snumChars == -1)
			throw new InputMismatchException();
		if (curChar >= snumChars) {
			curChar = 0;
			try {
				snumChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (snumChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public int ni() {
		int c = snext();
		while (isSpaceChar(c)) {
			c = snext();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = snext();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = snext();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public long nl() {
		int c = snext();
		while (isSpaceChar(c)) {
			c = snext();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = snext();
		}
		long res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = snext();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public int[] nIArr(int n) {
		int a[] = new int[n];
		for (int i = 0; i < n; i++) {
			a[i] = ni();
		}
		return a;
	}

	public long[] nLArr(int n) {
		long a[] = new long[n];
		for (int i = 0; i < n; i++) {
			a[i] = nl();
		}
		return a;
	}

	public String readString() {
		int c = snext();
		while (isSpaceChar(c)) {
			c = snext();
		}
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = snext();
		} while (!isSpaceChar(c));
		return res.toString();
	}

	public String nextLine() {
		int c = snext();
		while (isSpaceChar(c))
			c = snext();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = snext();
		} while (!isEndOfLine(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;
	}

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

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

}
}
