#[allow(unused_imports)]
use std::cmp::{max, min};
#[allow(unused_imports)]
use std::collections::{HashMap, HashSet};

mod util {
    use std::io::stdin;
    use std::str::FromStr;
    use std::fmt::Debug;

    #[allow(dead_code)]
    pub fn line() -> String {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.trim().to_string()
    }

    #[allow(dead_code)]
    pub fn get<T: FromStr>() -> T
    where
        <T as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.trim().parse().unwrap()
    }

    #[allow(dead_code)]
    pub fn gets<T: FromStr>() -> Vec<T>
    where
        <T as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.split_whitespace()
            .map(|t| t.parse().unwrap())
            .collect()
    }

    #[allow(dead_code)]
    pub fn get2<T: FromStr, U: FromStr>() -> (T, U)
    where
        <T as FromStr>::Err: Debug,
        <U as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        let mut iter = line.split_whitespace();
        (
            iter.next().unwrap().parse().unwrap(),
            iter.next().unwrap().parse().unwrap(),
        )
    }
}


#[allow(unused_macros)]
macro_rules! debug {
    ($x: expr) => {
        println!("{}: {:?}", stringify!($x), $x)
    }
}

fn leve_up(s: &[char]) -> String {
    let r = (0..s.len()).rev().find(|&i| s[i].is_digit(10));
    if let Some(r) = r {
        let l = (0..r + 1)
            .rev()
            .take_while(|&i| s[i].is_digit(10))
            .last()
            .unwrap();

        let s_level = s[l..r + 1].iter().cloned().collect::<String>();

        let next_level: usize = s_level.parse::<usize>().unwrap() + 1;

        let mut mid = next_level.to_string();
        if s_level.len() > mid.len() {
            mid = (0..s_level.len() - mid.len())
                .map(|_| '0')
                .chain(mid.chars())
                .collect();
        }

        s[0..l]
            .iter()
            .cloned()
            .chain(mid.chars())
            .chain(s[r + 1..].iter().cloned())
            .collect()

    } else {
        // no digit
        s.iter().cloned().collect()
    }
}

fn main() {
    let n: usize = util::get();
    for _ in 0..n {
        let line = util::line();
        let s = line.chars().collect::<Vec<char>>();
        println!("{}", leve_up(&s));
    }
}