#![allow(unused_imports, unused_macros)]

use kyoproio::*;
use std::{
    collections::*,
    io::{self, prelude::*},
    iter,
    mem::{replace, swap},
};

fn run<I: Input, O: Write>(mut kin: I, mut out: O) {
    macro_rules! output { ($($args:expr),+) => { write!(&mut out, $($args),+).unwrap(); }; }
    macro_rules! outputln {
        ($($args:expr),+) => { output!($($args),+); outputln!(); };
        () => { output!("\n"); if cfg!(debug_assertions) { out.flush().unwrap(); } }
    }

    let (k, m, n): (usize, usize, u64) = kin.input();
    let mut mat = SquareMat::zeros(k * k);
    let mut vec = vec![mint(0); k * k];
    for (p, q, r) in kin.iter::<(usize, usize, usize)>().take(m) {
        let (p, q, r) = (p - 1, q - 1, r - 1);
        mat[k * q + r][k * p + q] = mint(1);
        if p == 0 {
            vec[q] = mint(1);
        }
    }
    mat = mat.pow(n - 2);
    let vec2 = &mat * &vec;
    let mut ans = mint(0);
    for i in 0..k {
        ans += vec2[k * i];
    }
    outputln!("{}", ans);
}
use std::ops;
pub trait Zero {
    fn zero() -> Self;
}
pub trait One {
    fn one() -> Self;
}
#[derive(Clone)]
pub struct SquareMat<T> {
    a: Box<[T]>,
    n: usize,
}
impl<T: Zero> SquareMat<T> {
    pub fn zeros(n: usize) -> Self {
        Self {
            a: (0..n * n).map(|_| T::zero()).collect(),
            n,
        }
    }
}
impl<T: Zero + One> SquareMat<T> {
    pub fn id(n: usize) -> Self {
        let mut mat = Self::zeros(n);
        for i in 0..n {
            mat[i][i] = T::one();
        }
        mat
    }
}
impl<T> SquareMat<T> {
    pub fn deg(&self) -> usize {
        self.n
    }
    pub fn transpose(mut self) -> Self {
        for i in 0..self.n {
            for j in i + 1..self.n {
                unsafe {
                    std::ptr::swap(&mut self[i][j], &mut self[j][i]);
                }
            }
        }
        self
    }
    pub fn iter(&self) -> Iter<T> {
        Iter { mat: self, i: 0 }
    }
    pub fn get(&self, i: usize) -> Option<&[T]> {
        debug_assert_eq!(self.n * self.n, self.a.len());
        if i < self.n {
            unsafe { Some(self.a.get_unchecked(self.n * i..self.n * (i + 1))) }
        } else {
            None
        }
    }
    pub fn get_mut(&mut self, i: usize) -> Option<&mut [T]> {
        debug_assert_eq!(self.n * self.n, self.a.len());
        if i < self.n {
            unsafe { Some(self.a.get_unchecked_mut(self.n * i..self.n * (i + 1))) }
        } else {
            None
        }
    }
}
impl<T: Zero + One + ops::AddAssign> SquareMat<T>
where
    for<'a> &'a T: ops::Mul<Output = T>,
{
    pub fn pow(mut self, mut k: u64) -> Self {
        let mut res = Self::id(self.n);
        let mut tmp = Self::zeros(self.n);
        loop {
            if k % 2 == 1 {
                for j in 0..self.n {
                    for i in 0..self.n {
                        tmp[j][i] = T::zero();
                        for k in 0..self.n {
                            tmp[j][i] += &self[i][k] * &res[j][k];
                        }
                    }
                }
                std::mem::swap(&mut res, &mut tmp);
            }
            k /= 2;
            if k == 0 {
                return res.transpose();
            }
            tmp.mul_write(&self, &self);
            std::mem::swap(&mut self, &mut tmp);
        }
    }
}
impl<T: ops::AddAssign + Zero> SquareMat<T>
where
    for<'a> &'a T: ops::Mul<Output = T>,
{
    fn mul_write(&mut self, a: &Self, b: &Self) {
        assert_eq!(self.n, a.n);
        assert_eq!(self.n, b.n);
        for i in 0..self.n {
            for j in 0..self.n {
                self[i][j] = T::zero();
                for k in 0..self.n {
                    self[i][j] += &a[i][k] * &b[k][j];
                }
            }
        }
    }
}
impl<T: Zero + ops::Add<Output = T>> ops::Mul<&[T]> for &SquareMat<T>
where
    for<'a> &'a T: ops::Mul<Output = T>,
{
    type Output = Vec<T>;
    fn mul(self, v: &[T]) -> Self::Output {
        self.iter()
            .map(|r| {
                r.iter()
                    .zip(v.iter())
                    .map(|(x, y)| x * y)
                    .fold(T::zero(), |x, y| x + y)
            })
            .collect()
    }
}
/*
impl<T> ops::Index<usize> for SquareMat<T> {
    type Output = [T];
    fn index(&self, i: usize) -> &[T] {
        assert!(i < self.n, "deg = {}, i = {}", self.n, i);
        self.get(i).unwrap()
    }
}
impl<T> ops::IndexMut<usize> for SquareMat<T> {
    fn index_mut(&mut self, i: usize) -> &mut [T] {
        assert!(i < self.n, "deg = {}, i = {}", self.n, i);
        self.get_mut(i).unwrap()
    }
}
*/
impl<T> ops::Index<usize> for SquareMat<T> {
    type Output = [T];
    fn index(&self, i: usize) -> &[T] {
        assert!(i < self.n);
        unsafe { self.a.get_unchecked(self.n * i..self.n * (i + 1)) }
    }
}
impl<T> ops::IndexMut<usize> for SquareMat<T> {
    fn index_mut(&mut self, i: usize) -> &mut [T] {
        assert!(i < self.n);
        unsafe { self.a.get_unchecked_mut(self.n * i..self.n * (i + 1)) }
    }
}
impl<T: fmt::Debug> fmt::Debug for SquareMat<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_list()
            .entries((0..self.n).map(|i| &self[i]))
            .finish()
    }
}
pub struct Iter<'a, T> {
    mat: &'a SquareMat<T>,
    i: usize,
}
impl<'a, T> Iterator for Iter<'a, T> {
    type Item = &'a [T];
    fn next(&mut self) -> Option<Self::Item> {
        if self.i < self.mat.n {
            let i = self.i;
            self.i += 1;
            Some(&self.mat[i])
        } else {
            None
        }
    }
}

