/**
 * Stack implementation
 * @author Hristo Georgiev
 */
public class xStack<T> {
    private final int INITIAL_ARRAY_LENGTH = 4;
    private int size;
    private int count;
    private T[] stack;

    /**
    * Constructor of empty stack
    */
    public xStack(){
        this.count = -1;
        this.size = INITIAL_ARRAY_LENGTH;
        this.stack = (T[])new Object[this.size];
    }

    /**
    * Push an element in the head of the stack
    */
    public void push(T element){
        this.count++;
        if(this.count >= this.size){
            this.resizeArray();
        }
        stack[this.count] = element;
    }

    /**
    * Pop an element from the head of the stack
    */
    public T pop(){
        if(!isEmpty()){
            return this.stack[this.count–];
        }else{
            return null;
        }
    }

    /**
    * Checks if the stack is empty
    */
    public boolean isEmpty(){
        if(this.count == 0){
            return true;
        }
        return false;
    }

    private void resizeArray(){
        T[] newStack = (T[])new Object[2*this.size];
        System.arraycopy(this.stack, 0, newStack, 0, this.size);
        this.stack = newStack;
        this.size *= 2;
    }
}

/**
 * This class implements a half-static queue
 * @author Hristo Georgiev
 */
public class xQueue<T> {
    private final int INITIAL_ARRAY_LENGTH = 4;
    private final int INITIAL_POSITION = 0;
    private int size;
    private int count;
    private int position;

    private T[] queue;
       
    /**
    * Constructor of empty queue
    */
    public xQueue(){
        this.count = -1;
        this.size = INITIAL_ARRAY_LENGTH;
        this.position = INITIAL_POSITION;
        this.queue = (T[])new Object[this.size];
    }
   
    /**
    * Enqueue an element to the queue
    */
    public void enqueue(T element){
        this.count++;
        if(this.count >= this.size){
            this.resizeArray();
        }
        queue[this.count] = element;
    }

    /**
    * Dequeue an element to the queue
    */
    public T dequeue(){
        if(!isEmpty()){
            return this.queue[position++];
        }else{
            return null;
        }
    }

    /**
    * Checks if the queue is empty
    */
    public boolean isEmpty(){
        if(this.position == this.size){
            return true;
        }
        return false;
    }
   
    private void resizeArray(){
        T[] newQueue = (T[])new Object[2*this.size];
        System.arraycopy(this.queue, 0, newQueue, 0, this.size);
        this.queue = newQueue;
        this.size *= 2;
    }
}

public class PascalTriangle {
    private int[] lastRow;
    private int row;
    private int mod;

    public PascalTriangle(){ this(0); }
   
    public PascalTriangle(int mod){
        this.mod = mod;
        this.reset();
    }
   
    public final void reset(){
        this.row = 0;
        this.lastRow = new int[1];
        this.lastRow[0] = 1;
    }

    public int[] getRow()
    {
        int[] newRow = new int[++row];
        newRow[0] = 1;
        newRow[row-1] = 1;
        if(mod==0)
            for(int j=1;j<row-1;j++)
                newRow[j] = (lastRow[j-1]+lastRow[j]);
        else
            for(int j=1;j<row-1;j++)
                newRow[j] = (lastRow[j-1]+lastRow[j])%mod;

        this.lastRow = newRow;
        return newRow;
    }
}