use std::collections::BTreeSet;
use std::io;
use std::io::Stdin;
use std::str::FromStr;

fn read_line(stdin : &Stdin, line : &mut String) {
    match stdin.read_line(line) {
        Ok(_) => return,
        Err(msg) => panic!("Could not read line! Message: {}.", msg),
    }
}

fn parse_t<T : FromStr>(s : &str) -> T {
    match s.trim().parse() {
        Ok(y) => y,
        Err(_) => panic!("Could not read from string!"),
    }
}

fn read_ts<T : FromStr>(stdin : &Stdin, ts : &mut Vec<T>) {
    let mut line = String::new();
    read_line(stdin, &mut line);
    let word_iter = line.split_whitespace();
    for word in word_iter {
        let x = parse_t(word);
        ts.push(x);
    }
}

fn print_maximum_chain(envelopes : &mut Vec<(usize, usize, usize)>) {
    // Sort envelopes in descending order of (w, h).
    envelopes.sort();
    envelopes.reverse();
    // Keep track of the chains.
    let mut covering_dag : Vec<(usize, usize, usize)> = vec![];
    let mut covering_dag_roots = BTreeSet::new();
    let mut node_id = 0;
    for env_id in 0 .. envelopes.len() {
        let (w, h, _) = envelopes[env_id];
        // if the covering dag is empty.
        if covering_dag_roots.is_empty() {
            // The newly inserted node is a root.
            covering_dag.push((env_id, usize::max_value(), 1));
            covering_dag_roots.insert(node_id);
            node_id = node_id + 1;
        } else {
            let mut covering_nodes = vec![];
            let mut found_cover = false;
            // Insert the envelope into the covering dag.
            for &root in covering_dag_roots.iter() {
                let mut cursor = root;
                loop {
                    if cursor == usize::max_value() {
                        break;
                    } else {
                        let (cursor_env_id, cursor_child_id, _) = covering_dag[cursor];
                        let (cursor_w, cursor_h, _) = envelopes[cursor_env_id];
                        // if the envelope is covered.
                        if (cursor_w > w) && (cursor_h > h) {
                            covering_nodes.push(cursor);
                            found_cover = true;
                            break;
                        } else {
                            cursor = cursor_child_id;
                        }
                    }
                }
            }
            // If nodes were found to cover the envelope.
            if found_cover {
                // Add root to the deepest node.
                let mut deepest_node = usize::max_value();
                let mut deepest_node_depth = 0;
                for cursor in covering_nodes {
                    let (_, _, cursor_depth) = covering_dag[cursor];
                    if cursor_depth > deepest_node_depth {
                        deepest_node_depth = cursor_depth;
                        deepest_node = cursor;
                    }
                }
                covering_dag_roots.insert(node_id);
                covering_dag.push((env_id, deepest_node, deepest_node_depth + 1));
                node_id = node_id + 1;
            } else {
                // If no node was found to cover the envelope.
                // The envelope is a root of a new branch.
                covering_dag_roots.insert(node_id);
                covering_dag.push((env_id, usize::max_value(), 1));
                node_id = node_id + 1;
            }
        }
    }
    // Find the deepest root.
    let mut deepest_root = usize::max_value();
    let mut deepest_root_depth = 0;
    for &root in covering_dag_roots.iter() {
        let (_, _, root_depth) = covering_dag[root];
        if root_depth > deepest_root_depth {
            deepest_root_depth = root_depth;
            deepest_root = root;
        }
    }
    println!("{}", deepest_root_depth);
    let mut is_first = true;
    loop {
        if deepest_root == usize::max_value() {
            break;
        } else {
            let (env_id, child_id, _) = covering_dag[deepest_root];
            if is_first {
                is_first = false;
            } else {
                print!(" ");
            }
            let (_, _, i) = envelopes[env_id];
            print!("{}", i);
            deepest_root = child_id;
        }
    }
    println!();
}

fn main() {
    let stdin = io::stdin();
    let mut n_w_h = vec![];
    read_ts(&stdin, &mut n_w_h);
    let n = n_w_h[0];
    let card_width = n_w_h[1];
    let card_height = n_w_h[2];
    let mut envelopes : Vec<(usize, usize, usize)> = vec![];
    for i in 1 .. (n + 1) {
        let mut w_h = vec![];
        read_ts(&stdin, &mut w_h);
        let envelope_width = w_h[0];
        let envelope_height = w_h[1];
        if (envelope_width > card_width) && (envelope_height > card_height) {
            envelopes.push((envelope_width, envelope_height, i));
        }
    }
    print_maximum_chain(&mut envelopes);
}


use std::collections::BTreeSet;
use std::io;
use std::io::Stdin;
use std::str::FromStr;

fn read_line(stdin : &Stdin, line : &mut String) {
    match stdin.read_line(line) {
        Ok(_) => return,
        Err(msg) => panic!("Could not read line! Message: {}.", msg),
    }
}

fn parse_t<T : FromStr>(s : &str) -> T {
    match s.trim().parse() {
        Ok(y) => y,
        Err(_) => panic!("Could not read from string!"),
    }
}

fn read_ts<T : FromStr>(stdin : &Stdin, ts : &mut Vec<T>) {
    let mut line = String::new();
    read_line(stdin, &mut line);
    let word_iter = line.split_whitespace();
    for word in word_iter {
        let x = parse_t(word);
        ts.push(x);
    }
}

fn print_maximum_chain(envelopes : &mut Vec<(u64, u64, u64)>) {
    // Sort envelopes in descending order of (w, h).
    envelopes.sort();
    envelopes.reverse();
    let mut covering_tree : Vec<(usize, usize, usize)> = vec![];
    let mut covering_tree_roots = BTreeSet::new();
    for env_id in 0 .. envelopes.len() {
        let (w, h, _) = envelopes[env_id];
        let mut node_id = covering_tree.len();
        // if the covering_tree is empty.
        if covering_tree_roots.is_empty() {
            // The newly inserted node is a root.
            covering_tree.push((env_id, usize::max_value(), 1));
            covering_tree_roots.insert(node_id);
        } else {
            // Find the set of deepest root's that cover the given envelope.
            let mut deepest_roots = vec![];
            let mut deepest_root_depth = 0;
            for &root in covering_tree_roots.iter() {
                let (root_env_id, _, root_depth) = covering_tree[root];
                let (root_w, root_h, _) = envelopes[root_env_id];
                if (root_w > w) && (root_h > h) {
                    if root_depth > deepest_root_depth {
                        deepest_root_depth = root_depth;
                        deepest_roots.clear();
                        deepest_roots.push(root);
                    } else if root_depth == deepest_root_depth {
                        deepest_roots.push(root);
                    }
                }
            }
            // If no root was found to cover the envelope.
            if deepest_root_depth == 0 {
                // The envelope is a root of a new branch.
                covering_tree_roots.insert(node_id);
                covering_tree.push((env_id, usize::max_value(), 1));
            } else {
                // The envelope is the root of existing branches.
                for d_root in deepest_roots {
                    covering_tree_roots.insert(node_id);
                    covering_tree_roots.remove(&d_root);
                    covering_tree.push((env_id, d_root, deepest_root_depth + 1));
                    node_id = node_id + 1;
                }
            }
        }
    }

    // println!("{:?}", envelopes);
    // println!("{:?}", covering_tree_roots);
    // println!("{:?}", covering_tree);

    // Find the deepest root.
    let mut deepest_root = usize::max_value();
    let mut deepest_root_depth = 0;
    for &root in covering_tree_roots.iter() {
        let (_, _, root_depth) = covering_tree[root];
        if root_depth > deepest_root_depth {
            deepest_root_depth = root_depth;
            deepest_root = root;
        }
    }
    println!("{}", deepest_root_depth);
    let mut is_first = true;
    loop {
        if deepest_root == usize::max_value() {
            break;
        } else {
            let (env_id, child_id, _) = covering_tree[deepest_root];
            if is_first {
                is_first = false;
            } else {
                print!(" ");
            }
            let (_, _, i) = envelopes[env_id];
            print!("{}", i);
            deepest_root = child_id;
        }
    }
    println!();
}

fn main() {
    let stdin = io::stdin();
    let mut n_w_h = vec![];
    read_ts(&stdin, &mut n_w_h);
    let n = n_w_h[0];
    let card_width = n_w_h[1];
    let card_height = n_w_h[2];
    let mut envelopes : Vec<(u64, u64, u64)> = vec![];
    for i in 1 .. (n + 1) {
        let mut w_h = vec![];
        read_ts(&stdin, &mut w_h);
        let envelope_width = w_h[0];
        let envelope_height = w_h[1];
        if (envelope_width > card_width) && (envelope_height > card_height) {
            envelopes.push((envelope_width, envelope_height, i));
        }
    }
    // println!("n = {}, w = {}, h = {}", n, card_width, card_height);
    print_maximum_chain(&mut envelopes);
}


use std::collections::BTreeSet;
use std::io;
use std::io::Stdin;
use std::str::FromStr;

fn read_line(stdin : &Stdin, line : &mut String) {
    match stdin.read_line(line) {
        Ok(_) => return,
        Err(msg) => panic!("Could not read line! Message: {}.", msg),
    }
}

fn parse_t<T : FromStr>(s : &str) -> T {
    match s.trim().parse() {
        Ok(y) => y,
        Err(_) => panic!("Could not read from string!"),
    }
}

fn read_ts<T : FromStr>(stdin : &Stdin, ts : &mut Vec<T>) {
    let mut line = String::new();
    read_line(stdin, &mut line);
    let word_iter = line.split_whitespace();
    for word in word_iter {
        let x = parse_t(word);
        ts.push(x);
    }
}

fn print_maximum_chain(envelopes : &mut Vec<(usize, usize, usize)>, print_debug : bool) {
    if print_debug {
        println!("Sorting envelopes! - {}", envelopes.len());
    }
    // Sort envelopes in descending order of (w, h).
    envelopes.sort();
    envelopes.reverse();
    // Keep track of the chains.
    let mut covering_dag : Vec<(usize, usize, usize)> = vec![];
    let mut covering_dag_roots = BTreeSet::new();
    let mut node_id = 0;
    let mut counter = 0;
    for env_id in 0 .. envelopes.len() {
        counter = counter + 1;
        let (w, h, _) = envelopes[env_id];
        // if the covering dag is empty.
        if covering_dag_roots.is_empty() {
            // The newly inserted node is a root.
            covering_dag.push((env_id, usize::max_value(), 1));
            covering_dag_roots.insert(node_id);
            node_id = node_id + 1;
        } else {
            let mut roots_to_add = BTreeSet::new();
            let mut roots_to_remove = BTreeSet::new();
            let mut found_cover = false;
            // Insert the envelope into the covering dag.
            for &root in covering_dag_roots.iter() {
                let mut cursor = root;
                loop {
                    if cursor == usize::max_value() {
                        break;
                    } else {
                        let (cursor_env_id, cursor_child_id, cursor_depth) = covering_dag[cursor];
                        let (cursor_w, cursor_h, _) = envelopes[cursor_env_id];
                        // if the envelope is covered.
                        if (cursor_w > w) && (cursor_h > h) {
                            covering_dag.push((env_id, cursor, cursor_depth + 1));
                            roots_to_add.insert(node_id);
                            node_id = node_id + 1;
                            roots_to_remove.insert(cursor);
                            found_cover = true;
                            break;
                        } else {
                            cursor = cursor_child_id;
                        }
                    }
                }
            }
            for root in roots_to_remove.iter() {
                covering_dag_roots.remove(root);
            }
            for &root in roots_to_add.iter() {
                covering_dag_roots.insert(root);
            }
            // If no root was found to cover the envelope.
            if found_cover {
                // Do nothing ...
            } else {
                // The envelope is a root of a new branch.
                covering_dag_roots.insert(node_id);
                covering_dag.push((env_id, usize::max_value(), 1));
                node_id = node_id + 1;
            }
        }
        if print_debug && (counter == 10) {
            println!("Processed envelopes! - {} - {}", covering_dag_roots.len(), covering_dag.len());
            counter = 0;
        }
    }

    if print_debug {
        println!("Processed envelopes! - {} - {}", covering_dag_roots.len(), covering_dag.len());
    }

    // println!("{:?}", envelopes);
    // println!("{:?}", covering_tree_roots);
    // println!("{:?}", covering_tree);

    // Find the deepest root.
    let mut deepest_root = usize::max_value();
    let mut deepest_root_depth = 0;
    for &root in covering_dag_roots.iter() {
        let (_, _, root_depth) = covering_dag[root];
        if root_depth > deepest_root_depth {
            deepest_root_depth = root_depth;
            deepest_root = root;
        }
    }
    println!("{}", deepest_root_depth);
    let mut is_first = true;
    loop {
        if deepest_root == usize::max_value() {
            break;
        } else {
            let (env_id, child_id, _) = covering_dag[deepest_root];
            if is_first {
                is_first = false;
            } else {
                print!(" ");
            }
            let (_, _, i) = envelopes[env_id];
            print!("{}", i);
            deepest_root = child_id;
        }
    }
    println!();
}

fn main() {
    let stdin = io::stdin();
    let mut n_w_h = vec![];
    read_ts(&stdin, &mut n_w_h);
    let n = n_w_h[0];
    let card_width = n_w_h[1];
    let card_height = n_w_h[2];
    let mut envelopes : Vec<(usize, usize, usize)> = vec![];
    for i in 1 .. (n + 1) {
        let mut w_h = vec![];
        read_ts(&stdin, &mut w_h);
        let envelope_width = w_h[0];
        let envelope_height = w_h[1];
        if (envelope_width > card_width) && (envelope_height > card_height) {
            envelopes.push((envelope_width, envelope_height, i));
        }
    }
    // println!("n = {}, w = {}, h = {}", n, card_width, card_height);
    let print_debug = (n == 483) && (card_width == 103232) && (card_height == 75323);
    print_maximum_chain(&mut envelopes, print_debug);
}


package main

import (
	"bytes"
	"fmt"
	"io/ioutil"
	"os"
	"sort"
)

type Envelope struct {
	Index  int
	Height int
	Width  int
}

type Sorter struct {
	Envelopes []*Envelope
}

func (s Sorter) Len() int {
	return len(s.Envelopes)
}
func (s Sorter) Swap(i, j int) {
	s.Envelopes[i], s.Envelopes[j] = s.Envelopes[j], s.Envelopes[i]
}

func (s Sorter) Less(i, j int) bool {
	if s.Envelopes[i].Height == s.Envelopes[j].Height {
		return s.Envelopes[i].Width < s.Envelopes[j].Width
	}
	return s.Envelopes[i].Height < s.Envelopes[j].Height
}