impl<M: Modulo> Zero for ModInt<M> {
    fn zero() -> Self {
        Self::new(0)
    }
}
impl<M: Modulo> One for ModInt<M> {
    fn one() -> Self {
        Self::new(1)
    }
}
pub type Mint = ModInt<Mod1e9p7>;
pub fn mint(x: i32) -> Mint {
    ModInt::new(x)
}
pub trait Modulo {
    fn modulo() -> i32;
}
macro_rules! modulo_impl {
    ($($Type:ident $val:tt)*) => {
        $(pub struct $Type;
        impl Modulo for $Type {
            fn modulo() -> i32 {
                $val
            }
        })*
    };
}
modulo_impl!(Mod998244353 998244353 Mod1e9p7 1000000007);
use std::sync::atomic;
pub struct VarMod;
static VAR_MOD: atomic::AtomicI32 = atomic::AtomicI32::new(0);
pub fn set_var_mod(m: i32) {
    VAR_MOD.store(m, atomic::Ordering::Relaxed);
}
impl Modulo for VarMod {
    fn modulo() -> i32 {
        VAR_MOD.load(atomic::Ordering::Relaxed)
    }
}
use std::{fmt, marker::PhantomData /*ops*/};
pub struct ModInt<M>(i32, PhantomData<M>);
impl<M: Modulo> ModInt<M> {
    pub fn new(x: i32) -> Self {
        debug_assert!(x < M::modulo());
        Self(x, PhantomData)
    }
    pub fn normalize(self) -> Self {
        if self.0 < M::modulo() && 0 <= self.0 {
            self
        } else {
            Self::new(self.0.rem_euclid(M::modulo()))
        }
    }
    pub fn get(self) -> i32 {
        self.0
    }
    pub fn inv(self) -> Self {
        self.pow(M::modulo() - 2)
    }
    pub fn half(self) -> Self {
        Self::new(self.0 / 2 + self.0 % 2 * ((M::modulo() + 1) / 2))
    }
    pub fn modulo() -> i32 {
        M::modulo()
    }
}
impl<M: Modulo> ops::Neg for ModInt<M> {
    type Output = Self;
    fn neg(self) -> Self {
        Self::new(if self.0 == 0 { 0 } else { M::modulo() - self.0 })
    }
}
impl<M: Modulo> ops::AddAssign for ModInt<M> {
    fn add_assign(&mut self, rhs: Self) {
        self.0 += rhs.0;
        if self.0 >= M::modulo() {
            self.0 -= M::modulo();
        }
    }
}
impl<M: Modulo> ops::SubAssign for ModInt<M> {
    fn sub_assign(&mut self, rhs: Self) {
        self.0 -= rhs.0;
        if self.0 < 0 {
            self.0 += M::modulo();
        }
    }
}
impl<M: Modulo> ops::MulAssign for ModInt<M> {
    fn mul_assign(&mut self, rhs: Self) {
        self.0 = (self.0 as u32 as u64 * rhs.0 as u32 as u64 % M::modulo() as u32 as u64) as i32;
    }
}
impl<M: Modulo> ops::DivAssign for ModInt<M> {
    fn div_assign(&mut self, rhs: Self) {
        assert_ne!(rhs.get(), 0);
        *self *= rhs.inv();
    }
}
macro_rules! op_impl {
    ($($Op:ident $op:ident $OpAssign:ident $op_assign:ident)*) => {
        $(impl<M: Modulo> ops::$Op for ModInt<M> {
            type Output = Self;
            fn $op(self, rhs: Self) -> Self {
                let mut res = self;
                ops::$OpAssign::$op_assign(&mut res, rhs);
                res
            }
        }
        impl<M: Modulo> ops::$Op<&Self> for ModInt<M> {
            type Output = Self;
            fn $op(self, rhs: &Self) -> Self {
                self.$op(*rhs)
            }
        }
        impl<M: Modulo> ops::$Op<ModInt<M>> for &ModInt<M> {
            type Output = ModInt<M>;
            fn $op(self, rhs: ModInt<M>) -> ModInt<M> {
                (*self).$op(rhs)
            }
        }
        impl<M: Modulo> ops::$Op<&ModInt<M>> for &ModInt<M> {
            type Output = ModInt<M>;
            fn $op(self, rhs: &ModInt<M>) -> ModInt<M> {
                (*self).$op(*rhs)
            }
        }
        impl<M: Modulo> ops::$OpAssign<&ModInt<M>> for ModInt<M> {
            fn $op_assign(&mut self, rhs: &ModInt<M>) {
                self.$op_assign(*rhs);
            }
        })*
    };
}
op_impl! {
    Add add AddAssign add_assign
    Sub sub SubAssign sub_assign
    Mul mul MulAssign mul_assign
    Div div DivAssign div_assign
}
impl<M: Modulo> std::iter::Sum for ModInt<M> {
    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
        iter.fold(ModInt::new(0), |x, y| x + y)
    }
}
impl<M: Modulo> std::iter::Product for ModInt<M> {
    fn product<I: Iterator<Item = Self>>(iter: I) -> Self {
        iter.fold(ModInt::new(1), |x, y| x * y)
    }
}
pub trait Pow<T> {
    fn pow(self, n: T) -> Self;
}
impl<M: Modulo> Pow<u32> for ModInt<M> {
    fn pow(mut self, mut n: u32) -> Self {
        let mut y = Self::new(1);
        while n > 0 {
            if n % 2 == 1 {
                y *= self;
            }
            self *= self;
            n /= 2;
        }
        y
    }
}
macro_rules! mod_int_pow_impl {
    ($($T:ident)*) => {
        $(impl<M: Modulo> Pow<$T> for ModInt<M> {
            fn pow(self, n: $T) -> Self {
                self.pow(n.rem_euclid(M::modulo() as $T - 1) as u32)
            }
        })*
    };
}
mod_int_pow_impl!(isize i32 i64 usize u64);
macro_rules! mod_int_from_impl {
    ($($T:ident)*) => {
        $(impl<M: Modulo> From<$T> for ModInt<M> {
            fn from(x: $T) -> Self {
                if M::modulo() <= $T::max_value() as i32 {
                    Self::new(x.rem_euclid(M::modulo() as $T) as i32)
                } else {
                    Self::new(x as i32).normalize()
                }
            }
        })*
    }
}
mod_int_from_impl!(isize i8 i16 i32 i64 i128 usize u8 u16 u32 u64 u128);
impl<M> Copy for ModInt<M> {}
impl<M> Clone for ModInt<M> {
    fn clone(&self) -> Self {
        *self
    }
}
impl<M: Modulo> Default for ModInt<M> {
    fn default() -> Self {
        Self::new(0)
    }
}
impl<M> std::cmp::PartialEq for ModInt<M> {
    fn eq(&self, other: &Self) -> bool {
        self.0 == other.0
    }
}
impl<M> std::cmp::Eq for ModInt<M> {}
impl<M> std::cmp::PartialOrd for ModInt<M> {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        self.0.partial_cmp(&other.0)
    }
}
impl<M> std::cmp::Ord for ModInt<M> {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.0.cmp(&other.0)
    }
}
impl<M> std::hash::Hash for ModInt<M> {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        self.0.hash(state);
    }
}
impl<M> fmt::Display for ModInt<M> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}
impl<M> fmt::Debug for ModInt<M> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}

