human
Eugene likes working with arrays. And today he needs your help in solving one challenging task.

An array c is a subarray of an array b if c can be obtained from b by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.

Let's call a nonempty array good if for every nonempty subarray of this array, sum of the elements of this subarray is nonzero. For example, array [-1, 2, -3] is good, as all arrays [-1], [-1, 2], [-1, 2, -3], [2], [2, -3], [-3] have nonzero sums of elements. However, array [-1, 2, -1, -3] isn't good, as his subarray [-1, 2, -1] has sum of elements equal to 0.

Help Eugene to calculate the number of nonempty good subarrays of a given array a.

Input

The first line of the input contains a single integer n (1 ≤ n ≤ 2 × 10^5) — the length of array a.

The second line of the input contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the elements of a. 

Output

Output a single integer — the number of good subarrays of a.

Examples

Input

3
1 2 -3

Output

5

Input

3
41 -41 41

Output

3

Note

In the first sample, the following subarrays are good: [1], [1, 2], [2], [2, -3], [-3]. However, the subarray [1, 2, -3] isn't good, as its subarray [1, 2, -3] has sum of elements equal to 0.

In the second sample, three subarrays of size 1 are the only good subarrays. At the same time, the subarray [41, -41, 41] isn't good, as its subarray [41, -41] has sum of elements equal to 0.
assistant
#Here is Python code to calculate the number of nonempty good subarrays of a given array a.

NTC here
"""
import sys
inp = sys.stdin.readline
def input(): return inp().strip()
flush= sys.stdout.flush
# import threading
# sys.setrecursionlimit(10**6)
# threading.stack_size(2**26)

def iin(): return int(input())

def lin(): return list(map(int, input().split()))

# range = xrange
# input = raw_input

def main():
    T = 1
    def fn(n):
        return (n*(n+1))//2
    for _ in range(T):
        n = iin()
        a = lin()
        a1 = [0] + a[:]
        for i in range(1, n+1):
            a1[i]+=a1[i-1]
        dc = {}
        ans = fn(n)
        pv = 0
        for i in range(n+1):
            if a1[i] in dc:
                # print(a1[i], dc[a1[i]], i, (1+n-i)*(dc[a1[i]]- pv+1))
                if pv>dc[a1[i]]:continue
                ans -= (1+n-i)*(dc[a1[i]]-pv+1)
                pv = dc[a1[i]]+1
            dc[a1[i]] = i
        # print(a1)
        print(ans)

main()

# threading.Thread(target=main).start()