(a) U2 F U2 F' L2 F' L2 F L2 B L2 B'

(b) U R2 U' B2 U' B2 U B2 D B2 D' R2

(c) U' B2 U R2 U R2 U' R2 D' R2 D B2

We need to see what the moves

R U2 R' do to a solved cube.

(1) The two front corners in U are swapped with each other

(2) The other two corners are swapped with each other.

(3) The front and back edges in U are swapped with each other

(4) The other two edges are swapped with each other.

Take a screen shot of this, draw permutation arrows, or whatever necessary to ingrain this effect in your memory (or just keep it on the side as a reference). Also be aware of what the moves

L' U2 L do as well (the mirror case).

[1] Let's rotate these algorithms as follows so we can apply what we know now.

(a) U2 R U2 R' F2 R' F2 R F2 L F2 L'

(b) L U2 L' B2 L' B2 L B2 R B2 R' U2

(c) L' B2 L U2 L U2 L' U2 R' U2 R B2

[2] Let's rewrite these algorithms, introduce cube rotations and breaking them up into fragments of R U2 R' and L' U2 L.

(a) We take the inverse to start with a left or right slice turn: L F2 L' F2 R' F2 R F2 R U2 R' U2. Now we spit it.

y2 x' R U2 R' x y2 F2 x y2 L' U2 L y2 x' F2 R U2 R' U2 = y2 x' R U2 R' U2 L' U2 L y2 x' F2 R U2 R' U2

(b) We just need to split it:

y2 R U2 R' y2 x' U2 L' U2 L U2 R U2 R' x U2

(c) We just need to split it:

x' L' U2 L x U2 y2 R U2 R' y2 y2 U2 L' U2 L y2 B2 = x' L' U2 L x U2 y2 R U2 R' U2 L' U2 L y2 B2

[3] Now we observe each of them separately...it's not easy to see this, but if you study them long enough, having them broken up into pieces of R U2 R' and L' U2 L (or if you would instead prefer L U2 L' and R' U2 R), you can logically trace the pieces as you go. This is exactly how I found this algorithm for the 4x4x4:

r U2 r' U2 r' D2 r D2 r' B2 r B2 r'. Note that for this parity algorithm, I started with the piece (r U2) r' (U2 r'), which is a conjugate of the extra quarter turn. Then I used this technique to restore the centers and pair up the wing edges. In other words, instead of keeping my eye on corners and middle edges, I kept my eye on what

r U2 r' does to wing edges and 1x2 center blocks, respectively.

I later applied this technique to find ground breaking parity algorithms not in the move set <U2,D2,F2,B2,l,r>, as I describe how I found one such algorithm in

this post, and I later applied this same idea again to create my own semi-optimized reduction method which I introduced in

this post.

So perhaps these algorithms might be even easier to understand if you translate them to the inner slices of a 4x4x4 (the corners become wing edges and the middle edges become 1x2 center blocks), for example,

y2 r U2 r' y2 x' U2 l' U2 l U2 r U2 r' x U2