import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class VincentFast {
	private static class Tree {
		private int value;
		private int size;
		private Tree left;
		private Tree right;

		private Tree(int v) {
			value = v;
			size = 1;
			left = null;
			right = null;
		}

		private static int size(Tree t) {
			return t == null ? 0 : t.size;
		}

		private void leftWins() {
			int v = value;
			Tree a = left.left;
			Tree b = left.right;
			Tree c = right;
			Tree l = left;
			left = a;
			l.left = b;
			l.right = c;
			right = l;
			value = l.value;
			l.value = v;
			l.size = size(b) + size(c) + 1;
		}

		private void rightWins() {
			int v = value;
			Tree a = left;
			Tree b = right.left;
			Tree c = right.right;
			Tree r = right;
			right = c;
			r.right = b;
			r.left = a;
			left = r;
			value = r.value;
			r.value = v;
			r.size = size(a) + size(b) + 1;
		}

		private void balance() {
			if (size == 2) {
				return;
			} else if (left == null) {
				rightWins();
				return;
			} else if (right == null) {
				leftWins();
				return;
			}
			int l = size(left);
			int r = size(right);
			if (l > 4 * r) {
				int ll = size(left.left);
				if (ll < 2 * r) {
					left.rightWins();
				}
				leftWins();
			} else if (r > 4 * l) {
				int rr = size(right.right);
				if (rr < 2 * l) {
					right.leftWins();
				}
				rightWins();
			}
		}

		private void insert(int pos, int v) {
			size++;
			int s = size(left) + 1;
			if (pos == 1 && left == null) {
				left = new Tree(v);
			} else if (pos == size && right == null) {
				right = new Tree(v);
			} else if (pos <= s) {
				left.insert(pos, v);
			} else {
				right.insert(pos - s, v);
			}
			balance();
		}

		private static void inorder(Tree t, int[] tab, int offset) {
			if (t == null) {
				return;
			}
			int s = size(t.left);
			inorder(t.left, tab, offset);
			tab[offset + s] = t.value;
			inorder(t.right, tab, offset + s + 1);
		}

		private static Tree insert(Tree t, int pos) {
			if (t == null) {
				return new Tree(1);
			} else {
				t.insert(pos, t.size + 1);
				return t;
			}
		}
	}

	private static void read() throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int N = Integer.parseInt(br.readLine());
		String[] line1 = br.readLine().split(" ");
		String[] line2 = br.readLine().split(" ");
		br.close();
		Tree t = null;
		for (int i = N / 2 - 1; i >= 0; i--) {
			t = Tree.insert(t, Integer.parseInt(line2[i]));
			t = Tree.insert(t, Integer.parseInt(line1[i]));
		}
		int[] order = new int[N];
		Tree.inorder(t, order, 0);
		int[] postOrder = new int[N];
		for (int i = 0; i < N; i++) {
			postOrder[N - order[i]] = i + 1;
		}
		System.out.println(IntStream.range(0, N / 2).mapToObj(i -> postOrder[2 * i] + "").collect(Collectors.joining(" ")));
		System.out
				.println(IntStream.range(0, N / 2).mapToObj(i -> postOrder[2 * i + 1] + "").collect(Collectors.joining(" ")));
	}

	public static void main(String[] args) throws IOException {
		read();
	}
}