pub fn separate_numbers(s: &str) {
    //Time complexity: O(n^2)
    //Space complexity (ignoring input): O(n)
    //Python solution is way cleaner, made this one first and got lazy to rewrite
    let len_s = s.len();
    if len_s == 1 {
        println!("NO");
        return;
    }
    let vec_chars = s.chars().collect::<Vec<char>>();
    let mut start_number_size = 1;
    let mut number_size = start_number_size;
    let mut index: usize = start_number_size;
    let mut last_number = vec_chars[0]
        .to_string()
        .parse::<i64>()
        .expect("To have a number");
    let mut first_number = last_number;
    loop {
        if (last_number + 1) == (10u64.pow(number_size as u32) as i64) {
            number_size += 1;
        }
        let number = if number_size + index > len_s {
            last_number + 2
        } else {
            vec_chars[index..(number_size + index)]
                .iter()
                .collect::<String>()
                .parse::<i64>()
                .expect("To have a number")
        };
        if ((number - last_number) != 1) || (index + number_size > len_s) {
            start_number_size += 1;
            if start_number_size > (len_s + 1) / 2 {
                println!("NO");
                return;
            };
            number_size = start_number_size;
            index = 0;
            if vec_chars[0] == '0' {
                println!("NO");
                return;
            }
            last_number = vec_chars[0..start_number_size]
                .iter()
                .collect::<String>()
                .parse::<i64>()
                .expect("To have a number");
            first_number = last_number;
        } else {
            last_number = number;
        }
        index += number_size;
        if index == len_s {
            println!("YES {first_number}");
            return;
        }
    }
}