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.
""""""

def solve(a, b, n):
    op1 = []
    op2 = []
    a += '0'
    b += '0'
    for i in range(1, n + 1):
        if a[i] != a[i - 1]:
            op1.append(i)
        if b[i] != b[i - 1]:
            op2.append(i)
    op1 += op2[::-1]
    print(len(op1), ' '.join([str(x) for x in op1]))
    return
if __name__ == '__main__':
    t = int(input())
    while t:
        n = int(input())
        a = input()
        b = input()
        solve(a, b, n)
        t -= 1
def tc():
    n = int(input())
    a = input()
    b = input()
    segs = []
    prev = a[0]
    for (i, ch) in enumerate(a[1:]):
        if ch != prev:
            segs.append(i + 1)
        prev = ch
    bsegs = []
    bprev = b[0]
    for (i, ch) in enumerate(b[1:]):
        if ch != bprev:
            bsegs.append(i + 1)
        bprev = ch
    if a[-1] != b[-1]:
        segs.append(n)
    segs.extend(bsegs[::-1])
    print(len(segs), ' '.join(map(str, segs)))
T = int(input())
for _ in range(T):
    tc()
def prefixFlip(s1, s2, n):
    operations = []
    rev_ops = []
    k = 0
    for i in range(n - 1):
        if s1[i] != s1[i + 1]:
            operations.append(str(i + 1))
            k += 1
    for i in range(n - 1):
        if s2[i] != s2[i + 1]:
            rev_ops.append(str(i + 1))
            k += 1
    if s2[-1] != s1[-1]:
        rev_ops.append(str(n))
        k += 1
    operations += rev_ops[::-1]
    return [str(k)] + operations
t = int(input())
for g in range(t):
    n = int(input())
    s1 = input()
    s2 = input()
    ans = prefixFlip(s1, s2, n)
    print(' '.join(ans))