class BinaryIndexTree:  # 1-indexed

    def __init__(self, N):

        """

        INPUT

        N [int] -> 全部0で初期化

        N [list] -> そのまま初期化

        """

        if isinstance(N, int):

            self.N = N

            self.depth = N.bit_length()

            self.tree = [0] * (N + 1)

            self.elem = [0] * (N + 1)

        elif isinstance(N, list):

            self.N = len(N)

            self.depth = self.N.bit_length()

            self.tree = [0] + N

            self.elem = [0] + N

            self._init()

        else:

            raise "INVALID INPUT: input must be int or list"



    def _init(self):

        size = self.N + 1

        for i in range(1, self.N):

            if i + (i & -i) > size:

                continue

            self.tree[i + (i & -i)] += self.tree[i]



    def add(self, i, x):

        self.elem[i] += x

        while i <= self.N:

            self.tree[i] += x

            i += i & -i



    def sum(self, i):

        res = 0

        while i > 0:

            res += self.tree[i]

            i -= i & -i

        return res



    def lower_bound(self, val):

        if val <= 0:

            return 0

        i = 0

        k = 1 << self.depth

        while k:

            if i + k <= self.N and self.tree[i + k] < val:

                val -= self.tree[i + k]

                i += k

            k >>= 1

        return i + 1





if __name__ == "__main__":

    N = int(eval(input()))

    P = list(map(int, input().split()))

    idx = {a: i for i, a in enumerate(P, start=1)}



    bit = BinaryIndexTree(N)

    ans = 0

    for i in range(1, N + 1):

        bit.add(idx[i], 1)

        s = bit.sum(idx[i])

        l = bit.lower_bound(s)-bit.lower_bound(s-1)

        r = bit.lower_bound(s+1) - idx[i]

        ans += i*l*r

    print(ans)
N = int(eval(input()))

A = list(map(int, input().split()))

a_to_i = {a: i for i, a in enumerate(A, start=1)}



L = [i - 1 for i in range(N + 2)]

R = [i + 1 for i in range(N + 2)]



ans = 0

for a in range(N, 0, -1):

    i = a_to_i[a]

    ans += a * (R[i] - i) * (i - L[i])

    L[R[i]] = L[i]

    R[L[i]] = R[i]



print(ans)
class BinaryIndexTree:  # 1-indexed
    def __init__(self, N):
        """
        INPUT
        N [int] -> 全部0で初期化
        N [list] -> そのまま初期化
        """
        if isinstance(N, int):
            self.N = N
            self.depth = N.bit_length()
            self.tree = [0] * (N + 1)
            self.elem = [0] * (N + 1)
        elif isinstance(N, list):
            self.N = len(N)
            self.depth = self.N.bit_length()
            self.tree = [0] + N
            self.elem = [0] + N
            self._init()
        else:
            raise "INVALID INPUT: input must be int or list"

    def _init(self):
        size = self.N + 1
        for i in range(1, self.N):
            if i + (i & -i) > size:
                continue
            self.tree[i + (i & -i)] += self.tree[i]

    def add(self, i, x):
        self.elem[i] += x
        while i <= self.N:
            self.tree[i] += x
            i += i & -i

    def sum(self, i):
        res = 0
        while i > 0:
            res += self.tree[i]
            i -= i & -i
        return res

    def lower_bound(self, val):
        if val <= 0:
            return 0
        i = 0
        k = 1 << self.depth
        while k:
            if i + k <= self.N and self.tree[i + k] < val:
                val -= self.tree[i + k]
                i += k
            k >>= 1
        return i + 1


if __name__ == "__main__":
    N = int(eval(input()))
    P = list(map(int, input().split()))
    idx = {a: i for i, a in enumerate(P, start=1)}
    bit = BinaryIndexTree(N)
    ans = 0
    for i in range(1, N + 1):
        bit.add(idx[i], 1)
        s = bit.sum(idx[i])
        l = bit.lower_bound(s) - bit.lower_bound(s - 1)
        r = bit.lower_bound(s + 1) - idx[i]
        ans += i * l * r
    print(ans)

N = int(eval(input()))
A = list(map(int, input().split()))
a_to_i = {a: i for i, a in enumerate(A, start=1)}
L = [i - 1 for i in range(N + 2)]
R = [i + 1 for i in range(N + 2)]
ans = 0
for a in range(N, 0, -1):
    i = a_to_i[a]
    ans += a * (R[i] - i) * (i - L[i])
    L[R[i]] = L[i]
    R[L[i]] = R[i]
print(ans)

-class BinaryIndexTree:  # 1-indexed -    def __init__(self, N): -        """ -        INPUT -        N [int] -> 全部0で初期化 -        N [list] -> そのまま初期化 -        """ -        if isinstance(N, int): -            self.N = N -            self.depth = N.bit_length() -            self.tree = [0] * (N + 1) -            self.elem = [0] * (N + 1) -        elif isinstance(N, list): -            self.N = len(N) -            self.depth = self.N.bit_length() -            self.tree = [0] + N -            self.elem = [0] + N -            self._init() -        else: -            raise "INVALID INPUT: input must be int or list" - -    def _init(self): -        size = self.N + 1 -        for i in range(1, self.N): -            if i + (i & -i) > size: -                continue -            self.tree[i + (i & -i)] += self.tree[i] - -    def add(self, i, x): -        self.elem[i] += x -        while i <= self.N: -            self.tree[i] += x -            i += i & -i - -    def sum(self, i): -        res = 0 -        while i > 0: -            res += self.tree[i] -            i -= i & -i -        return res - -    def lower_bound(self, val): -        if val <= 0: -            return 0 -        i = 0 -        k = 1 << self.depth -        while k: -            if i + k <= self.N and self.tree[i + k] < val: -                val -= self.tree[i + k] -                i += k -            k >>= 1 -        return i + 1 - - -if __name__ == "__main__": -    N = int(eval(input())) -    P = list(map(int, input().split())) -    idx = {a: i for i, a in enumerate(P, start=1)} -    bit = BinaryIndexTree(N) -    ans = 0 -    for i in range(1, N + 1): -        bit.add(idx[i], 1) -        s = bit.sum(idx[i]) -        l = bit.lower_bound(s) - bit.lower_bound(s - 1) -        r = bit.lower_bound(s + 1) - idx[i] -        ans += i * l * r -    print(ans) +N = int(eval(input())) +A = list(map(int, input().split())) +a_to_i = {a: i for i, a in enumerate(A, start=1)} +L = [i - 1 for i in range(N + 2)] +R = [i + 1 for i in range(N + 2)] +ans = 0 +for a in range(N, 0, -1): +    i = a_to_i[a] +    ans += a * (R[i] - i) * (i - L[i]) +    L[R[i]] = L[i] +    R[L[i]] = R[i] +print(ans)