1. use std::fmt::Debug;
  2. use std::io::*;
  3.  
  4. fn reader() -> WordReader {
  5.     WordReader::new()
  6. }
  7.  
  8. fn writer() -> BufWriter<Stdout> {
  9.     BufWriter::new(stdout())
  10. }
  11. struct WordReader {
  12.     buf: Vec<u8>,
  13.     pos: usize,
  14.     lock: std::io::StdinLock<'static>,
  15. }
  16.  
  17. impl WordReader {
  18.    fn new() -> Self {
  19.        let r = unsafe { &*Box::into_raw(Box::new(stdin())) };
  20.        Self {
  21.            lock: r.lock(),
  22.            buf: Vec::new(),
  23.            pos: 0,
  24.        }
  25.    }
  26.    fn next_line(&mut self) -> bool {
  27.        self.buf.clear();
  28.        self.pos = 0;
  29.        self.lock.read_until(b'\n', &mut self.buf).unwrap_or(0) > 0
  30.    }
  31.    fn is_whitespace(c: u8) -> bool {
  32.        c == b' ' || c == b'\r' || c == b'\n' || c == b'\t'
  33.    }
  34.    fn byte(&mut self) -> Option<u8> {
  35.        if self.pos == self.buf.len() && !self.next_line() {
  36.            return None;
  37.        }
  38.        self.pos += 1;
  39.        Some(self.buf[self.pos - 1])
  40.    }
  41.    fn vb(&mut self) -> Vec<u8> {
  42.        let mut vector = Vec::with_capacity(8);
  43.        let mut b = false;
  44.        while let Some(c) = self.byte() {
  45.            if !Self::is_whitespace(c) {
  46.                vector.push(c);
  47.                b = true;
  48.            } else if b {
  49.                break;
  50.            }
  51.        }
  52.        vector
  53.    }
  54. }
  55.  
  56. fn next_permutation<T: Ord + Debug>(vector: &mut [T]) -> bool {
  57.    let n = vector.len();
  58.    for i in (0..n - 1).rev() {
  59.        if vector[i] < vector[i + 1] {
  60.            for j in (i + 1..n).rev() {
  61.                if vector[i] < vector[j] {
  62.                    vector.swap(i, j);
  63.                    break;
  64.                }
  65.            }
  66.            vector[i + 1..n].reverse();
  67.            return true;
  68.        }
  69.    }
  70.    false
  71. }
  72.  
  73. fn main() {
  74.    let mut input = reader();
  75.    let mut output = writer();
  76.    let mut vector = input.vb();
  77.    vector.sort();
  78.    let mut result = Vec::new();
  79.    result.push(vector.clone());
  80.    while next_permutation(&mut vector) {
  81.        result.push(vector.clone());
  82.    }
  83.    writeln!(output, "{}", result.len()).ok();
  84.    result
  85.        .into_iter()
  86.        .for_each(|r| writeln!(output, "{}", String::from_utf8(r).unwrap()).unwrap());
  87. }
  88.