## The First 2 Layers

These are the 41 distinct cases (plus one solved) for the placement of a corner and its matching edge from the F2L and the algorithms I use for them. It is highly recommended that you learn how to do F2L intuitively so that you can take advantage of empty slots, nonstandard F2L pairings, etc. However, I have provided these "algorithms" anyway. For most of these cases, I have broken the algorithms down into two stages: In the first stage, you will be pairing up the corner and the edge and AUF so that they can be placed. This stage will be shown in red. In the second stage, the pair will be inserted into the slot in which it belongs. This stage will be shown in green. Some cases do not have pairing-up or insertion stages and will be shown in the normal black font.

These algorithms appear EXACTLY as I perform them when I am solving the first two layers, in speedcubing notation with rotations included in the algorithm. It should be noted that these are the algorithms that I find easiest to perform. However, you may find other algorithms better-suited for your own hands, so it is recommended to try many different algorithms for the same situation to find which one works best for your own style of cubing.

I have included several algorithms for each case. The FR, FL, BR, and BL before an algorithm indicate which F2L slot the pair will be inserted into. For each of those cases, you would have to rotate the given image so that the missing F2L pair is in the slot I indicated.

For a printable page of these algorithms, visit my printable page. Please note that you will need Adobe Reader to access and print the printable page.

### Corner Correct, Edge Not Placed

In these cases, the corner is already solved and only the edge needs to be placed. In Cases #02 and #03, it is sometimes helpful to use a "working corner" to place the edge piece. This means you could rotate the D-layer so that an empty corner is under the edge you need to solve, place the edge with a quick trigger, and finally restore your D-layer. It is also possible to do this for Case #01 by taking the edge out (with an empty corner), AUF, and then correctly placing the edge piece.

# | Diagram | Algorithm | Comments |

01 | FR: (R
U' R') Dw (R' U2) (R U'2) (R'
U R) FL: (L' U L Dw') (L U'2) (L' Dw2) (R U' R') BR: (R' U R Dw') (R U2) (R' U2) (R U' R') BL: (L U'L' Dw) (L' U'2) (L U2) (L' U L) |
Separate the corner from the edge by placing them in the U-layer. Next, AUF and bring the corner to the bottom using the empty slot so you can move the edge freely to match-up with the corner. AUF again and place the block in the slot it belongs. | |

02 | FR: [U]
(R U' R') Dw' (L' U L) FL: [Dw] (R U' R') Dw' (L' U L) BR: [Dw] (L U' L') Dw' (R' U R) BL: [U] (L U' L') Dw' (R' U R) |
AUF so that the edge would "match the center" if you moved it one turn towards the empty slot. Next, remove the corner from the slot to match the edge, AUF again, and place them both together. | |

