import sys
from itertools import permutations
from heapq import heappop,heappush
from collections import deque
import random
import bisect

input = lambda :sys.stdin.readline().rstrip()
mi = lambda :map(int,input().split())
li = lambda :list(mi())

local = False


N = 100
P = [i for i in range(N)]
random.shuffle(P)

X = random.randint(750,750)
query_cnt = 0

def query(i,j):
    global query_cnt
    query_cnt += 1
    assert i < j
    if not local:
        print(i+1,j+1,flush=True)
        a = int(input())
        return a
    
    if query_cnt == X or query_cnt == 1500:
        return -1
    
    if P[i] > P[j]:
        P[i],P[j] = P[j],P[i]
        return 1
    else:
        return 0





def solve(n):
    pos = [i for i in range(N)]
    def range_sort(l,r):
        if r-l == 1:
            return [l]
        
        m = (l+r)>>1
        left = range_sort(l,m)
        if left == [-1]:
            return [-1]
        right = range_sort(m,r)
        if right == [-1]:
            return [-1]

        left,right = left[::-1],right[::-1]
        merged = []
        while left and right:
            a,b = left[-1],right[-1]

            if pos[a] < pos[b]:
                res = query(pos[a],pos[b])
                if res == -1:
                    return [-1]
                
                if res == 0:
                    merged.append(left.pop())
                else:
                    pos[a],pos[b] = pos[b],pos[a]
                    merged.append(right.pop())
            else:
                res = query(pos[b],pos[a])
                if res == -1:
                    return [-1]
                
                if res == 0:
                    merged.append(right.pop())
                else:
                    pos[a],pos[b] = pos[b],pos[a]
                    merged.append(left.pop())
        
        merged += left[::-1]
        merged += right[::-1]
        
        return merged
    
    res = range_sort(0,n)
    if res == [-1]:
        return 
    
    for i in range(n):
        t = res[i]
        
        if pos[t] == i:
            continue

        assert i < pos[t]
        check = query(i,pos[t])
        idx = pos.index(i)
        pos[idx],pos[t] = pos[t],pos[idx]
        if check == -1:
            break
    else:
        print(-1,-1,flush=True)
    return 


def local_checker():
    print("start",P)
    global N
    solve(N)
    print("after 1st run",P)
    solve(N)
    print("after 2nd run",P)

    for i in range(N):
        if P[i]!=i:
            print("WA!")
            break
    else:
        print("AC!",query_cnt)


def main():
    N = int(input())
    solve(N)

main()