func main() {

	dp := [5000]int{}
	prev := [5000]int{}
	max := -1
	maxIndex := -1

	bs, _ := ioutil.ReadAll(os.Stdin)
	reader := bytes.NewBuffer(bs)
	envs := make([]*Envelope, 0, 5000)
	var nn, n, w, h int
	fmt.Fscanf(reader, "%d %d %d\n", &n, &w, &h)
	for i := 0; i < n; i++ {
		e := Envelope{Index: i + 1}
		fmt.Fscanf(reader, "%d %d\n", &e.Width, &e.Height)
		if e.Width > w && e.Height > h {
			envs = append(envs, &e)
			nn++
		}
	}

	sort.Sort(Sorter{envs})
	for i := 0; i < nn; i++ {
		dp[i], prev[i] = 1, -1
		e0 := envs[i]
		for j := 0; j < i; j++ {
			e1 := envs[j]
			if e1.Height == e0.Height {
				break
			}
			if e1.Width < e0.Width && dp[j]+1 > dp[i] {
				dp[i] = dp[j] + 1
				prev[i] = j
			}
		}
		if max < dp[i] {
			max = dp[i]
			maxIndex = i
		}
	}

	if max == -1 {
		fmt.Printf("0")
	} else {
		solution := make([]int, 0, 5000)
		fmt.Printf("%d\n", max)
		for maxIndex != -1 {
			solution = append(solution, envs[maxIndex].Index)
			maxIndex = prev[maxIndex]
		}
		for i := len(solution) - 1; i >= 0; i-- {
			fmt.Printf("%d ", solution[i])
		}
	}
}


package main

import (
	"bufio"
	"bytes"
	"fmt"
	"os"
	"sort"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	n, w, h := readThreeNums(reader)
	envs := make([][]int, n)
	for i := 0; i < n; i++ {
		envs[i] = readNNums(reader, 2)
	}
	res := solve(n, w, h, envs)

	var buf bytes.Buffer

	buf.WriteString(fmt.Sprintf("%d\n", len(res)))

	for i := 0; i < len(res); i++ {
		buf.WriteString(fmt.Sprintf("%d ", res[i]))
	}
	fmt.Print(buf.String())
}

func readInt(bytes []byte, from int, val *int) int {
	i := from
	sign := 1
	if bytes[i] == '-' {
		sign = -1
		i++
	}
	tmp := 0
	for i < len(bytes) && bytes[i] >= '0' && bytes[i] <= '9' {
		tmp = tmp*10 + int(bytes[i]-'0')
		i++
	}
	*val = tmp * sign
	return i
}

func readNum(reader *bufio.Reader) (a int) {
	bs, _ := reader.ReadBytes('\n')
	readInt(bs, 0, &a)
	return
}

func readTwoNums(reader *bufio.Reader) (a int, b int) {
	res := readNNums(reader, 2)
	a, b = res[0], res[1]
	return
}

func readThreeNums(reader *bufio.Reader) (a int, b int, c int) {
	res := readNNums(reader, 3)
	a, b, c = res[0], res[1], res[2]
	return
}

func readNNums(reader *bufio.Reader, n int) []int {
	res := make([]int, n)
	x := 0
	bs, _ := reader.ReadBytes('\n')
	for i := 0; i < n; i++ {
		for x < len(bs) && (bs[x] < '0' || bs[x] > '9') {
			x++
		}
		x = readInt(bs, x, &res[i])
	}
	return res
}

func readUint64(bytes []byte, from int, val *uint64) int {
	i := from

	var tmp uint64
	for i < len(bytes) && bytes[i] >= '0' && bytes[i] <= '9' {
		tmp = tmp*10 + uint64(bytes[i]-'0')
		i++
	}
	*val = tmp

	return i
}

func solve(n, w, h int, envs [][]int) []int {
	items := make([]Envelope, n)
	var H int
	for i := 0; i < n; i++ {
		items[i] = Envelope{envs[i][0], envs[i][1], i}
		H = max(H, envs[i][1])
	}

	sort.Sort(Envelopes(items))
	H++
	arr := make([]int, 2*H)

	update := func(p int, v int) {
		p += H
		arr[p] = v
		for p > 0 {
			arr[p>>1] = max(arr[p], arr[p^1])
			p >>= 1
		}
	}

	get := func(l, r int) int {
		var res int
		l += H
		r += H

		for l < r {
			if l&1 == 1 {
				res = max(res, arr[l])
				l++
			}
			if r&1 == 1 {
				r--
				res = max(res, arr[r])
			}
			l >>= 1
			r >>= 1
		}
		return res
	}

	dp := make([]int, n+1)
	var best int
	for i := 0; i < n; i++ {
		cur := items[i]
		if cur.width <= w || cur.height <= h {
			continue
		}
		if i == 0 {
			dp[i] = 1
			update(cur.height, 1)
			continue
		}
		cnt := get(cur.height+1, H)
		dp[i] = cnt + 1
		update(cur.height, cnt+1)
		best = max(best, cnt+1)
	}

	if best == 0 {
		return nil
	}

	cur := -1
	for i := n - 1; i >= 0; i-- {
		if dp[i] == best {
			cur = i
			break
		}
	}
	res := make([]int, 0, best)
	res = append(res, items[cur].index+1)

	for i := cur - 1; i >= 0; i-- {
		if dp[i]+1 == best && items[i].width > items[cur].width && items[i].height > items[cur].height {
			best--
			cur = i
			res = append(res, items[cur].index+1)
		}
	}
	//reverse(res)

	return res
}

func max(a, b int) int {
	if a >= b {
		return a
	}
	return b
}

type Envelope struct {
	width  int
	height int
	index  int
}

type Envelopes []Envelope

func (ps Envelopes) Len() int {
	return len(ps)
}

func (ps Envelopes) Less(i, j int) bool {
	return ps[i].width > ps[j].width || ps[i].width == ps[j].width && ps[i].height > ps[j].height
}

func (ps Envelopes) Swap(i, j int) {
	ps[i], ps[j] = ps[j], ps[i]
}


package main

import (
	"bufio"
	"bytes"
	"fmt"
	"os"
	"sort"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	n, w, h := readThreeNums(reader)
	envs := make([][]int, n)
	for i := 0; i < n; i++ {
		envs[i] = readNNums(reader, 2)
	}
	res := solve(n, w, h, envs)

	var buf bytes.Buffer

	buf.WriteString(fmt.Sprintf("%d\n", len(res)))

	for i := 0; i < len(res); i++ {
		buf.WriteString(fmt.Sprintf("%d ", res[i]))
	}
	fmt.Print(buf.String())
}

func readInt(bytes []byte, from int, val *int) int {
	i := from
	sign := 1
	if bytes[i] == '-' {
		sign = -1
		i++
	}
	tmp := 0
	for i < len(bytes) && bytes[i] >= '0' && bytes[i] <= '9' {
		tmp = tmp*10 + int(bytes[i]-'0')
		i++
	}
	*val = tmp * sign
	return i
}

func readNum(reader *bufio.Reader) (a int) {
	bs, _ := reader.ReadBytes('\n')
	readInt(bs, 0, &a)
	return
}

func readTwoNums(reader *bufio.Reader) (a int, b int) {
	res := readNNums(reader, 2)
	a, b = res[0], res[1]
	return
}

func readThreeNums(reader *bufio.Reader) (a int, b int, c int) {
	res := readNNums(reader, 3)
	a, b, c = res[0], res[1], res[2]
	return
}

func readNNums(reader *bufio.Reader, n int) []int {
	res := make([]int, n)
	x := 0
	bs, _ := reader.ReadBytes('\n')
	for i := 0; i < n; i++ {
		for x < len(bs) && (bs[x] < '0' || bs[x] > '9') {
			x++
		}
		x = readInt(bs, x, &res[i])
	}
	return res
}

func readUint64(bytes []byte, from int, val *uint64) int {
	i := from

	var tmp uint64
	for i < len(bytes) && bytes[i] >= '0' && bytes[i] <= '9' {
		tmp = tmp*10 + uint64(bytes[i]-'0')
		i++
	}
	*val = tmp

	return i
}

func solve(n, w, h int, envs [][]int) []int {
	items := make([]Envelope, n)
	var H int
	for i := 0; i < n; i++ {
		items[i] = Envelope{envs[i][0], envs[i][1], i}
		H = max(H, envs[i][1])
	}

	sort.Sort(Envelopes(items))
	H++
	arr := make([]int, 2*H)

	update := func(p int, v int) {
		p += H
		arr[p] = v
		for p > 0 {
			arr[p>>1] = max(arr[p], arr[p^1])
			p >>= 1
		}
	}

	get := func(l, r int) int {
		var res int
		l += H
		r += H

		for l < r {
			if l&1 == 1 {
				res = max(res, arr[l])
				l++
			}
			if r&1 == 1 {
				r--
				res = max(res, arr[r])
			}
			l >>= 1
			r >>= 1
		}
		return res
	}

	dp := make([]int, n+1)
	var best int
	for i := 0; i < n; i++ {
		cur := items[i]
		if cur.width <= w {
			break
		}

		if cur.height <= h {
			continue
		}

		cnt := get(cur.height+1, H)
		dp[i] = cnt + 1
		update(cur.height, cnt+1)
		best = max(best, cnt+1)
	}

	if best == 0 {
		return nil
	}

	cur := -1
	for i := n - 1; i >= 0; i-- {
		if dp[i] == best {
			cur = i
			break
		}
	}
	res := make([]int, 0, best)
	res = append(res, items[cur].index+1)

	for i := cur - 1; i >= 0; i-- {
		if dp[i]+1 == best && items[i].width > items[cur].width && items[i].height > items[cur].height {
			best--
			cur = i
			res = append(res, items[cur].index+1)
		}
	}
	//reverse(res)

	return res
}

func max(a, b int) int {
	if a >= b {
		return a
	}
	return b
}

type Envelope struct {
	width  int
	height int
	index  int
}

type Envelopes []Envelope

func (ps Envelopes) Len() int {
	return len(ps)
}

func (ps Envelopes) Less(i, j int) bool {
	return ps[i].width > ps[j].width || ps[i].width == ps[j].width && ps[i].height < ps[j].height
}

func (ps Envelopes) Swap(i, j int) {
	ps[i], ps[j] = ps[j], ps[i]
}


package main

import (
	"bufio"
	"bytes"
	"fmt"
	"os"
	"sort"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	n, w, h := readThreeNums(reader)
	envs := make([][]int, n)
	for i := 0; i < n; i++ {
		envs[i] = readNNums(reader, 2)
	}
	res := solve(n, w, h, envs)

	var buf bytes.Buffer

	buf.WriteString(fmt.Sprintf("%d\n", len(res)))

	for i := 0; i < len(res); i++ {
		buf.WriteString(fmt.Sprintf("%d ", res[i]))
	}
	fmt.Print(buf.String())
}

func readInt(bytes []byte, from int, val *int) int {
	i := from
	sign := 1
	if bytes[i] == '-' {
		sign = -1
		i++
	}
	tmp := 0
	for i < len(bytes) && bytes[i] >= '0' && bytes[i] <= '9' {
		tmp = tmp*10 + int(bytes[i]-'0')
		i++
	}
	*val = tmp * sign
	return i
}

func readNum(reader *bufio.Reader) (a int) {
	bs, _ := reader.ReadBytes('\n')
	readInt(bs, 0, &a)
	return
}

func readTwoNums(reader *bufio.Reader) (a int, b int) {
	res := readNNums(reader, 2)
	a, b = res[0], res[1]
	return
}

func readThreeNums(reader *bufio.Reader) (a int, b int, c int) {
	res := readNNums(reader, 3)
	a, b, c = res[0], res[1], res[2]
	return
}

func readNNums(reader *bufio.Reader, n int) []int {
	res := make([]int, n)
	x := 0
	bs, _ := reader.ReadBytes('\n')
	for i := 0; i < n; i++ {
		for x < len(bs) && (bs[x] < '0' || bs[x] > '9') {
			x++
		}
		x = readInt(bs, x, &res[i])
	}
	return res
}

func readUint64(bytes []byte, from int, val *uint64) int {
	i := from

	var tmp uint64
	for i < len(bytes) && bytes[i] >= '0' && bytes[i] <= '9' {
		tmp = tmp*10 + uint64(bytes[i]-'0')
		i++
	}
	*val = tmp

	return i
}

func solve(n, h, w int, envs [][]int) []int {
	items := make([]Envelope, n)
	var H int
	for i := 0; i < n; i++ {
		items[i] = Envelope{envs[i][0], envs[i][1], i}
		H = max(H, envs[i][1])
	}

	sort.Sort(Envelopes(items))
	H++
	arr := make([]int, 2*H)

	update := func(p int, v int) {
		p += H
		arr[p] = v
		for p > 0 {
			arr[p>>1] = max(arr[p], arr[p^1])
			p >>= 1
		}
	}

	get := func(l, r int) int {
		var res int
		l += H
		r += H

		for l < r {
			if l&1 == 1 {
				res = max(res, arr[l])
				l++
			}
			if r&1 == 1 {
				r--
				res = max(res, arr[r])
			}
			l >>= 1
			r >>= 1
		}
		return res
	}

	dp := make([]int, n+1)
	var best int
	for i := 0; i < n; i++ {
		cur := items[i]
		if cur.width <= w || cur.height <= h {
			break
		}
		if i == 0 {
			dp[i] = 1
			update(cur.height, 1)
			continue
		}
		cnt := get(cur.height+1, H)
		dp[i] = cnt + 1
		update(cur.height, cnt+1)
		best = max(best, cnt+1)
	}

	if best == 0 {
		return nil
	}

	cur := -1
	for i := n - 1; i >= 0; i-- {
		if dp[i] == best {
			cur = i
			break
		}
	}
	res := make([]int, 0, best)
	res = append(res, items[cur].index+1)

	for i := cur - 1; i >= 0; i-- {
		if dp[i]+1 == best && items[i].width > items[cur].width && items[i].height > items[cur].height {
			best--
			cur = i
			res = append(res, items[cur].index+1)
		}
	}
	//reverse(res)

	return res
}

func max(a, b int) int {
	if a >= b {
		return a
	}
	return b
}

type Envelope struct {
	width  int
	height int
	index  int
}

type Envelopes []Envelope

func (ps Envelopes) Len() int {
	return len(ps)
}

func (ps Envelopes) Less(i, j int) bool {
	return ps[i].width > ps[j].width || ps[i].width == ps[j].width && ps[i].height > ps[j].height
}

func (ps Envelopes) Swap(i, j int) {
	ps[i], ps[j] = ps[j], ps[i]
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
)

type envelope struct {
	w, h, index, len int
}

func solve() {
	n := readInt()
	w := readInt()
	h := readInt()

	e := make([]envelope, 0, n)
	for i := 0; i < n; i++ {
		ew := readInt()
		eh := readInt()
		if ew <= w || eh <= h {
			// card won't fit, ignore it
			continue
		}
		e = append(e, envelope{ew, eh, i + 1, 0})
	}

	if len(e) == 0 {
		fmt.Println(0)
		return
	}

	// Sort by area
	sort.Slice(e, func(i, j int) bool {
		ai := uint64(e[i].w) * uint64(e[i].h)
		aj := uint64(e[j].w) * uint64(e[j].h)
		return ai < aj
	})

	maxlen := 0
	for inner, v_inner := range e {
		for outer := inner; outer < len(e); outer++ {
			if v_inner.w >= e[outer].w || v_inner.h >= e[outer].h {
				// doesn't fit: too wide or too tall
				continue
			}
			e[outer].len = max(v_inner.len+1, e[outer].len)
			maxlen = max(e[outer].len, maxlen)
		}
	}
	fmt.Println(maxlen + 1)

	a := make([]int, maxlen+1)
	lastidx := len(e)
	for i := len(e) - 1; i >= 0; i-- {
		if e[i].len == maxlen {
			if lastidx == len(e) || (e[i].h < e[lastidx].h &&
				e[i].w < e[lastidx].h) {
				a[maxlen] = e[i].index
				maxlen--
				lastidx = i
			}
		}
	}

	space := ""
	for _, i := range a {
		fmt.Printf("%v%v", space, i)
		space = " "
	}
	fmt.Println()

}

