Looking at this problem, I need to find the number of stable arrays of length k with elements from 1 to n in strictly increasing order.

**Key Insight:** An array is stable if the order of mod operations doesn't matter. Let me analyze when this happens.

For an array [a₁, a₂, ..., aₖ] (sorted increasingly), applying mods in any order gives the same result. The critical observation is:

If we have elements a₁ < a₂ < ... < aₖ, then for the array to be stable, each aᵢ must be a divisor of aᵢ₊₁ (or more precisely, each element must divide all larger elements). Wait, let me reconsider.

Actually, the condition is that for any x and any reordering, the sequential mod gives the same result. 

If a divides b, then (x mod b) mod a = x mod a, and (x mod a) mod b = x mod a (since x mod a < a ≤ b). So both orderings give x mod a. This means if every element divides every larger element (i.e., a₁ | a₂ | ... | aₖ), then the result is always x mod a₁ regardless of order.

Also, if a₁ = 1, the result is always 0 regardless of order.

Additionally, arrays where all elements are equal wouldn't apply here since elements are strictly increasing.

The case k=1 is trivially n arrays.

So stable arrays are:
1. Any array containing 1 (since mod 1 = 0, and this 0 persists through all subsequent mods). The number of such arrays is C(n-1, k-1).
2. Arrays where a₁ | a₂ | ... | aₖ (divisibility chain), not containing 1.

For divisibility chains of length k with elements in [2, n]: we need to count chains a₁ | a₂ | ... | aₖ where 2 ≤ a₁ < a₂ < ... < aₖ ≤ n and each divides the next.

I can count divisibility chains using DP. Let f[v] = number of divisibility chains of length k ending at v. We build this layer by layer.

Let dp[j][v] = number of chains of length j ending at value v. Transition: dp[j][v] = sum of dp[j-1][d] for all proper divisors d of v with d ≥ 2.

This would be O(k * n log n) which might be too slow for k, n up to 5×10⁵. But in practice, divisibility chains can't be too long since each element at least doubles. So the maximum chain length is log₂(n) ≈ 19. If k > 19 (for n=500000), chains without 1 contribute 0, and the answer is just C(n-1, k-1).

So for k ≤ 19, we compute the DP; otherwise, answer = C(n-1, k-1).

```go
package main

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

const MOD = 998244353

func main() {
	reader := bufio.NewReader(os.Stdin)
	var n, k int
	fmt.Fscan(reader, &n, &k)

	// Precompute factorials for combinations
	maxN := n + 1
	fac := make([]int64, maxN)
	inv := make([]int64, maxN)
	fac[0] = 1
	for i := 1; i < maxN; i++ {
		fac[i] = fac[i-1] * int64(i) % MOD
	}
	inv[maxN-1] = power(fac[maxN-1], MOD-2)
	for i := maxN - 2; i >= 0; i-- {
		inv[i] = inv[i+1] * int64(i+1) % MOD
	}

	comb := func(a, b int) int64 {
		if b < 0 || b > a {
			return 0
		}
		return fac[a] % MOD * inv[b] % MOD * inv[a-b] % MOD
	}

	// Arrays containing 1
	ans := comb(n-1, k-1)

	// Divisibility chains of length k in [2..n]
	if k >= 2 && k <= 19 {
		// dp[v] = number of chains of current length ending at v
		dp := make([]int64, n+1)
		for v := 2; v <= n; v++ {
			dp[v] = 1
		}
		for j := 2; j <= k; j++ {
			ndp := make([]int64, n+1)
			for v := 2; v <= n; v++ {
				if dp[v] == 0 {
					continue
				}
				for m := 2 * v; m <= n; m += v {
					ndp[m] = (ndp[m] + dp[v]) % MOD
				}
			}
			dp = ndp
		}
		for v := 2; v <= n; v++ {
			ans = (ans + dp[v]) % MOD
		}
	} else if k == 1 {
		ans = int64(n)
	}

	fmt.Println(ans % MOD)
}

func power(base, exp int64) int64 {
	result := int64(1)
	base %= MOD
	for exp > 0 {
		if exp%2 == 1 {
			result = result * base % MOD
		}
		base = base * base % MOD
		exp /= 2
	}
	return result
}
```