package jp.funnything.competition.util;

import java.math.BigInteger;

/**
 * Utility for BigInteger
 */
public class BI {
    public static BigInteger ZERO = BigInteger.ZERO;
    public static BigInteger ONE = BigInteger.ONE;

    public static BigInteger add( final BigInteger x , final BigInteger y ) {
        return x.add( y );
    }

    public static BigInteger add( final BigInteger x , final long y ) {
        return add( x , v( y ) );
    }

    public static BigInteger add( final long x , final BigInteger y ) {
        return add( v( x ) , y );
    }

    public static int cmp( final BigInteger x , final BigInteger y ) {
        return x.compareTo( y );
    }

    public static int cmp( final BigInteger x , final long y ) {
        return cmp( x , v( y ) );
    }

    public static int cmp( final long x , final BigInteger y ) {
        return cmp( v( x ) , y );
    }

    public static BigInteger div( final BigInteger x , final BigInteger y ) {
        return x.divide( y );
    }

    public static BigInteger div( final BigInteger x , final long y ) {
        return div( x , v( y ) );
    }

    public static BigInteger div( final long x , final BigInteger y ) {
        return div( v( x ) , y );
    }

    public static BigInteger mod( final BigInteger x , final BigInteger y ) {
        return x.mod( y );
    }

    public static BigInteger mod( final BigInteger x , final long y ) {
        return mod( x , v( y ) );
    }

    public static BigInteger mod( final long x , final BigInteger y ) {
        return mod( v( x ) , y );
    }

    public static BigInteger mul( final BigInteger x , final BigInteger y ) {
        return x.multiply( y );
    }

    public static BigInteger mul( final BigInteger x , final long y ) {
        return mul( x , v( y ) );
    }

    public static BigInteger mul( final long x , final BigInteger y ) {
        return mul( v( x ) , y );
    }

    public static BigInteger sub( final BigInteger x , final BigInteger y ) {
        return x.subtract( y );
    }

    public static BigInteger sub( final BigInteger x , final long y ) {
        return sub( x , v( y ) );
    }

    public static BigInteger sub( final long x , final BigInteger y ) {
        return sub( v( x ) , y );
    }

    public static BigInteger v( final long value ) {
        return BigInteger.valueOf( value );
    }
}

package codejam.recycled;

import codejam.is.TestAbstract;

import java.util.*;

/**
 * Created with IntelliJ IDEA.
 * User: ofer
 * Date: 4/14/12
 * Time: 2:41 AM
 * To change this template use File | Settings | File Templates.
 */
public class RecycledTest extends TestAbstract {
    @Override
    public void run(String s) {
        StringTokenizer tokenizer = new StringTokenizer(s);
        int min = Integer.parseInt(tokenizer.nextToken());
        int max = Integer.parseInt(tokenizer.nextToken());

        int tmp = max;
        int length = 0;
        while (tmp != 0) {
            tmp = tmp / 10;
            length++;
        }

        int resultCounter = 0;
        for (int i = min; i < max; i++) {
            int rotatedNum = i;
            Set<Integer> foundSet = new HashSet<Integer>();
            for (int j = 0; j < length-1; j++) {

                int end = rotatedNum / 10;
                int beginning = (int)Math.pow(10,length-1) * (rotatedNum%10);

                rotatedNum = beginning + end;
                if (rotatedNum > i && rotatedNum <= max && !foundSet.contains(rotatedNum)) {
                    foundSet.add(rotatedNum);
//                    output.append("\n");
//                    output.append(i);
//                    output.append("->");
//                    output.append(rotatedNum);
                    resultCounter++;
                }
            }
        }
        output.append(resultCounter);
    }
}