func max(x, y int) int {
	if x > y {
		return x
	}
	return y
}

var scanner *bufio.Scanner

func main() {
	scanner = bufio.NewScanner(os.Stdin)
	const MaxTokenLength = 1024 * 1024
	scanner.Buffer(make([]byte, 0, MaxTokenLength), MaxTokenLength)
	scanner.Split(bufio.ScanWords)
	solve()
}

func readString() string {
	scanner.Scan()
	return scanner.Text()
}

func readInt() int {
	val, _ := strconv.Atoi(readString())
	return val
}

func readInt64() int64 {
	v, _ := strconv.ParseInt(readString(), 10, 64)
	return v
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
)

type envelope struct {
	w, h, index, len int
}

func solve() {
	n := readInt()
	w := readInt()
	h := readInt()

	e := make([]envelope, 0, n)
	for i := 0; i < n; i++ {
		ew := readInt()
		eh := readInt()
		if ew <= w || eh <= h {
			// card won't fit, ignore it
			continue
		}
		e = append(e, envelope{ew, eh, i + 1, 0})
	}

	if len(e) == 0 {
		fmt.Println(0)
		return
	}

	// Sort by area
	sort.Slice(e, func(i, j int) bool {
		return (e[i].w * e[i].h) < (e[j].w * e[j].h)
	})

	maxlen := 0
	for inner, v_inner := range e {
		for outer := inner; outer < len(e); outer++ {
			if v_inner.w >= e[outer].w || v_inner.h >= e[outer].h {
				// doesn't fit: too wide or too tall
				continue
			}
			e[outer].len = max(v_inner.len+1, e[outer].len)
			maxlen = max(e[outer].len, maxlen)
		}
	}
	fmt.Println(maxlen + 1)

	a := make([]int, maxlen+1)
	for i := len(e) - 1; i >= 0; i-- {
		if e[i].len == maxlen {
			a[maxlen] = e[i].index
			maxlen--
		}
	}

	space := ""
	for _, i := range a {
		fmt.Printf("%v%v", space, i)
		space = " "
	}
	fmt.Println()

}

func max(x, y int) int {
	if x > y {
		return x
	}
	return y
}

var scanner *bufio.Scanner

func main() {
	scanner = bufio.NewScanner(os.Stdin)
	const MaxTokenLength = 1024 * 1024
	scanner.Buffer(make([]byte, 0, MaxTokenLength), MaxTokenLength)
	scanner.Split(bufio.ScanWords)
	solve()
}

func readString() string {
	scanner.Scan()
	return scanner.Text()
}

func readInt() int {
	val, _ := strconv.Atoi(readString())
	return val
}

func readInt64() int64 {
	v, _ := strconv.ParseInt(readString(), 10, 64)
	return v
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
)

type envelope struct {
	w, h, index, len, child int
}

func solve() {
	n := readInt()
	w := readInt()
	h := readInt()

	e := make([]envelope, 0, n)
	for i := 0; i < n; i++ {
		ew := readInt()
		eh := readInt()
		if ew <= w || eh <= h {
			// card won't fit, ignore it
			continue
		}
		e = append(e, envelope{ew, eh, i + 1, 0, -1})
	}

	if len(e) == 0 {
		fmt.Println(0)
		return
	}

	// Sort by area
	sort.Slice(e, func(i, j int) bool {
		ai := uint64(e[i].w) * uint64(e[i].h)
		aj := uint64(e[j].w) * uint64(e[j].h)
		return ai < aj
	})

	maxlen := 0
	for inner, v_inner := range e {
		for outer := inner; outer < len(e); outer++ {
			if v_inner.w >= e[outer].w || v_inner.h >= e[outer].h {
				// doesn't fit: too wide or too tall
				continue
			}
			if v_inner.len+1 > e[outer].len {
				e[outer].len = v_inner.len + 1
				e[outer].child = inner
			}
			maxlen = max(e[outer].len, maxlen)
		}
	}
	fmt.Println(maxlen + 1)

	lastidx := len(e)
	for i := len(e) - 1; i >= 0; i-- {
		if e[i].len == maxlen {
			lastidx = i
			break
		}
	}
	if lastidx == len(e) {
		panic("huh?")
	}

	a := make([]int, maxlen+1)
	for ; maxlen >= 0; maxlen-- {
		a[maxlen] = e[lastidx].index
		lastidx = e[lastidx].child
	}
	space := ""
	for _, v := range a {
		fmt.Printf("%v%v", space, v)
		space = " "
	}
	fmt.Println()
}

func max(x, y int) int {
	if x > y {
		return x
	}
	return y
}

var scanner *bufio.Scanner

func main() {
	scanner = bufio.NewScanner(os.Stdin)
	const MaxTokenLength = 1024 * 1024
	scanner.Buffer(make([]byte, 0, MaxTokenLength), MaxTokenLength)
	scanner.Split(bufio.ScanWords)
	solve()
}

func readString() string {
	scanner.Scan()
	return scanner.Text()
}

func readInt() int {
	val, _ := strconv.Atoi(readString())
	return val
}

func readInt64() int64 {
	v, _ := strconv.ParseInt(readString(), 10, 64)
	return v
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
)

type envelope struct {
	w, h, index, len int
}

func solve() {
	n := readInt()
	w := readInt()
	h := readInt()

	e := make([]envelope, 0, n)
	for i := 0; i < n; i++ {
		ew := readInt()
		eh := readInt()
		if ew <= w || eh <= h {
			// card won't fit, ignore it
			continue
		}
		e = append(e, envelope{ew, eh, i + 1, 0})
	}

	if len(e) == 0 {
		fmt.Println(0)
		return
	}

	// Sort by area
	sort.Slice(e, func(i, j int) bool {
		ai := uint64(e[i].w) * uint64(e[i].h)
		aj := uint64(e[j].w) * uint64(e[j].h)
		return ai < aj
	})

	maxlen := 0
	for inner, v_inner := range e {
		for outer := inner; outer < len(e); outer++ {
			if v_inner.w >= e[outer].w || v_inner.h >= e[outer].h {
				// doesn't fit: too wide or too tall
				continue
			}
			e[outer].len = max(v_inner.len+1, e[outer].len)
			maxlen = max(e[outer].len, maxlen)
		}
	}
	fmt.Println(maxlen + 1)

	a := make([]int, maxlen+1)
	for i := len(e) - 1; i >= 0; i-- {
		if e[i].len == maxlen {
			a[maxlen] = e[i].index
			maxlen--
		}
	}

	space := ""
	for _, i := range a {
		fmt.Printf("%v%v", space, i)
		space = " "
	}
	fmt.Println()

}

func max(x, y int) int {
	if x > y {
		return x
	}
	return y
}

var scanner *bufio.Scanner

func main() {
	scanner = bufio.NewScanner(os.Stdin)
	const MaxTokenLength = 1024 * 1024
	scanner.Buffer(make([]byte, 0, MaxTokenLength), MaxTokenLength)
	scanner.Split(bufio.ScanWords)
	solve()
}

func readString() string {
	scanner.Scan()
	return scanner.Text()
}

func readInt() int {
	val, _ := strconv.Atoi(readString())
	return val
}

func readInt64() int64 {
	v, _ := strconv.ParseInt(readString(), 10, 64)
	return v
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
)

type envelope struct {
	w, h, index, len int
}

func solve() {
	n := readInt()
	w := readInt()
	h := readInt()

	e := make([]envelope, 0, n)
	for i := 0; i < n; i++ {
		ew := readInt()
		eh := readInt()
		if ew <= w || eh <= h {
			// card won't fit, ignore it
			continue
		}
		e = append(e, envelope{ew, eh, i + 1, 0})
	}

	if len(e) == 0 {
		fmt.Println(0)
		return
	}

	// Sort by area
	sort.Slice(e, func(i, j int) bool {
		return (e[i].w * e[i].h) < (e[j].w * e[j].h)
	})

	maxlen := 0
	for inner, v_inner := range e {
		for outer := inner; outer < len(e); outer++ {
			if v_inner.w >= e[outer].w || v_inner.h >= e[outer].h {
				// doesn't fit: too wide or too tall
				continue
			}
			e[outer].len = max(v_inner.len+1, e[outer].len)
			maxlen = max(e[outer].len, maxlen)
		}
	}
	fmt.Println(maxlen + 1)

	a := make([]int, maxlen+1)
	for i := len(e) - 1; i >= 0; i-- {
		if e[i].len == maxlen {
			a[maxlen] = e[i].index
			maxlen--
		}
	}

	space := ""
	for _, i := range a {
		fmt.Printf("%v%v", space, i)
		space = " "
	}
	fmt.Println()
}

func max(x, y int) int {
	if x > y {
		return x
	}
	return y
}

var scanner *bufio.Scanner

func main() {
	scanner = bufio.NewScanner(os.Stdin)
	const MaxTokenLength = 1024 * 1024
	scanner.Buffer(make([]byte, 0, MaxTokenLength), MaxTokenLength)
	scanner.Split(bufio.ScanWords)
	solve()
}

func readString() string {
	scanner.Scan()
	return scanner.Text()
}

func readInt() int {
	val, _ := strconv.Atoi(readString())
	return val
}

func readInt64() int64 {
	v, _ := strconv.ParseInt(readString(), 10, 64)
	return v
}


package main

import (
  "bufio"
  "fmt"
  "os"
  "sort"
  "strconv"
)

var in = bufio.NewScanner(os.Stdin)

var n, w, h, max, maxi int
var e [5001][3]int
var dep [5001]int
var prev [5001]int
var ret [5001]int

type Matrix [5001][3]int

func init() {
  in.Split(bufio.ScanWords)
  for i := range dep {
    dep[i] = 1
  }

  for i := range prev {
    prev[i] = -1
  }
}

func (m Matrix) Len() int           { return n }
func (m Matrix) Less(i, j int) bool { return m[i][0] < m[j][0] }
func (m *Matrix) Swap(i, j int)     { m[i], m[j] = m[j], m[i] }

func main() {
  n, w, h = readInt(), readInt(), readInt()

  for i := 0; i < n; i++ {
    tw, th := readInt(), readInt()
    if tw > w && th > h {
      e[i][0], e[i][1], e[i][2] = tw, th, i
    }
  }

  if e[0][0] == 0 {
    fmt.Println("0")
    return
  }

  m := Matrix(e)
  sort.Sort(&m)

  for i := 1; i < n; i++ {
    for j := 0; j < i; j++ {
      if m[i][0] > m[j][0] && m[i][1] > m[j][1] && dep[i] < dep[j]+1 {
        dep[i] = dep[j] + 1
        prev[i] = j
      }
    }
  }

  for i := 0; i < n; i++ {
    if max < dep[i] {
      max = dep[i]
      maxi = i
    }
  }

  i := maxi
  j := 0
  for {
    ret[j] = m[i][2]
    i = prev[i]
    if i == -1 {
      break
    }
    j++
  }

  fmt.Printf("%d\n", max)
  for i := j; i >= 0; i-- {
    fmt.Printf("%d ", ret[i])
  }
}

func readInt() int {
  in.Scan()
  n, _ := strconv.Atoi(in.Text())
  return n
}


package main

import (
  "bufio"
  "fmt"
  "os"
  "sort"
  "strconv"
)

var in = bufio.NewScanner(os.Stdin)
var n, w, h int

func init() {
  in.Split(bufio.ScanWords)
}

type Matrix [5010][3]int

func (m Matrix) Len() int { return n }
func (m Matrix) Less(i, j int) bool {
  return m[i][0] < m[j][0]
}

func (m *Matrix) Swap(i, j int) { m[i], m[j] = m[j], m[i] }

func main() {
  var dp [5010][5010]int
  var e [5010][3]int
  maxSum, maxIdx := -1, -1
  n, w, h = readInt(), readInt(), readInt()

  for i := 0; i < n; i++ {
    e[i][0], e[i][1], e[i][2] = readInt(), readInt(), i
  }

  m := Matrix(e)
  sort.Sort(&m)

  for i := 0; i < n; i++ {
    if m[i][0] > w && m[i][1] > h {
      for j := i + 1; j < n; j++ {
        if m[j][0] > m[i][0] && m[j][1] > m[i][1] {
          dp[i][j] = 1
        }
      }
    }
  }

  for i := 0; i < n; i++ {
    sum := 0
    for j := 0; j < n; j++ {
      if dp[j][i] == 1 {
        sum++
      }
    }

    if maxSum < sum {
      maxSum = sum
      maxIdx = i
    }
  }

    if maxSum < sum {
      maxSum = sum
      maxIdx = i
    }
  }

  fmt.Printf("%d\n", maxSum+1)
  for i := 0; i < n; i++ {
    if dp[i][maxIdx] == 1 {
      fmt.Printf("%d ", m[i][2]+1)
    }
  }
  fmt.Printf("%d\n", m[maxIdx][2]+1)
}

func readInt() int {
  in.Scan()
  n, _ := strconv.Atoi(in.Text())
  return n
}


package main

import (
  "bufio"
  "fmt"
  "os"
  "sort"
  "strconv"
)

var in = bufio.NewScanner(os.Stdin)
var n, w, h int
var dp [5010][5010]int
var e [5010][3]int

func init() {
  in.Split(bufio.ScanWords)
}

type Matrix [5010][3]int

func (m Matrix) Len() int { return n }
func (m Matrix) Less(i, j int) bool {
  return m[i][0] < m[j][0]
}

func (m *Matrix) Swap(i, j int) { m[i], m[j] = m[j], m[i] }

func main() {
  maxSum, maxIdx := -1, -1
  n, w, h = readInt(), readInt(), readInt()

  for i := 0; i < n; i++ {
    e[i][0], e[i][1], e[i][2] = readInt(), readInt(), i
  }

  m := Matrix(e)
  sort.Sort(&m)

  for i := 0; i < n; i++ {
    if m[i][0] > w && m[i][1] > h {
      for j := i + 1; j < n; j++ {
        if m[j][0] > m[i][0] && m[j][1] > m[i][1] {
          dp[i][j] = 1
        }
      }
    }
  }

  for i := 0; i < n; i++ {
    sum := 0
    for j := 0; j < n; j++ {
      if dp[j][i] == 1 {
        sum++
      }
    }

    if maxSum < sum {
      maxSum = sum
      maxIdx = i
    }
  }

  fmt.Printf("%d\n", maxSum+1)
  for i := 0; i < n; i++ {
    if dp[i][maxIdx] == 1 {
      fmt.Printf("%d ", m[i][2]+1)
    }
  }
  fmt.Printf("%d\n", m[maxIdx][2]+1)
}

func readInt() int {
  in.Scan()
  n, _ := strconv.Atoi(in.Text())
  return n
}


