#[macro_use] extern crate lazy_static;
extern crate regex;

use std::str::FromStr;
use std::io::{self, BufRead};
use std::fmt;


struct Screen {
    screen: Vec<Vec<bool>>
}

impl Screen {
    fn new(width: usize, height: usize) -> Self {
        Screen {
            screen: vec![vec![false; width]; height]
        }
    }

    fn set(&mut self, display: &str) {
        for (y, line) in display.lines().enumerate() {
            for (x, c) in line.chars().enumerate() {
                self.screen[y][x] = match c {
                    '#' => true,
                    '.' => false,
                    _   => panic!("invalid char!")
                };
            }
        }
    }

    fn get(&self) -> String {
        self.screen.iter()
            .map(|row| {
                row.iter()
                    .map(|c| if *c { '#' } else { '.' })
                    .collect::<String>()
            })
            .collect::<Vec<_>>()
            .join("\n")
    }

    fn fill_rect(&mut self, width: usize, height: usize) {
        for y in 0..height {
            for x in 0..width {
                self.screen[y][x] = true;
            }
        }
    }

    fn rotate_column(&mut self, column: usize, step: usize) {
        let swaps = self.screen.len();

        for _ in 0..step {
            for y in (1..swaps).rev() {
                let tmp = self.screen[y - 1][column];

                self.screen[y - 1][column] = self.screen[y][column];

                self.screen[y][column] = tmp;
            }
        }
    }

    fn rotate_row(&mut self, row: usize, step: usize) {
        let mut vec = &mut self.screen[row];

        let swaps = vec.len();

        for _ in 0..step {
            for x in (1..swaps).rev() {
                vec.swap(x, x - 1);
            }
        }
    }
}

impl fmt::Display for Screen {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.get())
    }
}


#[derive(Debug, PartialEq)]
enum Instruction {
    Rect { x: usize, y: usize },
    RotateColumn { x: usize, step: usize },
    RotateRow { y: usize, step: usize }
}

impl FromStr for Instruction {
    type Err = ();

    fn from_str(s: &str) -> Result<Instruction, ()> {
        use regex::Regex;

        lazy_static! {
            static ref RECT: Regex = Regex::new(r"^rect (\d+)x(\d+)$").unwrap();
            static ref R_COL: Regex = Regex::new(r"^rotate column x=(\d+) by (\d+)$").unwrap();
            static ref R_ROW: Regex = Regex::new(r"^rotate row y=(\d+) by (\d+)$").unwrap();
        }

        if let Some(caps) = RECT.captures(s) {
            let x = caps.at(1).unwrap().parse::<usize>().unwrap();
            let y = caps.at(2).unwrap().parse::<usize>().unwrap();

            return Ok(Instruction::Rect { x: x, y: y });
        }

        if let Some(caps) = R_COL.captures(s) {
            let x = caps.at(1).unwrap().parse::<usize>().unwrap();
            let step = caps.at(2).unwrap().parse::<usize>().unwrap();

            return Ok(Instruction::RotateColumn { x: x, step: step });
        }

        if let Some(caps) = R_ROW.captures(s) {
            let y = caps.at(1).unwrap().parse::<usize>().unwrap();
            let step = caps.at(2).unwrap().parse::<usize>().unwrap();

            return Ok(Instruction::RotateRow { y: y, step: step });
        }

        Err(())
    }
}


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

    let instructions = stdin.lock().lines()
        .filter_map(|line| line.ok())
        .filter_map(|line| Instruction::from_str(&line).ok());

    let mut screen = Screen::new(50, 6);

    for instruction in instructions {
        use Instruction::*;

        match instruction {
            Rect { x, y }            => screen.fill_rect(x, y),
            RotateColumn { x, step } => screen.rotate_column(x, step),
            RotateRow { y, step }    => screen.rotate_row(y, step)
        }
    }

    let count = screen.get().chars()
        .fold(0, |acc, c| if c == '#' { acc + 1 } else { acc });

    println!("{}", screen);
    println!("lit={}", count);
}


#[cfg(test)]
mod tests {
    use std::fmt::Write;
    use std::str::FromStr;

    use super::{Screen, Instruction};


    #[test]
    fn test_rect() {
        let mut screen = Screen::new(7, 3);

        screen.fill_rect(3, 2);

        let mut w = String::new();
        write!(&mut w, "{}", screen).unwrap();

        assert_eq!(w, "###....\n\
                       ###....\n\
                       .......");
    }

    #[test]
    fn test_rotate_column() {
        let mut screen = Screen::new(7, 3);

        screen.set("###....\n\
                    ###....\n\
                    .......");

        screen.rotate_column(1, 1);

        let mut w = String::new();
        write!(&mut w, "{}", screen).unwrap();

        assert_eq!(w, "#.#....\n\
                       ###....\n\
                       .#.....");
    }

    #[test]
    fn test_rotate_row() {
        let mut screen = Screen::new(7, 3);

        screen.set("#.#....\n\
                    ###....\n\
                    .#.....");

        screen.rotate_row(0, 4);

        let mut w = String::new();
        write!(&mut w, "{}", screen).unwrap();

        assert_eq!(w, "....#.#\n\
                       ###....\n\
                       .#.....");
    }

    #[test]
    fn test_parse_rect() {
        assert_eq!(Ok(Instruction::Rect { x: 1, y: 1 }), Instruction::from_str("rect 1x1"));
    }

    #[test]
    fn test_parse_rotate_column() {
        assert_eq!(Ok(Instruction::RotateColumn { x: 0, step: 1 }), Instruction::from_str("rotate column x=0 by 1"));
    }

    #[test]
    fn test_parse_rotate_row() {
        assert_eq!(Ok(Instruction::RotateRow { y: 2, step: 15 }), Instruction::from_str("rotate row y=2 by 15"));
    }
}