Problem:
Score: 500 points

Problem Statement

Does there exist an undirected graph with N vertices satisfying the following conditions?

The graph is simple and connected.

The vertices are numbered 1, 2, ..., N.

Let M be the number of edges in the graph. The edges are numbered 1, 2, ..., M, the length of each edge is 1, and Edge i connects Vertex u_i and Vertex v_i.

There are exactly K pairs of vertices (i,\ j)\ (i < j) such that the shortest distance between them is 2.

If there exists such a graph, construct an example.

Constraints

All values in input are integers.

2 \leq N \leq 100

0 \leq K \leq \frac{N(N - 1)}{2}

Input

Input is given from Standard Input in the following format:

N K

Output

If there does not exist an undirected graph with N vertices satisfying the conditions, print -1.

If there exists such a graph, print an example in the following format (refer to Problem Statement for what the symbols stand for):

M
u_1 v_1
:
u_M v_M

If there exist multiple graphs satisfying the conditions, any of them will be accepted.

Sample Input 1

5 3

Sample Output 1

5
4 3
1 2
3 1
4 5
2 3

This graph has three pairs of vertices such that the shortest distance between them is 2: (1,\ 4), (2,\ 4), and (3,\ 5). Thus, the condition is satisfied.

Sample Input 2

5 8

Sample Output 2

-1

There is no graph satisfying the conditions.

Solution in Rust (1.15.1) (judge verdict: Wrong Answer)

#![allow(unused)]

use std::cmp::{max, min};
use std::io::stdin;
use std::str::FromStr;

fn input<T: FromStr>() -> Result<T, T::Err> {
    let mut buf = String::new();
    stdin().read_line(&mut buf).unwrap();
    buf.trim().parse()
}

fn input_vec<T: FromStr>() -> Result<Vec<T>, T::Err> {
    let mut buf = String::new();
    stdin().read_line(&mut buf).unwrap();
    buf.trim().split_whitespace().map(|x| x.parse()).collect()
}

use std::collections::HashMap;

fn main() {
    let (n, k): (usize, usize) = {
        let v = input_vec().unwrap();
        (v[0], v[1])
    };

    if k > (n - 1) * (n - 2) / 2 {
        println!("-1");
    } else {
        let mut enable = vec![false; (n - 1) * (n - 2) / 2 + 1];
        for m in 2..n {
            let unused = n - m - 1;
            for rng in (m * (m - 1) / 2)..min((n - 1) * (n - 2) / 2, (m * (m - 1) / 2) + unused) {
                enable[rng] = true;
            }
        }

        if enable[k] == false {
            println!("-1");
        } else {
            let mut ans = Vec::new();
            let mut last = 0usize;
            for i in (2usize..).take_while(|x| (x - 1) * x / 2 <= k) {
                ans.push((1, i));
                last = i;
            }
            let mut before = 2usize;

            for j in before+1..before+(k-(last-2)*(last-1)/2)+1 {
                ans.push((before, j));
                before = j;
            }

            for (an, s) in ans {
                println!("{} {}", an, s);
            }
        }
    }
}