03 | FR: [Dw']
(L' U L Dw) (R U' R') FL: [U'] (L' U L Dw) (R U' R') BR: [U'] (R' U R Dw) (L U' L') BL: [Dw'] (R' U R Dw) (L U' L') |
This is just the mirror of Case #02. |

### Edge Correct, Corner Slot Free

In this group, the edge is already solved, but the corner is in the U-layer. In Cases #05 and #06, it is sometimes useful to use a "working edge" to place the corner. This is very similar to a working corner method, but you place the corner using a free edge slot instead.

# | Diagram | Algorithm | Comments |

04 | FR: (R
U R' U') (R U R' U') (R
U R') FL: (L' U' L U) (L' U' L U) (L' U' L) BR: [U'] (R' U) (R U') (R' U) (R U') (R' U R) BL: [U] (L U') (L' U) (L U') (L' U) (L U' L') |
This is easy to remember because it is the repetition of a very fast trigger three times. | |

05 | FR: [Dw]
(R' U) (R U2) (R' U R) FL: [U] (L' U) (L U'2) (L' U L) BR: [U] (R' U) (R U2) (R' U R) BL: [Dw] (L' U) (L U'2) (L' U L) |
To place the corner, you match the corner with the edge to form a block and place them both together. | |

06 | FR: [U']
(R U') (R' U2) (R U' R') FL: [Dw'] (L U') (L' U'2) (L U' L') BR: [Dw'] (R U') (R' U2) (R U' R') BL: [U'] (L U') (L' U'2) (L U' L') |
This is just the mirror of Case #05. |

### Corner In First Layer Twisted Clockwise

In this group, the corner is in the first layer and its sticker with the cross-color is on the F-face.

# | Diagram | Algorithm | Comments |

07 | FR: (R'2
U2) (R' U' R U') (R'
U2 R') FL: (L' U2) (L' U' L U') (L' U2 L2) BR: (R' U2) (R' U' R U') (R' U2 R'2) BL: (L2 U2) (L' U' L U') (L' U2 L') |
In this case, the edge is solved, but the corner is not. A common way of solving this involves removing the entire first layer, breaking away the corner to match it with its edge, and then restoring everything. | |

08 | FR: (R
U' R U) y (R U') (R' F2) FL: (L' U L) (F R U'2) (R' F') BR: (R' U R) B (L U'2 L' B') BL: (L U' L U) y' (R U') (R' F2) |
This is one of the least intuitive cases for the F2L. It involves breaking up the two pieces and restoring them while the cross is still not yet restored. | |

09 | FR: [U2]
(R U' R') y (L' U' L) FL: (L' U' L U) (L' U' L) BR: (R' U' R U) (R' U' R) BL: [U2] (L U' L') y (R' U' R) |
In this case, the goal is to get the corner to be "opposite" from its matching edge and then placing them both together. | |

10 | FR: (R
U') (R' U) (R U' R') FL: (L' U'2 L) y'(R U2 R') BR: (R' U2 R) y (R U2 R') BL: (L U') (L' U) (L U' L') |
In this case, the goal is to form a corner-edge block and then place it in its slot. |

### Corner In First Layer Twisted Counter-Clockwise

These cases are just the mirrors of the group above.

# | Diagram | Algorithm | Comments |

11 | FR: (R
U'2) (R U R' U) (R U'2 R'2) FL: (L2 U'2) (L U L' U) (L U'2 L) BR: (R'2 U2) (R U R' U) (R U2 R) BL: (L U'2) (L U L' U) (L U2 L'2) |
This is just the mirror of Case #07. | |

12 | FR: (R
U' R') (F' L' U2) (L F) FL: (L' U L' U') y' (L' U) (L F'2) BR: (R' U R' U') y (L' U) (L F'2) BL: (L U' L') B' (R' U2 R B) |
This is just the mirror of Case #08. | |

13 | FR: (R
U2 R') y' (R' U2 R) FL: (L' U) (L U') (L' U L) BR: (R' U) (R U') (R' U R) BL: (L U'2 L') y (R' U2 R) |
This is just the mirror of Case #10. | |

14 | FR: (R
U R' U') (R U R') FL: [U2] (L' U L) y (R U R') BR: [U2] (R' U R) y (R U R') BL: (L U L' U') (L U L') |
This is just the mirror of Case #09. |

### Corner In U-Layer With Cross-Color on U-Face

In these cases, the corner's sticker with the cross color will be on the U-face, making the corner completely "upside-down" of where it needs to be.

# | Diagram | Algorithm | Comments |

15 | FR: (R
U' R' Dw) (R' U R) FL: (L' U L Dw') (L U' L') BR: (R' U R Dw') (R U' R') BL: (L U' L' Dw) (L' U L) |
This pair is already connected, so just take it out of the slot (without losing the edge!) and put it back in. | |

16 | FL: (L'
U'2 L U) (L' U' L) BR: (R' U2 R U) (R' U' R) |
Break up the two pieces so that they become opposite from each other and then just place them. | |

17 | FR: [U2]
(R2 U'2) (R' U' R U' R'2) BL: [U2] (L2 U'2) (L' U' L U' L'2) |
This is different than most cases because you match the edge with the other edges, then match the corner with the other corners, and finally restore everything together. | |

18 | FR: [Dw']
(L' U2 L U') (L' U L) FL: [U'] (L' U2 L U') (L' U L) BR: [U'] (R' U2 R U') (R' U R) BL: [Dw'] (R' U2 R U') (R' U R) |
First, AUF to "match" the edge piece with a center, then move the corner to match the edge using the free slot, and place the block in its slot. | |

19 | FR: [U2]
(R U R' U) (R U' R') FL: (F R U'2) (R' F') BR: B (L U'2 L' B') BL: [U2] (L U L' U) (L U' L') |
This case is very similar to Case #18. | |

20 | FR: (R
U2 R' U') (R U R') BL: (L U'2 L' U') (L U L') |
This is just the mirror of Case #16. | |

21 | FL: [U2]
(L'2 U2) (L U L' U L2) BR: [U2] (R'2 U2) (R U R' U R2) |
This is just the mirror of Case #17. | |

22 | FR: [U]
(R U'2 R' U) (R U' R') FL: [Dw] (R U'2 R' U) (R U' R') BR: [Dw] (L U2 L' U) (L U' L') BL: [U] (L U2 L' U) (L U' L') |
This is just the mirror of Case #18. | |

23 | FR: (F'
L' U2) (L F) FL: [U2] (L' U' L U') (L' U L) BR: [U2] (R' U' R U') (R' U R) BL: B' (R' U2 R B) |
This is just the mirror of Case #19. |

### Corner In U-Layer With Cross-Color on R-Face

In these cases, the corner's sticker with the cross color will be on the R-face.

# | Diagram | Algorithm | Comments |

24 | FR: [Dw]
(R' U' R Dw') (R U R') FL: [U] (L' U' L Dw') (L U L') BR: [U] (R' U' R Dw') (R U R') BL: [Dw] (L' U' L Dw') (L U L') |
In this case, you remove the edge from the second layer such that it is opposite the corner, AUF, and place the pair. | |

25 | FR: [Dw']
(L' U L) FL: [U'] (L' U L) BR: [U'] (R' U R) BL: [Dw'] (R' U R) |
This case is easy to recognize because the corner-edge pair is already connected and only need to be inserted. It is common for many of the F2L algorithms to end with this trigger. | |

26 | FR: [Dw]
(R' U2 R Dw') (R U R') FL: [U] (L' U'2 L Dw') (L U L') BR: [U] (R' U2 R Dw') (R U R') BL: [Dw] (L' U'2 L Dw') (L U L') |
Use the empty slot to break up the pair such that the corner and edge are opposite each other and then place the pair. | |

27 | FR: [Dw]
(R' U' R U'2) (R' U R) FL: [U] (L' U' L U'2) (L' U L) BR: [U] (R' U' R U'2) (R' U R) BL: [Dw] (L' U' L U'2) (L' U L) |
Use the empty slot to form a 2x1x1 block and place the block into the slot in which it belongs. | |

28 | FR: [Dw]
(R' U R Dw') (R U R') FL: [U] (L' U L Dw') (L U L') BR: [U] (R' U R Dw') (R U R') BL: [Dw] (L' U L Dw') (L U L') |
This case is very similar to Case #26. | |

29 | FR: [U']
(R U' R' U) (R U R') FL: [Dw'] (L U' L' U) (L U L') BR: [d'] (R U' R' U) (R U R') BL: [Dw'] (L U' L' U) (L U L') |
This case is very similar to Case #26. | |

30 | FR: (R
U') (R' U2) y' (R' U'
R) FL: (Rw' U' R' F) (R U Rw) BR: (R' F') (L' U L) (F R) BL: (L U') (L' U'2) y (R' U' R) |
One way of doing this is to break up these two pieces and twist the corner so that the two pieces are opposite each other and then placing them. The other way of fixing htis case is to just use the clever algorithm that doesn't necessarily have pair-up and insertion phases. | |

31 | FR: (R
U R') BL: (L U L') |
Here, the corner and edge are "opposite" each other and can be placed with a simple trigger. The goal of many F2L algorithms is to get the corner and edge into this case and then solve them with this trigger. | |

32 | FR: [Dw]
(R' U2 R U'2) (R' U R) FL: [U] (L' U'2 L U2) (L' U L) BR: [U] (R' U2 R U'2) (R' U R) FL: [Dw] (L' U'2 L U2) (L' U L) |
This case is very similar to Case #27. |

### Corner In U-Layer With Cross-Color on F-Face

These cases are just the mirrors of the group above.

# | Diagram | Algorithm | Comments |

33 | FR: [U']
(R U R' Dw) (R' U' R) FL: [Dw'] (L U L' Dw) (L' U' L) BR: [Dw'] (R U R' Dw) (R' U' R) BL: [U'] (L U L' Dw) (L' U' L) |
This is just the mirror of Case #24. | |

34 | FR: [Dw]
(R' U R U') (R' U' R) FL: [U] (L' U L U') (L' U' L) BR: [U] (R' U R U') (R' U' R) BL: [Dw] (L' U L U') (L' U' L) |
This is just the mirror of Case #29. | |

35 | FR: (Lw
U L F') (L' U' Lw') FL: (L' U) (L U'2) y' (R U R') BR: (R' U) (R U2) y (R U R') BL: (L F) (R U' R') (F' L') |
This is just the mirror of Case #30, with a right-handed optimization at the FL slot. | |

36 | FL: (L'
U' L) BR: (R' U' R) |
This is just the mirror of Case #31. | |

37 | FR: [U']
(R U'2 R' U2) (R U' R') FL: [Dw'] (L U2 L' U2) (L U' L') BL: [U'] (L U2 L' U2) (L U' L') BR: [Dw'] (R U'2 R' U2) (R U' R') |
This is just the mirror of Case #32. | |

38 | FR: [U]
(R U' R') FL: [Dw] (R U' R') BR: [Dw] (L U' L') BL: [U] (L U' L') |
This is just the mirror of Case #25. | |

39 | FR: [U']
(R U'2 R' Dw) (R' U' R) FL: [Dw'] (L U'2 L' Dw) (L' U' L) BR: [Dw'] (R U'2 R' Dw) (R' U' R) BL: [U'] (L U'2 L' Dw) (L' U' L) |
This is just the mirror of Case #26. | |

40 | FR: [U']
(R U R' U2) (R U' R') FL: [Dw'] (L U L' U'2) (L U' L') BR: [Dw'] (R U R' U2) (R U' R') BL: [U'] (L U L' U'2) (L U' L') |
This is just the mirror of Case #27. | |

41 | FR: [U']
(R U' R' Dw) (R' U' R) FL: [Dw'] (L U' L' Dw) (L' U' L) BR: [Dw'] (R U' R' Dw) (R' U' R) BL: [U'] (L U' L' Dw) (L' U' L) |
This is just the mirror of Case #28. |