class UnionFind{
    vector<int> id;
public:
    UnionFind(int n):id(n){
        iota(id.begin(),id.end(),0);
    }
    // 找到p的父节点
    int find(int p){
        while(p!=id[p])
            p=id[p];
        return p;
    }
    // 在p和q之间添加边
    void connect(int p,int q){
        id[find(p)]=find(q);
    }
    // p和q是否同属于一个集合
    bool isConnect(int p,int q){
        return find(p)==find(q);
    }
};

class UnionFind {
    vector<int> id, size;

  public:
	//把数组初始化为0到n-1
    UnionFind(int n) : id(n), size(n, 1) { iota(id.begin(), id.end(), 0); }

    // 路径压缩
    int find(int p) {
        // p的父节点
        while (id[p] != p) {
            id[p] = id[id[p]];
            p = id[p];
        }
        return p;
    }

    void connect(int p, int q) {
        int i = find(p), j = find(q);
        if (i != j) {
            // 按秩合并，把元素数少的集合合并到元素数多的集合
            if (size[i] > size[j]) {
                id[j] = i;
                size[i] += size[j];
            } else {
                id[i] = j;
                size[j] += size[i];
            }
        }
    }

    bool isConnect(int p, int q) { return find(p) == find(q); }
    // 返回由多少个独立的集合
    int getCnt() {
        int cnt = 0;
        for (int i = 0; i < id.size(); i++) {
            if (id[i] == i)
                cnt++;
        }
        return cnt;
    }
};

int a; // a 为左值
a = 3; // 3 为右值

struct Node{
	int x,y;
};

struct cmp{
	bool operator()(const Node&a, const Node&b){
	return a.x==b.x?a.y<b.y:a.x<b.x;
	}
};

multiset<Node,cmp> s;

#include <string>  
#include <iostream>  
#include <set>  
using namespace std;  
void main(){      
    int x;  
    scanf("%ld",&x);      
    multiset<int>h;            
    while(x!=0){          
        h.insert(x);           
        scanf("%ld",&x);      
    }      
    while(!h.empty()){                 
        __typeof(h.begin()) c=h.begin();  
        printf("%ld ",*c);             
        h.erase(c);                
    }  
}

struct rec{int x,y;};  
multiset<rec>h;

struct cmp{  
    bool operator()(const rec&a,const rec&b{  
    return a.x<b.x||a.x==b.x&&a.y<b.y;    }  
};
					
struct rec{int x,y;};  
struct cmp{bool operator()(const rec&a,const rec&b){return a.x<b.x||a.x==b.x&&a.y<b.y;    }};  
multiset<rec,cmp>h;

// unordered_set<pair<int, int>> test;   # error: use of deleted function function
set<pair<int, int>> record, gu; // 记录边

string line="this student is studious";
stringstream ss;
string w;
ss<<line;
while(ss>>w){
	cout<<w<<endl;
}

priority_queue<int> pq;


//自定义排序，小根堆
struct Comp{
    bool operator()(ListNode* a,ListNode *b){
        return a->val>b->val;
    }
 };
priority_queue<ListNode*,vector<ListNode*>,Comp> pq;


 static bool cmp(pair<int, int>& m, pair<int, int>& n) {
        return m.second > n.second;
}
priority_queue<pair<int, int>, vector<pair<int, int>>, decltype(&cmp)> q(cmp);

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
bool compare(vector<int> &a, vector<int> b)
{
    return a[1] < b[1];
}

int main(){
	//自定义排序
	vector<vector<int>> nums={{1, 2}, {2, 4}, {1, 3}};
	sort(nums.begin(),nums.end(),[](auto &a,auto &b){
		return a[1]<b[1];
	});
	//定义排序函数
	sort(nums.beign(),nums.end(),compare);

	sort(nums.begin(), nums.end(), greater<pair<int,int>>());从大到小排序
	
	vector<int> nums;
	sort(nums.begin(),nums.end(),greater<int>());
}

 template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
   typename _Compare>
   void
   __push_heap(_RandomAccessIterator __first,
	_Distance __holeIndex, _Distance __topIndex, _Tp __value,
	_Compare& __comp)
//首迭代器,插入值索引(__last-1),堆顶索引(0),插入值,比较函数
   {
     _Distance __parent = (__holeIndex - 1) / 2;
     //父节点值与节点值比较，默认less，父节点小，则交换
     while (__holeIndex > __topIndex && __comp(__first + __parent, __value))
{
  *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __parent));
  __holeIndex = __parent;
  __parent = (__holeIndex - 1) / 2;
}
     *(__first + __holeIndex) = _GLIBCXX_MOVE(__value);
   }

template <typename _BidirectionalIterator, typename _Compare>
bool __next_permutation(_BidirectionalIterator __first,
                        _BidirectionalIterator __last, _Compare __comp) {
    if (__first == __last)  //区间为空
        return false;
    _BidirectionalIterator __i = __first;
    ++__i;
    if (__i == __last)  //区间只有一个元素
        return false;
    __i = __last;
    --__i;

    for (;;) {
        _BidirectionalIterator __ii = __i;  //__i指向__ii前一个位置
        --__i;
        if (__comp(__i, __ii)) {    // *__i<*__ii
            _BidirectionalIterator __j = __last;
            while (!__comp(__i, --__j)) {   //找到从后面起第一个*__j>*__i
            }
            std::iter_swap(__i, __j);
            std::__reverse(__ii, __last, std::__iterator_category(__first));
            return true;
        }
        //区间已经完全逆序
        if (__i == __first) {
            std::__reverse(__first, __last, std::__iterator_category(__first));
            return false;
        }
    }
}