use std::str::FromStr;
use std::io::*;
use utils::*;

pub fn main() {
    let i = stdin();
    let mut o = Vec::new();
    run(i.lock(), &mut o);
    stdout().write_all(&o).unwrap();
}

fn run<R: BufRead, W: Write>(i: R, o: &mut W) {
    let mut i = AtRead::from(i);
    let n = i.read::<usize>();
    let a = i.read_vec::<i64>(n);
    let mut r = vec![0; n];

    let mut sum = 0;
    let mut x = 0;
    for i in 0..n {
        r[i] += sum;
        sum += (x - a[i]).abs();
        x = a[i];
    }

    let mut sum = 0;
    let mut x = 0;
    for i in 0..n {
        let j = n - i - 1;
        r[j] += sum;
        sum += (x - a[j]).abs();
        x = a[j];
    }
    r[0] += a[1].abs();
    r[n - 1] += a[n - 2].abs();

    for i in 1..n - 1 {
        r[i] += (a[i - 1] - a[i + 1]).abs();
    }
    for &r in &r {
        writeln!(o, "{}", r).unwrap();
    }
}
fn solve(_n: usize) -> usize {
    unimplemented!()
}

mod utils {
    #![allow(dead_code)]
    use super::*;
    use std::ops::*;

    pub struct AtRead<R: BufRead> {
        r: R,
        s: String,
    }

    macro_rules! fn_read {
        {$f:ident($($v:ident: $t:ident),*)} => {
            pub fn $f<$($t: FromStr),*>(&mut self) -> ($($t),*) {
                let i = &mut self.read_line().split(' ');
                $(
                    let $v = next(i);
                )*
                ($($v),*)
            }
        };
    }

    impl<R: BufRead> AtRead<R> {
        pub fn from(r: R) -> Self {
            AtRead {
                r: r,
                s: String::new(),
            }
        }
        pub fn read_line(&mut self) -> &str {
            self.s.clear();
            self.r.read_line(&mut self.s).unwrap();
            self.s.trim()
        }

        pub fn read<T: FromStr>(&mut self) -> T {
            self.read_line().parse().ok().unwrap()
        }
        fn_read! { read2(v1: T1, v2: T2) }
        fn_read! { read3(v1: T1, v2: T2, v3: T3) }
        fn_read! { read4(v1: T1, v2: T2, v3: T3, v4: T4) }

        pub fn read_vec<T: FromStr>(&mut self, n: usize) -> Vec<T> {
            self.read_line()
                .split(' ')
                .take(n)
                .map(|x| x.parse().ok().unwrap())
                .collect()
        }
    }

    fn next<'a, T: FromStr, I: std::iter::Iterator<Item = &'a str>>(i: &mut I) -> T {
        i.next().unwrap().parse().ok().unwrap()
    }

    const MOD_BASE: usize = 1000000007;

    #[derive(Debug, Clone, Copy)]
    struct ModNum(usize);

    impl ModNum {
        fn new(n: usize) -> Self {
            ModNum(n % MOD_BASE)
        }
    }
    macro_rules! modnum_op {
        (($ot:ident, $f:ident), ($ot_a:ident, $f_a:ident), $($rhs:ty, $e:expr,)*) => {
            $(
            impl $ot<$rhs> for ModNum {
                type Output = Self;
                fn $f(self, rhs: $rhs) -> Self {
                    Self::new(($e)(self, rhs))
                }
            }
            impl $ot_a<$rhs> for ModNum {
                fn $f_a(&mut self, rhs: $rhs) {
                    *self = Self::new(($e)(*self, rhs))
                }
            }
            )*
        }
    }

    modnum_op!(
        (Add, add),
        (AddAssign, add_assign),
        ModNum,
        |l: ModNum, r: ModNum| l.0 + r.0,
        usize,
        |l: ModNum, r: usize| l.0 + r,
    );

    modnum_op!(
        (Mul, mul),
        (MulAssign, mul_assign),
        ModNum,
        |l: ModNum, r: ModNum| l.0 * r.0,
        usize,
        |l: ModNum, r: usize| l.0 * r,
    );

    modnum_op!(
        (Sub, sub),
        (SubAssign, sub_assign),
        ModNum,
        |l: ModNum, r: ModNum| MOD_BASE + l.0 - r.0,
        usize,
        |l: ModNum, r: usize| MOD_BASE + l.0 - r,
    );

}


Measured memory_bytes: 10492