The Koszul Sign Rule A Bit of Background

The exterior algebra is a central object in topology and physics (for the physics concept cf. fermion). The basic rule dictating the behavior of the exterior algebra is that \$yx = -xy\$ (and consequently \$x^2 = -x^2 = 0\$). Applying this rule twice we see that \$yzx = -yxz = xyz\$. 

The product of two monomials is 0 if any repeated variable occurs, e.g. \$vxyz * stuv = 0\$ because \$v\$ is repeated. Otherwise, we want to put the variables into some standard order, say alphabetical order, and there is a sign introduced that counts how many variables we passed by each other, so for example \$tvy * suxz = +stuvxyz\$ because it takes a total of six crossings to put \$tvysuxz\$ into alphabetical order (on each line I have highlighted the most recently swapped pair):
$$tvy * suxz = +\, tvy\;suxz\\
\phantom{tvy * suxz } {}= -tv\mathbf{\large sy}uxz\\
\phantom{tvy * suxz } {}= +t\mathbf{\large sv}yuxz\\
\phantom{tvy * suxz } {}= -\mathbf{\large st}vyuxz\\
\phantom{tvy * suxz } {}= +stv\mathbf{\large uy}xz\\
\phantom{tvy * suxz } {}= -st\mathbf{\large uv}yxz\\
\phantom{tvy * suxz } {}= +stuv\mathbf{\large xy}z\\
$$
Your task will be to compute this sign.

This is a special case of the Koszul Sign Rule which determines the sign of the terms in many sums in math.
If you are familiar with determinants, the sign in the determinant formula is an example.

Task

You will take as input two 32 bit integers \$a\$ and \$b\$, which we will interpret as bitflags. You may assume that \$a\$ and \$b\$ have no common bits set, in other words that \$a\mathrel{\&amp;}b = 0\$. Say a pair of integers \$(i, j)\$ where \$0\leq i,j &lt; 32\$ is an "out of order pair in \$(a,b)\$" when:


\$i &lt; j\$,
bit \$i\$ is set in \$b\$, and
bit \$j\$ is set in \$a\$.


Your goal is to determine whether the number of out of order pairs in \$(a,b)\$ is even or odd. You should output true if the number of out of order pairs is odd, false if it is even. 

Input

A pair of 32 bit integers. If you would like your input instead to be a list of 0's and 1's or the list of bits set in each integer, that's fine.

Output

true or any truthy value if the number of out of order pairs is odd, false or any falsey value if it is even.
Alternatively, it is fine to output any pair of distinct values for the two cases. 
It is also fine to output any falsey value when the number of out of order pairs is odd and any truthy value when the number of out of order pairs is even.

Metric

This is code golf so shortest code in bytes wins.

Test cases

    a = 0b000000
    b = 0b101101 
    output = false // If one number is 0, the output is always false.

    a = 0b11
    b = 0b10    
    output = UNDEFINED // a &amp; b != 0 so the behavior is unspecified.

    a = 0b01
    b = 0b10
    output = true // 1 out of order pair (1,2). 1 is odd.

    a = 0b011
    b = 0b100
    output = false // 2 out of order pairs (1,2) and (1,3). 2 is even.

    a = 0b0101
    b = 0b1010
    output = true // 3 out of order pairs (1,2), (1,4), (3,4). 3 is odd.

    a = 0b0101010 // The example from the introduction
    b = 0b1010101 
    output = false // 6 out of order pairs (1,2), (1,4), (1,6), (3,4), (3,6), (5,6).

    a = 33957418
    b = 135299136
    output = false

    a = 2149811776
    b = 1293180930
    output = false

    a = 101843025
    b = 2147562240
    output = false

    a = 1174713364
    b = 2154431232
    output = true

    a = 2289372170
    b = 637559376
    output = false

    a = 2927666276
    b = 17825795
    output = true

    a = 1962983666
    b = 2147814409
    output = true

