const INF: i64 = 1 << 61;
use std::cmp::min;


struct GraphWarshalFloyd {
    edges: Vec<Vec<i64>>,
    n: usize
}

impl GraphWarshalFloyd {
    fn new(n: usize) -> Self {
        GraphWarshalFloyd {
            edges: vec![vec![INF; n]; n],
            n: n
        }
    }

    fn add_costs(&mut self, from: usize, to: usize, cost: i64, directed: bool) {
        if directed {
            self.edges[from][to] = cost;
        } else {
            self.edges[from][to] = cost;
            self.edges[to][from] = cost;
        }
    }

    fn warshalfloyd(&self) -> (bool, Vec<Vec<i64>>) {
        // (true, dist) なら負の閉路を含む
        let mut dist: Vec<Vec<i64>> = vec![vec![INF; self.n]; self.n];
        for i in 0..self.n {
            for j in 0..self.n {
                dist[i][j] = self.edges[i][j]
            }
        }
        for i in 0..self.n {
            for j in 0..self.n {
                for k in 0..self.n {
                    if (dist[j][i] != INF) & (dist[i][k] != INF) {
                        dist[j][k] = min(dist[j][k], dist[j][i]+dist[i][k])
                    }
                }
            }
        }
        let mut has_negative_cycle = false;
        for i in 0..self.n {
            if dist[i][i] < 0 {
                has_negative_cycle = true;
            }
            dist[i][i] = 0;
        }
        return (has_negative_cycle, dist)
    }
}

macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

fn main() {
    input! {
    v: usize, e: usize,
    std: [(usize, usize, i64); e],
    }

    let mut graph = GraphWarshalFloyd::new(v);
    for i in 0..e {
        let s = std[i].0;
        let t = std[i].1;
        let d = std[i].2;
        graph.add_costs(s, t, d, true);
    }
    let (has_negative_cycle, dist) = graph.warshalfloyd();
    if has_negative_cycle {
        println!("{}", "NEGATIVE CYCLE");
    } else {
        for i in 0..v {
            for j in 0..v {
                if dist[i][j] == INF {
                    print!("{}", "INF");
                } else {
                    print!("{}", dist[i][j])
                }
                if j < v - 1 {
                    print!(" ");
                }
            }
            println!("");
        }
    }
}


Measured memory_bytes: 5056