int BinarySearch(int a[],int size,int p)
{
	int L = 0; // 查找区间的左端点
	int R = size - 1; // 查找区间的右端点
	while( L <= R) { // 如果查找区间不为空就继续查找
		int mid = L+(R-L) >> 1; // 取查找区间正中元素的下标，防止溢出（相当于 L+(R-L)/2） 
		if( p == a[mid] ) // 如果找到了就返回 
			return mid;
		else if( p > a[mid]) 
			L = mid + 1; //设置新的查找区间的左端点
		else 
			R = mid - 1; //设置新的查找区间的右端点
	}
	return -1;// 没找到就返回-1 
} //复杂度O(log(n))

int LowerBound(int a[],int size,int p) //复杂度O(log(n))
{
	int L = 0; //查找区间的左端点
	int R = size - 1; //查找区间的右端点
	int lastPos = -1; //到目前为止找到的最优解
	while( L <= R) { //如果查找区间不为空就继续查找
		int mid = L+(R-L)/ >> 1; //取查找区间正中元素的下标
		if(a[mid]>= p)
			R = mid - 1;// 设置右端点 
		else {
			lastPos = mid; // 设置左端点 
			L = mid+1;
		}
	}
	return lastPos;
}

#include<stdio.h>
#include<math.h>
#define EPS  1e-6
double f(double x) // 定义函数 
{ 
	return x*x*x - 5*x*x + 10*x - 80; 
	}
int main() {
	double root, x1 = 0, x2 = 100,y;
	root = x1+(x2-x1) / 2;
	y = f(root);
	while( fabs(y) > EPS) {
		if( y > 0 ) x2 = root;// 右端点左移 
		else x1 = root;// 左端点右移
		root = x1+(x2 - x1)/2;
		y = f(root);
	}
	printf("%.8f\n",root);
	return 0;
}

// 两层for循环，失败！

#include<stdio.h>
int cmp(const void* a, const void* b);
int main(void)
{
	int n, i ,min = 1000,m;
	// 输入 
	scanf("%d %d", &n,&m);
	int a[n];
	for(i = 0;i < n; i++){
		scanf("%d", &a[i]);
	} 
	//排序 
	qsort(a, n, sizeof(a[0]), cmp);
	//遍历 
	for(i = 0;i < n - 1; i++){	
	
	if(BinarySearch(a,n,m-a[i]) != -1){
		printf("%d %d\n",a[i],m-a[i]);
	}
	}
	return 0;
}
// 升序排序 
int cmp(const void* a, const void* b)
{
	return *(int *)a - *(int *)b;
}
// 查找 
int BinarySearch(int a[],int size,int p)
{
	int L = 0; // 查找区间的左端点
	int R = size - 1; // 查找区间的右端点
	while( L <= R) { // 如果查找区间不为空就继续查找
		int mid = L+(R-L) / 2; // 取查找区间正中元素的下标，防止溢出（相当于 L+(R-L)/2） 
		if( p == a[mid] ) // 如果找到了就返回 
			return mid;
		else if( p > a[mid]) 
			L = mid + 1; //设置新的查找区间的左端点
		else 
			R = mid - 1; //设置新的查找区间的右端点
	}
	return -1;// 没找到就返回-1 
} //复杂度O(log(n))

#include<stdio.h>
int cmp(const void* a, const void* b);
void removeElement(int* nums, int numsSize, int val);
int main(void)
{
	int n, i ,min = 1000,m;
	// 输入 
	scanf("%d %d", &n,&m);
	int a[n];
	for(i = 0;i < n; i++){
		scanf("%d", &a[i]);
	} 
	//排序 
	qsort(a, n, sizeof(a[0]), cmp);
	//遍历 
	removeElement(a, n-1, m);
	return 0;
}
// 升序排序 
int cmp(const void* a, const void* b)
{
	return *(int *)a - *(int *)b;
}
// 查找 
void removeElement(int* nums, int numsSize, int val){
    int left = 0, right = numsSize;
    while (left < right) {    // 循环判断条件，左闭右开
        if (nums[left]+nums[right] > val) {    // 如果两指针大于目标值           
            right--;    // 右指针左移
        } else {
            left++;    // 否则左指针右移
        }
    if(nums[left]+nums[right] == val )
    printf("%d %d\n",nums[left],nums[right]);
	}
}

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hash = dict()    # 声明一个字典
        for i, num in enumerate(nums):    # 使用enumerate()函数来遍历同时返回索引
            if target - num in hash:    # 如果在哈希表里找到，就返回下标
                return [hash[target - num], i]
            hash[nums[i]] = i    # 如果没找到，就放入哈希表中
        return []

class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        left, right = 0, len(nums)-1    # 确定区间为闭区间
 
        while left <= right:    # 之所以是小于等于，是因为我们选择的区间是闭区间，如果是开区间，则不需要等号
            middle = (right + left) >> 1 
# 将中间值设置好，这个地方选择用位运算，不过对于python来说速度提升不大，还有一点，就是要防止溢出所以会选择 middle = left + ((right - left) >> 1)这种写法
 
            if nums[middle] < target:   # target 在右区间，所以在[middle + 1, right]这个区间
                left = middle + 1
            elif nums[middle] > target:  # target 在左区间，所以在[left, middle - 1]这个区间
                right = middle - 1
            else:
                return middle
        return right + 1    # 经过模拟计算，发现需要返回right + 1

int searchInsert(int* nums, int numsSize, int target) {
    int left = 0, right = numsSize - 1;
    while (left <= right) {
        int mid = ((right - left) >> 1) + left;
        if (target <= nums[mid]) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    return right + 1;
}