#### shadowslice e

##### Member

So some of you have probably heard something about this method before. I've been working on it for a while and I've spoken to a few people about it. Let's go through what this method is:

Spoiler: Why 42?

Spoiler: What are the steps?
Spoiler: Pros
Spoiler: Cons
Spoiler: Additional observations/extensions/improvements
Spoiler: Video
Spoiler: Video tutorials/descriptions
Spoiler: BT-redux/conjugated CMLL recognition
Spoiler: OH L7E

Spoiler: Additional links

The simplest version of this method takes 42 moves on average using 42 algorithms (also something to do with Deep Thought )- this is discounting any beginner variations

- First Block
- Exactly the same as Roux, no fancy CP, EP, CO, EO, BLD tracing etc, just a standard 1x2x3 in DL

- Second Block Square+ 1 oriented LL corner
- The second block square is again exactly the same as the in Roux. For beginners you will need to build a block in BDR and orient
**any**LL corner and place it in UBR then do an R. - For more advanced solvers, the block could be built directly with the R move off.
- The corner orientation will frequently be skipped (just under 1/3 of the time)

- The second block square is again exactly the same as the in Roux. For beginners you will need to build a block in BDR and orient
- Conjugated CMLL/BT-redux
- This sounds scary but it really isn't. all you do is recognise what case you have and execute an algorithm exactly as you would with COLL, CMLL, TTLL etc. You don't even need any weird tricks for cycle recognition or anything. You don't have to know a thing about Commutators or Conjugates. You just recognise by looking at the sticker in RDB and then what CLLesque pattern of orientation and what opp/same colours there are.
- If you know all the algorithms for any CxLL, you already know all the necessary algorithms for this step so it is simply a matter of learning new cases to associate with that algorithm.

- Conjugated CMLL/BT-redux cases (Word version)
- Conjugated CMLL/BT-redux cases (PDF version)
- *BT-redux is a slightly more general and advanced

- Last 7 Edges (L7E)
- This step is very similar to LSE in roux and there are many ways to do this. my personal favourites are:
- EO+FR: This is quite similar to EOLR with Roux where you combine 4a+4b so you solve EO for all edges while solving the FR edge. This essentially reduces the step down to oriented LSE which is fast and easy.
- 2opp EO: this could be considered slightly more advanced than the previous but only fractionally more. You solve any 2 edges which are opposite each other (so whatever slots are in ULUR or UFUB (or even DFDB but i'm not sure I can recommend this).

- Of course you can always do this algorithmically like in LMCF or WaterRoux but I don't find much improvement (at least movecountwise)
- I will be releasing an "alg" set for EO+FR or 2opp EO (or both) soon.

- This step is very similar to LSE in roux and there are many ways to do this. my personal favourites are:

- Ergonomic movesets
- Very low movecount (especially for the number of algs)
- Very low algorithm count (especially for the number of moves)
- Relatively simple recognition
- Easy obvious extension (especially compared to Roux)
- Can look proportionally further into the intuitive part of the solve than most methods
- Almost every benefit Roux has

- Multiple cases per algorithm can be difficult to get used to.
- Lower chance of lucky solves do to more of the cube being solved in final steps where lucky cases are more beneficial (if you can really call this a disadvantage as it leads to much more consistent solves)

- If you use TCMLL then you don't even have to orient the corner with SB
- Algorithms for each "set of cases" are not optimised for this method and just use CMLLs/COLLs from other methods so there is room for further optimisation
- Any potential Roux techniques can be applied to this method
- Nonlinear blocks may be more practical to implement than in Roux or FreeFOP etc because there is less to blockbuild at a time
- NMB is much easier than with Roux as the recognition presented above is not as affected- this mean that you can easily build any of the 4 possible SBsquare which will make it easier to plan further into the solve when a solver becomes reasonably proficient at FB
- It is possible that the solver could use F/B moves rather than L/R moves which could lead to better blocks or better L7E etc
- This could also be a reasonably effective method for 2x2

Last edited: Aug 18, 2017