fn main() {
    let mut input = Input::stdin();
    let mut output = Output::<_>::stdout();
    let h: usize = input.val();
    let w: usize = input.val();
    let mut a = vec![0u32; h * w];
    for a in a.iter_mut() {
        *a = input.val();
    }
    let c = a.chunks_exact(w).map(|a| a.iter().sum::<u32>()).collect::<Vec<_>>();
    let t = c.iter().sum::<u32>();
    for c in c {
        output.val((c + t) as u64);
    }
    output.flush().unwrap();
}

// https://judge.yosupo.jp/submission/362621

use crate::urectanc::fast_io::{Input, Output};

pub mod urectanc {
    pub mod fast_io {
        mod input {
            use std::{io::Read, os::fd::FromRawFd};
            mod mman {
                use std::ffi::{c_int, c_void};
                pub const PROT_READ: c_int = 1;
                pub const MAP_PRIVATE: c_int = 2;
                #[link(name = "c")]
                unsafe extern "C" {
                    pub fn mmap(
                        addr: *mut c_void,
                        len: usize,
                        prot: c_int,
                        flags: c_int,
                        fd: c_int,
                        offset: isize,
                    ) -> *mut c_void;
                }
            }
            pub struct Input {
                ptr: *const u8,
                end: *const u8,
            }
            impl Input {
                pub fn new(ptr: *const u8, len: usize) -> Self {
                    let end = unsafe { ptr.add(len) };
                    Self { ptr, end }
                }
                pub fn stdin() -> Self {
                    use mman::*;
                    let mut stdin = unsafe { std::fs::File::from_raw_fd(0) };
                    let (ptr, len) = if let Ok(metadata) = stdin.metadata() {
                        let len = metadata.len() as usize;
                        unsafe {
                            (
                                mmap(std::ptr::null_mut(), len, PROT_READ, MAP_PRIVATE, 0, 0) as _,
                                len,
                            )
                        }
                    } else {
                        let mut buf = Vec::new();
                        stdin.read_to_end(&mut buf).unwrap();
                        let len = buf.len();
                        (Box::leak(buf.into_boxed_slice()).as_ptr(), len)
                    };
                    Self::new(ptr, len)
                }
                fn peek<T>(&self) -> T {
                    let ptr = self.ptr as *const T;
                    unsafe { std::ptr::read_unaligned(ptr) }
                }
                fn next<T>(&mut self) -> T {
                    let val = self.peek();
                    self.ptr = unsafe { self.ptr.add(1) };
                    val
                }
                fn skip_whitespace(&mut self) {
                    while self.peek::<u8>().is_ascii_whitespace() {
                        self.ptr = unsafe { self.ptr.add(1) };
                    }
                }
                fn parse_neg(&mut self) -> bool {
                    let neg = self.peek::<u8>() == b'-';
                    self.ptr = unsafe { self.ptr.add(neg as usize) };
                    neg
                }
                fn parse_digits(&mut self, mut val: u64) -> u64 {
                    loop {
                        let c = self.next::<u8>();
                        if c.is_ascii_whitespace() {
                            break;
                        }
                        val = val * 10 + (c - b'0') as u64;
                    }
                    val
                }
                fn parse_digits_8byte(&mut self) -> Option<u64> {
                    if unsafe { self.ptr.add(8) > self.end } {
                        return None;
                    }
                    let mut val = self.peek::<u64>() ^ 0x3030303030303030;
                    if val & 0xf0f0f0f0f0f0f0f0 != 0 {
                        return None;
                    }
                    self.ptr = unsafe { self.ptr.add(8) };
                    val = val.wrapping_mul((10 << 8) + 1) >> 8 & 0x00ff00ff00ff00ff;
                    val = val.wrapping_mul((100 << 16) + 1) >> 16 & 0x0000ffff0000ffff;
                    val = val.wrapping_mul((10000 << 32) + 1) >> 32;
                    Some(val)
                }
                pub fn val<T: Readable>(&mut self) -> T {
                    self.skip_whitespace();
                    T::read(self)
                }
                pub fn vec<T: Readable>(&mut self, len: usize) -> Vec<T> {
                    (0..len).map(|_| self.val()).collect()
                }
            }
            pub trait Readable {
                fn read(input: &mut Input) -> Self;
            }
            impl Readable for u32 {
                fn read(input: &mut Input) -> Self {
                    let val = input.parse_digits_8byte().unwrap_or(0);
                    input.parse_digits(val) as _
                }
            }
            impl Readable for u64 {
                fn read(input: &mut Input) -> Self {
                    let val = input.parse_digits_8byte().map_or(0, |x| {
                        input
                            .parse_digits_8byte()
                            .map_or(x, |y| x * 100_000_000 + y)
                    });
                    input.parse_digits(val)
                }
            }
            impl Readable for usize {
                fn read(input: &mut Input) -> Self {
                    u64::read(input) as _
                }
            }
            impl Readable for i32 {
                fn read(input: &mut Input) -> Self {
                    let neg = input.parse_neg();
                    let val = u32::read(input) as Self;
                    if neg {
                        -val
                    } else {
                        val
                    }
                }
            }
            impl Readable for i64 {
                fn read(input: &mut Input) -> Self {
                    let neg = input.parse_neg();
                    let val = u64::read(input) as Self;
                    if neg {
                        -val
                    } else {
                        val
                    }
                }
            }
            impl Readable for isize {
                fn read(input: &mut Input) -> Self {
                    i64::read(input) as _
                }
            }
        }
        mod output {
            use std::io::Write;
            const DEFAULT_BUF_SIZE: usize = 1 << 18;
            pub struct Output<W: Write, const N: usize = DEFAULT_BUF_SIZE> {
                buf: [u8; N],
                pos: usize,
                inner: W,
            }
            impl<const N: usize> Output<std::io::StdoutLock<'static>, N> {
                pub fn stdout() -> Self {
                    Self::new(std::io::stdout().lock())
                }
            }
            impl<W: Write, const N: usize> Output<W, N> {
                pub fn new(inner: W) -> Self {
                    Self {
                        buf: [0; N],
                        pos: 0,
                        inner,
                    }
                }
                pub fn flush(&mut self) -> std::io::Result<()> {
                    self.inner.write_all(&self.buf[..self.pos])?;
                    self.pos = 0;
                    Ok(())
                }
                fn reserve(&mut self, size: usize) {
                    if self.pos + size > self.buf.len() {
                        self.flush().unwrap();
                    }
                }
                fn write_bytes(&mut self, src: &[u8]) {
                    let src_len = src.len();
                    unsafe {
                        let src = src.as_ptr();
                        let dst = self.buf.as_mut_ptr().add(self.pos);
                        std::ptr::copy_nonoverlapping(src, dst, src_len);
                    }
                    self.pos += src.len();
                }
                fn write_digits<const LZ: bool>(&mut self, n: usize) {
                    static TABLE: [u8; 40_000] = {
                        let mut table = [b'0'; 40_000];
                        let mut i = 0;
                        while i < 10_000 {
                            table[4 * i + 0] += (i / 1000) as u8;
                            table[4 * i + 1] += (i / 100 % 10) as u8;
                            table[4 * i + 2] += (i / 10 % 10) as u8;
                            table[4 * i + 3] += (i % 10) as u8;
                            i += 1;
                        }
                        table
                    };
                    let offset = if LZ {
                        0
                    } else {
                        (n < 10) as usize + (n < 100) as usize + (n < 1000) as usize
                    };
                    unsafe {
                        let src = TABLE.as_ptr().add(4 * n + offset) as *const u32;
                        let dst = self.buf.as_mut_ptr().add(self.pos) as *mut u32;
                        std::ptr::write_unaligned(dst, std::ptr::read_unaligned(src));
                    }
                    self.pos += 4 - offset;
                }
                pub fn val<T: Writable<W, N>>(&mut self, val: T) {
                    T::write(self, val);
                    self.write_bytes(&[b'\n']);
                }
            }
            pub trait Writable<W: Write, const N: usize> {
                fn write(output: &mut Output<W, N>, val: Self);
            }
            impl<W: Write, const N: usize> Writable<W, N> for u64 {
                fn write(output: &mut Output<W, N>, val: Self) {
                    output.reserve(20);
                    if val >= 1_0000_0000_0000_0000 {
                        output
                            .write_digits::<false>((val / 10000 / 10000 / 10000 / 10000) as usize);
                        output.write_digits::<true>((val / 10000 / 10000 / 10000 % 10000) as usize);
                        output.write_digits::<true>((val / 10000 / 10000 % 10000) as usize);
                        output.write_digits::<true>((val / 10000 % 10000) as usize);
                        output.write_digits::<true>((val % 10000) as usize);
                    } else if val >= 1_0000_0000_0000 {
                        output.write_digits::<false>((val / 10000 / 10000 / 10000) as usize);
                        output.write_digits::<true>((val / 10000 / 10000 % 10000) as usize);
                        output.write_digits::<true>((val / 10000 % 10000) as usize);
                        output.write_digits::<true>((val % 10000) as usize);
                    } else if val >= 1_0000_0000 {
                        output.write_digits::<false>((val / 10000 / 10000) as usize);
                        output.write_digits::<true>((val / 10000 % 10000) as usize);
                        output.write_digits::<true>((val % 10000) as usize);
                    } else if val >= 1_0000 {
                        output.write_digits::<false>((val / 10000) as usize);
                        output.write_digits::<true>((val % 10000) as usize);
                    } else {
                        output.write_digits::<false>(val as usize);
                    }
                }
            }
        }
        #[cfg(unix)]
        pub use input::Input;
        #[cfg(unix)]
        pub use output::Output;
    }
}
mod util {
    pub trait Join {
        fn join(self, sep: &str) -> String;
    }

    impl<T, I> Join for I
    where
        I: Iterator<Item = T>,
        T: std::fmt::Display,
    {
        fn join(self, sep: &str) -> String {
            let mut s = String::new();
            use std::fmt::*;
            for (i, v) in self.enumerate() {
                if i > 0 {
                    write!(&mut s, "{}", sep).ok();
                }
                write!(&mut s, "{}", v).ok();
            }
            s
        }
    }
}