interface O {
    public Integer oc(Integer i);
}

abstract class A {
    Integer i;
    public A(){
        this.i = 0;
    }
    abstract void n(Object o);
    
    class X{
        private X(Integer i){
            A.this.i = i;
        }
    }
    public X getX(int i){
        return new X(i);
    }
}

class B extends A implements O{
    B(){
        super();
        new J().oc(i);
    }
    public Integer oc(Integer i) {
        new B().getX(i);
        return i;
    }
    void n(Object o) {
        for (int j = 0; j < J.petTypes.length; ++j){
            if (J.petTypes[J.petTypes.length - 1].isInstance(o)) {
                ((J)o).oc(i);
            } else {
                ((B)o).oc(j);
            }
        }
    }
}

class C extends B{
    C(Integer i){
        super();
        super.i=i;
    }
    public Integer oc(Integer i) {
        new C(i);
        return i;
    }
}

public class J implements O{
    static Class petTypes[] = {
            B.class,
            C.class,
            J.class
    };
    public Integer oc(Integer i) {
        i++;
        try {
            Object o = petTypes[i].newInstance();
            C c = new C(i);
            c.n(o);
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

        if (petTypes.length == i){
            return i;
        }
        return new J().oc(i);
    }

    public static void main(String[] args) {
        System.out.print(new B().oc(1));
    }
}