```go
package main

import (
	"fmt"
	"strings"
)

func main() {
	var s string
	fmt.Scan(&s)
	fmt.Println(solve(s))
}

func solve(s string) int {
	n := len(s)

	if n == 1 {
		if s == "0" || s == "_" || s == "X" {
			return 1
		}
		return 0
	}

	patterns := []string{"00", "25", "50", "75"}
	total := 0
	hasX := strings.Contains(s, "X")

	for _, pattern := range patterns {
		p0 := int(pattern[0] - '0')
		p1 := int(pattern[1] - '0')

		if n == 2 && p0 == 0 {
			continue
		}

		if hasX {
			xMin, xMax := 0, 9

			if s[n-2] == 'X' {
				xMin, xMax = p0, p0
			}
			if s[n-1] == 'X' {
				if xMin > p1 || xMax < p1 {
					continue
				}
				xMin, xMax = p1, p1
			}

			if n >= 3 && s[0] == 'X' {
				if xMin == 0 && xMax >= 1 {
					xMin = 1
				} else if xMax == 0 {
					continue
				}
			}

			for xVal := xMin; xVal <= xMax; xVal++ {
				total += countWays(s, pattern, xVal, n)
			}
		} else {
			total += countWays(s, pattern, -1, n)
		}
	}

	return total
}

func countWays(s string, pattern string, xVal int, n int) int {
	p0 := int(pattern[0] - '0')
	p1 := int(pattern[1] - '0')

	last1 := s[n-2]
	last2 := s[n-1]

	if last1 != 'X' && last1 != '_' && int(last1-'0') != p0 {
		return 0
	}
	if last2 != 'X' && last2 != '_' && int(last2-'0') != p1 {
		return 0
	}

	if xVal >= 0 {
		if last1 == 'X' && xVal != p0 {
			return 0
		}
		if last2 == 'X' && xVal != p1 {
			return 0
		}
	}

	if n >= 3 {
		first := s[0]
		if first == 'X' && xVal == 0 {
			return 0
		}
		if first != 'X' && first != '_' && first == '0' {
			return 0
		}
	}

	ways := 1
	for i := 0; i < n; i++ {
		if i == n-2 || i == n-1 {
			continue
		}
		if s[i] == '_' {
			if i == 0 {
				ways *= 9
			} else {
				ways *= 10
			}
		}
	}

	return ways
}
```