use std::io::prelude::*;

fn input<T>() -> T
    where T: std::str::FromStr {
    let stdin = std::io::stdin();
    let token: String = stdin
        .lock()
        .bytes()
        .map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().unwrap()
}

static NMAX: usize = 1000;

static INF: i64 = 1 << 50;

fn main() {
    let n = input::<usize>();
    let m = input::<usize>();
    let abcs = (0..m)
        .map(|_| (input::<usize>()-1,input::<usize>()-1,-input::<i64>()))
        .collect::<Vec<_>>();

    let mut dist = vec![INF; NMAX];
    dist[0] = 0;

    for _ in 0..n-1 {
        for &(a, b, c) in &abcs {
            if dist[a] == INF {continue;}
            if dist[b] > dist[a] + c {
                dist[b] = dist[a] + c;
            }
        }
    }

    let ans = dist[n-1];
    let mut negative = vec![false; NMAX];
    for _ in 0..n {
        for &(a, b, c) in &abcs {
            if  dist[a] == INF {continue};

            if dist[b] > dist[a] + c {
                dist[b] = dist[a] + c;
                negative[b] = true;
            }
            if negative[a] {
                negative[b] = true;
            }
        }
    }
    if negative[n-1] {
        println!("inf");
    } else {
        println!("{}", -ans);
    }
}

#[allow(unused_doc_comments)]
#[cfg(test)]
mod tests {
    #[test]
    fn tester() {
        let inputs = [
("
 3 3
1 2 4
2 3 3
1 3 5
", "
7
"),

("
 2 2
1 2 1
2 1 1
", "
inf
"),

("
 6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
", "
-5000000000
"),
        ];

        for (input, expected) in inputs.iter() {
            call(input, expected.to_string());
        }
    }

    fn call<T: AsRef<str>>(input: T, expected: String) {
        use std::process::{Command, Stdio};
        use std::io::{Read, Write};

        let mut cmd_ls = Command::new("echo")
            .arg(input.as_ref())
            .stdout(Stdio::piped())
            .spawn()
            .unwrap();
        let mut cmd_grep = Command::new("cargo")
            .arg("run")
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .spawn()
            .unwrap();

        if let Some(ref mut stdout) = cmd_ls.stdout {
            if let Some(ref mut stdin) = cmd_grep.stdin {
                let mut buf: Vec<u8> = Vec::new();
                stdout.read_to_end(&mut buf).unwrap();
                stdin.write_all(&buf).unwrap();
            }
        }

        let res = cmd_grep.wait_with_output().unwrap().stdout;

        let res_string: String = String::from_utf8(res.to_vec()).unwrap();

        // convert '\n' into space
        let actual = res_string
            .replace("\n", " ")
            .trim_end_matches(" ")
            .trim_start_matches(" ")
            .to_owned();
        let expected = expected
            .replace("\n", " ")
            .trim_end_matches(" ")
            .trim_start_matches(" ")
            .to_owned();

        // split into a vector
        let actual = actual
            .split(" ")
            .map(|s| s.parse::<String>().unwrap())
            .collect::<Vec<_>>();
        let expected = expected
            .split(" ")
            .map(|s| s.parse::<String>().unwrap())
            .collect::<Vec<_>>();

        assert_eq!(actual, expected);
    }
}


Measured memory_bytes: 4352