package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

type Node struct {
	sum  int64
	max  int
	min  int
	lazy int
}

var tree []Node

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func apply_set(node, l, r, X int) {
	tree[node].sum = int64(X) * int64(r-l+1)
	tree[node].max = X
	tree[node].min = X
	tree[node].lazy = X
}

func push_down(node, l, r int) {
	if tree[node].lazy != -1 {
		mid := (l + r) / 2
		apply_set(node*2, l, mid, tree[node].lazy)
		apply_set(node*2+1, mid+1, r, tree[node].lazy)
		tree[node].lazy = -1
	}
}

func pull_up(node int) {
	tree[node].sum = tree[node*2].sum + tree[node*2+1].sum
	tree[node].max = max(tree[node*2].max, tree[node*2+1].max)
	tree[node].min = min(tree[node*2].min, tree[node*2+1].min)
}

func update_min(node, l, r, ql, qr, X int) {
	if ql > qr {
		return
	}
	if l > qr || r < ql || tree[node].max <= X {
		return
	}
	if ql <= l && r <= qr && tree[node].min >= X {
		apply_set(node, l, r, X)
		return
	}
	push_down(node, l, r)
	mid := (l + r) / 2
	update_min(node*2, l, mid, ql, qr, X)
	update_min(node*2+1, mid+1, r, ql, qr, X)
	pull_up(node)
}

func build(node, l, r int) {
	tree[node].lazy = -1
	if l == r {
		tree[node].sum = int64(l)
		tree[node].max = l
		tree[node].min = l
		return
	}
	mid := (l + r) / 2
	build(node*2, l, mid)
	build(node*2+1, mid+1, r)
	pull_up(node)
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	buf := make([]byte, 1024*1024)
	scanner.Buffer(buf, 10*1024*1024)

	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())

	a := make([]int, n+1)
	maxA := 0
	for i := 1; i <= n; i++ {
		scanner.Scan()
		a[i], _ = strconv.Atoi(scanner.Text())
		if a[i] > maxA {
			maxA = a[i]
		}
	}

	pos := make([]int, maxA+1)
	for i := 1; i <= n; i++ {
		pos[a[i]] = i
	}

	tree = make([]Node, 4*n+1)
	if n > 0 {
		build(1, 1, n)
	}

	var total_ans int64 = 0

	for g := maxA; g >= 1; g-- {
		p1, p2 := n+1, n+1
		pk_1, pk := 0, 0

		for m := 1; m*g <= maxA; m++ {
			p := pos[m*g]
			if p != 0 {
				if p < p1 {
					p2 = p1
					p1 = p
				} else if p < p2 {
					p2 = p
				}

				if p > pk {
					pk_1 = pk
					pk = p
				} else if p > pk_1 {
					pk_1 = p
				}
			}
		}

		if pk_1 != 0 {
			update_min(1, 1, n, 1, pk_1-1, 0)
			update_min(1, 1, n, pk_1, pk-1, p1)
			update_min(1, 1, n, pk, n, p2)
		}

		if n > 0 {
			U := tree[1].sum
			total_ans += int64(n)*int64(n+1)/2 - U
		}
	}

	fmt.Println(total_ans)
}