Problem:
Score : 500 points

Problem Statement

You are given an integer N. Determine if there exists a tuple of subsets of \{1,2,...N\}, (S_1,S_2,...,S_k), that satisfies the following conditions:

Each of the integers 1,2,...,N is contained in exactly two of the sets S_1,S_2,...,S_k.

Any two of the sets S_1,S_2,...,S_k have exactly one element in common.

If such a tuple exists, construct one such tuple.

Constraints

1 \leq N \leq 10^5

N is an integer.

Input

Input is given from Standard Input in the following format:

N

Output

If a tuple of subsets of \{1,2,...N\} that satisfies the conditions does not exist, print No.
If such a tuple exists, print Yes first, then print such subsets in the following format:

k
|S_1| S_{1,1} S_{1,2} ... S_{1,|S_1|}
:
|S_k| S_{k,1} S_{k,2} ... S_{k,|S_k|}

where S_i={S_{i,1},S_{i,2},...,S_{i,|S_i|}}.

If there are multiple such tuples, any of them will be accepted.

Sample Input 1

3

Sample Output 1

Yes
3
2 1 2
2 3 1
2 2 3

It can be seen that (S_1,S_2,S_3)=(\{1,2\},\{3,1\},\{2,3\}) satisfies the conditions.

Sample Input 2

4

Sample Output 2

No

Solution in Rust (1.42.0) (judge verdict: Accepted)

use std::io;
use std::cmp;
use std::collections::BinaryHeap;
use std::collections::HashMap;
use std::collections::HashSet;
use std::f64::consts::PI;

fn read_line() -> String {
    let mut buf = String::new();
    io::stdin().read_line(&mut buf).ok();
    buf
}

fn find_m(n: u64) -> Option<usize> {
    for i in 1..2*n+1 {
        if i*(i-1) == 2*n {
            return Some(i as usize);
        } else if i*(i-1) > 2*n {
            break;
        }
    }
    None
}


fn main() {
    let line: Vec<u64> = read_line().split_whitespace().map(|s| s.parse().unwrap()).collect();
    let n = line[0];
    match find_m(n) {
        Some(m) => {
            println!("Yes");
            println!("{}", m);

            let mut memo = vec![Vec::new(); m];
            let mut tmp = 1;
            for i in 0..m {
                for j in i+1..m {
                    memo[i].push(tmp);
                    memo[j].push(tmp);
                    tmp += 1;
                }
            }
            for i in 0..m {
                println!("{} {}", memo[i].len(), memo[i].iter().map(|x| x.to_string()).collect::<Vec<String>>().join(" "));
            }
        },
        None => {
            println!("No");
        },
    }

}