```go
package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
)

func is_4th(n int64) int64 {
	x := int64(math.Round(math.Pow(float64(n), 0.25)))
	for i := x - 2; i <= x + 2; i++ {
		if i > 0 && i*i*i*i == n {
			return i
		}
	}
	return 0
}

func is_3rd(n int64) int64 {
	x := int64(math.Round(math.Pow(float64(n), 1.0/3.0)))
	for i := x - 2; i <= x + 2; i++ {
		if i > 0 && i*i*i == n {
			return i
		}
	}
	return 0
}

func is_2nd(n int64) int64 {
	x := int64(math.Round(math.Sqrt(float64(n))))
	for i := x - 2; i <= x + 2; i++ {
		if i > 0 && i*i == n {
			return i
		}
	}
	return 0
}

func gcd(a, b int64) int64 {
	for b != 0 {
		a, b = b, a%b
	}
	return a
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	var n int
	if _, err := fmt.Fscan(reader, &n); err != nil {
		return
	}

	a := make([]int64, n)
	orig_a := make([]int64, n)
	for i := 0; i < n; i++ {
		fmt.Fscan(reader, &a[i])
		orig_a[i] = a[i]
	}

	is_perf := make([]bool, n)
	var known_primes []int64

	for i := 0; i < n; i++ {
		if p := is_4th(a[i]); p > 0 {
			known_primes = append(known_primes, p)
			is_perf[i] = true
		} else if p := is_3rd(a[i]); p > 0 {
			known_primes = append(known_primes, p)
			is_perf[i] = true
		} else if p := is_2nd(a[i]); p > 0 {
			known_primes = append(known_primes, p)
			is_perf[i] = true
		}
	}

	for i := 0; i < n; i++ {
		if !is_perf[i] {
			for j := i + 1; j < n; j++ {
				if !is_perf[j] && a[i] != a[j] {
					g := gcd(a[i], a[j])
					if g > 1 {
						known_primes = append(known_primes, g)
					}
				}
			}
		}
	}

	unique_primes := make(map[int64]bool)
	for _, p := range known_primes {
		unique_primes[p] = true
	}

	primes := make(map[int64]int)

	for p := range unique_primes {
		for i := 0; i < n; i++ {
			for a[i]%p == 0 {
				primes[p]++
				a[i] /= p
			}
		}
	}

	for i := 0; i < n; i++ {
		if a[i] > 1 && a[i] < orig_a[i] {
			primes[a[i]]++
			a[i] = 1
		}
	}

	rem_counts := make(map[int64]int)
	for i := 0; i < n; i++ {
		if a[i] > 1 {
			rem_counts[a[i]]++
		}
	}

	ans := int64(1)
	mod := int64(998244353)

	for _, count := range primes {
		ans = (ans * int64(count+1)) % mod
	}

	for _, count := range rem_counts {
		ans = (ans * int64(count+1)) % mod
		ans = (ans * int64(count+1)) % mod
	}

	fmt.Println(ans)
}
```