import java.util.*;

public class VectorBigInteger implements BigInteger, Comparable<VectorBigInteger> {
    //Data
	private Vector<Integer> digits;	//digits = (a0,...,an)
    public static int base = 10;  	//base = 10^k, k = 1, 2, ...

	//Constructors
    public  VectorBigInteger() { this("0"); }
    public  VectorBigInteger(BigInteger arg) { this(arg.toString()); }

    public  VectorBigInteger(String arg) { //arg="an...a0"
       digits = new  Vector<Integer>();
       int k = howLong(base)-1;
       while(k < arg.length()) {
           int index = arg.length() - k;
           String s = arg.substring(index);
           digits.add(digits.size(),Integer.parseInt(s));
           arg = arg.substring(0,index);
       }
       digits.add(digits.size(),Integer.parseInt(arg));
    }

    //Private method
    private static int howLong(int n) {
    	int d = 0;
        do {
              d++;
              n /= 10;
        }while(n != 0);
        return d;
     }

     //BigInteger methods implementation
     public int length() { return digits.size() * (howLong(base)-1); }
     
     public BigInteger add(BigInteger arg) {
     	VectorBigInteger Int1 = this;
     	VectorBigInteger Int2 = new VectorBigInteger(arg.toString());
     	Vector<Integer> left = Int1.digits;
     	Vector<Integer> right = Int2.digits;
     	
     	int max = Math.max(left.size(),right.size());
     	int min = Math.min(left.size(),right.size());
     	
     	VectorBigInteger w = new VectorBigInteger();
     	Vector<Integer> result = w.digits = new Vector<Integer>();
     	     	
     	int d, c = 0;
     	for(int i = 0; i < min; i++) {
          	d = left.get(i) + right.get(i) + c;
          	result.add(result.size(),d % base);      
          	c = d / base;
		}

		Vector<Integer> temp;
		if(max == left.size()) temp = left;
		else temp = right;
		for(int i = min; i < temp.size(); i++) {
			d = temp.get(i) + c;         
            result.add(result.size(),d % base);      
            c = d / base;
		}
		if(c != 0) result.add(result.size(),c);
		
		return w;
     }
     
     public BigInteger mult(BigInteger arg) {
     	VectorBigInteger Int1 = this;
     	VectorBigInteger Int2 = new VectorBigInteger(arg.toString());
     	Vector<Integer> left = Int1.digits;
     	Vector<Integer> right = Int2.digits;
     	
     	VectorBigInteger w = new VectorBigInteger();
     	Vector<Integer> result = w.digits = new Vector<Integer>();;
     	     	
     	for(int i = 0; i < left.size() + right.size()-1; i++)
     		result.add(0,0);
         	
     	int d, c;
     	for(int i = 0; i < left.size(); i++) {
     		d = left.get(i);
     		for(int j = 0; j < right.size(); j++) {
          		c = result.get(i+j) + d * right.get(j);
          		result.set(i+j,c);
          	}
        }
          
        c = 0;
        for(int i = 0; i < result.size(); i++) {
        	d = result.get(i) + c;
			result.set(i,d % base);
            c = d / base;
		}
		
		if(c != 0) result.add(result.size(),c);

        return w;
     }
     
     public int compareTo(BigInteger arg) {
     	VectorBigInteger left = this;
     	VectorBigInteger right = new VectorBigInteger(arg.toString());
     	return left.compareTo(right);
     }
     
     //Comparable method implementation
     public int compareTo(VectorBigInteger arg) {
     	String left = this.toString();
     	String right = arg.toString();
     	int diff = Math.abs(left.length() - right.length());
     	if(left.length() < right.length())
     		for(int i = 0; i <= diff; i++) left = "0" + left;
     	else if(right.length() < left.length())
     		for(int i = 0; i <= diff; i++) right = "0" + right; 
     	return left.compareTo(right);   	
     }
     
     //Override methods - inherited from class Object
     public boolean equals(Object obj){ System.out.println("Not implemented!"); return true; }
     public Object clone(){ System.out.println("Not implemented!"); return null; }
     
     public String toString() { 
         String result = "";	//digits = (a0,...,an) => result="an...a0"
         int k = howLong(base)-1;
         for(int i = 0; i < digits.size(); i++){
         	String w = (digits.get(i)).toString();
         	while(k > w.length())
         		w = 0  + w;
         	result = w + result;
         }
         return result;
     }
          
     //Constants
     public static final VectorBigInteger ZERO = new VectorBigInteger("0");
     public static final VectorBigInteger ONE = new VectorBigInteger("1");
     public static final VectorBigInteger TEN = new VectorBigInteger("10");
}

class TestVectorBigInteger {

     public static void main(String[] args){
     	Scanner s = new Scanner(System.in);
        System.out.print("     n=");
        BigInteger n1 = new VectorBigInteger(s.nextLine());
        System.out.println("Base = " + VectorBigInteger.base);
        System.out.println(n1 + "+" + n1 + "=" + n1.add(n1));
        System.out.println(n1 + "*" + n1 + "=" + n1.mult(n1));
        
        VectorBigInteger.base=1000;
        System.out.print("     n=");
        BigInteger n2 = new VectorBigInteger(s.nextLine());
        System.out.println("Base = " + VectorBigInteger.base);
        System.out.println(n2 + " + " + n2 + "=" + n2.add(n2));
        System.out.println(n2 + "*" + n2 + "=" + n2.mult(n2)); 
        
        System.out.print("     n=");
        BigInteger n3 = new VectorBigInteger(s.nextLine());
        System.out.println("Base = " + VectorBigInteger.base);
        System.out.println(n3 + "<" + n2 + "=" + (n3.compareTo(n2) < 0 ? "Yes" : "No"));
    }
}