//本地编译结果四个：
//【输入1】 389 207 155 300 299 170 158 65
//【输出1】 6 2
//******************************************
//【输入2】 10 9 8 7 8 7 6 5
//【输出2】 6 2
//******************************************
//【输入3】 8 7 6 5 4 3 2 1
//【输出3】 8 1
//******************************************
//【输入4】 1 2 3 4 5 6 7 8
//【输出4】 1 8

//云编译失败
//以下是源代码：
#include<iostream>
#include<list>
#include<string>

using namespace std;
class Ball;
typedef list<Ball*> BallList;

class Ball{
private:
    BallList NextBall_List;
public:
    Ball(){};
    BallList * get_NextBall_List(){return &NextBall_List;}
};

int CountMax=0;//记录单个系统可以击落的最大数

void getCountMax(BallList* ballList){
    int static Count=0;
    for(auto it=ballList->begin();it!=ballList->end();it++){
        Count++;
        getCountMax((*it)->get_NextBall_List());
    }
    if(Count>CountMax)CountMax=Count;
    Count--;
}

int main(){
    int const N_Max=10000+100000;//10^4+10^5
    int hight[N_Max];//记录每个炮弹的高度
    int N=0;
    string *str=new string;
    getline(cin,*str);
    //初始化输入数据
    while(1)
    {
        N++;
        int index=(int)str->find(" ");
        string subStr;
        if(index!=(int)string::npos){
            subStr=str->substr(0,index);
            *str = str->substr(index+1);
            hight[N-1]=stoi(subStr);
        }else{
            subStr=str->substr(0);
            hight[N-1]=stoi(subStr);
            break;
        }
    }

    Ball ball[N];//该数组与hight[N]相对应
    for(int i=0;i<N;i++){
        for(int j=i+1;j<N;j++){
            BallList* myList=ball[i].get_NextBall_List();
            if(hight[i]>hight[j]){
                myList->push_back(ball+j);
            }
        }
    }

    BallList beginBall;
    for(int i=0;i<N;i++){
        beginBall.push_back(ball+i);
    }

    getCountMax(&beginBall);
    cout<<CountMax<<endl;

    //**********下面计算全防需要最少几个防空系统

    list<int> systemList;//systemLsit链表中，每一个元素表示一个防空系统，元素的值表示该系统射出的最后一发炮弹的高度
    systemList.push_back(hight[0]);//首发炮弹确定第一个防空系统
    list<int> MaxInt;//MaxInt链表中只记录一个值，是最大INT
    MaxInt.push_back(INT_MAX);

    for(int i=1;i<N;i++){
        auto itBegin=systemList.begin();
        auto itEnd=systemList.end();
        auto greater_Hight_Min=MaxInt.begin();//定义一个迭代器，它指向大于炮弹高度的最小高度防空系统
                                            //该迭代器初始化时，指向最大INT值
        bool FlagLunch=false;
        for(;itBegin!=itEnd;itBegin++)
        {
            if(hight[i] <= (*itBegin) && (*itBegin) < (*greater_Hight_Min)){
                greater_Hight_Min=itBegin;
                FlagLunch=true;
            }
        }
        if(FlagLunch){
            *greater_Hight_Min = hight[i];
        }else
        {
            systemList.push_back(hight[i]);
        }
    }

    //for(auto it=systemList.begin();it!=systemList.end();it++)cout<<*it<<" ";
    cout<<systemList.size()<<endl;

}