use std::io::BufRead;
use std::io;


trait PipeTrait: Iterator {
    fn pipe<T>(self, transform: T) -> Pipe<Self, T>
    where
        Self: Sized,
        T: Transform<In = Self::Item>,
    {
        Pipe::new(self, transform)
    }
}


// Pipe Struct/Impl
struct Pipe<I, T> {
    iter: I,
    transform: T,
}

impl<T: Transform<In = I::Item>, I: Iterator> Pipe<I, T> {
    fn new(iter: I, transform: T) -> Pipe<I, T> {
        Pipe { iter, transform }
    }
}

impl<T: Transform<In = I::Item>, I: Iterator> Iterator for Pipe<I, T> {
    type Item = T::Out;
    fn next(&mut self) -> Option<T::Out> {
        self.transform.transform(&mut self.iter)
    }
}

trait Transform {
    type In;
    type Out;
    fn transform<I: Iterator<Item = Self::In>>(&mut self, iter: &mut I) -> Option<Self::Out>;
}




// Sample Transform implementation
struct Splitter<'a> {
	delim: &'a str,
    buffer: std::str::Split<'a, &'a str>,
}
impl <'a>Splitter<'a> {
	fn new(delim: &'a str) -> Splitter<'a> {
		let b = "".split(delim);
		Splitter {delim, buffer: b}
	}
}
impl <'a>Transform for Splitter<'a> {
    type In = Result<String, std::io::Error>;
    type Out = &'a str;
    fn transform<I: Iterator<Item = Self::In>>(&mut self, iter: &'a mut I) -> Option<Self::Out> {
    	match self.buffer.next() {
    		Some(value) => return Some(value),
    		None => {
	        	match iter.next() {
		            Some(next_str) => {
		            	let a = self.delim;
		            	let b = next_str.unwrap();
	        			let c = b.split(a);
	        			self.buffer = c
	        		},
	        		None => return None
		        }
		    }
        }
        self.buffer.next()
    }
}







fn main() {
	impl<I: Iterator> PipeTrait for I {}


	let s1 = Splitter::new("j");

	let stdin = io::stdin();
	let lines = stdin.lock().lines();

    for v in lines.pipe(s1)
    {
        println!("{}", v);
    }
}