fn main() {
    let stdin = std::io::read_to_string(std::io::stdin().lock()).unwrap();
    let mut stdin = stdin.split_ascii_whitespace();

    let n: usize = stdin.next().unwrap().parse().unwrap();

    use std::io::Write;
    std::io::stdout()
        .lock()
        .write_all(output(solve(n)).as_bytes())
        .unwrap();
}

const fn prepare() -> [[f64; 1 << 6]; 20] {
    let mut doubling = [[0.0; 1 << 6]; 20];

    let mut k = 0;
    while k < 6 {
        doubling[0][1 << k] = 1.0 / 6.0;
        k += 1;
    }

    let mut i = 1;
    while i < doubling.len() {
        let mut j = 0;
        while j < (1 << 6) {
            let mut k = 0;
            while k < (1 << 6) {
                doubling[i][j | k] += doubling[i - 1][j] * doubling[i - 1][k];
                k += 1;
            }
            j += 1;
        }
        i += 1;
    }

    doubling
}

fn solve(n: usize) -> f64 {
    const DOUBLING: [[f64; 1 << 6]; 20] = prepare();
    let mut dp_cur = [0.0; 1 << 6];
    let mut dp_next = [0.0; 1 << 6];
    dp_cur[0] = 1.0;

    (0..20).for_each(|i| {
        if ((n >> i) & 1) == 1 {
            dp_next.fill(0.0);
            (0..(1 << 6)).for_each(|j| {
                (0..(1 << 6)).for_each(|k| dp_next[j | k] += dp_cur[j] * DOUBLING[i][k])
            })
        } else {
            dp_next.copy_from_slice(&dp_cur);
        }
        dp_cur.swap_with_slice(&mut dp_next);
    });
    dp_cur[(1 << 6) - 1]
}

fn output(ans: f64) -> String {
    ans.to_string() + "\n"
}