package main

import (
  "bufio"
  "fmt"
  "os"
  "sort"
  "strconv"
)

var in = bufio.NewScanner(os.Stdin)
var n, w, h int

func init() {
  in.Split(bufio.ScanWords)
}

type Matrix [5010][3]int

func (m Matrix) Len() int { return n }
func (m Matrix) Less(i, j int) bool {
  return m[i][0] < m[j][0]
}

func (m *Matrix) Swap(i, j int) { m[i], m[j] = m[j], m[i] }

func main() {
  var dp [5010][5010]int
  var e [5010][3]int
  maxSum, maxIdx := -1, -1
  n, w, h = readInt(), readInt(), readInt()

  for i := 0; i < n; i++ {
    e[i][0], e[i][1], e[i][2] = readInt(), readInt(), i
  }

  m := Matrix(e)
  sort.Sort(&m)

  for i := 0; i < n; i++ {
    if m[i][0] > w && m[i][1] > h {
      for j := i + 1; j < n; j++ {
        if m[j][0] > m[i][0] && m[j][1] > m[i][1] {
          dp[i][j] = 1
        }
      }
    }
  }

  for i := 0; i < n; i++ {
    sum := 0
    for j := 0; j < n; j++ {
      if dp[j][i] == 1 {
        sum++
      }
    }

    if maxSum < sum {
      maxSum = sum
      maxIdx = i
    }
  }

  fmt.Printf("%d\n", maxSum+1)
  for i := 0; i < n; i++ {
    if dp[i][maxIdx] == 1 {
      fmt.Printf("%d ", m[i][2]+1)
    }
  }
  fmt.Printf("%d\n", m[maxIdx][2]+1)
}

func readInt() int {
  in.Scan()
  n, _ := strconv.Atoi(in.Text())
  return n
}


package main

import (
  "bufio"
  "fmt"
  "os"
  "sort"
  "strconv"
)

var in = bufio.NewScanner(os.Stdin)

var n, w, h, max, maxi, elen int
var e [5001][3]int
var dep [5001]int
var prev [5001]int
var ret [5001]int

type Matrix [5001][3]int

func init() {
  in.Split(bufio.ScanWords)
  for i := range dep {
    dep[i] = 1
  }

  for i := range prev {
    prev[i] = -1
  }
}

func (m Matrix) Len() int           { return elen }
func (m Matrix) Less(i, j int) bool { return m[i][0] < m[j][0] }
func (m *Matrix) Swap(i, j int)     { m[i], m[j] = m[j], m[i] }

func main() {
  n, w, h = readInt(), readInt(), readInt()

  for i := 0; i < n; i++ {
    tw, th := readInt(), readInt()
    if tw > w && th > h {
      e[i][0], e[i][1], e[i][2] = tw, th, i
      elen++
    }
  }

  if elen == 0 {
    fmt.Println("0")
    return
  }

  m := Matrix(e)
  sort.Sort(&m)

  for i := 1; i < elen; i++ {
    for j := 0; j < i; j++ {
      if m[i][0] > m[j][0] && m[i][1] > m[j][1] && dep[i] < dep[j]+1 {
        dep[i] = dep[j] + 1
        prev[i] = j
      }
    }
  }

  for i := 0; i < elen; i++ {
    if max < dep[i] {
      max = dep[i]
      maxi = i
    }
  }

  i := maxi
  j := 0
  for {
    ret[j] = m[i][2]
    i = prev[i]
    if i == -1 {
      break
    }
    j++
  }

  fmt.Printf("%d\n", max)
  for i := j; i >= 0; i-- {
    fmt.Printf("%d ", ret[i]+1)
  }
}

func readInt() int {
  in.Scan()
  n, _ := strconv.Atoi(in.Text())
  return n
}


package main

import (
  "bufio"
  "fmt"
  "os"
  "sort"
  "strconv"
)

var in = bufio.NewScanner(os.Stdin)
var n, w, h int

func init() {
  in.Split(bufio.ScanWords)
}

type Matrix [][]int

func (m Matrix) Len() int { return n }
func (m Matrix) Less(i, j int) bool {
  return m[i][0] < m[j][0]
}

func (m Matrix) Swap(i, j int) { m[i], m[j] = m[j], m[i] }

func main() {
  maxSum, maxIdx := -1, -1
  n, w, h = readInt(), readInt(), readInt()
  dp := make([][]int, n)
  for i := range dp {
    dp[i] = make([]int, n)
  }

  e := make([][]int, n)
  for i := range e {
    e[i] = make([]int, 3)
  }

  for i := 0; i < n; i++ {
    e[i][0], e[i][1], e[i][2] = readInt(), readInt(), i
  }

  m := Matrix(e)
  sort.Sort(&m)

  for i := 0; i < n; i++ {
    if m[i][0] > w && m[i][1] > h {
      for j := i + 1; j < n; j++ {
        if m[j][0] > m[i][0] && m[j][1] > m[i][1] {
          dp[i][j] = 1
        }
      }
    }
  }

  for i := 0; i < n; i++ {
    sum := 0
    for j := 0; j < n; j++ {
      if dp[j][i] == 1 {
        sum++
      }
    }

    if maxSum < sum {
      maxSum = sum
      maxIdx = i
    }
  }

  fmt.Printf("%d\n", maxSum+1)
  for i := 0; i < n; i++ {
    if dp[i][maxIdx] == 1 {
      fmt.Printf("%d ", m[i][2]+1)
    }
  }
  fmt.Printf("%d\n", m[maxIdx][2]+1)
}

func readInt() int {
  in.Scan()
  n, _ := strconv.Atoi(in.Text())
  return n
}


package main

import (
  "bufio"
  "fmt"
  "os"
  "sort"
  "strconv"
)

var in = bufio.NewScanner(os.Stdin)
var n, w, h int

func init() {
  in.Split(bufio.ScanWords)
}

type Matrix [][]int

func (m Matrix) Len() int { return n }
func (m Matrix) Less(i, j int) bool {
  return m[i][0] < m[j][0]
}

func (m Matrix) Swap(i, j int) { m[i], m[j] = m[j], m[i] }

func main() {
  maxSum, maxIdx := -1, -1
  n, w, h = readInt(), readInt(), readInt()
  dp := make([][]int, n)
  for i := range dp {
    dp[i] = make([]int, n)
  }

  e := make([][]int, n)
  for i := range e {
    e[i] = make([]int, 3)
  }

  for i := 0; i < n; i++ {
    e[i][0], e[i][1], e[i][2] = readInt(), readInt(), i
  }

  m := Matrix(e)
  sort.Sort(&m)

  for i := 0; i < n; i++ {
    if m[i][0] > w && m[i][1] > h {
      dp[i][i] = 1
      for j := i + 1; j < n; j++ {
        if m[j][0] > m[i][0] && m[j][1] > m[i][1] {
          dp[i][j] = 1
        }
      }
    }
  }

  for i := 0; i < n; i++ {
    sum := 0
    for j := 0; j < n; j++ {
      if dp[j][i] == 1 {
        sum++
      }
    }

    if maxSum < sum {
      maxSum = sum
      maxIdx = i
    }
  }

  fmt.Printf("%d\n", maxSum)
  for i := 0; i < n; i++ {
    if dp[i][maxIdx] == 1 {
      fmt.Printf("%d ", m[i][2]+1)
    }
  }
}

func readInt() int {
  in.Scan()
  n, _ := strconv.Atoi(in.Text())
  return n
}


package main

import (
  "bufio"
  "fmt"
  "os"
  "sort"
  "strconv"
)

var in = bufio.NewScanner(os.Stdin)

var n, w, h, max, maxi, elen int
var e [5001][3]int
var dep [5001]int
var prev [5001]int
var ret [5001]int

type Matrix [5001][3]int

func init() {
  in.Split(bufio.ScanWords)
  for i := range dep {
    dep[i] = 1
  }

  for i := range prev {
    prev[i] = -1
  }
}

func (m Matrix) Len() int           { return elen }
func (m Matrix) Less(i, j int) bool { return m[i][0] < m[j][0] }
func (m *Matrix) Swap(i, j int)     { m[i], m[j] = m[j], m[i] }

func main() {
  n, w, h = readInt(), readInt(), readInt()

  for i := 0; i < n; i++ {
    tw, th := readInt(), readInt()
    if tw > w && th > h {
      e[elen][0], e[elen][1], e[elen][2] = tw, th, i
      elen++
    }
  }

  if elen == 0 {
    fmt.Println("0")
    return
  }

  m := Matrix(e)
  sort.Sort(&m)

  for i := 1; i < elen; i++ {
    for j := 0; j < i; j++ {
      if m[i][0] > m[j][0] && m[i][1] > m[j][1] && dep[i] < dep[j]+1 {
        dep[i] = dep[j] + 1
        prev[i] = j
      }
    }
  }

  for i := 0; i < elen; i++ {
    if max < dep[i] {
      max = dep[i]
      maxi = i
    }
  }

  i := maxi
  j := 0
  for {
    fmt.Println(m[i][0])
    ret[j] = m[i][2]
    i = prev[i]
    if i == -1 {
      break
    }
    j++
  }

  fmt.Printf("%d\n", max)
  for i := j; i >= 0; i-- {
    fmt.Printf("%d ", ret[i]+1)
  }
}

func readInt() int {
  in.Scan()
  n, _ := strconv.Atoi(in.Text())
  return n
}


package main

import (
  "bufio"
  "fmt"
  "os"
  "sort"
  "strconv"
)

var in = bufio.NewScanner(os.Stdin)

var n, w, h, max, maxi, elen int
var e [5001][3]int
var dep [5001]int
var prev [5001]int
var ret [5001]int

type Matrix [5001][3]int

func init() {
  in.Split(bufio.ScanWords)
  for i := range dep {
    dep[i] = 1
  }

  for i := range prev {
    prev[i] = -1
  }
}

func (m Matrix) Len() int           { return elen }
func (m Matrix) Less(i, j int) bool { return m[i][0] < m[j][0] }
func (m *Matrix) Swap(i, j int)     { m[i], m[j] = m[j], m[i] }

func main() {
  n, w, h = readInt(), readInt(), readInt()

  for i := 0; i < n; i++ {
    tw, th := readInt(), readInt()
    if tw > w && th > h {
      e[i][0], e[i][1], e[i][2] = tw, th, i
      elen++
    }
  }

  if elen == 0 {
    fmt.Println("0")
    return
  }

  m := Matrix(e)
  sort.Sort(&m)

  for i := 1; i < elen; i++ {
    for j := 0; j < i; j++ {
      if m[i][0] > m[j][0] && m[i][1] > m[j][1] && dep[i] < dep[j]+1 {
        dep[i] = dep[j] + 1
        prev[i] = j
      }
    }
  }

  for i := 0; i < elen; i++ {
    if max < dep[i] {
      max = dep[i]
      maxi = i
    }
  }

  i := maxi
  j := 0
  for {
    ret[j] = m[i][2]
    i = prev[i]
    if i == -1 {
      break
    }
    j++
  }

  fmt.Printf("%d\n", max)
  for i := j; i >= 0; i-- {
    fmt.Printf("%d ", ret[i])
  }
}

func readInt() int {
  in.Scan()
  n, _ := strconv.Atoi(in.Text())
  return n
}


package main

import (
  "bufio"
  "fmt"
  "os"
  "sort"
  "strconv"
)

var in = bufio.NewScanner(os.Stdin)
var n, w, h int

func init() {
  in.Split(bufio.ScanWords)
}

type Matrix [][]int

func (m Matrix) Len() int { return n }
func (m Matrix) Less(i, j int) bool {
  return m[i][0] < m[j][0]
}

func (m Matrix) Swap(i, j int) { m[i], m[j] = m[j], m[i] }

func main() {
  maxSum, maxIdx := -1, -1
  n, w, h = readInt(), readInt(), readInt()
  dp := make([][]int, 5010)
  for i := range dp {
    dp[i] = make([]int, 5010)
  }

  e := make([][]int, 5010)
  for i := range e {
    e[i] = make([]int, 3)
  }

  for i := 0; i < n; i++ {
    e[i][0], e[i][1], e[i][2] = readInt(), readInt(), i
  }

  m := Matrix(e)
  sort.Sort(&m)

  for i := 0; i < n; i++ {
    if m[i][0] > w && m[i][1] > h {
      for j := i + 1; j < n; j++ {
        if m[j][0] > m[i][0] && m[j][1] > m[i][1] {
          dp[i][j] = 1
        }
      }
    }
  }

  for i := 0; i < n; i++ {
    sum := 0
    for j := 0; j < n; j++ {
      if dp[j][i] == 1 {
        sum++
      }
    }

    if maxSum < sum {
      maxSum = sum
      maxIdx = i
    }
  }

  fmt.Printf("%d\n", maxSum+1)
  for i := 0; i < n; i++ {
    if dp[i][maxIdx] == 1 {
      fmt.Printf("%d ", m[i][2]+1)
    }
  }
  fmt.Printf("%d\n", m[maxIdx][2]+1)
}

func readInt() int {
  in.Scan()
  n, _ := strconv.Atoi(in.Text())
  return n
}


package main

import (
  "bufio"
  "fmt"
  "os"
  "sort"
  "strconv"
)

var in = bufio.NewScanner(os.Stdin)
var n, w, h int

func init() {
  in.Split(bufio.ScanWords)
}

type Matrix [5010][3]int

func (m Matrix) Len() int { return n }
func (m Matrix) Less(i, j int) bool {
  return m[i][0] < m[j][0]
}

func (m *Matrix) Swap(i, j int) { m[i], m[j] = m[j], m[i] }

func main() {
  var dp [5010][5010]int
  var e [5010][3]int
  maxSum, maxIdx := -1, -1
  n, w, h = readInt(), readInt(), readInt()

  for i := 0; i < n; i++ {
    e[i][0], e[i][1], e[i][2] = readInt(), readInt(), i
  }

  m := Matrix(e)
  sort.Sort(&m)

  for i := 0; i < n; i++ {
    if m[i][0] > w && m[i][1] > h {
      for j := i + 1; j < n; j++ {
        if m[j][0] > m[i][0] && m[j][1] > m[i][1] {
          dp[i][j] = 1
        }
      }
    }
  }

  for i := 0; i < n; i++ {
    sum := 0
    for j := 0; j < n; j++ {
      if dp[j][i] == 1 {
        sum++
      }
    }

    if maxSum < sum {
      maxSum = sum
      maxIdx = i
    }
  }

  fmt.Printf("%d\n", maxSum+1)
  for i := 0; i < n; i++ {
    if dp[i][maxIdx] == 1 {
      fmt.Printf("%d ", m[i][2]+1)
    }
  }
  fmt.Printf("%d\n", m[maxIdx][2]+1)

}

func readInt() int {
  in.Scan()
  n, _ := strconv.Atoi(in.Text())
  return n
}


package main

import (
  "bufio"
  "fmt"
  "os"
  "sort"
  "strconv"
)

var in = bufio.NewScanner(os.Stdin)

var n, w, h, max, maxi int
var e [5001][3]int
var dep [5001]int
var prev [5001]int
var ret [5001]int

type Matrix [5001][3]int

