In this section of the guide I will assume you use Speffz. During memorization, you will first memorize the corners, then the edges. During the solving phase, you will solve the edges first, then parity, and finally the corners. It is important to memorize these pieces with letter pairs, as they become useful during solving.

For corners, I will be using Old Pochmann, which uses a swap with parity. The buffer sticker position is A, and the target is P. The swapping algorithm is Σ = (R U' R' U') (R U R' F') (R U R' U') (R' F R), which swaps stickers A and P. The parity component P swaps the up-back and up-left edges, so the C_{p} algorithms may only use R, F, and D turns. A full table of algorithms is presented below. Note that A is the buffer, and E and R are on the buffer piece, so you will never need to target them.

p | Swap | p | Swap | p | Swap | p | Swap | p | Swap | p | Swap |
---|---|---|---|---|---|---|---|---|---|---|---|

A | - |
E | - |
I | F' D Σ D F' |
M | R' Σ R |
Q | R' F Σ F' R |
U | F' Σ F |

B | R D' Σ D R' |
F | F2 Σ F2 |
J | R2 D' Σ D R2 |
N | R2 Σ R2 |
R | - |
V | D' F' Σ F D |

C | F Σ F' |
G | D2 R Σ R' D2 |
K | R F Σ F' R' |
O | R Σ R' |
S | D' R Σ R' D |
W | D2 F' Σ F D2 |

D | F R' Σ R F' |
H | D2 Σ D2 |
L | D Σ D' |
P | Σ |
T | D' Σ D |
X | D F' Σ F D' |

For edges, I will be using M2, which uses an impure swap with parity. The buffer sticker position is U, and the target is A. The swapping algorithm is simply Σ = M2. This algorithm affects the centers, but it also affects the up-front and down-back edges, which contain the sticker positions C, I, S, and W. Therefore, swapping to these positions requires care. For other positions, the swaps are simple, and a table is presented below. Note that U is the buffer and K is on the buffer piece, so you will never need to target them. The table is presented out of order to highlight similarities between the different cases.

p | Swap | p | Swap | p | Swap | p | Swap | p | Swap |
---|---|---|---|---|---|---|---|---|---|

B | R' U R U' M2 U R' U' R |
D | L U' L' U M2 U' L U L' |
M | B' R B M2 B' R' B |
E | B L' B' M2 B L B' |
A | M2 |

L | U R U' M2 U R' U' |
J | U' L' U M2 U' L U |
N |
R' B' R B M2 B' R' B R Uw R Uw' M2 Uw R' Uw'* |
H |
L B L' B' M2 B L B' L' Uw' L' Uw M2 Uw' L Uw* |
Q | U R U' B' R2 B M2 B' R2 B U R' U' |

V | U R2 U' M2 U R2 U' |
X | U' L2 U M2 U' L2 U |
O | B' R' B M2 B' R B |
G | B L B' M2 B L' B' |
||

T | U R' U' M2 U R U' |
R | U' L U M2 U' L' U |
P | B' R2 B M2 B' R2 B |
F | B L2 B' M2 B L2 B' |

*These algorithms only work on a 3×3×3. If you want to use them on larger cubes, you should use the other provided algorithm.

For ease of execution, algorithms with a B in them should be performed with a rotation, so as to bring the moves into a more favorable position near the front of the cube.

The sticker positions C, I, S, and W are more difficult, and there are several approaches to them.

If you are more comfortable with learning and applying algorithms, you should use this method. Here, each of the special targets has an algorithm that does not follow the above format, which you use instead of the swaps above. There is an important caveat, which is that if the letter in question is the second in a pair, you must use the algorithm that corresponds to the sticker position an M2 away from it. This is explained in the following table.

p | Swap (first in pair) | Swap (second in pair) |
---|---|---|

C | U2 M' U2 M' |
M U2 M U2 |

I | D M' U R2 U' M U R2 U' D' M2 |
M2 D U R2 U' M' U R2 U' M D' |

S | M2 D U R2 U' M' U R2 U' M D' |
D M' U R2 U' M U R2 U' D' M2 |

W | M U2 M U2 |
U2 M' U2 M' |

If you are more comfortable with constructing algorithms intuitively, you should use this method. This method treats the targets in pairs, and as such it is closer to 3-style. It has more cases than algorithmic M2, but the cases are intuitive. The cases presented below are only examples; there are many other ways to solve these exceptional pairs you may find more convenient.

Here, we assume the other target p in the pair is not on the M-slice, i.e. not A, C, I, Q, S, or W. The principle behind these cases is that you can take the piece in I or S directly to the other target, or vice versa. The cases are in the table below.

Pair | Algorithm | Pair | Algorithm |
---|---|---|---|

(p I) | M' C |
(p S) | M C |

(I p) | M2 C |
(S p) | M2 C |

Here, we also assume the other target p in the pair is not on the M-slice, i.e. not A, C, I, Q, S, or W. In this case, you can perform either a setup move of U2 or B2 to take the C or W position to the A position. Now, you can execute the pair as before, replacing C or W with A. Be careful: the setup move could have moved p to another target position. In that case, the pair executed should also have p replaced with its new position. Finally, undo the setup move.

These six pairs with two targets on the middle layer can be solved in only four moves. They are very intuitive and worth using.

Pair | Algorithm | Pair | Algorithm | Pair | Algorithm |
---|---|---|---|---|---|

(A C) | M' U2 M U2 |
(W A) | M' D2 M D2 |
(C W) | M D2 M' D2 |

(C A) | U2 M' U2 M |
(A W) | D2 M' D2 M |
(W C) | D2 M D2 M' |

Here, you can apply a similar technique to the previous case. Instead of using a setup move to place a target on the A position, though, you can use one, like a U or B', that moves one or both targets off the middle layer. You can track both targets in the process, apply the appropriate case, and then undo the setup move at the end.

Because of the group theory behind the 3×3×3, if there are an odd number of corner targets, there are an odd number of edge targets as well. As discussed in the swaps with parity section, the parity must be solved at some stage, and here we solve both at once. There are several popular ways to do this.

The simplest method of solving the parity is as follows: if there are an odd number of targets in your edge memorization, append the sequence of targets A D A. (If you use intuitive M2, it may be convenient at certain times to append D A D instead. These are equivalent.) This has the effect of swapping the up-back and up-left edges to compensate for the parity component of the corner swap algorithm.

Another convenient method is to use the parity algorithm D' L2 D M2 D' L2 D after edge execution is finished. This always works if you use algorithmic M2, but if you use intuitive M2, you may have to fall back on the previous method.

The final way to solve parity requires preparation. Because the corner parity and edge parity are linked, if you have an odd number of targets in your corner memorization, you will also have parity in the edges. To compensate, you have to memorize the edges pretending that the up-back and up-left edges are swapped. This will cause your edge memorization to have an even length, and solve directly into the parity component of the corner swap.