Add Numbers deux — Bitwise Addition Your job is to implement bitwise addition.

To ensure that this is done, you will compute and print the result of addition without carry (or bitwise XOR). Then, you will compute the carry of the addition (bitwise AND) and multiply it by two (bitwise left shift). If the carry is nonzero, then you add the carry and the previous result until the carry is zero, at which point you stop producing output. If all is done correctly, the final result printed should be the sum of the two integers that you received as input.

Here's an ungolfed reference implementation in C:

#include &lt;stdio.h&gt;

void print_add(unsigned a, unsigned b)
{
    unsigned carry;

    while(b)
    {
        carry = a &amp; b;
        a ^= b;
        printf("%u\n", a);
        b = carry &lt;&lt; 1;
    }
}


Input

Two positive integers in any convenient format.

Output

A list of positive integers in any convenient format representing each result of addition without carry. Leading/trailing whitespace/newlines are allowed.

Rules


This is code-golf. The answer with the least bytes in each language wins, which means that I will not accept an answer.
Standard loopholes are forbidden. This includes, but is not limited to, Abusing native number types to trivialize a problem.


Testcases

1, 1 -&gt; 0, 2
3, 17 -&gt; 18, 16, 20
6, 7 -&gt; 1, 13
21, 19 -&gt; 6, 36, 32, 40
10, 9 -&gt; 3, 19
20, 20 -&gt; 0, 40


Your code must work for at least all pairs of positive integers that your integer type can represent the sum of.
JavaScript (ES6), 34 bytes
Takes input as (A)(B), where A+B is a positive-looking 32-bit integer, i.e. less than 0x80000000.
Returns an array.

A=&gt;g=B=&gt;B?[A^=B,...g((B&amp;~A)*2)]:[]

Try it online!
Or for 35 bytes, a BigInt version with unlimited input:

A=&gt;g=B=&gt;B?[A^=B,...g((B&amp;~A)*2n)]:[]

Try it online!
How?
In order to use only 2 variables and pass a single variable to the recursive function, we apply the XOR right away to A and prepend the result to the output array.
Instead of computing (A AND B) * 2, we now need to compute (B AND (A XOR B)) * 2. Fortunately this can also be expressed as:
(B AND (NOT A)) * 2

leading to the rather short (B&amp;~A)*2 in JS syntax.