func init() {
  in.Split(bufio.ScanWords)
  for i := range dep {
    dep[i] = 1
  }

  for i := range prev {
    prev[i] = -1
  }
}

func (m Matrix) Len() int           { return n }
func (m Matrix) Less(i, j int) bool { return m[i][0] < m[j][0] }
func (m *Matrix) Swap(i, j int)     { m[i], m[j] = m[j], m[i] }

func main() {
  n, w, h = readInt(), readInt(), readInt()

  for i := 0; i < n; i++ {
    tw, th := readInt(), readInt()
    if tw > w && th > h {
      e[i][0], e[i][1], e[i][2] = tw, th, i
    }
  }

  if e[0][0] == 0 {
    fmt.Println("0")
    return
  }

  m := Matrix(e)
  sort.Sort(&m)

  for i := 1; i < n; i++ {
    for j := 0; j < i; j++ {
      if m[i][0] > m[j][0] && m[i][1] > m[j][1] && dep[i] < dep[j]+1 {
        dep[i] = dep[j] + 1
        prev[i] = j
      }
    }
  }

  for i := 0; i < n; i++ {
    if max < dep[i] {
      max = dep[i]
      maxi = i
    }
  }

  i := maxi
  j := 0
  for {
    ret[j] = m[i][2]
    i = prev[i]
    if i == -1 {
      break
    }
    j++
  }

  fmt.Printf("%d\n", max)
  for i := j; i >= 0; i-- {
    fmt.Printf("%d ", ret[i]+1)
  }
}

func readInt() int {
  in.Scan()
  n, _ := strconv.Atoi(in.Text())
  return n
}


package main

import (
  "bufio"
  "fmt"
  "os"
  "sort"
  "strconv"
)

var in = bufio.NewScanner(os.Stdin)

var n, w, h, max, maxi, elen int
var e [5001][3]int
var dep [5001]int
var prev [5001]int
var ret [5001]int

type Matrix [5001][3]int

func init() {
  in.Split(bufio.ScanWords)
  for i := range dep {
    dep[i] = 1
  }

  for i := range prev {
    prev[i] = -1
  }
}

func (m Matrix) Len() int           { return elen }
func (m Matrix) Less(i, j int) bool { return m[i][0] < m[j][0] }
func (m *Matrix) Swap(i, j int)     { m[i], m[j] = m[j], m[i] }

func main() {
  n, w, h = readInt(), readInt(), readInt()

  for i := 0; i < n; i++ {
    tw, th := readInt(), readInt()
    if tw > w && th > h {
      e[elen][0], e[elen][1], e[elen][2] = tw, th, i
      elen++
    }
  }

  if elen == 0 {
    fmt.Println("0")
    return
  }

  m := Matrix(e)
  sort.Sort(&m)

  for i := 1; i < elen; i++ {
    for j := 0; j < i; j++ {
      if m[i][0] > m[j][0] && m[i][1] > m[j][1] && dep[i] < dep[j]+1 {
        dep[i] = dep[j] + 1
        prev[i] = j
      }
    }
  }

  for i := 0; i < elen; i++ {
    if max < dep[i] {
      max = dep[i]
      maxi = i
    }
  }

  i := maxi
  j := 0
  for {
    ret[j] = m[i][2]
    i = prev[i]
    if i == -1 {
      break
    }
    j++
  }

  fmt.Printf("%d\n", max)
  for i := j; i >= 0; i-- {
    fmt.Printf("%d ", ret[i]+1)
  }
}

func readInt() int {
  in.Scan()
  n, _ := strconv.Atoi(in.Text())
  return n
}


package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"sort"
	"strings"
)

var reader = bufio.NewReader(os.Stdin)
var writer = bufio.NewWriter(os.Stdout)

