```go
package main

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

const MOD = 998244353

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

	scanner.Scan()
	A := scanner.Text()
	scanner.Scan()
	L := scanner.Text()
	scanner.Scan()
	R := scanner.Text()

	n := len(A)
	nL := len(L)
	nR := len(R)

	// Precompute Z-values for LCP
	zL := zFunc(L + "#" + A)
	zR := zFunc(R + "#" + A)

	dp := make([]int, n+1)
	dp[0] = 1

	// Prefix sums of dp[k] where A[k] != '0'
	P := make([]int, n+1)
	if A[0] != '0' {
		P[0] = 1
	}

	for i := 1; i <= n; i++ {
		// 1. Range sum for lengths strictly between nL and nR
		// Valid length k in (nL, nR) -> k in [nL+1, nR-1]
		// Start index j = i - k -> j in [i-nR+1, i-nL-1]
		if nL < nR {
			minJ := i - nR + 1
			maxJ := i - nL - 1
			
			if minJ < 0 {
				minJ = 0
			}
			
			if maxJ >= minJ {
				sum := P[maxJ]
				if minJ > 0 {
					sum = (sum - P[minJ-1] + MOD) % MOD
				}
				dp[i] = (dp[i] + sum) % MOD
			}
		}

		// 2. Boundary length nL
		j := i - nL
		if j >= 0 {
			match := false
			idx := nL + 1 + j
			lcp := zL[idx]
			if lcp >= nL {
				match = true
			} else if A[j+lcp] > L[lcp] {
				match = true
			}

			if match {
				// If length is 1, '0' is allowed (if L="0")
				// If length > 1, no leading zero
				if nL == 1 || A[j] != '0' {
					dp[i] = (dp[i] + dp[j]) % MOD
				}
			}
		}

		// 3. Boundary length nR
		if nR > nL {
			j = i - nR
			if j >= 0 {
				match := false
				idx := nR + 1 + j
				lcp := zR[idx]
				if lcp >= nR {
					match = true
				} else if A[j+lcp] < R[lcp] {
					match = true
				}

				if match {
					// nR > nL >= 1 implies nR >= 2, so leading '0' invalid
					if A[j] != '0' {
						dp[i] = (dp[i] + dp[j]) % MOD
					}
				}
			}
		}

		// Update P for next iterations
		if i < n {
			val := 0
			if A[i] != '0' {
				val = dp[i]
			}
			P[i] = (P[i-1] + val) % MOD
		}
	}

	fmt.Println(dp[n])
}

func zFunc(s string) []int {
	n := len(s)
	z := make([]int, n)
	for i, l, r := 1, 0, 0; i < n; i++ {
		if i <= r {
			min := r - i + 1
			if z[i-l] < min {
				min = z[i-l]
			}
			z[i] = min
		}
		for i+z[i] < n && s[z[i]] == s[i+z[i]] {
			z[i]++
		}
		if i+z[i]-1 > r {
			l, r = i, i+z[i]-1
		}
	}
	return z
}
```