// use std::fs;
struct Prng {
    a: u16,
    b: u16,
    c: u16,
    s0: u16,
    s1: u16,
}

impl Iterator for Prng {
    type Item = u8;

    fn next(&mut self) -> Option<u8> {
        let r = self.s0;
        self.s0 = self.s1;
        self.s1 = ((self.a * self.s1) % 257 + (self.b * r) % 257 + self.c) % 257;
        Some((r % 256) as u8)
    }
}

impl Prng {
    fn new(s0: u16, s1: u16) -> Self {
        Self {
            s0: s0 % 257,
            s1: s1 % 257,
            a: 97,
            b: 212,
            c: 42,
        }
    }
}

fn main() {
    // let c: &[u8] = &[0x4E, 0x7E, 0x3D, 0x88, 0x8E, 0x01, 0x0D, 0x84];
    // let p: &[u8] = &[0x68, 0x74, 0x74, 0x70, 0x73, 0x3A, 0x2F, 0x2F];
    // c.iter()
    //     .zip(p.iter())
    //     .map(|(c, p)| c ^ p)
    //     .for_each(|k| print!("{:02X} ", k));

    let c: &[u8] = &[
        0x4E, 0x7E, 0x3D, 0x88, 0x8E, 0x01, 0x0D, 0x84, 0xB8, 0x7E, 0xBF, 0x1A, 0x25, 0x37, 0xFA,
        0x4D, 0x89, 0x87, 0x91, 0xFA, 0x50, 0x51, 0xFC, 0x42, 0x7A, 0x9A, 0x6A, 0xE4,
    ];
    let p = Prng::new(0x26, 0x0a);

    c.into_iter()
        .zip(p)
        .map(|(c, k)| c ^ k)
        .map(|c| c as char)
        .for_each(|c| print!("{}", c));
    println!();

    // let key: &[u8] = &[0xba, 0xad, 0xa5, 0x55, 0xc0, 0x00, 0x10, 0xff];
    // // let cipher: &[u8] = &[0x33, 0xfd, 0xeb, 0x12, 0xcd, 0x0a, 0x0a, 0xf5];
    // // let key: &[u8] = &[0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
    // // cipher
    // //     .iter()
    // //     .zip(key.iter())
    // //     .map(|(c, k)| c ^ k)
    // //     .for_each(|p| print!("0x{:x} ", p));

    // let args: Vec<_> = std::env::args().skip(1).collect();
    // let data = fs::read(&args[0]).expect("Cannot read");
    // let plain: Vec<_> = data
    //     .into_iter()
    //     .zip(key.into_iter().cycle())
    //     .map(|(c, k)| c ^ k)
    //     .collect();

    // fs::write(&args[1], plain).expect("Cannot write");
}

// fn main() {
//     let cipher: &[u8] = &[
//         0xDC, 0x48, 0x13, 0x3B, 0x9C, 0x4C, 0x49, 0x80, 0xAC, 0xA7, 0xB9, 0x54, 0xF2, 0x7C, 0x2B,
//         0x9E, 0xD5, 0xDF, 0x0D, 0x05, 0xB3, 0x1D, 0x4E, 0xF8,
//     ];
//     let key: &[u8] = &[
//         0x98, 0x29, 0x60, 0x72, 0xF2, 0x38, 0x2C, 0xF2, 0xC2, 0xC2, 0xCD, 0x1D, 0x81, 0x08, 0x65,
//         0xFB, 0xA0, 0xB3, 0x6C, 0x6B, 0xD7, 0x3C, 0x6F, 0xD9,
//     ];
//     cipher.iter().for_each(|c| print!("0x{:X} ", c));
//     println!();
//     key.iter().for_each(|c| print!("0x{:X} ", c));
//     println!();
//     cipher
//         .iter()
//         .zip(key.iter())
//         .map(|(c, k)| c ^ k)
//         .for_each(|p| print!("{:X} ", p));
//     println!();

//     cipher
//         .iter()
//         .zip(key.iter())
//         .map(|(c, k)| c ^ k)
//         .map(|c| c as char)
//         .for_each(|p| print!("{} ", p));
//     println!();
// }