// Some asymmetric cases:
    a = 2214669314
    b = 1804730945
    output = true

    a = 1804730945
    b = 2214669314
    output = false

    a = 285343744
    b = 68786674
    output = false

    a = 68786674
    b = 285343744
    output = true

    a = 847773792
    b = 139415
    output = false
COW, 363 285 bytes
moOoommoOmoOmoOoomMOOmoOmOoMOOMOomOoMoOmoOMMMMOOMMMMOomOoMOomoOmoOMoOmOoMMMOOOmooMMMmoomoOMMMOOOmOoMMMmOoMOOmOoMMMmoOmoOmoOMMMMOOMOomoOMMMMOOMMMMOoMOoMMMOOOmooMMMMoOmOomoomOomOoOOOmoomOomOoMOOMOomoOMoOmOoMMMMOOMMMMOomoOMOomOomOoMoOmoOMMMOOOmooMMMmoomOoMMMOOOmoOMMMmoOmoOmoOmoomoOmoOOOM

Try it online!
A major change! (It's faster but still test cases exceed the 60 seconds timeout on TIO)
Now I like it better, it's cleaner, symmetric and I've brute forced the memory cells disposition for least number of movements.
The idea is to directly operate in terms of parity. Information in both LSB will be used in each iteration and then a and b will be halved, until b=0.

Every a%2 is calculated (during repeated subtraction) alternating +1 and -1 in one memory cell, so that their partial sum p is available.
When a '1' is found in b, the parity (the answer) is toggled p many times.

Detailed Explanation:
moo ]    mOo &lt;    MOo -    OOO *    OOM i
MOO [    moO &gt;    MoO +    MMM =    oom o


[0]: a/2     [1]: a     [2]: Sum(a%2)     [3]: b%2     [4]: b     [5]: b/2     [6]: parity


&gt;i&gt;&gt;&gt;i                        ;  Read a in [1] and b in [5]
[                             ;  Loop while [5] is non-zero
    &gt;&lt;                        ;     Just 2 instructions for free cause COW doesn't handle consecutive parethesis :D
    [                         ;     Loop while [5] is non-zero
        -&lt;+&gt;=[=-&lt;-&gt;&gt;+&lt;=*]=    ;         SECTION B
    ]                         ;     [5] is 0, [3] is b%2, [5] is b/2
    &gt;=*&lt;=                     ;     Copy [5] in [4], delete [5]
    &lt;                         ;     Point to [3]
    [                         ;     Loop if [3] is non-zero. '1' it's been found in b, parity gets updated
        &lt;=&gt;&gt;&gt;=                ;         Copy [2] in [5]
        [                     ;         Loop while [5] is non zero
            -                 ;             Decrement [5]
            &gt;=[=--=*]=+&lt;      ;             TOGGLE [6]
        ]                     ;  
        &lt;&lt;*                   ;         Delete [3] (to exit the loop)
    ]                         ;     
    &lt;&lt;                        ;     Point to [1]
    [                         ;     Loop while [1] is non-zero
        -&gt;+&lt;=[=-&gt;-&lt;&lt;+&gt;=*]=    ;         SECTION A
    ]                         ;     [1] is 0, a%2 is added in [2], [0] is a/2
    &lt;=*&gt;=                     ;     Copy [0] in [1], delete [0]
    &gt;&gt;&gt;                       ;     Point to [5]
]                             ;     a's and b's LSB have been treated. Now a=a/2 and b=b/2
&gt;&gt;o                           ;  Print [6]

SECTION A ≈ SECTION B is repeated subtraction that divide \$n\$ (a or b, resp.) by \$2\$.
This can't be done in one single step (i.e. --), because \$0\$ can't be surpassed in order to stop (so it'd be -[- =*]=). These sections contextually produce \$n\bmod 2\$ (LSB).
TOGGLE is a toggling method:
When target is 0 it fails the condition and simply +1 is done.
When target is 1 it passes the condition and it's set to -1 so that +1 on exit makes it 0.
Copy, delete, and paste in the same memory cell is a tecnique to treat a while loop like an if loop, also the seemgly useless copy-paste at the beginning of these (=[=) serves to balance the ending one (=*]=) in case if condition fails.