// -----------------------------------------------------------------------------
fn main() -> io::Result<()> {
    std::thread::Builder::new()
        .stack_size(64 * 1024 * 1024)
        .spawn(|| {
            run(
                KInput::new(io::stdin()),
                io::BufWriter::new(io::stdout().lock()),
            )
        })?
        .join()
        .unwrap();
    Ok(())
}

// -----------------------------------------------------------------------------
pub mod kyoproio {
    use std::{io::prelude::*, mem};
    pub trait Input {
        fn bytes(&mut self) -> &[u8];
        fn str(&mut self) -> &str {
            std::str::from_utf8(self.bytes()).unwrap()
        }
        fn input<T: InputParse>(&mut self) -> T {
            T::input(self)
        }
        fn iter<T: InputParse>(&mut self) -> Iter<T, Self> {
            Iter(self, std::marker::PhantomData)
        }
        fn seq<T: InputParse, B: std::iter::FromIterator<T>>(&mut self, n: usize) -> B {
            self.iter().take(n).collect()
        }
    }
    pub struct KInput<R> {
        src: R,
        buf: Vec<u8>,
        pos: usize,
        len: usize,
    }
    impl<R: Read> KInput<R> {
        pub fn new(src: R) -> Self {
            Self {
                src,
                buf: vec![0; 1 << 16],
                pos: 0,
                len: 0,
            }
        }
    }
    impl<R: Read> Input for KInput<R> {
        fn bytes(&mut self) -> &[u8] {
            loop {
                while let Some(delim) = self.buf[self.pos..self.len]
                    .iter()
                    .position(|b| b.is_ascii_whitespace())
                {
                    let p = self.pos;
                    self.pos += delim + 1;
                    if delim > 0 {
                        return &self.buf[p..p + delim];
                    }
                }
                if self.read() == 0 {
                    return &self.buf[mem::replace(&mut self.pos, self.len)..self.len];
                }
            }
        }
    }
    impl<R: Read> KInput<R> {
        fn read(&mut self) -> usize {
            if self.pos > 0 {
                self.buf.copy_within(self.pos..self.len, 0);
                self.len -= self.pos;
                self.pos = 0;
            } else if self.len >= self.buf.len() {
                self.buf.resize(2 * self.buf.len(), 0);
            }
            let read = self.src.read(&mut self.buf[self.len..]).unwrap();
            self.len += read;
            read
        }
    }
    pub struct Iter<'a, T, I: ?Sized>(&'a mut I, std::marker::PhantomData<*const T>);
    impl<'a, T: InputParse, I: Input + ?Sized> Iterator for Iter<'a, T, I> {
        type Item = T;
        fn next(&mut self) -> Option<T> {
            Some(self.0.input())
        }
        fn size_hint(&self) -> (usize, Option<usize>) {
            (!0, None)
        }
    }
    pub trait InputParse: Sized {
        fn input<I: Input + ?Sized>(src: &mut I) -> Self;
    }
    impl InputParse for Vec<u8> {
        fn input<I: Input + ?Sized>(src: &mut I) -> Self {
            src.bytes().to_owned()
        }
    }
    macro_rules! from_str_impl {
        { $($T:ty)* } => {
            $(impl InputParse for $T {
                fn input<I: Input + ?Sized>(src: &mut I) -> Self {
                    src.str().parse::<$T>().unwrap()
                }
            })*
        }
    }
    from_str_impl! { String char bool f32 f64 }
    macro_rules! parse_int_impl {
        { $($I:ty: $U:ty)* } => {
            $(impl InputParse for $I {
                fn input<I: Input + ?Sized>(src: &mut I) -> Self {
                    let f = |s: &[u8]| s.iter().fold(0, |x, b| 10 * x + (b & 0xf) as $I);
                    let s = src.bytes();
                    if let Some((&b'-', t)) = s.split_first() { -f(t) } else { f(s) }
                }
            }
            impl InputParse for $U {
                fn input<I: Input + ?Sized>(src: &mut I) -> Self {
                    src.bytes().iter().fold(0, |x, b| 10 * x + (b & 0xf) as $U)
                }
            })*
        };
    }
    parse_int_impl! { isize:usize i8:u8 i16:u16 i32:u32 i64:u64 i128:u128 }
    macro_rules! tuple_impl {
        ($H:ident $($T:ident)*) => {
            impl<$H: InputParse, $($T: InputParse),*> InputParse for ($H, $($T),*) {
                fn input<I: Input + ?Sized>(src: &mut I) -> Self {
                    ($H::input(src), $($T::input(src)),*)
                }
            }
            tuple_impl!($($T)*);
        };
        () => {}
    }
    tuple_impl!(A B C D E F G);
    macro_rules! array_impl {
        { $($N:literal)* } => {
            $(impl<T: InputParse> InputParse for [T; $N] {
                fn input<I: Input + ?Sized>(src: &mut I) -> Self {
                    let mut arr = mem::MaybeUninit::uninit();
                    unsafe {
                        let ptr = arr.as_mut_ptr() as *mut T;
                        for i in 0..$N {
                            ptr.add(i).write(src.input());
                        }
                        arr.assume_init()
                    }
                }
            })*
        };
    }
    array_impl! { 1 2 3 4 5 6 7 8 }
    #[macro_export]
    macro_rules! kdbg {
        ($($v:expr),*) => {
            if cfg!(debug_assertions) { dbg!($($v),*) } else { ($($v),*) }
        }
    }
}