long long quick_power(int base, int power)
{
	long long ans = 1;
	while (power > 0)           //指数大于0进行指数折半，底数变其平方的操作
	{
		if (power & 1)     //指数为奇数
		{
			power -= 1;         //指数减一,不写也可以int自动取整
			ans *= base % mod;     //分离出当前项并累乘
		}
		power >>= 1;         //指数折半
		base *= base % mod;       //底数变其平方
	}
	return ans % mod;
}

long long quick_power(int base, int power)
{
    long long ans = 1;   //用于存储项累乘与返回最终结果，由于要存储累乘所以要初始化为1
    while (power > 0)           //指数大于0说明指数的二进制位并没有被左移舍弃完毕
    {
        if (power & 1){          //当前位为1
            ans *= base % mod;     //累乘当前项并存储
        }
        power >>= 1;            //指数位右移(区别主要就在这一步的理解上)
        base *= base % mod;           //递推,如n的2次变为n的4次
    }
    return ans % mod;
}

int gcd(int a, int b){
    return b ? gcd(b, a % b) : a;
}

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5+5;
int st[N][21]; //st[i][j],i记录的是现在遍历的下标,j记录的是log2(长度)
int lg[N]; //因为二进制就是2的i次,所以用来记录很方便,位移就可以了.
int n,m;

void init(){
	lg[0] = -1;
	for(int i = 1; i <= n; i++){
		lg[i] = lg[i>>1] + 1;
	}
	for(int i = 1; i <= n; i++){
		cin>>st[i][0];
	} 
	for(int j = 1; j <= lg[n]; j++){
		for(int i = 1; i <= n - (1<<(j-1)) +1; i++){
			st[i][j] = min(st[i][j-1], st[i + (1<<(j-1))][j-1]); //j-1就是上一个log2(上一层长度),我们<<位移就为了展开来定下i的位置
		}
	}
} 

int query(int l, int r){
	int k = lg[r-l+1];
	return min(st[l][k], st[r-(1<<k)+1][k]); //和初始化是同理的,log2上一层就是k
}

int main(){
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	cin>>n>>m;
	init();
	for(int i = 0; i< m; i++){
		int l,r;
		cin>>l>>r;
		cout<<query(l,r)<<" ";
	}
	return 0;
}

#include<bits/stdc++.h>
using namespace std;

const int N = 6005;
vector<int> G[N];
int dp[N][2],val[N],father[N];

//dp定义,dp[i][j]选或不选i节点的值(j为1选,0不选) 
void dfs(int u){
	dp[u][0] = 0;
	dp[u][1] = val[u];
	for(int i : G[u]){
		dfs(i);//遍历子节点
		dp[u][1] += dp[i][0];//父选子不选 
		dp[u][0] += max(dp[i][0], dp[i][1]);//父不选,子选或不选 
	}	
} 

int main(){
	int n;
	cin>>n;
	for(int i = 1; i <= n; i++){
		cin>>val[i];
	}
	for(int i = 1; i < n; i++){
		int to,from;
		cin>>to>>from;
		G[from].push_back(to);
		father[to] = from;
	}
	int t = 1;
	while(father[t]) t = father[t];//找根节点
	dfs(t);
	cout<<max(dp[t][0], dp[t][1]);
	return 0; 
} 

bool compare(TreeNode* left, TreeNode* right){
    if (left == NULL && right == NULL) return true;
    else if(left == NULL || right==NULL) return false;
    else if (left->val != right->val) return false;
    return compare(left->left, right->right) && compare(left->right, right->left);
 }

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        return compare(root->left, root->right);
    }
};

class Solution {
public:
    TreeNode* reverseOddLevels(TreeNode* root) {
        dfs(root->left, root->right, true);
        return root;
    }

    void dfs(TreeNode *l, TreeNode *r, bool jud) {
        if (l == nullptr) {
            return;
        }
        if (jud) {
            swap(l->val, r->val);
        }
        dfs(l->left, r->right, !jud);
        dfs(l->right, r->left, !jud);
    }
};

#include<bits/stdc++.h>
using namespace std;

const int N = 1e6;
int a[N];
int len = 0;//记现有节点数的 

void push(int x){//上浮(提高优先级的) 添加的优先级最低 
	a[++len] = x;
	int i = len;
	while(i > 1 && a[i] < a[i/2]){ //子比父,父不如子啊 
		swap(a[i], a[i/2]); //老登,辈分该改了
		i/=2; //看看爷爷 
	} 
} ;

void pop(){ //下沉(降低优先级的) 删除的那个优先级最高 
	a[1] = a[len--]; //根节点直接换成叶子节点(因为叶子无牵无挂)
	int i = 1;
	while(i * 2 <= len){//父比子(至少有左子) 
		int sonL = i * 2;//左子 
		int sonR = i * 2 + 1;//右子 
		if(a[i] < a[sonL] || a[i] < a[sonR]){
			if(a[sonL] < a[sonR] || sonR >= len) {//左子好或者右子死掉了
				swap(a[i], a[sonL]); 
				i = sonL;
			}
			else {//右子好 
				swap(a[i], a[sonR]);
				i = sonR;
			}
		}
		else break; //父强,不用看了 
	} 
};

//懒狗,不想封个类了,就用一次 
int main(){
	int n;
	cin>>n;
	while(n--){
		int jud;
		cin>>jud;
		if(jud == 1) {
			int x;
			cin>>x;
			push(x); 
		}
		else if(jud == 2) cout<<a[1]<<endl;
		else pop(); 
	}
	return 0;
}