I am not sure if older versions of cube explorer yield identical solutions, so I need to mention that I am using version 5.00.

1) Start out with the 4-cycle double-parity case:

r U2 r l' U2 r2 U2 r' U2 r U2 r' U2 r' U2 l U2 r'
(I got this algorithm from Thom Barlow's (Kirjava's)

ELL page.)

2) Convert all inner-layer slices to outer-layers (to match the 3x3x3)

R U2 R L' U2 R2 U2 R' U2 R U2 R' U2 R' U2 L U2 R' (18 f)

3) Type (or copy and paste) this into cube explorer, apply to a solved 3x3x3 cube, and hit the "add and solve" button. Then click the green arrow until you get the following 15f solution:

F2 R F2 R F2 R' U2 R2 U2 F2 L' U2 L U2 R2 (15 f)

**Cube Explorer's work is done.** From here, it is all up to us to make this into what we want.

4) By experimentation, we can find out to convert both

**double** turns of R into wide turns.

So that you have a set-up like this:

F2 R F2 R F2 R' U2 Rw2 U2 F2 L' U2 L U2 Rw2, where

a) the cube isn't totally scrambled

b) the inner layers are affected, but the net result is a "half turn" away from being "solved", as opposed to if we tried to convert an even number of the quarter turns to wide too.

For example, the following are very bad because they don't give us much to work with AND, it is making this algorithm more on the inner-layer odd parity algorithm's side (by really affecting the wings).

F2 R F2 R F2 R' U2 R2 U2 F2 Lw' U2 Lw U2 R2
or

F2 R F2 Rw F2 Rw' U2 R2 U2 F2 Lw' U2 Lw U2 R2
or

F2 R F2 Rw F2 Rw' U2 R2 U2 F2 L' U2 L U2 Rw2
...etc.

5) Although it might seem to be a mess, what we have

F2 R F2 R F2 R' U2 Rw2 U2 F2 L' U2 L U2 Rw2
will work out just fine.

Adding the algorithm piece, U2 r2,

So we have

F2 R F2 R F2 R' U2 Rw2 U2 F2 L' U2 L U2 Rw2 + U2 r2

=

F2 R F2 R F2 R' U2 Rw2 U2 F2 L' U2 L U2 Rw2 U2 r2
This swaps two corners and two 1x2 center blocks (it also turns another center 90 degrees due to swapping two corners: that is related to regular PLLs).

From here, we can just add one set-up move to swap the same-color centers with each other:

r2

F2 R F2 R F2 R' U2 Rw2 U2 F2 L' U2 L U2 Rw2 U2 r2

r2
=

r2 F2 R F2 R F2 R' U2 Rw2 U2 F2 L' U2 L U2 Rw2 U2 (17 btm)

6) Now for optimization (which is totally up to the individual, but this is how I made it into the algorithm I presented),

a) Rotating about y2 and taking the mirror image of that,

r2 B2 R' B2 R' B2 R U2 Rw2 U2 B2 L U2 L' U2 Rw2 U2
b) Adding an x cube rotation (for faster execution)

x' r2 U2 R' U2 R' U2 R x U2 Rw2 U2 B2 L U2 L' U2 Rw2 U2
c) More cube rotation "conjugates" to move the two swapped corners in the top-front,

z x

x' r2 U2 R' U2 R' U2 R x U2 Rw2 U2 B2 L U2 L' U2 Rw2 U2

x' z'
=

z r2 U2 R' U2 R' U2 R x U2 Rw2 U2 B2 L U2 L' U2 Rw2 U2 x' z'
DONE