'''
总体思想
带回滚机制的莫队，通过回滚机制保证增量计算时候，只有加法没有减法
规避减法难以维护的问题
'''

import sys
import math

n, m = map(int, input().split())

s = sys.stdin.readline()
arr = list(map(int, s.split()))

new_arr = arr[::]
new_arr.sort()
map_arr = []        # 离散化去重之后的表
last_val = -0x7fffffff
for val in new_arr:
    if val != last_val:
        map_arr.append(val)
    last_val = val

# 不同数值的个数
diff_val_num = len(map_arr)

# 根据数值获取离散化后的下标
def val2map_idx(val):
    l, r = 0, diff_val_num-1
    while l <= r:
        mid = (l + r) >> 1
        if map_arr[mid] == val:
            return mid
        elif map_arr[mid] < val:
            l = mid + 1
        else:
            r = mid - 1
    return None

arr = [val2map_idx(val) for val in arr]


q_arr = []
part_len = int(math.sqrt(n))

ss = sys.stdin.readlines()

for idx, s in enumerate(ss):
    l, r  = map(int, s.split())
    l, r = l-1, r-1

    q_arr.append((l // part_len, r, l, idx))

ret = [0] * m
q_arr.sort()

last_group = -1
ans = None
flag = False
for group, r, l, idx in q_arr:

    if group != last_group:
        # 刚刚进入一个新的组, 进行初始化
        c = [0] * diff_val_num        # 数值计数的Counter
        max_val = None  # 从j所在的组开始位置到j位置的区间中统计出来的最大值
        j = None        # 右端点位置
        flag = True

    if r // part_len == group:
        # 左右端点在同一个组里面, 直接暴力求解
        tmp_ans = 0
        for pos in range(l, r+1):
            val = arr[pos]
            c[val] += 1
            tmp_ans = max(tmp_ans, map_arr[val] * c[val])
        ret[idx] = tmp_ans

        for pos in range(l, r+1):
            c[arr[pos]] -= 1

    else:
        if flag:
            flag = False
            j = (group+1) * part_len    # 下一组刚开始的位置
            c[arr[j]] = 1
            max_val = map_arr[arr[j]]

        # j一定是向右移动的，这里只维护j的移动，左端点位置一定是在当前组里面，左端点多出来的部分暴力添加
        # 这样所有操作中就只有加没有减，这样才能顺利进行增量计算
        while j != r:
            j += 1
            c[arr[j]] += 1
            max_val = max(max_val, c[arr[j]]* map_arr[arr[j]])

        # 下面暴力把剩下的在本分组的部分区间加上
        i = (group+1) * part_len
        ans = max_val
        while i != l:
            i -= 1
            c[arr[i]] += 1
            ans = max(ans, c[arr[i]]* map_arr[arr[i]])

        ret[idx] = ans

        # 将暴力加的部分回滚回去，把c的计数值恢复
        for i in range(l, (group+1) * part_len):
            c[arr[i]] -= 1

    last_group = group

for pos in range(len(q_arr)):
    print(ret[pos])