Problem:
Score: 500 points

Problem Statement

You are the top spy of AtCoder Kingdom. To prevent the stolen secret from being handed to AlDebaran Kingdom, you have sneaked into the party where the transaction happens.

There are N attendees in the party, and they are given attendee numbers from 1 through N. The height of Attendee i is A_i.

According to an examination beforehand, you know that a pair of attendees satisfying the condition below will make the transaction.

The absolute difference of their attendee numbers is equal to the sum of their heights.

There are \frac{N(N-1)}{2} ways to choose two from the N attendees and make a pair. Among them, how many satisfy the condition above?

P.S.: We cannot let you know the secret.

Constraints

All values in input are integers.

2 \leq N \leq 2 \times 10^5

1 \leq A_i \leq 10^9\ (1 \leq i \leq N)

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 \dots A_N

Output

Print the number of pairs satisfying the condition.

Sample Input 1

6
2 3 3 1 3 1

Sample Output 1

3

A_1 + A_4 = 3, so the pair of Attendee 1 and 4 satisfy the condition.

A_2 + A_6 = 4, so the pair of Attendee 2 and 6 satisfy the condition.

A_4 + A_6 = 2, so the pair of Attendee 4 and 6 satisfy the condition.

No other pair satisfies the condition, so you should print 3.

Sample Input 2

6
5 2 4 2 8 8

Sample Output 2

0

No pair satisfies the condition, so you should print 0.

Sample Input 3

32
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4 6 2 6 4 3 3 8 3 2 7 9 5

Sample Output 3

22

Solution in C# (.NET Core 3.1.201) (judge verdict: Time Limit Exceeded)

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;

namespace AtCoder
{
    static class Program_E
    {
        class Solver
        {


            public void Solve()
            {
                var n = Int();
                var a = Ints(0);
                //var n = 2 * 100000;
                //var a = CreateDummy(n);
                int min = Int32.MaxValue;
                int max = 0;
                int[] aMin = new int[a.Length];
                int[] aMax = new int[a.Length];
                for (int i = a.Length - 1; i >= 0; --i)
                {
                    min = Math.Min(min, a[i]);
                    max = Math.Max(max, a[i]);
                    aMin[i] = min;
                    aMax[i] = max;
                }
                //Twl("aMin:"+string.Join(",", aMin.Select(v => v.ToString()).ToArray()));
                //Twl("aMax:" + string.Join(",", aMax.Select(v => v.ToString()).ToArray()));

                int count = 0;

                for (int i = 0; i < n; ++i)
                {
                    int start = 0;
                    //try
                    //{
                    int requiredHeight = 0;
                    start = i + a[i] + 1;

                    do
                    {
                        //Twl($"start : {start}");
                        requiredHeight = start - i - a[i];
                        if (start >= n) break;
                        if (aMin[start] > requiredHeight)
                        {
                            start += aMin[start] - requiredHeight;
                            //Twl($"aMin[{start}]({aMin[start]}) > requiredHeight({requiredHeight})");
                        }
                        else
                        {
                            break;
                        }
                    } while (true);

                    for (int j = start; j < n; ++j)
                    {
                        requiredHeight = j - i - a[i];
                        if (requiredHeight > aMax[j])
                        {
                            //Twl($"requiredHeight({requiredHeight}) > aMax[{j}]({aMax[j]})");
                            break;
                        }
                        if (requiredHeight == a[j])
                        {
                            //Twl($"match a[{i}]({a[i]}) : a[{j}]({a[j]})");
                            count++;
                        }
                    }

                    //}
                    //catch (IndexOutOfRangeException)
                    //{
                    //    //Twl($"index exception (start,i)({start},{i})");

                    //}
                }
                Console.WriteLine(count);


            }

            private int[] CreateDummy(int n)
            {
                var result = new int[n];
                var rand = new Random();
                for(int i=0;i<n;++i)
                {
                    result[i] = rand.Next(1, 1000000000);
                }
                return result;
            }



            // ----------------------------------------------------------------------------
            void Twl(string mes)
            {
                //Console.WriteLine(mes);
            }
            public int Int()
            {
                return int.Parse(Console.ReadLine());
            }
            public int[] Ints(int subtract)
            {
                return Console.ReadLine().Split(' ').Select(s => int.Parse(s) - subtract).ToArray();
            }
            public long[] Longs()
            {
                return Console.ReadLine().Split(' ').Select(s => long.Parse(s)).ToArray();
            }

        }



        static void Main(string[] args)
        {
            new Solver().Solve();
        }
    }
    struct ModInt
    {
        const int MOD = 1000000007;
        long Data;
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public ModInt(long data) { if ((Data = data % MOD) < 0) Data += MOD; }
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static implicit operator long(ModInt modInt) => modInt.Data;
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static implicit operator ModInt(long val) => new ModInt(val);
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt operator +(ModInt a, ModInt b)
        {
            long res = a.Data + b.Data;
            return new ModInt() { Data = res >= MOD ? res - MOD : res };
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt operator +(ModInt a, long b) => a.Data + b;
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt operator -(ModInt a, ModInt b)
        {
            long res = a.Data - b.Data;
            return new ModInt() { Data = res < 0 ? res + MOD : res };
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt operator -(ModInt a, long b) => a.Data - b;
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt operator *(ModInt a, ModInt b) => new ModInt() { Data = a.Data * b.Data % MOD };
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ModInt operator /(ModInt a, ModInt b) => a.Data * GetInverse(b);

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public override string ToString() => Data.ToString();

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        static long GetInverse(long a)
        {
            long div;
            long p = MOD;
            long x1 = 1, y1 = 0, x2 = 0, y2 = 1;
            while (true)
            {
                if (p == 1) return x2;
                div = a / p;
                x1 -= x2 * div;
                y1 -= y2 * div;
                a %= p;
                if (a == 1) return x1;
                div = p / a;
                x2 -= x1 * div;
                y2 -= y1 * div;
                p %= a;
            }
        }
    }

}