Edge solving for BLD with TuRBo method

The idea of this method is to solve 2 edges at once with a small amount of setup moves - and algorithm - then undo the setup moves.
TuRBo = The Ruling Blind method
It goes like: put the next 2 pieces on UL/LU/UR/RU, do an algorithm, undo setup moves. This results in 2 solved edges. Each time you solve 2 pieces the 3 cycle of edges you use starts at UF which is the BUFFER position.


It's the same principle as pochmann and R2 only you solve more pieces at once. At this method you also have to memorize in pairs and also break into new cycles etc. for more info about that check Joels' BLD site: Here

For an example solve check at the bottom of this page.
Also the M2 page here: M2
You can also use this principle to solve the corners: corners

There are 8 standard cases which you can work to, and because of this it doesn't matter which orientation the edges you will solve are in.
The possible cycles are:

UF->UL->UR also known as a normal 3 cycle
UF->UR->UL also known as a normal 3 cycle

UF->LU->RU an ELL algo
UF->RU->LU an ELL algo

UF->UL->RU
UF->UR->LU

UF->LU->UR
UF->RU->UL


The applets


M2U'MU2M'U'M2 - UF->UL->UR
M2UMU2M'UM2 - UF->UR->UL

MUM'U2MUM' - UF->LU->RU
MU'M'U2MU'M' - UF->RU->LU

U L'U'LUM'U'L'Ul U' - UF->UL->RU
U' RUR'U'M'URU'r' U - UF->UR->LU

U' rUR'U'MURU'R' U - UF->LU->UR
U l'U'LUMU'L'UL U' - UF->RU->UL

Example


Scramble: B F' D U2 F2 U' R' F U2 F2 L' U2 B' D' U2 F2 D' U2 L' B F' L2 D2 B2 L'
First make up the cycle and turn that into pairs, so first we have:
(UF->) BL->RD, ->RB->DF, ->FR->LF, ->UB->BD, ->DL->LU, and remember that UR has to be flipped

Execution:

BL->RD: straight forward setup with LR2, following the pieces you will see that target 1 is now at UL and target 2 at RU (not UR!), this leads to the algorithm that does: UF->UL->RU which is: U L'U'LUM'U'L'Ul U', note that the U moves can also be replaced by a cube rotation if you like.
In short: BL->RD: LR2 - U L'U'LUM'U'L'Ul U' - R2L'

RB->DF: setup is slightly longer and more complicated now, though of course still pretty easy: R'D'L2. Target one edges up at RU and target 2 goes to UL so the algorithm is this time: UF->RU->UL which is: U l'U'LUMU'L'UL U'.
In short: RB->DF: R'D'L2 - U l'U'LUMU'L'UL U' - L2DR

FR->LF: this is an interesting case, setup moves could be RL' but for advanced use of this method you COULD do: xy2 algo y2x', it's only a bit hard to find out which algorithm you could use. So I'll give 2 possible ways of solving this:
RL', target 1 goes to UR, target 2 goes to LU, which gives: UF->UR->LU: U' RUR'U'M'URU'r' U
In short: FR->LF: RL' - U' RUR'U'M'URU'r' U - LR'
The advance way: xy2 you'll see that we will temporarily have ot change the buffer position which is now at FU, still I want to shoot from UF so everything changes, after looking good you'll see that we have now: UF->LU->UR which is: U' rUR'U'MURU'R' U
In short: xy2 U' rUR'U'MURU'R' U y2x'

UB->BD: there are numerous setups here, a difficult way would be to do D'R2y and try to figure out the cycle then which is hard cause you have to follow the cycle from a different position now. Easier is to do BR'L. Target 1 goes to LU and target 2 to UR so we have: UF->LU->UR which is: U' rUR'U'MURU'R' U.
In short: UB->BD: BR'L - U' rUR'U'MURU'R' U - L'RB'

DL->LU: setup move for this is ridiculously easy: b', target one goes to LU and target 2 goes to UR so we have: UF->LU->UR again: U' rUR'U'MURU'R' U
In short: DL->LU: b' - U' rUR'U'MURU'R' U - b

Now we have to flip UR and UF which I use an ELL for:
R'U2R2UR'U'R'U2LFRF'L' and DONE!