Problem: You are given n pairs of integers (a_1, b_1), (a_2, b_2), …, (a_n, b_n). All of the integers in the pairs are distinct and are in the range from 1 to 2 ⋅ n inclusive.

Let's call a sequence of integers x_1, x_2, …, x_{2k} good if either 

  * x_1 < x_2 > x_3 < … < x_{2k-2} > x_{2k-1} < x_{2k}, or 
  * x_1 > x_2 < x_3 > … > x_{2k-2} < x_{2k-1} > x_{2k}. 



You need to choose a subset of distinct indices i_1, i_2, …, i_t and their order in a way that if you write down all numbers from the pairs in a single sequence (the sequence would be a_{i_1}, b_{i_1}, a_{i_2}, b_{i_2}, …, a_{i_t}, b_{i_t}), this sequence is good.

What is the largest subset of indices you can choose? You also need to construct the corresponding index sequence i_1, i_2, …, i_t.

Input

The first line contains single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of pairs.

Each of the next n lines contain two numbers — a_i and b_i (1 ≤ a_i, b_i ≤ 2 ⋅ n) — the elements of the pairs.

It is guaranteed that all integers in the pairs are distinct, that is, every integer from 1 to 2 ⋅ n is mentioned exactly once.

Output

In the first line print a single integer t — the number of pairs in the answer.

Then print t distinct integers i_1, i_2, …, i_t — the indexes of pairs in the corresponding order.

Examples

Input


5
1 7
6 4
2 10
9 8
3 5


Output


3
1 5 3


Input


3
5 4
3 2
6 1


Output


3
3 2 1

Note

The final sequence in the first example is 1 < 7 > 3 < 5 > 2 < 10.

The final sequence in the second example is 6 > 1 < 3 > 2 < 5 > 4.

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.InputMismatchException;
import java.util.TreeMap;

public class Solution1 implements Runnable {
	static final long MAX = 464897L;

	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 Solution1(), "Solution1", 1 << 26).start();
	}

	static long gcd(long a, long b) {
		if (b == 0)
			return a;
		return gcd(b, a % b);
	}

	static long lcm(long a, long b) {
		return (a * b) / gcd(a, b);
	}

	int maxn = 1000005;
	long MOD = 998244353;
	long prime = 29;
	ArrayList<Pair> adj[];
	TreeMap<Long, Long> tmap = new TreeMap();
	int[] val;
	int[] ans;
	long[] arr;
	ArrayList<Long> segTree[];
	public void run() {
		InputReader sc = new InputReader(System.in);
		PrintWriter w = new PrintWriter(System.out);
		int n = sc.nextInt();
		ArrayList<Pair> p1 = new ArrayList();
		ArrayList<Pair2> p2 = new ArrayList();
		for(int i = 1;i <= n;i++) {
			int a = sc.nextInt();
			int b = sc.nextInt();
			if(a < b)
				p1.add(new Pair(a,b,i));
			else
				p2.add(new Pair2(a,b,i));
		}
		ArrayList<Integer> ans1 = new ArrayList();
		ArrayList<Integer> ans2 = new ArrayList();
		Collections.sort(p1);
		for(int i = 0;i < p1.size();i++) {
			ans1.add(p1.get(i).c);
		}
		Collections.sort(p2);
		for(int i = 0;i < p2.size();i++) {
			ans2.add(p2.get(i).c);
		}
		if(ans1.size() > ans2.size()) {
			w.println(ans1.size());
			for(int i = 0;i < ans1.size();i++) {
				w.print(ans1.get(i) + " ");
			}
		}else {
			w.println(ans2.size());
			for(int i = 0;i < ans2.size();i++) {
				w.print(ans2.get(i) + " ");
			}
		}
		w.close();
	}
	Pair swap(TreeMap<Integer,Integer> tmap,TreeMap<Integer,Integer> tmap2,int i,int x) {
		int temp = tmap2.get(x);
		tmap2.put(x, tmap2.get(i));
		tmap2.put(i, temp);
		tmap.put(tmap2.get(x), x);
		tmap.put(tmap2.get(i),i);
		return (new Pair(i,x,1));
	}
	
	static long power(long a, long b, long mod) {
		long ans = 1;
		a = a % mod;
		while (b != 0) {
			if (b % 2 == 1) {
				ans = (ans * a) % mod;
			}
			a = (a * a) % mod;
			b = b / 2;
		}
		return ans;
	}

	class Pair implements Comparable<Pair> {
		int a;
		int b;
		int c;

		Pair(int a, int b, int c) {
			this.b = b;
			this.a = a;
			this.c = c;
		}

		public boolean equals(Object o) {
			Pair p = (Pair) o;
			return this.a == p.a && this.b == this.b;
		}

		public int hashCode() {
			return Long.hashCode(a) * 27 + Long.hashCode(b) * 31;
		}
		public int compareTo(Pair p) {
			return Long.compare(p.a, this.a);
		}
	}

	class Pair2 implements Comparable<Pair2> {
		int a;
		int b;
		int c;

		Pair2(int a, int b, int c) {
			this.b = b;
			this.a = a;
			this.c = c;
		}

		public boolean equals(Object o) {
			Pair p = (Pair) o;
			return this.a == p.a && this.b == this.b;
		}

		public int hashCode() {
			return Long.hashCode(a) * 27 + Long.hashCode(b) * 31;
		}

		public int compareTo(Pair2 p) {
			return Long.compare(this.b, p.b);
		}
	}
}