import java.util.*;
 
/**
 * Created by IntelliJ IDEA.
 * User: me
 * Date: 11.09.2006
 * Time: 15:21:14
 * To change this template use File | Settings | File Templates.
 */
public class ShortStrings implements Iterator {
    private Iterator strings;
    private String nextShort;
    private final int maxLen;
 
    public ShortStrings(Iterator strings, int maxLen) {
        this.strings = strings;
        this.nextShort = null;
        this.maxLen = maxLen;
    }
 
    public boolean hasNext() {
        if (nextShort != null)
            return true;
 
        while (strings.hasNext()) {
            nextShort = (String) strings.next();
            if (nextShort.length() <= maxLen)
                return true;
        }
        nextShort = null;
        return false;
    }
 
    public Object next() {
        if (nextShort == null && !hasNext())
            throw new NoSuchElementException();
 
        String n  = nextShort;
        nextShort = null;
        return n;
    }
 
    public void remove() {
        throw new UnsupportedOperationException();
    }
}

import java.util.*;
 
/**
 * Created by IntelliJ IDEA.
 * User: me
 * Date: 11.09.2006
 * Time: 15:38:21
 * To change this template use File | Settings | File Templates.
 */
public class ArrayBunchList extends AbstractList {
    private Object[][] arrays;
    private int size;
 
    // **************************** INNER >>
    private class ABLIterator implements Iterator {
        private int off;
        private int array;
        private int pos;
 
        public ABLIterator() {
            off = 0;
            pos = 0;
            // Miss all empty arrays
            for (array = 0; array < arrays.length; array++)
                if (arrays[array].length > 0)
                    break;
        }
 
        public boolean hasNext() {
            return off + pos < size();
        }
 
        public Object next() {
            if (!hasNext())
                throw new NoSuchElementException();
 
            Object ret = arrays[array][pos++];
            while (pos >= arrays[array].length) {
                off += arrays[array++].length;
                pos = 0;
                if (array >= arrays.length)
                    break;
            }
            return ret;
        }
 
        public void remove() {
            throw new UnsupportedOperationException();
        }
    }
    // **************************** << INNER
 
    public ArrayBunchList(Object[][] arrays) {
        this.arrays = (Object[][])arrays.clone();
        int s = 0;
        for (int i = 0; i < arrays.length; i++) {
            s += arrays[i].length;
        }
        size = s;
    }
 
 
    public int size() {
        return size;
    }
 
    public Object get(int index) {
        int off = 0;
        for (int i = 0; i < arrays.length; i++) {
            if (index < off + arrays[i].length)
                return arrays[i][index - off];
            off += arrays[i].length;
        }
        throw new ArrayIndexOutOfBoundsException(index);
    }
 
    public Object set(int index, Object value) {
        int off = 0;
        for (int i = 0; i < arrays.length; i++) {
            if (index < off + arrays[i].length) {
                Object ret = arrays[i][index - off];
                arrays[i][index - off] = value;
                return ret;
            }
            off += arrays[i].length;
        }
        throw new ArrayIndexOutOfBoundsException(index);
    }
 
    public Iterator iterator() {
        return new ABLIterator();
    }
}
 
 
 

import java.util.List;
import java.util.ArrayList;
 
/**
 * Created by IntelliJ IDEA.
 * User: me
 * Date: 11.09.2006
 * Time: 15:16:20
 * To change this template use File | Settings | File Templates.
 */
public class Polygon {
    private List vertices = new ArrayList();
 
    public void add(Point p) {
        vertices.add(p);
    }
 
    public void remove(Point p) {
        vertices.remove(p);
    }
 
    public int numVertices() {
        return vertices.size();
    }
}
 
class Point {
    private int x = 0, y = 0;
 
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
 
    public int getX() {
        return x;
    }
 
    public void setX(int x) {
        this.x = x;
    }
 
    public int getY() {
        return y;
    }
 
    public void setY(int y) {
        this.y = y;
    }
}

/**
 * Created by IntelliJ IDEA.
 * User: me
 * Date: 12.09.2006
 * Time: 17:09:20
 * To change this template use File | Settings | File Templates.
 */
import java.io.*;
public class CountBytes {
    public static void main(String[] args)
            throws IOException {
        InputStream in;
        if (args.length == 0)
            in = System.in;
        else
            in = new FileInputStream(args[0]);
 
        int total = 0;
        while (in.read() != -1)
            total++;
 
        System.out.println(total + " bytes");
    }
}
 

/**
 * Created by IntelliJ IDEA.
 * User: me
 * Date: 12.09.2006
 * Time: 17:17:15
 * To change this template use File | Settings | File Templates.
 */
import java.io.*;
public class TranslateByte {
    public static void main(String[] args)
        throws IOException
    {
        byte from = (byte)args[0].charAt(0);
        byte to   = (byte)args[1].charAt(0);
 
        int b;
        while ((b = System.in.read()) != -1) {
            System.out.write(b == from ? to : b);
        }
    }
}
 

/**
 * Created by IntelliJ IDEA.
 * User: me
 * Date: 12.09.2006
 * Time: 17:23:48
 * To change this template use File | Settings | File Templates.
 */
import java.io.*;
public class CountSpace {
    public static void main(String[] args) throws IOException {
        Reader in;
        if (args.length == 0)
            in = new InputStreamReader(System.in);
        else
            in = new FileReader(args[0]);
 
        int ch;
        int total;
        int spaces = 0;
        for (total = 0; (ch = in.read()) != -1; total++) {
            if (Character.isWhitespace((char) ch))
                spaces++;
        }
 
        System.out.println(total + " symbols, " + spaces + " spaces");
    }
}

import java.io.FilterReader;
import java.io.Reader;
import java.io.IOException;
 
/**
 * Created by IntelliJ IDEA.
 * User: me
 * Date: 13.09.2006
 * Time: 16:46:20
 * To change this template use File | Settings | File Templates.
 */
public class UpperCaseConvertor extends FilterReader {
    public UpperCaseConvertor(Reader reader) {
        super(reader);
    }
 
    public int read() throws IOException {
        int c = super.read();
        return (c == -1 ? c : Character.toUpperCase((char)c));
    }
 
    public int read(char[] buf, int offset, int count) throws IOException {
        int nread = super.read(buf, offset, count);
        int last = offset + nread;
        for (int i = offset; i < last; i++) {
            buf[i] = Character.toUpperCase(buf[i]);
        }
        return nread;
    }
}
 

import java.io.StringReader;
import java.io.FilterReader;
import java.io.IOException;
 
/**
 * Created by IntelliJ IDEA.
 * User: me
 * Date: 13.09.2006
 * Time: 16:48:39
 * To change this template use File | Settings | File Templates.
 */
public class UpperCaseConvertorTest {
    public static void main(String[] args) throws IOException {
        StringReader src = new StringReader(args[0]);
        FilterReader f   = new UpperCaseConvertor(src);
        int c;
        while ((c = f.read()) != -1) System.out.print((char)c);
        System.out.println();
    }
}