Prefix Flip (Hard Version)
This is the hard version of the problem. The difference between the versions is the constraint on $$$n$$$ and the required number of operations. You can make hacks only if all versions of the problem are solved.There are two binary strings $$$a$$$ and $$$b$$$ of length $$$n$$$ (a binary string is a string consisting of symbols $$$0$$$ and $$$1$$$). In an operation, you select a prefix of $$$a$$$, and simultaneously invert the bits in the prefix ($$$0$$$ changes to $$$1$$$ and $$$1$$$ changes to $$$0$$$) and reverse the order of the bits in the prefix.For example, if $$$a=001011$$$ and you select the prefix of length $$$3$$$, it becomes $$$011011$$$. Then if you select the entire string, it becomes $$$001001$$$.Your task is to transform the string $$$a$$$ into $$$b$$$ in at most $$$2n$$$ operations. It can be proved that it is always possible.
In the first test case, we have $$$01\to 11\to 00\to 10$$$.In the second test case, we have $$$01011\to 00101\to 11101\to 01000\to 10100\to 00100\to 11100$$$.In the third test case, the strings are already the same. Another solution is to flip the prefix of length $$$2$$$, which will leave $$$a$$$ unchanged.
The first line contains a single integer $$$t$$$ ($$$1\le t\le 1000$$$)  — the number of test cases. Next $$$3t$$$ lines contain descriptions of test cases.The first line of each test case contains a single integer $$$n$$$ ($$$1\le n\le 10^5$$$)  — the length of the binary strings.The next two lines contain two binary strings $$$a$$$ and $$$b$$$ of length $$$n$$$.It is guaranteed that the sum of $$$n$$$ across all test cases does not exceed $$$10^5$$$.
For each test case, output an integer $$$k$$$ ($$$0\le k\le 2n$$$), followed by $$$k$$$ integers $$$p_1,\ldots,p_k$$$ ($$$1\le p_i\le n$$$). Here $$$k$$$ is the number of operations you use and $$$p_i$$$ is the length of the prefix you flip in the $$$i$$$-th operation.
for _ in range(int(input())):
    n = int(input())
    s = input()
    s += '0'
    t = input()
    t += '0'
    t = t[::-1]
    result = []
    for i in range(n):
        if s[i] != s[i + 1]:
            result.append(i + 1)
    for j in range(n):
        if t[j] != t[j + 1]:
            result.append(n - j)
    print(len(result), *result)
import sys
p2D = lambda x: print(*x, sep='\n')

def II():
    return int(sys.stdin.buffer.readline())

def MI():
    return map(int, sys.stdin.buffer.readline().split())

def LI():
    return list(map(int, sys.stdin.buffer.readline().split()))

def LLI(rows_number):
    return [LI() for _ in range(rows_number)]

def BI():
    return sys.stdin.buffer.readline().rstrip()

def SI():
    return sys.stdin.buffer.readline().rstrip().decode()

def li():
    return [int(i) for i in input().split()]

def lli(rows):
    return [li() for _ in range(rows)]

def si():
    return input()

def ii():
    return int(input())

def ins():
    return input().split()

def merge(a, b, l1, l2):
    ans = []
    i = j = 0
    while i < l1 and j < l2:
        if a[i] < b[j]:
            ans.append(a[i])
            i += 1
        else:
            ans.append(b[j])
            j += 1
    if i != l1:
        ans += a[i:]
    if j != l2:
        ans += b[j:]
    return ans

def msort(a, n):
    if n == 1:
        return a
    if n == 2:
        return [min(a), max(a)]
    return merge(msort(a[:n // 2], n // 2), msort(a[n // 2:n], n - n // 2), n // 2, n - n // 2)

def binexp(a, x, mod=1):
    ans = 1
    if x == 0:
        return 1
    elif x == 1:
        return a
    p = binexp(a, x // 2, mod)
    if x % 2 == 0:
        ans *= p * p % mod
    else:
        ans *= p * p * a % mod
    return ans

def gcd(a, b):
    if b == 0:
        x = 1
        y = 0
        return (x, y, a)
    (x, y, g) = gcd(b, a % b)
    return (y, x - a // b * y, g)
mod = 998244353

def solve():
    (n, a, b) = (ii(), list(si()), si())
    ans = []
    (start, end, i, flip) = (0, n - 1, n - 1, False)
    while i != -1:
        if (int(a[end]) + flip) % 2 != int(b[i]):
            if (int(a[start]) + flip) % 2 == int(b[i]):
                ans.append(1)
            (start, end) = (end, start + (-1) ** flip)
            flip = not flip
            ans.append(i + 1)
        else:
            end = int(end + (-1) ** (not flip))
        i -= 1
    return str(len(ans)) + ' ' + ' '.join(map(str, ans))

def main():
    for _ in range(ii()):
        sys.stdout.write(str(solve()) + '\n')
if __name__ == '__main__':
    main()
for _ in range(int(input())):
    n = int(input())
    s = str(input())
    t = str(input())
    f = 0
    if s[0] == '1':
        f = 1
    ans = []
    for i in range(n):
        if s[i] == '1':
            if f:
                continue
            else:
                f = 1
                ans.append(i)
        elif f == 0:
            continue
        else:
            f = 0
            ans.append(i)
    for i in range(n - 1, -1, -1):
        if t[i] == '1':
            if f:
                continue
            else:
                f = 1
                ans.append(i + 1)
        elif f == 0:
            continue
        else:
            f = 0
            ans.append(i + 1)
    print(len(ans), *ans)