#### ottozing

##### Platinum Member

- Joined
- Aug 13, 2011

- Messages
- 3,275

- Location
- Canberra, Australia

- WCA
- 2012MCNE01

- YouTube
- Visit Channel

The way the method works is very easy to relate to M2 edges, so I'll be using that as my initial example. With M2, you have 2 important pieces. Your buffer (DF) and your helper piece (UB). Now, take any solution you can think of to solve a single target such as FR, which is U R U' M2 U R' U', or even a harder case such as FU, which is F E R U R' E' R U' R' F' M2. For every single target solution, if you attach an M2 to the end of it, you get the cycle buffer>target>helper piece, and if you attach an M2 to the start of any target not in the M layer (Because they work differently), you get buffer>helper>target.

The main point I'm trying to get across is that with M2, you're basically cycling buffer>target>helper and buffer>helper>target over and over again which solves every piece. In old pochmann terms, that's the equivalent of solving the cycle UBL>UFR>ULF by doing Y perm, 2 L perms, and a U2 J perm U2 (Where L perm = R' U L' U2 R U' R' U2 R L U' and UBR is the "helper" piece).

Now here's where the Orozco method comes in. The basic idea is that using UFR/UF buffers, and UBR/BU helper pieces, you learn 21 commutators forwards and backwards for corners and 22 commutators forwards and backwards for edges. For every odd target you get in a solve, you UFR/UF>target>UBR/BU, and for every even target you cycle UFR/UF>UBR/BU>helper. The only thing left to mention is how you solve when your next target is the helper piece and it's not in its helper orientation. In the M2 method, when you have to shoot to BU you essentially do an algorithm that flipped the buffer and the helper and then do an M2 (Something like [U M']3 U M [U M']4). With the Orozco method it's the same without adding a move at the end.

D2 R2 B2 D F2 D F2 L2 U L' B' R2 U' R2 D' R B F' R'

R' U2 R' D' R U2 R' D R2 (UFR>BUL>URB)

R2 D' R2 D R2 U R2 D' R2 D R2 U' (UFR>URB>DFR)

R2 D R' U2 R D' R' U2 R' (UFR>FLU>URB)

U' R D2 R' U R D2 R' (UFR>URB>FLD)

R U2 R' U' R U' R' L' U2 L U L' U L (UFR>RBU>UBR)

R' D R U R' D' R U' (UFR>UBR>RDF)

R D R' U' R D' R' U (UFR>RDB>UBR)

U' R D' R' U R D R' (UFR>UBR>LBD)

Leaving last target until end

M U L U' M' U L' U' (UF>BL>BU)

U' R' U M U' R U M' (UF>BU>BR)

R U R' U' M' U R U' r' (UF>RU>BU)

U L' U' M U L U' M' (UF>BU>FL)

U R U' M' U R' U' M (UF>RF>BU)

M' U R' U' M U R U' (UF>BU>RB)

M U' R2 U M' U' R2 U (UF>DR>BU)

M' U' L2 U M U' L2 U (UF>BU>LD)

U R2 U' M' U R2 U' M (UF>RD>BU)

F E R U R' E' R U' R' F' (UF>BU>FD)

l U L' U' M' U L U' L' (UF>UL>BU)

Skip! (UF>BU>BU)

B2 r U R' U R U R' F' R U R' U' R' F R2 U' R' U2 R U' R' U2 M B2 (Bad parity)

R' U2 R' D' R U2 R' D R2 (UFR>BUL>URB)

R2 D' R2 D R2 U R2 D' R2 D R2 U' (UFR>URB>DFR)

R2 D R' U2 R D' R' U2 R' (UFR>FLU>URB)

U' R D2 R' U R D2 R' (UFR>URB>FLD)

R U2 R' U' R U' R' L' U2 L U L' U L (UFR>RBU>UBR)

R' D R U R' D' R U' (UFR>UBR>RDF)

R D R' U' R D' R' U (UFR>RDB>UBR)

U' R D' R' U R D R' (UFR>UBR>LBD)

Leaving last target until end

M U L U' M' U L' U' (UF>BL>BU)

U' R' U M U' R U M' (UF>BU>BR)

R U R' U' M' U R U' r' (UF>RU>BU)

U L' U' M U L U' M' (UF>BU>FL)

U R U' M' U R' U' M (UF>RF>BU)

M' U R' U' M U R U' (UF>BU>RB)

M U' R2 U M' U' R2 U (UF>DR>BU)

M' U' L2 U M U' L2 U (UF>BU>LD)

U R2 U' M' U R2 U' M (UF>RD>BU)

F E R U R' E' R U' R' F' (UF>BU>FD)

l U L' U' M' U L U' L' (UF>UL>BU)

Skip! (UF>BU>BU)

B2 r U R' U R U R' F' R U R' U' R' F R2 U' R' U2 R U' R' U2 M B2 (Bad parity)

That's pretty much all there is to it. With these ideas you could make similar methods depending on what buffer you want to learn. For example, if you're already comfortable with comms using UBL corner buffer, maybe you'd rather have a UB edge buffer to make parity solving a bit easier (adjacent buffers ftw). As of right now though, I'm pretty sure UF and UFR and the best buffers