use std::io;

fn main() {
    let (h, w) = input_hw();

    let field = input_field(h);
    let minesweeper_field = generate_minesweeper_field(h, w, &field);

    for line in minesweeper_field {
        for s in line {
            print!("{}", s);
        }
        println!();
    }

}

fn input() -> String {
    let mut s = String::new();
    io::stdin().read_line(&mut s).expect("panic input hw");
    s
}

fn parse_vec_i32(s: String) -> Vec<i32> {
     s.split_whitespace()
    .map(|s| s.parse().expect("panic parse"))
    .collect()
}

fn input_hw() -> (i32, i32) {
    let s = input();
    let hw = parse_vec_i32(s);

    (hw[0], hw[1])
}

fn input_field(h: i32) -> Vec<Vec<String>> {
    let mut field: Vec<Vec<String>> = Vec::new();

    for _ in 0..h {
        let line = input();
        let line = line.chars().map(|c| c.to_string()).collect();
        field.push(line);
    }

    field
}


fn generate_minesweeper_field(h: i32, w: i32, field: &Vec<Vec<String>>) -> Vec<Vec<String>>{
    let mut mineswepper_field: Vec<Vec<String>> = Vec::new();

    for i in 0..h {
        let mut line: Vec<String> = Vec::new();

        for j in 0..w {
            let trout = generate_trout(i as usize, j as usize, h, w, &field);
            line.push(trout);
       }

        mineswepper_field.push(line)
    }

    mineswepper_field
}

fn generate_trout(i: usize, j: usize, h: i32, w:i32, field: &Vec<Vec<String>>) -> String {
    let field_trout = &field[i][j];

    if is_bomb(field_trout) {
        return "#".to_string();
    }


    let top = i as i32 - 1;
    let right = j + 1;
    let bottom = i + 1;
    let left = j as i32 - 1;

    println!("{} {} {} {}", top, right, bottom, left);

    let top_safe = top >= 0;
    let right_safe = right < w as usize;
    let bottom_safe = bottom < h as usize;
    let left_safe = left >= 0;


    println!("{} {} {} {}", top_safe, right_safe, bottom_safe, left_safe);

    let mut around_bomb_count = 0;
    let mut increment = || around_bomb_count += 1;


    if top_safe {
        let top = top as usize;
        let left = left as usize;

        if is_bomb(&field[top][j]) {
            increment();
        }

        if left_safe && is_bomb(&field[top][left]) {
            increment();
        }

        if right_safe && is_bomb(&field[top][right]) {
            increment();
        }

    }

    if bottom_safe {
        let bottom = bottom as usize;
        let left = left as usize;

        if is_bomb(&field[bottom][j]) {
            increment();
        }

        if left_safe && is_bomb(&field[bottom][left]) {
            increment();
        }

        if right_safe && is_bomb(&field[bottom][right]) {
            increment();
        }
    }

    if right_safe {
        if is_bomb(&field[i][right]) {
            around_bomb_count += 1;
        }
    }

    if left_safe {
        let left = left as usize;

        if is_bomb(&field[i][left]) {
            around_bomb_count += 1;
        }
    }

    around_bomb_count.to_string()
}

fn is_bomb(s: &String) -> bool {
    s == "#"
}