use std::env;
use std::io;

const TARGET: i64 = 500_000_000_000_000_000;

fn main() {
    env::set_var("RUST_BACKTRACE", "1");

    let mut n = String::new();
    io::stdin().read_line(&mut n).expect("Failed to read line");
    let n: usize = n.trim().parse().expect("Failed to parse N");

    let mut a = [0i64; 50];
    let mut b = [0i64; 50];
    let mut c = [0i64; 50];
    let mut d = [0i64; 50];

    for i in 1..=n {
        let mut input = String::new();
        io::stdin()
            .read_line(&mut input)
            .expect("Failed to read line");

        let pair: Vec<i64> = input
            .split_whitespace()
            .map(|s| s.parse().expect("Failed to parse i64"))
            .collect();

        if pair.len() == 2 {
            a[i] = pair[0];
            b[i] = pair[1];
            c[i] = a[i];
            d[i] = b[i];
        } else {
            panic!("Invalid input format for A_i B_i");
        }
    }

    let mut ans = vec![];
    let mut min_error = i64::MAX;
    for i in 2..=n {
        for j in i + 1..=n {
            for k in 2..=n {
                for l in k + 1..=n {
                    let cand = vec![i, j, k, l];
                    for cand in cand {
                        c[i] = (c[i] + c[j]) / 2;
                        c[j] = c[i];
                        d[i] = (d[i] + d[j]) / 2;
                        d[j] = d[i];

                        c[k] = (c[k] + c[l]) / 2;
                        c[l] = c[k];
                        d[k] = (d[k] + d[l]) / 2;
                        d[l] = d[k];

                        c[1] = (c[1] + c[cand]) / 2;
                        d[1] = (d[1] + d[cand]) / 2;

                        let error = calc_error(c[1], d[1]);
                        if error < min_error {
                            min_error = error;
                            ans.clear();
                            ans.push((i, j));
                            ans.push((k, l));
                            ans.push((cand, 1));
                        }
                    }
                }
            }
        }
    }

    println!("{}", ans.len());
    for ans in ans {
        println!("{} {}", ans.0, ans.1);
    }
    eprintln!("best_score: {}", min_error);
}

fn calc_error(a: i64, b: i64) -> i64 {
    ((a - TARGET).abs()).max((b - TARGET).abs())
}