use std::io::BufRead;

pub struct StdinReader<R: BufRead> {
    pub buf_reader: R,
    pub buf: String,
}

impl<R: BufRead> StdinReader<R> {
    pub fn new(r: R) -> Self {
        StdinReader {
            buf_reader: r,
            buf: String::with_capacity(10000),
        }
    }
}

#[macro_export]
macro_rules! input {
    ($reader : expr, $t : ty) => { // one variable
        match &mut $reader {
            reader => {
                use std::io::BufRead;
                reader.buf_reader.read_line(&mut reader.buf).unwrap();
                let tmp_var: $t = reader.buf.trim().parse().unwrap();
                reader.buf.clear();
                tmp_var
            },
        }
    };
    ($reader : expr, $t0 : ty, $t1 : ty) => { // 2 tuple
        match &mut $reader {
            reader => {
                use std::io::BufRead;
                reader.buf_reader.read_line(&mut reader.buf).unwrap();
                let tmp_var: Vec<$t0> = reader.buf.trim().split_whitespace().map(|a| a.parse().unwrap()).collect();
                reader.buf.clear();
                (tmp_var[0].clone(), tmp_var[1].clone())
            }
        }
    };
    ($reader : expr, $t0 : ty, $t1 : ty, $t2 : ty) => { // 3 tuple
        match &mut $reader {
            reader => {
                use std::io::BufRead;
                reader.buf_reader.read_line(&mut reader.buf).unwrap();
                let tmp_var: Vec<$t0> = reader.buf.trim().split_whitespace().map(|a| a.parse().unwrap()).collect();
                reader.buf.clear();
                (tmp_var[0].clone(), tmp_var[1].clone(), tmp_var[2].clone())
            }
        }
    };
    ($reader : expr, $t : ty; $size : expr) => { // Vector
        match &mut $reader {
            reader => {
                use std::io::BufRead;
                reader.buf_reader.read_line(&mut reader.buf).unwrap();
                let tmp_var: $t = reader.buf.trim().split_whitespace().map(|a| a.parse().unwrap()).collect();
                reader.buf.clear();
                tmp_var
            }
        }
    };
}

fn main() {
    solve_d();
}

fn solve_d() {
    let mm = 1000000007;
    let handle = std::io::stdin();
    let mut r = StdinReader::new(handle.lock());
    let n: usize = input!(r, usize);
    let mut memo: Vec<Vec<Vec<Vec<usize>>>> = vec![vec![vec![vec![0; 4]; 4]; 4]; n+1];
    memo[0][3][3][3] = 1;
    for len in 0..n {
        for i in 0..4 {
            for j in 0..4 {
                for k in 0..4 {
                    if memo[len][i][j][k] == 0 { continue; }
                    for a in 0..4 {
                        if a == 2 && k == 1 && j == 0 { continue; }
                        if a == 2 && k == 0 && j == 1 { continue; }
                        if a == 1 && k == 2 && j == 0 { continue; }
                        if a == 2 && k == 1 && i == 0 { continue; }
                        if a == 2 && j == 1 && i == 0 { continue; }
                        memo[len+1][j][k][a] += memo[len][i][j][k];
                        memo[len+1][j][k][a] %= mm;
                    }
                }
            }
        }
    }
    println!("{}", memo[n].iter()
        .map(|i| i.into_iter()
            .map(|j| j.into_iter().sum::<usize>() % mm)
            .sum::<usize>() % mm)
        .sum::<usize>() % mm);
}



Measured memory_bytes: 4352