B_Alice_s_Adventures_in_Permuting.rs

#![allow(unused)]

fn solve(scan: &mut Scanner, case: usize) {
    let n: i128 = scan.next();
    let b: i128 = scan.next();
    let c: i128 = scan.next();
    let (mut l, mut r) = (0, n);

    let mut m = 0;
    let mut calc = 0;
    if b==0 {
        if c>=n {
			n.println();
		} else if c==n-1 || c==n-2 {
			(n-1).println();
		}else {
			"-1".println();
		}
		return;
    }
	if c>=n {
		n.println();
	}else {
		(n-0.max(1+(n-c-1)/b)).println();
	}
}

fn main() {
    let mut scan = Scanner::new();
    let t: usize = 1;
    let t: usize = scan.next();
    (1..=t).for_each(|case| solve(&mut scan, case));
}
trait Print {
    fn println(&self);
}
impl<T: std::fmt::Display> Print for T {
    fn println(&self) {
        println!("{}", self);
    }
}

trait Prints {
    fn println(&self);
}
impl<T: std::fmt::Display> Prints for Vec<T> {
    fn println(&self) {
        if let Some((last, elements)) = self.split_last() {
            for element in elements {
                print!("{} ", element);
            }
            println!("{}", last);
        }
    }
}
struct Scanner {
    arr: Vec<String>,
}
impl Scanner {
    fn new() -> Self {
        Self { arr: Vec::new() }
    }
    fn next<T: std::str::FromStr>(&mut self) -> T
    where
        T::Err: std::fmt::Debug,
    {
        if self.arr.is_empty() {
            let mut input = String::new();
            std::io::stdin().read_line(&mut input).unwrap();
            self.arr = input.split_whitespace().rev().map(String::from).collect();
        }
        self.arr.pop().unwrap().parse().unwrap()
    }

    fn vec<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T>
    where
        T::Err: std::fmt::Debug,
    {
        (0..n).map(|_| self.next()).collect()
    }
}