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 best_score = !0;
    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 new_score = calc_score(c[1], d[1]);
                        if new_score > best_score {
                            best_score = new_score;
                            ans.clear();
                            ans.push((i, j));
                            ans.push((k, l));
                            ans.push((1, cand));
                        }
                    }
                }
            }
        }
    }
    
    println!("{}", ans.len());
    for ans in ans {
        println!("{} {}", ans.0, ans.1);
    }
    eprintln!("best_score: {}", best_score);
}

fn calc_score(a: i64, b: i64) -> i64 {
    let err = ((a - TARGET).abs()).max((b - TARGET).abs()) as f64;
    (2_000_000f64 - 100_000f64 * (err + 1f64).log10()) as i64
}