f2 r d L R2 b' l u' L2 B2 F' f' d f' // UD centres (14/14)
L2 U u' R B' u2 d' F2 u L F d F2 u F2 u' // LR, FB centres (16/30)
r2 L f2 R' b2 u2 // green, blue (6/36)
L D R2 f2 // centres, 1 wing (4/40)
U' F' d2 B' D L U' B L' d2 // +5/6 (10/50)
D' B' u' U D' B R D2 U' B' R' u // +6/12 (12/62)
( B L' B r B2 U B2 U' r' ) // +4/16 (on inverse) (9/71)
B D' r' B R L B' r // +5/21 (8/79)
l D' R2 D l' // +3/24 (5/84)
garbage 333 solution to bootstrap the 3FMC part (41 moves):
U D' F R U2 L D' F' D2 F U' F U L F2 L'
R' D' L D' L' D2 R L' F D' F' D R2 U F U' F' R2 D' F D
L F' L2 D2
better bootstrap scramble with a better solve:
NORMAL: F2 L' D2 L2 U' L D L' U D2 F2 U' B R2 B' U F D2 F L2 B F' D' F B' L F' L2 F' L U2 R' F' U' D
INV: U D' F R U2 L' F L2 F L' F' B D F B' L2 F' D2 F' U' B R2 B' U F2 U' D2 L D' L' U L2 D2 L F2
(R F R2 F L' U' D') // 223-c (7/7)
(L F' D' L' D) // pF2L-c (5/12)
L F D' L D L' // F2L-1, ab5c3e (6/18)
R F2 U F2 U' R' // ab3c (6/24; 108 total)
skeleton:
f2 r d L R2 b' l u' L2 B2 F' f' d f'
L2 U u' R B' u2 d' F2 u L F d F2 u F2 u'
r2 L f2 R' b2 u2
L D R2 f2
U' F' d2 B' D L @ U' B L' d2
D' B' u' U D' B R D2 U' B' R' u
B D' r' B R L B' r
l D' R2 D l'
L F D' L D L' R F2 U F2 U' R' D' L D F L' U D L F' R2 F' R'
r U B2 U' B2 r' B' L B'
@ = L U' R U L' U' R' U // corner comm (8-3/113)
(Old PB was 126 moves, which was also a UWR then. Current UWR is
102 moves by trangium, at least for the no-time-limit category.)
The mod-opposites centre solving at the start is super mind-bending. Over the course of hours of experimentation I managed to shave a couple of moves off of the mod-opposite L4C as well as fully solving the centres. Edge pairing is still using the classic cycles method (rather than simultaneously solving the centres and edges like trangium did), and I don't think I wall-of-text'd about the method here before, so here are some notes about that!
0. Wing parity is solved right at the start, while sorting the centres out.
1. A rough benchmark for the number of moves needed to do a 3-cycle of the wings is 5 moves: slice (1), trigger (3), slice back (1). One key exception to this is when flipped wings are involved (wings that are on the wrong side of the matching midge): flipping an edge in its slot always takes at least 5 moves, so the move count requirement is at least 7 moves when a flipped wing is involved.
2. The optimal flipping alg R F' U' R' F is longer than a basic trigger, but it's also quite versatile. You can throw in a D move to simultaneously insert an edge into an adjacent slot, and you can mirror it four ways in total. It's still bad, though.
3. Six-at-a-time chain pairing is probably not worth it unless you get something that's literally already set up for it. Six-at-a-time chain pairing is equivalent to doing a 7-cycle; per point 1 above, this means that it should take at most 15 moves to be worth it. If you're doing it as if it's a Yau solve and using 3-move triggers to insert all of the edges, this costs around (1+3+3) (first three edges) + 1 (slice) + (3+3+3) (next three edges) + 1 (slice back) = 18 moves, and this isn't even accounting for that fact that sometimes you need 4-move triggers, or the matching edge piece is elsewhere on the slice. Two-at-a-time chain pairing (i.e. spamming 3-cycles) just works, and four-at-a-time chain pairing is sometimes useful.
4. Related to the above: freeslice sucks for bigFMC, although it's not for quite the same reason. Freeslice prioritises fully paired tredges, even though that's less important (and sometimes counterproductive) for efficiency compared to the number of paired wings, or rather, the number of 3-cycles needed. Most of my earlier bigFMC attempts used freeslice, and I bet they're all easily improvable.
5. Since I mentioned it above: Odd-length cycles are ideal; even-length cycles should be avoided; 2-cycles are (usually) the worst to deal with. There are very few useful 2-cycle edge pairing algs; the main ones are r2 F2 U2 r2 U2 F2 r2 and u L2 F2 B2 R2 d. These look like short algs, but the first one is useful only in a very specific scenario and the second one requires setting up four edge pieces first. What about doing a u2 to kill off two 2-cycles at once? Now you're left with two more swaps you have to do in order to restore the centres, and if you don't have any more even-length cycles left to sacrifice, you have to set up four edge pieces from different parts of an odd-length cycle.
6. Algs like u R' F2 R F2 u' (and related) are useful for getting out of sticky situations. The R2 F R2 F' flips an edge while transferring it to an adjacent slot and also inserting another one, making it a handy alternative to chain pairing when a single edge has to be used multiple times in the cycle.
7. You can use NISS during edge pairing as long as the centres are all solved (or a bit more generally, if all the t-centres of each face have the same colour, and likewise for the x-centres). The puzzle states attain a group structure when none of the pieces you need to care about have duplicates, and having a group structure means you can switch to inverse or switch back to normal.
You cannot do this before the centres are solved enough. In practice, NISS edge pairing has rather limited use, because the cycles don't change when you switch; they just get relocated.
8. (not part of the edge pairing method per se) Under no-time-limit conditions, you can brute force over "trivial" variations of the centre solutions to see if they lead to better edge cycles. For example, if the center solution starts with U F R Bw Lw, you can try all six permutations of the first three moves; all of them will still lead to the centres being solved, but with a few edge pieces in different places. I spent probably like a whole hour on this.
