use std::fmt;
use std::io::{self, BufRead};
use std::time::Instant;

struct Graph {
    size: usize,
    matrix: Vec<Vec<u8>>,
}

impl Clone for Graph {
    fn clone(&self) -> Self {
        let mut matrix = vec![vec![0; self.size]; self.size];
        for row in 0..self.size {
            for col in 0..self.size {
                matrix[row][col] = self.matrix[row][col];
            }
        }
        return Graph {
            size: self.size,
            matrix,
        };
    }
}

impl fmt::Display for Graph {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        for row in 0..self.size {
            for col in 0..self.size {
                write!(f, "{}", self.matrix[row][col])?;
                if col < self.size - 1 {
                    write!(f, " ")?;
                }
            }
            if row < self.size - 1 {
                write!(f, "\n")?;
            }
        }
        return Ok(());
    }
}

impl Graph {
    fn from_g6(line: &String) -> Graph {
        let mut chars: Vec<u8> = Vec::new();
        for character in line.chars() {
            chars.push((character as i32 - 63) as u8);
        }
        // TODO: spec allows multi-byte vector size
        let size = chars[0] as usize;
        let bytes = &chars[1..];

        let mut matrix: Vec<Vec<u8>> = vec![vec![0; size]; size];
        let mut i = 0;
        for col in 1..size {
            for row in 0..col {
                let bit: u8 = bytes[i / 6] >> (5 - i % 6) & 1;
                matrix[row][col] = bit;
                matrix[col][row] = bit;
                i += 1;
            }
        }
        return Graph { size, matrix };
    }

    fn degree(&self, vertex: usize) -> usize {
        let mut sum: usize = 0;
        for i in &self.matrix[vertex] {
            sum += *i as usize;
        }
        return sum;
    }

    fn get_closure(&self) -> Graph {
        let mut closure = self.clone();
        for _ in 0..(closure.size * closure.size) {
            for row in 0..closure.size {
                for col in 0..closure.size {
                    if row == col {
                        continue;
                    }
                    let sum = closure.degree(row) + closure.degree(col);
                    if sum >= closure.size {
                        closure.matrix[row][col] = 1;
                    }
                }
            }
        }
        return closure;
    }

    fn is_complete(&self) -> bool {
        for row in 0..self.size {
            for col in 0..self.size {
                if row != col && self.matrix[row][col] != 1 {
                    return false;
                }
            }
        }
        return true;
    }
}

fn main() {
    let stdin = io::stdin();

    let mut t = 0;
    let mut count = 0;
    for line in stdin.lock().lines() {
        let line = line.unwrap();

        let start = Instant::now();
        let g = Graph::from_g6(&line);
        let closure = g.get_closure();
        if closure.is_complete() {
            count += 1;
        }
        let elapsed = start.elapsed();
        t += elapsed.as_nanos();
    }

    println!("Time elapsed: {}s", t as f64 / 1e9);
    println!("Count of Hamiltonian graphs: {}", count);
}