#[allow(unused_imports)]
use std::{collections::{HashSet, HashMap, BTreeSet, BTreeMap, BinaryHeap, VecDeque}, cmp::{Reverse, PartialOrd, Ordering, max, min}, mem::swap};

macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<\Vec<\_>>()
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<\Vec<\char>>()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

struct XorShiftStar{
    state: u64,
}

impl XorShiftStar{
    fn new(seed: u64)->Self{
        XorShiftStar{state: seed}
    }

    fn next(&mut self)->u64{
        let mut x = self.state;
        x ^= x << 13;
        x ^= x >> 7;
        x ^= x << 17;
        self.state = x;
        x.wrapping_mul(0x2545F4914F6CDD1D)
    }

    fn get(&mut self, l: usize, r: usize) -> usize {
        let range = r - l + 1;
        let num = (self.next() as usize) % (range) + l;
        num
    }

    fn shuffle<T>(&mut self, a: &mut Vec<T>){
        let n = a.len();
        for i in 0..n{
            let j = self.get(0, i);
            a.swap(i, j);
        }
    }

    fn choose<T>(&mut self, a: &Vec<T>)->T where T: Copy{
        let n = a.len();
        let p = self.get(0, n-1);
        a[p]
    }
}

fn main(){
    input!{
        c: u64,
    }
    //入力ごとに乱数シードを変更するため調整する
    let config1 = 0;
    let config2 = 0;
    //ここまで
    let mut pre_rng = XorShiftStar::new(config1*c+config2);
    for _ in 0..c{
        pre_rng.next();
    }
    let seed = (pre_rng.get(0, 199999) as u64+c*config2)%200000;
    let mut rng = XorShiftStar::new(seed);
    //ここは直接指定して操作するかpre_rngにより決定
    let n = pre_rng.get(2, 2);
    let m = pre_rng.get(n-1, 100000).min(n*(n-1)/2);
    let k = pre_rng.get(1, 100000);
    //ここまで。ここ以降は完全にrngのみで乱数を扱う。
    let mx = 200000i32;
    let h = 100000i32;
    let mut p = Vec::new();
    p.push(rng.get(0, mx as usize) as i32-h);
    p.push(rng.get(0, mx as usize) as i32-h);
    let mut used1 = HashSet::new();
    used1.insert((p[0], p[1]));
    let mut cnt = 0;
    let mut station = Vec::new();
    while cnt < n{
        let (u, v) = (rng.get(0, mx as usize) as i32-h, rng.get(0, mx as usize) as i32-h);
        if used1.contains(&(u, v)){continue}
        cnt += 1;
        used1.insert((u, v));
        station.push((u, v));
    }
    let mut t = Vec::new();
    cnt = 0;
    while cnt < k{
        let (u, v) = (rng.get(0, mx as usize) as i32-h, rng.get(0, mx as usize) as i32-h);
        if used1.contains(&(u, v)){continue}
        cnt += 1;
        used1.insert((u, v));
        t.push((u, v));
    }
    let z = 1_000_000_000_000_000_000i64;
    let mut leaf = Vec::new();
    for i in 0..n{
        leaf.push(i);
    }
    rng.shuffle(&mut leaf);
    let mut parent = Vec::new();
    let x = leaf.pop().unwrap();
    parent.push(x);
    let mut e = Vec::new();
    let mut used2 = HashSet::new();
    for _ in 1..n{
        let pre = rng.choose(&parent);
        let nex = leaf.pop().unwrap();
        e.push((pre, nex));
        parent.push(nex);
        used2.insert((pre, nex));
        used2.insert((nex, pre));
    }
    let mut cnt = n-1;
    while cnt < m{
        let (u, v) = (rng.get(0, n-1), rng.get(0, n-1));
        if u==v||used2.contains(&(u, v)){continue}
        used2.insert((u, v));
        used2.insert((v, u));
        e.push((u, v));
        cnt += 1;
    }
    assert!(n >= 2);
    assert!(n <= 100000);
    assert!(n-1 <= m);
    assert!(m <= n*(n-1)/2);
    assert!(m <= 100000);
    assert!(k >= 1);
    assert!(k <= 100000);
    assert!(p[0] <= h);
    assert!(p[0] >= -h);
    assert!(p[1] <= h);
    assert!(p[1] >= -h);
    assert_eq!(z, 1_000_000_000_000_000_000);
    println!("{} {} {}", n, m, k);
    println!("{} {}", p[0], p[1]);
    for &(u, v) in &station{
        assert!(u <= h);
        assert!(u >= -h);
        assert!(v <= h);
        assert!(v >= -h);
        println!("{} {}", u, v);
    }
    for &(u, v) in &t{
        assert!(u <= h);
        assert!(u >= -h);
        assert!(v <= h);
        assert!(v >= -h);
        println!("{} {}", u, v);
    }
    println!("{}", z);
    for &(u, v) in &e{
        assert!(u+1 >= 1);
        assert!(v+1 >= 1);
        assert!(u+1 <= n);
        assert!(v+1 <= n);
        println!("{} {}", u+1, v+1);
    }
    //ケース名はケースごとに直接指定するか渡された値を利用。シード値は出力から確認している。その後テストケース名から削除している。
    eprintln!("00_some_{}_seed_{}", c, seed);
}