n = eval(input())
nums = list(map(int, input().split()))
t = eval(input())

start = end = 0
idx = 0
while idx < len(nums)-1:
    if nums[idx] > nums[idx+1]:
        break
    else:
        idx += 1

idx += 1
orig = nums[idx:] + nums[:idx]

while start < len(orig):
    if orig[start] == t:
        break
    else:
        start += 1

tmp = start + 1
while tmp < len(orig):
    if orig[tmp] > t:
        end = tmp - 1
        break
    else:
        tmp += 1

if tmp == len(nums):
    end = len(nums) - 1
    
res = [str((start+idx) % len(nums)), str((end+idx) % len(nums))]

print(" ".join(res))

#include <iostream>
#include <vector>
using namespace std;

int main() {
    int n, t;
    
    // 输入数组长度 n
    cin >> n;
    
    // 创建一个大小为 n 的数组来存储输入的值
    vector<int> a(n);
    
    // 输入循环数组中的每个值
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }
    
    // 输入需要查找的目标值 t
    cin >> t;
    
    // 变量 s 用于记录旋转数组的实际起点，初始为 0
    int s = 0;
    
    // 遍历数组，找到数组中的逆序位置，即旋转数组的起点
    // 如果 a[i] < a[i-1]，说明 i 是实际的数组起点
    for (int i = 1; i < n; i++) {
        if (a[i] < a[i - 1]) {
            s = i; // 找到逆序的位置，标记为起点
            break;
        }
    }
    
    // 定义 start 和 end 用于记录目标值 t 的开始位置和结束位置
    int start = -1;
    int end = -1;
    
    // 遍历数组，按照旋转后的顺序查找目标值 t
    for (int i = 0; i < n; i++) {
        // idx 表示通过起点 s 重新计算的当前索引
        // (i + s) % n 用来模拟从起点开始循环的效果
        int idx = (i + s) % n;
        
        // 如果当前元素等于目标值 t
        if (a[idx] == t) {
            // 如果是第一次找到目标值，记录其开始位置
            if (start == -1) { 
                start = idx; 
            }
            // 每次找到目标值时更新结束位置
            end = idx;
        }
    }
    
    // 输出目标值的开始位置和结束位置
    cout << start << " " << end << endl;
    
    return 0;
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // 创建Scanner对象用于读取输入
        Scanner scanner = new Scanner(System.in);

        // 读取数组的长度 n
        int n = scanner.nextInt();

        // 创建数组 a 来存储输入的 n 个整数
        int[] a = new int[n];

        // 读取数组中的每个元素
        for (int i = 0; i < n; i++) {
            a[i] = scanner.nextInt();
        }

        // 读取目标值 t
        int t = scanner.nextInt();

        // s 用于记录旋转数组的实际起点，初始值为 0
        int s = 0;

        // 遍历数组，找到逆序的位置，也就是数组旋转后的起点
        for (int i = 1; i < n; i++) {
            if (a[i] < a[i - 1]) {
                s = i; // 找到起点位置
                break; // 找到起点后可以直接退出循环
            }
        }

        // start 和 end 用于记录目标值 t 在数组中的起始和结束位置
        int start = -1;
        int end = -1;

        // 遍历数组，从起点 s 开始循环遍历整个数组
        for (int i = 0; i < n; i++) {
            // idx 通过 (i + s) % n 计算当前的实际索引位置，模拟从旋转起点 s 开始遍历
            int idx = (i + s) % n;

            // 如果找到与目标值 t 相等的元素
            if (a[idx] == t) {
                // 如果是第一次找到目标值，则记录其起始位置
                if (start == -1) {
                    start = idx;
                }
                // 每次找到目标值都更新其结束位置
                end = idx;
            }
        }

        // 输出目标值的起始位置和结束位置
        System.out.println(start + " " + end);
    }
}

# 读取输入：n 表示数组的长度，a 是旋转数组，t 是目标值
n = int(input())
a = list(map(int, input().split()))
t = int(input())

# s 用来记录旋转数组的起点，初始为 0
s = 0

# 遍历数组，找到数组的逆序点，即旋转数组的起点
for i in range(1, n):
    if a[i] < a[i - 1]:
        s = i  # 找到起点位置
        break

# 初始化 l 和 r，分别用于记录目标值 t 的开始位置和结束位置
l = -1
r = -1

# 遍历数组，从旋转数组的起点开始顺序遍历
for i in range(n):
    # 计算当前的索引 idx，模拟从旋转起点 s 开始的顺序遍历
    idx = (i + s) % n
    
    # 如果当前元素等于目标值 t
    if a[idx] == t:
        if l == -1:  # 第一次找到目标值时，记录其开始位置
            l = idx
        r = idx  # 每次找到目标值都更新结束位置

# 输出目标值的开始和结束位置
print(l, r)