Next: L2 B' D2 B' U2 B' R2 B' U2 R2 U' F' R2 B' U2 R' U2 L2

method: 3-cycles TurBO variation "Solid Diagonal"

solving orientation: scramble orientation: white up green front std colors

letter system: anticlockwise major: UFRBLD order "A" thru "W" and "Y"

generator: B2 D2 L2 D2 F2 D2 R2 U F D' R F' U' R' B2 D B R' (18f*)

edge_#_corner cycles per my solving orientation and letter system: (ATJON_BYEGPq'r_Sv_#_AOLISq-u_Gj-y_Kn-w)

split into pairs off A_ edge buffer and memorize: TJ ON BY EG PQ(flip) S(flip)

similarly off _A corner buffer: OL IS(backtwist) G(backtwist) K(backtwist)

I prefer to solve the corners first.

to solve _OL corner, apply _OL 6 BO 2 YO:

code 6 move _OL to _BO (I think "setup _O"): x z

// twist the whole cube along the axis of 3-fold symmetry along ULB-DRF

// whole-cube turning ULB to BUL and DRF to RFD. Then _O becomes _B and _L

// becomes _O, BDL becomes ULF and RBU becomes BDL in two steps: _O moves

// with the whole cube to _T (BDL to LUF) and twists once anticlockwise with

// the buffer to _B (LUF to UFL); _L moves with the whole cube to _V (RBU to

// DLB) and twists once anticlockwise with the buffer to _O (DLB to BLD)

double-type move _BO to _YO (I think "setup _Y"): F2

solve _YO with the alg for _OY: x' U R' U' L' U R U' L x

return _YO to _BO (I think "restore _O"): F2

return _BO to _OL (I think "restore _L"): x' y

// whole-cube untwist along the same 3-fold axis applying a single spin-type move.

optimal generator of the result after this step:

U2 L2 F' U' L D R2 F' L' D B' D R2 D F2 D2 L2 (17f*)

(ATJON_BYEGP'r_S'v_#_AIS-u_G-y_K-w)

to solve _IS corner, apply _IS _IO _JO

move _IS to _IO (I think "setup _O"): D'

move _IO to _JO (I think "setup _J"): R'

solve _JO with the alg for _OJ: L B' R2 B L' B' R2 B

return _JO to _IO (I think "restore _I"): R

return _IO to _IS (I think "restore _S"): D

optimal generator of the result after this step:

B2 U2 B L2 D B2 U B D L' F R2 F U2 B2 R2 U2 (17f*)

(ATJON_BYEGPq'r_Sv_#_Aq-p_Gj-y_Kn-w)

// here all the corners are in place, but three are back-twisted. To solve,

// I apply a solid-diagonal twist-untwist algorithm that affects _A and _G

// (UBL and DRF).

R' Fw2 L D' F2 D L' Fw2 R U' F2 U

optimal generator of the result after this step:

F U2 R2 D U' R2 U' B' L' U2 R2 F L F2 R F' (16f*)

(ATJON_BYEGPq'r_Sv_#_Ap+q_Kn-w)

// to apply a second time, I setup move _K to _J (RDB to RFD)

( "setup _J") R

R' Fw2 L D' F2 D L' Fw2 R U' F2 U

( "restore "_K") R'

// now the corners are solved

optimal generator of the result after this step:

U' B2 D L' R B' R2 B2 R F U L R' B' R' B2 F U' (18f*)

(ATJON_BYEGPq'r_Sv_#)

to solve TJ_ edge: apply TJ_ 2 JT 2 JR UR

( "setup R_" ) TJ_ 2 JT 2 JR: F2 L2

( "setup U_" ) JR_ UR: F

solve UR_ with alg for RU_: M2 F L2 F' M2 F L2 F'

( "restore "T_" ) UR_ JR: F'

( "restore "J_" ) JR_ 2 JT 2 TJ: L2 F2

optimal generator of the result after this step:

U2 F' D L R' F' R F2 D' B R' B2 F2 L F' R (16f*)

(AON_BYEGPq'r_Sv_#)

to solve ON_ edge: ON_ 3 SR GR

( "setup R_") ON_ 3 SR: Dw // "3" is my code for a two-layer "w" type move

// 'w' and '3' look somewhat alike

( "setup G_") SR GR: D

solve GR_ with alg for RG_: D2 M' D L' D' M D L D

( "restore "O_" ): GR_ SR: D'

( "restore "N_" ): SR_ 3 ON: Dw'

optimal generator of the result after this step:

F2 L2 F2 L' D2 U L D U' F' D L' F2 L2 (14f*)

(BYEGPq'r_Sv_#)

to solve BY_ edge: BY_ PY 2 PV % // % signifies that I set up the target first

( "setup P_" % ): BY_ PY: L' // % flags a reversed setup order

( "setup V_" ): PY_ 2 PV: D2

solve PV_ with the alg for VP_: L' D M2 D' L D M2 D'

( "restore Y_" % ): PV_ 2 PY: D2

( "restore B_" ): PY_ BY: L

optimal generator of the result after this step:

B2 L' D U L' D' U B U2 L' B2 R2 F2 R2 (14f*)

(AEGPQm'b_Sv_#)

to solve EG_ edge: EG_ ES ER 2 GR

( "setup R_" ): EG_ ES ER: D' L

( "setup G_" ): ER_ 2 GR: F2

solve GR_ with the alg or RG_: D2 M' D L' D' M D L D

( "restore E_" ): GR_ 2 ER_: F2

( "restore G_" ): ER_ ES EG: L' D

optimal generator of the result after this step:

U L' U' F L U2 L' U' F' L U L U (13f*)

(APQm'b_Sv_#)

to solve PQ_ edge: PQ_ VR UR

( "setup R_" ): PQ_ VR: L'

( "setup U_" ): VR_ UR: D

solve UR_ with the alg for RU_: M2 F L2 F' M2 F L2 F'

( "restore P_" ): UR_ VR: D'

( "restore Q_" ): VR_ PQ: L

// now all of the cubies are in place, but two are flipped

optimal generator of the result after this step:

L' U' L' U L2 U2 L' R' F' L F R U2 (13f*)

(Am_Sv_#)

// here all the edges are in place, but two are flipped. To solve,

// I apply a solid-diagonal flip-flip algorithm that affects UB and FD:

( "setup F_" ): S_ F_: D

U' Fw U F U' F' / Fw' U2 F2 U F' U' F' U'

( "restore S_" ): F_ S_: D'

(#) // solved!

my turn, challenge scramble: D L2 B2 L2 U B2 U2 B' R' U2 F2 U2 B' L D' F2 L D L2