func printf(f string, a ...interface{}) {
	_, err := fmt.Fprintf(writer, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func scanf(f string, a ...interface{}) {
	_, err := fmt.Fscanf(reader, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func readline() string {
	name, err := reader.ReadString('\n')
	if err != nil {
		log.Fatal(err)
	}

	name = strings.TrimRight(name, "\r\n")

	return name
}

func flush() {
	err := writer.Flush()
	if err != nil {
		log.Fatal(err)
	}
}

var debug = false

func main() {
	defer flush()
	var n, w, h int
	scanf("%d %d %d\n", &n, &w, &h)

	//if n == 6 && w == 1 && h == 1 {
	//	debug = true
	//}

	type envelope struct {
		w, h int
	}

	envs := make([]envelope, 0, n)
	envIdxMap := make(map[envelope]int)

	for i := 0; i < n; i++ {
		var ew, eh int
		scanf("%d %d\n", &ew, &eh)
		if ew <= w || eh <= h {
			continue
		}

		env := envelope{ew, eh}

		if _, ok := envIdxMap[env]; !ok {
			envIdxMap[env] = i
			envs = append(envs, env)
		}
	}

	if debug {
		printf("bits: %d\n", (32 << (^uint(0) >> 63)))
		printf("%v\n", envIdxMap)
		printf("%v\n", envs)
	}

	sort.Slice(envs, func(i, j int) bool {
		return int64(envs[i].w)*int64(envs[i].h) < int64(envs[j].w)*int64(envs[j].h) && envs[i].w <= envs[j].w && envs[i].h <= envs[j].h
	})

	if debug {
		printf("%v\n", envs)
	}
	idxList := make([]int, 0, len(envs))

	lastEnv := 0
	for i := 0; i < len(envs); i++ {
		if i > 0 && (envs[i].w <= envs[lastEnv].w || envs[i].h <= envs[lastEnv].h) {
			continue
		}
		idxList = append(idxList, envIdxMap[envs[i]]+1)
		lastEnv = i
	}

	printf("%d\n", len(idxList))
	for i := 0; i < len(idxList); i++ {
		printf("%d ", idxList[i])
		if i == len(idxList)-1 {
			printf("\n")
		}
	}
}


package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"sort"
	"strings"
)

var reader = bufio.NewReader(os.Stdin)
var writer = bufio.NewWriter(os.Stdout)

func printf(f string, a ...interface{}) {
	_, err := fmt.Fprintf(writer, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func scanf(f string, a ...interface{}) {
	_, err := fmt.Fscanf(reader, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func readline() string {
	name, err := reader.ReadString('\n')
	if err != nil {
		log.Fatal(err)
	}

	name = strings.TrimRight(name, "\r\n")

	return name
}

func flush() {
	err := writer.Flush()
	if err != nil {
		log.Fatal(err)
	}
}

var debug = false

func main() {
	defer flush()
	var n, w, h int
	scanf("%d %d %d\n", &n, &w, &h)

	if n == 6 && w == 1 && h == 1 {
		debug = true
	}

	type envelope struct {
		w, h int
	}

	envs := make([]envelope, 0, n)
	envIdxMap := make(map[envelope]int)

	for i := 0; i < n; i++ {
		var ew, eh int
		scanf("%d %d\n", &ew, &eh)
		if ew <= w || eh <= h {
			continue
		}

		env := envelope{ew, eh}

		if _, ok := envIdxMap[env]; !ok {
			envIdxMap[env] = i
			envs = append(envs, env)
		}
	}

	if debug {
		printf("bits: %d\n", (32 << (^uint(0) >> 63)))
		printf("%v\n", envIdxMap)
		printf("%v\n", envs)
	}

	sort.Slice(envs, func(i, j int) bool {
		//return envs[i].w < envs[j].w && envs[i].h < envs[j].h
		return envs[i].w*envs[i].h < envs[j].w*envs[j].h
	})
	if debug {
		printf("%v\n", envs)
	}
	idxList := make([]int, 0, len(envs))

	lastEnv := 0
	for i := 0; i < len(envs); i++ {
		if i > 0 && (envs[i].w <= envs[lastEnv].w || envs[i].h <= envs[lastEnv].h) {
			continue
		}
		idxList = append(idxList, envIdxMap[envs[i]]+1)
		lastEnv = i
	}

	printf("%d\n", len(idxList))
	for i := 0; i < len(idxList); i++ {
		printf("%d ", idxList[i])
		if i == len(idxList)-1 {
			printf("\n")
		}
	}
}


package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"sort"
	"strings"
)

var reader = bufio.NewReader(os.Stdin)
var writer = bufio.NewWriter(os.Stdout)

func printf(f string, a ...interface{}) {
	_, err := fmt.Fprintf(writer, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func scanf(f string, a ...interface{}) {
	_, err := fmt.Fscanf(reader, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func readline() string {
	name, err := reader.ReadString('\n')
	if err != nil {
		log.Fatal(err)
	}

	name = strings.TrimRight(name, "\r\n")

	return name
}

func flush() {
	err := writer.Flush()
	if err != nil {
		log.Fatal(err)
	}
}

var debug = false

func main() {
	defer flush()
	var n, w, h int
	scanf("%d %d %d\n", &n, &w, &h)

	if n == 6 && w == 1 && h == 1 {
		debug = true
	}

	type envelope struct {
		w, h int
	}

	envs := make([]envelope, 0, n)
	envIdxMap := make(map[envelope]int)

	for i := 0; i < n; i++ {
		var ew, eh int
		scanf("%d %d\n", &ew, &eh)
		if ew <= w || eh <= h {
			continue
		}

		env := envelope{ew, eh}

		if _, ok := envIdxMap[env]; !ok {
			envIdxMap[env] = i
			envs = append(envs, env)
		}
	}

	if debug {
		printf("%v\n", envIdxMap)
		printf("%v\n", envs)
	}

	sort.Slice(envs, func(i, j int) bool {
		//return envs[i].w < envs[j].w && envs[i].h < envs[j].h
		return envs[i].w*envs[i].h < envs[j].w*envs[j].h
	})
	if debug {
		printf("%v\n", envs)
	}
	idxList := make([]int, 0, len(envs))

	lastEnv := 0
	for i := 0; i < len(envs); i++ {
		if i > 0 && (envs[i].w <= envs[lastEnv].w || envs[i].h <= envs[lastEnv].h) {
			continue
		}
		idxList = append(idxList, envIdxMap[envs[i]]+1)
		lastEnv = i
	}

	printf("%d\n", len(idxList))
	for i := 0; i < len(idxList); i++ {
		printf("%d ", idxList[i])
		if i == len(idxList)-1 {
			printf("\n")
		}
	}
}


package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"sort"
	"strings"
)

var reader = bufio.NewReader(os.Stdin)
var writer = bufio.NewWriter(os.Stdout)

func printf(f string, a ...interface{}) {
	_, err := fmt.Fprintf(writer, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func scanf(f string, a ...interface{}) {
	_, err := fmt.Fscanf(reader, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func readline() string {
	name, err := reader.ReadString('\n')
	if err != nil {
		log.Fatal(err)
	}

	name = strings.TrimRight(name, "\r\n")

	return name
}

func flush() {
	err := writer.Flush()
	if err != nil {
		log.Fatal(err)
	}
}

func main() {
	defer flush()
	var n, w, h int
	scanf("%d %d %d\n", &n, &w, &h)

	type envelope struct {
		w, h int
	}

	envs := make([]envelope, 0, n)
	envIdxMap := make(map[envelope]int)

	for i := 0; i < n; i++ {
		var ew, eh int
		scanf("%d %d\n", &ew, &eh)
		if ew <= w || eh <= h {
			continue
		}

		env := envelope{ew, eh}

		if _, ok := envIdxMap[env]; !ok {
			envIdxMap[env] = i
			envs = append(envs, env)
		}
	}

	//printf("%v\n", envs)
	sort.Slice(envs, func(i, j int) bool {
		//return envs[i].w < envs[j].w && envs[i].h < envs[j].h
		return envs[i].w*envs[i].h < envs[j].w*envs[j].h
	})
	//printf("%v\n", envs)
	idxList := make([]int, 0, len(envs))

	lastIdx := 0
	for i := 0; i < len(envs); i++ {
		if i > 0 && (envs[i].w <= envs[lastIdx].w || envs[i].h <= envs[lastIdx].h) {
			continue
		}
		idxList = append(idxList, envIdxMap[envs[i]]+1)
		lastIdx = i
	}

	printf("%d\n", len(idxList))
	for i := 0; i < len(idxList); i++ {
		printf("%d ", idxList[i])
		if i == len(idxList)-1 {
			printf("\n")
		}
	}
}


package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"sort"
	"strings"
)

var reader = bufio.NewReader(os.Stdin)
var writer = bufio.NewWriter(os.Stdout)

func printf(f string, a ...interface{}) {
	_, err := fmt.Fprintf(writer, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func scanf(f string, a ...interface{}) {
	_, err := fmt.Fscanf(reader, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func readline() string {
	name, err := reader.ReadString('\n')
	if err != nil {
		log.Fatal(err)
	}

	name = strings.TrimRight(name, "\r\n")

	return name
}

func flush() {
	err := writer.Flush()
	if err != nil {
		log.Fatal(err)
	}
}

func main() {
	defer flush()
	var n, w, h int
	scanf("%d %d %d\n", &n, &w, &h)

	type envelope struct {
		w, h int
	}

	envs := make([]envelope, 0, n)
	envIdxMap := make(map[envelope]int)

	for i := 0; i < n; i++ {
		var ew, eh int
		scanf("%d %d\n", &ew, &eh)
		if ew <= w || eh <= h {
			continue
		}

		env := envelope{ew, eh}

		if _, ok := envIdxMap[env]; !ok {
			envIdxMap[env] = i
			envs = append(envs, env)
		}
	}

	sort.Slice(envs, func(i, j int) bool {
		return envs[i].w < envs[j].w && envs[i].h < envs[j].h
	})

	idxList := make([]int, 0, len(envs))

	for i := 0; i < len(envs); i++ {
		if i > 0 && (envs[i].w <= envs[i-1].w || envs[i].h <= envs[i-1].h) {
			continue
		}
		idxList = append(idxList, envIdxMap[envs[i]]+1)
	}

	printf("%d\n", len(idxList))
	for i := 0; i < len(idxList); i++ {
		printf("%d ", idxList[i])
		if i == len(idxList)-1 {
			printf("\n")
		}
	}
}


package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"sort"
	"strings"
)

var reader = bufio.NewReader(os.Stdin)
var writer = bufio.NewWriter(os.Stdout)

func printf(f string, a ...interface{}) {
	_, err := fmt.Fprintf(writer, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func scanf(f string, a ...interface{}) {
	_, err := fmt.Fscanf(reader, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func readline() string {
	name, err := reader.ReadString('\n')
	if err != nil {
		log.Fatal(err)
	}

	name = strings.TrimRight(name, "\r\n")

	return name
}

func flush() {
	err := writer.Flush()
	if err != nil {
		log.Fatal(err)
	}
}

var debug = false

func main() {
	defer flush()
	var n, w, h int
	scanf("%d %d %d\n", &n, &w, &h)

	//if n == 6 && w == 1 && h == 1 {
	//	debug = true
	//}

	type envelope struct {
		w, h int
	}

	envs := make([]envelope, 0, n)
	envIdxMap := make(map[envelope]int)

	for i := 0; i < n; i++ {
		var ew, eh int
		scanf("%d %d\n", &ew, &eh)
		if ew <= w || eh <= h {
			continue
		}

		env := envelope{ew, eh}

		if _, ok := envIdxMap[env]; !ok {
			envIdxMap[env] = i
			envs = append(envs, env)
		}
	}

	if debug {
		printf("bits: %d\n", (32 << (^uint(0) >> 63)))
		printf("%v\n", envIdxMap)
		printf("%v\n", envs)
	}

	sort.Slice(envs, func(i, j int) bool {
		//return envs[i].w < envs[j].w && envs[i].h < envs[j].h
		return int64(envs[i].w)*int64(envs[i].h) < int64(envs[j].w)*int64(envs[j].h)
	})
	if debug {
		printf("%v\n", envs)
	}
	idxList := make([]int, 0, len(envs))

	lastEnv := 0
	for i := 0; i < len(envs); i++ {
		if i > 0 && (envs[i].w <= envs[lastEnv].w || envs[i].h <= envs[lastEnv].h) {
			continue
		}
		idxList = append(idxList, envIdxMap[envs[i]]+1)
		lastEnv = i
	}

	printf("%d\n", len(idxList))
	for i := 0; i < len(idxList); i++ {
		printf("%d ", idxList[i])
		if i == len(idxList)-1 {
			printf("\n")
		}
	}
}


package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"sort"
	"strings"
)

var reader = bufio.NewReader(os.Stdin)
var writer = bufio.NewWriter(os.Stdout)

func printf(f string, a ...interface{}) {
	_, err := fmt.Fprintf(writer, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func scanf(f string, a ...interface{}) {
	_, err := fmt.Fscanf(reader, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func readline() string {
	name, err := reader.ReadString('\n')
	if err != nil {
		log.Fatal(err)
	}

	name = strings.TrimRight(name, "\r\n")

	return name
}

func flush() {
	err := writer.Flush()
	if err != nil {
		log.Fatal(err)
	}
}

var debug = false

type envelope struct {
	w, h int
}

func readEnvs(n, w, h int) ([]envelope, map[envelope]int) {
	envs := make([]envelope, 0, n)
	envIdxMap := make(map[envelope]int)

	for i := 0; i < n; i++ {
		var ew, eh int
		scanf("%d %d\n", &ew, &eh)
		if ew <= w || eh <= h {
			continue
		}

		env := envelope{ew, eh}

		if _, ok := envIdxMap[env]; !ok {
			envIdxMap[env] = i
			envs = append(envs, env)
		}
	}

	return envs, envIdxMap
}

func findlis(envs []envelope) []int {
	lis := make([]int, len(envs))
	parent := make([]int, len(envs))

	globalMaxLisIdx := 0

	for i := 0; i < len(envs); i++ {
		maxLis := lis[i]
		maxLisIdx := -1
		for j := 0; j < i; j++ {
			if envs[i].w > envs[j].w && envs[i].h > envs[j].h && lis[j] >= maxLis {
				maxLis = lis[j]
				maxLisIdx = j
			}
		}

		lis[i] = maxLis + 1
		parent[i] = maxLisIdx

		if lis[globalMaxLisIdx] <= lis[i] {
			globalMaxLisIdx = i
		}
	}

	idxList := make([]int, 0)
	for idx := globalMaxLisIdx; idx != -1; {
		idxList = append(idxList, idx)
		idx = parent[idx]
	}

	return idxList
}

func main() {
	defer flush()
	var n, w, h int
	scanf("%d %d %d\n", &n, &w, &h)

	envs, envIdxMap := readEnvs(n, w, h)

	if len(envs) == 0 {
		printf("0\n")
		return
	}

	if debug {
		printf("bits: %d\n", (32 << (^uint(0) >> 63)))
		printf("%v\n", envIdxMap)
		printf("%v\n", envs)
	}

	sort.Slice(envs, func(i, j int) bool {
		return envs[i].w < envs[j].w || ((envs[i].w == envs[j].w) && envs[i].h <= envs[j].h)
		//return int64(envs[i].w)*int64(envs[i].h) < int64(envs[j].w)*int64(envs[j].h) && envs[i].w <= envs[j].w && envs[i].h <= envs[j].h
	})

	if debug {
		printf("%v\n", envs)
	}

	idxList := findlis(envs)

	printf("%d\n", len(idxList))
	for i := len(idxList) - 1; i >= 0; i-- {
		if debug {
			printf("%d (%v) ", envIdxMap[envs[idxList[i]]]+1, envs[idxList[i]])
		} else {
			printf("%d ", envIdxMap[envs[idxList[i]]]+1)
		}
		if i == 0 {
			printf("\n")
		}
	}
}


package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"sort"
	"strings"
)

var reader = bufio.NewReader(os.Stdin)
var writer = bufio.NewWriter(os.Stdout)

func printf(f string, a ...interface{}) {
	_, err := fmt.Fprintf(writer, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func scanf(f string, a ...interface{}) {
	_, err := fmt.Fscanf(reader, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func readline() string {
	name, err := reader.ReadString('\n')
	if err != nil {
		log.Fatal(err)
	}

	name = strings.TrimRight(name, "\r\n")

	return name
}

func flush() {
	err := writer.Flush()
	if err != nil {
		log.Fatal(err)
	}
}

var debug = false

type envelope struct {
	w, h int
}

func readEnvs(n, w, h int) ([]envelope, map[envelope]int) {
	envs := make([]envelope, 0, n)
	envIdxMap := make(map[envelope]int)

	for i := 0; i < n; i++ {
		var ew, eh int
		scanf("%d %d\n", &ew, &eh)
		if ew <= w || eh <= h {
			continue
		}

		env := envelope{ew, eh}

		if _, ok := envIdxMap[env]; !ok {
			envIdxMap[env] = i
			envs = append(envs, env)
		}
	}

	return envs, envIdxMap
}

func findlis(envs []envelope) []int {
	lis := make([]int, len(envs))
	parent := make([]int, len(envs))

	globalMaxLisIdx := 0

	for i := 0; i < len(envs); i++ {
		maxLis := lis[i]
		maxLisIdx := -1
		for j := 0; j < i; j++ {
			if envs[i].w > envs[j].w && envs[i].h > envs[j].h && lis[j] > maxLis {
				maxLis = lis[j]
				maxLisIdx = j
			}
		}

		lis[i] = maxLis + 1
		parent[i] = maxLisIdx

		if lis[globalMaxLisIdx] < lis[i] {
			globalMaxLisIdx = i
		}
	}

	idxList := make([]int, 0)
	for idx := globalMaxLisIdx; idx != -1; {
		idxList = append(idxList, idx)
		idx = parent[idx]
	}

	return idxList
}

func main() {
	defer flush()
	var n, w, h int
	scanf("%d %d %d\n", &n, &w, &h)

	envs, envIdxMap := readEnvs(n, w, h)

	if len(envs) == 0 {
		printf("0\n")
		return
	}

	if debug {
		printf("bits: %d\n", (32 << (^uint(0) >> 63)))
		printf("%v\n", envIdxMap)
		printf("%v\n", envs)
	}

	sort.Slice(envs, func(i, j int) bool {
		return envs[i].w <= envs[j].w && envs[i].h <= envs[j].h
	})

	if debug {
		printf("%v\n", envs)
	}

	idxList := findlis(envs)

	printf("%d\n", len(idxList))
	for i := len(idxList) - 1; i >= 0; i-- {
		if debug {
			printf("%d (%v) ", envIdxMap[envs[idxList[i]]]+1, envs[idxList[i]])
		} else {
			printf("%d ", envIdxMap[envs[idxList[i]]]+1)
		}
		if i == 0 {
			printf("\n")
		}
	}
}


package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"sort"
	"strings"
)

var reader = bufio.NewReader(os.Stdin)
var writer = bufio.NewWriter(os.Stdout)

func printf(f string, a ...interface{}) {
	_, err := fmt.Fprintf(writer, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func scanf(f string, a ...interface{}) {
	_, err := fmt.Fscanf(reader, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func readline() string {
	name, err := reader.ReadString('\n')
	if err != nil {
		log.Fatal(err)
	}

	name = strings.TrimRight(name, "\r\n")

	return name
}

func flush() {
	err := writer.Flush()
	if err != nil {
		log.Fatal(err)
	}
}

var debug = false

type envelope struct {
	w, h int
}

func readEnvs(n, w, h int) ([]envelope, map[envelope]int) {
	envs := make([]envelope, 0, n)
	envIdxMap := make(map[envelope]int)

	for i := 0; i < n; i++ {
		var ew, eh int
		scanf("%d %d\n", &ew, &eh)
		if ew <= w || eh <= h {
			continue
		}

		env := envelope{ew, eh}

		if _, ok := envIdxMap[env]; !ok {
			envIdxMap[env] = i
			envs = append(envs, env)
		}
	}

	return envs, envIdxMap
}

func findlis(envs []envelope) []int {
	lis := make([]int, len(envs))
	parent := make([]int, len(envs))

	globalMaxLisIdx := 0

	for i := 0; i < len(envs); i++ {
		maxLis := lis[i]
		maxLisIdx := -1
		for j := 0; j < i; j++ {
			if envs[i].w > envs[j].w && envs[i].h > envs[j].h && lis[j] >= maxLis {
				maxLis = lis[j]
				maxLisIdx = j
			}
		}

		lis[i] = maxLis + 1
		parent[i] = maxLisIdx

		if lis[globalMaxLisIdx] <= lis[i] {
			globalMaxLisIdx = i
		}
	}

	idxList := make([]int, 0)
	for idx := globalMaxLisIdx; idx != -1; {
		idxList = append(idxList, idx)
		idx = parent[idx]
	}

	return idxList
}

func main() {
	defer flush()
	var n, w, h int
	scanf("%d %d %d\n", &n, &w, &h)

	envs, envIdxMap := readEnvs(n, w, h)

	if len(envs) == 0 {
		printf("0\n")
		return
	}

	if debug {
		printf("bits: %d\n", (32 << (^uint(0) >> 63)))
		printf("%v\n", envIdxMap)
		printf("%v\n", envs)
	}

	sort.Slice(envs, func(i, j int) bool {
		return int64(envs[i].w)*int64(envs[i].h) < int64(envs[j].w)*int64(envs[j].h) && envs[i].w <= envs[j].w && envs[i].h <= envs[j].h
	})

	if debug {
		printf("%v\n", envs)
	}

	idxList := findlis(envs)

	printf("%d\n", len(idxList))
	for i := len(idxList) - 1; i >= 0; i-- {
		if debug {
			printf("%d (%v) ", envIdxMap[envs[idxList[i]]]+1, envs[idxList[i]])
		} else {
			printf("%d ", envIdxMap[envs[idxList[i]]]+1)
		}
		if i == 0 {
			printf("\n")
		}
	}
}


package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"sort"
	"strings"
)

var reader = bufio.NewReader(os.Stdin)
var writer = bufio.NewWriter(os.Stdout)

func printf(f string, a ...interface{}) {
	_, err := fmt.Fprintf(writer, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func scanf(f string, a ...interface{}) {
	_, err := fmt.Fscanf(reader, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func readline() string {
	name, err := reader.ReadString('\n')
	if err != nil {
		log.Fatal(err)
	}

	name = strings.TrimRight(name, "\r\n")

	return name
}

func flush() {
	err := writer.Flush()
	if err != nil {
		log.Fatal(err)
	}
}

var debug = false

type envelope struct {
	w, h int
}

func readEnvs(n, w, h int) ([]envelope, map[envelope]int) {
	envs := make([]envelope, 0, n)
	envIdxMap := make(map[envelope]int)

	for i := 0; i < n; i++ {
		var ew, eh int
		scanf("%d %d\n", &ew, &eh)
		if ew <= w || eh <= h {
			continue
		}

		env := envelope{ew, eh}

		if _, ok := envIdxMap[env]; !ok {
			envIdxMap[env] = i
			envs = append(envs, env)
		}
	}

	return envs, envIdxMap
}

func findlis(envs []envelope) []int {
	lis := make([]int, len(envs))
	parent := make([]int, len(envs))

	globalMaxLisIdx := 0

	for i := 0; i < len(envs); i++ {
		maxLis := lis[i]
		maxLisIdx := -1
		for j := 0; j < i; j++ {
			if envs[i].w > envs[j].w && envs[i].h > envs[j].h && lis[j] > maxLis {
				maxLis = lis[j]
				maxLisIdx = j
			}
		}

		lis[i] = maxLis + 1
		parent[i] = maxLisIdx

		if lis[globalMaxLisIdx] < lis[i] {
			globalMaxLisIdx = i
		}
	}

	idxList := make([]int, 0)
	for idx := globalMaxLisIdx; idx != -1; {
		idxList = append(idxList, idx)
		idx = parent[idx]
	}

	return idxList
}

func main() {
	defer flush()
	var n, w, h int
	scanf("%d %d %d\n", &n, &w, &h)

	envs, envIdxMap := readEnvs(n, w, h)

	if debug {
		printf("bits: %d\n", (32 << (^uint(0) >> 63)))
		printf("%v\n", envIdxMap)
		printf("%v\n", envs)
	}

	sort.Slice(envs, func(i, j int) bool {
		return envs[i].w <= envs[j].w && envs[i].h <= envs[j].h
	})

	if debug {
		printf("%v\n", envs)
	}

	idxList := findlis(envs)

	for i := len(idxList) - 1; i >= 0; i-- {
		if debug {
			printf("%d (%v) ", envIdxMap[envs[idxList[i]]]+1, envs[idxList[i]])
		} else {
			printf("%d ", envIdxMap[envs[idxList[i]]]+1)
		}
		if i == 0 {
			printf("\n")
		}
	}
}


package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"sort"
	"strings"
)

var reader = bufio.NewReader(os.Stdin)
var writer = bufio.NewWriter(os.Stdout)

func printf(f string, a ...interface{}) {
	_, err := fmt.Fprintf(writer, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func scanf(f string, a ...interface{}) {
	_, err := fmt.Fscanf(reader, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func readline() string {
	name, err := reader.ReadString('\n')
	if err != nil {
		log.Fatal(err)
	}

	name = strings.TrimRight(name, "\r\n")

	return name
}

func flush() {
	err := writer.Flush()
	if err != nil {
		log.Fatal(err)
	}
}

func main() {
	defer flush()
	var n, w, h int
	scanf("%d %d %d\n", &n, &w, &h)

	type envelope struct {
		w, h int
	}

	envs := make([]envelope, 0, n)
	envIdxMap := make(map[envelope]int)

	for i := 0; i < n; i++ {
		var ew, eh int
		scanf("%d %d\n", &ew, &eh)
		if ew <= w || eh <= h {
			continue
		}

		env := envelope{ew, eh}

		if _, ok := envIdxMap[env]; !ok {
			envIdxMap[env] = i
			envs = append(envs, env)
		}
	}

	//printf("%v\n", envs)
	sort.Slice(envs, func(i, j int) bool {
		//return envs[i].w < envs[j].w && envs[i].h < envs[j].h
		return envs[i].w*envs[i].h < envs[j].w*envs[j].h
	})

	//printf("%v\n", envs)

	idxList := make([]int, 0, len(envs))

	lastIdx := 0
	for i := 0; i < len(envs); i++ {
		if i > 0 && (envs[i].w <= envs[lastIdx].w || envs[i].h <= envs[lastIdx].h) {
			continue
		}
		idxList = append(idxList, envIdxMap[envs[i]]+1)
		lastIdx = i
	}

	printf("%d\n", len(idxList))
	for i := 0; i < len(idxList); i++ {
		printf("%d ", idxList[i])
		if i == len(idxList)-1 {
			printf("\n")
		}
	}
}


package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"sort"
	"strings"
)

var reader = bufio.NewReader(os.Stdin)
var writer = bufio.NewWriter(os.Stdout)

func printf(f string, a ...interface{}) {
	_, err := fmt.Fprintf(writer, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func scanf(f string, a ...interface{}) {
	_, err := fmt.Fscanf(reader, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func readline() string {
	name, err := reader.ReadString('\n')
	if err != nil {
		log.Fatal(err)
	}

	name = strings.TrimRight(name, "\r\n")

	return name
}

func flush() {
	err := writer.Flush()
	if err != nil {
		log.Fatal(err)
	}
}

var debug = false

func main() {
	defer flush()
	var n, w, h int
	scanf("%d %d %d\n", &n, &w, &h)

	//if n == 6 && w == 1 && h == 1 {
	//	debug = true
	//}

	type envelope struct {
		w, h int
	}

	envs := make([]envelope, 0, n)
	envIdxMap := make(map[envelope]int)

	for i := 0; i < n; i++ {
		var ew, eh int
		scanf("%d %d\n", &ew, &eh)
		if ew <= w || eh <= h {
			continue
		}

		env := envelope{ew, eh}

		if _, ok := envIdxMap[env]; !ok {
			envIdxMap[env] = i
			envs = append(envs, env)
		}
	}

	if debug {
		printf("bits: %d\n", (32 << (^uint(0) >> 63)))
		printf("%v\n", envIdxMap)
		printf("%v\n", envs)
	}

	sort.Slice(envs, func(i, j int) bool {
		return int64(envs[i].w)*int64(envs[i].h) < int64(envs[j].w)*int64(envs[j].h) && envs[i].w < envs[j].w && envs[i].h < envs[j].h
	})

	if debug {
		printf("%v\n", envs)
	}
	idxList := make([]int, 0, len(envs))

	lastEnv := 0
	for i := 0; i < len(envs); i++ {
		if i > 0 && (envs[i].w <= envs[lastEnv].w || envs[i].h <= envs[lastEnv].h) {
			continue
		}
		idxList = append(idxList, envIdxMap[envs[i]]+1)
		lastEnv = i
	}

	printf("%d\n", len(idxList))
	for i := 0; i < len(idxList); i++ {
		printf("%d ", idxList[i])
		if i == len(idxList)-1 {
			printf("\n")
		}
	}
}


package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"sort"
	"strings"
)

var reader = bufio.NewReader(os.Stdin)
var writer = bufio.NewWriter(os.Stdout)

func printf(f string, a ...interface{}) {
	_, err := fmt.Fprintf(writer, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func scanf(f string, a ...interface{}) {
	_, err := fmt.Fscanf(reader, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func readline() string {
	name, err := reader.ReadString('\n')
	if err != nil {
		log.Fatal(err)
	}

	name = strings.TrimRight(name, "\r\n")

	return name
}

func flush() {
	err := writer.Flush()
	if err != nil {
		log.Fatal(err)
	}
}

var debug = false

type envelope struct {
	w, h int
}

func readEnvs(n, w, h int) ([]envelope, map[envelope]int) {
	envs := make([]envelope, 0, n)
	envIdxMap := make(map[envelope]int)

	for i := 0; i < n; i++ {
		var ew, eh int
		scanf("%d %d\n", &ew, &eh)
		if ew <= w || eh <= h {
			continue
		}

		env := envelope{ew, eh}

		if _, ok := envIdxMap[env]; !ok {
			envIdxMap[env] = i
			envs = append(envs, env)
		}
	}

	return envs, envIdxMap
}

func findlis(envs []envelope) []int {
	lis := make([]int, len(envs))
	parent := make([]int, len(envs))

	globalMaxLisIdx := 0

	for i := 0; i < len(envs); i++ {
		maxLis := lis[i]
		maxLisIdx := -1
		for j := 0; j < i; j++ {
			if envs[i].w > envs[j].w && envs[i].h > envs[j].h && lis[j] > maxLis {
				maxLis = lis[j]
				maxLisIdx = j
			}
		}

		lis[i] = maxLis + 1
		parent[i] = maxLisIdx

		if lis[globalMaxLisIdx] < lis[i] {
			globalMaxLisIdx = i
		}
	}

	idxList := make([]int, 0)
	for idx := globalMaxLisIdx; idx != -1; {
		idxList = append(idxList, idx)
		idx = parent[idx]
	}

	return idxList
}

func main() {
	defer flush()
	var n, w, h int
	scanf("%d %d %d\n", &n, &w, &h)

	envs, envIdxMap := readEnvs(n, w, h)

	if len(envs) == 0 {
		printf("0\n")
		return
	}

	if debug {
		printf("bits: %d\n", (32 << (^uint(0) >> 63)))
		printf("%v\n", envIdxMap)
		printf("%v\n", envs)
	}

	sort.Slice(envs, func(i, j int) bool {
		return envs[i].w < envs[j].w && envs[i].h < envs[j].h
	})

	if debug {
		printf("%v\n", envs)
	}

	idxList := findlis(envs)

	printf("%d\n", len(idxList))
	for i := len(idxList) - 1; i >= 0; i-- {
		if debug {
			printf("%d (%v) ", envIdxMap[envs[idxList[i]]]+1, envs[idxList[i]])
		} else {
			printf("%d ", envIdxMap[envs[idxList[i]]]+1)
		}
		if i == 0 {
			printf("\n")
		}
	}
}


package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"sort"
	"strings"
)

var reader = bufio.NewReader(os.Stdin)
var writer = bufio.NewWriter(os.Stdout)

func printf(f string, a ...interface{}) {
	_, err := fmt.Fprintf(writer, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func scanf(f string, a ...interface{}) {
	_, err := fmt.Fscanf(reader, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func readline() string {
	name, err := reader.ReadString('\n')
	if err != nil {
		log.Fatal(err)
	}

	name = strings.TrimRight(name, "\r\n")

	return name
}

func flush() {
	err := writer.Flush()
	if err != nil {
		log.Fatal(err)
	}
}

func main() {
	defer flush()
	var n, w, h int
	scanf("%d %d %d\n", &n, &w, &h)

	type envelope struct {
		w, h int
	}

	envs := make([]envelope, 0, n)
	envIdxMap := make(map[envelope]int)

	for i := 0; i < n; i++ {
		var ew, eh int
		scanf("%d %d\n", &ew, &eh)
		if ew <= w || eh <= h {
			continue
		}

		env := envelope{ew, eh}

		if _, ok := envIdxMap[env]; !ok {
			envIdxMap[env] = i
			envs = append(envs, env)
		}
	}

	//printf("%v\n", envs)
	sort.Slice(envs, func(i, j int) bool {
		//return envs[i].w < envs[j].w && envs[i].h < envs[j].h
		return envs[i].w*envs[i].h < envs[j].w*envs[j].h
	})
	//printf("%v\n", envs)
	idxList := make([]int, 0, len(envs))

	lastEnv := 0
	for i := 0; i < len(envs); i++ {
		if i > 0 && (envs[i].w <= envs[lastEnv].w || envs[i].h <= envs[lastEnv].h) {
			continue
		}
		idxList = append(idxList, envIdxMap[envs[i]]+1)
		lastEnv = i
	}

	printf("%d\n", len(idxList))
	for i := 0; i < len(idxList); i++ {
		printf("%d ", idxList[i])
		if i == len(idxList)-1 {
			printf("\n")
		}
	}
}


package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"sort"
	"strings"
)

var reader = bufio.NewReader(os.Stdin)
var writer = bufio.NewWriter(os.Stdout)

func printf(f string, a ...interface{}) {
	_, err := fmt.Fprintf(writer, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func scanf(f string, a ...interface{}) {
	_, err := fmt.Fscanf(reader, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func readline() string {
	name, err := reader.ReadString('\n')
	if err != nil {
		log.Fatal(err)
	}

	name = strings.TrimRight(name, "\r\n")

	return name
}

func flush() {
	err := writer.Flush()
	if err != nil {
		log.Fatal(err)
	}
}

var debug = false

type envelope struct {
	w, h int
}

func readEnvs(n, w, h int) ([]envelope, map[envelope]int) {
	envs := make([]envelope, 0, n)
	envIdxMap := make(map[envelope]int)

	for i := 0; i < n; i++ {
		var ew, eh int
		scanf("%d %d\n", &ew, &eh)
		if ew <= w || eh <= h {
			continue
		}

		env := envelope{ew, eh}

		if _, ok := envIdxMap[env]; !ok {
			envIdxMap[env] = i
			envs = append(envs, env)
		}
	}

	return envs, envIdxMap
}

func findlis(envs []envelope) []int {
	lis := make([]int, len(envs))
	parent := make([]int, len(envs))

	globalMaxLisIdx := 0

	for i := 0; i < len(envs); i++ {
		maxLis := lis[i]
		maxLisIdx := -1
		for j := 0; j < i; j++ {
			if envs[i].w > envs[j].w && envs[i].h > envs[j].h && lis[j] > maxLis {
				maxLis = lis[j]
				maxLisIdx = j
			}
		}

		lis[i] = maxLis + 1
		parent[i] = maxLisIdx

		if lis[globalMaxLisIdx] < lis[i] {
			globalMaxLisIdx = i
		}
	}

	idxList := make([]int, 0)
	for idx := globalMaxLisIdx; idx != -1; {
		idxList = append(idxList, idx)
		idx = parent[idx]
	}

	return idxList
}

func main() {
	defer flush()
	var n, w, h int
	scanf("%d %d %d\n", &n, &w, &h)

	envs, envIdxMap := readEnvs(n, w, h)

	if len(envs) == 0 {
		printf("0\n")
		return
	}

	if debug {
		printf("bits: %d\n", (32 << (^uint(0) >> 63)))
		printf("%v\n", envIdxMap)
		printf("%v\n", envs)
	}

	sort.Slice(envs, func(i, j int) bool {
		return int64(envs[i].w)*int64(envs[i].h) < int64(envs[j].w)*int64(envs[j].h) && envs[i].w < envs[j].w && envs[i].h < envs[j].h
	})

	if debug {
		printf("%v\n", envs)
	}

	idxList := findlis(envs)

	printf("%d\n", len(idxList))
	for i := len(idxList) - 1; i >= 0; i-- {
		if debug {
			printf("%d (%v) ", envIdxMap[envs[idxList[i]]]+1, envs[idxList[i]])
		} else {
			printf("%d ", envIdxMap[envs[idxList[i]]]+1)
		}
		if i == 0 {
			printf("\n")
		}
	}
}


package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"sort"
	"strings"
)

var reader = bufio.NewReader(os.Stdin)
var writer = bufio.NewWriter(os.Stdout)

func printf(f string, a ...interface{}) {
	_, err := fmt.Fprintf(writer, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func scanf(f string, a ...interface{}) {
	_, err := fmt.Fscanf(reader, f, a...)
	if err != nil {
		log.Fatal(err)
	}
}

func readline() string {
	name, err := reader.ReadString('\n')
	if err != nil {
		log.Fatal(err)
	}

	name = strings.TrimRight(name, "\r\n")

	return name
}

func flush() {
	err := writer.Flush()
	if err != nil {
		log.Fatal(err)
	}
}

var debug = false

type envelope struct {
	w, h int
}

func readEnvs(n, w, h int) ([]envelope, map[envelope]int) {
	envs := make([]envelope, 0, n)
	envIdxMap := make(map[envelope]int)

	for i := 0; i < n; i++ {
		var ew, eh int
		scanf("%d %d\n", &ew, &eh)
		if ew <= w || eh <= h {
			continue
		}

		env := envelope{ew, eh}

		if _, ok := envIdxMap[env]; !ok {
			envIdxMap[env] = i
			envs = append(envs, env)
		}
	}

	return envs, envIdxMap
}

func findlis(envs []envelope) []int {
	lis := make([]int, len(envs))
	parent := make([]int, len(envs))

	globalMaxLisIdx := 0

	for i := 0; i < len(envs); i++ {
		maxLis := lis[i]
		maxLisIdx := -1
		for j := 0; j < i; j++ {
			if envs[i].w > envs[j].w && envs[i].h > envs[j].h && lis[j] > maxLis {
				maxLis = lis[j]
				maxLisIdx = j
			}
		}

		lis[i] = maxLis + 1
		parent[i] = maxLisIdx

		if lis[globalMaxLisIdx] < lis[i] {
			globalMaxLisIdx = i
		}
	}

	idxList := make([]int, 0)
	for idx := globalMaxLisIdx; idx != -1; {
		idxList = append(idxList, idx)
		idx = parent[idx]
	}

	return idxList
}

func main() {
	defer flush()
	var n, w, h int
	scanf("%d %d %d\n", &n, &w, &h)

	envs, envIdxMap := readEnvs(n, w, h)

	if debug {
		printf("bits: %d\n", (32 << (^uint(0) >> 63)))
		printf("%v\n", envIdxMap)
		printf("%v\n", envs)
	}

	sort.Slice(envs, func(i, j int) bool {
		return envs[i].w <= envs[j].w && envs[i].h <= envs[j].h
	})

	if debug {
		printf("%v\n", envs)
	}

	idxList := findlis(envs)

	printf("%d\n", len(idxList))
	for i := len(idxList) - 1; i >= 0; i-- {
		if debug {
			printf("%d (%v) ", envIdxMap[envs[idxList[i]]]+1, envs[idxList[i]])
		} else {
			printf("%d ", envIdxMap[envs[idxList[i]]]+1)
		}
		if i == 0 {
			printf("\n")
		}
	}
}


package main

import (
	"fmt"
	"os"
	"bufio"
	"sort"
)

type envelope struct {
	w, h, i int
}

type input struct {
	n int
	w, h int
	es []envelope
}

type output struct {
	ary []int
	memo []int
	crumbs []int
	max_len, max_idx int
}

func read_input() *input {
	result := &input{}
	r := bufio.NewReader(os.Stdin)

	fmt.Fscanf(r, "%d %d %d\n", &result.n, &result.w, &result.h)

	result.es = make([]envelope, result.n)

	for i := 0; i < result.n; i++ {
		result.es[i].i = i + 1
		fmt.Fscanf(r, "%d %d\n", &result.es[i].w, &result.es[i].h)
	}

	return result
}

func process_input(inp *input) *output {
	sort.Sort(ByArea(inp.es))

	out := &output{}
	out.max_len, out.max_idx = 0, -1
 	out.memo = make([]int, inp.n)

	// initialize the memo, taking into account that valid envelopes must be > postcard's dimensions
	for i := range out.memo {
		if inp.es[i].w > inp.w && inp.es[i].h > inp.h {
			out.memo[i] = 1
			if out.max_len == 0 {
				out.max_len = 1
				out.max_idx = i
			}
		}
 	}

	out.crumbs = make([]int, inp.n)
	for i := range out.crumbs {
		out.crumbs[i] = -1
	}

 	for i := 0; i < inp.n; i++ {
 		for j := 0; j < inp.n; j++ {
			if i == j {
				// we are not interested in link to ourselves
				continue
			}

			// ignore too small an envelope
			if inp.es[i].w <= inp.w || inp.es[i].h <= inp.h {
				continue
			}

			if inp.es[i].w < inp.es[j].w && inp.es[i].h < inp.es[j].h {
				// i -> j
				if out.memo[j] < out.memo[i] + 1 {
					out.memo[j] = out.memo[i] + 1
					out.crumbs[j] = i

					if out.memo[j] > out.max_len {
						out.max_len = out.memo[j]
						out.max_idx = j
					}
				}
			}
		}
	}

	out.ary = make([]int, out.max_len)
	for i, idx := out.max_len - 1, out.max_idx; i >= 0; i-- {
		out.ary[i] = inp.es[idx].i
		idx        = out.crumbs[idx]
	}

	return out
}

// ByArea implements sort.Interface for []envelope based on the area of the envelope.
type ByArea []envelope

func (a ByArea) Len() int           { return len(a) }
func (a ByArea) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a ByArea) Less(i, j int) bool { return a[i].w * a[i].h < a[j].w * a[j].h }

func main() {
	i := read_input()

	out := process_input(i)
	fmt.Printf("%d\n", out.max_len)
	if (out.max_len != 0) {
		fmt.Printf("%d\n", out.max_len)
		idx, l := 0, len(out.ary)
		fmt.Printf("%d", out.ary[idx])
		for idx = 1; idx < l; idx++ {
			fmt.Printf(" %d", out.ary[idx])
		}
		fmt.Println()
	}
}


package main

import (
	"fmt"
	"os"
	"bufio"
	"sort"
)

type envelope struct {
	w, h, i int
}

type input struct {
	n int
	w, h int
	es []envelope
}

type output struct {
	ary []int
	memo []int
	crumbs []int
	max_len, max_idx int
}

func read_input() *input {
	result := &input{}
	r := bufio.NewReader(os.Stdin)

	fmt.Fscanf(r, "%d %d %d\n", &result.n, &result.w, &result.h)

	result.es = make([]envelope, result.n)

	for i := 0; i < result.n; i++ {
		result.es[i].i = i + 1
		fmt.Fscanf(r, "%d %d\n", &result.es[i].w, &result.es[i].h)
	}

	return result
}

func process_input(inp *input) *output {
	sort.Sort(ByArea(inp.es))

	out := &output{}
	out.max_len, out.max_idx = 0, -1
 	out.memo = make([]int, inp.n)

	// initialize the memo, taking into account that valid envelopes must be > postcard's dimensions
	for i := range out.memo {
		if inp.es[i].w > inp.w && inp.es[i].h > inp.h {
			out.memo[i] = 1
			if out.max_len == 0 {
				out.max_len = 1
				out.max_idx = i
			}
		}
 	}

	out.crumbs = make([]int, inp.n)
	for i := range out.crumbs {
		out.crumbs[i] = -1
	}

 	for i := 0; i < inp.n; i++ {
 		for j := 0; j < inp.n; j++ {
			if i == j {
				// we are not interested in link to ourselves
				continue
			}

			// ignore too small an envelope
			if inp.es[i].w <= inp.w || inp.es[i].h <= inp.h {
				continue
			}

			if inp.es[i].w < inp.es[j].w && inp.es[i].h < inp.es[j].h {
				// i -> j
				if out.memo[j] < out.memo[i] + 1 {
					out.memo[j] = out.memo[i] + 1
					out.crumbs[j] = i

					if out.memo[j] > out.max_len {
						out.max_len = out.memo[j]
						out.max_idx = j
					}
				}
			}
		}
	}

	out.ary = make([]int, out.max_len)
	for i, idx := out.max_len - 1, out.max_idx; i >= 0; i-- {
		out.ary[i] = inp.es[idx].i
		idx        = out.crumbs[idx]
	}

	return out
}

// ByArea implements sort.Interface for []envelope based on the area of the envelope.
type ByArea []envelope

func (a ByArea) Len() int           { return len(a) }
func (a ByArea) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a ByArea) Less(i, j int) bool { return int64(a[i].w) * int64(a[i].h) < int64(a[j].w) * int64(a[j].h) }

func main() {
	i := read_input()

	out := process_input(i)
	fmt.Printf("%d\n", out.max_len)
	if (out.max_len != 0) {
		idx, l := 0, len(out.ary)
		fmt.Printf("%d", out.ary[idx])
		for idx = 1; idx < l; idx++ {
			fmt.Printf(" %d", out.ary[idx])
		}
		fmt.Println()
	}
}


package main

import (
	"fmt"
	"os"
	"bufio"
	"sort"
)

type envelope struct {
	w, h, i int
}

type input struct {
	n int
	w, h int
	es []envelope
}

type output struct {
	ary []int
	memo []int
	crumbs []int
	max_len, max_idx int
}

func read_input() *input {
	result := &input{}
	r := bufio.NewReader(os.Stdin)

	fmt.Fscanf(r, "%d %d %d\n", &result.n, &result.w, &result.h)

	result.es = make([]envelope, result.n)

	for i := 0; i < result.n; i++ {
		result.es[i].i = i + 1
		fmt.Fscanf(r, "%d %d\n", &result.es[i].w, &result.es[i].h)
	}

	return result
}

func process_input(inp *input) *output {
	sort.Sort(ByArea(inp.es))

	out := &output{}
	out.max_len, out.max_idx = 0, -1
 	out.memo = make([]int, inp.n)

	// initialize the memo, taking into account that valid envelopes must be > postcard's dimensions
	for i := range out.memo {
		if inp.es[i].w > inp.w && inp.es[i].h > inp.h {
			out.memo[i] = 1
			if out.max_len == 0 {
				out.max_len = 1
				out.max_idx = i
			}
		}
 	}

	out.crumbs = make([]int, inp.n)
	for i := range out.crumbs {
		out.crumbs[i] = -1
	}

 	for i := 0; i < inp.n; i++ {
 		for j := 0; j < inp.n; j++ {
			if i == j {
				// we are not interested in link to ourselves
				continue
			}

			// ignore too small an envelope
			if inp.es[i].w <= inp.w || inp.es[i].h <= inp.h {
				continue
			}

			if inp.es[i].w < inp.es[j].w && inp.es[i].h < inp.es[j].h {
				// i -> j
				if out.memo[j] < out.memo[i] + 1 {
					out.memo[j] = out.memo[i] + 1
					out.crumbs[j] = i

					if out.memo[j] > out.max_len {
						out.max_len = out.memo[j]
						out.max_idx = j
					}
				}
			}
		}
	}

	out.ary = make([]int, out.max_len)
	for i, idx := out.max_len - 1, out.max_idx; i >= 0; i-- {
		out.ary[i] = inp.es[idx].i
		idx        = out.crumbs[idx]
	}

	return out
}

// ByAread implements sort.Interface for []envelope based on the area of the envelope.
type ByArea []envelope

func (a ByArea) Len() int           { return len(a) }
func (a ByArea) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a ByArea) Less(i, j int) bool { return a[i].w * a[i].h < a[j].w * a[j].h }

func main() {
	i := read_input()
//	fmt.Printf("%v\n", i)

	out := process_input(i)
	if (out.max_len == 0) {
		fmt.Printf("%d\n", out.max_len)
	} else {
		fmt.Printf("%d\n", out.max_len)
		idx, l := 0, len(out.ary)
		fmt.Printf("%d", out.ary[idx])
		for idx = 1; idx < l; idx++ {
			fmt.Printf(" %d", out.ary[idx])
		}
		fmt.Println()

	// 	arr := make([]int, out.max_len)
	// 	for i, idx := out.max_len - 1, out.max_idx; i >= 0; i-- {
	// 		arr[i] = idx
	// 		idx = out.crumbs[idx]
	// 	}

	// 	fmt.Printf("(%d, %d) -> ", i.w, i.h)
	// 	for j := range out.ary {
	// 		fmt.Printf("(%d, %d) -> ", i.es[arr[j]].w, i.es[arr[j]].h)
	// 	}
	}

//	fmt.Printf("%v\n", out)
}


package main

import (
	"fmt"
	"os"
	"bufio"
	"sort"
)

type envelope struct {
	w, h, i int
}

type input struct {
	n int
	w, h int
	es []envelope
}

type output struct {
	ary []int
	memo []int
	crumbs []int
	max_len, max_idx int
}

func read_input() *input {
	result := &input{}
	r := bufio.NewReader(os.Stdin)

	fmt.Fscanf(r, "%d %d %d\n", &result.n, &result.w, &result.h)

	result.es = make([]envelope, result.n)

	for i := 0; i < result.n; i++ {
		result.es[i].i = i + 1
		fmt.Fscanf(r, "%d %d\n", &result.es[i].w, &result.es[i].h)
	}

	return result
}

func process_input(inp *input) *output {
	sort.Sort(ByArea(inp.es))

	out := &output{}
	out.max_len, out.max_idx = 0, -1
 	out.memo = make([]int, inp.n)

	// initialize the memo, taking into account that valid envelopes must be > postcard's dimensions
	for i := range out.memo {
		if inp.es[i].w > inp.w && inp.es[i].h > inp.h {
			out.memo[i] = 1
			if out.max_len == 0 {
				out.max_len = 1
				out.max_idx = i
			}
		}
 	}

	out.crumbs = make([]int, inp.n)
	for i := range out.crumbs {
		out.crumbs[i] = -1
	}

 	for i := 0; i < inp.n; i++ {
 		for j := 0; j < inp.n; j++ {
			if i == j {
				// we are not interested in link to ourselves
				continue
			}

			// ignore too small an envelope
			if inp.es[i].w <= inp.w || inp.es[i].h <= inp.h {
				continue
			}

			if inp.es[i].w < inp.es[j].w && inp.es[i].h < inp.es[j].h {
				// i -> j
				if out.memo[j] < out.memo[i] + 1 {
					out.memo[j] = out.memo[i] + 1
					out.crumbs[j] = i

					if out.memo[j] > out.max_len {
						out.max_len = out.memo[j]
						out.max_idx = j
					}
				}
			}
		}
	}

	out.ary = make([]int, out.max_len)
	for i, idx := out.max_len - 1, out.max_idx; i >= 0; i-- {
		out.ary[i] = inp.es[idx].i
		idx        = out.crumbs[idx]
	}

	return out
}

// ByArea implements sort.Interface for []envelope based on the area of the envelope.
type ByArea []envelope

func (a ByArea) Len() int           { return len(a) }
func (a ByArea) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a ByArea) Less(i, j int) bool { return a[i].w * a[i].h < a[j].w * a[j].h }

func main() {
	i := read_input()

	out := process_input(i)
	fmt.Printf("%d\n", out.max_len)
	if (out.max_len != 0) {
		idx, l := 0, len(out.ary)
		fmt.Printf("%d", out.ary[idx])
		for idx = 1; idx < l; idx++ {
			fmt.Printf(" %d", out.ary[idx])
		}
		fmt.Println()
	}
}


package main

import (
	"bufio"
	. "fmt"
	"io"
	"os"
)

// github.com/EndlessCheng/codeforces-go
func Sol4D(reader io.Reader, writer io.Writer) {
	in := bufio.NewReader(reader)
	out := bufio.NewWriter(writer)
	defer out.Flush()

	var n int
	Fscan(in, &n)
	g := make([][]int, n+1)
	type pair struct{ w, h int }
	env := make([]pair, n+1)
	for i := range env {
		Fscan(in, &env[i].w, &env[i].h)
		for j, e := range env[:i] {
			if env[i].w > e.w && env[i].h > e.h {
				g[j] = append(g[j], i)
			} else if env[i].w < e.w && env[i].h < e.h {
				g[i] = append(g[i], j)
			}
		}
	}

	next := make([]int, n+1)
	for i := range next {
		next[i] = -1
	}
	dp := make([]int, n+1)
	var dfs func(v int) int
	dfs = func(v int) int {
		if dp[v] == 0 {
			for _, w := range g[v] {
				if dpw := dfs(w) + 1; dpw > dp[v] {
					dp[v] = dpw
					next[v] = w
				}
			}
		}
		return dp[v]
	}
	Fprintln(out, dfs(0))
	for v := next[0]; v != -1; v = next[v] {
		Fprint(out, v, " ")
	}
}

func main() {
	Sol4D(os.Stdin, os.Stdout)
}


package main

import (
	"bufio"
	. "fmt"
	"io"
	"os"
)

// github.com/EndlessCheng/codeforces-go
func Sol4D(reader io.Reader, writer io.Writer) {
	in := bufio.NewReader(reader)
	out := bufio.NewWriter(writer)
	defer out.Flush()

	var n int
	Fscan(in, &n)
	type pair struct{ w, h int }
	env := make([]pair, n+1)
	for i := range env {
		Fscan(in, &env[i].w, &env[i].h)
	}

	next := make([]int, n+1)
	for i := range next {
		next[i] = -1
	}
	dp := make([]int, n+1)
	var dfs func(v int) int
	dfs = func(v int) int {
		if dp[v] == 0 {
			for w, e := range env {
				if env[v].w < e.w && env[v].h < e.h {
					if dpw := dfs(w) + 1; dpw > dp[v] {
						dp[v] = dpw
						next[v] = w
					}
				}
			}
		}
		return dp[v]
	}
	Fprintln(out, dfs(0))
	for v := next[0]; v != -1; v = next[v] {
		Fprint(out, v, " ")
	}
}

func main() {
	Sol4D(os.Stdin, os.Stdout)
}


package main

import (
	"bufio"
	. "fmt"
	"io"
	"os"
)

// github.com/EndlessCheng/codeforces-go
func Sol4D(reader io.Reader, writer io.Writer) {
	in := bufio.NewReader(reader)
	out := bufio.NewWriter(writer)
	defer out.Flush()

	var n int
	Fscan(in, &n)
	g := make([][]int, n+1)
	type pair struct{ w, h int }
	env := make([]pair, n+1)
	for i := range env {
		Fscan(in, &env[i].w, &env[i].h)
		for j, e := range env[:i] {
			if env[i].w > e.w && env[i].h > e.h {
				g[j] = append(g[j], i)
			} else if env[i].w < e.w && env[i].h < e.h {
				g[i] = append(g[i], j)
			}
		}
	}

	maxDeep := 0
	var dfs func(v, deep int)
	dfs = func(v, deep int) {
		if deep > maxDeep {
			maxDeep = deep
		}
		for _, w := range g[v] {
			dfs(w, deep+1)
		}
	}
	dfs(0, 0)
	ans := []int{}
	dfs = func(v, deep int) {
		if deep == maxDeep {
			ans = append(ans, v)
			return
		}
		for _, w := range g[v] {
			dfs(w, deep+1)
			if len(ans) > 0 {
				ans = append(ans, v)
				return
			}
		}
	}
	dfs(0, 0)
	Fprintln(out, len(ans)-1)
	for i := len(ans) - 2; i >= 0; i-- {
		Fprint(out, ans[i], " ")
	}
}

func main() {
	Sol4D(os.Stdin, os.Stdout)
}