```python
def get_total_number_of_sequences(m, n):
    """
    Finds the number of possible sequences of length n such that each
    element is >= 2 * previous element and <= m.
    """
    if n == 0:
        return 1

    # dp[j] stores the number of valid sequences of the current length
    # that end with the value j.
    # Initialize for sequences of length 1.
    dp = [1] * (m + 1)
    dp[0] = 0

    # Iterate for lengths from 2 to n. This loop runs n-1 times.
    for _ in range(n - 1):
        # To calculate the dp values for the current length, we need the
        # prefix sums of the dp values from the previous length.
        prefix_sum = [0] * (m + 1)
        for k in range(1, m + 1):
            prefix_sum[k] = prefix_sum[k - 1] + dp[k]

        # Calculate the new dp table for the current length.
        new_dp = [0] * (m + 1)
        for j in range(1, m + 1):
            # A sequence of the current length ending in j must have come from a
            # sequence of the previous length ending in k, where 2*k <= j.
            # The number of such sequences is the sum of dp[k] for k from 1 to j//2,
            # which is exactly what prefix_sum[j//2] stores.
            limit = j // 2
            new_dp[j] = prefix_sum[limit]
        
        # The new dp table becomes the current dp table for the next iteration.
        dp = new_dp

    # The total number of sequences of length n is the sum of sequences
    # ending in any possible value from 1 to m.
    return sum(dp)

```