From d39ec79a82e4c22fb78258e5613c743d6512ce00 Mon Sep 17 00:00:00 2001 From: Werner Stein Date: Sun, 1 Nov 2026 13:11:16 +0000 Subject: [PATCH 01/10] feat(orbit64): add the Orbit64 V2 facelet bridge Orbit64V2Facelets turns a V2 color-model cube into its U R F D L B facelet string and back, for 2x2x2-15x15x15, canonical and framed. The slot tables are derived like the reference (5x5x5 corners and midges, 4x4x4 wings, centers from geometry); a whole-cube rotation goes through the geometry of FORMAT.md. Every failure is an Error with its reason. The picture model has no letters and is an Error. Token helpers go from a facelet string to a token and back. Co-Authored-By: Claude Sonnet 5.5 --- src/cube/notation/Orbit64V2.res | 3 +- src/cube/notation/Orbit64V2.resi | 6 + src/cube/notation/Orbit64V2Facelets.res | 590 +++++++++++++++++++++++ src/cube/notation/Orbit64V2Facelets.resi | 48 ++ src/cube/notation/orbit64V2Facelets.ts | 16 + 5 files changed, 662 insertions(+), 1 deletion(-) create mode 100644 src/cube/notation/Orbit64V2Facelets.res create mode 100644 src/cube/notation/Orbit64V2Facelets.resi create mode 100644 src/cube/notation/orbit64V2Facelets.ts diff --git a/src/cube/notation/Orbit64V2.res b/src/cube/notation/Orbit64V2.res index f2bfc80..b240474 100644 --- a/src/cube/notation/Orbit64V2.res +++ b/src/cube/notation/Orbit64V2.res @@ -1,5 +1,6 @@ // Orbit64 V2 state tokens for n x n x n cubes, n = 2..15, in coordinates only: -// registry, state ranking and the token codec. There is no facelet bridge. +// registry, state ranking and the token codec. The facelet bridge is +// Orbit64V2Facelets.res. // Format: FORMAT-V2.md of flix-orbit64@8dc17fb (Apache-2.0); reference // implementation: src/Orbit64/V2/{Registry,State,Codec}.flix there. // diff --git a/src/cube/notation/Orbit64V2.resi b/src/cube/notation/Orbit64V2.resi index 6a7c78d..6bfef19 100644 --- a/src/cube/notation/Orbit64V2.resi +++ b/src/cube/notation/Orbit64V2.resi @@ -50,3 +50,9 @@ type decoded = {entry: entry, cube: cube} // The registry entry and state a token addresses, or why it addresses none. @genType let decodeOrbit64V2State: string => result + +// For the facelet bridge (Orbit64V2Facelets.res): a copy of a cube read once +// and by index, and why a cube is no state of the type, if it is none. The +// fault is the reason `encodeOrbit64V2State` gives; `faultOf` needs a snapshot. +let snapshot: cube => cube +let faultOf: (int, model, pose, cube) => option diff --git a/src/cube/notation/Orbit64V2Facelets.res b/src/cube/notation/Orbit64V2Facelets.res new file mode 100644 index 0000000..4c4cea2 --- /dev/null +++ b/src/cube/notation/Orbit64V2Facelets.res @@ -0,0 +1,590 @@ +// The facelet bridge of Orbit64 V2: a cube state to its stickers and back, for +// n x n x n cubes, n = 2..15, in the color model. +// Format: FORMAT-V2.md of flix-orbit64@d701008 (Apache-2.0); reference +// implementation: src/Orbit64/V2/Facelets.flix there. +// +// A facelet string writes the 6 n^2 stickers as the letters U R F D L B, one +// per facelet (index `face * n^2 + row * n + col`), six face fields in that +// order separated by one space. Reading ignores spaces. It does not reuse +// `NotationOutput`, which also trims and upper-cases, accepts any white space +// and answers with a warning instead of a reason. +// +// The slot tables follow the V1 slot convention and its extension to n >= 8 +// ("Conventions" in FORMAT-V2.md). Three reference tables carry it: the +// corners and midges of the 5x5x5 and the wings of the 4x4x4. Every other size +// takes its slots by replacing each axis of a reference facelet, 0 by 0, 1 by +// the wing depth d, 2 (5x5x5 only) by n / 2, and the last two by n - 1 - d and +// n - 1. Center orbits come from geometry: the four quarter turn images of a +// cell, on six faces, ordered by facelet index. A piece is numbered by its home +// slot and the solved cube shows face colors, so a piece's colors are the faces +// of its home slot's facelets and no color table is needed. +// +// A whole-cube rotation is applied through the geometry of FORMAT.md, not +// through V1's x, z, y composition: frame r is the rotation that moves +// physical face frameFaces[r][i] into slot i. + +type slots = { + corners: array>, + midges: array>, + wings: array>>, + centers: array>, + fixed: array, +} + +type decodedFacelets = {entry: Orbit64V2.entry, facelets: string} + +let range = count => Array.fromInitializer(~length=count, i => i) +let odd = n => mod(n, 2) == 1 +let get = (values, i) => values->Array.getUnsafe(i) +let wingOrbits = n => (n - 2) / 2 +let letters = ["U", "R", "F", "D", "L", "B"] + +// ------------------------------------------------------------------ slot tables + +// Corner slots of the 5x5x5: the facelet orientation counts from, then clockwise. +let cornerReference = [ + [24, 25, 54], + [20, 50, 104], + [0, 100, 129], + [4, 125, 29], + [79, 74, 45], + [75, 124, 70], + [95, 149, 120], + [99, 49, 145], +] + +// Midge slots of the 5x5x5. +let midgeReference = [ + [14, 27], + [22, 52], + [10, 102], + [2, 127], + [89, 47], + [77, 72], + [85, 122], + [97, 147], + [64, 35], + [60, 114], + [139, 110], + [135, 39], +] + +// Wing slots of the 4x4x4, the reference sticker first. +let wingReference = [ + [1, 82], + [7, 18], + [8, 66], + [14, 34], + [17, 11], + [23, 84], + [24, 43], + [30, 59], + [33, 13], + [39, 20], + [40, 75], + [46, 50], + [49, 45], + [55, 29], + [56, 77], + [62, 93], + [65, 4], + [71, 36], + [72, 91], + [78, 52], + [81, 2], + [87, 68], + [88, 27], + [94, 61], +] + +let expandAxis = (n, base, depth, value) => + (base == 4 ? [0, depth, n - 1 - depth, n - 1] : [0, depth, n / 2, n - 1 - depth, n - 1])->get( + value, + ) + +// Carries a reference facelet of a base x base cube to wing depth `depth` of an n x n x n. +let expandFacelet = (n, base, depth, index) => { + let face = index / (base * base) + let row = mod(index / base, base) + let col = mod(index, base) + face * n * n + expandAxis(n, base, depth, row) * n + expandAxis(n, base, depth, col) +} + +let expandTable = (n, base, depth, table) => + table->Array.map(slot => slot->Array.map(index => expandFacelet(n, base, depth, index))) + +let centerRepresentative = (n, row, col) => { + let last = n - 1 + let rank = row * n + col + rank <= col * n + last - row && + rank <= (last - row) * n + last - col && + rank <= (last - col) * n + row +} + +// The four quarter turn images of a cell, on all six faces, by facelet index. +let centerTable = (n, row, col) => { + let last = n - 1 + range(6 * n * n)->Array.filter(i => { + let cell = mod(i, n * n) + cell == row * n + col || + cell == col * n + last - row || + cell == (last - row) * n + last - col || + cell == (last - col) * n + row + }) +} + +// Center orbits ordered by their lowest facelet; the fixed center of an odd +// cube is no orbit. +let centerTables = n => + range(n - 2)->Array.flatMap(r0 => + range(n - 2)->Array.filterMap(c0 => { + let row = r0 + 1 + let col = c0 + 1 + centerRepresentative(n, row, col) && !(odd(n) && row == n / 2 && col == n / 2) + ? Some(centerTable(n, row, col)) + : None + }) + ) + +let fixedFacelets = n => odd(n) ? range(6)->Array.map(face => face * n * n + (n * n - 1) / 2) : [] + +let buildTables = n => { + corners: expandTable(n, 5, 1, cornerReference), + midges: odd(n) ? expandTable(n, 5, 1, midgeReference) : [], + wings: range(wingOrbits(n))->Array.map(i => expandTable(n, 4, i + 1, wingReference)), + centers: centerTables(n), + fixed: fixedFacelets(n), +} + +// The tables are internal: callers of `slotTables` get a fresh copy. +let tablesBySize = Map.make() + +let tables = n => + switch tablesBySize->Map.get(n) { + | Some(found) => found + | None => + let built = buildTables(n) + tablesBySize->Map.set(n, built) + built + } + +let isInt = x => { + let f = Int.toFloat(x) + Float.isFinite(f) && Math.floor(f) == f +} + +// A number or whatever a caller passed, as text for a message. +@val external show: 'a => string = "String" + +let validSize = n => isInt(n) && n >= 2 && n <= 15 + +@genType +let slotTables = n => validSize(n) ? Some(buildTables(n)) : None + +// The face color of a facelet: in the solved cube a sticker shows its face. +let faceOf = (n, facelet) => facelet / (n * n) + +// -------------------------------------------------------------------- geometry + +type vec = (int, int, int) + +// A rotation as the images of the unit vectors x, y and z. +type turn = (vec, vec, vec) + +// Position (doubled grid, -m..m with m = n - 1) and outward normal of a facelet. +let geometry = (n, index): (vec, vec) => { + let m = n - 1 + let face = index / (n * n) + let a = 2 * mod(index, n) - m + let b = 2 * mod(index / n, n) - m + switch face { + | 0 => ((a, m, b), (0, 1, 0)) + | 1 => ((m, -b, -a), (1, 0, 0)) + | 2 => ((a, -b, m), (0, 0, 1)) + | 3 => ((a, -m, -b), (0, -1, 0)) + | 4 => ((-m, -b, a), (-1, 0, 0)) + | _ => ((-a, -b, -m), (0, 0, -1)) + } +} + +let faceOfNormal = (normal: vec) => + switch normal { + | (0, 1, 0) => 0 + | (1, 0, 0) => 1 + | (0, 0, 1) => 2 + | (0, -1, 0) => 3 + | (-1, 0, 0) => 4 + | _ => 5 + } + +// The (a, b) grid coordinates of a position on a face, as in `geometry`. +let gridOf = (face, (x, y, z): vec) => + switch face { + | 0 => (x, z) + | 1 => (-z, -y) + | 2 => (x, -y) + | 3 => (x, -z) + | 4 => (z, -y) + | _ => (-x, -y) + } + +// The inverse of `geometry`. +let faceletAt = (n, position, normal) => { + let m = n - 1 + let face = faceOfNormal(normal) + let (a, b) = gridOf(face, position) + face * n * n + (b + m) / 2 * n + (a + m) / 2 +} + +let normalOf = (face): vec => + switch face { + | 0 => (0, 1, 0) + | 1 => (1, 0, 0) + | 2 => (0, 0, 1) + | 3 => (0, -1, 0) + | 4 => (-1, 0, 0) + | _ => (0, 0, -1) + } + +// The physical faces in slots U R F D L B of the 24 whole-cube frames, in the +// rank order of Orbit64 frames (FORMAT.md: x turns, then z turns, then y turns). +@scope("Object") @val external freeze: 'a => 'a = "freeze" + +// Frozen, so no caller can change a frame. +@genType +let frameFaces = freeze([ + "URFDLB", + "UBRDFL", + "ULBDRF", + "UFLDBR", + "FRDBLU", + "FURBDL", + "FLUBRD", + "FDLBUR", + "DRBULF", + "DFRUBL", + "DLFURB", + "DBLUFR", + "BRUFLD", + "BDRFUL", + "BLDFRU", + "BULFDR", + "LUFRDB", + "LBURFD", + "LDBRUF", + "LFDRBU", + "RDFLUB", + "RBDLFU", + "RUBLDF", + "RFULBD", +]) + +let faceIndex = letter => letters->Array.findIndex(l => l == letter) + +// The physical faces in slots U R F D L B of a frame, as indices. +let facesOfFrame = frame => frameFaces->get(frame)->String.split("")->Array.map(faceIndex) + +// The rotation of a frame: it moves physical face faces[i] onto slot i. +let turnOf = (frame): turn => { + let faces = facesOfFrame(frame) + let slotOf = f => normalOf(faces->Array.findIndex(x => x == f)) + (slotOf(1), slotOf(0), slotOf(2)) +} + +let dot = ((ax, ay, az): vec, (bx, by, bz): vec) => ax * bx + ay * by + az * bz + +// The image of v under the rotation: x, y and z times their images. +let forward = (((ax, ay, az), (bx, by, bz), (cx, cy, cz)): turn, (x, y, z): vec): vec => ( + x * ax + y * bx + z * cx, + x * ay + y * by + z * cy, + x * az + y * bz + z * cz, +) + +// The inverse of a rotation is its transpose. +let backward = ((ex, ey, ez): turn, v: vec): vec => (dot(v, ex), dot(v, ey), dot(v, ez)) + +// The stickers after the cube is rotated by `turn`: each sticker moves with its color. +let rotate = (n, turn, fs) => + fs->Array.mapWithIndex((_, i) => { + let (p, q) = geometry(n, i) + fs->get(faceletAt(n, backward(turn, p), backward(turn, q))) + }) + +// The stickers of the cube rotated back: the inverse of `rotate`. +let unrotate = (n, turn, fs) => + fs->Array.mapWithIndex((_, i) => { + let (p, q) = geometry(n, i) + fs->get(faceletAt(n, forward(turn, p), forward(turn, q))) + }) + +// ---------------------------------------------------------------- cube to stickers + +let writeOriented = (n, sticker, table, pieces, twists) => + table->Array.forEachWithIndex((slotFacelets, slot) => { + let m = Array.length(slotFacelets) + let home = table->get(pieces->get(slot)) + let twist = twists->get(slot) + for k in 0 to m - 1 { + sticker->Array.setUnsafe(slotFacelets->get(k), faceOf(n, home->get(mod(k - twist + m, m)))) + } + }) + +let writeCenters = (sticker, table: array, colors: array) => + table->Array.forEachWithIndex((facelet, slot) => + sticker->Array.setUnsafe(facelet, colors->get(slot)) + ) + +// The stickers of a canonical-pose cube; fixed centers are home. +let paint = (n, t, cube: Orbit64V2.cube) => { + let sticker = Array.make(~length=6 * n * n, 0) + t.fixed->Array.forEachWithIndex((facelet, face) => sticker->Array.setUnsafe(facelet, face)) + writeOriented(n, sticker, t.corners, cube.cornerPieces, cube.cornerTwists) + if odd(n) { + writeOriented(n, sticker, t.midges, cube.midgePieces, cube.midgeFlips) + } + t.wings->Array.forEachWithIndex((table, i) => + writeOriented(n, sticker, table, cube.wings->get(i), Array.make(~length=24, 0)) + ) + t.centers->Array.forEachWithIndex((table, i) => + writeCenters(sticker, table, cube.centers->get(i)) + ) + sticker +} + +// Why a type has no facelet letters, if it has none. +let typeFault = (n, model: Orbit64V2.model) => + if !validSize(n) { + Some(`no V2 type for the ${show(n)}x${show(n)}x${show(n)}`) + } else if model == Picture { + Some("the picture model has no letters") + } else if model != Color { + Some("unknown sticker model") + } else { + None + } + +let spell = (n, fs) => + range(6) + ->Array.map(face => + range(n * n)->Array.map(i => letters->get(fs->get(face * n * n + i)))->Array.join("") + ) + ->Array.join(" ") + +@genType +let toFacelets = (n, model, pose, cube) => + try { + switch typeFault(n, model) { + | Some(why) => Error(why) + | None => + let cube = Orbit64V2.snapshot(cube) + switch Orbit64V2.faultOf(n, model, pose, cube) { + | Some(why) => Error(why) + | None => + let fs = paint(n, tables(n), cube) + Ok(spell(n, odd(n) ? rotate(n, turnOf(cube.frame), fs) : fs)) + } + } + } catch { + | _ => Error("malformed state") + } + +// ---------------------------------------------------------------- stickers to cube + +@val external codePoints: string => array = "Array.from" + +// The face index of a facelet letter; a tab or newline is a bad letter like any other. +let letterIndex = letter => + switch faceIndex(letter) { + | -1 => Error(`facelet '${letter}' is not one of U R F D L B`) + | index => Ok(index) + } + +let rec traverse = (items, f, index, out) => + if index == Array.length(items) { + Ok(out) + } else { + switch f(items->get(index), index) { + | Error(why) => Error(why) + | Ok(value) => + out->Array.push(value) + traverse(items, f, index + 1, out) + } + } + +let traverseAll = (items, f) => traverse(items, f, 0, []) + +// The stickers of a facelet string as face indices, or why it is no string of n^2 per face. +let parse = (n, text) => + codePoints(text) + ->Array.filter(c => c != " ") + ->traverseAll((letter, _) => letterIndex(letter)) + ->Result.flatMap(indices => { + let length = Array.length(indices) + if length != 6 * n * n { + Error( + `expected ${Int.toString(6 * n * n)} facelets for the ${Int.toString(n)}x${Int.toString( + n, + )}x${Int.toString(n)}, got ${Int.toString(length)}`, + ) + } else { + Ok(indices) + } + }) + +let checkCounts = (n, fs) => + switch range(6)->Array.find(f => fs->Array.filter(x => x == f)->Array.length != n * n) { + | Some(f) => + Error( + `color ${letters->get(f)} occurs ${Int.toString( + fs->Array.filter(x => x == f)->Array.length, + )} times, expected ${Int.toString(n * n)}`, + ) + | None => Ok() + } + +// The stickers on the facelets of one slot. +let seenAt = (table, slot, fs) => table->get(slot)->Array.map(at => fs->get(at)) + +// The piece and twist whose colors, read from the slot's first facelet, are `seen`. +let readPiece = (n, table, seen) => { + let m = Array.length(seen) + table + ->Array.mapWithIndex((home, p) => + range(m) + ->Array.find(o => + range(m)->Array.every(k => seen->get(k) == faceOf(n, home->get(mod(k - o + m, m)))) + ) + ->Option.map(o => (p, o)) + ) + ->Array.find(found => found != None) + ->Option.flatMap(found => found) +} + +let noPiece = (what, slot, seen) => { + let shown = seen->Array.map(f => letters->get(f))->Array.join("") + `${what} slot ${Int.toString(slot)} shows ${shown}, which is no ${what} of this cube` +} + +let readOriented = (n, what, table, fs) => + range(Array.length(table)) + ->traverseAll((slot, _) => { + let seen = seenAt(table, slot, fs) + switch readPiece(n, table, seen) { + | Some(found) => Ok(found) + | None => Error(noPiece(what, slot, seen)) + } + }) + ->Result.map(found => (found->Array.map(((p, _)) => p), found->Array.map(((_, o)) => o))) + +// A wing carries no twist: its two stickers sit in the order of its home slot or not at all. +let readWingsStrict = (n, table, fs) => { + let solved = range(6 * n * n)->Array.map(i => faceOf(n, i)) + let homes = range(Array.length(table))->Array.map(p => seenAt(table, p, solved)) + range(Array.length(table))->traverseAll((slot, _) => { + let seen = seenAt(table, slot, fs) + switch homes->Array.findIndex(home => home == seen) { + | -1 => Error(noPiece("wing", slot, seen)) + | p => Ok(p) + } + }) +} + +// The coordinates of a canonical-pose string; the frame is `frame`. +let readCube = (n, t, frame, fs): result => + readOriented(n, "corner", t.corners, fs)->Result.flatMap(((cp, co)) => + (odd(n) ? readOriented(n, "midge", t.midges, fs) : Ok(([], [])))->Result.flatMap(((mp, mo)) => + t.wings + ->traverseAll((table, _) => readWingsStrict(n, table, fs)) + ->Result.map( + (wings): Orbit64V2.cube => { + cornerPieces: cp, + cornerTwists: co, + midgePieces: mp, + midgeFlips: mo, + wings, + centers: t.centers->Array.map(table => table->Array.map(at => fs->get(at))), + rotations: [], + frame, + }, + ) + ) + ) + +// Rotates an odd cube so that its fixed centers are home; the frame is the one they show. +let normalizeOdd = (n, t, fs) => { + let shown = t.fixed->Array.map(at => fs->get(at)) + switch range(24)->Array.find(r => facesOfFrame(r) == shown) { + | Some(r) => Ok((r, unrotate(n, turnOf(r), fs))) + | None => Error("the six fixed centers are not a right-handed whole-cube frame") + } +} + +// Rotates an even cube so that its DBL corner is in slot DBL with twist 0. +let normalizeEven = (n, t, fs) => + switch range(24)->Array.findMap(r => { + let rotated = unrotate(n, turnOf(r), fs) + readPiece(n, t.corners, seenAt(t.corners, 6, rotated)) == Some((6, 0)) ? Some(rotated) : None + }) { + | Some(rotated) => Ok(rotated) + | None => Error("no whole-cube rotation puts the DBL corner home") + } + +// The frame to record and the stickers in the pose the type reads them in. +let posedStickers = (n, pose: Orbit64V2.pose, t, fs) => + if odd(n) { + normalizeOdd(n, t, fs)->Result.map(((r, posed)) => (pose == Framed ? r : 0, posed)) + } else if pose == Canonical { + normalizeEven(n, t, fs)->Result.map(posed => (0, posed)) + } else { + Ok((0, fs)) + } + +let readStickers = (n, model, pose, text) => { + let t = tables(n) + parse(n, text) + ->Result.flatMap(fs => checkCounts(n, fs)->Result.map(() => fs)) + ->Result.flatMap(fs => posedStickers(n, pose, t, fs)) + ->Result.flatMap(((frame, posed)) => readCube(n, t, frame, posed)) + ->Result.flatMap(cube => + switch Orbit64V2.faultOf(n, model, pose, cube) { + | Some(why) => Error(why) + | None => Ok(cube) + } + ) +} + +@genType +let fromFacelets = (n, model, pose, facelets) => + try { + switch typeFault(n, model) { + | Some(why) => Error(why) + | None => + Type.typeof(facelets) == #string + ? readStickers(n, model, pose, facelets) + : Error("facelets must be a string") + } + } catch { + | _ => Error("malformed facelets") + } + +// ------------------------------------------------------------ registry level helpers + +@genType +let encodeFacelets = (id, facelets) => + try { + switch Orbit64V2.entryById(id) { + | None => Error(`unknown registry entry ${show(id)}`) + | Some(entry) => + fromFacelets(entry.n, entry.model, entry.pose, facelets)->Result.flatMap(cube => + Orbit64V2.encodeOrbit64V2State(id, cube) + ) + } + } catch { + | _ => Error("malformed registry entry") + } + +@genType +let decodeFacelets = token => + Orbit64V2.decodeOrbit64V2State(token)->Result.flatMap(({entry, cube}) => + toFacelets(entry.n, entry.model, entry.pose, cube)->Result.map(facelets => {entry, facelets}) + ) diff --git a/src/cube/notation/Orbit64V2Facelets.resi b/src/cube/notation/Orbit64V2Facelets.resi new file mode 100644 index 0000000..af06c85 --- /dev/null +++ b/src/cube/notation/Orbit64V2Facelets.resi @@ -0,0 +1,48 @@ +// Slot tables of one cube size, as lists of facelets (`face * n^2 + row * n + +// col` over U R F D L B). A corner, midge or wing lists the facelets of its +// slot, reference sticker first; a center slot is one facelet. `wings` holds +// one list per depth, outermost first. `fixed` holds the fixed centers of an +// odd cube, one per face. +@genType +type slots = { + corners: array>, + midges: array>, + wings: array>>, + centers: array>, + fixed: array, +} + +// The slot tables of an n x n x n cube, n = 2..15, derived like the reference +// (a fresh copy on every call). +@genType let slotTables: int => option + +// The physical faces in slots U R F D L B of each of the 24 whole-cube frames, +// in the rank order of Orbit64 frames, as letters such as "URFDLB". +@genType let frameFaces: array + +// The facelet string of a cube state of the type (n, model, pose): six face +// fields in the order U R F D L B, a space between fields. A canonical cube is +// written in its reference pose; a framed cube of an odd size is that picture +// rotated by its frame. Only the color model has letters: a picture type is an +// Error, as is a cube that is no state of the type. +@genType +let toFacelets: (int, Orbit64V2.model, Orbit64V2.pose, Orbit64V2.cube) => result + +// The cube state a facelet string shows, in the pose of the type. Spaces are +// ignored; every other character must be one of U R F D L B. A canonical read +// turns the cube so that its reference is home first (the fixed centers of an +// odd cube, the DBL corner of an even one) and so accepts any whole-cube +// orientation. A framed read of an odd cube keeps the orientation as +// `frame`; of an even cube, in its corners. Anything that is no reachable cube +// is an Error with its reason, never an exception. +@genType +let fromFacelets: (int, Orbit64V2.model, Orbit64V2.pose, string) => result + +@genType +type decodedFacelets = {entry: Orbit64V2.entry, facelets: string} + +// The V2 token of the cube a facelet string shows, for registry entry `id`. +@genType let encodeFacelets: (int, string) => result + +// The registry entry of a token and the facelet string of its state. +@genType let decodeFacelets: string => result diff --git a/src/cube/notation/orbit64V2Facelets.ts b/src/cube/notation/orbit64V2Facelets.ts new file mode 100644 index 0000000..b81871a --- /dev/null +++ b/src/cube/notation/orbit64V2Facelets.ts @@ -0,0 +1,16 @@ +// Orbit64 V2 facelet bridge for 2x2-15x15 cubes: typed entry point for the +// ReScript module (Orbit64V2Facelets.res). The color model only; a picture +// type is an error. The generated functions are used as they are. +// Format: FORMAT-V2.md of flix-orbit64@d701008 (Apache-2.0). +export type { + decodedFacelets as Orbit64V2DecodedFacelets, + slots as Orbit64V2Slots, +} from './Orbit64V2Facelets.gen' +export { + decodeFacelets as decodeOrbit64V2Facelets, + encodeFacelets as encodeOrbit64V2Facelets, + frameFaces as orbit64V2FrameFaces, + fromFacelets as orbit64V2FromFacelets, + slotTables as orbit64V2Slots, + toFacelets as orbit64V2ToFacelets, +} from './Orbit64V2Facelets.gen' From 151b8974330ae6ce50e724d3170fdd36d17c14c6 Mon Sep 17 00:00:00 2001 From: Werner Stein Date: Sun, 1 Nov 2026 13:11:16 +0000 Subject: [PATCH 02/10] test(orbit64): add the V2 facelet fixture and its generator A Julia script copies the slot tables of FORMAT-V2-SLOTS.md and the 448 facelet rows of flix-orbit64's TestV2FaceletData.flix into a JSON fixture. The row count comes from the input and the output is written the way the formatter leaves it, so regenerating it changes nothing. Co-Authored-By: Claude Sonnet 5.5 --- scripts/orbit64V2FaceletFixture.jl | 160 + test/cube/notation/orbit64V2Facelets.json | 3285 +++++++++++++++++++++ 2 files changed, 3445 insertions(+) create mode 100644 scripts/orbit64V2FaceletFixture.jl create mode 100644 test/cube/notation/orbit64V2Facelets.json diff --git a/scripts/orbit64V2FaceletFixture.jl b/scripts/orbit64V2FaceletFixture.jl new file mode 100644 index 0000000..80bddab --- /dev/null +++ b/scripts/orbit64V2FaceletFixture.jl @@ -0,0 +1,160 @@ +#!/usr/bin/env julia +# +# Writes test/cube/notation/orbit64V2Facelets.json from the Orbit64 V2 +# reference repository (flix-orbit64, Apache-2.0). +# +# julia scripts/orbit64V2FaceletFixture.jl +# +# It copies the slot tables of FORMAT-V2-SLOTS.md (n = 2..15) and the rows of +# test/TestV2FaceletData.flix, which tools/format-v2/facelet_vectors.jl +# generates there. Nothing is computed here. The row count comes from the +# input. Needs only Julia's standard library; the output is deterministic, and +# written the way `biome format` leaves it, so regenerating it changes nothing. + +root = length(ARGS) == 1 ? ARGS[1] : error("usage: julia scripts/orbit64V2FaceletFixture.jl ") +read_text(path) = read(joinpath(root, path), String) + +revision = strip(read(`git -C $root rev-parse --short HEAD`, String)) + +# ---- FORMAT-V2-SLOTS.md -------------------------------------------------------- +# ## 5x5x5 +# corners slot: facelets +# C 0: 24 25 54 +# wings, depth 1 +# W1 0: 1 128 +# centers, 24 slots each, ascending +# Z[1,1]: 7 10 25 ... +# A slot is the facelets after the colon, in the order listed. + +struct Slots + corners::Vector{String} + midges::Vector{String} + wings::Vector{Vector{String}} + centers::Vector{String} +end + +function parse_slots(text::String) + sizes = Dict{Int,Slots}() + current = nothing + kind = :none + for line in split(text, '\n') + if (m = match(r"^## (\d+)x\1x\1$", line)) !== nothing + current = Slots(String[], String[], Vector{String}[], String[]) + sizes[parse(Int, m.captures[1])] = current + kind = :none + elseif current === nothing + continue + elseif startswith(line, "corners") + kind = :corners + elseif startswith(line, "midges") + kind = :midges + elseif startswith(line, "wings, depth") + kind = :wings + push!(current.wings, String[]) + elseif startswith(line, "centers") + kind = :centers + elseif (m = match(r"^ \S+(?: \d+)?: ([\d ]+)$", line)) !== nothing + kind == :none && error("slot line outside an orbit: $line") + facelets = join(split(m.captures[1]), " ") + kind == :corners && push!(current.corners, facelets) + kind == :midges && push!(current.midges, facelets) + kind == :wings && push!(current.wings[end], facelets) + kind == :centers && push!(current.centers, facelets) + end + end + sizes +end + +slots = parse_slots(read_text("FORMAT-V2-SLOTS.md")) +sort(collect(keys(slots))) == collect(2:15) || error("FORMAT-V2-SLOTS.md: sizes $(sort(collect(keys(slots)))), expected 2:15") +for (n, s) in slots + length(s.corners) == 8 || error("$(n)x$(n)x$(n): $(length(s.corners)) corners") + length(s.midges) == (isodd(n) ? 12 : 0) || error("$(n)x$(n)x$(n): $(length(s.midges)) midges") + length(s.wings) == (n - 2) ÷ 2 || error("$(n)x$(n)x$(n): $(length(s.wings)) wing depths") + all(w -> length(w) == 24, s.wings) || error("$(n)x$(n)x$(n): a wing depth without 24 slots") +end + +# ---- test/TestV2FaceletData.flix ----------------------------------------------- +# (0, "1R", "UFUF RRRR FDFD DBDB LLLL UBUB", "IbH7", ""), + +struct Row + id::Int + moves::String + facelets::String + token::String + canonical::String +end + +row_pattern = r"^\s*\((\d+), \"([^\"]*)\", \"([^\"]*)\", \"([^\"]*)\", \"([^\"]*)\"\),?\s*$" +rows = Row[] +for line in split(read_text("test/TestV2FaceletData.flix"), '\n') + m = match(row_pattern, line) + m === nothing && continue + push!(rows, Row(parse(Int, m.captures[1]), m.captures[2], m.captures[3], m.captures[4], m.captures[5])) +end +isempty(rows) && error("TestV2FaceletData.flix: no rows") + +# ---- JSON ---------------------------------------------------------------------- + +function quoted(text::AbstractString) + out = IOBuffer() + print(out, '"') + for c in text + c == '"' ? print(out, "\\\"") : + c == '\\' ? print(out, "\\\\") : + c < ' ' ? print(out, "\\u", string(UInt16(c), base = 16, pad = 4)) : print(out, c) + end + print(out, '"') + String(take!(out)) +end + +# One `"key": value` line at an indent of `depth` levels of two spaces. +member(depth::Int, key::AbstractString, value::AbstractString) = repeat(" ", depth) * quoted(key) * ": " * value + +# Slots are strings, `|` between slots, so that no array is short enough for the +# formatter to join its lines. Indentation is the formatter's. +function slot_object(n::Int, s::Slots) + wings = isempty(s.wings) ? "{}" : + "{\n" * join([member(4, string(d), quoted(join(w, " | "))) for (d, w) in enumerate(s.wings)], ",\n") * "\n }" + join([ + " " * quoted(string(n)) * ": {", + member(3, "corners", quoted(join(s.corners, " | "))) * ",", + member(3, "midges", quoted(join(s.midges, " | "))) * ",", + member(3, "wings", wings) * ",", + member(3, "centers", quoted(join(s.centers, " | "))), + " }", + ], "\n") +end + +row_object(r::Row) = join([ + " {", + member(3, "id", string(r.id)) * ",", + member(3, "moves", quoted(r.moves)) * ",", + member(3, "facelets", quoted(r.facelets)) * ",", + member(3, "token", quoted(r.token)) * ",", + member(3, "canonical", quoted(r.canonical)), + " }", +], "\n") + +slot_text = join([slot_object(n, slots[n]) for n in 2:15], ",\n") +row_text = join([row_object(r) for r in rows], ",\n") + +json = """ +{ + "source": $(quoted("flix-orbit64@$revision: FORMAT-V2-SLOTS.md and test/TestV2FaceletData.flix (generated there by tools/format-v2/facelet_vectors.jl)")), + "generatedBy": "scripts/orbit64V2FaceletFixture.jl. Do not edit.", + "slotText": "Facelets of each slot of an orbit, separated by spaces, slots separated by |, in slot order. Wings are keyed by depth, outermost first.", + "rowText": "id: registry entry; moves: layer turns (depth, face, suffix) and whole-cube turns x y z from the solved cube; facelets: what the entry writes for the cube; token: its V2 token; canonical: the reference pose of that cube when the entry's facelets differ from it, else empty.", + "rowCount": $(length(rows)), + "slots": { +$slot_text + }, + "rows": [ +$row_text + ] +} +""" + +target = joinpath(@__DIR__, "..", "test", "cube", "notation", "orbit64V2Facelets.json") +write(target, json) +println("wrote ", length(rows), " rows and the slot tables of ", length(slots), " sizes") diff --git a/test/cube/notation/orbit64V2Facelets.json b/test/cube/notation/orbit64V2Facelets.json new file mode 100644 index 0000000..ae04fdc --- /dev/null +++ b/test/cube/notation/orbit64V2Facelets.json @@ -0,0 +1,3285 @@ +{ + "source": "flix-orbit64@d701008: FORMAT-V2-SLOTS.md and test/TestV2FaceletData.flix (generated there by tools/format-v2/facelet_vectors.jl)", + "generatedBy": "scripts/orbit64V2FaceletFixture.jl. Do not edit.", + "slotText": "Facelets of each slot of an orbit, separated by spaces, slots separated by |, in slot order. Wings are keyed by depth, outermost first.", + "rowText": "id: registry entry; moves: layer turns (depth, face, suffix) and whole-cube turns x y z from the solved cube; facelets: what the entry writes for the cube; token: its V2 token; canonical: the reference pose of that cube when the entry's facelets differ from it, else empty.", + "rowCount": 448, + "slots": { + "2": { + "corners": "3 4 9 | 2 8 17 | 0 16 21 | 1 20 5 | 13 11 6 | 12 19 10 | 14 23 18 | 15 7 22", + "midges": "", + "wings": {}, + "centers": "" + }, + "3": { + "corners": "8 9 20 | 6 18 38 | 0 36 47 | 2 45 11 | 29 26 15 | 27 44 24 | 33 53 42 | 35 17 51", + "midges": "5 10 | 7 19 | 3 37 | 1 46 | 32 16 | 28 25 | 30 43 | 34 52 | 23 12 | 21 41 | 50 39 | 48 14", + "wings": {}, + "centers": "" + }, + "4": { + "corners": "15 16 35 | 12 32 67 | 0 64 83 | 3 80 19 | 51 47 28 | 48 79 44 | 60 95 76 | 63 31 92", + "midges": "", + "wings": { + "1": "1 82 | 7 18 | 8 66 | 14 34 | 17 11 | 23 84 | 24 43 | 30 59 | 33 13 | 39 20 | 40 75 | 46 50 | 49 45 | 55 29 | 56 77 | 62 93 | 65 4 | 71 36 | 72 91 | 78 52 | 81 2 | 87 68 | 88 27 | 94 61" + }, + "centers": "5 6 9 10 21 22 25 26 37 38 41 42 53 54 57 58 69 70 73 74 85 86 89 90" + }, + "5": { + "corners": "24 25 54 | 20 50 104 | 0 100 129 | 4 125 29 | 79 74 45 | 75 124 70 | 95 149 120 | 99 49 145", + "midges": "14 27 | 22 52 | 10 102 | 2 127 | 89 47 | 77 72 | 85 122 | 97 147 | 64 35 | 60 114 | 139 110 | 135 39", + "wings": { + "1": "1 128 | 9 28 | 15 103 | 23 53 | 26 19 | 34 130 | 40 69 | 48 94 | 51 21 | 59 30 | 65 119 | 73 78 | 76 71 | 84 46 | 90 121 | 98 146 | 101 5 | 109 55 | 115 144 | 123 80 | 126 3 | 134 105 | 140 44 | 148 96" + }, + "centers": "6 8 16 18 31 33 41 43 56 58 66 68 81 83 91 93 106 108 116 118 131 133 141 143 | 7 11 13 17 32 36 38 42 57 61 63 67 82 86 88 92 107 111 113 117 132 136 138 142" + }, + "6": { + "corners": "35 36 77 | 30 72 149 | 0 144 185 | 5 180 41 | 113 107 66 | 108 179 102 | 138 215 174 | 143 71 210", + "midges": "", + "wings": { + "1": "1 184 | 11 40 | 24 148 | 34 76 | 37 29 | 47 186 | 60 101 | 70 137 | 73 31 | 83 42 | 96 173 | 106 112 | 109 103 | 119 67 | 132 175 | 142 211 | 145 6 | 155 78 | 168 209 | 178 114 | 181 4 | 191 150 | 204 65 | 214 139", + "2": "2 183 | 17 39 | 18 147 | 33 75 | 38 23 | 53 192 | 54 95 | 69 131 | 74 32 | 89 48 | 90 167 | 105 111 | 110 104 | 125 68 | 126 176 | 141 212 | 146 12 | 161 84 | 162 203 | 177 120 | 182 3 | 197 156 | 198 59 | 213 140" + }, + "centers": "7 10 25 28 43 46 61 64 79 82 97 100 115 118 133 136 151 154 169 172 187 190 205 208 | 8 16 19 27 44 52 55 63 80 88 91 99 116 124 127 135 152 160 163 171 188 196 199 207 | 9 13 22 26 45 49 58 62 81 85 94 98 117 121 130 134 153 157 166 170 189 193 202 206 | 14 15 20 21 50 51 56 57 86 87 92 93 122 123 128 129 158 159 164 165 194 195 200 201" + }, + "7": { + "corners": "48 49 104 | 42 98 202 | 0 196 251 | 6 245 55 | 153 146 91 | 147 244 140 | 189 293 238 | 195 97 287", + "midges": "27 52 | 45 101 | 21 199 | 3 248 | 174 94 | 150 143 | 168 241 | 192 290 | 125 70 | 119 223 | 272 217 | 266 76", + "wings": { + "1": "1 250 | 13 54 | 35 201 | 47 103 | 50 41 | 62 252 | 84 139 | 96 188 | 99 43 | 111 56 | 133 237 | 145 152 | 148 141 | 160 92 | 182 239 | 194 288 | 197 7 | 209 105 | 231 286 | 243 154 | 246 5 | 258 203 | 280 90 | 292 190", + "2": "2 249 | 20 53 | 28 200 | 46 102 | 51 34 | 69 259 | 77 132 | 95 181 | 100 44 | 118 63 | 126 230 | 144 151 | 149 142 | 167 93 | 175 240 | 193 289 | 198 14 | 216 112 | 224 279 | 242 161 | 247 4 | 265 210 | 273 83 | 291 191" + }, + "centers": "8 12 36 40 57 61 85 89 106 110 134 138 155 159 183 187 204 208 232 236 253 257 281 285 | 9 19 29 39 58 68 78 88 107 117 127 137 156 166 176 186 205 215 225 235 254 264 274 284 | 10 22 26 38 59 71 75 87 108 120 124 136 157 169 173 185 206 218 222 234 255 267 271 283 | 11 15 33 37 60 64 82 86 109 113 131 135 158 162 180 184 207 211 229 233 256 260 278 282 | 16 18 30 32 65 67 79 81 114 116 128 130 163 165 177 179 212 214 226 228 261 263 275 277 | 17 23 25 31 66 72 74 80 115 121 123 129 164 170 172 178 213 219 221 227 262 268 270 276" + }, + "8": { + "corners": "63 64 135 | 56 128 263 | 0 256 327 | 7 320 71 | 199 191 120 | 192 319 184 | 248 383 312 | 255 127 376", + "midges": "", + "wings": { + "1": "1 326 | 15 70 | 48 262 | 62 134 | 65 55 | 79 328 | 112 183 | 126 247 | 129 57 | 143 72 | 176 311 | 190 198 | 193 185 | 207 121 | 240 313 | 254 377 | 257 8 | 271 136 | 304 375 | 318 200 | 321 6 | 335 264 | 368 119 | 382 249", + "2": "2 325 | 23 69 | 40 261 | 61 133 | 66 47 | 87 336 | 104 175 | 125 239 | 130 58 | 151 80 | 168 303 | 189 197 | 194 186 | 215 122 | 232 314 | 253 378 | 258 16 | 279 144 | 296 367 | 317 208 | 322 5 | 343 272 | 360 111 | 381 250", + "3": "3 324 | 31 68 | 32 260 | 60 132 | 67 39 | 95 344 | 96 167 | 124 231 | 131 59 | 159 88 | 160 295 | 188 196 | 195 187 | 223 123 | 224 315 | 252 379 | 259 24 | 287 152 | 288 359 | 316 216 | 323 4 | 351 280 | 352 103 | 380 251" + }, + "centers": "9 14 49 54 73 78 113 118 137 142 177 182 201 206 241 246 265 270 305 310 329 334 369 374 | 10 22 41 53 74 86 105 117 138 150 169 181 202 214 233 245 266 278 297 309 330 342 361 373 | 11 30 33 52 75 94 97 116 139 158 161 180 203 222 225 244 267 286 289 308 331 350 353 372 | 12 25 38 51 76 89 102 115 140 153 166 179 204 217 230 243 268 281 294 307 332 345 358 371 | 13 17 46 50 77 81 110 114 141 145 174 178 205 209 238 242 269 273 302 306 333 337 366 370 | 18 21 42 45 82 85 106 109 146 149 170 173 210 213 234 237 274 277 298 301 338 341 362 365 | 19 29 34 44 83 93 98 108 147 157 162 172 211 221 226 236 275 285 290 300 339 349 354 364 | 20 26 37 43 84 90 101 107 148 154 165 171 212 218 229 235 276 282 293 299 340 346 357 363 | 27 28 35 36 91 92 99 100 155 156 163 164 219 220 227 228 283 284 291 292 347 348 355 356" + }, + "9": { + "corners": "80 81 170 | 72 162 332 | 0 324 413 | 8 405 89 | 251 242 153 | 243 404 234 | 315 485 396 | 323 161 477", + "midges": "44 85 | 76 166 | 36 328 | 4 409 | 287 157 | 247 238 | 279 400 | 319 481 | 206 117 | 198 368 | 449 360 | 441 125", + "wings": { + "1": "1 412 | 17 88 | 63 331 | 79 169 | 82 71 | 98 414 | 144 233 | 160 314 | 163 73 | 179 90 | 225 395 | 241 250 | 244 235 | 260 154 | 306 397 | 322 478 | 325 9 | 341 171 | 387 476 | 403 252 | 406 7 | 422 333 | 468 152 | 484 316", + "2": "2 411 | 26 87 | 54 330 | 78 168 | 83 62 | 107 423 | 135 224 | 159 305 | 164 74 | 188 99 | 216 386 | 240 249 | 245 236 | 269 155 | 297 398 | 321 479 | 326 18 | 350 180 | 378 467 | 402 261 | 407 6 | 431 342 | 459 143 | 483 317", + "3": "3 410 | 35 86 | 45 329 | 77 167 | 84 53 | 116 432 | 126 215 | 158 296 | 165 75 | 197 108 | 207 377 | 239 248 | 246 237 | 278 156 | 288 399 | 320 480 | 327 27 | 359 189 | 369 458 | 401 270 | 408 5 | 440 351 | 450 134 | 482 318" + }, + "centers": "10 16 64 70 91 97 145 151 172 178 226 232 253 259 307 313 334 340 388 394 415 421 469 475 | 11 25 55 69 92 106 136 150 173 187 217 231 254 268 298 312 335 349 379 393 416 430 460 474 | 12 34 46 68 93 115 127 149 174 196 208 230 255 277 289 311 336 358 370 392 417 439 451 473 | 13 37 43 67 94 118 124 148 175 199 205 229 256 280 286 310 337 361 367 391 418 442 448 472 | 14 28 52 66 95 109 133 147 176 190 214 228 257 271 295 309 338 352 376 390 419 433 457 471 | 15 19 61 65 96 100 142 146 177 181 223 227 258 262 304 308 339 343 385 389 420 424 466 470 | 20 24 56 60 101 105 137 141 182 186 218 222 263 267 299 303 344 348 380 384 425 429 461 465 | 21 33 47 59 102 114 128 140 183 195 209 221 264 276 290 302 345 357 371 383 426 438 452 464 | 22 38 42 58 103 119 123 139 184 200 204 220 265 281 285 301 346 362 366 382 427 443 447 463 | 23 29 51 57 104 110 132 138 185 191 213 219 266 272 294 300 347 353 375 381 428 434 456 462 | 30 32 48 50 111 113 129 131 192 194 210 212 273 275 291 293 354 356 372 374 435 437 453 455 | 31 39 41 49 112 120 122 130 193 201 203 211 274 282 284 292 355 363 365 373 436 444 446 454" + }, + "10": { + "corners": "99 100 209 | 90 200 409 | 0 400 509 | 9 500 109 | 309 299 190 | 300 499 290 | 390 599 490 | 399 199 590", + "midges": "", + "wings": { + "1": "1 508 | 19 108 | 80 408 | 98 208 | 101 89 | 119 510 | 180 289 | 198 389 | 201 91 | 219 110 | 280 489 | 298 308 | 301 291 | 319 191 | 380 491 | 398 591 | 401 10 | 419 210 | 480 589 | 498 310 | 501 8 | 519 410 | 580 189 | 598 391", + "2": "2 507 | 29 107 | 70 407 | 97 207 | 102 79 | 129 520 | 170 279 | 197 379 | 202 92 | 229 120 | 270 479 | 297 307 | 302 292 | 329 192 | 370 492 | 397 592 | 402 20 | 429 220 | 470 579 | 497 320 | 502 7 | 529 420 | 570 179 | 597 392", + "3": "3 506 | 39 106 | 60 406 | 96 206 | 103 69 | 139 530 | 160 269 | 196 369 | 203 93 | 239 130 | 260 469 | 296 306 | 303 293 | 339 193 | 360 493 | 396 593 | 403 30 | 439 230 | 460 569 | 496 330 | 503 6 | 539 430 | 560 169 | 596 393", + "4": "4 505 | 49 105 | 50 405 | 95 205 | 104 59 | 149 540 | 150 259 | 195 359 | 204 94 | 249 140 | 250 459 | 295 305 | 304 294 | 349 194 | 350 494 | 395 594 | 404 40 | 449 240 | 450 559 | 495 340 | 504 5 | 549 440 | 550 159 | 595 394" + }, + "centers": "11 18 81 88 111 118 181 188 211 218 281 288 311 318 381 388 411 418 481 488 511 518 581 588 | 12 28 71 87 112 128 171 187 212 228 271 287 312 328 371 387 412 428 471 487 512 528 571 587 | 13 38 61 86 113 138 161 186 213 238 261 286 313 338 361 386 413 438 461 486 513 538 561 586 | 14 48 51 85 114 148 151 185 214 248 251 285 314 348 351 385 414 448 451 485 514 548 551 585 | 15 41 58 84 115 141 158 184 215 241 258 284 315 341 358 384 415 441 458 484 515 541 558 584 | 16 31 68 83 116 131 168 183 216 231 268 283 316 331 368 383 416 431 468 483 516 531 568 583 | 17 21 78 82 117 121 178 182 217 221 278 282 317 321 378 382 417 421 478 482 517 521 578 582 | 22 27 72 77 122 127 172 177 222 227 272 277 322 327 372 377 422 427 472 477 522 527 572 577 | 23 37 62 76 123 137 162 176 223 237 262 276 323 337 362 376 423 437 462 476 523 537 562 576 | 24 47 52 75 124 147 152 175 224 247 252 275 324 347 352 375 424 447 452 475 524 547 552 575 | 25 42 57 74 125 142 157 174 225 242 257 274 325 342 357 374 425 442 457 474 525 542 557 574 | 26 32 67 73 126 132 167 173 226 232 267 273 326 332 367 373 426 432 467 473 526 532 567 573 | 33 36 63 66 133 136 163 166 233 236 263 266 333 336 363 366 433 436 463 466 533 536 563 566 | 34 46 53 65 134 146 153 165 234 246 253 265 334 346 353 365 434 446 453 465 534 546 553 565 | 35 43 56 64 135 143 156 164 235 243 256 264 335 343 356 364 435 443 456 464 535 543 556 564 | 44 45 54 55 144 145 154 155 244 245 254 255 344 345 354 355 444 445 454 455 544 545 554 555" + }, + "11": { + "corners": "120 121 252 | 110 242 494 | 0 484 615 | 10 605 131 | 373 362 231 | 363 604 352 | 473 725 594 | 483 241 715", + "midges": "65 126 | 115 247 | 55 489 | 5 610 | 428 236 | 368 357 | 418 599 | 478 720 | 307 176 | 297 549 | 670 539 | 660 186", + "wings": { + "1": "1 614 | 21 130 | 99 493 | 119 251 | 122 109 | 142 616 | 220 351 | 240 472 | 243 111 | 263 132 | 341 593 | 361 372 | 364 353 | 384 232 | 462 595 | 482 716 | 485 11 | 505 253 | 583 714 | 603 374 | 606 9 | 626 495 | 704 230 | 724 474", + "2": "2 613 | 32 129 | 88 492 | 118 250 | 123 98 | 153 627 | 209 340 | 239 461 | 244 112 | 274 143 | 330 582 | 360 371 | 365 354 | 395 233 | 451 596 | 481 717 | 486 22 | 516 264 | 572 703 | 602 385 | 607 8 | 637 506 | 693 219 | 723 475", + "3": "3 612 | 43 128 | 77 491 | 117 249 | 124 87 | 164 638 | 198 329 | 238 450 | 245 113 | 285 154 | 319 571 | 359 370 | 366 355 | 406 234 | 440 597 | 480 718 | 487 33 | 527 275 | 561 692 | 601 396 | 608 7 | 648 517 | 682 208 | 722 476", + "4": "4 611 | 54 127 | 66 490 | 116 248 | 125 76 | 175 649 | 187 318 | 237 439 | 246 114 | 296 165 | 308 560 | 358 369 | 367 356 | 417 235 | 429 598 | 479 719 | 488 44 | 538 286 | 550 681 | 600 407 | 609 6 | 659 528 | 671 197 | 721 477" + }, + "centers": "12 20 100 108 133 141 221 229 254 262 342 350 375 383 463 471 496 504 584 592 617 625 705 713 | 13 31 89 107 134 152 210 228 255 273 331 349 376 394 452 470 497 515 573 591 618 636 694 712 | 14 42 78 106 135 163 199 227 256 284 320 348 377 405 441 469 498 526 562 590 619 647 683 711 | 15 53 67 105 136 174 188 226 257 295 309 347 378 416 430 468 499 537 551 589 620 658 672 710 | 16 56 64 104 137 177 185 225 258 298 306 346 379 419 427 467 500 540 548 588 621 661 669 709 | 17 45 75 103 138 166 196 224 259 287 317 345 380 408 438 466 501 529 559 587 622 650 680 708 | 18 34 86 102 139 155 207 223 260 276 328 344 381 397 449 465 502 518 570 586 623 639 691 707 | 19 23 97 101 140 144 218 222 261 265 339 343 382 386 460 464 503 507 581 585 624 628 702 706 | 24 30 90 96 145 151 211 217 266 272 332 338 387 393 453 459 508 514 574 580 629 635 695 701 | 25 41 79 95 146 162 200 216 267 283 321 337 388 404 442 458 509 525 563 579 630 646 684 700 | 26 52 68 94 147 173 189 215 268 294 310 336 389 415 431 457 510 536 552 578 631 657 673 699 | 27 57 63 93 148 178 184 214 269 299 305 335 390 420 426 456 511 541 547 577 632 662 668 698 | 28 46 74 92 149 167 195 213 270 288 316 334 391 409 437 455 512 530 558 576 633 651 679 697 | 29 35 85 91 150 156 206 212 271 277 327 333 392 398 448 454 513 519 569 575 634 640 690 696 | 36 40 80 84 157 161 201 205 278 282 322 326 399 403 443 447 520 524 564 568 641 645 685 689 | 37 51 69 83 158 172 190 204 279 293 311 325 400 414 432 446 521 535 553 567 642 656 674 688 | 38 58 62 82 159 179 183 203 280 300 304 324 401 421 425 445 522 542 546 566 643 663 667 687 | 39 47 73 81 160 168 194 202 281 289 315 323 402 410 436 444 523 531 557 565 644 652 678 686 | 48 50 70 72 169 171 191 193 290 292 312 314 411 413 433 435 532 534 554 556 653 655 675 677 | 49 59 61 71 170 180 182 192 291 301 303 313 412 422 424 434 533 543 545 555 654 664 666 676" + }, + "12": { + "corners": "143 144 299 | 132 288 587 | 0 576 731 | 11 720 155 | 443 431 276 | 432 719 420 | 564 863 708 | 575 287 852", + "midges": "", + "wings": { + "1": "1 730 | 23 154 | 120 586 | 142 298 | 145 131 | 167 732 | 264 419 | 286 563 | 289 133 | 311 156 | 408 707 | 430 442 | 433 421 | 455 277 | 552 709 | 574 853 | 577 12 | 599 300 | 696 851 | 718 444 | 721 10 | 743 588 | 840 275 | 862 565", + "2": "2 729 | 35 153 | 108 585 | 141 297 | 146 119 | 179 744 | 252 407 | 285 551 | 290 134 | 323 168 | 396 695 | 429 441 | 434 422 | 467 278 | 540 710 | 573 854 | 578 24 | 611 312 | 684 839 | 717 456 | 722 9 | 755 600 | 828 263 | 861 566", + "3": "3 728 | 47 152 | 96 584 | 140 296 | 147 107 | 191 756 | 240 395 | 284 539 | 291 135 | 335 180 | 384 683 | 428 440 | 435 423 | 479 279 | 528 711 | 572 855 | 579 36 | 623 324 | 672 827 | 716 468 | 723 8 | 767 612 | 816 251 | 860 567", + "4": "4 727 | 59 151 | 84 583 | 139 295 | 148 95 | 203 768 | 228 383 | 283 527 | 292 136 | 347 192 | 372 671 | 427 439 | 436 424 | 491 280 | 516 712 | 571 856 | 580 48 | 635 336 | 660 815 | 715 480 | 724 7 | 779 624 | 804 239 | 859 568", + "5": "5 726 | 71 150 | 72 582 | 138 294 | 149 83 | 215 780 | 216 371 | 282 515 | 293 137 | 359 204 | 360 659 | 426 438 | 437 425 | 503 281 | 504 713 | 570 857 | 581 60 | 647 348 | 648 803 | 714 492 | 725 6 | 791 636 | 792 227 | 858 569" + }, + "centers": "13 22 121 130 157 166 265 274 301 310 409 418 445 454 553 562 589 598 697 706 733 742 841 850 | 14 34 109 129 158 178 253 273 302 322 397 417 446 466 541 561 590 610 685 705 734 754 829 849 | 15 46 97 128 159 190 241 272 303 334 385 416 447 478 529 560 591 622 673 704 735 766 817 848 | 16 58 85 127 160 202 229 271 304 346 373 415 448 490 517 559 592 634 661 703 736 778 805 847 | 17 70 73 126 161 214 217 270 305 358 361 414 449 502 505 558 593 646 649 702 737 790 793 846 | 18 61 82 125 162 205 226 269 306 349 370 413 450 493 514 557 594 637 658 701 738 781 802 845 | 19 49 94 124 163 193 238 268 307 337 382 412 451 481 526 556 595 625 670 700 739 769 814 844 | 20 37 106 123 164 181 250 267 308 325 394 411 452 469 538 555 596 613 682 699 740 757 826 843 | 21 25 118 122 165 169 262 266 309 313 406 410 453 457 550 554 597 601 694 698 741 745 838 842 | 26 33 110 117 170 177 254 261 314 321 398 405 458 465 542 549 602 609 686 693 746 753 830 837 | 27 45 98 116 171 189 242 260 315 333 386 404 459 477 530 548 603 621 674 692 747 765 818 836 | 28 57 86 115 172 201 230 259 316 345 374 403 460 489 518 547 604 633 662 691 748 777 806 835 | 29 69 74 114 173 213 218 258 317 357 362 402 461 501 506 546 605 645 650 690 749 789 794 834 | 30 62 81 113 174 206 225 257 318 350 369 401 462 494 513 545 606 638 657 689 750 782 801 833 | 31 50 93 112 175 194 237 256 319 338 381 400 463 482 525 544 607 626 669 688 751 770 813 832 | 32 38 105 111 176 182 249 255 320 326 393 399 464 470 537 543 608 614 681 687 752 758 825 831 | 39 44 99 104 183 188 243 248 327 332 387 392 471 476 531 536 615 620 675 680 759 764 819 824 | 40 56 87 103 184 200 231 247 328 344 375 391 472 488 519 535 616 632 663 679 760 776 807 823 | 41 68 75 102 185 212 219 246 329 356 363 390 473 500 507 534 617 644 651 678 761 788 795 822 | 42 63 80 101 186 207 224 245 330 351 368 389 474 495 512 533 618 639 656 677 762 783 800 821 | 43 51 92 100 187 195 236 244 331 339 380 388 475 483 524 532 619 627 668 676 763 771 812 820 | 52 55 88 91 196 199 232 235 340 343 376 379 484 487 520 523 628 631 664 667 772 775 808 811 | 53 67 76 90 197 211 220 234 341 355 364 378 485 499 508 522 629 643 652 666 773 787 796 810 | 54 64 79 89 198 208 223 233 342 352 367 377 486 496 511 521 630 640 655 665 774 784 799 809 | 65 66 77 78 209 210 221 222 353 354 365 366 497 498 509 510 641 642 653 654 785 786 797 798" + }, + "13": { + "corners": "168 169 350 | 156 338 688 | 0 676 857 | 12 845 181 | 519 506 325 | 507 844 494 | 663 1013 832 | 675 337 1001", + "midges": "90 175 | 162 344 | 78 682 | 6 851 | 597 331 | 513 500 | 585 838 | 669 1007 | 428 247 | 416 766 | 935 754 | 923 259", + "wings": { + "1": "1 856 | 25 180 | 143 687 | 167 349 | 170 155 | 194 858 | 312 493 | 336 662 | 339 157 | 363 182 | 481 831 | 505 518 | 508 495 | 532 326 | 650 833 | 674 1002 | 677 13 | 701 351 | 819 1000 | 843 520 | 846 11 | 870 689 | 988 324 | 1012 664", + "2": "2 855 | 38 179 | 130 686 | 166 348 | 171 142 | 207 871 | 299 480 | 335 649 | 340 158 | 376 195 | 468 818 | 504 517 | 509 496 | 545 327 | 637 834 | 673 1003 | 678 26 | 714 364 | 806 987 | 842 533 | 847 10 | 883 702 | 975 311 | 1011 665", + "3": "3 854 | 51 178 | 117 685 | 165 347 | 172 129 | 220 884 | 286 467 | 334 636 | 341 159 | 389 208 | 455 805 | 503 516 | 510 497 | 558 328 | 624 835 | 672 1004 | 679 39 | 727 377 | 793 974 | 841 546 | 848 9 | 896 715 | 962 298 | 1010 666", + "4": "4 853 | 64 177 | 104 684 | 164 346 | 173 116 | 233 897 | 273 454 | 333 623 | 342 160 | 402 221 | 442 792 | 502 515 | 511 498 | 571 329 | 611 836 | 671 1005 | 680 52 | 740 390 | 780 961 | 840 559 | 849 8 | 909 728 | 949 285 | 1009 667", + "5": "5 852 | 77 176 | 91 683 | 163 345 | 174 103 | 246 910 | 260 441 | 332 610 | 343 161 | 415 234 | 429 779 | 501 514 | 512 499 | 584 330 | 598 837 | 670 1006 | 681 65 | 753 403 | 767 948 | 839 572 | 850 7 | 922 741 | 936 272 | 1008 668" + }, + "centers": "14 24 144 154 183 193 313 323 352 362 482 492 521 531 651 661 690 700 820 830 859 869 989 999 | 15 37 131 153 184 206 300 322 353 375 469 491 522 544 638 660 691 713 807 829 860 882 976 998 | 16 50 118 152 185 219 287 321 354 388 456 490 523 557 625 659 692 726 794 828 861 895 963 997 | 17 63 105 151 186 232 274 320 355 401 443 489 524 570 612 658 693 739 781 827 862 908 950 996 | 18 76 92 150 187 245 261 319 356 414 430 488 525 583 599 657 694 752 768 826 863 921 937 995 | 19 79 89 149 188 248 258 318 357 417 427 487 526 586 596 656 695 755 765 825 864 924 934 994 | 20 66 102 148 189 235 271 317 358 404 440 486 527 573 609 655 696 742 778 824 865 911 947 993 | 21 53 115 147 190 222 284 316 359 391 453 485 528 560 622 654 697 729 791 823 866 898 960 992 | 22 40 128 146 191 209 297 315 360 378 466 484 529 547 635 653 698 716 804 822 867 885 973 991 | 23 27 141 145 192 196 310 314 361 365 479 483 530 534 648 652 699 703 817 821 868 872 986 990 | 28 36 132 140 197 205 301 309 366 374 470 478 535 543 639 647 704 712 808 816 873 881 977 985 | 29 49 119 139 198 218 288 308 367 387 457 477 536 556 626 646 705 725 795 815 874 894 964 984 | 30 62 106 138 199 231 275 307 368 400 444 476 537 569 613 645 706 738 782 814 875 907 951 983 | 31 75 93 137 200 244 262 306 369 413 431 475 538 582 600 644 707 751 769 813 876 920 938 982 | 32 80 88 136 201 249 257 305 370 418 426 474 539 587 595 643 708 756 764 812 877 925 933 981 | 33 67 101 135 202 236 270 304 371 405 439 473 540 574 608 642 709 743 777 811 878 912 946 980 | 34 54 114 134 203 223 283 303 372 392 452 472 541 561 621 641 710 730 790 810 879 899 959 979 | 35 41 127 133 204 210 296 302 373 379 465 471 542 548 634 640 711 717 803 809 880 886 972 978 | 42 48 120 126 211 217 289 295 380 386 458 464 549 555 627 633 718 724 796 802 887 893 965 971 | 43 61 107 125 212 230 276 294 381 399 445 463 550 568 614 632 719 737 783 801 888 906 952 970 | 44 74 94 124 213 243 263 293 382 412 432 462 551 581 601 631 720 750 770 800 889 919 939 969 | 45 81 87 123 214 250 256 292 383 419 425 461 552 588 594 630 721 757 763 799 890 926 932 968 | 46 68 100 122 215 237 269 291 384 406 438 460 553 575 607 629 722 744 776 798 891 913 945 967 | 47 55 113 121 216 224 282 290 385 393 451 459 554 562 620 628 723 731 789 797 892 900 958 966 | 56 60 108 112 225 229 277 281 394 398 446 450 563 567 615 619 732 736 784 788 901 905 953 957 | 57 73 95 111 226 242 264 280 395 411 433 449 564 580 602 618 733 749 771 787 902 918 940 956 | 58 82 86 110 227 251 255 279 396 420 424 448 565 589 593 617 734 758 762 786 903 927 931 955 | 59 69 99 109 228 238 268 278 397 407 437 447 566 576 606 616 735 745 775 785 904 914 944 954 | 70 72 96 98 239 241 265 267 408 410 434 436 577 579 603 605 746 748 772 774 915 917 941 943 | 71 83 85 97 240 252 254 266 409 421 423 435 578 590 592 604 747 759 761 773 916 928 930 942" + }, + "14": { + "corners": "195 196 405 | 182 392 797 | 0 784 993 | 13 980 209 | 601 587 378 | 588 979 574 | 770 1175 966 | 783 391 1162", + "midges": "", + "wings": { + "1": "1 992 | 27 208 | 168 796 | 194 404 | 197 181 | 223 994 | 364 573 | 390 769 | 393 183 | 419 210 | 560 965 | 586 600 | 589 575 | 615 379 | 756 967 | 782 1163 | 785 14 | 811 406 | 952 1161 | 978 602 | 981 12 | 1007 798 | 1148 377 | 1174 771", + "2": "2 991 | 41 207 | 154 795 | 193 403 | 198 167 | 237 1008 | 350 559 | 389 755 | 394 184 | 433 224 | 546 951 | 585 599 | 590 576 | 629 380 | 742 968 | 781 1164 | 786 28 | 825 420 | 938 1147 | 977 616 | 982 11 | 1021 812 | 1134 363 | 1173 772", + "3": "3 990 | 55 206 | 140 794 | 192 402 | 199 153 | 251 1022 | 336 545 | 388 741 | 395 185 | 447 238 | 532 937 | 584 598 | 591 577 | 643 381 | 728 969 | 780 1165 | 787 42 | 839 434 | 924 1133 | 976 630 | 983 10 | 1035 826 | 1120 349 | 1172 773", + "4": "4 989 | 69 205 | 126 793 | 191 401 | 200 139 | 265 1036 | 322 531 | 387 727 | 396 186 | 461 252 | 518 923 | 583 597 | 592 578 | 657 382 | 714 970 | 779 1166 | 788 56 | 853 448 | 910 1119 | 975 644 | 984 9 | 1049 840 | 1106 335 | 1171 774", + "5": "5 988 | 83 204 | 112 792 | 190 400 | 201 125 | 279 1050 | 308 517 | 386 713 | 397 187 | 475 266 | 504 909 | 582 596 | 593 579 | 671 383 | 700 971 | 778 1167 | 789 70 | 867 462 | 896 1105 | 974 658 | 985 8 | 1063 854 | 1092 321 | 1170 775", + "6": "6 987 | 97 203 | 98 791 | 189 399 | 202 111 | 293 1064 | 294 503 | 385 699 | 398 188 | 489 280 | 490 895 | 581 595 | 594 580 | 685 384 | 686 972 | 777 1168 | 790 84 | 881 476 | 882 1091 | 973 672 | 986 7 | 1077 868 | 1078 307 | 1169 776" + }, + "centers": "15 26 169 180 211 222 365 376 407 418 561 572 603 614 757 768 799 810 953 964 995 1006 1149 1160 | 16 40 155 179 212 236 351 375 408 432 547 571 604 628 743 767 800 824 939 963 996 1020 1135 1159 | 17 54 141 178 213 250 337 374 409 446 533 570 605 642 729 766 801 838 925 962 997 1034 1121 1158 | 18 68 127 177 214 264 323 373 410 460 519 569 606 656 715 765 802 852 911 961 998 1048 1107 1157 | 19 82 113 176 215 278 309 372 411 474 505 568 607 670 701 764 803 866 897 960 999 1062 1093 1156 | 20 96 99 175 216 292 295 371 412 488 491 567 608 684 687 763 804 880 883 959 1000 1076 1079 1155 | 21 85 110 174 217 281 306 370 413 477 502 566 609 673 698 762 805 869 894 958 1001 1065 1090 1154 | 22 71 124 173 218 267 320 369 414 463 516 565 610 659 712 761 806 855 908 957 1002 1051 1104 1153 | 23 57 138 172 219 253 334 368 415 449 530 564 611 645 726 760 807 841 922 956 1003 1037 1118 1152 | 24 43 152 171 220 239 348 367 416 435 544 563 612 631 740 759 808 827 936 955 1004 1023 1132 1151 | 25 29 166 170 221 225 362 366 417 421 558 562 613 617 754 758 809 813 950 954 1005 1009 1146 1150 | 30 39 156 165 226 235 352 361 422 431 548 557 618 627 744 753 814 823 940 949 1010 1019 1136 1145 | 31 53 142 164 227 249 338 360 423 445 534 556 619 641 730 752 815 837 926 948 1011 1033 1122 1144 | 32 67 128 163 228 263 324 359 424 459 520 555 620 655 716 751 816 851 912 947 1012 1047 1108 1143 | 33 81 114 162 229 277 310 358 425 473 506 554 621 669 702 750 817 865 898 946 1013 1061 1094 1142 | 34 95 100 161 230 291 296 357 426 487 492 553 622 683 688 749 818 879 884 945 1014 1075 1080 1141 | 35 86 109 160 231 282 305 356 427 478 501 552 623 674 697 748 819 870 893 944 1015 1066 1089 1140 | 36 72 123 159 232 268 319 355 428 464 515 551 624 660 711 747 820 856 907 943 1016 1052 1103 1139 | 37 58 137 158 233 254 333 354 429 450 529 550 625 646 725 746 821 842 921 942 1017 1038 1117 1138 | 38 44 151 157 234 240 347 353 430 436 543 549 626 632 739 745 822 828 935 941 1018 1024 1131 1137 | 45 52 143 150 241 248 339 346 437 444 535 542 633 640 731 738 829 836 927 934 1025 1032 1123 1130 | 46 66 129 149 242 262 325 345 438 458 521 541 634 654 717 737 830 850 913 933 1026 1046 1109 1129 | 47 80 115 148 243 276 311 344 439 472 507 540 635 668 703 736 831 864 899 932 1027 1060 1095 1128 | 48 94 101 147 244 290 297 343 440 486 493 539 636 682 689 735 832 878 885 931 1028 1074 1081 1127 | 49 87 108 146 245 283 304 342 441 479 500 538 637 675 696 734 833 871 892 930 1029 1067 1088 1126 | 50 73 122 145 246 269 318 341 442 465 514 537 638 661 710 733 834 857 906 929 1030 1053 1102 1125 | 51 59 136 144 247 255 332 340 443 451 528 536 639 647 724 732 835 843 920 928 1031 1039 1116 1124 | 60 65 130 135 256 261 326 331 452 457 522 527 648 653 718 723 844 849 914 919 1040 1045 1110 1115 | 61 79 116 134 257 275 312 330 453 471 508 526 649 667 704 722 845 863 900 918 1041 1059 1096 1114 | 62 93 102 133 258 289 298 329 454 485 494 525 650 681 690 721 846 877 886 917 1042 1073 1082 1113 | 63 88 107 132 259 284 303 328 455 480 499 524 651 676 695 720 847 872 891 916 1043 1068 1087 1112 | 64 74 121 131 260 270 317 327 456 466 513 523 652 662 709 719 848 858 905 915 1044 1054 1101 1111 | 75 78 117 120 271 274 313 316 467 470 509 512 663 666 705 708 859 862 901 904 1055 1058 1097 1100 | 76 92 103 119 272 288 299 315 468 484 495 511 664 680 691 707 860 876 887 903 1056 1072 1083 1099 | 77 89 106 118 273 285 302 314 469 481 498 510 665 677 694 706 861 873 890 902 1057 1069 1086 1098 | 90 91 104 105 286 287 300 301 482 483 496 497 678 679 692 693 874 875 888 889 1070 1071 1084 1085" + }, + "15": { + "corners": "224 225 464 | 210 450 914 | 0 900 1139 | 14 1125 239 | 689 674 435 | 675 1124 660 | 885 1349 1110 | 899 449 1335", + "midges": "119 232 | 217 457 | 105 907 | 7 1132 | 794 442 | 682 667 | 780 1117 | 892 1342 | 569 330 | 555 1019 | 1244 1005 | 1230 344", + "wings": { + "1": "1 1138 | 29 238 | 195 913 | 223 463 | 226 209 | 254 1140 | 420 659 | 448 884 | 451 211 | 479 240 | 645 1109 | 673 688 | 676 661 | 704 436 | 870 1111 | 898 1336 | 901 15 | 929 465 | 1095 1334 | 1123 690 | 1126 13 | 1154 915 | 1320 434 | 1348 886", + "2": "2 1137 | 44 237 | 180 912 | 222 462 | 227 194 | 269 1155 | 405 644 | 447 869 | 452 212 | 494 255 | 630 1094 | 672 687 | 677 662 | 719 437 | 855 1112 | 897 1337 | 902 30 | 944 480 | 1080 1319 | 1122 705 | 1127 12 | 1169 930 | 1305 419 | 1347 887", + "3": "3 1136 | 59 236 | 165 911 | 221 461 | 228 179 | 284 1170 | 390 629 | 446 854 | 453 213 | 509 270 | 615 1079 | 671 686 | 678 663 | 734 438 | 840 1113 | 896 1338 | 903 45 | 959 495 | 1065 1304 | 1121 720 | 1128 11 | 1184 945 | 1290 404 | 1346 888", + "4": "4 1135 | 74 235 | 150 910 | 220 460 | 229 164 | 299 1185 | 375 614 | 445 839 | 454 214 | 524 285 | 600 1064 | 670 685 | 679 664 | 749 439 | 825 1114 | 895 1339 | 904 60 | 974 510 | 1050 1289 | 1120 735 | 1129 10 | 1199 960 | 1275 389 | 1345 889", + "5": "5 1134 | 89 234 | 135 909 | 219 459 | 230 149 | 314 1200 | 360 599 | 444 824 | 455 215 | 539 300 | 585 1049 | 669 684 | 680 665 | 764 440 | 810 1115 | 894 1340 | 905 75 | 989 525 | 1035 1274 | 1119 750 | 1130 9 | 1214 975 | 1260 374 | 1344 890", + "6": "6 1133 | 104 233 | 120 908 | 218 458 | 231 134 | 329 1215 | 345 584 | 443 809 | 456 216 | 554 315 | 570 1034 | 668 683 | 681 666 | 779 441 | 795 1116 | 893 1341 | 906 90 | 1004 540 | 1020 1259 | 1118 765 | 1131 8 | 1229 990 | 1245 359 | 1343 891" + }, + "centers": "16 28 196 208 241 253 421 433 466 478 646 658 691 703 871 883 916 928 1096 1108 1141 1153 1321 1333 | 17 43 181 207 242 268 406 432 467 493 631 657 692 718 856 882 917 943 1081 1107 1142 1168 1306 1332 | 18 58 166 206 243 283 391 431 468 508 616 656 693 733 841 881 918 958 1066 1106 1143 1183 1291 1331 | 19 73 151 205 244 298 376 430 469 523 601 655 694 748 826 880 919 973 1051 1105 1144 1198 1276 1330 | 20 88 136 204 245 313 361 429 470 538 586 654 695 763 811 879 920 988 1036 1104 1145 1213 1261 1329 | 21 103 121 203 246 328 346 428 471 553 571 653 696 778 796 878 921 1003 1021 1103 1146 1228 1246 1328 | 22 106 118 202 247 331 343 427 472 556 568 652 697 781 793 877 922 1006 1018 1102 1147 1231 1243 1327 | 23 91 133 201 248 316 358 426 473 541 583 651 698 766 808 876 923 991 1033 1101 1148 1216 1258 1326 | 24 76 148 200 249 301 373 425 474 526 598 650 699 751 823 875 924 976 1048 1100 1149 1201 1273 1325 | 25 61 163 199 250 286 388 424 475 511 613 649 700 736 838 874 925 961 1063 1099 1150 1186 1288 1324 | 26 46 178 198 251 271 403 423 476 496 628 648 701 721 853 873 926 946 1078 1098 1151 1171 1303 1323 | 27 31 193 197 252 256 418 422 477 481 643 647 702 706 868 872 927 931 1093 1097 1152 1156 1318 1322 | 32 42 182 192 257 267 407 417 482 492 632 642 707 717 857 867 932 942 1082 1092 1157 1167 1307 1317 | 33 57 167 191 258 282 392 416 483 507 617 641 708 732 842 866 933 957 1067 1091 1158 1182 1292 1316 | 34 72 152 190 259 297 377 415 484 522 602 640 709 747 827 865 934 972 1052 1090 1159 1197 1277 1315 | 35 87 137 189 260 312 362 414 485 537 587 639 710 762 812 864 935 987 1037 1089 1160 1212 1262 1314 | 36 102 122 188 261 327 347 413 486 552 572 638 711 777 797 863 936 1002 1022 1088 1161 1227 1247 1313 | 37 107 117 187 262 332 342 412 487 557 567 637 712 782 792 862 937 1007 1017 1087 1162 1232 1242 1312 | 38 92 132 186 263 317 357 411 488 542 582 636 713 767 807 861 938 992 1032 1086 1163 1217 1257 1311 | 39 77 147 185 264 302 372 410 489 527 597 635 714 752 822 860 939 977 1047 1085 1164 1202 1272 1310 | 40 62 162 184 265 287 387 409 490 512 612 634 715 737 837 859 940 962 1062 1084 1165 1187 1287 1309 | 41 47 177 183 266 272 402 408 491 497 627 633 716 722 852 858 941 947 1077 1083 1166 1172 1302 1308 | 48 56 168 176 273 281 393 401 498 506 618 626 723 731 843 851 948 956 1068 1076 1173 1181 1293 1301 | 49 71 153 175 274 296 378 400 499 521 603 625 724 746 828 850 949 971 1053 1075 1174 1196 1278 1300 | 50 86 138 174 275 311 363 399 500 536 588 624 725 761 813 849 950 986 1038 1074 1175 1211 1263 1299 | 51 101 123 173 276 326 348 398 501 551 573 623 726 776 798 848 951 1001 1023 1073 1176 1226 1248 1298 | 52 108 116 172 277 333 341 397 502 558 566 622 727 783 791 847 952 1008 1016 1072 1177 1233 1241 1297 | 53 93 131 171 278 318 356 396 503 543 581 621 728 768 806 846 953 993 1031 1071 1178 1218 1256 1296 | 54 78 146 170 279 303 371 395 504 528 596 620 729 753 821 845 954 978 1046 1070 1179 1203 1271 1295 | 55 63 161 169 280 288 386 394 505 513 611 619 730 738 836 844 955 963 1061 1069 1180 1188 1286 1294 | 64 70 154 160 289 295 379 385 514 520 604 610 739 745 829 835 964 970 1054 1060 1189 1195 1279 1285 | 65 85 139 159 290 310 364 384 515 535 589 609 740 760 814 834 965 985 1039 1059 1190 1210 1264 1284 | 66 100 124 158 291 325 349 383 516 550 574 608 741 775 799 833 966 1000 1024 1058 1191 1225 1249 1283 | 67 109 115 157 292 334 340 382 517 559 565 607 742 784 790 832 967 1009 1015 1057 1192 1234 1240 1282 | 68 94 130 156 293 319 355 381 518 544 580 606 743 769 805 831 968 994 1030 1056 1193 1219 1255 1281 | 69 79 145 155 294 304 370 380 519 529 595 605 744 754 820 830 969 979 1045 1055 1194 1204 1270 1280 | 80 84 140 144 305 309 365 369 530 534 590 594 755 759 815 819 980 984 1040 1044 1205 1209 1265 1269 | 81 99 125 143 306 324 350 368 531 549 575 593 756 774 800 818 981 999 1025 1043 1206 1224 1250 1268 | 82 110 114 142 307 335 339 367 532 560 564 592 757 785 789 817 982 1010 1014 1042 1207 1235 1239 1267 | 83 95 129 141 308 320 354 366 533 545 579 591 758 770 804 816 983 995 1029 1041 1208 1220 1254 1266 | 96 98 126 128 321 323 351 353 546 548 576 578 771 773 801 803 996 998 1026 1028 1221 1223 1251 1253 | 97 111 113 127 322 336 338 352 547 561 563 577 772 786 788 802 997 1011 1013 1027 1222 1236 1238 1252" + } + }, + "rows": [ + { + "id": 0, + "moves": "", + "facelets": "UUUU RRRR FFFF DDDD LLLL BBBB", + "token": "AAAA", + "canonical": "" + }, + { + "id": 1, + "moves": "", + "facelets": "UUUU RRRR FFFF DDDD LLLL BBBB", + "token": "AAAAA", + "canonical": "" + }, + { + "id": 0, + "moves": "1R", + "facelets": "UFUF RRRR FDFD DBDB LLLL UBUB", + "token": "IbH7", + "canonical": "" + }, + { + "id": 1, + "moves": "1R", + "facelets": "UFUF RRRR FDFD DBDB LLLL UBUB", + "token": "CvX4t", + "canonical": "" + }, + { + "id": 0, + "moves": "1R2", + "facelets": "UDUD RRRR FBFB DUDU LLLL FBFB", + "token": "MdKn", + "canonical": "" + }, + { + "id": 1, + "moves": "1R2", + "facelets": "UDUD RRRR FBFB DUDU LLLL FBFB", + "token": "Et0L7", + "canonical": "" + }, + { + "id": 0, + "moves": "1R'", + "facelets": "UBUB RRRR FUFU DFDF LLLL DBDB", + "token": "GdeJ", + "canonical": "" + }, + { + "id": 1, + "moves": "1R'", + "facelets": "UBUB RRRR FUFU DFDF LLLL DBDB", + "token": "CF-f3", + "canonical": "" + }, + { + "id": 0, + "moves": "1U", + "facelets": "UUUU BBRR RRFF DDDD FFLL LLBB", + "token": "GAbw", + "canonical": "" + }, + { + "id": 1, + "moves": "1U", + "facelets": "UUUU BBRR RRFF DDDD FFLL LLBB", + "token": "B-JGw", + "canonical": "" + }, + { + "id": 0, + "moves": "1U2", + "facelets": "UUUU LLRR BBFF DDDD RRLL FFBB", + "token": "ErAQ", + "canonical": "" + }, + { + "id": 1, + "moves": "1U2", + "facelets": "UUUU LLRR BBFF DDDD RRLL FFBB", + "token": "BgG8A", + "canonical": "" + }, + { + "id": 0, + "moves": "1U'", + "facelets": "UUUU FFRR LLFF DDDD BBLL RRBB", + "token": "CZxg", + "canonical": "" + }, + { + "id": 1, + "moves": "1U'", + "facelets": "UUUU FFRR LLFF DDDD BBLL RRBB", + "token": "AxDio", + "canonical": "" + }, + { + "id": 0, + "moves": "1F", + "facelets": "UULL URUR FFFF RRDD LDLD BBBB", + "token": "DbA6", + "canonical": "" + }, + { + "id": 1, + "moves": "1F", + "facelets": "UULL URUR FFFF RRDD LDLD BBBB", + "token": "BDRwc", + "canonical": "" + }, + { + "id": 0, + "moves": "1F2", + "facelets": "UUDD LRLR FFFF UUDD LRLR BBBB", + "token": "LhL-", + "canonical": "" + }, + { + "id": 1, + "moves": "1F2", + "facelets": "UUDD LRLR FFFF UUDD LRLR BBBB", + "token": "Dst4y", + "canonical": "" + }, + { + "id": 0, + "moves": "1F'", + "facelets": "UURR DRDR FFFF LLDD LULU BBBB", + "token": "IGX8", + "canonical": "" + }, + { + "id": 1, + "moves": "1F'", + "facelets": "UURR DRDR FFFF LLDD LULU BBBB", + "token": "CpcVO", + "canonical": "" + }, + { + "id": 0, + "moves": "1L", + "facelets": "BUBU RRRR UFUF FDFD LLLL BDBD", + "token": "IbH7", + "canonical": "UFUF RRRR FDFD DBDB LLLL UBUB" + }, + { + "id": 1, + "moves": "1L", + "facelets": "BUBU RRRR UFUF FDFD LLLL BDBD", + "token": "AKRCu", + "canonical": "" + }, + { + "id": 0, + "moves": "1L2", + "facelets": "DUDU RRRR BFBF UDUD LLLL BFBF", + "token": "MdKn", + "canonical": "UDUD RRRR FBFB DUDU LLLL FBFB" + }, + { + "id": 1, + "moves": "1L2", + "facelets": "DUDU RRRR BFBF UDUD LLLL BFBF", + "token": "Aijj6", + "canonical": "" + }, + { + "id": 0, + "moves": "1L'", + "facelets": "FUFU RRRR DFDF BDBD LLLL BUBU", + "token": "GdeJ", + "canonical": "UBUB RRRR FUFU DFDF LLLL DBDB" + }, + { + "id": 1, + "moves": "1L'", + "facelets": "FUFU RRRR DFDF BDBD LLLL BUBU", + "token": "AYTH0", + "canonical": "" + }, + { + "id": 0, + "moves": "1D", + "facelets": "UUUU RRFF FFLL DDDD LLBB BBRR", + "token": "GAbw", + "canonical": "UUUU BBRR RRFF DDDD FFLL LLBB" + }, + { + "id": 1, + "moves": "1D", + "facelets": "UUUU RRFF FFLL DDDD LLBB BBRR", + "token": "AAEzj", + "canonical": "" + }, + { + "id": 0, + "moves": "1D2", + "facelets": "UUUU RRLL FFBB DDDD LLRR BBFF", + "token": "ErAQ", + "canonical": "UUUU LLRR BBFF DDDD RRLL FFBB" + }, + { + "id": 1, + "moves": "1D2", + "facelets": "UUUU RRLL FFBB DDDD LLRR BBFF", + "token": "AAIiw", + "canonical": "" + }, + { + "id": 0, + "moves": "1D'", + "facelets": "UUUU RRBB FFRR DDDD LLFF BBLL", + "token": "CZxg", + "canonical": "UUUU FFRR LLFF DDDD BBLL RRBB" + }, + { + "id": 1, + "moves": "1D'", + "facelets": "UUUU RRBB FFRR DDDD LLFF BBLL", + "token": "AAJnG", + "canonical": "" + }, + { + "id": 0, + "moves": "1B", + "facelets": "RRUU RDRD FFFF DDLL ULUL BBBB", + "token": "DbA6", + "canonical": "UULL URUR FFFF RRDD LDLD BBBB" + }, + { + "id": 1, + "moves": "1B", + "facelets": "RRUU RDRD FFFF DDLL ULUL BBBB", + "token": "AB3-R", + "canonical": "" + }, + { + "id": 0, + "moves": "1B2", + "facelets": "DDUU RLRL FFFF DDUU RLRL BBBB", + "token": "LhL-", + "canonical": "UUDD LRLR FFFF UUDD LRLR BBBB" + }, + { + "id": 1, + "moves": "1B2", + "facelets": "DDUU RLRL FFFF DDUU RLRL BBBB", + "token": "AF8sj", + "canonical": "" + }, + { + "id": 0, + "moves": "1B'", + "facelets": "LLUU RURU FFFF DDRR DLDL BBBB", + "token": "IGX8", + "canonical": "UURR DRDR FFFF LLDD LULU BBBB" + }, + { + "id": 1, + "moves": "1B'", + "facelets": "LLUU RURU FFFF DDRR DLDL BBBB", + "token": "AEFd0", + "canonical": "" + }, + { + "id": 0, + "moves": "x", + "facelets": "FFFF RRRR DDDD BBBB LLLL UUUU", + "token": "AAAA", + "canonical": "UUUU RRRR FFFF DDDD LLLL BBBB" + }, + { + "id": 1, + "moves": "x", + "facelets": "FFFF RRRR DDDD BBBB LLLL UUUU", + "token": "DBaBc", + "canonical": "" + }, + { + "id": 0, + "moves": "x2", + "facelets": "DDDD RRRR BBBB UUUU LLLL FFFF", + "token": "AAAA", + "canonical": "UUUU RRRR FFFF DDDD LLLL BBBB" + }, + { + "id": 1, + "moves": "x2", + "facelets": "DDDD RRRR BBBB UUUU LLLL FFFF", + "token": "FQXv1", + "canonical": "" + }, + { + "id": 0, + "moves": "x'", + "facelets": "BBBB RRRR UUUU FFFF LLLL DDDD", + "token": "AAAA", + "canonical": "UUUU RRRR FFFF DDDD LLLL BBBB" + }, + { + "id": 1, + "moves": "x'", + "facelets": "BBBB RRRR UUUU FFFF LLLL DDDD", + "token": "CO-Yd", + "canonical": "" + }, + { + "id": 0, + "moves": "y", + "facelets": "UUUU BBBB RRRR DDDD FFFF LLLL", + "token": "AAAA", + "canonical": "UUUU RRRR FFFF DDDD LLLL BBBB" + }, + { + "id": 1, + "moves": "y", + "facelets": "UUUU BBBB RRRR DDDD FFFF LLLL", + "token": "B-St2", + "canonical": "" + }, + { + "id": 0, + "moves": "y2", + "facelets": "UUUU LLLL BBBB DDDD RRRR FFFF", + "token": "AAAA", + "canonical": "UUUU RRRR FFFF DDDD LLLL BBBB" + }, + { + "id": 1, + "moves": "y2", + "facelets": "UUUU LLLL BBBB DDDD RRRR FFFF", + "token": "BgPew", + "canonical": "" + }, + { + "id": 0, + "moves": "y'", + "facelets": "UUUU FFFF LLLL DDDD BBBB RRRR", + "token": "AAAA", + "canonical": "UUUU RRRR FFFF DDDD LLLL BBBB" + }, + { + "id": 1, + "moves": "y'", + "facelets": "UUUU FFFF LLLL DDDD BBBB RRRR", + "token": "AxIWL", + "canonical": "" + }, + { + "id": 0, + "moves": "z", + "facelets": "LLLL UUUU FFFF RRRR DDDD BBBB", + "token": "AAAA", + "canonical": "UUUU RRRR FFFF DDDD LLLL BBBB" + }, + { + "id": 1, + "moves": "z", + "facelets": "LLLL UUUU FFFF RRRR DDDD BBBB", + "token": "BGT8m", + "canonical": "" + }, + { + "id": 0, + "moves": "z2", + "facelets": "DDDD LLLL FFFF UUUU RRRR BBBB", + "token": "AAAA", + "canonical": "UUUU RRRR FFFF DDDD LLLL BBBB" + }, + { + "id": 1, + "moves": "z2", + "facelets": "DDDD LLLL FFFF UUUU RRRR BBBB", + "token": "DwIRF", + "canonical": "" + }, + { + "id": 0, + "moves": "z'", + "facelets": "RRRR DDDD FFFF LLLL UUUU BBBB", + "token": "AAAA", + "canonical": "UUUU RRRR FFFF DDDD LLLL BBBB" + }, + { + "id": 1, + "moves": "z'", + "facelets": "RRRR DDDD FFFF LLLL UUUU BBBB", + "token": "CrGbB", + "canonical": "" + }, + { + "id": 0, + "moves": "2U2 2F 2D' 1F' 2D' 1U' 2F' 2F 2L 1F2 1B' x' 1L 2F", + "facelets": "DFDL UDUR RFFF DRLB BBUL RLUB", + "token": "AxRF", + "canonical": "LDBR FFFR RUDU FLDD BULR LUBB" + }, + { + "id": 1, + "moves": "2U2 2F 2D' 1F' 2D' 1U' 2F' 2F 2L 1F2 1B' x' 1L 2F", + "facelets": "DFDL UDUR RFFF DRLB BBUL RLUB", + "token": "BTu_H", + "canonical": "" + }, + { + "id": 0, + "moves": "2D 2F 2B' 2L' 1R 2U2 2R2 2U2 1D 2R 2F 2B x2 1L'", + "facelets": "DBBU FDRR ULUB RURF LLDF LFDB", + "token": "B9km", + "canonical": "LLDF UUBL RRFU RRDF FBLD BDUB" + }, + { + "id": 1, + "moves": "2D 2F 2B' 2L' 1R 2U2 2R2 2U2 1D 2R 2F 2B x2 1L'", + "facelets": "DBBU FDRR ULUB RURF LLDF LFDB", + "token": "AzuWu", + "canonical": "" + }, + { + "id": 0, + "moves": "1D z2 1L2 1L 2U' 2F' 2L' y2 2B' 2R2 2L 1B2 z' 2R'", + "facelets": "DFFL DLRF LBRB FUBD RULU DBRU", + "token": "FwCr", + "canonical": "UURL BFDU BUDR LFDR FDLF RLBB" + }, + { + "id": 1, + "moves": "1D z2 1L2 1L 2U' 2F' 2L' y2 2B' 2R2 2L 1B2 z' 2R'", + "facelets": "DFFL DLRF LBRB FUBD RULU DBRU", + "token": "EIM6q", + "canonical": "" + }, + { + "id": 0, + "moves": "2L 2B' 1B2 1F2 1L 1D' 1F' 1F 2R y' 1L 2D 1D 2B2", + "facelets": "RDRR BFFR DDBU LLUB FFBD LUUL", + "token": "LIXH", + "canonical": "FBRF DRRR ULLU BFDF LBLU DUDB" + }, + { + "id": 1, + "moves": "2L 2B' 1B2 1F2 1L 1D' 1F' 1F 2R y' 1L 2D 1D 2B2", + "facelets": "RDRR BFFR DDBU LLUB FFBD LUUL", + "token": "E-_pP", + "canonical": "" + }, + { + "id": 2, + "moves": "", + "facelets": "UUUUUUUUU RRRRRRRRR FFFFFFFFF DDDDDDDDD LLLLLLLLL BBBBBBBBB", + "token": "AAAAAAAAAAA", + "canonical": "" + }, + { + "id": 3, + "moves": "", + "facelets": "UUUUUUUUU RRRRRRRRR FFFFFFFFF DDDDDDDDD LLLLLLLLL BBBBBBBBB", + "token": "AAAAAAAAAAAA", + "canonical": "" + }, + { + "id": 2, + "moves": "1R", + "facelets": "UUFUUFUUF RRRRRRRRR FFDFFDFFD DDBDDBDDB LLLLLLLLL UBBUBBUBB", + "token": "TjwgiBcKmAA", + "canonical": "" + }, + { + "id": 3, + "moves": "1R", + "facelets": "UUFUUFUUF RRRRRRRRR FFDFFDFFD DDBDDBDDB LLLLLLLLL UBBUBBUBB", + "token": "HVaMMwij-QAA", + "canonical": "" + }, + { + "id": 2, + "moves": "1R2", + "facelets": "UUDUUDUUD RRRRRRRRR FFBFFBFFB DDUDDUDDU LLLLLLLLL FBBFBBFBB", + "token": "hqQwhPTuFAA", + "canonical": "" + }, + { + "id": 3, + "moves": "1R2", + "facelets": "UUDUUDUUD RRRRRRRRR FFBFFBFFB DDUDDUDDU LLLLLLLLL FBBFBBFBB", + "token": "Mn2SMdvZR4AA", + "canonical": "" + }, + { + "id": 2, + "moves": "1R'", + "facelets": "UUBUUBUUB RRRRRRRRR FFUFFUFFU DDFDDFDDF LLLLLLLLL DBBDBBDBB", + "token": "O8SBgdT6MgA", + "canonical": "" + }, + { + "id": 3, + "moves": "1R'", + "facelets": "UUBUUBUUB RRRRRRRRR FFUFFUFFU DDFDDFDDF LLLLLLLLL DBBDBBDBB", + "token": "FmmwkK_d0sAA", + "canonical": "" + }, + { + "id": 2, + "moves": "2R", + "facelets": "UFUUFUUFU RRRRRRRRR FDFFDFFDF DBDDBDDBD LLLLLLLLL BUBBUBBUB", + "token": "P8ggFPdjyAA", + "canonical": "BUBBUBBUB RRRRRRRRR UFUUFUUFU FDFFDFFDF LLLLLLLLL DBDDBDDBD" + }, + { + "id": 3, + "moves": "2R", + "facelets": "UFUUFUUFU RRRRRRRRR FDFFDFFDF DBDDBDDBD LLLLLLLLL BUBBUBBUB", + "token": "F-sMB9zFawAE", + "canonical": "" + }, + { + "id": 2, + "moves": "2R2", + "facelets": "UDUUDUUDU RRRRRRRRR FBFFBFFBF DUDDUDDUD LLLLLLLLL BFBBFBBFB", + "token": "lg6LFdRC5gA", + "canonical": "DUDDUDDUD RRRRRRRRR BFBBFBBFB UDUUDUUDU LLLLLLLLL FBFFBFFBF" + }, + { + "id": 3, + "moves": "2R2", + "facelets": "UDUUDUUDU RRRRRRRRR FBFFBFFBF DUDDUDDUD LLLLLLLLL BFBBFBBFB", + "token": "OEV0KC-ZFkAI", + "canonical": "" + }, + { + "id": 2, + "moves": "2R'", + "facelets": "UBUUBUUBU RRRRRRRRR FUFFUFFUF DFDDFDDFD LLLLLLLLL BDBBDBBDB", + "token": "VkeXX5MpiAA", + "canonical": "FUFFUFFUF RRRRRRRRR DFDDFDDFD BDBBDBBDB LLLLLLLLL UBUUBUUBU" + }, + { + "id": 3, + "moves": "2R'", + "facelets": "UBUUBUUBU RRRRRRRRR FUFFUFFUF DFDDFDDFD LLLLLLLLL BDBBDBBDB", + "token": "IFrYw9cvkwAM", + "canonical": "" + }, + { + "id": 2, + "moves": "1U", + "facelets": "UUUUUUUUU BBBRRRRRR RRRFFFFFF DDDDDDDDD FFFLLLLLL LLLBBBBBB", + "token": "OEXPosx_AAA", + "canonical": "" + }, + { + "id": 3, + "moves": "1U", + "facelets": "UUUUUUUUU BBBRRRRRR RRRFFFFFF DDDDDDDDD FFFLLLLLL LLLBBBBBB", + "token": "FRot3QyvoAAA", + "canonical": "" + }, + { + "id": 2, + "moves": "1U2", + "facelets": "UUUUUUUUU LLLRRRRRR BBBFFFFFF DDDDDDDDD RRRLLLLLL FFFBBBBBB", + "token": "Kt_bJnToAAA", + "canonical": "" + }, + { + "id": 3, + "moves": "1U2", + "facelets": "UUUUUUUUU LLLRRRRRR BBBFFFFFF DDDDDDDDD RRRLLLLLL FFFBBBBBB", + "token": "EBPyLmvXAAAA", + "canonical": "" + }, + { + "id": 2, + "moves": "1U'", + "facelets": "UUUUUUUUU FFFRRRRRR LLLFFFFFF DDDDDDDDD BBBLLLLLL RRRBBBBBB", + "token": "FeJChkNdgAA", + "canonical": "" + }, + { + "id": 3, + "moves": "1U'", + "facelets": "UUUUUUUUU FFFRRRRRR LLLFFFFFF DDDDDDDDD BBBLLLLLL RRRBBBBBB", + "token": "CDTY8llDEAAA", + "canonical": "" + }, + { + "id": 2, + "moves": "2U", + "facelets": "UUUUUUUUU RRRBBBRRR FFFRRRFFF DDDDDDDDD LLLFFFLLL BBBLLLBBB", + "token": "FerVshboeAA", + "canonical": "UUUUUUUUU FFFRRRFFF LLLFFFLLL DDDDDDDDD BBBLLLBBB RRRBBBRRR" + }, + { + "id": 3, + "moves": "2U", + "facelets": "UUUUUUUUU RRRBBBRRR FFFRRRFFF DDDDDDDDD LLLFFFLLL BBBLLLBBB", + "token": "CDgQIsiXLQAB", + "canonical": "" + }, + { + "id": 2, + "moves": "2U2", + "facelets": "UUUUUUUUU RRRLLLRRR FFFBBBFFF DDDDDDDDD LLLRRRLLL BBBFFFBBB", + "token": "Ku8ZrUJVAAA", + "canonical": "UUUUUUUUU LLLRRRLLL BBBFFFBBB DDDDDDDDD RRRLLLRRR FFFBBBFFF" + }, + { + "id": 3, + "moves": "2U2", + "facelets": "UUUUUUUUU RRRLLLRRR FFFBBBFFF DDDDDDDDD LLLRRRLLL BBBFFFBBB", + "token": "EBmpoPjf4AAC", + "canonical": "" + }, + { + "id": 2, + "moves": "2U'", + "facelets": "UUUUUUUUU RRRFFFRRR FFFLLLFFF DDDDDDDDD LLLBBBLLL BBBRRRBBB", + "token": "OFb1-nOiEAA", + "canonical": "UUUUUUUUU BBBRRRBBB RRRFFFRRR DDDDDDDDD FFFLLLFFF LLLBBBLLL" + }, + { + "id": 3, + "moves": "2U'", + "facelets": "UUUUUUUUU RRRFFFRRR FFFLLLFFF DDDDDDDDD LLLBBBLLL BBBRRRBBB", + "token": "FSCcPetcxgAD", + "canonical": "" + }, + { + "id": 2, + "moves": "1F", + "facelets": "UUUUUULLL URRURRURR FFFFFFFFF RRRDDDDDD LLDLLDLLD BBBBBBBBB", + "token": "HgNHWLzPEMi", + "canonical": "" + }, + { + "id": 3, + "moves": "1F", + "facelets": "UUUUUULLL URRURRURR FFFFFFFFF RRRDDDDDD LLDLLDLLD BBBBBBBBB", + "token": "C0E6wUbNpksw", + "canonical": "" + }, + { + "id": 2, + "moves": "1F2", + "facelets": "UUUUUUDDD LRRLRRLRR FFFFFFFFF UUUDDDDDD LLRLLRLLR BBBBBBBBB", + "token": "aZnDDvTutgA", + "canonical": "" + }, + { + "id": 3, + "moves": "1F2", + "facelets": "UUUUUUDDD LRRLRRLRR FFFFFFFFF UUUDDDDDD LLRLLRLLR BBBBBBBBB", + "token": "J5mpJZvZhEAA", + "canonical": "" + }, + { + "id": 2, + "moves": "1F'", + "facelets": "UUUUUURRR DRRDRRDRR FFFFFFFFF LLLDDDDDD LLULLULLU BBBBBBBBB", + "token": "S5bXnmqoFsi", + "canonical": "" + }, + { + "id": 3, + "moves": "1F'", + "facelets": "UUUUUURRR DRRDRRDRR FFFFFFFFF LLLDDDDDD LLULLULLU BBBBBBBBB", + "token": "HFiQ22f_CIsw", + "canonical": "" + }, + { + "id": 2, + "moves": "2F", + "facelets": "UUULLLUUU RURRURRUR FFFFFFFFF DDDRRRDDD LDLLDLLDL BBBBBBBBB", + "token": "TFQnBEBBxeq", + "canonical": "RRRUUURRR DRDDRDDRD FFFFFFFFF LLLDDDLLL ULUULUULU BBBBBBBBB" + }, + { + "id": 3, + "moves": "2F", + "facelets": "UUULLLUUU RURRURRUR FFFFFFFFF DDDRRRDDD LDLLDLLDL BBBBBBBBB", + "token": "HJ-OoZgYqjgA", + "canonical": "" + }, + { + "id": 2, + "moves": "2F2", + "facelets": "UUUDDDUUU RLRRLRRLR FFFFFFFFF DDDUUUDDD LRLLRLLRL BBBBBBBBB", + "token": "ax9xZNWPXgA", + "canonical": "DDDUUUDDD LRLLRLLRL FFFFFFFFF UUUDDDUUU RLRRLRRLR BBBBBBBBB" + }, + { + "id": 3, + "moves": "2F2", + "facelets": "UUUDDDUUU RLRRLRRLR FFFFFFFFF DDDUUUDDD LRLLRLLRL BBBBBBBBB", + "token": "KCvKhdAVw0AK", + "canonical": "" + }, + { + "id": 2, + "moves": "2F'", + "facelets": "UUURRRUUU RDRRDRRDR FFFFFFFFF DDDLLLDDD LULLULLUL BBBBBBBBB", + "token": "H13LjLZvO-q", + "canonical": "LLLUUULLL URUURUURU FFFFFFFFF RRRDDDRRR DLDDLDDLD BBBBBBBBB" + }, + { + "id": 3, + "moves": "2F'", + "facelets": "UUURRRUUU RDRRDRRDR FFFFFFFFF DDDLLLDDD LULLULLUL BBBBBBBBB", + "token": "C8MsVMRptngE", + "canonical": "" + }, + { + "id": 2, + "moves": "1L", + "facelets": "BUUBUUBUU RRRRRRRRR UFFUFFUFF FDDFDDFDD LLLLLLLLL BBDBBDBBD", + "token": "BJRwk8BKHAA", + "canonical": "" + }, + { + "id": 3, + "moves": "1L", + "facelets": "BUUBUUBUU RRRRRRRRR UFFUFFUFF FDDFDDFDD LLLLLLLLL BBDBBDBBD", + "token": "AbeqN2gbyoAA", + "canonical": "" + }, + { + "id": 2, + "moves": "1L2", + "facelets": "DUUDUUDUU RRRRRRRRR BFFBFFBFF UDDUDDUDD LLLLLLLLL BBFBBFBBF", + "token": "D2pakOTyAgA", + "canonical": "" + }, + { + "id": 3, + "moves": "1L2", + "facelets": "DUUDUUDUU RRRRRRRRR BFFBFFBFF UDDUDDUDD LLLLLLLLL BBFBBFBBF", + "token": "Bcfh9lXawMAA", + "canonical": "" + }, + { + "id": 2, + "moves": "1L'", + "facelets": "FUUFUUFUU RRRRRRRRR DFFDFFDFF BDDBDDBDD LLLLLLLLL BBUBBUBBU", + "token": "Ctb9rsOongA", + "canonical": "" + }, + { + "id": 3, + "moves": "1L'", + "facelets": "FUUFUUFUU RRRRRRRRR DFFDFFDFF BDDBDDBDD LLLLLLLLL BBUBBUBBU", + "token": "BBCfIYlfO0AA", + "canonical": "" + }, + { + "id": 2, + "moves": "1D", + "facelets": "UUUUUUUUU RRRRRRFFF FFFFFFLLL DDDDDDDDD LLLLLLBBB BBBBBBRRR", + "token": "AAiTK9OK-AA", + "canonical": "" + }, + { + "id": 3, + "moves": "1D", + "facelets": "UUUUUUUUU RRRRRRFFF FFFFFFLLL DDDDDDDDD LLLLLLBBB BBBBBBRRR", + "token": "AAM3MG9UHQAA", + "canonical": "" + }, + { + "id": 2, + "moves": "1D2", + "facelets": "UUUUUUUUU RRRRRRLLL FFFFFFBBB DDDDDDDDD LLLLLLRRR BBBBBBFFF", + "token": "AA8-hs1tAAA", + "canonical": "" + }, + { + "id": 3, + "moves": "1D2", + "facelets": "UUUUUUUUU RRRRRRLLL FFFFFFBBB DDDDDDDDD LLLLLLRRR BBBBBBFFF", + "token": "AAW3co0I4AAA", + "canonical": "" + }, + { + "id": 2, + "moves": "1D'", + "facelets": "UUUUUUUUU RRRRRRBBB FFFFFFRRR DDDDDDDDD LLLLLLFFF BBBBBBLLL", + "token": "ABEmV6cjEAA", + "canonical": "" + }, + { + "id": 3, + "moves": "1D'", + "facelets": "UUUUUUUUU RRRRRRBBB FFFFFFRRR DDDDDDDDD LLLLLLFFF BBBBBBLLL", + "token": "AAZuYN6tJgAA", + "canonical": "" + }, + { + "id": 2, + "moves": "1B", + "facelets": "RRRUUUUUU RRDRRDRRD FFFFFFFFF DDDDDDLLL ULLULLULL BBBBBBBBB", + "token": "ANYVAOO_aSI", + "canonical": "" + }, + { + "id": 3, + "moves": "1B", + "facelets": "RRRUUUUUU RRDRRDRRD FFFFFFFFF DDDDDDLLL ULLULLULL BBBBBBBBB", + "token": "AFBH4FVnx2zA", + "canonical": "" + }, + { + "id": 2, + "moves": "1B2", + "facelets": "DDDUUUUUU RRLRRLRRL FFFFFFFFF DDDDDDUUU RLLRLLRLL BBBBBBBBB", + "token": "AqdSVx0A-AA", + "canonical": "" + }, + { + "id": 3, + "moves": "1B2", + "facelets": "DDDUUUUUU RRLRRLRRL FFFFFFFFF DDDDDDUUU RLLRLLRLL BBBBBBBBB", + "token": "AP6-4KrgXQAA", + "canonical": "" + }, + { + "id": 2, + "moves": "1B'", + "facelets": "LLLUUUUUU RRURRURRU FFFFFFFFF DDDDDDRRR DLLDLLDLL BBBBBBBBB", + "token": "AdKQmYqV6SI", + "canonical": "" + }, + { + "id": 3, + "moves": "1B'", + "facelets": "LLLUUUUUU RRURRURRU FFFFFFFFF DDDDDDRRR DLLDLLDLL BBBBBBBBB", + "token": "AK72OZP4N2zA", + "canonical": "" + }, + { + "id": 2, + "moves": "x", + "facelets": "FFFFFFFFF RRRRRRRRR DDDDDDDDD BBBBBBBBB LLLLLLLLL UUUUUUUUU", + "token": "AAAAAAAAAAA", + "canonical": "UUUUUUUUU RRRRRRRRR FFFFFFFFF DDDDDDDDD LLLLLLLLL BBBBBBBBB" + }, + { + "id": 3, + "moves": "x", + "facelets": "FFFFFFFFF RRRRRRRRR DDDDDDDDD BBBBBBBBB LLLLLLLLL UUUUUUUUU", + "token": "AAAAAAAAAAAE", + "canonical": "" + }, + { + "id": 2, + "moves": "x2", + "facelets": "DDDDDDDDD RRRRRRRRR BBBBBBBBB UUUUUUUUU LLLLLLLLL FFFFFFFFF", + "token": "AAAAAAAAAAA", + "canonical": "UUUUUUUUU RRRRRRRRR FFFFFFFFF DDDDDDDDD LLLLLLLLL BBBBBBBBB" + }, + { + "id": 3, + "moves": "x2", + "facelets": "DDDDDDDDD RRRRRRRRR BBBBBBBBB UUUUUUUUU LLLLLLLLL FFFFFFFFF", + "token": "AAAAAAAAAAAI", + "canonical": "" + }, + { + "id": 2, + "moves": "x'", + "facelets": "BBBBBBBBB RRRRRRRRR UUUUUUUUU FFFFFFFFF LLLLLLLLL DDDDDDDDD", + "token": "AAAAAAAAAAA", + "canonical": "UUUUUUUUU RRRRRRRRR FFFFFFFFF DDDDDDDDD LLLLLLLLL BBBBBBBBB" + }, + { + "id": 3, + "moves": "x'", + "facelets": "BBBBBBBBB RRRRRRRRR UUUUUUUUU FFFFFFFFF LLLLLLLLL DDDDDDDDD", + "token": "AAAAAAAAAAAM", + "canonical": "" + }, + { + "id": 2, + "moves": "y", + "facelets": "UUUUUUUUU BBBBBBBBB RRRRRRRRR DDDDDDDDD FFFFFFFFF LLLLLLLLL", + "token": "AAAAAAAAAAA", + "canonical": "UUUUUUUUU RRRRRRRRR FFFFFFFFF DDDDDDDDD LLLLLLLLL BBBBBBBBB" + }, + { + "id": 3, + "moves": "y", + "facelets": "UUUUUUUUU BBBBBBBBB RRRRRRRRR DDDDDDDDD FFFFFFFFF LLLLLLLLL", + "token": "AAAAAAAAAAAB", + "canonical": "" + }, + { + "id": 2, + "moves": "y2", + "facelets": "UUUUUUUUU LLLLLLLLL BBBBBBBBB DDDDDDDDD RRRRRRRRR FFFFFFFFF", + "token": "AAAAAAAAAAA", + "canonical": "UUUUUUUUU RRRRRRRRR FFFFFFFFF DDDDDDDDD LLLLLLLLL BBBBBBBBB" + }, + { + "id": 3, + "moves": "y2", + "facelets": "UUUUUUUUU LLLLLLLLL BBBBBBBBB DDDDDDDDD RRRRRRRRR FFFFFFFFF", + "token": "AAAAAAAAAAAC", + "canonical": "" + }, + { + "id": 2, + "moves": "y'", + "facelets": "UUUUUUUUU FFFFFFFFF LLLLLLLLL DDDDDDDDD BBBBBBBBB RRRRRRRRR", + "token": "AAAAAAAAAAA", + "canonical": "UUUUUUUUU RRRRRRRRR FFFFFFFFF DDDDDDDDD LLLLLLLLL BBBBBBBBB" + }, + { + "id": 3, + "moves": "y'", + "facelets": "UUUUUUUUU FFFFFFFFF LLLLLLLLL DDDDDDDDD BBBBBBBBB RRRRRRRRR", + "token": "AAAAAAAAAAAD", + "canonical": "" + }, + { + "id": 2, + "moves": "z", + "facelets": "LLLLLLLLL UUUUUUUUU FFFFFFFFF RRRRRRRRR DDDDDDDDD BBBBBBBBB", + "token": "AAAAAAAAAAA", + "canonical": "UUUUUUUUU RRRRRRRRR FFFFFFFFF DDDDDDDDD LLLLLLLLL BBBBBBBBB" + }, + { + "id": 3, + "moves": "z", + "facelets": "LLLLLLLLL UUUUUUUUU FFFFFFFFF RRRRRRRRR DDDDDDDDD BBBBBBBBB", + "token": "AAAAAAAAAAAQ", + "canonical": "" + }, + { + "id": 2, + "moves": "z2", + "facelets": "DDDDDDDDD LLLLLLLLL FFFFFFFFF UUUUUUUUU RRRRRRRRR BBBBBBBBB", + "token": "AAAAAAAAAAA", + "canonical": "UUUUUUUUU RRRRRRRRR FFFFFFFFF DDDDDDDDD LLLLLLLLL BBBBBBBBB" + }, + { + "id": 3, + "moves": "z2", + "facelets": "DDDDDDDDD LLLLLLLLL FFFFFFFFF UUUUUUUUU RRRRRRRRR BBBBBBBBB", + "token": "AAAAAAAAAAAK", + "canonical": "" + }, + { + "id": 2, + "moves": "z'", + "facelets": "RRRRRRRRR DDDDDDDDD FFFFFFFFF LLLLLLLLL UUUUUUUUU BBBBBBBBB", + "token": "AAAAAAAAAAA", + "canonical": "UUUUUUUUU RRRRRRRRR FFFFFFFFF DDDDDDDDD LLLLLLLLL BBBBBBBBB" + }, + { + "id": 3, + "moves": "z'", + "facelets": "RRRRRRRRR DDDDDDDDD FFFFFFFFF LLLLLLLLL UUUUUUUUU BBBBBBBBB", + "token": "AAAAAAAAAAAU", + "canonical": "" + }, + { + "id": 2, + "moves": "1U 3R 3D' 3B2 1L 2L 1F' z2 1F' 3F 1D2 1R' 1B x'", + "facelets": "FDBBDDFUF LFUBLLDRL RLUDFULLB FFRUUFUBB URDFRRBRD RBRDBUDLL", + "token": "cFv1lSCPdgA", + "canonical": "BBUFUURFF DRBRRFDRU BLLUFDULR FUFDDBBDF LRDLLBUFL LLDUBDRBR" + }, + { + "id": 3, + "moves": "1U 3R 3D' 3B2 1L 2L 1F' z2 1F' 3F 1D2 1R' 1B x'", + "facelets": "FDBBDDFUF LFUBLLDRL RLUDFULLB FFRUUFUBB URDFRRBRD RBRDBUDLL", + "token": "KiJ8F-w1zEAK", + "canonical": "" + }, + { + "id": 2, + "moves": "2R2 z2 1U' 2R 3B2 1R' x2 2R' 2B x' 1L' 3D 2F2 2D'", + "facelets": "DUUUFRDRU BUFFRFBDL FFRBDULDR DBDFBRULU LLRBLLLDB RBFLURBDF", + "token": "CriM-9rfeUH", + "canonical": "FDBRULFBR FFLURDBFB DUUUFRDRU FFRBDULDR LBLDLLBLR ULURBFDBD" + }, + { + "id": 3, + "moves": "2R2 z2 1U' 2R 3B2 1R' x2 2R' 2B x' 1L' 3D 2F2 2D'", + "facelets": "DUUUFRDRU BUFFRFBDL FFRBDULDR DBDFBRULU LLRBLLLDB RBFLURBDF", + "token": "BAU03nITzXis", + "canonical": "" + }, + { + "id": 2, + "moves": "2L2 2B' 1U2 1D2 3F 2D' 1B2 2B 1R' 1B 1D2 3U 3B' 2F2", + "facelets": "DRLUBBFFR UUBDLLFLU LRBLDFRDL BRDLFDUDB FFURRUFFD DURBUBLBR", + "token": "BLvl10mIH3S", + "canonical": "DURBUBLBR FRFFRFDUU BDUDFLDRB LDRFDLBRL BLUULLUDF DRLUBBFFR" + }, + { + "id": 3, + "moves": "2L2 2B' 1U2 1D2 3F 2D' 1B2 2B 1R' 1B 1D2 3U 3B' 2F2", + "facelets": "DRLUBBFFR UUBDLLFLU LRBLDFRDL BRDLFDUDB FFURRUFFD DURBUBLBR", + "token": "AcZ2MLuTC8u-", + "canonical": "" + }, + { + "id": 2, + "moves": "1D' y' 1F' 2B2 2F2 2U' 3B' 2U2 3B' 1F' 1U' 2F x2 2L'", + "facelets": "DBDRBBDFD RRRBURLUL BUBLLLFUF UBULFRUUU LDLFDFRDR FDFFRDBLB", + "token": "KqKDTiFgqYZ", + "canonical": "RRRBURLUL BFFLRDBDF URUBFUULU RDRFDFLDL BLFULUBLF DBDBBFDRD" + }, + { + "id": 3, + "moves": "1D' y' 1F' 2B2 2F2 2U' 3B' 2U2 3B' 1F' 1U' 2F x2 2L'", + "facelets": "DBDRBBDFD RRRBURLUL BUBLLLFUF UBULFRUUU LDLFDFRDR FDFFRDBLB", + "token": "D_zxPUyEP5Jn", + "canonical": "" + }, + { + "id": 6, + "moves": "", + "facelets": "UUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "" + }, + { + "id": 7, + "moves": "", + "facelets": "UUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "" + }, + { + "id": 6, + "moves": "1R", + "facelets": "UUUFUUUFUUUFUUUF RRRRRRRRRRRRRRRR FFFDFFFDFFFDFFFD DDDBDDDBDDDBDDDB LLLLLLLLLLLLLLLL UBBBUBBBUBBBUBBB", + "token": "DHd8Zq61D4d6_3mi7MvVxKsg6A", + "canonical": "" + }, + { + "id": 7, + "moves": "1R", + "facelets": "UUUFUUUFUUUFUUUF RRRRRRRRRRRRRRRR FFFDFFFDFFFDFFFD DDDBDDDBDDDBDDDB LLLLLLLLLLLLLLLL UBBBUBBBUBBBUBBB", + "token": "BA4rDnv8rAurNNJNm7a3tPSsg6A", + "canonical": "" + }, + { + "id": 6, + "moves": "1R2", + "facelets": "UUUDUUUDUUUDUUUD RRRRRRRRRRRRRRRR FFFBFFFBFFFBFFFB DDDUDDDUDDDUDDDU LLLLLLLLLLLLLLLL FBBBFBBBFBBBFBBB", + "token": "Em8IqRljf-e5wFFPJLcLwEry6A", + "canonical": "" + }, + { + "id": 7, + "moves": "1R2", + "facelets": "UUUDUUUDUUUDUUUD RRRRRRRRRRRRRRRR FFFBFFFBFFFBFFFB DDDUDDDUDDDUDDDU LLLLLLLLLLLLLLLL FBBBFBBBFBBBFBBB", + "token": "BvqtHHxqzNGJsKBrZL8fWTUry6A", + "canonical": "" + }, + { + "id": 6, + "moves": "1R'", + "facelets": "UUUBUUUBUUUBUUUB RRRRRRRRRRRRRRRR FFFUFFFUFFFUFFFU DDDFDDDFDDDFDDDF LLLLLLLLLLLLLLLL DBBBDBBBDBBBDBBB", + "token": "CY-mmTrgvM_s8h5061vBpL636A", + "canonical": "" + }, + { + "id": 7, + "moves": "1R'", + "facelets": "UUUBUUUBUUUBUUUB RRRRRRRRRRRRRRRR FFFUFFFUFFFUFFFU DDDFDDDFDDDFDDDF LLLLLLLLLLLLLLLL DBBBDBBBDBBBDBBB", + "token": "AxkcCb8BDYek66qUO3ZXxFD636A", + "canonical": "" + }, + { + "id": 6, + "moves": "2R", + "facelets": "UUFUUUFUUUFUUUFU RRRRRRRRRRRRRRRR FFDFFFDFFFDFFFDF DDBDDDBDDDBDDDBD LLLLLLLLLLLLLLLL BUBBBUBBBUBBBUBB", + "token": "AAAAAADEAY2dBTM0NmvSkNEww-", + "canonical": "" + }, + { + "id": 7, + "moves": "2R", + "facelets": "UUFUUUFUUUFUUUFU RRRRRRRRRRRRRRRR FFDFFFDFFFDFFFDF DDBDDDBDDDBDDDBD LLLLLLLLLLLLLLLL BUBBBUBBBUBBBUBB", + "token": "AAAAAAADEAY2dBTM0NmvSkNEww-", + "canonical": "" + }, + { + "id": 6, + "moves": "2R2", + "facelets": "UUDUUUDUUUDUUUDU RRRRRRRRRRRRRRRR FFBFFFBFFFBFFFBF DDUDDDUDDDUDDDUD LLLLLLLLLLLLLLLL BFBBBFBBBFBBBFBB", + "token": "AAAAAAElXd6zcc6I15lEJvblrG", + "canonical": "" + }, + { + "id": 7, + "moves": "2R2", + "facelets": "UUDUUUDUUUDUUUDU RRRRRRRRRRRRRRRR FFBFFFBFFFBFFFBF DDUDDDUDDDUDDDUD LLLLLLLLLLLLLLLL BFBBBFBBBFBBBFBB", + "token": "AAAAAAAElXd6zcc6I15lEJvblrG", + "canonical": "" + }, + { + "id": 6, + "moves": "2R'", + "facelets": "UUBUUUBUUUBUUUBU RRRRRRRRRRRRRRRR FFUFFFUFFFUFFFUF DDFDDDFDDDFDDDFD LLLLLLLLLLLLLLLL BDBBBDBBBDBBBDBB", + "token": "AAAAAAGfEUQOO3MflHiKlbgNqU", + "canonical": "" + }, + { + "id": 7, + "moves": "2R'", + "facelets": "UUBUUUBUUUBUUUBU RRRRRRRRRRRRRRRR FFUFFFUFFFUFFFUF DDFDDDFDDDFDDDFD LLLLLLLLLLLLLLLL BDBBBDBBBDBBBDBB", + "token": "AAAAAAAGfEUQOO3MflHiKlbgNqU", + "canonical": "" + }, + { + "id": 6, + "moves": "1U", + "facelets": "UUUUUUUUUUUUUUUU BBBBRRRRRRRRRRRR RRRRFFFFFFFFFFFF DDDDDDDDDDDDDDDD FFFFLLLLLLLLLLLL LLLLBBBBBBBBBBBB", + "token": "COPBrKR91ykQf6A-TpaJ7bldoA", + "canonical": "" + }, + { + "id": 7, + "moves": "1U", + "facelets": "UUUUUUUUUUUUUUUU BBBBRRRRRRRRRRRR RRRRFFFFFFFFFFFF DDDDDDDDDDDDDDDD FFFFLLLLLLLLLLLL LLLLBBBBBBBBBBBB", + "token": "Auq7ii3iaU5Ku6uaLKf8lHbldoA", + "canonical": "" + }, + { + "id": 6, + "moves": "1U2", + "facelets": "UUUUUUUUUUUUUUUU LLLLRRRRRRRRRRRR BBBBFFFFFFFFFFFF DDDDDDDDDDDDDDDD RRRRLLLLLLLLLLLL FFFFBBBBBBBBBBBB", + "token": "BuoIb-DlsNFgmY7GPc78fsQSoA", + "canonical": "" + }, + { + "id": 7, + "moves": "1U2", + "facelets": "UUUUUUUUUUUUUUUU LLLLRRRRRRRRRRRR BBBBFFFFFFFFFFFF DDDDDDDDDDDDDDDD RRRRLLLLLLLLLLLL FFFFBBBBBBBBBBBB", + "token": "AjjwaWA23GuMv7gzQYfVb2sQSoA", + "canonical": "" + }, + { + "id": 6, + "moves": "1U'", + "facelets": "UUUUUUUUUUUUUUUU FFFFRRRRRRRRRRRR LLLLFFFFFFFFFFFF DDDDDDDDDDDDDDDD BBBBLLLLLLLLLLLL RRRRBBBBBBBBBBBB", + "token": "A45NeWLml_deMk9nz9mL6iBm4A", + "canonical": "" + }, + { + "id": 7, + "moves": "1U'", + "facelets": "UUUUUUUUUUUUUUUU FFFFRRRRRRRRRRRR LLLLFFFFFFFFFFFF DDDDDDDDDDDDDDDD BBBBLLLLLLLLLLLL RRRRBBBBBBBBBBBB", + "token": "ASJlYGwLsiSIXBcglOz15rCBm4A", + "canonical": "" + }, + { + "id": 6, + "moves": "2U", + "facelets": "UUUUUUUUUUUUUUUU RRRRBBBBRRRRRRRR FFFFRRRRFFFFFFFF DDDDDDDDDDDDDDDD LLLLFFFFLLLLLLLL BBBBLLLLBBBBBBBB", + "token": "AAAAAAABB1RDviWHL_gFQhN1AQ", + "canonical": "" + }, + { + "id": 7, + "moves": "2U", + "facelets": "UUUUUUUUUUUUUUUU RRRRBBBBRRRRRRRR FFFFRRRRFFFFFFFF DDDDDDDDDDDDDDDD LLLLFFFFLLLLLLLL BBBBLLLLBBBBBBBB", + "token": "AAAAAAAABB1RDviWHL_gFQhN1AQ", + "canonical": "" + }, + { + "id": 6, + "moves": "2U2", + "facelets": "UUUUUUUUUUUUUUUU RRRRLLLLRRRRRRRR FFFFBBBBFFFFFFFF DDDDDDDDDDDDDDDD LLLLRRRRLLLLLLLL BBBBFFFFBBBBBBBB", + "token": "AAAAAAAAxb3WGGzUe_oyfVNJ1J", + "canonical": "" + }, + { + "id": 7, + "moves": "2U2", + "facelets": "UUUUUUUUUUUUUUUU RRRRLLLLRRRRRRRR FFFFBBBBFFFFFFFF DDDDDDDDDDDDDDDD LLLLRRRRLLLLLLLL BBBBFFFFBBBBBBBB", + "token": "AAAAAAAAAxb3WGGzUe_oyfVNJ1J", + "canonical": "" + }, + { + "id": 6, + "moves": "2U'", + "facelets": "UUUUUUUUUUUUUUUU RRRRFFFFRRRRRRRR FFFFLLLLFFFFFFFF DDDDDDDDDDDDDDDD LLLLBBBBLLLLLLLL BBBBRRRRBBBBBBBB", + "token": "AAAAAAAAQo9drxElDksr7KpcF_", + "canonical": "" + }, + { + "id": 7, + "moves": "2U'", + "facelets": "UUUUUUUUUUUUUUUU RRRRFFFFRRRRRRRR FFFFLLLLFFFFFFFF DDDDDDDDDDDDDDDD LLLLBBBBLLLLLLLL BBBBRRRRBBBBBBBB", + "token": "AAAAAAAAAQo9drxElDksr7KpcF_", + "canonical": "" + }, + { + "id": 6, + "moves": "1F", + "facelets": "UUUUUUUUUUUULLLL URRRURRRURRRURRR FFFFFFFFFFFFFFFF RRRRDDDDDDDDDDDD LLLDLLLDLLLDLLLD BBBBBBBBBBBBBBBB", + "token": "BRCDJctMu-0Y5OJewh6783joUA", + "canonical": "" + }, + { + "id": 7, + "moves": "1F", + "facelets": "UUUUUUUUUUUULLLL URRRURRRURRRURRR FFFFFFFFFFFFFFFF RRRRDDDDDDDDDDDD LLLDLLLDLLLDLLLD BBBBBBBBBBBBBBBB", + "token": "AY5ERPcxTxL1FqsZZmd7nd_joUA", + "canonical": "" + }, + { + "id": 6, + "moves": "1F2", + "facelets": "UUUUUUUUUUUUDDDD LRRRLRRRLRRRLRRR FFFFFFFFFFFFFFFF UUUUDDDDDDDDDDDD LLLRLLLRLLLRLLLR BBBBBBBBBBBBBBBB", + "token": "EQv5QVy2S6cLSGIaK5nnMqr4UA", + "canonical": "" + }, + { + "id": 7, + "moves": "1F2", + "facelets": "UUUUUUUUUUUUDDDD LRRRLRRRLRRRLRRR FFFFFFFFFFFFFFFF UUUUDDDDDDDDDDDD LLLRLLLRLLLRLLLR BBBBBBBBBBBBBBBB", + "token": "BXlPEgHSD3w-jTAWG7Fe1t6r4UA", + "canonical": "" + }, + { + "id": 6, + "moves": "1F'", + "facelets": "UUUUUUUUUUUURRRR DRRRDRRRDRRRDRRR FFFFFFFFFFFFFFFF LLLLDDDDDDDDDDDD LLLULLLULLLULLLU BBBBBBBBBBBBBBBB", + "token": "C_ym-b-3K_cNjb23pdNAZUnzUA", + "canonical": "" + }, + { + "id": 7, + "moves": "1F'", + "facelets": "UUUUUUUUUUUURRRR DRRRDRRRDRRRDRRR FFFFFFFFFFFFFFFF LLLLDDDDDDDDDDDD LLLULLLULLLULLLU BBBBBBBBBBBBBBBB", + "token": "A-sPkINZ9to94y30pjtDjZcnzUA", + "canonical": "" + }, + { + "id": 6, + "moves": "2F", + "facelets": "UUUUUUUULLLLUUUU RURRRURRRURRRURR FFFFFFFFFFFFFFFF DDDDRRRRDDDDDDDD LLDLLLDLLLDLLLDL BBBBBBBBBBBBBBBB", + "token": "AAAAACIJ17bSztB6-mrw2yi7BI", + "canonical": "" + }, + { + "id": 7, + "moves": "2F", + "facelets": "UUUUUUUULLLLUUUU RURRRURRRURRRURR FFFFFFFFFFFFFFFF DDDDRRRRDDDDDDDD LLDLLLDLLLDLLLDL BBBBBBBBBBBBBBBB", + "token": "AAAAAACIJ17bSztB6-mrw2yi7BI", + "canonical": "" + }, + { + "id": 6, + "moves": "2F2", + "facelets": "UUUUUUUUDDDDUUUU RLRRRLRRRLRRRLRR FFFFFFFFFFFFFFFF DDDDUUUUDDDDDDDD LLRLLLRLLLRLLLRL BBBBBBBBBBBBBBBB", + "token": "AAAAABYhTmlx8H2-K3KNJQEqYA", + "canonical": "" + }, + { + "id": 7, + "moves": "2F2", + "facelets": "UUUUUUUUDDDDUUUU RLRRRLRRRLRRRLRR FFFFFFFFFFFFFFFF DDDDUUUUDDDDDDDD LLRLLLRLLLRLLLRL BBBBBBBBBBBBBBBB", + "token": "AAAAAABYhTmlx8H2-K3KNJQEqYA", + "canonical": "" + }, + { + "id": 6, + "moves": "2F'", + "facelets": "UUUUUUUURRRRUUUU RDRRRDRRRDRRRDRR FFFFFFFFFFFFFFFF DDDDLLLLDDDDDDDD LLULLLULLLULLLUL BBBBBBBBBBBBBBBB", + "token": "AAAAAAQhpcGfnTRYvqkjcSjcaS", + "canonical": "" + }, + { + "id": 7, + "moves": "2F'", + "facelets": "UUUUUUUURRRRUUUU RDRRRDRRRDRRRDRR FFFFFFFFFFFFFFFF DDDDLLLLDDDDDDDD LLULLLULLLULLLUL BBBBBBBBBBBBBBBB", + "token": "AAAAAAAQhpcGfnTRYvqkjcSjcaS", + "canonical": "" + }, + { + "id": 6, + "moves": "1L", + "facelets": "BUUUBUUUBUUUBUUU RRRRRRRRRRRRRRRR UFFFUFFFUFFFUFFF FDDDFDDDFDDDFDDD LLLLLLLLLLLLLLLL BBBDBBBDBBBDBBBD", + "token": "DHd8hkPU4v5J0QIg0_oawMJRpl", + "canonical": "UFFFUFFFUFFFUFFF RRRRRRRRRRRRRRRR FDDDFDDDFDDDFDDD DBBBDBBBDBBBDBBB LLLLLLLLLLLLLLLL UUUBUUUBUUUBUUUB" + }, + { + "id": 7, + "moves": "1L", + "facelets": "BUUUBUUUBUUUBUUU RRRRRRRRRRRRRRRR UFFFUFFFUFFFUFFF FDDDFDDDFDDDFDDD LLLLLLLLLLLLLLLL BBBDBBBDBBBDBBBD", + "token": "ADzGJcYPtawATrCTQIF-ilzvrUg", + "canonical": "" + }, + { + "id": 6, + "moves": "1L2", + "facelets": "DUUUDUUUDUUUDUUU RRRRRRRRRRRRRRRR BFFFBFFFBFFFBFFF UDDDUDDDUDDDUDDD LLLLLLLLLLLLLLLL BBBFBBBFBBBFBBBF", + "token": "Em8I2HgejWzngFEZpobATA4zAT", + "canonical": "UDDDUDDDUDDDUDDD RRRRRRRRRRRRRRRR FBBBFBBBFBBBFBBB DUUUDUUUDUUUDUUU LLLLLLLLLLLLLLLL FFFBFFFBFFFBFFFB" + }, + { + "id": 7, + "moves": "1L2", + "facelets": "DUUUDUUUDUUUDUUU RRRRRRRRRRRRRRRR BFFFBFFFBFFFBFFF UDDDUDDDUDDDUDDD LLLLLLLLLLLLLLLL BBBFBBBFBBBFBBBF", + "token": "AMyPrxCudFXteYkQOYTdtRAg4Ag", + "canonical": "" + }, + { + "id": 6, + "moves": "1L'", + "facelets": "FUUUFUUUFUUUFUUU RRRRRRRRRRRRRRRR DFFFDFFFDFFFDFFF BDDDBDDDBDDDBDDD LLLLLLLLLLLLLLLL BBBUBBBUBBBUBBBU", + "token": "CY-m9C-SdBnvxPQHlk-3zjn6RT", + "canonical": "UBBBUBBBUBBBUBBB RRRRRRRRRRRRRRRR FUUUFUUUFUUUFUUU DFFFDFFFDFFFDFFF LLLLLLLLLLLLLLLL DDDBDDDBDDDBDDDB" + }, + { + "id": 7, + "moves": "1L'", + "facelets": "FUUUFUUUFUUUFUUU RRRRRRRRRRRRRRRR DFFFDFFFDFFFDFFF BDDDBDDDBDDDBDDD LLLLLLLLLLLLLLLL BBBUBBBUBBBUBBBU", + "token": "AI_X07U5ZUQyqNvKBoBsBpf3uWg", + "canonical": "" + }, + { + "id": 6, + "moves": "2L", + "facelets": "UBUUUBUUUBUUUBUU RRRRRRRRRRRRRRRR FUFFFUFFFUFFFUFF DFDDDFDDDFDDDFDD LLLLLLLLLLLLLLLL BBDBBBDBBBDBBBDB", + "token": "AAAAWvMSpgfJBA3yRIVxs8LtLg", + "canonical": "" + }, + { + "id": 7, + "moves": "2L", + "facelets": "UBUUUBUUUBUUUBUU RRRRRRRRRRRRRRRR FUFFFUFFFUFFFUFF DFDDDFDDDFDDDFDD LLLLLLLLLLLLLLLL BBDBBBDBBBDBBBDB", + "token": "AAAAAWvMSpgfJBA3yRIVxs8LtLg", + "canonical": "" + }, + { + "id": 6, + "moves": "2L2", + "facelets": "UDUUUDUUUDUUUDUU RRRRRRRRRRRRRRRR FBFFFBFFFBFFFBFF DUDDDUDDDUDDDUDD LLLLLLLLLLLLLLLL BBFBBBFBBBFBBBFB", + "token": "AAAAL4mzhGZIeTM-ULL86RNiJ8", + "canonical": "" + }, + { + "id": 7, + "moves": "2L2", + "facelets": "UDUUUDUUUDUUUDUU RRRRRRRRRRRRRRRR FBFFFBFFFBFFFBFF DUDDDUDDDUDDDUDD LLLLLLLLLLLLLLLL BBFBBBFBBBFBBBFB", + "token": "AAAAAL4mzhGZIeTM-ULL86RNiJ8", + "canonical": "" + }, + { + "id": 6, + "moves": "2L'", + "facelets": "UFUUUFUUUFUUUFUU RRRRRRRRRRRRRRRR FDFFFDFFFDFFFDFF DBDDDBDDDBDDDBDD LLLLLLLLLLLLLLLL BBUBBBUBBBUBBBUB", + "token": "AAAAH8B5pqj_85hfJWk5HKqHim", + "canonical": "" + }, + { + "id": 7, + "moves": "2L'", + "facelets": "UFUUUFUUUFUUUFUU RRRRRRRRRRRRRRRR FDFFFDFFFDFFFDFF DBDDDBDDDBDDDBDD LLLLLLLLLLLLLLLL BBUBBBUBBBUBBBUB", + "token": "AAAAAH8B5pqj_85hfJWk5HKqHim", + "canonical": "" + }, + { + "id": 6, + "moves": "1D", + "facelets": "UUUUUUUUUUUUUUUU RRRRRRRRRRRRFFFF FFFFFFFFFFFFLLLL DDDDDDDDDDDDDDDD LLLLLLLLLLLLBBBB BBBBBBBBBBBBRRRR", + "token": "COPBrKR-2uVI9hosqEWs94vUeH", + "canonical": "UUUUUUUUUUUUUUUU BBBBBBBBBBBBRRRR RRRRRRRRRRRRFFFF DDDDDDDDDDDDDDDD FFFFFFFFFFFFLLLL LLLLLLLLLLLLBBBB" + }, + { + "id": 7, + "moves": "1D", + "facelets": "UUUUUUUUUUUUUUUU RRRRRRRRRRRRFFFF FFFFFFFFFFFFLLLL DDDDDDDDDDDDDDDD LLLLLLLLLLLLBBBB BBBBBBBBBBBBRRRR", + "token": "AABxya6jFx1Xwr0EuNB7RgiddPw", + "canonical": "" + }, + { + "id": 6, + "moves": "1D2", + "facelets": "UUUUUUUUUUUUUUUU RRRRRRRRRRRRLLLL FFFFFFFFFFFFBBBB DDDDDDDDDDDDDDDD LLLLLLLLLLLLRRRR BBBBBBBBBBBBFFFF", + "token": "BuoIb-Dmb1JQTS80ewUb-_Sr7a", + "canonical": "UUUUUUUUUUUUUUUU LLLLLLLLLLLLRRRR BBBBBBBBBBBBFFFF DDDDDDDDDDDDDDDD RRRRRRRRRRRRLLLL FFFFFFFFFFFFBBBB" + }, + { + "id": 7, + "moves": "1D2", + "facelets": "UUUUUUUUUUUUUUUU RRRRRRRRRRRRLLLL FFFFFFFFFFFFBBBB DDDDDDDDDDDDDDDD LLLLLLLLLLLLRRRR BBBBBBBBBBBBFFFF", + "token": "AADKShoFfm4XNCaSYbI17lybDpw", + "canonical": "" + }, + { + "id": 6, + "moves": "1D'", + "facelets": "UUUUUUUUUUUUUUUU RRRRRRRRRRRRBBBB FFFFFFFFFFFFRRRR DDDDDDDDDDDDDDDD LLLLLLLLLLLLFFFF BBBBBBBBBBBBLLLL", + "token": "A45NeWLmzAAz5lQWgcRdKb_Yt-", + "canonical": "UUUUUUUUUUUUUUUU FFFFFFFFFFFFRRRR LLLLLLLLLLLLFFFF DDDDDDDDDDDDDDDD BBBBBBBBBBBBLLLL RRRRRRRRRRRRBBBB" + }, + { + "id": 7, + "moves": "1D'", + "facelets": "UUUUUUUUUUUUUUUU RRRRRRRRRRRRBBBB FFFFFFFFFFFFRRRR DDDDDDDDDDDDDDDD LLLLLLLLLLLLFFFF BBBBBBBBBBBBLLLL", + "token": "AADjk11GLjxiz1I2uhiXH79xiHw", + "canonical": "" + }, + { + "id": 6, + "moves": "2D", + "facelets": "UUUUUUUUUUUUUUUU RRRRRRRRFFFFRRRR FFFFFFFFLLLLFFFF DDDDDDDDDDDDDDDD LLLLLLLLBBBBLLLL BBBBBBBBRRRRBBBB", + "token": "AAAAAAAAA7OBdm3O9C6w2iCX60", + "canonical": "" + }, + { + "id": 7, + "moves": "2D", + "facelets": "UUUUUUUUUUUUUUUU RRRRRRRRFFFFRRRR FFFFFFFFLLLLFFFF DDDDDDDDDDDDDDDD LLLLLLLLBBBBLLLL BBBBBBBBRRRRBBBB", + "token": "AAAAAAAAAA7OBdm3O9C6w2iCX60", + "canonical": "" + }, + { + "id": 6, + "moves": "2D2", + "facelets": "UUUUUUUUUUUUUUUU RRRRRRRRLLLLRRRR FFFFFFFFBBBBFFFF DDDDDDDDDDDDDDDD LLLLLLLLRRRRLLLL BBBBBBBBFFFFBBBB", + "token": "AAAAAAAACv0zxdBcuWDG6U_qJb", + "canonical": "" + }, + { + "id": 7, + "moves": "2D2", + "facelets": "UUUUUUUUUUUUUUUU RRRRRRRRLLLLRRRR FFFFFFFFBBBBFFFF DDDDDDDDDDDDDDDD LLLLLLLLRRRRLLLL BBBBBBBBFFFFBBBB", + "token": "AAAAAAAAACv0zxdBcuWDG6U_qJb", + "canonical": "" + }, + { + "id": 6, + "moves": "2D'", + "facelets": "UUUUUUUUUUUUUUUU RRRRRRRRBBBBRRRR FFFFFFFFRRRRFFFF DDDDDDDDDDDDDDDD LLLLLLLLFFFFLLLL BBBBBBBBLLLLBBBB", + "token": "AAAAAAAADqH-Kc6sekYmvse45u", + "canonical": "" + }, + { + "id": 7, + "moves": "2D'", + "facelets": "UUUUUUUUUUUUUUUU RRRRRRRRBBBBRRRR FFFFFFFFRRRRFFFF DDDDDDDDDDDDDDDD LLLLLLLLFFFFLLLL BBBBBBBBLLLLBBBB", + "token": "AAAAAAAAADqH-Kc6sekYmvse45u", + "canonical": "" + }, + { + "id": 6, + "moves": "1B", + "facelets": "RRRRUUUUUUUUUUUU RRRDRRRDRRRDRRRD FFFFFFFFFFFFFFFF DDDDDDDDDDDDLLLL ULLLULLLULLLULLL BBBBBBBBBBBBBBBB", + "token": "BRCDKIA75rCro7g6yzMinJVcxI", + "canonical": "UUUULLLLLLLLLLLL UUURUUURUUURUUUR FFFFFFFFFFFFFFFF RRRRRRRRRRRRDDDD LDDDLDDDLDDDLDDD BBBBBBBBBBBBBBBB" + }, + { + "id": 7, + "moves": "1B", + "facelets": "RRRRUUUUUUUUUUUU RRRDRRRDRRRDRRRD FFFFFFFFFFFFFFFF DDDDDDDDDDDDLLLL ULLLULLLULLLULLL BBBBBBBBBBBBBBBB", + "token": "AAsY2LmGeo3l6Ird79kttvo_UEw", + "canonical": "" + }, + { + "id": 6, + "moves": "1B2", + "facelets": "DDDDUUUUUUUUUUUU RRRLRRRLRRRLRRRL FFFFFFFFFFFFFFFF DDDDDDDDDDDDUUUU RLLLRLLLRLLLRLLL BBBBBBBBBBBBBBBB", + "token": "EQv5Q6_447W01GBe1fO1Pg8bkc", + "canonical": "UUUUDDDDDDDDDDDD LLLRLLLRLLLRLLLR FFFFFFFFFFFFFFFF UUUUUUUUUUUUDDDD LRRRLRRRLRRRLRRR BBBBBBBBBBBBBBBB" + }, + { + "id": 7, + "moves": "1B2", + "facelets": "DDDDUUUUUUUUUUUU RRRLRRRLRRRLRRRL FFFFFFFFFFFFFFFF DDDDDDDDDDDDUUUU RLLLRLLLRLLLRLLL BBBBBBBBBBBBBBBB", + "token": "ACM2hxUXUFgfU6JKbXDWEaw7GSQ", + "canonical": "" + }, + { + "id": 6, + "moves": "1B'", + "facelets": "LLLLUUUUUUUUUUUU RRRURRRURRRURRRU FFFFFFFFFFFFFFFF DDDDDDDDDDDDRRRR DLLLDLLLDLLLDLLL BBBBBBBBBBBBBBBB", + "token": "C_ym-s1ltwBy-q_EAzeGzGfbti", + "canonical": "UUUURRRRRRRRRRRR DDDRDDDRDDDRDDDR FFFFFFFFFFFFFFFF LLLLLLLLLLLLDDDD LUUULUUULUUULUUU BBBBBBBBBBBBBBBB" + }, + { + "id": 7, + "moves": "1B'", + "facelets": "LLLLUUUUUUUUUUUU RRRURRRURRRURRRU FFFFFFFFFFFFFFFF DDDDDDDDDDDDRRRR DLLLDLLLDLLLDLLL BBBBBBBBBBBBBBBB", + "token": "ABgvRNW5ZhSpMsk5JzwH4vjfjNg", + "canonical": "" + }, + { + "id": 6, + "moves": "2B", + "facelets": "UUUURRRRUUUUUUUU RRDRRRDRRRDRRRDR FFFFFFFFFFFFFFFF DDDDDDDDLLLLDDDD LULLLULLLULLLULL BBBBBBBBBBBBBBBB", + "token": "AAAAAQmnrHxRXw3CgoMgfkc0h8", + "canonical": "" + }, + { + "id": 7, + "moves": "2B", + "facelets": "UUUURRRRUUUUUUUU RRDRRRDRRRDRRRDR FFFFFFFFFFFFFFFF DDDDDDDDLLLLDDDD LULLLULLLULLLULL BBBBBBBBBBBBBBBB", + "token": "AAAAAAQmnrHxRXw3CgoMgfkc0h8", + "canonical": "" + }, + { + "id": 6, + "moves": "2B2", + "facelets": "UUUUDDDDUUUUUUUU RRLRRRLRRRLRRRLR FFFFFFFFFFFFFFFF DDDDDDDDUUUUDDDD LRLLLRLLLRLLLRLL BBBBBBBBBBBBBBBB", + "token": "AAAAAj0juq6zazhZzggsmR0t2A", + "canonical": "" + }, + { + "id": 7, + "moves": "2B2", + "facelets": "UUUUDDDDUUUUUUUU RRLRRRLRRRLRRRLR FFFFFFFFFFFFFFFF DDDDDDDDUUUUDDDD LRLLLRLLLRLLLRLL BBBBBBBBBBBBBBBB", + "token": "AAAAAAj0juq6zazhZzggsmR0t2A", + "canonical": "" + }, + { + "id": 6, + "moves": "2B'", + "facelets": "UUUULLLLUUUUUUUU RRURRRURRRURRRUR FFFFFFFFFFFFFFFF DDDDDDDDRRRRDDDD LDLLLDLLLDLLLDLL BBBBBBBBBBBBBBBB", + "token": "AAAAApT-B10uyz1skL-eoUdzbU", + "canonical": "" + }, + { + "id": 7, + "moves": "2B'", + "facelets": "UUUULLLLUUUUUUUU RRURRRURRRURRRUR FFFFFFFFFFFFFFFF DDDDDDDDRRRRDDDD LDLLLDLLLDLLLDLL BBBBBBBBBBBBBBBB", + "token": "AAAAAApT-B10uyz1skL-eoUdzbU", + "canonical": "" + }, + { + "id": 6, + "moves": "x", + "facelets": "FFFFFFFFFFFFFFFF RRRRRRRRRRRRRRRR DDDDDDDDDDDDDDDD BBBBBBBBBBBBBBBB LLLLLLLLLLLLLLLL UUUUUUUUUUUUUUUU", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "UUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBB" + }, + { + "id": 7, + "moves": "x", + "facelets": "FFFFFFFFFFFFFFFF RRRRRRRRRRRRRRRR DDDDDDDDDDDDDDDD BBBBBBBBBBBBBBBB LLLLLLLLLLLLLLLL UUUUUUUUUUUUUUUU", + "token": "BHjr7IoYWEYd9KNFw2n-GFyftgF", + "canonical": "" + }, + { + "id": 6, + "moves": "x2", + "facelets": "DDDDDDDDDDDDDDDD RRRRRRRRRRRRRRRR BBBBBBBBBBBBBBBB UUUUUUUUUUUUUUUU LLLLLLLLLLLLLLLL FFFFFFFFFFFFFFFF", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "UUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBB" + }, + { + "id": 7, + "moves": "x2", + "facelets": "DDDDDDDDDDDDDDDD RRRRRRRRRRRRRRRR BBBBBBBBBBBBBBBB UUUUUUUUUUUUUUUU LLLLLLLLLLLLLLLL FFFFFFFFFFFFFFFF", + "token": "B8c8zEqD0tvpeRluhD1Kx68gGgz", + "canonical": "" + }, + { + "id": 6, + "moves": "x'", + "facelets": "BBBBBBBBBBBBBBBB RRRRRRRRRRRRRRRR UUUUUUUUUUUUUUUU FFFFFFFFFFFFFFFF LLLLLLLLLLLLLLLL DDDDDDDDDDDDDDDD", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "UUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBB" + }, + { + "id": 7, + "moves": "x'", + "facelets": "BBBBBBBBBBBBBBBB RRRRRRRRRRRRRRRR UUUUUUUUUUUUUUUU FFFFFFFFFFFFFFFF LLLLLLLLLLLLLLLL DDDDDDDDDDDDDDDD", + "token": "A05gcPmvWRN_sxks6FldcQV2zlz", + "canonical": "" + }, + { + "id": 6, + "moves": "y", + "facelets": "UUUUUUUUUUUUUUUU BBBBBBBBBBBBBBBB RRRRRRRRRRRRRRRR DDDDDDDDDDDDDDDD FFFFFFFFFFFFFFFF LLLLLLLLLLLLLLLL", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "UUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBB" + }, + { + "id": 7, + "moves": "y", + "facelets": "UUUUUUUUUUUUUUUU BBBBBBBBBBBBBBBB RRRRRRRRRRRRRRRR DDDDDDDDDDDDDDDD FFFFFFFFFFFFFFFF LLLLLLLLLLLLLLLL", + "token": "AuufHYsom5j2IMiUV_R8cOGy5wH", + "canonical": "" + }, + { + "id": 6, + "moves": "y2", + "facelets": "UUUUUUUUUUUUUUUU LLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBB DDDDDDDDDDDDDDDD RRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFF", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "UUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBB" + }, + { + "id": 7, + "moves": "y2", + "facelets": "UUUUUUUUUUUUUUUU LLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBB DDDDDDDDDDDDDDDD RRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFF", + "token": "Ajm6s3o8XdL_Zaclwmkabsh02ta", + "canonical": "" + }, + { + "id": 6, + "moves": "y'", + "facelets": "UUUUUUUUUUUUUUUU FFFFFFFFFFFFFFFF LLLLLLLLLLLLLLLL DDDDDDDDDDDDDDDD BBBBBBBBBBBBBBBB RRRRRRRRRRRRRRRR", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "UUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBB" + }, + { + "id": 7, + "moves": "y'", + "facelets": "UUUUUUUUUUUUUUUU FFFFFFFFFFFFFFFF LLLLLLLLLLLLLLLL DDDDDDDDDDDDDDDD BBBBBBBBBBBBBBBB RRRRRRRRRRRRRRRR", + "token": "ASLXKhquyhFbKZUTwFJIojuu5H-", + "canonical": "" + }, + { + "id": 6, + "moves": "z", + "facelets": "LLLLLLLLLLLLLLLL UUUUUUUUUUUUUUUU FFFFFFFFFFFFFFFF RRRRRRRRRRRRRRRR DDDDDDDDDDDDDDDD BBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "UUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBB" + }, + { + "id": 7, + "moves": "z", + "facelets": "LLLLLLLLLLLLLLLL UUUUUUUUUUUUUUUU FFFFFFFFFFFFFFFF RRRRRRRRRRRRRRRR DDDDDDDDDDDDDDDD BBBBBBBBBBBBBBBB", + "token": "AaA6gkrLMOjMh0g7i_bHehXLN-o", + "canonical": "" + }, + { + "id": 6, + "moves": "z2", + "facelets": "DDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLL FFFFFFFFFFFFFFFF UUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRR BBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "UUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBB" + }, + { + "id": 7, + "moves": "z2", + "facelets": "DDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLL FFFFFFFFFFFFFFFF UUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRR BBBBBBBBBBBBBBBB", + "token": "BY2CGTHOApMsefH_OfI-ljmX32s", + "canonical": "" + }, + { + "id": 6, + "moves": "z'", + "facelets": "RRRRRRRRRRRRRRRR DDDDDDDDDDDDDDDD FFFFFFFFFFFFFFFF LLLLLLLLLLLLLLLL UUUUUUUUUUUUUUUU BBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "UUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBB" + }, + { + "id": 7, + "moves": "z'", + "facelets": "RRRRRRRRRRRRRRRR DDDDDDDDDDDDDDDD FFFFFFFFFFFFFFFF LLLLLLLLLLLLLLLL UUUUUUUUUUUUUUUU BBBBBBBBBBBBBBBB", + "token": "A_TfsNYeIov0RFWe1tL5YmCthwS", + "canonical": "" + }, + { + "id": 6, + "moves": "2B 4L2 1F2 2L 4U2 1B2 4R 3R' 4L2 3U2 x2 3D 2U 1B", + "facelets": "LULLFRFDFUFLBBBD LDRUDUUDLDRDLULF DDDFBFBRUDDFUUFB BBUDBBRLBBUDRLRR URRRFDRLULLLFRRR BBRFFFLUFBLBUUFD", + "token": "A9jsh3L1U2-0UpYegRlOVHdoEf", + "canonical": "DBBBLFUFDFRFLLUL URRRFDRLULLLFRRR BBRFFFLUFBLBUUFD RRLRDUBBLRBBDUBB LDRUDUUDLDRDLULF DDDFBFBRUDDFUUFB" + }, + { + "id": 7, + "moves": "2B 4L2 1F2 2L 4U2 1B2 4R 3R' 4L2 3U2 x2 3D 2U 1B", + "facelets": "LULLFRFDFUFLBBBD LDRUDUUDLDRDLULF DDDFBFBRUDDFUUFB BBUDBBRLBBUDRLRR URRRFDRLULLLFRRR BBRFFFLUFBLBUUFD", + "token": "BboVkZw7hr2PihJeHcxaU-or7rs", + "canonical": "" + }, + { + "id": 6, + "moves": "1R2 1U2 4U 1R x' 4R2 2U 2B2 1B2 2B 2F2 2U' 2B2 3L'", + "facelets": "DRUBLDRBDFUBRFUU LLDRRRFRRUDDFLBR UUBBRFBBDULBDULR LBDUUBLFLULLULUF BUBBDBDFDRDFLFLF DFULFFBRFRLRDRDF", + "token": "AYltq-8FiD-DVB4Ya3AiBwI3Fu", + "canonical": "ULULLUBBULLDFLFU RLUDBLUDBBFRBBUU RBLFDDURRFRRRDLL BBBUURUURDFFDLDR FDRDRLRFRBFFLUFD FLFLFDRDFDBDBBUB" + }, + { + "id": 7, + "moves": "1R2 1U2 4U 1R x' 4R2 2U 2B2 1B2 2B 2F2 2U' 2B2 3L'", + "facelets": "DRUBLDRBDFUBRFUU LLDRRRFRRUDDFLBR UUBBRFBBDULBDULR LBDUUBLFLULLULUF BUBBDBDFDRDFLFLF DFULFFBRFRLRDRDF", + "token": "AlWYY1O4gMZnRZM-cstQPDqsVVR", + "canonical": "" + }, + { + "id": 6, + "moves": "2U' 4R 1D' 1R 4L' 4L 1F' 2R 1R 4R 1L 4R' 2U 2D2", + "facelets": "LUDBUUFRUUFRUBDR DDDLFURDFLLLRRRR FDLFRRRRLUBDBDRB DLBUFDBUFDRUDBBU DLLLLLDBFFFFFUUR UBBBFBBBFLDRFULL", + "token": "CpaHBxLY_8pTRmNKRuCiSabpz1", + "canonical": "LDLRDRLRDULRDFFR UUUUBBRBLDDBDFFD FRDBLRBRDRUDFRLB LBFRLDFULLFUDLFF BRRRDFFDUUUBLUUU FFFUULBBLDBBLRBB" + }, + { + "id": 7, + "moves": "2U' 4R 1D' 1R 4L' 4L 1F' 2R 1R 4R 1L 4R' 2U 2D2", + "facelets": "LUDBUUFRUUFRUBDR DDDLFURDFLLLRRRR FDLFRRRRLUBDBDRB DLBUFDBUFDRUDBBU DLLLLLDBFFFFFUUR UBBBFBBBFLDRFULL", + "token": "BCCjJpG9mnMFma01TCLRnH2LwaP", + "canonical": "" + }, + { + "id": 6, + "moves": "3L' x 3D2 3R' 2B 3L 3B 1B2 x' 4L' 1U 2L2 4U' 1R", + "facelets": "UFDLUFLUBFBDFFRL FRLURFUUFDUFDRLF RDBDRRFURRRDLLRB DDURRBUDDDRUFLLR BBDDFUDFFBDFUBBB BLURBBLLULLLUBBL", + "token": "CEFs4qjaahkgDlKqew5tZC9VeD", + "canonical": "FBUUFFFFRBLDLDUL BLURBBLLULLLUBBL FRLURFUUFDUFDRLF RDURUURLDBDLDRDF RDBDRRFURRRDLLRB BBDDFUDFFBDFUBBB" + }, + { + "id": 7, + "moves": "3L' x 3D2 3R' 2B 3L 3B 1B2 x' 4L' 1U 2L2 4U' 1R", + "facelets": "UFDLUFLUBFBDFFRL FRLURFUUFDUFDRLF RDBDRRFURRRDLLRB DDURRBUDDDRUFLLR BBDDFUDFFBDFUBBB BLURBBLLULLLUBBL", + "token": "BYAc5kPE9iaqRFGV-QsW_wsnhD_", + "canonical": "" + }, + { + "id": 10, + "moves": "", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "" + }, + { + "id": 11, + "moves": "", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "CgGWpjtIh4vYo4b_KxcD7DG7DGuzTmUAIAAAAAAAAA", + "canonical": "" + }, + { + "id": 10, + "moves": "1R", + "facelets": "UUUUFUUUUFUUUUFUUUUFUUUUF RRRRRRRRRRRRRRRRRRRRRRRRR FFFFDFFFFDFFFFDFFFFDFFFFD DDDDBDDDDBDDDDBDDDDBDDDDB LLLLLLLLLLLLLLLLLLLLLLLLL UBBBBUBBBBUBBBBUBBBBUBBBB", + "token": "BTd_f4Bnnq55sBqNFuMk4ZvsOiKUMdzop89zfSNBgA", + "canonical": "" + }, + { + "id": 11, + "moves": "1R", + "facelets": "UUUUFUUUUFUUUUFUUUUFUUUUF RRRRRRRRRRRRRRRRRRRRRRRRR FFFFDFFFFDFFFFDFFFFDFFFFD DDDDBDDDDBDDDDBDDDDBDDDDB LLLLLLLLLLLLLLLLLLLLLLLLL UBBBBUBBBBUBBBBUBBBBUBBBB", + "token": "hzWKmkT_Z-dBJgQ5UGJ5Es_gf6mX-xrP23LTu04kAA", + "canonical": "" + }, + { + "id": 10, + "moves": "1R2", + "facelets": "UUUUDUUUUDUUUUDUUUUDUUUUD RRRRRRRRRRRRRRRRRRRRRRRRR FFFFBFFFFBFFFFBFFFFBFFFFB DDDDUDDDDUDDDDUDDDDUDDDDU LLLLLLLLLLLLLLLLLLLLLLLLL FBBBBFBBBBFBBBBFBBBBFBBBB", + "token": "CPpgrU5hQrZkTD-jueXyQjix2PJVUmKnPC8jHCohgA", + "canonical": "" + }, + { + "id": 11, + "moves": "1R2", + "facelets": "UUUUDUUUUDUUUUDUUUUDUUUUD RRRRRRRRRRRRRRRRRRRRRRRRR FFFFBFFFFBFFFFBFFFFBFFFFB DDDDUDDDDUDDDDUDDDDUDDDDU LLLLLLLLLLLLLLLLLLLLLLLLL FBBBBFBBBBFBBBBFBBBBFBBBB", + "token": "4Xqm5ZRmyKU_yX5YmKW6IYJnYyOzB6StxGtKo_MkAA", + "canonical": "" + }, + { + "id": 10, + "moves": "1R'", + "facelets": "UUUUBUUUUBUUUUBUUUUBUUUUB RRRRRRRRRRRRRRRRRRRRRRRRR FFFFUFFFFUFFFFUFFFFUFFFFU DDDDFDDDDFDDDDFDDDDFDDDDF LLLLLLLLLLLLLLLLLLLLLLLLL DBBBBDBBBBDBBBBDBBBBDBBBB", + "token": "A_xBQ9MrkDOQSa6R0NJxbZOXw5yfo0ReZ_fCzmfRgA", + "canonical": "" + }, + { + "id": 11, + "moves": "1R'", + "facelets": "UUUUBUUUUBUUUUBUUUUBUUUUB RRRRRRRRRRRRRRRRRRRRRRRRR FFFFUFFFFUFFFFUFFFFUFFFFU DDDDFDDDDFDDDDFDDDDFDDDDF LLLLLLLLLLLLLLLLLLLLLLLLL DBBBBDBBBBDBBBBDBBBBDBBBB", + "token": "aae1AgdeDGFfi-SqvtGmMgf1YxqqnM3Z3zpDWbukAA", + "canonical": "" + }, + { + "id": 10, + "moves": "2R", + "facelets": "UUUFUUUUFUUUUFUUUUFUUUUFU RRRRRRRRRRRRRRRRRRRRRRRRR FFFDFFFFDFFFFDFFFFDFFFFDF DDDBDDDDBDDDDBDDDDBDDDDBD LLLLLLLLLLLLLLLLLLLLLLLLL BUBBBBUBBBBUBBBBUBBBBUBBB", + "token": "AAAAAAAAAAAAAAjU1Ibhr6aLf_JkxwbuxTE8_SvtIU", + "canonical": "" + }, + { + "id": 11, + "moves": "2R", + "facelets": "UUUFUUUUFUUUUFUUUUFUUUUFU RRRRRRRRRRRRRRRRRRRRRRRRR FFFDFFFFDFFFFDFFFFDFFFFDF DDDBDDDDBDDDDBDDDDBDDDDBD LLLLLLLLLLLLLLLLLLLLLLLLL BUBBBBUBBBBUBBBBUBBBBUBBB", + "token": "CgGWpjtIh4vYpFrzF7wsY87PCyUl9wtinJ23vB47Hg", + "canonical": "" + }, + { + "id": 10, + "moves": "2R2", + "facelets": "UUUDUUUUDUUUUDUUUUDUUUUDU RRRRRRRRRRRRRRRRRRRRRRRRR FFFBFFFFBFFFFBFFFFBFFFFBF DDDUDDDDUDDDDUDDDDUDDDDUD LLLLLLLLLLLLLLLLLLLLLLLLL BFBBBBFBBBBFBBBBFBBBBFBBB", + "token": "AAAAAAAAAAAAAA031dRuBGO6_88TVcCoFrqc9u6TsA", + "canonical": "" + }, + { + "id": 11, + "moves": "2R2", + "facelets": "UUUDUUUUDUUUUDUUUUDUUUUDU RRRRRRRRRRRRRRRRRRRRRRRRR FFFBFFFFBFFFFBFFFFBFFFFBF DDDUDDDDUDDDDUDDDDUDDDDUD LLLLLLLLLLLLLLLLLLLLLLLLL BFBBBBFBBBBFBBBBFBBBBFBBB", + "token": "CgGWpjtIh4vYpMQ7NwFUVYtDB9WDWHTCQX63Jl3YgA", + "canonical": "" + }, + { + "id": 10, + "moves": "2R'", + "facelets": "UUUBUUUUBUUUUBUUUUBUUUUBU RRRRRRRRRRRRRRRRRRRRRRRRR FFFUFFFFUFFFFUFFFFUFFFFUF DDDFDDDDFDDDDFDDDDFDDDDFD LLLLLLLLLLLLLLLLLLLLLLLLL BDBBBBDBBBBDBBBBDBBBBDBBB", + "token": "AAAAAAAAAAAAABKzl3VPGQNB36alviGD5lz2wwwxwm", + "canonical": "" + }, + { + "id": 11, + "moves": "2R'", + "facelets": "UUUBUUUUBUUUUBUUUUBUUUUBU RRRRRRRRRRRRRRRRRRRRRRRRR FFFUFFFFUFFFFUFFFFUFFFFUF DDDFDDDDFDDDDFDDDDFDDDDFD LLLLLLLLLLLLLLLLLLLLLLLLL BDBBBBDBBBBDBBBBDBBBBDBBB", + "token": "CgGWpjtIh4vYpUfVXhZuRH_oBAs9IYlduLciSSSqOQ", + "canonical": "" + }, + { + "id": 10, + "moves": "3R", + "facelets": "UUFUUUUFUUUUFUUUUFUUUUFUU RRRRRRRRRRRRRRRRRRRRRRRRR FFDFFFFDFFFFDFFFFDFFFFDFF DDBDDDDBDDDDBDDDDBDDDDBDD LLLLLLLLLLLLLLLLLLLLLLLLL BBUBBBBUBBBBUBBBBUBBBBUBB", + "token": "BEDHG1N7Nx4-i3BkFwdbjApkLYWv9TTs9u47T3JJC0", + "canonical": "BBUBBBBUBBBBUBBBBUBBBBUBB RRRRRRRRRRRRRRRRRRRRRRRRR UUFUUUUFUUUUFUUUUFUUUUFUU FFDFFFFDFFFFDFFFFDFFFFDFF LLLLLLLLLLLLLLLLLLLLLLLLL DDBDDDDBDDDDBDDDDBDDDDBDD" + }, + { + "id": 11, + "moves": "3R", + "facelets": "UUFUUUUFUUUUFUUUUFUUUUFUU RRRRRRRRRRRRRRRRRRRRRRRRR FFDFFFFDFFFFDFFFFDFFFFDFF DDBDDDDBDDDDBDDDDBDDDDBDD LLLLLLLLLLLLLLLLLLLLLLLLL BBUBBBBUBBBBUBBBBUBBBBUBB", + "token": "cBRBNg7VsmG1thBhU8eZDSsfUPQyS1s3RlWPcrbZDk", + "canonical": "" + }, + { + "id": 10, + "moves": "3R2", + "facelets": "UUDUUUUDUUUUDUUUUDUUUUDUU RRRRRRRRRRRRRRRRRRRRRRRRR FFBFFFFBFFFFBFFFFBFFFFBFF DDUDDDDUDDDDUDDDDUDDDDUDD LLLLLLLLLLLLLLLLLLLLLLLLL BBFBBBBFBBBBFBBBBFBBBBFBB", + "token": "CgGGY0n2V0zRZoB7HQthe6un40KDpblPki84kVK8aC", + "canonical": "DDUDDDDUDDDDUDDDDUDDDDUDD RRRRRRRRRRRRRRRRRRRRRRRRR BBFBBBBFBBBBFBBBBFBBBBFBB UUDUUUUDUUUUDUUUUDUUUUDUU LLLLLLLLLLLLLLLLLLLLLLLLL FFBFFFFBFFFFBFFFFBFFFFBFF" + }, + { + "id": 11, + "moves": "3R2", + "facelets": "UUDUUUUDUUUUDUUUUDUUUUDUU RRRRRRRRRRRRRRRRRRRRRRRRR FFBFFFFBFFFFBFFFFBFFFFBFF DDUDDDDUDDDDUDDDDUDDDDUDD LLLLLLLLLLLLLLLLLLLLLLLLL BBFBBBBFBBBBFBBBBFBBBBFBB", + "token": "-iYv9Spgtr96P5KJ5CgnhEl4WqgK18R11G1Nn8Gpw4", + "canonical": "" + }, + { + "id": 10, + "moves": "3R'", + "facelets": "UUBUUUUBUUUUBUUUUBUUUUBUU RRRRRRRRRRRRRRRRRRRRRRRRR FFUFFFFUFFFFUFFFFUFFFFUFF DDFDDDDFDDDDFDDDDFDDDDFDD LLLLLLLLLLLLLLLLLLLLLLLLL BBDBBBBDBBBBDBBBBDBBBBDBB", + "token": "BcDTT2OB734FWnj_2seFIlf4b1qsQkO0yPF0JQh_9u", + "canonical": "FFUFFFFUFFFFUFFFFUFFFFUFF RRRRRRRRRRRRRRRRRRRRRRRRR DDFDDDDFDDDDFDDDDFDDDDFDD BBDBBBBDBBBBDBBBBDBBBBDBB LLLLLLLLLLLLLLLLLLLLLLLLL UUBUUUUBUUUUBUUUUBUUUUBUU" + }, + { + "id": 11, + "moves": "3R'", + "facelets": "UUBUUUUBUUUUBUUUUBUUUUBUU RRRRRRRRRRRRRRRRRRRRRRRRR FFUFFFFUFFFFUFFFFUFFFFUFF DDFDDDDFDDDDFDDDDFDDDDFDD LLLLLLLLLLLLLLLLLLLLLLLLL BBDBBBBDBBBBDBBBBDBBBBDBB", + "token": "lBVmF492-1xZHt77rct_JHEFfOvZhL3y9qLjeMv_Jc", + "canonical": "" + }, + { + "id": 10, + "moves": "1U", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU BBBBBRRRRRRRRRRRRRRRRRRRR RRRRRFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD FFFFFLLLLLLLLLLLLLLLLLLLL LLLLLBBBBBBBBBBBBBBBBBBBB", + "token": "A8CYftAS9i-nWcFMqCWDlEsDOzI-ueUxluxO0FNmAA", + "canonical": "" + }, + { + "id": 11, + "moves": "1U", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU BBBBBRRRRRRRRRRRRRRRRRRRR RRRRRFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD FFFFFLLLLLLLLLLLLLLLLLLLL LLLLLBBBBBBBBBBBBBBBBBBBB", + "token": "ZA_iib0PnAOJDaYu7ptZ0zoImSGUu-GmRidjh9GQAA", + "canonical": "" + }, + { + "id": 10, + "moves": "1U2", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU LLLLLRRRRRRRRRRRRRRRRRRRR BBBBBFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD RRRRRLLLLLLLLLLLLLLLLLLLL FFFFFBBBBBBBBBBBBBBBBBBBB", + "token": "Atvh5rKxpC5y1uBnX4whM6Vn4bmI1GDCxkekXAIWAA", + "canonical": "" + }, + { + "id": 11, + "moves": "1U2", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU LLLLLRRRRRRRRRRRRRRRRRRRR BBBBBFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD RRRRRLLLLLLLLLLLLLLLLLLLL FFFFFBBBBBBBBBBBBBBBBBBBB", + "token": "Tp7ERvvv6-acyJCwIDogw7N4NdCHN3dCtrdooDIQAA", + "canonical": "" + }, + { + "id": 10, + "moves": "1U'", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU FFFFFRRRRRRRRRRRRRRRRRRRR LLLLLFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD BBBBBLLLLLLLLLLLLLLLLLLLL RRRRRBBBBBBBBBBBBBBBBBBBB", + "token": "AXWQoxVSOUO0kDQXlv8aXbP7wEZ6YoO7d0Z3hvFSAA", + "canonical": "" + }, + { + "id": 11, + "moves": "1U'", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU FFFFFRRRRRRRRRRRRRRRRRRRR LLLLLFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD BBBBBLLLLLLLLLLLLLLLLLLLL RRRRRBBBBBBBBBBBBBBBBBBBB", + "token": "LQcl8Dr95eTGKGk1UwF8tRFVEwcsir6TTps0pp-wAA", + "canonical": "" + }, + { + "id": 10, + "moves": "2U", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRBBBBBRRRRRRRRRRRRRRR FFFFFRRRRRFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLFFFFFLLLLLLLLLLLLLLL BBBBBLLLLLBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAL3V4l31Siu1fqL2uG6vBm1abcgm", + "canonical": "" + }, + { + "id": 11, + "moves": "2U", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRBBBBBRRRRRRRRRRRRRRR FFFFFRRRRRFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLFFFFFLLLLLLLLLLLLLLL BBBBBLLLLLBBBBBBBBBBBBBBB", + "token": "CgGWpjtIh4vYo4gb6-qQ3CD8nKmnwHmmJomkB6SsOQ", + "canonical": "" + }, + { + "id": 10, + "moves": "2U2", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRLLLLLRRRRRRRRRRRRRRR FFFFFBBBBBFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLRRRRRLLLLLLLLLLLLLLL BBBBBFFFFFBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAI6NkbSmL7z6lfq6J5wVU5E6OeSn", + "canonical": "" + }, + { + "id": 11, + "moves": "2U2", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRLLLLLRRRRRRRRRRRRRRR FFFFFBBBBBFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLRRRRRLLLLLLLLLLLLLLL BBBBBFFFFFBBBBBBBBBBBBBBB", + "token": "CgGWpjtIh4vYo4fU_3GS5XlWhEyrZaBqP_1Z11bW-o", + "canonical": "" + }, + { + "id": 10, + "moves": "2U'", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRFFFFFRRRRRRRRRRRRRRR FFFFFLLLLLFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLBBBBBLLLLLLLLLLLLLLL BBBBBRRRRRBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAC_7xpCMvG8iucNOcTL3AYXvQGxh", + "canonical": "" + }, + { + "id": 11, + "moves": "2U'", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRFFFFFRRRRRRRRRRRRRRR FFFFFLLLLLFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLBBBBBLLLLLLLLLLLLLLL BBBBBRRRRRBBBBBBBBBBBBBBB", + "token": "CgGWpjtIh4vYo4dHJMDcv0xhwIJYRA7MkoJI5uCikY", + "canonical": "" + }, + { + "id": 10, + "moves": "3U", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRBBBBBRRRRRRRRRR FFFFFFFFFFRRRRRFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLFFFFFLLLLLLLLLL BBBBBBBBBBLLLLLBBBBBBBBBB", + "token": "AXYjA3aY-LGr3vSwR1cJtupfx8I8iBCosdHNOKbbE6", + "canonical": "UUUUUUUUUUUUUUUUUUUUUUUUU FFFFFFFFFFRRRRRFFFFFFFFFF LLLLLLLLLLFFFFFLLLLLLLLLL DDDDDDDDDDDDDDDDDDDDDDDDD BBBBBBBBBBLLLLLBBBBBBBBBB RRRRRRRRRRBBBBBRRRRRRRRRR" + }, + { + "id": 11, + "moves": "3U", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRBBBBBRRRRRRRRRR FFFFFFFFFFRRRRRFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLFFFFFLLLLLLLLLL BBBBBBBBBBLLLLLBBBBBBBBBB", + "token": "LRTe-Vmf2DP1ineF2z_tEiq1xqFgD_TQy6s9T6SJ1x", + "canonical": "" + }, + { + "id": 10, + "moves": "3U2", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRLLLLLRRRRRRRRRR FFFFFFFFFFBBBBBFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLRRRRRLLLLLLLLLL BBBBBBBBBBFFFFFBBBBBBBBBB", + "token": "AtzmIEMvsWeraPNMULnV7IlYQ9PDWcVDmj0Q3HUEuz", + "canonical": "UUUUUUUUUUUUUUUUUUUUUUUUU LLLLLLLLLLRRRRRLLLLLLLLLL BBBBBBBBBBFFFFFBBBBBBBBBB DDDDDDDDDDDDDDDDDDDDDDDDD RRRRRRRRRRLLLLLRRRRRRRRRR FFFFFFFFFFBBBBBFFFFFFFFFF" + }, + { + "id": 11, + "moves": "3U2", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRLLLLLRRRRRRRRRR FFFFFFFFFFBBBBBFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLRRRRRLLLLLLLLLL BBBBBBBBBBFFFFFBBBBBBBBBB", + "token": "TrcprIfBKUPqelYmvIMSGRIBaEYDuONWlbmUqvhxjK", + "canonical": "" + }, + { + "id": 10, + "moves": "3U'", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRFFFFFRRRRRRRRRR FFFFFFFFFFLLLLLFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLBBBBBLLLLLLLLLL BBBBBBBBBBRRRRRBBBBBBBBBB", + "token": "A8G9P5KhVRgFo_qka97faW5v2Dc0_mLwnicxGLIjme", + "canonical": "UUUUUUUUUUUUUUUUUUUUUUUUU BBBBBBBBBBRRRRRBBBBBBBBBB RRRRRRRRRRFFFFFRRRRRRRRRR DDDDDDDDDDDDDDDDDDDDDDDDD FFFFFFFFFFLLLLLFFFFFFFFFF LLLLLLLLLLBBBBBLLLLLLLLLL" + }, + { + "id": 11, + "moves": "3U'", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRFFFFFRRRRRRRRRR FFFFFFFFFFLLLLLFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLBBBBBLLLLLLLLLL BBBBBBBBBBRRRRRBBBBBBBBBB", + "token": "ZCtUm_pogcxgAwZpR_v1zow3UZirJ6uO86yaULNWbT", + "canonical": "" + }, + { + "id": 10, + "moves": "1F", + "facelets": "UUUUUUUUUUUUUUUUUUUULLLLL URRRRURRRRURRRRURRRRURRRR FFFFFFFFFFFFFFFFFFFFFFFFF RRRRRDDDDDDDDDDDDDDDDDDDD LLLLDLLLLDLLLLDLLLLDLLLLD BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AgBUZO0wHMvvYm5gbCOjePY8jttotv7nIGiWcyEbAA", + "canonical": "" + }, + { + "id": 11, + "moves": "1F", + "facelets": "UUUUUUUUUUUUUUUUUUUULLLLL URRRRURRRRURRRRURRRRURRRR FFFFFFFFFFFFFFFFFFFFFFFFF RRRRRDDDDDDDDDDDDDDDDDDDD LLLLDLLLLDLLLLDLLLLDLLLLD BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "OgmAHHfLOqpJ3eAJTm5XQ0docP2EdkqrKc4ayxqIAA", + "canonical": "" + }, + { + "id": 10, + "moves": "1F2", + "facelets": "UUUUUUUUUUUUUUUUUUUUDDDDD LRRRRLRRRRLRRRRLRRRRLRRRR FFFFFFFFFFFFFFFFFFFFFFFFF UUUUUDDDDDDDDDDDDDDDDDDDD LLLLRLLLLRLLLLRLLLLRLLLLR BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "BwqkQ0mWuw4jMT-pGqj6ybuQmsqFWXqTcek0LyAbAA", + "canonical": "" + }, + { + "id": 11, + "moves": "1F2", + "facelets": "UUUUUUUUUUUUUUUUUUUUDDDDD LRRRRLRRRRLRRRRLRRRRLRRRR FFFFFFFFFFFFFFFFFFFFFFFFF UUUUUDDDDDDDDDDDDDDDDDDDD LLLLRLLLLRLLLLRLLLLRLLLLR BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "swD89SFqEN8lQX7Zqu6G1cdJj2gzseLSzdzkawKIAA", + "canonical": "" + }, + { + "id": 10, + "moves": "1F'", + "facelets": "UUUUUUUUUUUUUUUUUUUURRRRR DRRRRDRRRRDRRRRDRRRRDRRRR FFFFFFFFFFFFFFFFFFFFFFFFF LLLLLDDDDDDDDDDDDDDDDDDDD LLLLULLLLULLLLULLLLULLLLU BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "BQpV_z9jEjRLWcONqvE5lzrMTCgOQviCAlxarTZrAA", + "canonical": "" + }, + { + "id": 11, + "moves": "1F'", + "facelets": "UUUUUUUUUUUUUUUUUUUURRRRR DRRRRDRRRRDRRRRDRRRRDRRRR FFFFFFFFFFFFFFFFFFFFFFFFF LLLLLDDDDDDDDDDDDDDDDDDDD LLLLULLLLULLLLULLLLULLLLU BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "gvmmlCySPHLpDdxHMbRqGbTiMC0JlbEwWKiAPRoIAA", + "canonical": "" + }, + { + "id": 10, + "moves": "2F", + "facelets": "UUUUUUUUUUUUUUULLLLLUUUUU RURRRRURRRRURRRRURRRRURRR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDRRRRRDDDDDDDDDDDDDDD LLLDLLLLDLLLLDLLLLDLLLLDL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAYidvOjz1fBPwGOjtgeTHZZSu4-IFE", + "canonical": "" + }, + { + "id": 11, + "moves": "2F", + "facelets": "UUUUUUUUUUUUUUULLLLLUUUUU RURRRRURRRRURRRRURRRRURRR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDRRRRRDDDDDDDDDDDDDDD LLLDLLLLDLLLLDLLLLDLLLLDL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "CgGWpjtIh4vYyFXI4O3f-rk1FcMMXxrK5hfBlXTB5g", + "canonical": "" + }, + { + "id": 10, + "moves": "2F2", + "facelets": "UUUUUUUUUUUUUUUDDDDDUUUUU RLRRRRLRRRRLRRRRLRRRRLRRR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDUUUUUDDDDDDDDDDDDDDD LLLRLLLLRLLLLRLLLLRLLLLRL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAP9CbGtYWAnfOj1ikIJtFnIjBYdm-e", + "canonical": "" + }, + { + "id": 11, + "moves": "2F2", + "facelets": "UUUUUUUUUUUUUUUDDDDDUUUUU RLRRRRLRRRRLRRRRLRRRRLRRR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDUUUUUDDDDDDDDDDDDDDD LLLRLLLLRLLLLRLLLLRLLLLRL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "CgGWpjtIh4vYu3U5VSdMLR6ogizw2p86OrNIhLGnbQ", + "canonical": "" + }, + { + "id": 10, + "moves": "2F'", + "facelets": "UUUUUUUUUUUUUUURRRRRUUUUU RDRRRRDRRRRDRRRRDRRRRDRRR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDLLLLLDDDDDDDDDDDDDDD LLLULLLLULLLLULLLLULLLLUL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAC-nbNtoruZJJwIjhwOoH8jmeDsG0q", + "canonical": "" + }, + { + "id": 11, + "moves": "2F'", + "facelets": "UUUUUUUUUUUUUUURRRRRUUUUU RDRRRRDRRRRDRRRRDRRRRDRRR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDLLLLLDDDDDDDDDDDDDDD LLLULLLLULLLLULLLLULLLLUL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "CgGWpjtIh4vYp_6xX6jUUciWtJ8H9rzDGtWbRYijvw", + "canonical": "" + }, + { + "id": 10, + "moves": "3F", + "facelets": "UUUUUUUUUULLLLLUUUUUUUUUU RRURRRRURRRRURRRRURRRRURR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDRRRRRDDDDDDDDDD LLDLLLLDLLLLDLLLLDLLLLDLL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "BRb1l0dfp0nSriEB_pI47nEbPzyi8SLidgcDi9k2qg", + "canonical": "RRRRRRRRRRUUUUURRRRRRRRRR DDRDDDDRDDDDRDDDDRDDDDRDD FFFFFFFFFFFFFFFFFFFFFFFFF LLLLLLLLLLDDDDDLLLLLLLLLL UULUUUULUUUULUUUULUUUULUU BBBBBBBBBBBBBBBBBBBBBBBBB" + }, + { + "id": 11, + "moves": "3F", + "facelets": "UUUUUUUUUULLLLLUUUUUUUUUU RRURRRRURRRRURRRRURRRRURR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDRRRRRDDDDDDDDDD LLDLLLLDLLLLDLLLLDLLLLDLL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "hCic1OxANneY9p8vCMxaRsxI-hr56ao7MKhVHF0f8Q", + "canonical": "" + }, + { + "id": 10, + "moves": "3F2", + "facelets": "UUUUUUUUUUDDDDDUUUUUUUUUU RRLRRRRLRRRRLRRRRLRRRRLRR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDUUUUUDDDDDDDDDD LLRLLLLRLLLLRLLLLRLLLLRLL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "BySgQscBEqW3N1sQ5SE9NeVUs6zumBl2VZnoroVhdo", + "canonical": "DDDDDDDDDDUUUUUDDDDDDDDDD LLRLLLLRLLLLRLLLLRLLLLRLL FFFFFFFFFFFFFFFFFFFFFFFFF UUUUUUUUUUDDDDDUUUUUUUUUU RRLRRRRLRRRRLRRRRLRRRRLRR BBBBBBBBBBBBBBBBBBBBBBBBB" + }, + { + "id": 11, + "moves": "3F2", + "facelets": "UUUUUUUUUUDDDDDUUUUUUUUUU RRLRRRRLRRRRLRRRRLRRRRLRR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDUUUUUDDDDDDDDDD LLRLLLLRLLLLRLLLLRLLLLRLL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "tXCc6ONiRxUF1BCUpjTA-bGr5KIRkMgYJm3QXIEjHK", + "canonical": "" + }, + { + "id": 10, + "moves": "3F'", + "facelets": "UUUUUUUUUURRRRRUUUUUUUUUU RRDRRRRDRRRRDRRRRDRRRRDRR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDLLLLLDDDDDDDDDD LLULLLLULLLLULLLLULLLLULL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AhdvjpcXJ65WssGWMR8ogq-FhvatjipB2fqudKb8ew", + "canonical": "LLLLLLLLLLUUUUULLLLLLLLLL UURUUUURUUUURUUUURUUUURUU FFFFFFFFFFFFFFFFFFFFFFFFF RRRRRRRRRRDDDDDRRRRRRRRRR DDLDDDDLDDDDLDDDDLDDDDLDD BBBBBBBBBBBBBBBBBBBBBBBBB" + }, + { + "id": 11, + "moves": "3F'", + "facelets": "UUUUUUUUUURRRRRUUUUUUUUUU RRDRRRRDRRRRDRRRRDRRRRDRR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDLLLLLDDDDDDDDDD LLULLLLULLLLULLLLULLLLULL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "PDQMBGV0P-P5Za0TxgLQLKY_s4v4olssj4Ba76eriU", + "canonical": "" + }, + { + "id": 10, + "moves": "1L", + "facelets": "BUUUUBUUUUBUUUUBUUUUBUUUU RRRRRRRRRRRRRRRRRRRRRRRRR UFFFFUFFFFUFFFFUFFFFUFFFF FDDDDFDDDDFDDDDFDDDDFDDDD LLLLLLLLLLLLLLLLLLLLLLLLL BBBBDBBBBDBBBBDBBBBDBBBBD", + "token": "AE4t-lzgq-SgpexKHPEOhv7xKYaW7FYZsAaX4KlO4A", + "canonical": "" + }, + { + "id": 11, + "moves": "1L", + "facelets": "BUUUUBUUUUBUUUUBUUUUBUUUU RRRRRRRRRRRRRRRRRRRRRRRRR UFFFFUFFFFUFFFFUFFFFUFFFF FDDDDFDDDDFDDDDFDDDDFDDDD LLLLLLLLLLLLLLLLLLLLLLLLL BBBBDBBBBDBBBBDBBBBDBBBBD", + "token": "EVXmHvBYpProMa3x4bBglBhW8QnZdndooJ49D99lAA", + "canonical": "" + }, + { + "id": 10, + "moves": "1L2", + "facelets": "DUUUUDUUUUDUUUUDUUUUDUUUU RRRRRRRRRRRRRRRRRRRRRRRRR BFFFFBFFFFBFFFFBFFFFBFFFF UDDDDUDDDDUDDDDUDDDDUDDDD LLLLLLLLLLLLLLLLLLLLLLLLL BBBBFBBBBFBBBBFBBBBFBBBBF", + "token": "AQcltfv06egvWM2-N7Aqg7y_Zv_XUtOpaOQCgo7j4A", + "canonical": "" + }, + { + "id": 11, + "moves": "1L2", + "facelets": "DUUUUDUUUUDUUUUDUUUUDUUUU RRRRRRRRRRRRRRRRRRRRRRRRR BFFFFBFFFFBFFFFBFFFFBFFFF UDDDDUDDDDUDDDDUDDDDUDDDD LLLLLLLLLLLLLLLLLLLLLLLLL BBBBFBBBBFBBBBFBBBBFBBBBF", + "token": "Iq0ftdo-dVBI9tDUY5sAReOstGfjEjzh9WA8PWVdAA", + "canonical": "" + }, + { + "id": 10, + "moves": "1L'", + "facelets": "FUUUUFUUUUFUUUUFUUUUFUUUU RRRRRRRRRRRRRRRRRRRRRRRRR DFFFFDFFFFDFFFFDFFFFDFFFF BDDDDBDDDDBDDDDBDDDDBDDDD LLLLLLLLLLLLLLLLLLLLLLLLL BBBBUBBBBUBBBBUBBBBUBBBBU", + "token": "ALkKHdEJ42SjeQAYK7xErRrUhd8Tu3jdi4kihKiuYA", + "canonical": "" + }, + { + "id": 11, + "moves": "1L'", + "facelets": "FUUUUFUUUUFUUUUFUUUUFUUUU RRRRRRRRRRRRRRRRRRRRRRRRR DFFFFDFFFFDFFFFDFFFFDFFFF BDDDDBDDDDBDDDDBDDDDBDDDD LLLLLLLLLLLLLLLLLLLLLLLLL BBBBUBBBBUBBBBUBBBBUBBBBU", + "token": "G1qJcdQ12Psr-4lDRL10JrWnmVWM4bnFNNs8b9BZAA", + "canonical": "" + }, + { + "id": 10, + "moves": "2L", + "facelets": "UBUUUUBUUUUBUUUUBUUUUBUUU RRRRRRRRRRRRRRRRRRRRRRRRR FUFFFFUFFFFUFFFFUFFFFUFFF DFDDDDFDDDDFDDDDFDDDDFDDD LLLLLLLLLLLLLLLLLLLLLLLLL BBBDBBBBDBBBBDBBBBDBBBBDB", + "token": "AAAAAAAAAAAEGQ5j4wpvS7x6RkFP9igg887prBL5Jy", + "canonical": "" + }, + { + "id": 11, + "moves": "2L", + "facelets": "UBUUUUBUUUUBUUUUBUUUUBUUU RRRRRRRRRRRRRRRRRRRRRRRRR FUFFFFUFFFFUFFFFUFFFFUFFF DFDDDDFDDDDFDDDDFDDDDFDDD LLLLLLLLLLLLLLLLLLLLLLLLL BBBDBBBBDBBBBDBBBBDBBBBDB", + "token": "CgGWpjtIh4w6_OBcdBFzBd0xoosyYigW-2XoIcdbqw", + "canonical": "" + }, + { + "id": 10, + "moves": "2L2", + "facelets": "UDUUUUDUUUUDUUUUDUUUUDUUU RRRRRRRRRRRRRRRRRRRRRRRRR FBFFFFBFFFFBFFFFBFFFFBFFF DUDDDDUDDDDUDDDDUDDDDUDDD LLLLLLLLLLLLLLLLLLLLLLLLL BBBFBBBBFBBBBFBBBBFBBBBFB", + "token": "AAAAAAAAAAACJFNOrGCi-c8C3f6rsVcTqPW3MMN7bI", + "canonical": "" + }, + { + "id": 11, + "moves": "2L2", + "facelets": "UDUUUUDUUUUDUUUUDUUUUDUUU RRRRRRRRRRRRRRRRRRRRRRRRR FBFFFFBFFFFBFFFFBFFFFBFFF DUDDDDUDDDDUDDDDUDDDDUDDD LLLLLLLLLLLLLLLLLLLLLLLLL BBBFBBBBFBBBBFBBBBFBBBBFB", + "token": "CgGWpjtIh4wMC1ZfVCZLV5n_3EvL7o7X9wksklOSLA", + "canonical": "" + }, + { + "id": 10, + "moves": "2L'", + "facelets": "UFUUUUFUUUUFUUUUFUUUUFUUU RRRRRRRRRRRRRRRRRRRRRRRRR FDFFFFDFFFFDFFFFDFFFFDFFF DBDDDDBDDDDBDDDDBDDDDBDDD LLLLLLLLLLLLLLLLLLLLLLLLL BBBUBBBBUBBBBUBBBBUBBBBUB", + "token": "AAAAAAAAAAABbj3Sl9xKLrrqFFAzLX_QYHj44p8Yac", + "canonical": "" + }, + { + "id": 11, + "moves": "2L'", + "facelets": "UFUUUUFUUUUFUUUUFUUUUFUUU RRRRRRRRRRRRRRRRRRRRRRRRR FDFFFFDFFFFDFFFFDFFFFDFFF DBDDDDBDDDDBDDDDBDDDDBDDD LLLLLLLLLLLLLLLLLLLLLLLLL BBBUBBBBUBBBBUBBBBUBBBBUB", + "token": "CgGWpjtIh4v6-VK9Z734Tbes8_B_kmCJK1dVPupJ6g", + "canonical": "" + }, + { + "id": 10, + "moves": "1D", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRFFFFF FFFFFFFFFFFFFFFFFFFFLLLLL DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLBBBBB BBBBBBBBBBBBBBBBBBBBRRRRR", + "token": "AACSYGFGv233TsCWWgwxmU0WT5ZqNvS8nDn2hu96EA", + "canonical": "" + }, + { + "id": 11, + "moves": "1D", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRFFFFF FFFFFFFFFFFFFFFFFFFFLLLLL DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLBBBBB BBBBBBBBBBBBBBBBBBBBRRRRR", + "token": "Cg9Pr1nqedsIBZUXnDuqS2vSgoWodVauxW8cpnNxgA", + "canonical": "" + }, + { + "id": 10, + "moves": "1D2", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRLLLLL FFFFFFFFFFFFFFFFFFFFBBBBB DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLRRRRR BBBBBBBBBBBBBBBBBBBBFFFFF", + "token": "AAEEOZB-DTk4khLcXbYsX_lYT2TntZR2hGuFGeFjkA", + "canonical": "" + }, + { + "id": 11, + "moves": "1D2", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRLLLLL FFFFFFFFFFFFFFFFFFFFBBBBB DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLRRRRR BBBBBBBBBBBBBBBBBBBBFFFFF", + "token": "Chn8C8cZxOkmVUun9Css65ICfeFsVFAcihR6bSFVgA", + "canonical": "" + }, + { + "id": 10, + "moves": "1D'", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRBBBBB FFFFFFFFFFFFFFFFFFFFRRRRR DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLFFFFF BBBBBBBBBBBBBBBBBBBBLLLLL", + "token": "AAEkwMKOXuheSjlMEbTBhRMOMw5rHJ8ENDjXBXLsEA", + "canonical": "" + }, + { + "id": 11, + "moves": "1D'", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRBBBBB FFFFFFFFFFFFFFFFFFFFRRRRR DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLFFFFF BBBBBBBBBBBBBBBBBBBBLLLLL", + "token": "Ch0IuHihbVSvmOYg1AkoZfsP1cW9_U1lBVQogsYhgA", + "canonical": "" + }, + { + "id": 10, + "moves": "2D", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRFFFFFRRRRR FFFFFFFFFFFFFFFLLLLLFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLBBBBBLLLLL BBBBBBBBBBBBBBBRRRRRBBBBB", + "token": "AAAAAAAAAAAAAAAAKrD-9zaEDu_KKb9rnV_jRdZnA4", + "canonical": "" + }, + { + "id": 11, + "moves": "2D", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRFFFFFRRRRR FFFFFFFFFFFFFFFLLLLLFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLBBBBBLLLLL BBBBBBBBBBBBBBBRRRRRBBBBB", + "token": "CgGWpjtIh4vYo4cDK67rGU4ccuanOFcW4P1OjBmoVA", + "canonical": "" + }, + { + "id": 10, + "moves": "2D2", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRLLLLLRRRRR FFFFFFFFFFFFFFFBBBBBFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLRRRRRLLLLL BBBBBBBBBBBBBBBFFFFFBBBBB", + "token": "AAAAAAAAAAAAAAAAfsDa-4-sQD3uvk5D2f-fTNfavP", + "canonical": "" + }, + { + "id": 11, + "moves": "2D2", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRLLLLLRRRRR FFFFFFFFFFFFFFFBBBBBFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLRRRRRLLLLL BBBBBBBBBBBBBBBFFFFFBBBBB", + "token": "CgGWpjtIh4vYo4cLDSuLganhEjoVJbtcj_bvNDyBto", + "canonical": "" + }, + { + "id": 10, + "moves": "2D'", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRBBBBBRRRRR FFFFFFFFFFFFFFFRRRRRFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLFFFFFLLLLL BBBBBBBBBBBBBBBLLLLLBBBBB", + "token": "AAAAAAAAAAAAAAAAqMgesNS499SR2E_us0SGFLpez4", + "canonical": "" + }, + { + "id": 11, + "moves": "2D'", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRBBBBBRRRRR FFFFFFFFFFFFFFFRRRRRFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLFFFFFLLLLL BBBBBBBBBBBBBBBLLLLLBBBBB", + "token": "CgGWpjtIh4vYo4cO_dnkgCMSSFlfleNg7myR8XjjdA", + "canonical": "" + }, + { + "id": 10, + "moves": "1B", + "facelets": "RRRRRUUUUUUUUUUUUUUUUUUUU RRRRDRRRRDRRRRDRRRRDRRRRD FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDLLLLL ULLLLULLLLULLLLULLLLULLLL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AA5GdZLPDsCKhSdP0A9VI5DefmD-lZEvWjRJs7F00A", + "canonical": "" + }, + { + "id": 11, + "moves": "1B", + "facelets": "RRRRRUUUUUUUUUUUUUUUUUUUU RRRRDRRRRDRRRRDRRRRDRRRRD FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDLLLLL ULLLLULLLLULLLLULLLLULLLL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "C1gxq_6x6ZjVHzZ6rIb_QcaW5YORVAFwlObo2KLzgA", + "canonical": "" + }, + { + "id": 10, + "moves": "1B2", + "facelets": "DDDDDUUUUUUUUUUUUUUUUUUUU RRRRLRRRRLRRRRLRRRRLRRRRL FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDUUUUU RLLLLRLLLLRLLLLRLLLLRLLLL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AC1MRTaXAESLaFVRl-D-0RYaZpFqp-H3ch-kDKbdcA", + "canonical": "" + }, + { + "id": 11, + "moves": "1B2", + "facelets": "DDDDDUUUUUUUUUUUUUUUUUUUU RRRRLRRRRLRRRRLRRRRLRRRRL FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDUUUUU RLLLLRLLLLRLLLLRLLLLRLLLL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "DkC9I1lwjfjqa4alaC7nhkQ0qg2zC5Qy0vdhL6TCgA", + "canonical": "" + }, + { + "id": 10, + "moves": "1B'", + "facelets": "LLLLLUUUUUUUUUUUUUUUUUUUU RRRRURRRRURRRRURRRRURRRRU FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDRRRRR DLLLLDLLLLDLLLLDLLLLDLLLL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AB8cbvu6lmzWcfEQ0UnElcV-NqQNugwZbjtQZXhYoA", + "canonical": "" + }, + { + "id": 11, + "moves": "1B'", + "facelets": "LLLLLUUUUUUUUUUUUUUUUUUUU RRRRURRRRURRRRURRRRURRRRU FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDRRRRR DLLLLDLLLLDLLLLDLLLLDLLLL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "DOxBDdTGob_zUiCSygFx9rWQK8z8v4didY-Jg0hPAA", + "canonical": "" + }, + { + "id": 10, + "moves": "2B", + "facelets": "UUUUURRRRRUUUUUUUUUUUUUUU RRRDRRRRDRRRRDRRRRDRRRRDR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDLLLLLDDDDD LULLLLULLLLULLLLULLLLULLL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAC_gx46u4mKKiXtuC7BJkpWGv0MrHgI", + "canonical": "" + }, + { + "id": 11, + "moves": "2B", + "facelets": "UUUUURRRRRUUUUUUUUUUUUUUU RRRDRRRRDRRRRDRRRRDRRRRDR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDLLLLLDDDDD LULLLLULLLLULLLLULLLLULLL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "CgGWpjtIh4vZwsusgzBSO3Dz8P_5cB5voSh7kwK0DA", + "canonical": "" + }, + { + "id": 10, + "moves": "2B2", + "facelets": "UUUUUDDDDDUUUUUUUUUUUUUUU RRRLRRRRLRRRRLRRRRLRRRRLR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDUUUUUDDDDD LRLLLLRLLLLRLLLLRLLLLRLLL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAGdLfgk2RscKAem5tymvcSpKZmyCCBW", + "canonical": "" + }, + { + "id": 11, + "moves": "2B2", + "facelets": "UUUUUDDDDDUUUUUUUUUUUUUUU RRRLRRRRLRRRRLRRRRLRRRRLR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDUUUUUDDDDD LRLLLLRLLLLRLLLLRLLLLRLLL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "CgGWpjtIh4vbD0vzYlyslm3GhsX-SIGnHb5miwwwgQ", + "canonical": "" + }, + { + "id": 10, + "moves": "2B'", + "facelets": "UUUUULLLLLUUUUUUUUUUUUUUU RRRURRRRURRRRURRRRURRRRUR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDRRRRRDDDDD LDLLLLDLLLLDLLLLDLLLLDLLL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAHcg1qag9cY2h_9e97vGnGQE0jaJkfA", + "canonical": "" + }, + { + "id": 11, + "moves": "2B'", + "facelets": "UUUUULLLLLUUUUUUUUUUUUUUU RRRURRRRURRRRURRRRURRRRUR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDRRRRRDDDDD LDLLLLDLLLLDLLLLDLLLLDLLL BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "CgGWpjtIh4vbbkwHEtzGkXjrCKWBtQyqeBztRzlroA", + "canonical": "" + }, + { + "id": 10, + "moves": "x", + "facelets": "FFFFFFFFFFFFFFFFFFFFFFFFF RRRRRRRRRRRRRRRRRRRRRRRRR DDDDDDDDDDDDDDDDDDDDDDDDD BBBBBBBBBBBBBBBBBBBBBBBBB LLLLLLLLLLLLLLLLLLLLLLLLL UUUUUUUUUUUUUUUUUUUUUUUUU", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBB" + }, + { + "id": 11, + "moves": "x", + "facelets": "FFFFFFFFFFFFFFFFFFFFFFFFF RRRRRRRRRRRRRRRRRRRRRRRRR DDDDDDDDDDDDDDDDDDDDDDDDD BBBBBBBBBBBBBBBBBBBBBBBBB LLLLLLLLLLLLLLLLLLLLLLLLL UUUUUUUUUUUUUUUUUUUUUUUUU", + "token": "CgGWpjtIh4vYo4b_KxcD7DG7DGuzTmUAIAAAAAAAAE", + "canonical": "" + }, + { + "id": 10, + "moves": "x2", + "facelets": "DDDDDDDDDDDDDDDDDDDDDDDDD RRRRRRRRRRRRRRRRRRRRRRRRR BBBBBBBBBBBBBBBBBBBBBBBBB UUUUUUUUUUUUUUUUUUUUUUUUU LLLLLLLLLLLLLLLLLLLLLLLLL FFFFFFFFFFFFFFFFFFFFFFFFF", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBB" + }, + { + "id": 11, + "moves": "x2", + "facelets": "DDDDDDDDDDDDDDDDDDDDDDDDD RRRRRRRRRRRRRRRRRRRRRRRRR BBBBBBBBBBBBBBBBBBBBBBBBB UUUUUUUUUUUUUUUUUUUUUUUUU LLLLLLLLLLLLLLLLLLLLLLLLL FFFFFFFFFFFFFFFFFFFFFFFFF", + "token": "CgGWpjtIh4vYo4b_KxcD7DG7DGuzTmUAIAAAAAAAAI", + "canonical": "" + }, + { + "id": 10, + "moves": "x'", + "facelets": "BBBBBBBBBBBBBBBBBBBBBBBBB RRRRRRRRRRRRRRRRRRRRRRRRR UUUUUUUUUUUUUUUUUUUUUUUUU FFFFFFFFFFFFFFFFFFFFFFFFF LLLLLLLLLLLLLLLLLLLLLLLLL DDDDDDDDDDDDDDDDDDDDDDDDD", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBB" + }, + { + "id": 11, + "moves": "x'", + "facelets": "BBBBBBBBBBBBBBBBBBBBBBBBB RRRRRRRRRRRRRRRRRRRRRRRRR UUUUUUUUUUUUUUUUUUUUUUUUU FFFFFFFFFFFFFFFFFFFFFFFFF LLLLLLLLLLLLLLLLLLLLLLLLL DDDDDDDDDDDDDDDDDDDDDDDDD", + "token": "CgGWpjtIh4vYo4b_KxcD7DG7DGuzTmUAIAAAAAAAAM", + "canonical": "" + }, + { + "id": 10, + "moves": "y", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU BBBBBBBBBBBBBBBBBBBBBBBBB RRRRRRRRRRRRRRRRRRRRRRRRR DDDDDDDDDDDDDDDDDDDDDDDDD FFFFFFFFFFFFFFFFFFFFFFFFF LLLLLLLLLLLLLLLLLLLLLLLLL", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBB" + }, + { + "id": 11, + "moves": "y", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU BBBBBBBBBBBBBBBBBBBBBBBBB RRRRRRRRRRRRRRRRRRRRRRRRR DDDDDDDDDDDDDDDDDDDDDDDDD FFFFFFFFFFFFFFFFFFFFFFFFF LLLLLLLLLLLLLLLLLLLLLLLLL", + "token": "CgGWpjtIh4vYo4b_KxcD7DG7DGuzTmUAIAAAAAAAAB", + "canonical": "" + }, + { + "id": 10, + "moves": "y2", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU LLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBB DDDDDDDDDDDDDDDDDDDDDDDDD RRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFF", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBB" + }, + { + "id": 11, + "moves": "y2", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU LLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBB DDDDDDDDDDDDDDDDDDDDDDDDD RRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFF", + "token": "CgGWpjtIh4vYo4b_KxcD7DG7DGuzTmUAIAAAAAAAAC", + "canonical": "" + }, + { + "id": 10, + "moves": "y'", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU FFFFFFFFFFFFFFFFFFFFFFFFF LLLLLLLLLLLLLLLLLLLLLLLLL DDDDDDDDDDDDDDDDDDDDDDDDD BBBBBBBBBBBBBBBBBBBBBBBBB RRRRRRRRRRRRRRRRRRRRRRRRR", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBB" + }, + { + "id": 11, + "moves": "y'", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUU FFFFFFFFFFFFFFFFFFFFFFFFF LLLLLLLLLLLLLLLLLLLLLLLLL DDDDDDDDDDDDDDDDDDDDDDDDD BBBBBBBBBBBBBBBBBBBBBBBBB RRRRRRRRRRRRRRRRRRRRRRRRR", + "token": "CgGWpjtIh4vYo4b_KxcD7DG7DGuzTmUAIAAAAAAAAD", + "canonical": "" + }, + { + "id": 10, + "moves": "z", + "facelets": "LLLLLLLLLLLLLLLLLLLLLLLLL UUUUUUUUUUUUUUUUUUUUUUUUU FFFFFFFFFFFFFFFFFFFFFFFFF RRRRRRRRRRRRRRRRRRRRRRRRR DDDDDDDDDDDDDDDDDDDDDDDDD BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBB" + }, + { + "id": 11, + "moves": "z", + "facelets": "LLLLLLLLLLLLLLLLLLLLLLLLL UUUUUUUUUUUUUUUUUUUUUUUUU FFFFFFFFFFFFFFFFFFFFFFFFF RRRRRRRRRRRRRRRRRRRRRRRRR DDDDDDDDDDDDDDDDDDDDDDDDD BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "CgGWpjtIh4vYo4b_KxcD7DG7DGuzTmUAIAAAAAAAAQ", + "canonical": "" + }, + { + "id": 10, + "moves": "z2", + "facelets": "DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLL FFFFFFFFFFFFFFFFFFFFFFFFF UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRR BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBB" + }, + { + "id": 11, + "moves": "z2", + "facelets": "DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLL FFFFFFFFFFFFFFFFFFFFFFFFF UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRR BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "CgGWpjtIh4vYo4b_KxcD7DG7DGuzTmUAIAAAAAAAAK", + "canonical": "" + }, + { + "id": 10, + "moves": "z'", + "facelets": "RRRRRRRRRRRRRRRRRRRRRRRRR DDDDDDDDDDDDDDDDDDDDDDDDD FFFFFFFFFFFFFFFFFFFFFFFFF LLLLLLLLLLLLLLLLLLLLLLLLL UUUUUUUUUUUUUUUUUUUUUUUUU BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "UUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBB" + }, + { + "id": 11, + "moves": "z'", + "facelets": "RRRRRRRRRRRRRRRRRRRRRRRRR DDDDDDDDDDDDDDDDDDDDDDDDD FFFFFFFFFFFFFFFFFFFFFFFFF LLLLLLLLLLLLLLLLLLLLLLLLL UUUUUUUUUUUUUUUUUUUUUUUUU BBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "CgGWpjtIh4vYo4b_KxcD7DG7DGuzTmUAIAAAAAAAAU", + "canonical": "" + }, + { + "id": 10, + "moves": "5B2 3B 2D 3R' 3F2 3B 4D 2L x' 3U' x' y' 5R2 5D'", + "facelets": "DDBBDDLFDDRRBURDLUDDDFFDD RRURRRDDRLBFLBBRDRRLBDDBB BUUBBFBDBBLLDLLFBFBBLLDLL UULUUURLRBFBFDBFUDUUUULUU LLDLLLULLRFBRFFLUULRFDDFF FUUFFFFUFBRRURRFFBFBRRURR", + "token": "AG3ikF5ytsU7ur3JN98_SzeYwbVm33_ktjpvXUO8tz", + "canonical": "FUUFFFFUFBRRURRFFBFBRRURR FLFLLDUBULDURLDFLFLLFRFRL UULUUUUDUFBDFBFBRLRUUULUU LLDLLBBFBFLLDLLBBDBFBBUUB RLBLBRRBRBUDLRDRDFDDRRBRB DDBBDDLFDDRRBURDLUDDDFFDD" + }, + { + "id": 11, + "moves": "5B2 3B 2D 3R' 3F2 3B 4D 2L x' 3U' x' y' 5R2 5D'", + "facelets": "DDBBDDLFDDRRBURDLUDDDFFDD RRURRRDDRLBFLBBRDRRLBDDBB BUUBBFBDBBLLDLLFBFBBLLDLL UULUUURLRBFBFDBFUDUUUULUU LLDLLLULLRFBRFFLUULRFDDFF FUUFFFFUFBRRURRFFBFBRRURR", + "token": "FE7ULxYJqglyJVHcaATy-WgNNW1YQmJxNXpwvlmxLW", + "canonical": "" + }, + { + "id": 10, + "moves": "3B 5F' 5R 4U2 5B' 3U' 2U2 4R2 2R2 2B y 5D y' 4B2", + "facelets": "RRRULRLLDLRFRUUDUDUBFRFFU LULBDLRLUDFBFDFURLULUUDBD LULLBBFBFUURURDFFFBFFBFBF RRRRRLDLLLBRLRLLRBRUBDLLL BFBRUUDDLDBUBBRRDDLDUFUBD FRDDDFFFBFUUDUDDBFBFBDBBR", + "token": "ApAxJ-tB_2b7c_vsY9ygUb1j86TUFsNHoTP7cNGMO7", + "canonical": "FFUBLBFRFUFFUBLBBRFLFFDUB UFFRFBUDUDUURFRLDLLRLURRR UUFLLURBRUDLFLLBUDUBDLFDD BDUFFDBUFRBFDFDBBUBDRFDFD RRRRRLDLLLBRLRLLRBRUBDLLL UDRDDRLBLBBDBDUFDUDFBUBRU" + }, + { + "id": 11, + "moves": "3B 5F' 5R 4U2 5B' 3U' 2U2 4R2 2R2 2B y 5D y' 4B2", + "facelets": "RRRULRLLDLRFRUUDUDUBFRFFU LULBDLRLUDFBFDFURLULUUDBD LULLBBFBFUURURDFFFBFFBFBF RRRRRLDLLLBRLRLLRBRUBDLLL BFBRUUDDLDBUBBRRDDLDUFUBD FRDDDFFFBFUUDUDDBFBFBDBBR", + "token": "R4YyZEl4eTNrgyUoh8YLlfMZ49-VcLO3PN-Sk6Ulmf", + "canonical": "" + }, + { + "id": 10, + "moves": "1L' 1B' 2F2 5B2 5U' 4D 5B 5R 2U2 5F' 5D2 5L 5R' 5D2", + "facelets": "RBUURLUUUURUUUURDDDULFLLL DLLLUDRRRFDRRRFDBLLFLRBBR BRDDBBLRRFULFFFULFFFDDFFF LBRRULDDUDRDDULRDDULRULLD DFDDUBBBFLDLLFRDLLFRBBBDF FBBRFUBBRUUBBFBUBBFBBFFRU", + "token": "B_O2XqGhUMimZDyoWm8iyJpB_37Oc5T2DPg-4M77Lm", + "canonical": "" + }, + { + "id": 11, + "moves": "1L' 1B' 2F2 5B2 5U' 4D 5B 5R 2U2 5F' 5D2 5L 5R' 5D2", + "facelets": "RBUURLUUUURUUUURDDDULFLLL DLLLUDRRRFDRRRFDBLLFLRBBR BRDDBBLRRFULFFFULFFFDDFFF LBRRULDDUDRDDULRDDULRULLD DFDDUBBBFLDLLFRDLLFRBBBDF FBBRFUBBRUUBBFBUBBFBBFFRU", + "token": "yNqvhWJoGltyCTbHpYJGuqfrAE8OJFwRV0XlE2eMWQ", + "canonical": "" + }, + { + "id": 10, + "moves": "2D2 1L' 4F 3U 5B2 1R' 1F2 2L2 1B 1U2 1F2 1F2 2B 1D'", + "facelets": "UUUDDRULLLLUUDFFLLDLLRRUR BBLDLRUBRDBRBRDLRBUUUULUU FDDRDUFFFFURRURLBBBBRLFRB DDRDLDDDDLDDDFDULUDLBFBRL RBULDULLRRUUFFRDULRFUBFFF BBFFFBFDBBBFLBBFFRBFFBLRR", + "token": "BmcFg8BsDdq1igqkMPlXwjTCWOVxWlcXX7a-tfie6c", + "canonical": "DLFLRDLDDUULULRUUULRURLFL FDDRDUFFFFURRURLBBBBRLFRB RBULDULLRRUUFFRDULRFUBFFF BUDDDFLDDDBUDDRRDFDDLLDLL BBFFFBFDBBBFLBBFFRBFFBLRR BBLDLRUBRDBRBRDLRBUUUULUU" + }, + { + "id": 11, + "moves": "2D2 1L' 4F 3U 5B2 1R' 1F2 2L2 1B 1U2 1F2 1F2 2B 1D'", + "facelets": "UUUDDRULLLLUUDFFLLDLLRRUR BBLDLRUBRDBRBRDLRBUUUULUU FDDRDUFFFFURRURLBBBBRLFRB DDRDLDDDDLDDDFDULUDLBFBRL RBULDULLRRUUFFRDULRFUBFFF BBFFFBFDBBBFLBBFFRBFFBLRR", + "token": "o6obAEVp1AzdlIZjwnc-ISPzYe5Txo8xGSHhD07l6h", + "canonical": "" + }, + { + "id": 14, + "moves": "", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "" + }, + { + "id": 15, + "moves": "", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "" + }, + { + "id": 14, + "moves": "4U2 5L2 1B 6D 2D2 2L 3D' 2U2 6D' 2R' 4L 2U' 6U2 2R2", + "facelets": "RRRFFRRFBFBBUUURBUUUUFFUUUUFFUUUUFLU RRRRLDFFFBBFRRRRRDBBFBDBULLLLLULLLLL FFFLUFRRRRUUFUFUUFLLLUUDBUFULBBUDBLB LBFLBLDBBDFDDLLDRDDFFDBDDDBDDDDBFDBD UULLLLFUDFBFULLLLLBUBBBBRRRRRDRRRRRD BDRBBBDDLLLLBDDBDBUDDRRRFRDFDFFRFUDF", + "token": "D7yX7dx5mYqUmVrOxHDz7R6n02PdjOByP3Yy1dIE3VXX3PviVRk4SFbrmD_aDBvcE", + "canonical": "UUBRFRLLBRFRLLFRFRLLBRBRLLDRBLLLBDFD RBUUUUFBBFFLFFRFFFRBUUUURFUUUURRUUUU FFUBDBRRDDDDFDDDLRUFRBLBDDRDLBFFRBLB RRBUFURRULUURRBLDLRRBLFLRRBLBLDDBLFL LDDDDDBFRBDBLDDDDDFBLFBFBBLFDBLDDDDD FUFDBBUUUULLLRUUUBFRFLFDFRULUUFRFLBB" + }, + { + "id": 15, + "moves": "4U2 5L2 1B 6D 2D2 2L 3D' 2U2 6D' 2R' 4L 2U' 6U2 2R2", + "facelets": "RRRFFRRFBFBBUUURBUUUUFFUUUUFFUUUUFLU RRRRLDFFFBBFRRRRRDBBFBDBULLLLLULLLLL FFFLUFRRRRUUFUFUUFLLLUUDBUFULBBUDBLB LBFLBLDBBDFDDLLDRDDFFDBDDDBDDDDBFDBD UULLLLFUDFBFULLLLLBUBBBBRRRRRDRRRRRD BDRBBBDDLLLLBDDBDBUDDRRRFRDFDFFRFUDF", + "token": "AAhdaNvHZZDzrzBq38CdcEFMS-GsBq9xaeK8wCH_YxMtfbSV1SRf8j9H_zQMKynFU-", + "canonical": "" + }, + { + "id": 14, + "moves": "5L' 1D2 4D 1F 6B2 1L2 5B 5D' x' 3U' 6U 2L2 5D2 6F2", + "facelets": "BBRBBFDRBBUBFRBBUBFRRRRRLDLLLUFDBBUB RFFRRDLLBLDDDUUUFLRBFRRDDUDDBRRLLBLU LBUUFUDDDDRULBBLLRDRUUFURBFRRLDBDDBD BDBBUBFBFFFFFBFFFFLRLLLLFFFFFFFFFFRF UFUUBUUBDRRLLDDDBUULBLDRRUUUDULRFRRL RULBLLRULULLULDDDDLURFBRUFUULDRBDDDD", + "token": "ChyZywq-ap6VUc6gZqLzGySde4jcr4p_Qbx4KKD0lM5ZQcJmRzQh7xJYzlCrLVaoa", + "canonical": "DDDDBRDLUUFURBFRULDDDDLULLULURLLBLUR DDLDRURDFRBLRLURDBFBUFDLFLUBULRLDRDR BBRBBFDRBBUBFRBBUBFRRRRRLDLLLUFDBBUB LBUUFUDDDDRULBBLLRDRUUFURBFRRLDBDDBD LRULUURULDBFFUBDDURULDRURDDBRBLURULU FRFFFFFFFFFFLLLLRLFFFFBFFFFFBFBUBBDB" + }, + { + "id": 15, + "moves": "5L' 1D2 4D 1F 6B2 1L2 5B 5D' x' 3U' 6U 2L2 5D2 6F2", + "facelets": "BBRBBFDRBBUBFRBBUBFRRRRRLDLLLUFDBBUB RFFRRDLLBLDDDUUUFLRBFRRDDUDDBRRLLBLU LBUUFUDDDDRULBBLLRDRUUFURBFRRLDBDDBD BDBBUBFBFFFFFBFFFFLRLLLLFFFFFFFFFFRF UFUUBUUBDRRLLDDDBUULBLDRRUUUDULRFRRL RULBLLRULULLULDDDDLURFBRUFUULDRBDDDD", + "token": "AmANnVGggJw6s0jkpRRtorzfBVa0zEwFUvz0aJ0KGLhGO1qWzt344N3H7Lsv9Foj1e", + "canonical": "" + }, + { + "id": 14, + "moves": "5D' 3U2 6U' 6D' 4U' 1L' 2D y2 6L2 4L2 3D2 1B2 3B 2U", + "facelets": "RDUDDDUUUDULRBRFRRUUUDURUUUDUBUUUDUR BLBBFFBLBLFUBLBUFBFFFDFLBLBDFBBLBDFB LLLLLDUBBDBDFFFLFDULFLLLRRRRRDRRRRRD DDDUDLDDDUDFDDDUDLBBLBFFDDDUDRLUDUUU FBFBBBLLLRLFFLDLLLFLURFFBFUFFFFFUFFF LLLLLUFBUBBBDRBRRRBBBRBURRRRRRRRRRRU", + "token": "AB2xcdO6vk3FrjDyW4qrKkXQ4eJeDdp9dPRivoBCx1Ya8Cvhot3KkuJm7QR5wweyU", + "canonical": "RRBDFLRRBRBLRRBBULRRRRBLRRBRBLURURBU RDUDDDUUUDULRBRFRRUUUDURUUUDUBUUUDUR FBFFLFFFLLLBUUUDLFFFRLRBFFFLLBFFFLFB RRUFULRRLFBLRRFFBLRRLLDLRRLFBLDDLDDD UUUDULRDUDDDFFBLBBLDUDDDFDUDDDLDUDDD FUBLBBFFFFFFBLUDDDBBBFBBLLLFLLBBBFBB" + }, + { + "id": 15, + "moves": "5D' 3U2 6U' 6D' 4U' 1L' 2D y2 6L2 4L2 3D2 1B2 3B 2U", + "facelets": "RDUDDDUUUDULRBRFRRUUUDURUUUDUBUUUDUR BLBBFFBLBLFUBLBUFBFFFDFLBLBDFBBLBDFB LLLLLDUBBDBDFFFLFDULFLLLRRRRRDRRRRRD DDDUDLDDDUDFDDDUDLBBLBFFDDDUDRLUDUUU FBFBBBLLLRLFFLDLLLFLURFFBFUFFFFFUFFF LLLLLUFBUBBBDRBRRRBBBRBURRRRRRRRRRRU", + "token": "BXZm_x-mmgCtNp_-2--L2aVD3BzgK-xe41zgktKonknmoMPjAVoU1fgCPNu7TtKAuG", + "canonical": "" + }, + { + "id": 14, + "moves": "2R' z' 2D 2R2 3F 5D 1B2 6F' 3R2 5U2 3R' 3B 4B' 6R2", + "facelets": "LBUFDULRRULRRUDDRDUFLLDLLRRULRDRRFLR DDULDRUUBRDRDDUBDRDDFLDRRBBLBBDDULDR BFFLBFUBBLBBBFFDBFBFFLBFBFLLUFBFFDBF ULLBRLRLLFRLDBRRURLDUULURLLFRLRFDBUD UUDRULLFFRFFUUBRULUUDFULDDFLULUUDRUL BFRBDFBFRBDFBFUBDFBRRBDFUURBDBBFUBDF", + "token": "DdC2BK35REWRu0a_zJGgVMJH05pvMm3XuMCYfwsHIcA3PMsOhyFa38T_eNg-zaH67", + "canonical": "ULLBRLRLLFRLDBRRURLDUULURLLFRLRFDBUD RDLUDDBBLBBRRDLFDDRDBUDDRDRBUURDLUDD FDBUFBBDBRUUFDBRRBFDBUFBFDBRFBFDBRFB LBUFDULRRULRRUDDRDUFLLDLLRRULRDRRFLR LURDUULULFDDLUFDUULURBUUFFRFFLLURDUU FBDFFBFULLFBFBLFFBFBDFFBBBLBBUFBLFFB" + }, + { + "id": 15, + "moves": "2R' z' 2D 2R2 3F 5D 1B2 6F' 3R2 5U2 3R' 3B 4B' 6R2", + "facelets": "LBUFDULRRULRRUDDRDUFLLDLLRRULRDRRFLR DDULDRUUBRDRDDUBDRDDFLDRRBBLBBDDULDR BFFLBFUBBLBBBFFDBFBFFLBFBFLLUFBFFDBF ULLBRLRLLFRLDBRRURLDUULURLLFRLRFDBUD UUDRULLFFRFFUUBRULUUDFULDDFLULUUDRUL BFRBDFBFRBDFBFUBDFBRRBDFUURBDBBFUBDF", + "token": "A414cQVyZOiu3YcHTKFogtFibBc3PAyuWfHTwXiWne9KMe9_Bf0wzix40WNsHGzeoI", + "canonical": "" + }, + { + "id": 18, + "moves": "", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "" + }, + { + "id": 19, + "moves": "", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "" + }, + { + "id": 18, + "moves": "5R 1L 1L 5R 2D' 3R2 7B2 y' 7U2 2R 5U 2R2 6U x'", + "facelets": "RLLLLDLLLLLFLLFBFBFUBRRRRRDLRRRRRFLRRRRRDFRRRRRUL BRBBRFFFRFFRBBBRBBRFFFRFFRBBBBBBRBFFRFFDDBFRFFLLB UUUUULUUUUUUBDDDDDDRUUUUUURDDDDDDRUUUUUURDDDDDDRD LLLLLURLLLLLUBLLLLLBRLLLLLURFFBFBDBFFLFBFBLRRRRDR FBLBBBBFFLBBBBBBLFFRFFFLBBBBBFLFFFFFUUBBBBBRRFFFF URUUUUUDFDDDDUULUUUUDDLDDDDUULUUUUDDLDDDDUDLDDDDD", + "token": "G97m5tpL6C57ZtRwOXRXQl31FKwbhJRJw8StkqfFNg-SxAztvzDKuvoiP-yJf_jzE0I6i0AALz1etHHENQKVzmu8e", + "canonical": "DUDUDUUDUDUDUUDUDUDUUDUDUDUUDUDUDUURRRRRBLDDUDUDU LURRRRRFDRRRRRLFRRRRRLDRRRRRBUFBFBFLLFLLLLLDLLLLR FFBFBFBRRBRRRRFFBFBFBFFBFBFBLDRRRRRLDBBFBFBBFBFBF DDUDUDULLLLLFRDDUDUDUDDUDUDUDDUDUDUDDUDUDUDUDUDUU LLLLLURLLLLLUBLLLLLBRLLLLLURFFBFBDBFFLFBFBLRRRRDR BBFBFBFBBRBFBFBBFBFBFBBFBFBFLLLLLURBFBFFURFFBFBFB" + }, + { + "id": 19, + "moves": "5R 1L 1L 5R 2D' 3R2 7B2 y' 7U2 2R 5U 2R2 6U x'", + "facelets": "RLLLLDLLLLLFLLFBFBFUBRRRRRDLRRRRRFLRRRRRDFRRRRRUL BRBBRFFFRFFRBBBRBBRFFFRFFRBBBBBBRBFFRFFDDBFRFFLLB UUUUULUUUUUUBDDDDDDRUUUUUURDDDDDDRUUUUUURDDDDDDRD LLLLLURLLLLLUBLLLLLBRLLLLLURFFBFBDBFFLFBFBLRRRRDR FBLBBBBFFLBBBBBBLFFRFFFLBBBBBFLFFFFFUUBBBBBRRFFFF URUUUUUDFDDDDUULUUUUDDLDDDDUULUUUUDDLDDDDUDLDDDDD", + "token": "CnOWlpHcdxFuRo-qFYuguOM758CKUbebqWnBFv7p9EXXCYTZJ7JMBh3M1_izj_1bJzjV9DgAEbcDg6qpk-D4LWhmrn", + "canonical": "" + }, + { + "id": 18, + "moves": "2R 3U' x' 3F 2L2 z2 4B 7R 6F' 2D' z' 6R 2B 2F'", + "facelets": "LULLLFLRRRBRRRLULLLDLBUBBBDBLULLLDLBFBBBUDLBLLLDL BRBRBUBFDFRFFFBRBRBFBBDBRBFBBRBRBFBUBURUUUDRDDDFD URUUULUDRDDDUDURUUULUURUUUUUURUUULUFBFFFLFBRBRBLB RFRFRURFBFFFDURDRFRURRDRFRURRDRFRURLLLLLLLRDRFRBR FDFLFLFBBBLBUBFBFLFLFFBFLFLFFBFLFLFDDDLDFDUBUUULU DRDDDLDUDUUULUDRDDDLDDRDDDFDDRDDDLDBRBBBFBFRFLFLF", + "token": "UsKwp7hkPmy7EkvJ0QGCEC4s47iHz13zFCqlrYoKhIKDxAwVxQGOn98ial0MoNldLbXfR28i9_tdffChOITWTn5vO", + "canonical": "URUUULUDRDDDUDURUUULUURUUUUUURUUULUFBFFFLFBRBRBLB DUBBBFBRBRDRDRDUBBBFBDRRRRRRDUBBBFBFUFFFFUDUBBBFB RFRFRURFBFFFDURDRFRURRDRFRURRDRFRURLLLLLLLRDRFRBR FLFLFRFBFBBBRBDLDDDRDDFDDDRDDLDDDRDULUUUDUDLDDDRD FBFFFDULULLLFLFBFFFDULLLLLLUFBFFFDUDBBBBDBFBFFFDU LDLLLBLDUBBBFBLDLLLULBDBBBUBLDLLLULRRRBRRRLFLLLUL" + }, + { + "id": 19, + "moves": "2R 3U' x' 3F 2L2 z2 4B 7R 6F' 2D' z' 6R 2B 2F'", + "facelets": "LULLLFLRRRBRRRLULLLDLBUBBBDBLULLLDLBFBBBUDLBLLLDL BRBRBUBFDFRFFFBRBRBFBBDBRBFBBRBRBFBUBURUUUDRDDDFD URUUULUDRDDDUDURUUULUURUUUUUURUUULUFBFFFLFBRBRBLB RFRFRURFBFFFDURDRFRURRDRFRURRDRFRURLLLLLLLRDRFRBR FDFLFLFBBBLBUBFBFLFLFFBFLFLFFBFLFLFDDDLDFDUBUUULU DRDDDLDUDUUULUDRDDDLDDRDDDFDDRDDDLDBRBBBFBFRFLFLF", + "token": "HwkCPuUll2jGJtxrrmCQxhFQ1WUy7cM7J4_-IRPD8bDxaYSIKeCVe_Os5-LkvFGC8SQzusmtHP5DDzo8dTHQXW9ptc", + "canonical": "" + }, + { + "id": 18, + "moves": "3L 7D' z y 5U 7B 2B 3R' 1U 2D2 4R2 7D2 1R2 2U2", + "facelets": "LBLRLLRLBLFLLRDDFRFDRLBLRLLRLDLRLLRLBLRLLFLBLRLLR BRBBBBBFLFFFFFDRDDDDBBRBBBBBDRDDDDDBRBBBBBUULUUUU FLFUFFDDDUDDDDBBBFLBFUUUDLUDUUUFLUFDDRDDDDUUUFDUB RRRLBRLRRRLBRLRRRLBRDRRRLBRLRRRDBRLFFULBFLRRRLLRL DDRDDDDFFFFFLFULUUUUUFLFFFFFULUUBUFBBBBBRBFLFFFFF UBBDBRBUUUUDUUUFRUFFFUDRUDDDBFRBFFRUUUULUUFDUBDDD", + "token": "SVDbDYh9GjN1mT-n6zGeZnP6dcrmWoiPDcFKTXtX6B_aKhkJWjFx4wbUJbUplpBKzIegxCKlilui7NGkCuZtjZdL4", + "canonical": "FUBUUUUDUFDFUBUURRRUBBUBUUUDDLFDFDBDUFDFURDURDFUB LBLRLLRLBLFLLRDDFRFDRLBLRLLRLDLRLLRLBLRLLFLBLRLLR FBUFUFDLBLLLFDFBUFUFRFBUFUFDFBBFUFDFRUFULDFBFFUFD UDUUBDFUDUUBDLURUUBUFFDFDFDUDDLLLDFUDUUBDFBDFDFDD LRLLRRRLFBLUFFLRBDRRRLRBLRRRDRBLRRRLRBLRRRLRBLRRR BFBBDBUBFDBDBUBFDBDBUBFDBDBUBFDBDBLRLRRRRUBFDBDBU" + }, + { + "id": 19, + "moves": "3L 7D' z y 5U 7B 2B 3R' 1U 2D2 4R2 7D2 1R2 2U2", + "facelets": "LBLRLLRLBLFLLRDDFRFDRLBLRLLRLDLRLLRLBLRLLFLBLRLLR BRBBBBBFLFFFFFDRDDDDBBRBBBBBDRDDDDDBRBBBBBUULUUUU FLFUFFDDDUDDDDBBBFLBFUUUDLUDUUUFLUFDDRDDDDUUUFDUB RRRLBRLRRRLBRLRRRLBRDRRRLBRLRRRDBRLFFULBFLRRRLLRL DDRDDDDFFFFFLFULUUUUUFLFFFFFULUUBUFBBBBBRBFLFFFFF UBBDBRBUUUUDUUUFRUFFFUDRUDDDBFRBFFRUUUULUUFDUBDDD", + "token": "G35SJRMu6dNMGXfe-DKbZmt97CwWYfM1pSh73Q5A9wvxz8ljgdKKtSKPjiPvmHYcDLLcSYz-E-JdGM6dhBZpFRi8dV", + "canonical": "" + }, + { + "id": 18, + "moves": "2B 3F 5U' 4L' 5D 5R' 5F 4D' 1F' 4F2 4F' 5B 5F' 2F", + "facelets": "UUBFUUURRBFRRRUURDUUULLBDLLLUUFBFUULLBFBLLRRFBFRR DURURDRDURURDRDBRBFFFBFRFRBBFULUFFFDURURDRDURURDR FFLRLFFFFLDLFFFFDFDFFDDLRDLDURUULUUFFURUFFFFLRLFF LLBFBLLRRFBFRRDDBFBDDRRFURRRDDLUDDDLLFBLLLDDFBDDD LULDLDULULDLDUBBBFLFUFFLBLBFBBBDRDBLULDLDULULDLDU BBBUDBBBBBULBBRRURDDRLUBLDLLRRUURDRBBBRDBBBBBUDBB", + "token": "QmrW-OsNB-OXpq2WRE-7QYzEcxqewix1DTyXqgGkOTB-53ZbOElmM0POUySKy1maU4wKHJN6a1HCL6rCsBq880N6s", + "canonical": "DLDRDRLDLDRDRLFFLFBFBBBUUFBFDLDRBFBDLDRDRLDLDRDRL FFLRLFFFFURUFFUULUURUDLDRLDDFFDFDFFFFLDLFFFFLRLFF RDRURUDRDRURUDFFFULUFBBRFRFBFFFBRBDRDRURUDRDRURUD URULULRURULULRURULFBFFFDDBFBBBRBFBFURULULRURULULR BBDUBBBBBDRBBBRDRUURRLLDLBULRDDRURRBBLUBBBBBDUBBB UDLDLULUDLDLULBDRDBBBFBLBLFFUFLFBBBUDLDLULUDLDLUL" + }, + { + "id": 19, + "moves": "2B 3F 5U' 4L' 5D 5R' 5F 4D' 1F' 4F2 4F' 5B 5F' 2F", + "facelets": "UUBFUUURRBFRRRUURDUUULLBDLLLUUFBFUULLBFBLLRRFBFRR DURURDRDURURDRDBRBFFFBFRFRBBFULUFFFDURURDRDURURDR FFLRLFFFFLDLFFFFDFDFFDDLRDLDURUULUUFFURUFFFFLRLFF LLBFBLLRRFBFRRDDBFBDDRRFURRRDDLUDDDLLFBLLLDDFBDDD LULDLDULULDLDUBBBFLFUFFLBLBFBBBDRDBLULDLDULULDLDU BBBUDBBBBBULBBRRURDDRLUBLDLLRRUURDRBBBRDBBBBBUDBB", + "token": "GOgQnVgk4vVY3oEYWZ3mOJTJqyn7iNCr5Pa438CdlXIvlsxiNRuGUzltXy20DEGZ31SDyrdN6D6o0eAJAgoG2zlOAp", + "canonical": "" + }, + { + "id": 22, + "moves": "", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "" + }, + { + "id": 23, + "moves": "", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "" + }, + { + "id": 22, + "moves": "6R' x2 x' 2B' 1U' 2L' 2R 7B 8U2 4F2", + "facelets": "FBFFFFLFFDFFFFDFFDFFFFDFFDFFFFDFBUDBBBUBUDUUUUDUDRRRRRRRFDFFFFDF DBFRDDDDRURLRRFRRBRLRRURRBRLRRFRRBRLRRFRRDRLRRFRRURLRRFRLBLULLFL LBLLLLBLDBFDDDBDDBFDDDBDDBFDDDBDDBFDDDBDDBFDDDBDDRFDDDRDUFUUUBLU BRBBBDFBRURRRRURBUBBBDUBFDFFFFDFBUBBBDUBBUBBBDUBLLLLLLLUBUBBBDUB UUUULBFULBLLRLDLLDLLRLFLLBLLRLFLLBLLRLFLLBLLRLFLLBLLRLDLRBRRDRFR RFRRRRLRUFUUUBLUUUUUUBLUUFUUUBLUUFUUUBLUUFUUUBLUUFUUUBLUDBFDDDBD", + "token": "BjpluVumb_wmJjX_R80h8bZ6YLRWrLs8WvOnFovAhY82m1W5PQlREplxMH6iNL8DLXOT3qxkMkrHGp2Ov0fFdGhRXfauN_EWNKp7sD251ZM-F3rfMXCs2jlpX", + "canonical": "ULBUUUFUDRDDDFRDDBDDDFBDDBDDDFBDDBDDDFBDDBDDDFBDDBDDDFBDLBLLLLBL ULLLLLLRFDFFFFDFBLLLLLLRLRRRRRRDULLLLLLRULLLLLLRUBDBBBBBULLLLLLR FDFFFFDFRRRRRRRDUDUUUUDUBUBBBDUBFDFFFFDFFDFFFFDFFDFFFFDFFLFFFFBF RFRRRRLRUFUUUBLUUUUUUBLUUFUUUBLUUFUUUBLUUFUUUBLUUFUUUBLUDBFDDDBD LRRRRRRDBUDBBBUBLRRRRRRFULLLLLLRLRRRRRRDLRRRRRRDFFFFFUFDLRRRRRRD BRBBBDFBRURRRRURBUBBBDUBFDFFFFDFBUBBBDUBBUBBBDUBLLLLLLLUBUBBBDUB" + }, + { + "id": 23, + "moves": "6R' x2 x' 2B' 1U' 2L' 2R 7B 8U2 4F2", + "facelets": "FBFFFFLFFDFFFFDFFDFFFFDFFDFFFFDFBUDBBBUBUDUUUUDUDRRRRRRRFDFFFFDF DBFRDDDDRURLRRFRRBRLRRURRBRLRRFRRBRLRRFRRDRLRRFRRURLRRFRLBLULLFL LBLLLLBLDBFDDDBDDBFDDDBDDBFDDDBDDBFDDDBDDBFDDDBDDRFDDDRDUFUUUBLU BRBBBDFBRURRRRURBUBBBDUBFDFFFFDFBUBBBDUBBUBBBDUBLLLLLLLUBUBBBDUB UUUULBFULBLLRLDLLDLLRLFLLBLLRLFLLBLLRLFLLBLLRLFLLBLLRLDLRBRRDRFR RFRRRRLRUFUUUBLUUUUUUBLUUFUUUBLUUFUUUBLUUFUUUBLUUFUUUBLUDBFDDDBD", + "token": "Bik-KKyu6dB3Wqxtkxve6lA_Am8kIV3BTipeSHI9TGcpIDJ0Qxc3dZtaperzeWxe-Xw6CXRy5NnpIN74MtkJIyWJ03FV-ozd4kNvnNFDEcG0vXDe3-k8wWZNRW", + "canonical": "" + }, + { + "id": 22, + "moves": "1D2 8B' x' 6D2 3U 2D' 8U' 6B 7R' 3L'", + "facelets": "FUUFFFFFBLUBBBBBBDLBBBBBBDUBBBBBBDUBBBBBRRURRRDLBDRBBBBBBDDBBBBB RRFRRRRLRRFRRRRLUUFUUUUURRFRRRRLRRFRRRRLRRFRRRRLDDFDDDDDRLFLLLLL UFBUUUUUUBFUUUUURBDLLLLLUBFUUUUUUBFUUUUUURFUUUUURBFRRRRLDBFDDDDD BUUBBBBBFULFFFFFLLDLLLURFUDFFFFFFUDFFFFFFURFFFFFFRDFFFFFFDDFFFFF RLLLLBLLRLLLLBLLDDDDDBDDRLLLLBLLRLLLLBLLRLLLLBLLUUUUUBUURRRRRBRL DDDDDBFDDDDDDBFDRRRRRUFLDDDDDBFDDDDDDBFDDDDDDBLDRLLLLBFLUUUUUFBU", + "token": "FKjkefg627JFDBQlydnHH2nA5RdT-f6x5zSlfVp1yu32OJhKVyb9WcGPYgZ6Rck_4OfG-3IIqSqnO69iCsWK7p657oioqmlNTOhKpJM-Ty9ty1ZrCQaxhogXD", + "canonical": "UBFUUUUULFBLLLLRDLBDDDDDDFBDDDDDDFBDDDDDLFURRRRRDFBDDDDDDFBDDDDD LLULLLDLRRURRRDLRRURRRDLRRURRRDLRRURRRDLFFFFFFFFRRURRRDLRRURRRDR FUUFFFFFBLUBBBBBBDLBBBBBBDUBBBBBBDUBBBBBRRURRRDLBDRBBBBBBDDBBBBB UFBUUUUUUBFUUUUURBDLLLLLUBFUUUUUUBFUUUUUURFUUUUURBFRRRRLDBFDDDDD RURRRDRRRULLLDLLRULLLDLLRULLLDLLRULLLDLLBBBBBBBBRULLLDLLLULLLDLL FFFFFDDFFFFFFDRFFFFFFRUFFFFFFDUFFFFFFDUFRULLLDLLFFFFFLUFBBBBBUUB" + }, + { + "id": 23, + "moves": "1D2 8B' x' 6D2 3U 2D' 8U' 6B 7R' 3L'", + "facelets": "FUUFFFFFBLUBBBBBBDLBBBBBBDUBBBBBBDUBBBBBRRURRRDLBDRBBBBBBDDBBBBB RRFRRRRLRRFRRRRLUUFUUUUURRFRRRRLRRFRRRRLRRFRRRRLDDFDDDDDRLFLLLLL UFBUUUUUUBFUUUUURBDLLLLLUBFUUUUUUBFUUUUUURFUUUUURBFRRRRLDBFDDDDD BUUBBBBBFULFFFFFLLDLLLURFUDFFFFFFUDFFFFFFURFFFFFFRDFFFFFFDDFFFFF RLLLLBLLRLLLLBLLDDDDDBDDRLLLLBLLRLLLLBLLRLLLLBLLUUUUUBUURRRRRBRL DDDDDBFDDDDDDBFDRRRRRUFLDDDDDBFDDDDDDBFDDDDDDBLDRLLLLBFLUUUUUFBU", + "token": "BACfT1J0Uy07XDo41VlYLGYOYelTJsHPrEeXKQMZ4efLQ1YZ3c7x4cAJ35C7j2AwrApU1RaHqueASjYsUMBafiZZBZzFg5pzhMYookr_P9F_opbxUQ2o9XAZZD", + "canonical": "" + }, + { + "id": 22, + "moves": "3F z2 6F 7L 2B' 3R2 7R' 4D2 8U2 6R2", + "facelets": "DBDDDUBDRBDRRURRRBRRRLBRDBDDDUBDDBDDDUBDRBRRRLBRDBRDDLBDDBDDDUBD LLDLLDDLLLDLLDDLLLDLLDDLLLDLLDDLRUURRURRLLDLLDDLLLDLLDBLRUURRURR FDBFFBDFFRBFFBDFFRBFFBRFFDBFFBDFBUBBBBUBFRBFFBRFFDBFFBDFBUBBBBUB UFDUUUFULLRLLLFLLFRLLLFLUFDUUUFUUFDUUUFULFRLLLFLUFDUUUFUUFDUUUFU RUURRURRRUURRURRRUURRURRRUURRURRLLDLLDDLRUURRURRRFURRURRLLDLLDDL BUFBBFUBBUFBBFLBBLFBBFLBBUFBBFUBFDFFFFDFBLFBBFLBBUFBBFUBFDFFFFDF", + "token": "CIC2XOqeICNdyiQjb5iNS8R99bVRkrN0XjOOluFtFBRG1YJ95Tp5QhbSNnaN26cUULIfwd3VsKsz0bRyiKp42ergiJOrNg90Jd68m2YG99axgWg_xBuxG7E7Z", + "canonical": "UFUUUDFUUFUUUDFULFLLLRFLUFUUUDFUUFUUUDFULFLLLRFLLFLLLRLLUFUUUDFU LDDLLDLLRRURRUFRRRURRUURLDDLLDLLRRURRUURRRURRUURRRURRUURRRURRUUR BUBBBBUBFDBFFBDFFRBFFBRFBUBBBBUBFDBFFBDFFRBFFBRFFDBFFBRFFDBFFBDF DBUDDDBDDBLDDRBDRBLRRRBRDBUDDDBDDBUDDDBDRBLRRRBRRRURRDBRDBUDDDBD RRURRUURLBDLLDLLLDDLLDLLRRURRUURLDDLLDLLLDDLLDLLLDDLLDLLLDDLLDLL FDFFFFDFBUFBBFUBBLFBBFLBFDFFFFDFBUFBBFUBBLFBBFLBBLFBBFUBBUFBBFUB" + }, + { + "id": 23, + "moves": "3F z2 6F 7L 2B' 3R2 7R' 4D2 8U2 6R2", + "facelets": "DBDDDUBDRBDRRURRRBRRRLBRDBDDDUBDDBDDDUBDRBRRRLBRDBRDDLBDDBDDDUBD LLDLLDDLLLDLLDDLLLDLLDDLLLDLLDDLRUURRURRLLDLLDDLLLDLLDBLRUURRURR FDBFFBDFFRBFFBDFFRBFFBRFFDBFFBDFBUBBBBUBFRBFFBRFFDBFFBDFBUBBBBUB UFDUUUFULLRLLLFLLFRLLLFLUFDUUUFUUFDUUUFULFRLLLFLUFDUUUFUUFDUUUFU RUURRURRRUURRURRRUURRURRRUURRURRLLDLLDDLRUURRURRRFURRURRLLDLLDDL BUFBBFUBBUFBBFLBBLFBBFLBBUFBBFUBFDFFFFDFBLFBBFLBBUFBBFUBFDFFFFDF", + "token": "BtUVHbpbdaNvHT-m-JFaKgEahkRy8BS1lKMKoO1As5jXznJFyEhBjvVR_tdg6r_JKOvJlDL2lH3GGJLEkeOY56jCk_fUkp4DSSJS5Yzb_x2bs7xiHZ4KIMHSdp", + "canonical": "" + }, + { + "id": 26, + "moves": "", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "" + }, + { + "id": 27, + "moves": "", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "" + }, + { + "id": 26, + "moves": "1U' 5U' x 3B y' 2F' 7F 5D 3F2 6L2", + "facelets": "LFRFLBFFFLFRFLUFFFUUUUUFUUULFRFLBFFFLFRFLBFFFLFRFLBFFFBBBBRDLBRDDDDDBDDDLFRFLBFFF DBUDDDLDDDBUDDDFDDDBUDDDRDDDBUDDDFDDBLBLBLLLLDBUDDDFDDDLUDDDFDDDBUDDDFDDDRUDDDFDD BLFLBRLLLBLFLBRLLLBLFLBRLLLBLFLBRLLLUURUUDULUBLFLBRLLLBLFLBRLLLBLFLBRLLLBLFLBRLLL RBLBRFBBBUUUUUFUUUFFFFLURFLRBLBRFBBBRBLBRFBBBRBLBRFBBBDDDDDBDDDRBLBRDBBBRBLBRFBBB UURUUUDFUUUBUUUDFUUULUUUDFUUUBUUUDFURRRRFRFRFUUBUUUDFUUUBUUUDRUUUBUUUDFUUUBUUUDLU RRRLFRBRFRRRLFRBRFRRRLFRBRFRRRLFRBRFDRDUDDLDDRRRLFRBRFRRRLFRBRFRRRLFRBRFRRRLFRBRF", + "token": "CsfZrzS1yAWIBkVWR1LOe15qiMdmtxRFJjLf1sVfIZOm9P6Ian8dsCUfl9hLxfVw4wPRzpGMxaDjlRDDg8IuxCgYoYoHajLKq52HwVrB6pMa0wUwrW1PJNmL9WjG0EIUFcxr7oGdCEfjEUvrSVpmUJPS-U", + "canonical": "LLLLULLLLLLLLLLLLLLLLLULLLLRRRRDRRRRBBBBUBBBBLLLLULLLLFFFFRFFFFLLLLULLLLBBBBUBBBB RBLBRFBBBUUUUUFUUUFFFFLURFLRBLBRFBBBRBLBRFBBBRBLBRFBBBDDDDDBDDDRBLBRDBBBRBLBRFBBB UUUUFUUUUFFFFRFRFLDDDDFDDDDUUUURUUUUUUUUFUUUUUUUURUUUURBLBRBBBBUUUURUUUUUUUURUUUU FFFFDFFFFRRRRDRRRRBBBBLBBBBRRRRDRRRRFFFFDFFFFLLLLULLLLRRRRDRRRRRRRRRRRRRRRRRDRRRR FFFBLFRFLDDDBDDDDDRBLDRBBBBFFFBLFRFLFFFBLFRFLFFFBLFRFLUUUFUUUUUFFFULFRFLFFFBLFRFL DDDDBDDDDRBLBLBBBBUUUUBUUUUDDDDLDDDDDDDDBDDDDDDDDLDDDDFFFFLFRFLDDDDLDDDDDDDDLDDDD" + }, + { + "id": 27, + "moves": "1U' 5U' x 3B y' 2F' 7F 5D 3F2 6L2", + "facelets": "LFRFLBFFFLFRFLUFFFUUUUUFUUULFRFLBFFFLFRFLBFFFLFRFLBFFFBBBBRDLBRDDDDDBDDDLFRFLBFFF DBUDDDLDDDBUDDDFDDDBUDDDRDDDBUDDDFDDBLBLBLLLLDBUDDDFDDDLUDDDFDDDBUDDDFDDDRUDDDFDD BLFLBRLLLBLFLBRLLLBLFLBRLLLBLFLBRLLLUURUUDULUBLFLBRLLLBLFLBRLLLBLFLBRLLLBLFLBRLLL RBLBRFBBBUUUUUFUUUFFFFLURFLRBLBRFBBBRBLBRFBBBRBLBRFBBBDDDDDBDDDRBLBRDBBBRBLBRFBBB UURUUUDFUUUBUUUDFUUULUUUDFUUUBUUUDFURRRRFRFRFUUBUUUDFUUUBUUUDRUUUBUUUDFUUUBUUUDLU RRRLFRBRFRRRLFRBRFRRRLFRBRFRRRLFRBRFDRDUDDLDDRRRLFRBRFRRRLFRBRFRRRLFRBRFRRRLFRBRF", + "token": "BArxobPEKwITAloAWr8NbkNn80rGhKeZ7lMT8IoDrJdem99zJ--rIg3r2PEcajwKVSFurXaUyhxVV-ZJUWjRiY8JPJPCx9MMAFsS6IIIt_cqDyHyQQj9rdGUfAdKjhjHiCyoeXCa4xr1Jnx4O4HmXjdvHXx", + "canonical": "" + }, + { + "id": 26, + "moves": "2B 6F' 8B 7L 9R' z' 3B' 1F2 6L2 4L", + "facelets": "RRRLRRRRRDDDBDLDDDBUUBULBUUDDDBDLDDDRRRBRLRRRRRRBRLRRRRRRLRDRRRDDDBDLDDDLULBLLLUL BLDDDLRLDULDDDLRLDUFFFFFRFFULDDDLRLDULDDDLRLDULDDDLRLDBLDDDLRLDULDDDLRLDUFFFFFRFF URURUDURUFFFDFBFFFFFFUFBFFFFFFDFBFFFFFFRFBFFFFFFRFBFFFURURUDURUFFFDFBFFFFFFLFBFFF RRRURRRRRLULFLDLULLULFLULULLULFLDLULLULFLRLULLULFLRLULFDDUDRFDDLULFLDLULLULFLULUL URLRUUURFURURUUURDBBLBBBBBDURURUUURDURLRUUURDURLRUUURDURLRUUURFURURUUURDBBLBBBBBD BBBFBUBBBBBBFBUBBBDLDRDDDLDBBBFBUBBBBBBFBUBBBBBBFBUBBBBBBFBUBBBBBBFBUBBBDLDRDRDLD", + "token": "BOgtQv-aiQVgi5PsexgfREB4qAyukFCFkOlAYx4-NqdUlViKIvANxnyikDnBHF_mG7W5kQNTTFKPFLRgumMWXrkKtDjEEf7jG_d0duogF3aud7EpAvJs_IZP0Btiiq1uKxh7EHyZWspvBBjTpswVEgNq_R", + "canonical": "BUUUUUBUUBRRRRRBRRLULLLULULBRRRRRBRRBUUUUUBUUBUUUUUBUUBUUUUUBUUBRRRRRBRRDDFDDDDDF LDRRRDBDRUDRRRDUDRLDRRRDUDRBBLBBBBBLLDRRRDUDRLLDLLLLLRLDRRRDBDRUDRRRDUDRLDRRRDUDR FFUFFFFFUFFRFFFFFRFFUFFFFFULDRRRDUDRFFUFFFFFUBBDBBBBBDFFUFFFFFUFFRFFFFFRFFUFFFFFU UUBUUUUUBFLLLLLFLLFDDDDDFDDFDDDDDFDDFDDDDDFDDFLLLLLFLLRRRRRRRRRFLLLLLFLLFDDDDDFDD LLFLLLLLRUUDUUUUURLLDLLLLLRFFUFFFFFULLDLLLLLRUDRRRDUDRLLFLLLLLRUUDUUUUURLLDLLLLLR BBDBBBBBDBBLBBBBBLBBDBBBBBDUUDUUUUURBBDBBBBBDFFRFFFFFRBBDBBBBBDBBLBBBBBLBBDBBBBBD" + }, + { + "id": 27, + "moves": "2B 6F' 8B 7L 9R' z' 3B' 1F2 6L2 4L", + "facelets": "RRRLRRRRRDDDBDLDDDBUUBULBUUDDDBDLDDDRRRBRLRRRRRRBRLRRRRRRLRDRRRDDDBDLDDDLULBLLLUL BLDDDLRLDULDDDLRLDUFFFFFRFFULDDDLRLDULDDDLRLDULDDDLRLDBLDDDLRLDULDDDLRLDUFFFFFRFF URURUDURUFFFDFBFFFFFFUFBFFFFFFDFBFFFFFFRFBFFFFFFRFBFFFURURUDURUFFFDFBFFFFFFLFBFFF RRRURRRRRLULFLDLULLULFLULULLULFLDLULLULFLRLULLULFLRLULFDDUDRFDDLULFLDLULLULFLULUL URLRUUURFURURUUURDBBLBBBBBDURURUUURDURLRUUURDURLRUUURDURLRUUURFURURUUURDBBLBBBBBD BBBFBUBBBBBBFBUBBBDLDRDDDLDBBBFBUBBBBBBFBUBBBBBBFBUBBBBBBFBUBBBBBBFBUBBBDLDRDRDLD", + "token": "AdcQ-R_Z82IENFd4rikLuZgtPwTBdh4yFld4JStXVH6_uAEzzRoFKm689hWoaqP2SmQllmE_PJ71p8OkReUoY4VkA5VJhr-VKnzLrJfMCMyBbOJvYRro3rJd7gpE9AEJUCkuJi65ggvpoYlPXoyH5sFIHus", + "canonical": "" + }, + { + "id": 26, + "moves": "8D2 8U' 2B 3R 8D2 5L2 1B' 2U 1D' 4R", + "facelets": "LBLLLFLLLRLRRDRBFRUUUUDFFUUUUUUDFFUUUUUUDFFUUUUUUDFFUUUUUUDFFUUUUUULLLUUUUUUDRFUU RRRRRRRDUBBBBBBBRBRRRRRRRDURRRRRRRDURRRRRRRDDRRRRRRRDURRRRRRRDFFFFFFFFDUBBBBBBBRB FFFFBDDFFRURRRDRRUFFFFBBDFFFFFFBDDFFFFFFBUDFFFFFFBDDFFFFFFBDDFFLLLLBDLLLRRRRRDRDU DDDDDLDLRDDDDDBDBRBRBBBUBFRDDDDDBDLRURUUUFUURDDDDDBDLRDDDDDBDLRDDDDDLDRFDDDDDBDLR DULLLLLLLFFUFRFFFFDULLLLLLLDULLLLLLLUULLLLLLLDULLLLLLLBULLLLLLLDUBBBBBBBFFFFBFDFF BBBUBBBRBDLLULLLDLBDBUBBBRBBBBUBBBRBFLFUFFFFFBBBUBBBRBUBUUUUURUBBBRBBBRBDULLLLLLL", + "token": "GQchEAEfKJGTwMB9EPmkuLLZbK70hngRBE3WUCrYiH-HqgXKfXXK0iaqf-KSjAmLAcd-ifqO72zCnu5XHG1K6brSilDEe6SvTCB__9AAV6D6SJr8OUMyQvctOmJdJyNpOPMZP5GfyplJ-dx6cFzcPIOOlK", + "canonical": "DDDDDLDLRDDDDDBDBRBRBBBUBFRDDDDDBDLRURUUUFUURDDDDDBDLRDDDDDBDLRDDDDDLDRFDDDDDBDLR BRBBBBBBBUDFFFFFFFFDRRRRRRRUDRRRRRRRDDRRRRRRRUDRRRRRRRUDRRRRRRRBRBBBBBBBUDRRRRRRR LLLLLLLUDBRBBBRBBBURUUUUUBUBRBBBUBBBFFFFFUFLFBRBBBUBBBBRBBBUBDBLDLLLULLDBRBBBUBBB LBLLLFLLLRLRRDRBFRUUUUDFFUUUUUUDFFUUUUUUDFFUUUUUUDFFUUUUUUDFFUUUUUULLLUUUUUUDRFUU FFDFBFFFFBBBBBBBUDLLLLLLLUBLLLLLLLUDLLLLLLLUULLLLLLLUDLLLLLLLUDFFFFRFUFFLLLLLLLUD UDRDRRRRRLLLDBLLLLFFDDBFFFFFFDDBFFFFFFDUBFFFFFFDDBFFFFFFDBBFFFFURRDRRRURFFDDBFFFF" + }, + { + "id": 27, + "moves": "8D2 8U' 2B 3R 8D2 5L2 1B' 2U 1D' 4R", + "facelets": "LBLLLFLLLRLRRDRBFRUUUUDFFUUUUUUDFFUUUUUUDFFUUUUUUDFFUUUUUUDFFUUUUUULLLUUUUUUDRFUU RRRRRRRDUBBBBBBBRBRRRRRRRDURRRRRRRDURRRRRRRDDRRRRRRRDURRRRRRRDFFFFFFFFDUBBBBBBBRB FFFFBDDFFRURRRDRRUFFFFBBDFFFFFFBDDFFFFFFBUDFFFFFFBDDFFFFFFBDDFFLLLLBDLLLRRRRRDRDU DDDDDLDLRDDDDDBDBRBRBBBUBFRDDDDDBDLRURUUUFUURDDDDDBDLRDDDDDBDLRDDDDDLDRFDDDDDBDLR DULLLLLLLFFUFRFFFFDULLLLLLLDULLLLLLLUULLLLLLLDULLLLLLLBULLLLLLLDUBBBBBBBFFFFBFDFF BBBUBBBRBDLLULLLDLBDBUBBBRBBBBUBBBRBFLFUFFFFFBBBUBBBRBUBUUUUURUBBBRBBBRBDULLLLLLL", + "token": "CWKsZgBrrzaXaEgu5l2dxUMRiMGbsm0GYZ0wXhARMy_S38Ir7wwsDs5_7_T29IOUIKrPc731mcjI-5lgqqj8F6YO895Jrl3BvIwv_-4AINxd2zoelXky2Ryw9eTi7q1HdVspd9ab6_l7vbKt6iLSlrFVd74", + "canonical": "" + }, + { + "id": 30, + "moves": "", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "" + }, + { + "id": 31, + "moves": "", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "" + }, + { + "id": 30, + "moves": "x2 z' 4B 5D' 7D 4D' 4F 7F2 z' 10F2", + "facelets": "DDDBBDFDDDUUUBUFFUUUUUUBUFFUUURRRBBRFRRRUUUBUFFUUUUUUBUFFUUURRRRRRRRRRUUUBUFFUUUUUUBUFFUUUUUUBUFFUUU LLLULLULLRLLLULLULLRLLLULLULLRLLLBLLULLRLLLULLULLRLLLFLLULLRLLLFLLULLRLLLULLULLRLLLULLULLRLLLULLULLR BBBDBUUBBBBBBDBUUBBBBBBDBUUBBBBBBDBLLBBBBBBDBUUBBBBBBDBUUBBBBBBRBUUBBBBBBDBUUBBBBBBDBUUBBBBBBDBUUBBB DDDFDBBDDDDDDFDBBDDDDDDFDBBDDDLLLLLLLLLLDDDFDBBDDDDDDFDBBDDDLLLFFLBLLLDDDFDBBDDDDDDFDBBDDDUUUFFUBUUU LRRDRRDRRRLRRDRRDRRRLRRDRRDRRRLRRDRRFRRRLRRDRRDRRRLRRDRRBRRRLRRDRRBRRRLRRDRRDRRRLRRDRRDRRRLRRDRRDRRR FFFUFDDFFFFFFUFDDFFFFFFUFDDFFFFFFLFDDFFFFFFUFDDFFFFFFUFDDFFFFFFUFRRFFFFFFUFDDFFFFFFUFDDFFFFFFUFDDFFF", + "token": "Ra2dlQzUxn6i-9nwwPcGlOmjBZwVTR13cSr270PoVUtvTHyP06YP3e45bmWXkP_Qlg8cTCrr6wVb4tszfCwhqcH2BL99ZFKIPiSQNPrrXn4U7Vd0IUKzXlPBZ0gLUaH05NwEcWrYo_uIPausNatB-Ifn_0zxkwDghQjlLcivGk-e8MDHmVUK4jRodMvLhp9y-U", + "canonical": "UUUFFUBUUUUUUFFUBUUUUUUFFUBUUURRRRRRRRRRUUUFFUBUUUUUUFFUBUUURRRFRBBRRRUUUFFUBUUUUUUFFUBUUUDDDFDBBDDD LRRDRRDRRRLRRDRRDRRRLRRDRRDRRRLRRDRRFRRRLRRDRRDRRRLRRDRRBRRRLRRDRRBRRRLRRDRRDRRRLRRDRRDRRRLRRDRRDRRR FFFUFDDFFFFFFUFDDFFFFFFUFDDFFFFFFLFDDFFFFFFUFDDFFFFFFUFDDFFFFFFUFRRFFFFFFUFDDFFFFFFUFDDFFFFFFUFDDFFF UUUBUFFUUUDDDBBDFDDDDDDBBDFDDDLLLBLFFLLLDDDBBDFDDDDDDBBDFDDDLLLLLLLLLLDDDBBDFDDDDDDBBDFDDDDDDBBDFDDD LLLULLULLRLLLULLULLRLLLULLULLRLLLBLLULLRLLLULLULLRLLLFLLULLRLLLFLLULLRLLLULLULLRLLLULLULLRLLLULLULLR BBBDBUUBBBBBBDBUUBBBBBBDBUUBBBBBBDBLLBBBBBBDBUUBBBBBBDBUUBBBBBBRBUUBBBBBBDBUUBBBBBBDBUUBBBBBBDBUUBBB" + }, + { + "id": 31, + "moves": "x2 z' 4B 5D' 7D 4D' 4F 7F2 z' 10F2", + "facelets": "DDDBBDFDDDUUUBUFFUUUUUUBUFFUUURRRBBRFRRRUUUBUFFUUUUUUBUFFUUURRRRRRRRRRUUUBUFFUUUUUUBUFFUUUUUUBUFFUUU LLLULLULLRLLLULLULLRLLLULLULLRLLLBLLULLRLLLULLULLRLLLFLLULLRLLLFLLULLRLLLULLULLRLLLULLULLRLLLULLULLR BBBDBUUBBBBBBDBUUBBBBBBDBUUBBBBBBDBLLBBBBBBDBUUBBBBBBDBUUBBBBBBRBUUBBBBBBDBUUBBBBBBDBUUBBBBBBDBUUBBB DDDFDBBDDDDDDFDBBDDDDDDFDBBDDDLLLLLLLLLLDDDFDBBDDDDDDFDBBDDDLLLFFLBLLLDDDFDBBDDDDDDFDBBDDDUUUFFUBUUU LRRDRRDRRRLRRDRRDRRRLRRDRRDRRRLRRDRRFRRRLRRDRRDRRRLRRDRRBRRRLRRDRRBRRRLRRDRRDRRRLRRDRRDRRRLRRDRRDRRR FFFUFDDFFFFFFUFDDFFFFFFUFDDFFFFFFLFDDFFFFFFUFDDFFFFFFUFDDFFFFFFUFRRFFFFFFUFDDFFFFFFUFDDFFFFFFUFDDFFF", + "token": "CWtQ7MdbzkoZzrPuYNDM9mfAm5KC-MvYaa1zXmitziVxBVCjR7Kgz9XVQSdh9SbjfdPuTptpSC4z4_6jcPHwvvPfo8aAt34QStkOEK-LG7BmJBOGFJcXtfI-1UJop8xyYP7RIbfKFOZeaRGewqW22qQilV1zTDD6wcDyAtg6golr7g4dmRWUuE5qBRXGfHry1nq", + "canonical": "" + }, + { + "id": 30, + "moves": "z2 4F2 8F' 1U2 1F' 9L2 z y 8F2 8F", + "facelets": "DRRLRRRDRRDRRLRRRDRRBBBBBBBBFBDRRLRRRDRRDRRLRRRDRRDRRLRRRDRRDRRLRRRDRRDRRLRRRDRRDRRLRRRDRRDLULLLRLLL FBBBBBBLBBFBBBBBBLBBFBBBBBBUBBFBBBBBBLBBFBBBBBBLBBFBBBBBBLBBFBBBBBBRBBFBBBBBBLBBFFFFFFFLFFFBBBBBBUBB RDLDDDUDDDLDLDDDUDDDLDLDDDUDDDLDLDDDUDDDLDLDDDUDDDLDLDDDUDDDLDLDDDUDDDLDLDDDUDDDUURUUUDUURLDLDDDUDDD URDRRRLRRRULLRLLLULLULLRLLLULLULLRLLLULLULLRLLLULLULLRLLLULLULLRLLLULLBFFFFFFFBFULLRLLLULLULLRLLLULL BBRBBBBBBBFFRFFFFFFFFFDFFFFFFFFFRFFFFFFFFFRFFFFFFFFFRFFFFFFFFFLFFFFFFFFFRFFFFFFFFBRBBBBBBBFFDFFFFFFF UURUUUDUULUURUUUDUURUURUUUDUURUURUUUDUURUURUUUDUURUURUUUDUURUURUUUDUURUURUUUDUURLDLDDDUDDDUURUUUDUUR", + "token": "NIdlvnFIK--axzi_OAT7peI8DbDwoXj33J10hjA2Y0xd6NNlb36JY7gIl7AudkPdV8HD5GzFuwgLGFJjBXdyrkfLiX7l_8J-mUIdq8GWK_vaQpvdYaUsaQF9ESZGnYnDG7jURsYX6dexAx0Vi2rdmprSSoHQcc87rhcz1ZpSSbC3LsF34S_Fje-v7rmSS03RtU", + "canonical": "UUBUUUUUUULLFLLLLLLRLLFLLLLLLDRRFRRRRRRRLLFLLLLLLRLLFLLLLLLRLLFLLLLLLLUUFUUUUUURLLBLLLLLLRLLFLLLLLLR DDDUDDDLDLRUUDUUURUUDDDUDDDLDLDDDUDDDLDLDDDUDDDLDLDDDUDDDLDLDDDUDDDLDLDDDUDDDLDLDDDUDDDLDLDDDUDDDLDR BBUBBBBBBFFFLFFFFFFFBBLBBBBBBFBBRBBBBBBFBBLBBBBBBFBBLBBBBBBFBBLBBBBBBFBBUBBBBBBFBBLBBBBBBFBBLBBBBBBF RRBRRRRRRLRRFRRRRRRLDDBDDDDDDLRRBRRRRRRRRRBRRRRRRLRRBRRRRRRLLLBLLLLLLLRRBRRRRRRURRBRRRRRRLDDBDDDDDDD RUUDUUURUUDDDUDDDLDLRUUDUUURUURUUDUUURUURUUDUUURUURUUDUUURUURUUDUUURUURUUDUUURUURUUDUUURUULUUDUUURUU FFFFFFFDFFBBBBBBBRBFFFFFFFFRFFFFFFFFFLFFFFFFFFFRFFFFFFFFFRFFFFFFFFFRFFFFFFFFFDFFFFFFFFFRFFBBBBBBBRBB" + }, + { + "id": 31, + "moves": "z2 4F2 8F' 1U2 1F' 9L2 z y 8F2 8F", + "facelets": "DRRLRRRDRRDRRLRRRDRRBBBBBBBBFBDRRLRRRDRRDRRLRRRDRRDRRLRRRDRRDRRLRRRDRRDRRLRRRDRRDRRLRRRDRRDLULLLRLLL FBBBBBBLBBFBBBBBBLBBFBBBBBBUBBFBBBBBBLBBFBBBBBBLBBFBBBBBBLBBFBBBBBBRBBFBBBBBBLBBFFFFFFFLFFFBBBBBBUBB RDLDDDUDDDLDLDDDUDDDLDLDDDUDDDLDLDDDUDDDLDLDDDUDDDLDLDDDUDDDLDLDDDUDDDLDLDDDUDDDUURUUUDUURLDLDDDUDDD URDRRRLRRRULLRLLLULLULLRLLLULLULLRLLLULLULLRLLLULLULLRLLLULLULLRLLLULLBFFFFFFFBFULLRLLLULLULLRLLLULL BBRBBBBBBBFFRFFFFFFFFFDFFFFFFFFFRFFFFFFFFFRFFFFFFFFFRFFFFFFFFFLFFFFFFFFFRFFFFFFFFBRBBBBBBBFFDFFFFFFF UURUUUDUULUURUUUDUURUURUUUDUURUURUUUDUURUURUUUDUURUURUUUDUURUURUUUDUURUURUUUDUURLDLDDDUDDDUURUUUDUUR", + "token": "F9LacM9EqqNXGwAzaLKtN3kCTrYQf-F53KjS9erBhqm6wg9Wd-bXsIqynNd1oUZTs1b83SxcEwkkTbTB1DrqlbxRroAmOo3cls8UcH_h8_v9ftAcKCIPnPqpLc9Im3snmHmlQ76SAnaj7B2TwJkO9YfELblBwNHkPZsfMKHTqFiZODMLCWIh5rYiUcFpn2o0EGp", + "canonical": "" + }, + { + "id": 30, + "moves": "4U2 2U 7B 5D' 2F' 7F 7U z2 7U' 8R'", + "facelets": "DDBDDDDDDDDDLDDDDDDDDDBDDDDDDDRBRLRBRRRRDDBDDDDDDDDDLDDDDDDDLLLLLLRLFLDDBDDDDDDDLLBLFLRLFLDDBDDDDDDD LULULLDLLLLULULLDLLLLULULLDLLLFFFFFFFFFFFUFFFFDFFFLULULLDLLLBBBBBBBBBBLULULLDLLLFUFUFFDFFFLULULLDLLL FFDFFFFFFFFFDFFFFFFFFFDFFFFFFFRRRURRDRDRRRDRRRDRRRFFDFFFFFFFLLLULLDLDLFFDFFFFFFFRRLRRRRRRRFFDFFFFFFF UUFUUUUUUURRFRBRLRBRUUFUUUUUUURRRRRRLRBRUURUUUUUUUUUFUUUUUUULFLRLFLLLLUUFUUUUUUUUURUUUUUUUUUFUUUUUUU RRRURRDRDRRRRURRDRDRRRRURRDRDRBBBBBBBBBBBBBUBBBBDBRRRURRDRDRFFFFFFFFFFRRRURRDRDRBBBUBBDBDBRRRURRDRDR BBBBBBBUBBBBBBBBBUBBBBBBBBBUBBLULULLDLLLLLLULLLULLBBBBBBBUBBRURURRDRRRBBBBBBBUBBLLLLLLLRLLBBBBBBBUBB", + "token": "AAAAABDnC8paO1KovVl4UjWgpZvmPA04t4q1yyPMUR4-lkuRzc-muvqAMmmxXGfh26xKADIHJPffhAdTCAS1hlQf5KUUqSYhmfHJ8kuuYjTl9I2DJOMQo0KDgY7XSm-MyanoOTdEVGC9B_EWvGd6ffV_q_IM8DetiP0NiHmhuxBDy_WS5UZIneHSFxsZ539nl-", + "canonical": "UUUUUUUFUUUUUUUUURUUUUUUUUUFUULLLLFLRLFLUUUUUUUFUUUUUUUUURUURBRLRRRRRRUUUUUUUFUURBRLRBRFRRUUUUUUUFUU RDRDRRURRRBDBDBBUBBBRDRDRRURRRFFFFFFFFFFRDRDRRURRRBDBBBBUBBBBBBBBBBBBBRDRDRRURRRRDRDRRURRRRDRDRRURRR FFFFFFFDFFRRRRRRRLRRFFFFFFFDFFLDLDLLULLLFFFFFFFDFFRRRDRRRDRRRDRDRRURRRFFFFFFFDFFFFFFFFFDFFFFFFFFFDFF DDDDDDDBDDLFLRLFLBLLDDDDDDDBDDLFLRLLLLLLDDDDDDDLDDDDDDDDDBDDRRRRBRLRBRDDDDDDDBDDDDDDDDDLDDDDDDDDDBDD LLLDLLULULFFFDFFUFUFLLLDLLULULBBBBBBBBBBLLLDLLULULFFFDFFFFUFFFFFFFFFFFLLLDLLULULLLLDLLULULLLLDLLULUL BBUBBBBBBBLLRLLLLLLLBBUBBBBBBBRRRDRRURURBBUBBBBBBBLLULLLULLLLLLDLLULULBBUBBBBBBBBBUBBBBBBBBBUBBBBBBB" + }, + { + "id": 31, + "moves": "4U2 2U 7B 5D' 2F' 7F 7U z2 7U' 8R'", + "facelets": "DDBDDDDDDDDDLDDDDDDDDDBDDDDDDDRBRLRBRRRRDDBDDDDDDDDDLDDDDDDDLLLLLLRLFLDDBDDDDDDDLLBLFLRLFLDDBDDDDDDD LULULLDLLLLULULLDLLLLULULLDLLLFFFFFFFFFFFUFFFFDFFFLULULLDLLLBBBBBBBBBBLULULLDLLLFUFUFFDFFFLULULLDLLL FFDFFFFFFFFFDFFFFFFFFFDFFFFFFFRRRURRDRDRRRDRRRDRRRFFDFFFFFFFLLLULLDLDLFFDFFFFFFFRRLRRRRRRRFFDFFFFFFF UUFUUUUUUURRFRBRLRBRUUFUUUUUUURRRRRRLRBRUURUUUUUUUUUFUUUUUUULFLRLFLLLLUUFUUUUUUUUURUUUUUUUUUFUUUUUUU RRRURRDRDRRRRURRDRDRRRRURRDRDRBBBBBBBBBBBBBUBBBBDBRRRURRDRDRFFFFFFFFFFRRRURRDRDRBBBUBBDBDBRRRURRDRDR BBBBBBBUBBBBBBBBBUBBBBBBBBBUBBLULULLDLLLLLLULLLULLBBBBBBBUBBRURURRDRRRBBBBBBBUBBLLLLLLLRLLBBBBBBBUBB", + "token": "FrJfm4NmK09TZvMi6eD0l1dLacIHUDKQlacYcaUr0SahRFtXK6zHt31IGWpW7h7gXzI6T88YAbv6PAySIBORnCPNzsli5Wt1xMrb7mjn0FIPGKXmwknuqq8GkB5hPih2bNSRNsunS8XPqpnr_7kqisbor-UkrTjLwtmK75LgwNrUYIov-FqWgiq-76FYcZeLX4B", + "canonical": "" + }, + { + "id": 34, + "moves": "", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "" + }, + { + "id": 35, + "moves": "", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "" + }, + { + "id": 34, + "moves": "10F x2 5B x2 3L2 11R 1R 10F 10L2 9D'", + "facelets": "FUDUUUUUUDFLDLLLLDLLDLFUDUUUUUUDFFUDUUUUUUDFFURUUUUUURFFUDUUUUUUDFFLDLLLLLLDFFUDUUUUUUDFFUDUUUUUUDFFURUUUUUURFFUDUUUUUUDF RRRRRRRRRFRRRRRRRRRRLRUFBBBBBBFBURRRRRRRRRLRUUUUUUUUULURRRRRRRRRLRRRRRRRRRRLRRRRRRRRRRLRRRRRRRRRRLRUUUUUUUUULURRRRRRRRRFR DFBFFFFFFBDDFBFFFFFFBDRRRRRRRRRDRDFBFFFFFFBDRFBFFFFFFBRDFBFFFFFFBDDFBFFFFFFBDDFBFFFFFFBDDFBFFFFFFBDRFBFFFFFFBRDFBFFFFFFBD BDUDDDDDDUBBDLDDDDDDLBBDUDDDDDDUBBDUDDDDDDUBBRURRRRRRUBBDUDDDDDDUBBDLDDDDDDLBBDUDDDDDDUBBDUDDDDDDUBRURRRRURRURBDUDDDDDDUB LBLLLLLLLLLLRLLLLLLLLLDFBFFFFFFBDLRLLLLLLLLLDRDDDDDDDDDLRLLLLLLLLLLRLLLLLLLLLLRLLLLLLLLLLRLLLLLLLLLDRDDDDDDDDDLBLLLLLLLLL UFBBBBBBFBUUFBBBBBBFBULULLLLLLLLLUFBBBBBBFBULFBBBBBBFBLUFBBBBBBFBUUFBBBBBBFBUUFBBBBBBFBUUFBBBBBBFBULFBBBBBBFBLUFBBBBBBFBU", + "token": "CM9981Fg0JxDZKiotVfjRwmz7ng1iZwlaESVkueO9THF2eg4VkGp8t-gCqavQccENewyQhSz-kQFXZaqY4MaFI9LPK0RrW0RAMe4E5u2kPp806XRvkTADnRXVJmtsMwAFNHT1s-U8iwXTkvtWfDpyRrWOwTEPpm-UWKdLdX1u7aeiGSXSpyeu4-GbOgG1GC377GAe73FF5HNB80v4gGNzE1-gDimHmdO9_IYa0qCHDIQ", + "canonical": "" + }, + { + "id": 35, + "moves": "10F x2 5B x2 3L2 11R 1R 10F 10L2 9D'", + "facelets": "FUDUUUUUUDFLDLLLLDLLDLFUDUUUUUUDFFUDUUUUUUDFFURUUUUUURFFUDUUUUUUDFFLDLLLLLLDFFUDUUUUUUDFFUDUUUUUUDFFURUUUUUURFFUDUUUUUUDF RRRRRRRRRFRRRRRRRRRRLRUFBBBBBBFBURRRRRRRRRLRUUUUUUUUULURRRRRRRRRLRRRRRRRRRRLRRRRRRRRRRLRRRRRRRRRRLRUUUUUUUUULURRRRRRRRRFR DFBFFFFFFBDDFBFFFFFFBDRRRRRRRRRDRDFBFFFFFFBDRFBFFFFFFBRDFBFFFFFFBDDFBFFFFFFBDDFBFFFFFFBDDFBFFFFFFBDRFBFFFFFFBRDFBFFFFFFBD BDUDDDDDDUBBDLDDDDDDLBBDUDDDDDDUBBDUDDDDDDUBBRURRRRRRUBBDUDDDDDDUBBDLDDDDDDLBBDUDDDDDDUBBDUDDDDDDUBRURRRRURRURBDUDDDDDDUB LBLLLLLLLLLLRLLLLLLLLLDFBFFFFFFBDLRLLLLLLLLLDRDDDDDDDDDLRLLLLLLLLLLRLLLLLLLLLLRLLLLLLLLLLRLLLLLLLLLDRDDDDDDDDDLBLLLLLLLLL UFBBBBBBFBUUFBBBBBBFBULULLLLLLLLLUFBBBBBBFBULFBBBBBBFBLUFBBBBBBFBUUFBBBBBBFBUUFBBBBBBFBUUFBBBBBBFBULFBBBBBBFBLUFBBBBBBFBU", + "token": "A03POz6ETjqZRb8_RAD1OqOjeW0UE5qOBxm4FxbVm_KqMbcVIFifuxPcA_6BuKqhlDiS2MfDfdmCAxh_5VEpx7W8NsDmoQjmYErlB1pkdl3uz14up1nIBWugv7mhIkyAB86vcI3X2tCIvVx5AbpXq2oQViHJl3mnXoT68TA8JmR7cyW4u_q7hlXSaNcCj6RE-eKQLmcp6Nas4uzx9MCVLJ0PcBU-S2a9nPrJKDvwypLGA", + "canonical": "" + }, + { + "id": 34, + "moves": "1L' 4F 1F' z' 11F' 2B 9L' 9D2 5D2 8B", + "facelets": "DDDDDDDDFDBDDDDDDDDFDBRRRRRRRRFRRRRRRRRRRFRRRRRRRRRRFRRRRRRRRRRFRRRRRRRRRRFRRRRURRRURRRRRRRRRRRRFRRRRRRRRRRFRRDDDDDDDDFDB LDDDDDDDDLLLDDDDDDDDLLRRUBUUULUURLDDDDDDDDLLLDDDDDDDDLLLDDDDDDDDLLRRUDUUULUURLDDDDDDDDLLLDDDDDDDDLLLDDDDDDDDLLLBBBBBBBBLL FFFFFFFFUFDFFFFFFFFLFDUBRBBBBBBBBFFFFFFFFDFDFFFFFFFFLFDFFFFFFFFLFDUBRBBBBBBBBFFFFFFFFLFDFFFFFFFFLFDFFFFFFFFUFDFFFFFFFFUFD UUUUUUUUBUFLLLLLLLLBLLLLLLLLLLBLLLLDLLLDLLLLLLLLLLLLBLLLLLLLLLLBLLLLLLLLLLBLLLLLLLLLLBLLLLLLLLLLBLLUUUUUUUUBUFUUUUUUUUBUF RRUUUUUUUURRRUUUUUUUURLDDRDDDFDLLRRUUUUUUUURRRUUUUUUUURRRUUUUUUUURLDDRDDDUDLLRRUUUUUUUURRRUUUUUUUURRRUUUUUUUURRRFFFFFFFFR UBDBBBBBBBBUBRBBBBBBBBFFFFFFFFLFDUBUBBBBBBBBUBRBBBBBBBBUBRBBBBBBBBFFFFFFFFLFDUBRBBBBBBBBUBRBBBBBBBBUBDBBBBBBBBUBDBBBBBBBB", + "token": "B8xOUiDBc_VSYCcmZmL5ycoxCeJSLxTMC5oesMHLfWHrWfqAUk6OSXMJVdNcJUScHTxR-XLbyDnW2yk9NPSEXc4MyPgcmeCGxTuQKdy-gHYtlAs1OefzCRHGFVnlflk1TtqpSjcDZGHK3rwZOU7izYoyk1sYJqz0WI4My3YOqH-20BE9QfObEkTQn_01Ybl-w_ee0RW67MiEyWoWSerrejGj170-pPXatTaXMVFtMMvI", + "canonical": "RRRRLRRRLRRRRRRDRRRDRRFUUUDUUUDUUFUUURUUURUUFUUUDUUUDUUFUUUDUUUDUUFUUUDUUUDUUFUUUUUUUFUUFUUUDUUUDUUFUUULUUULUURRRRLRRRLRR DRRRRRRRRDDDRRRRRRRRDDDRRURRRRRDDDRRRRRRRRDDDRRRRRRRRDDDRRRRRRRRDDDRRURRRRRDDDRRRRRRRRDDFFFRFFFFFFFDRRRRRRRRDDBRRRRRRRRBB FFFFUFFFUFFFFFFBFFFBFFFFFFRFFFRFFFFFFBFFFBFFFFFFBFFFBFFFFFFBFFFBFFFFFFBFFFBFFFFFFBFFFBFFUULLBLLDBLUFFFFBFFFBFFDDDDBDDDBDD LLLLRLLLRLLBDDDRDDDRDDBDDDUDDDUDDBDDDDDDDBDDBDDDUDDDUDDBDDDUDDDUDDBDDDUDDDUDDBDDDLDDDLDDBDDDUDDDUDDLLLLULLLULLLLLLRLLLRLL UULLLLLLLLUUULLLLLLLLUUULLLLLDLLUUULLLLLLLLUUULLLLLLLLUUULLLLLLLLUUULLLLLDLLUUULLLLLLLLUBBBBBBBLBBBUULLLLLLLLUFFLLLLLLLLF BBDBBBDBBBBBBFBBBFBBBBBBLBBBLBBBBBBFBBBFBBBBBBFBBBFBBBBBBFBBBFBBBBBBFBBBFBBBBBBFBBBFBBBBDRFURRFRRDDBBFBBBFBBBBUUFUUUFUUUU" + }, + { + "id": 35, + "moves": "1L' 4F 1F' z' 11F' 2B 9L' 9D2 5D2 8B", + "facelets": "DDDDDDDDFDBDDDDDDDDFDBRRRRRRRRFRRRRRRRRRRFRRRRRRRRRRFRRRRRRRRRRFRRRRRRRRRRFRRRRURRRURRRRRRRRRRRRFRRRRRRRRRRFRRDDDDDDDDFDB LDDDDDDDDLLLDDDDDDDDLLRRUBUUULUURLDDDDDDDDLLLDDDDDDDDLLLDDDDDDDDLLRRUDUUULUURLDDDDDDDDLLLDDDDDDDDLLLDDDDDDDDLLLBBBBBBBBLL FFFFFFFFUFDFFFFFFFFLFDUBRBBBBBBBBFFFFFFFFDFDFFFFFFFFLFDFFFFFFFFLFDUBRBBBBBBBBFFFFFFFFLFDFFFFFFFFLFDFFFFFFFFUFDFFFFFFFFUFD UUUUUUUUBUFLLLLLLLLBLLLLLLLLLLBLLLLDLLLDLLLLLLLLLLLLBLLLLLLLLLLBLLLLLLLLLLBLLLLLLLLLLBLLLLLLLLLLBLLUUUUUUUUBUFUUUUUUUUBUF RRUUUUUUUURRRUUUUUUUURLDDRDDDFDLLRRUUUUUUUURRRUUUUUUUURRRUUUUUUUURLDDRDDDUDLLRRUUUUUUUURRRUUUUUUUURRRUUUUUUUURRRFFFFFFFFR UBDBBBBBBBBUBRBBBBBBBBFFFFFFFFLFDUBUBBBBBBBBUBRBBBBBBBBUBRBBBBBBBBFFFFFFFFLFDUBRBBBBBBBBUBRBBBBBBBBUBDBBBBBBBBUBDBBBBBBBB", + "token": "AuydXsxIi3v-5A6uZmUdq6vSY7Te0afMhFnLgkisTwS4Qb3wHt11W4sjgC9Cjfm6ivaevYsSaxWwki9289uxoy1Ey10KubQyifZWD7LHcCxRF4Qz9bb7I2aqSAG2D2Fz_ZH_e9ShRaSsE4aJdX2VDRPS90IpDoDboTVEzExFfy_kjgZ2-LtaJtnOO_70BKWPiXzbjmgmGMsxy4fIW7gYTdKdcOb3fdwyA_R4sn6I8kxrU", + "canonical": "" + }, + { + "id": 34, + "moves": "1U2 6B2 6F2 z 3F2 11L 9B 4D2 4F2 z'", + "facelets": "UUUUUUUDDUUUUUUUUUDDUUUUUUUUURDUUUUUUUUUDDUUUUUUUUUDDUUUUUUUUUDDUUUUUUUUUDDUUDDDUDDDDDDDBLLLLLLDLLRUUUUUUUDDUUUUUUUUUDDUU BBULBBBBBBBRRULRRRRRRRRRULRRRRRRRRRULRRRRRRRRRULRRRRRRRRRULRRRRRRRRRULRRRRRRRRRULRRRRRRRRRULRRRRRRRRRULRRRRRRRRRUFRRRRRRR RRRRRRRBRRRFFFFFFFBFFFFFFFFFFBFFFFFFFFFFBFFFFFFFFFFBFFFFFFFFFFBFFFFFFFFFFBFFFFFFFFFFBFFFFFFFFFFBFFFFFFFFFFBFFFFFFFFFFLFFF DDDDDDDUDDDDDDDDDDUDDDFRRRRRRURRLUUDDUUUUUUUDDDDDDDUDDDDDDDDDDUDDDDDDDDDDUDDDDDDDDDDUDDDDDDDDDDLDDDDDDDDDDUDDDDDDDDDDUDDD FFFFFFFRUFFLLLLLLLRULLLLLLLLLRDLLLLLLLLLRULLLLLLLLLRULLLLLLLLLRULLLLLLLLLRULLLLLLLLLRULLLLLLLLLRULLLLLLLLLRULLLLLLLLLBULL LLLFLLLLLLLBBBFBBBBBBBBBBFBBBBBBBBBBFBBBBBBBBBBFBBBBBBBBBBFBBBBBBBBBBFBBBBBBBBBBFBBBBBBBBBBFBBBBBBBBBBFBBBBBBBBBBRBBBBBBB", + "token": "Bb8Plf63wnvMfcQAYACWXgUGapSGrukvzwXxvSCf5bNaSQbrJlCbhzRXWyyPDJkJcaS0iudKtpjhuiVpNhW5ytWjy3KLFOP1Tofx-aa_TlAgFJw6FdnG4Bcm2htjkjBxcRAzsk6CVEtz72BpZhinZpmQ5wZ4ywbwZNaOJLE4n3T6ccye0gx9YrIzn0MDxRJAe1iSgNx_XDxxe5IR_os2UswOnAvfp8k0oyZ4uzPkjdkA", + "canonical": "" + }, + { + "id": 35, + "moves": "1U2 6B2 6F2 z 3F2 11L 9B 4D2 4F2 z'", + "facelets": "UUUUUUUDDUUUUUUUUUDDUUUUUUUUURDUUUUUUUUUDDUUUUUUUUUDDUUUUUUUUUDDUUUUUUUUUDDUUDDDUDDDDDDDBLLLLLLDLLRUUUUUUUDDUUUUUUUUUDDUU BBULBBBBBBBRRULRRRRRRRRRULRRRRRRRRRULRRRRRRRRRULRRRRRRRRRULRRRRRRRRRULRRRRRRRRRULRRRRRRRRRULRRRRRRRRRULRRRRRRRRRUFRRRRRRR RRRRRRRBRRRFFFFFFFBFFFFFFFFFFBFFFFFFFFFFBFFFFFFFFFFBFFFFFFFFFFBFFFFFFFFFFBFFFFFFFFFFBFFFFFFFFFFBFFFFFFFFFFBFFFFFFFFFFLFFF DDDDDDDUDDDDDDDDDDUDDDFRRRRRRURRLUUDDUUUUUUUDDDDDDDUDDDDDDDDDDUDDDDDDDDDDUDDDDDDDDDDUDDDDDDDDDDLDDDDDDDDDDUDDDDDDDDDDUDDD FFFFFFFRUFFLLLLLLLRULLLLLLLLLRDLLLLLLLLLRULLLLLLLLLRULLLLLLLLLRULLLLLLLLLRULLLLLLLLLRULLLLLLLLLRULLLLLLLLLRULLLLLLLLLBULL LLLFLLLLLLLBBBFBBBBBBBBBBFBBBBBBBBBBFBBBBBBBBBBFBBBBBBBBBBFBBBBBBBBBBFBBBBBBBBBBFBBBBBBBBBBFBBBBBBBBBBFBBBBBBBBBBRBBBBBBB", + "token": "Aiel2D-E6O5srymAJAA4Y0HiZ_eygZdx7aI6puw79iNB22KYLl46UrOgwjC1pLljip3DtBa8BHlUpc4HdEglrBAdbEr0J9V7_XL6vZ6HvV4MB7qVyDGqlAiukcpFVtIqimYTYt1w35xLecQnhkk-xnmWVqJtTCKaJdB1TcJ1O8vd6qy7jsSvBQLTW7khaebYLkE28FKvwpaqjlbGv3Q0XwyFeoRz3utzvS5tRjN1tTFgA", + "canonical": "" + }, + { + "id": 38, + "moves": "", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "" + }, + { + "id": 39, + "moves": "", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "CSdOr7DiP3L1_LmU0MAWkdfYC8_oycoz6OTck4YY9kx9yAIgiOHB3X27s3IFbkUzJ-IP5rD_At6dU51X4WY94ClU0KBRFAnebk3wylA0-xT5eksLqzJW-LZwDKCfvKy6JNUQ1MgigQnl2fEJhp5juJdsUkY8YWAdXGBruTVx2vu-4bw1KxnKhTp_QPntmCasxz9yiDMXdw57ZJIuIimxOChjBS09HRtJ0fl7OhiDrpIIUUP0ri8uNxwH6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "" + }, + { + "id": 38, + "moves": "5B 7D2 6D2 10B 2L y 7B2 1D2 12D 12R'", + "facelets": "RBUUUUDUUUUULBUUUUDUUUUULBUUUURUUUUULBUUUUDUUUUULBRRRRDRRRRRRFUUUUDUUUUURFUUUUDUUUUULBUUUULUUUUULBUUUUDUUUUULBRRRLDRRRRRLBUUUUDUUUUUBBUUUUDUUUUU RRDRRRRDRRRRBBBBBFBBBBDBBBBBBFBBBBDBBBBBBFBBBBDBBBBBBFBBBBLBFFFFFBFFFFDFFFFFFBFFFFDFBBBBBFBBBBDBBBBBBFBBBBDBBBBBBFBBBBLBBBBBBFBBBBDBFUFFFFBFFFFF UUFFFFBFFFFFURDRRRRDRRRRURDRRRRDRRRRURDRRRRDRRRRRRDRRRRDRRRRULDLULLLLLLLULDLULLLLLLLURDRRRRDRRRRURDRRRRDRRRRRRDRRRRDRRRRURDRRRRDRRRRULLLULLLLULL FDDDLDDDDLDDRFFFFBBFFFFFRDDDLDDDDLDDRDDDLDDDDLDDRDDDLDDDDLDDLDDDLDDDDRDDLULUUUURUUUURDDDLDDDDLDDRDDDLDDDDLDDRDDDLDDDDLDDRDDDLDDDDLDDLDDDLDDDDLDD BFFFFBBFFFFLBURUUUURUUULBFFFFBBFFFFLBFFFFBBFFFFLBFFFFBBFFFFUFFFFFBBFFFFLBBBBBFFBBBBLBFFFFBBFFFFLBFFFFBBFFFFLBFFFFBBFFFFUDFFFFBBFFFFLBFFFFBBFFFFL BBBBBFBBBBDDLLLLULLLLULDLLLLULLLLULDLLLLULLLLULDLLLLULLLLULDRRRRRRRDRURURRRRRRRDRURDLLLLULLLLULDLLLLULLLLULDLLLLULLLLULDLLLLULLLLULFRRDRRRRDRRRD", + "token": "AN9vWOCFfTavMmK_TZYEoj8BzcKK_oYvzEksvHa-tLU_b2RgGV4rO1X-aULE6gfJJ_6bp7mgNUOA1NAAW2dNrAga8sQleXtYCu7wyGNJJbckEpAQq7ZnsvS4ztm-2KVcAI9IpP2XneLi_IPt9SfUOItZIYBlMMV3x1qemEet3uLx8AJMs8zffL4X591TG-gWmiH4C_oKwQ2_IP0iO00Hs3Ro_lxqB7fdvcRvlj-FlVkIBUEHjC_SqYKZ3y1f5QP8sbve28PBKiQFgaWafkziQkDQ-Utg-", + "canonical": "UURUUUURUUUULRRRRLLRRRRULDDDDDDDDDDFLRRRRLLRRRRFURRRRUURRRRFLRRRRLLRRRRFLRRRRLLRRRRBLDDDDLLDDDDFLRRRRLLRRRRFURRRRLLRRRRFLRRRRLLRRRRFLRRRRLLRRRRF UUUUUDUUUUBBUUUUUDUUUUBLRRRRRDLRRRBLUUUUUDUUUUBLUUUUULUUUUBLUUUUUDUUUUFRUUUUUDUUUUFRRRRRRDRRRRBLUUUUUDUUUUBLUUUUURUUUUBLUUUUUDUUUUBLUUUUUDUUUUBR FBBBBFFBBBBRUBBBBFFBBBBRFBBBBFFBBBBDFBBBBFFBBBBRFBBBBFFBBBBRFFFFFBBFFFFRBBBBBFFBBBBRFBBBBFFBBBBDFBBBBFFBBBBRFBBBBFFBBBBRFDLDDDDLDDDRFBBBBFFBBBBR RLLLLRRLLLLBRLLLLRRLLLLBDLLLLRRLLLLBRLLLLRRLLLLBRUUUURRUUUUBRLLLLRRLLLLFRLLLLRRLLLLBDLLLLDDLLLLBRLLLLRRLLLLBRUUUUUUUUUUBRLLLLRRLLLLDDFDDDDUDDDDD FDDDLDDDDLDDRFFFFBBFFFFFRDDDLDDDDLDDRDDDLDDDDLDDRDDDLDDDDLDDLDDDLDDDDRDDLULUUUURUUUURDDDLDDDDLDDRDDDLDDDDLDDRDDDLDDDDLDDRDDDLDDDDLDDLDDDLDDDDLDD LLLLULLLLULLFUFFFFBFFFFFFUFFFFBFFFFFFUFFFFBFFFFFFRFFFFBFFFFFBUBBBBFBBBBBBUBBBBFBBBBBFUFFFFBFFFFFFUFFFFBFFFFFFRFFFFBFFFFFFUFFFFBFFFFFBBBBBFBBBBDB" + }, + { + "id": 39, + "moves": "5B 7D2 6D2 10B 2L y 7B2 1D2 12D 12R'", + "facelets": "RBUUUUDUUUUULBUUUUDUUUUULBUUUURUUUUULBUUUUDUUUUULBRRRRDRRRRRRFUUUUDUUUUURFUUUUDUUUUULBUUUULUUUUULBUUUUDUUUUULBRRRLDRRRRRLBUUUUDUUUUUBBUUUUDUUUUU RRDRRRRDRRRRBBBBBFBBBBDBBBBBBFBBBBDBBBBBBFBBBBDBBBBBBFBBBBLBFFFFFBFFFFDFFFFFFBFFFFDFBBBBBFBBBBDBBBBBBFBBBBDBBBBBBFBBBBLBBBBBBFBBBBDBFUFFFFBFFFFF UUFFFFBFFFFFURDRRRRDRRRRURDRRRRDRRRRURDRRRRDRRRRRRDRRRRDRRRRULDLULLLLLLLULDLULLLLLLLURDRRRRDRRRRURDRRRRDRRRRRRDRRRRDRRRRURDRRRRDRRRRULLLULLLLULL FDDDLDDDDLDDRFFFFBBFFFFFRDDDLDDDDLDDRDDDLDDDDLDDRDDDLDDDDLDDLDDDLDDDDRDDLULUUUURUUUURDDDLDDDDLDDRDDDLDDDDLDDRDDDLDDDDLDDRDDDLDDDDLDDLDDDLDDDDLDD BFFFFBBFFFFLBURUUUURUUULBFFFFBBFFFFLBFFFFBBFFFFLBFFFFBBFFFFUFFFFFBBFFFFLBBBBBFFBBBBLBFFFFBBFFFFLBFFFFBBFFFFLBFFFFBBFFFFUDFFFFBBFFFFLBFFFFBBFFFFL BBBBBFBBBBDDLLLLULLLLULDLLLLULLLLULDLLLLULLLLULDLLLLULLLLULDRRRRRRRDRURURRRRRRRDRURDLLLLULLLLULDLLLLULLLLULDLLLLULLLLULDLLLLULLLLULFRRDRRRRDRRRD", + "token": "EIzf-f9k34bdne-lhWcCBoN5IsyurkmjNrPzBS7PX9bQltl4JiIJWmld08Izygu7oeUOVibt6gL62a5WVjwlVLN0VIiD8xuG-pXRqvpP4gnSSiXfUsWJITLEKHSzI8ZWq9e4ExY4Fx4m5AJ89ouaEs0WSlVnv4Qof7IQnXOaA4Zz6D3lxaEcIcn5RPTckQUO6nNHv9cTy2oJ9jqH2lDLb1hEU6UqaaysKZRn8Z_J_iv4k_PxFzkFazRAeKxFw0Ph9nU5DkVSpo9LZtyDISmD-vrWHnh2-", + "canonical": "" + }, + { + "id": 38, + "moves": "6B' 7F2 10R2 10F' 11U' 6B x 9D 12U2 11R", + "facelets": "FDBFFFFFFFFFFDBFFFFFFFFFFDBFFFFFFFFFFLBFFFFFFFFFFDBFFFFFFFFFFDBFFFFFFFFFFUBFFFFFFFFFFDBFFFFFFFFFFDBFFFFFFFFFFLBFFFFFFFFFLDULLULLLLLLFUBFFFFFFFFF RFRRRRRRRRRRRFRRRRRRRRRRRBRRRRRRRRRRDDUDDDDDDDDDRFRRRRRRRRRRRFRRRRRRRRRRLLULLLLLLLLLRFRRRRRRRRRRRFRRRRRRRRRRDFUDDDDDDDDDRFRRRRRRRRRRLLLLLLLLLLBL DBUDDDDDDDDDDBUDDDDDDDDDDBUDDDDDDDDDLBLLLLLLLLBLDBUDDDDDDDDDDBRDDDDDDDDDUBUUUUUUUUBUDBUDDDDDDDDDDBUDDDDDDDDDLBLLLLLLLLLLDRUDDDDDDDDDUBUUUUUUUDUU BDBBBBBBBFBBBUBBBBBBBFBBBRBBBBBBBFBBBUBBBBBBBFBBBUBBBBBBBFBBBDBBBBBBBFBBBUBBBBBBBFBBBUBBBBBBBFBBBRBBBBBBBFBBBUBBBBBBBFBBRURRRRDRRDRRBUBBBBBBBFBB LLLLLLLLLLBLLLLLLLLLLLBLLLLLLLLLLLFLUUUUUUUUUDUULLLLLLLLLLBLLLLLLLLLLLBLRRRRRRRRRDRRLLLLLLLLLLBLLLLLLLLLLLBLUUUUUUUUUDBULLLLLLLLLLBLRFRRRRRRRRRR UUUUUUUUUDFUUUUUUUUUUDLUUUUUUUUUUDFURFRRRRRRRRFRUUUUUUUUUDFUUUUUUUUUULFUDFDDDDDDDDFDUUUUUUUUUDFUUUUUUUUUUDFURRRRRRRRRRFRUUUUUUUUUDFUDDUDDDDDDDFD", + "token": "B4XKHjdDVcsbNqYOhhC9lu0J-6_ABWdzqi4hqWyhIsB9249Jd_3P7OU2bxcdZYvTiXLC2i0Nsl5HMNSmdUhHrCOoj9hqtu1P-GsPW-gRkCA66g1ZV78QaWDzzhsIcE73GTHLFckumyvK6Iey_iRts-iBIkLlF_r_-tN5dDYdskHUfuE059HWZKn5qz74R7CVxG4Er_v48O10HrdzbvtgQZACu8PNbsMYH7qQcc7_AxzC7NHkze6ktT3lG8kl0bBtA3B-ICMzCpKHcfIyJxERPkb3DmAlA", + "canonical": "UUDUUUUUUUBUDDDDDDDDDURDLLLLLLLLLLBLDDDDDDDDDUBDDDDDDDDDDUBDUBUUUUUUUUBUDDDDDDDDDRBDDDDDDDDDDUBDLBLLLLLLLLBLDDDDDDDDDUBDDDDDDDDDDUBDDDDDDDDDDUBD LLLULLRLLULRBBFUBBRBBBBRLLLDLLDLLDLRLLLULLRLLULRLLLULLRLLULRLLLULLRLLULRLLLULLRLLULRLLLULLRLLULRLLLULLRLLULRLLLULLRLLULRLLLULLRLLULFLLLULLRLLULR FFFFFFFFFBUFLLLLLLULLUDLFFFFFFFFFBLFFFFFFFFFFBDFFFFFFFFFFBDFFFFFFFFFFBUFFFFFFFFFFBDFFFFFFFFFFBDFFFFFFFFFFBLFFFFFFFFFFBDFFFFFFFFFFBDFFFFFFFFFFBDF UUUUUUUUUDFUUUUUUUUUUDLUUUUUUUUUUDFURFRRRRRRRRFRUUUUUUUUUDFUUUUUUUUUULFUDFDDDDDDDDFDUUUUUUUUUDFUUUUUUUUUUDFURRRRRRRRRRFRUUUUUUUUUDFUDDUDDDDDDDFD LRDRRLRRDRRRLFFFFLFFDBFFLRURRURRURRRLRDRRLRRDRRRLRDRRLRRDRRRLRDRRLRRDRRRLRDRRLRRDRRRLRDRRLRRDRRRLRDRRLRRDRRRLRDRRLRRDRRRBRDRRLRRDRRRLRDRRLRRDRRR BDBBBBBBBFBBBUBBBBBBBFBBBRBBBBBBBFBBBUBBBBBBBFBBBUBBBBBBBFBBBDBBBBBBBFBBBUBBBBBBBFBBBUBBBBBBBFBBBRBBBBBBBFBBBUBBBBBBBFBBRURRRRDRRDRRBUBBBBBBBFBB" + }, + { + "id": 39, + "moves": "6B' 7F2 10R2 10F' 11U' 6B x 9D 12U2 11R", + "facelets": "FDBFFFFFFFFFFDBFFFFFFFFFFDBFFFFFFFFFFLBFFFFFFFFFFDBFFFFFFFFFFDBFFFFFFFFFFUBFFFFFFFFFFDBFFFFFFFFFFDBFFFFFFFFFFLBFFFFFFFFFLDULLULLLLLLFUBFFFFFFFFF RFRRRRRRRRRRRFRRRRRRRRRRRBRRRRRRRRRRDDUDDDDDDDDDRFRRRRRRRRRRRFRRRRRRRRRRLLULLLLLLLLLRFRRRRRRRRRRRFRRRRRRRRRRDFUDDDDDDDDDRFRRRRRRRRRRLLLLLLLLLLBL DBUDDDDDDDDDDBUDDDDDDDDDDBUDDDDDDDDDLBLLLLLLLLBLDBUDDDDDDDDDDBRDDDDDDDDDUBUUUUUUUUBUDBUDDDDDDDDDDBUDDDDDDDDDLBLLLLLLLLLLDRUDDDDDDDDDUBUUUUUUUDUU BDBBBBBBBFBBBUBBBBBBBFBBBRBBBBBBBFBBBUBBBBBBBFBBBUBBBBBBBFBBBDBBBBBBBFBBBUBBBBBBBFBBBUBBBBBBBFBBBRBBBBBBBFBBBUBBBBBBBFBBRURRRRDRRDRRBUBBBBBBBFBB LLLLLLLLLLBLLLLLLLLLLLBLLLLLLLLLLLFLUUUUUUUUUDUULLLLLLLLLLBLLLLLLLLLLLBLRRRRRRRRRDRRLLLLLLLLLLBLLLLLLLLLLLBLUUUUUUUUUDBULLLLLLLLLLBLRFRRRRRRRRRR UUUUUUUUUDFUUUUUUUUUUDLUUUUUUUUUUDFURFRRRRRRRRFRUUUUUUUUUDFUUUUUUUUUULFUDFDDDDDDDDFDUUUUUUUUUDFUUUUUUUUUUDFURRRRRRRRRRFRUUUUUUUUUDFUDDUDDDDDDDFD", + "token": "h1m6EjLiGSC4voxFRx3jXLo05IPWUAel0qzoKB-HYSoFTtDMWUMnuBvjmo3z4ig7OvWIsC1IwssrGixcPxGbMb-zx2cNgi7t-nKHYa5i5xMSz5j2K3O_o4OHBCoOCxHIeWNTBtP2YsZOX-cGZHCmNhQyHFVfmgiB_xuEFg8O4FIbINn1okptfH8t8yOxlpvSJJUEhpfz6ZwrdmvX0B52PWmMAfJqu7Fzy2Z712HPnOtKddpd61RwfZSVuNdFfjQu12YkwhDQygt7JYmYuieGZrCQJB_lx", + "canonical": "" + }, + { + "id": 38, + "moves": "8F2 6L' 1L2 10B2 z' 12D2 6U 12B 5U2 5F2", + "facelets": "RRRRRRRRRRRRRRRRRRRRRRRRLLLLLLLLLLLLRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRUDDDDBBDDDDU LUUUUUUUUUUULDUDUDDUDDDDLDUDUDDUDDDDLDUDUDDUDDDDUUUUUUUUUDURLBBBFBBBBBBBLBUBFBBBBBBBLDUDUDDUDDDDLDUDUDDUDDDDLDUDUDDUDDDDLDUDUDDUDDDDLUUUUUUUUUUU BFFFFDDFFFFBBFFFFDDFFFFBBFFFFDDFFFFBBFFFFDDFFFFBBBBBBBBBBBBBBFFFFDDFFFFBBFFFFDDFFFFBBFFFFDDFFFFBBFFFFDDFFFFBBFFFFFDFFFFBBFFFFDDFFFFBBFFFFDDFFFFB DUUUUFFUUUUDLLLLLLLLLLLLRRRRRRRRRRRRLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL DDDDDDDDDDDRUUUUDUUDUDURUUUUDUUDUDURUUUUDUUDUDURLDUDDDDDDDDDFFFFFFFBFFFRFFFFFFFBFDFRUUUUDUUDUDURUUUUDUUDUDURUUUUDUUDUDURUUUUDUUDUDURDDDDDDDDDDDR FFFFFFFFFFFFBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBFFFFUUFFFFBUUUUDUUUUBUUUUUUDUUUUUUUBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBFFFFFFFFFFFF", + "token": "BUosjFsycRRiIWqD2-ZaTb4s0NhgtvxBXN6U0K68waFoPqugbcnzQBeWu10ssRcKtUxPB3pPA8ZMslvYC28AJ7K_hLyVqMf-pQ-lAGzn_VNE8PFF-Nn5OOmdz7oYQraev0U1I4u4eZwYQcL-70_Qx_qhUMMYXWf9oZNJNbNm4phGGgNafQFdjzxnH_Cn_MpM2Rf4LOySXzL-fleJ5Q7THqyN5ZyNqe7PVlWBAz7hG3UjKFbt_8_cbkMskQDxqLl7dOqVjr6YHDkPCvGSuCFnBW2wF1yEk", + "canonical": "UDDDDBBDDDDURRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRLLLLLLLLLLLLRRRRRRRRRRRRRRRRRRRRRRRR DDDDDDDDDDDRUUUUDUUDUDURUUUUDUUDUDURUUUUDUUDUDURLDUDDDDDDDDDFFFFFFFBFFFRFFFFFFFBFDFRUUUUDUUDUDURUUUUDUUDUDURUUUUDUUDUDURUUUUDUUDUDURDDDDDDDDDDDR FFFFFFFFFFFFBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBFFFFUUFFFFBUUUUDUUUUBUUUUUUDUUUUUUUBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBFFFFFFFFFFFF LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLRRRRRRRRRRRRLLLLLLLLLLLLDUUUUFFUUUUD LUUUUUUUUUUULDUDUDDUDDDDLDUDUDDUDDDDLDUDUDDUDDDDUUUUUUUUUDURLBBBFBBBBBBBLBUBFBBBBBBBLDUDUDDUDDDDLDUDUDDUDDDDLDUDUDDUDDDDLDUDUDDUDDDDLUUUUUUUUUUU BFFFFDDFFFFBBFFFFDDFFFFBBFFFFDDFFFFBBFFFFDDFFFFBBBBBBBBBBBBBBFFFFDDFFFFBBFFFFDDFFFFBBFFFFDDFFFFBBFFFFDDFFFFBBFFFFFDFFFFBBFFFFDDFFFFBBFFFFDDFFFFB" + }, + { + "id": 39, + "moves": "8F2 6L' 1L2 10B2 z' 12D2 6U 12B 5U2 5F2", + "facelets": "RRRRRRRRRRRRRRRRRRRRRRRRLLLLLLLLLLLLRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRUDDDDBBDDDDU LUUUUUUUUUUULDUDUDDUDDDDLDUDUDDUDDDDLDUDUDDUDDDDUUUUUUUUUDURLBBBFBBBBBBBLBUBFBBBBBBBLDUDUDDUDDDDLDUDUDDUDDDDLDUDUDDUDDDDLDUDUDDUDDDDLUUUUUUUUUUU BFFFFDDFFFFBBFFFFDDFFFFBBFFFFDDFFFFBBFFFFDDFFFFBBBBBBBBBBBBBBFFFFDDFFFFBBFFFFDDFFFFBBFFFFDDFFFFBBFFFFDDFFFFBBFFFFFDFFFFBBFFFFDDFFFFBBFFFFDDFFFFB DUUUUFFUUUUDLLLLLLLLLLLLRRRRRRRRRRRRLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL DDDDDDDDDDDRUUUUDUUDUDURUUUUDUUDUDURUUUUDUUDUDURLDUDDDDDDDDDFFFFFFFBFFFRFFFFFFFBFDFRUUUUDUUDUDURUUUUDUUDUDURUUUUDUUDUDURUUUUDUUDUDURDDDDDDDDDDDR FFFFFFFFFFFFBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBFFFFUUFFFFBUUUUDUUUUBUUUUUUDUUUUUUUBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBFFFFFFFFFFFF", + "token": "SVMkJpf1ncoIJ8QtavzIzyslxOOPx_tZzsLkyPtRatsd7CM5YBIx_RwUAOkB_xchkS-oDjmcwgkjQLtzd8CQfHMIafJQtCxGvFyJRjnoGvNsc6YCNrV6EFSWVQxUTw3GB-9WyUle7V1N2bc-7OAHlI81rR3Qk8j6TTpGPtKVqVCBnUaeX4XWvYEStI1p7WvbITTPtfG1KF_FdSLXQG1r-TafopuUkEMgK_7bZXzAUChFqOyWuLX0RNPvOstj_InRN1IhFeQL8pZf68FcWmzCrMg1gll8Z", + "canonical": "" + }, + { + "id": 42, + "moves": "", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "" + }, + { + "id": 43, + "moves": "", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "" + }, + { + "id": 42, + "moves": "8F 10D2 10U 8D' x' 6R2 9R 9F' 10B' 4B", + "facelets": "BBBBUBBFBBBBBBBBBUBBFBBBBBBBBBUBBFBBBBBBBBBBBBBBBBBBRRRRRURRRRRRRBBBBLBBUBBBBBBBBBUBBFBBBBBLLLLULLFLLLLLBBBBUBBFBBBBBRRRRRURRRRRRRBBBBUBBFBBBBBBBBBUBBFBBBBBBBBBUBBFBBBBB RRRFRBRRFRRRRRRRFRBRRFRRRRRRRFRBRRFRRRRRRRFRBRRFRRRRRRRURBRRFRRRRUUUFUBUUBFUUURRRFRBRRFRRRRRRRURBRRFRRRRRRRFRBRRDDRRRRRRFRBRRFRRRRRRRFRBRRFRRRRRRRFRBRRFRRRRRRRFRBRRFRRRR UUUUFUUDUUUUUUUUUFUUDUUUUUUUUUFUUDUUUUUUUUUBUUDUUUUUUUUUFUUDUUUUULLLLRLLDLLLLLUUUUFUUDUUUUUUUUUFUURUUUUUUUUUFUUDUUUUUUUUURUUDUUUUUUUUUFUUDUUUUUUUUUFUUDUUUUUUUUUFUUDUUUUU FFFFDFFBFFFFFFFFFDFFBFFFFFFFFFDFFBFFFFFLLLLLDLLLLLLLFFFFDFFBFFFFFRRRRDRRBRRRRRFFFFDFFBFFFFFFFFFRFFDFFFFFLLLLLDLLLLLLLFFFFFFFFFFFFFFFFFDFFBFFFFFFFFFDFFBFFFFFFFFFDFFBFFFFF LLLLBLLFLBLLLLLLLBLLFLBLLLLLLLBLLFLBLLLLLLLBLLFLBLLLLLLLBLLFLDLLLDDDBFDDFDBDDDLLLLBLLFLBLLLLLLLBLLFLDLLLLLLUULLFLBLLLLLLLBLLFLBLLLLLLLBLLFLBLLLLLLLBLLFLBLLLLLLLBLLFLBLLL DDDDDUDDBDDDDDDDDDUDDBDDDDDDDDDUDDBDDDDDDDDDUDDFDDDDDDDDDUDDBDDDDRRRRRURRLRRRRDDDDDUDDBDDDDDDDDDLDDBDDDDDDDDDUDDBDDDDDDDDDUDDLDDDDDDDDDUDDBDDDDDDDDDUDDBDDDDDDDDDUDDBDDDD", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW2iOCPtY0879h2xHVMP5k2upv5dMjNduwCcP-eevU6yo97sKRoJwQ1iUZZASqIn-UINKmZp3YFHu2CV1LC8mGtqIVT46zR-3IE5mT4nwMXcN0AxMdhN4Y-6Ca1D23GKfIc3DBHaGsF-6PAwhzZnnsyuQ5Hil9c2uMOfPwvX6FPBcqBw_z-2gfBhqSsdrSJqb1IJpD_LHdLnD1QZf3vUGMf5JBX4PqjfNaQj6StRfdd3aMJmF1UX9_8UkwooJagOm1JB5DPb_ovE1gWtl6z30TawPzgBFyZVSD39eM", + "canonical": "UUUUFUUDUUUUUUUUUFUUDUUUUUUUUUFUUDUUUUUUUUUBUUDUUUUUUUUUFUUDUUUUULLLLRLLDLLLLLUUUUFUUDUUUUUUUUUFUURUUUUUUUUUFUUDUUUUUUUUURUUDUUUUUUUUUFUUDUUUUUUUUUFUUDUUUUUUUUUFUUDUUUUU RRRRRRRURRRRRRRRRRRRURRRRRRRRRRRRURRRRRFFFFFUFFUFFFFRRRRRRRURRRRRBBBBBBBBBBBBBRRRRRRRURRRRRRRRRRRRURRRRRFFFFDFFBFFFFFRRRRDRRFRRRRRRRRRRRRURRRRRRRRRRRRURRRRRRRRRRRRURRRRR FFFFDFFBFFFFFFFFFDFFBFFFFFFFFFDFFBFFFFFLLLLLDLLLLLLLFFFFDFFBFFFFFRRRRDRRBRRRRRFFFFDFFBFFFFFFFFFRFFDFFFFFLLLLLDLLLLLLLFFFFFFFFFFFFFFFFFDFFBFFFFFFFFFDFFBFFFFFFFFFDFFBFFFFF DDDDBDDUDDDDDDDDDBDDUDDDDDDDDDBDDUDDDDDDDDDLDDUDDDDDDDDDBDDUDDDDDDDDDBDDLDDDDDDDDDBDDUDDDDDRRRRLRRURRRRRDDDDBDDUDDDDDDDDDFDDUDDDDDDDDDBDDUDDDDDDDDDBDDUDDDDDDDDDBDDUDDDDD LLLLLDLLLLLLLLLLLLDLLLLLLLLLLLLDLLLLLLLBBBBDBBDBBBBBLLLLLDLLLLLLLFFFFFFFFFFFFFLLLLLDLLLLLLLLLLLLDLLLLLLLBBBBBFBBUBBBBLLLLLBLLULLLLLLLLLDLLLLLLLLLLLLDLLLLLLLLLLLLDLLLLLLL BBBBBFBBUBBBBBBBBBFBBUBBBBBBBBBFBBUBBBBRRRRRRRURRRRRBBBBBFBBUBBBBLLLLLFLLULLLLBBBBBFBBUBBBBBBBBBUBBLBBBBRRRRRRRURRRRRBBBBBBBBBBBBBBBBBBFBBUBBBBBBBBBFBBUBBBBBBBBBFBBUBBBB" + }, + { + "id": 43, + "moves": "8F 10D2 10U 8D' x' 6R2 9R 9F' 10B' 4B", + "facelets": "BBBBUBBFBBBBBBBBBUBBFBBBBBBBBBUBBFBBBBBBBBBBBBBBBBBBRRRRRURRRRRRRBBBBLBBUBBBBBBBBBUBBFBBBBBLLLLULLFLLLLLBBBBUBBFBBBBBRRRRRURRRRRRRBBBBUBBFBBBBBBBBBUBBFBBBBBBBBBUBBFBBBBB RRRFRBRRFRRRRRRRFRBRRFRRRRRRRFRBRRFRRRRRRRFRBRRFRRRRRRRURBRRFRRRRUUUFUBUUBFUUURRRFRBRRFRRRRRRRURBRRFRRRRRRRFRBRRDDRRRRRRFRBRRFRRRRRRRFRBRRFRRRRRRRFRBRRFRRRRRRRFRBRRFRRRR UUUUFUUDUUUUUUUUUFUUDUUUUUUUUUFUUDUUUUUUUUUBUUDUUUUUUUUUFUUDUUUUULLLLRLLDLLLLLUUUUFUUDUUUUUUUUUFUURUUUUUUUUUFUUDUUUUUUUUURUUDUUUUUUUUUFUUDUUUUUUUUUFUUDUUUUUUUUUFUUDUUUUU FFFFDFFBFFFFFFFFFDFFBFFFFFFFFFDFFBFFFFFLLLLLDLLLLLLLFFFFDFFBFFFFFRRRRDRRBRRRRRFFFFDFFBFFFFFFFFFRFFDFFFFFLLLLLDLLLLLLLFFFFFFFFFFFFFFFFFDFFBFFFFFFFFFDFFBFFFFFFFFFDFFBFFFFF LLLLBLLFLBLLLLLLLBLLFLBLLLLLLLBLLFLBLLLLLLLBLLFLBLLLLLLLBLLFLDLLLDDDBFDDFDBDDDLLLLBLLFLBLLLLLLLBLLFLDLLLLLLUULLFLBLLLLLLLBLLFLBLLLLLLLBLLFLBLLLLLLLBLLFLBLLLLLLLBLLFLBLLL DDDDDUDDBDDDDDDDDDUDDBDDDDDDDDDUDDBDDDDDDDDDUDDFDDDDDDDDDUDDBDDDDRRRRRURRLRRRRDDDDDUDDBDDDDDDDDDLDDBDDDDDDDDDUDDBDDDDDDDDDUDDLDDDDDDDDDUDDBDDDDDDDDDUDDBDDDDDDDDDUDDBDDDD", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgkc1Q15BT22fEsiav8l9l0hfp9i8tNDJiA6l_bbhv2C_XOYj2nDqGUE3phYG_zO_XjE7-ZnsxB65kQ4L8JGuShHzH_dWDOvkrB1mXdO6EoylLgScrEdNJXlw6D5ckqT7rK0pIaxygiPl1oSMrRm24zBWVa0-PC0hUlbt6Rw9x9oivwqX7fkcLokn3ArIOzn6b7DnZfsKy8Wpb-Jj85viUr9bYg9F39TtB2Nd3A-jzDMx0jmSL_o_P-ntyPPDh8Fej7YtZNyf3Rp0EIhGODc7nSCF7UAaK5f-xc_DUs", + "canonical": "" + }, + { + "id": 42, + "moves": "13D2 7R' 11F 9D2 6F2 7B' 5D 13D2 8R' 5U2", + "facelets": "UUUUUBFUUUUUUUUUUUBBUUUUUUUUUUUBBUUUUUUUUUUUBBUUUUUUUUUUURBUUUUUUDDDDDBFDDDDDDRLLLRBLLLLLLLUUUUUBBUUUUUUUUUUUFBUUUUUUUUUUUBBUUUUUURLLLLBLLLLLLLUUUUUBBUUUUUUUUUUUBBUUUUUU RRDRRRDRRRRRRRRRRRLURRRURRRRRRRLURRRURRRRRRRLURRRURRRRRRRRDRRRURRRRRRRLURRRURRRRRRRLBRRRBRRRRRRRLURRRURRFFFFFFUFFFFFFRRRRRLURRRURRRRRRRLURRRURRRRRRRLURRRURRRRRRRRURRRURR FFFFFUDFFFFFFFFFFFUUFFFFFFFFFFFUUFFFFFFFFFFFUUFFFFFFFFFFFFUDFFFFFFFFFFDUFFFFFFFFFFFLUFFFFFFFFFFFUUFFFFFFLLDLLUDLLLLLLFFFFFUUFFFFFFFFFFFLUFFFFFFFFFFFUUFFFFFFFFFFFUUFFFFFF DDDDDFBDDDDDDDDDDDFFDDDDDDDDDDDFFDDDDDDDDDDDFFDDDDDDDDDDDBFDDDDDDUUUUUFBUUUUUURRRRRFRRLRRRLDDDDDFFDDDDDDDDDDDLFDDDDDDDDDDDFFDDDDDDRRRRRFRRRRRRLDDDDDFFDDDDDDDDDDDFFDDDDDD LLLLLLULLLULLLLDLLLDRLLLLLLLDLLLDRLLLLLLLDLLLDRLLLLLLLDLLLULLLLLLLLDLLLDRLLLLLLLFLLLFRLLLLLLLDLLLDRLLLLLBBBBBBDBBBBBBLLDLLLDRLLLLLLLDLLLDRLLLLLLLDLLLDRLLLLLLLDLLLDLLLLLL BBBBBBUDBBBBBBBBBBBDDBBBBBBBBBBBDRBBBBBBBBBBBDDBBBBBBBBBBUDBBBBBBBBBBBBDDBBBBBBBBBBBDRBBBBBBBBBBBDUBBBBBRRRRRRUDRRURRBBBBBBDDBBBBBBBBBBBDDBBBBBBBBBBBDDBBBBBBBBBBBDDBBBBB", + "token": "DEvFi6d0E1_HgM16C3bx3wDz6vJNVQRuV11LcLuaKxUvBFfCd2O8cW8XS6evrOItfOk26S_XjkJ74cX2JdpWYm2QKWMdyFznVZ0jd4OSBf5aYKsn8Wv3-AODk5OENwqtTX45m0KtuZd-nMK15vUttOwVSlnI7Wsyg5hXAFsw_PNwDWBdeQ1R5bawhCK8CpjNwhI81NxlnExmHHUO7sh26RBhec2x4aR0sFRRzmjudh5bla7tsIxKJhT7QRNKUTSMq8l4Gzc4Rc-ct6p2aFVnUDRp2PQJNM37eA6n7GFXPsFH8x2WY_GgKgVvuv-rTda8VYmmvmaysoKvXfC", + "canonical": "FFFFFFFFLFFFFFFFFFFFFLFFFFFFFFFFFFLFFFFFFFFFFFFLFFFFFFFFFFFFLFFFFFFFFDFFFLFFFFDUUUUUUUDUUUUUUUUFDLUUULUUFFFFFFFFLFFFFFFFFFFFFLFFFFFFFFFFFFDFFFFFFFFFFFFLFFFFFFFFFFFFLFFFF DDDDDFBDDDDDDDDDDDFFDDDDDDDDDDDFFDDDDDDDDDDDFFDDDDDDDDDDDBFDDDDDDUUUUUFBUUUUUURRRRRFRRLRRRLDDDDDFFDDDDDDDDDDDLFDDDDDDDDDDDFFDDDDDDRRRRRFRRRRRRLDDDDDFFDDDDDDDDDDDFFDDDDDD LLLLLLLLBLLLLLLLLLLLLBLLLLULLLLLLLBLLLLLLLLLLLLBLLLLLLLLLLLLBLLLLLRRRLRRRBRRRLUDDDUDFDDDDDDLLLLLLLLBLLLLLLLLLLLLBLLLLLLLLLLLLBLLLLLDDDDDFDBDDDDLLLLLLLLBLLLLLLLLLLLLBLLLL BBBBBBBBRBBBBBBBBBBBBRBBBBBBBBBBBBUBBBBBBBBBBBBRBBBBBBBBBBBBRBBBBDDRDBDRUDDDDDUDDDDDDDUDDDDBBBBUBBBRBBBBBBBBBBBBRBBBBBBBBBBBBRBBBBBBBBBBBBRBBBBBBBBBBBBRBBBBBBBBBBBBRBBBB UUUUUUBBUUUUUUUUUUUBBUUUUULLLLLLLBLLLLRUUUUUUBBUUUUUUUUUUUBFUUUUUUUUUUUBBUUUUULLLLLLLBRLLLRDDDDDDFBDDDDDUUUUUUBRUUUUUUUUUUUBBUUUUUUUUUUUBBUUUUUUUUUUUBBUUUUUUUUUUUFBUUUUU RRRRFRRRRRRRRRRRRFRRRRRRRRRRRRFRRRRRRRDRRRRFRRRRRRRRRRRRFRRRRRRRRRLLLFLLLRLLLRUUUUUUBUDUUUDRRRRFRRRRRRRRRRRRFRRRRRRRRRRRRFRRRRRRRRUUUUFUBUUUUURRRRRFRRRRRRRRRRRRFRRRRRRRR" + }, + { + "id": 43, + "moves": "13D2 7R' 11F 9D2 6F2 7B' 5D 13D2 8R' 5U2", + "facelets": "UUUUUBFUUUUUUUUUUUBBUUUUUUUUUUUBBUUUUUUUUUUUBBUUUUUUUUUUURBUUUUUUDDDDDBFDDDDDDRLLLRBLLLLLLLUUUUUBBUUUUUUUUUUUFBUUUUUUUUUUUBBUUUUUURLLLLBLLLLLLLUUUUUBBUUUUUUUUUUUBBUUUUUU RRDRRRDRRRRRRRRRRRLURRRURRRRRRRLURRRURRRRRRRLURRRURRRRRRRRDRRRURRRRRRRLURRRURRRRRRRLBRRRBRRRRRRRLURRRURRFFFFFFUFFFFFFRRRRRLURRRURRRRRRRLURRRURRRRRRRLURRRURRRRRRRRURRRURR FFFFFUDFFFFFFFFFFFUUFFFFFFFFFFFUUFFFFFFFFFFFUUFFFFFFFFFFFFUDFFFFFFFFFFDUFFFFFFFFFFFLUFFFFFFFFFFFUUFFFFFFLLDLLUDLLLLLLFFFFFUUFFFFFFFFFFFLUFFFFFFFFFFFUUFFFFFFFFFFFUUFFFFFF DDDDDFBDDDDDDDDDDDFFDDDDDDDDDDDFFDDDDDDDDDDDFFDDDDDDDDDDDBFDDDDDDUUUUUFBUUUUUURRRRRFRRLRRRLDDDDDFFDDDDDDDDDDDLFDDDDDDDDDDDFFDDDDDDRRRRRFRRRRRRLDDDDDFFDDDDDDDDDDDFFDDDDDD LLLLLLULLLULLLLDLLLDRLLLLLLLDLLLDRLLLLLLLDLLLDRLLLLLLLDLLLULLLLLLLLDLLLDRLLLLLLLFLLLFRLLLLLLLDLLLDRLLLLLBBBBBBDBBBBBBLLDLLLDRLLLLLLLDLLLDRLLLLLLLDLLLDRLLLLLLLDLLLDLLLLLL BBBBBBUDBBBBBBBBBBBDDBBBBBBBBBBBDRBBBBBBBBBBBDDBBBBBBBBBBUDBBBBBBBBBBBBDDBBBBBBBBBBBDRBBBBBBBBBBBDUBBBBBRRRRRRUDRRURRBBBBBBDDBBBBBBBBBBBDDBBBBBBBBBBBDDBBBBBBBBBBBDDBBBBB", + "token": "BJxqFF7Lh0Pq0E0NxEyas6BbeBrc_-GpYML8SkZZ0CfxoaDo7MVmqomovF7h4NTRDtd0l3Hw1VjudKo8TjHgZOkWD4UrKyLWwBrtTNFWwj9h5EAu-oh8_QFRV1dRlKQA_Q9VmjkBJZjPeskENpvxI9iH--GrWQgy8VkgoCIyXttKBQQjDWT-tiSCMY0Gg_lNKMbWz9KmGpymSqvlmYssl2Ykja0itJ2rwh-erWdZbEtiWCGZIjSbzkfeOGc73nO0wGuNCjS1Gi3axN_sZyAGvhOnsVuDc80-TQV--KSAt4h6-ysYZXqcD8IJ5h_gPTCGoBOeh2aDAvEBwzpB", + "canonical": "" + }, + { + "id": 42, + "moves": "8R' 7D 9L2 6D 5D' 13R2 7B2 5U y' x'", + "facelets": "RRRRRRLRRRRRRRRRRRRLRRRRRRRRRRRRLRRRRRRRRRRRRLRRRRRRBBBBBDFBFBBBBFFFFBFBUFFFFFFFFFFFBUFFFFFRRRRRRLRRRRRRRBBBBDBBFBBBBRRRRRRLRRRRRRRRRRRRLRRRRRRRRRRRRLRRRRRRRRRRRRLRRRRRR FFFFRFLLRFFFFFFFFRFLLRFFFFFFFFRFLLRFFFFFFFFRFLLRFFFFBBBBRBRLRBBBBFFFFRFLLRFFFFFFFFLFLLRFFFFUUUURULLRUUUUFFFFRFLLRFFFFFFFFRFLLRFFFFFFFFRFLLRFFFFFFFFRFLLRFFFFBBBBRRRBBBBBB UUUUUUUUUUUUUUUUUUUDUUUUUUUUUUUUDUUUUUUUUUUUUDUUUUUUDDDDDDDDDDDDDUUUUUUFUUUUUUUUUUUUDUUUUUUBBBBBBDBBBBBBUUUUUUUUUUUUUUUUUUUDUUUUUUUUUUUUDUUUUUUUUUUUUDUUUUUUDDDDDDDDDDDDD LLLLLLRLLLLLLLLLLLLRLLLLLLLLLLLLRLLLLLLLLLLLLRLLLLLLLFFFFUFFBFFFFBBBBBDFBFBBBBBBBBBDFBBBBBBLLLLLLRLLLLLLLLLLLLRLLLLLLLLLLLLRLLLLLLLLLLLLRLLLLLLLLLLLLRLLLLLLLLLLLLRLLLLLL BBBBLRRBFBBBBBBBBLRRBFBBBBBBBBLRRBFBBBBBBBBLRRBFBBBBFFFFLRLFBFFFFBBBBLRRBFBBBBBBBBLRRBBBBBBDDDDLRRDUDDDDBBBBLRRBFBBBBBBBBLRRBFBBBBBBBBLRRBFBBBBBBBBLRRBFBBBBFFFFFFLLFFFFF DDDDDDDDDDDDDDDDDDDUDDDDDDDDDDDDUDDDDDDDDDDDDUDDDDDDUUUUUUUUUUUUUDDDDDDBDDDDDDDDDDDDUDDDDDDFFFFFFUFFFFFFDDDDDDDDDDDDDDDDDDDUDDDDDDDDDDDDUDDDDDDDDDDDDUDDDDDDUUUUUUUUUUUUU", + "token": "AuSDUSmTi28_1kLmL5Qf1WVKYsmgyrr_QCtx_6tm-bgEfADnyUnCDvVS-MPPLu_N5tWrmvRn_qlBxB33sLZrJuWYjfk3X-4ry-ggrPPbzB9IIs_VC_WpEqsHLCezbbzJXi-RFTei-rCO-qf8fOT1olJRmCqhk4DChMMNeu79nIgwQaGCxQRvMUmIKOlMer8NOP4X4qE6U9rD1uaRWbiJkGWN9pKO6ajCbTHbRlyZ3kCMJDaaYERyTpnf10SSIhjrWupMXwDVrJY6jS0yZCCftMzL2RVpduCtHh3KAOo9TpmpT3IuzAKyESKMryZ9ofLPo2h8Jxq7IaiUeLu", + "canonical": "DDDDDDDDDDDDDDDDDDDUDDDDDDDDDDDDUDDDDDDDDDDDDUDDDDDDUUUUUUUUUUUUUDDDDDDBDDDDDDDDDDDDUDDDDDDFFFFFFUFFFFFFDDDDDDDDDDDDDDDDDDDUDDDDDDDDDDDDUDDDDDDDDDDDDUDDDDDDUUUUUUUUUUUUU FBBBBDBBFBBBBFBBBBDBBFBBBBFBBBBDBBFBBBBFBBBBDBBFBBBBFLLLLLLLLLLLLFRRRRRRRRRRRRLRRRRRRRLRRRRLBBBBDBBFBBBBFFFFFUBFBFFFFFBBBBDBBFBBBBFBBBBDBBFBBBBFBBBBDBBFBBBBFBBBBDBBFBBBB LLLLLLRLLLLLLLLLLLLRLLLLLLLLLLLLRLLLLLLLLLLLLRLLLLLLLLLLLLRLLLLLLLLLLLLRLLLLLLBBBBBBFDBBBBBBBBBFBFDBBBBBFFFFBFFUFFFFLLLLLLLRLLLLLLLLLLLLRLLLLLLLLLLLLRLLLLLLLLLLLLRLLLLLL DDDDDDDDDDDDDUUUUUUDUUUUUUUUUUUUDUUUUUUUUUUUUDUUUUUUUUUUUUUUUUUUUBBBBBBDBBBBBBUUUUUUDUUUUUUUUUUUUFUUUUUUDDDDDDDDDDDDDUUUUUUDUUUUUUUUUUUUDUUUUUUUUUUUUDUUUUUUUUUUUUUUUUUUU FFFFBFFUFFFFBFFFFBFFUFFFFBFFFFBFFUFFFFBFFFFBFFUFFFFBRRRRRRRRRRRRBLLLLLLLLLLLLBLLLLRLLLLLLLRFFFFBFFUFFFFRRRRRRRLRRRRRRFFFFBFFUFFFFBFFFFBFFUFFFFBFFFFBFFUFFFFBFFFFBFFUFFFFB RRRRRRLRRRRRRRRRRRRLRRRRRRRRRRRRLRRRRRRRRRRRRLRRRRRRBBBBBDFBFBBBBFFFFBFBUFFFFFFFFFFFBUFFFFFRRRRRRLRRRRRRRBBBBDBBFBBBBRRRRRRLRRRRRRRRRRRRLRRRRRRRRRRRRLRRRRRRRRRRRRLRRRRRR" + }, + { + "id": 43, + "moves": "8R' 7D 9L2 6D 5D' 13R2 7B2 5U y' x'", + "facelets": "RRRRRRLRRRRRRRRRRRRLRRRRRRRRRRRRLRRRRRRRRRRRRLRRRRRRBBBBBDFBFBBBBFFFFBFBUFFFFFFFFFFFBUFFFFFRRRRRRLRRRRRRRBBBBDBBFBBBBRRRRRRLRRRRRRRRRRRRLRRRRRRRRRRRRLRRRRRRRRRRRRLRRRRRR FFFFRFLLRFFFFFFFFRFLLRFFFFFFFFRFLLRFFFFFFFFRFLLRFFFFBBBBRBRLRBBBBFFFFRFLLRFFFFFFFFLFLLRFFFFUUUURULLRUUUUFFFFRFLLRFFFFFFFFRFLLRFFFFFFFFRFLLRFFFFFFFFRFLLRFFFFBBBBRRRBBBBBB UUUUUUUUUUUUUUUUUUUDUUUUUUUUUUUUDUUUUUUUUUUUUDUUUUUUDDDDDDDDDDDDDUUUUUUFUUUUUUUUUUUUDUUUUUUBBBBBBDBBBBBBUUUUUUUUUUUUUUUUUUUDUUUUUUUUUUUUDUUUUUUUUUUUUDUUUUUUDDDDDDDDDDDDD LLLLLLRLLLLLLLLLLLLRLLLLLLLLLLLLRLLLLLLLLLLLLRLLLLLLLFFFFUFFBFFFFBBBBBDFBFBBBBBBBBBDFBBBBBBLLLLLLRLLLLLLLLLLLLRLLLLLLLLLLLLRLLLLLLLLLLLLRLLLLLLLLLLLLRLLLLLLLLLLLLRLLLLLL BBBBLRRBFBBBBBBBBLRRBFBBBBBBBBLRRBFBBBBBBBBLRRBFBBBBFFFFLRLFBFFFFBBBBLRRBFBBBBBBBBLRRBBBBBBDDDDLRRDUDDDDBBBBLRRBFBBBBBBBBLRRBFBBBBBBBBLRRBFBBBBBBBBLRRBFBBBBFFFFFFLLFFFFF DDDDDDDDDDDDDDDDDDDUDDDDDDDDDDDDUDDDDDDDDDDDDUDDDDDDUUUUUUUUUUUUUDDDDDDBDDDDDDDDDDDDUDDDDDDFFFFFFUFFFFFFDDDDDDDDDDDDDDDDDDDUDDDDDDDDDDDDUDDDDDDDDDDDDUDDDDDDUUUUUUUUUUUUU", + "token": "ARWxPm-XVEm38FkWUdeL8AX75QucTAYfuBBKv-BGnaUBroBW63uoxZv_HUltsZntNpAgWhum_394qYs84kRoLpYZNT10w_lQbHcMQNtybIu7DQ3v5HwfZwAisI7jSSbLg1HWZ_TdHgI1nf7-rtXcHN7emQ_8l1BI8cklDhmfGrMSGJyRCeGpsnuTD1d8rgek9V9I9Px133IJcJZ2gaUzliYVPHb1l59I6PKyOmK5s1g0jZR55Bmq3Xmz8Lm2zMlYQhfco6BQILhV9PDy5Yw748zMcWgHjJRA60srwFfW_XmffcrRjIECxmz0wa5vHLsN3UcujqoGLJ83rUZe", + "canonical": "" + }, + { + "id": 46, + "moves": "", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "" + }, + { + "id": 47, + "moves": "", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "" + }, + { + "id": 46, + "moves": "9L2 1F' 5U2 6B' 5R' 13U' 6L2 6L' 7L2 4D", + "facelets": "UUUUUBLUDBUUUUUUUUUUDUDBUUUUUUUUUBDUDBUUUUUUUUUBDUDBUUUUUUUUUBDUDBUUUULLLLLBDLLBLLLLUUUUUBDUDBUUUUUUUUUBDUDBUUUUUUUUUBRUDBUUUUUUUUUFDUDFUUUUUUUUUBDUDBUUUUUUUUUBDUDBUUUUUUUUUBDUDBUUUURRRRRBDRRBRRRR DRRRRRRRURRRRRDRRRRRRRURRRRRDRRRRRRRURRRRRDRRRRRRRURRRRRLLLLLLLLULLLLUURRRRRRRURRRRRDRRRRRRRURRRRRDRRRRRRRURRRRRDRRRRRRRDRRRRRDRRRRRRRURRRRRFFFFFUBFFUFFFFDRRRRRRRURRRRRFFFFFFFFFUFFFFDRRRRRRRURRRRR FFFFFUBFFUFFFFFFFFFURFFUFFFFFFFFFUBFFUFFFFFFFFFUBFFUFFFFBBBBBUBBBUBBBBBBBBBLBBBRBBBBFFFFFUBFFUFFFFFFFFFUBFFUFFFFFFFFFUBFFUFFFFFFFFFUFFFUFFFFLLLLLDLLLLLLLUFFFFFUBFFUFFFFLLLLLUBLLLLLLUFFFFFRBFFRFFFF LLLLLFULLFLLLLDDDDDFUDUFDDDDDDDDDFUDUFDDDDDDDDDFUDUFDDDDDDDDDFUDUBDDDDDDDDDBLDUBDDDDDDDDDFUDUFDDDDDDDDDFUDUFDDDDRRRRRFURRFRRRRDDDDDFUDUFDDDDDDDDDFUDUFDDDDDDDDDFUDUFDDDDDDDDDDUDUFDDDDDDDDDFRDUFDDDD LLLLLDLLLLLLLULLLLLDLLLLLLLULLLLLDLLLLLLLULLLLLDLLLLLLLUDRRRRDRRRRRRRRLLLLLDLLLLLLLDLLLLLDLLLLLLLULLLLLDLLLLLLLULLLLLULLLLLLLULLLLLDLLLLLLLUBBBBDFBFDBBBBBLLLLLDLLLLLLLUBBBBDFBBBBBBBBLLLLLDLLLLLLLU BBBBDFBFDBBBBBBBBBDFBLDBBBBBBBBBDFBFDBBBBBBBBBDFBFDBBBBBFFFFDFFFDFFFFFBBBBLFBFRBBBBBBBBBDFBFDBBBBBBBBBDFBFDBBBBBBBBBDFBBDBBBBBBBBBDFBBDBBBBBDRRRRRRRURRRRRBBBBDFBFDBBBBBDRRRRRRFDRRRRRBBBBLFBFLBBBBB", + "token": "S_sPBk54GVv7SaL8rFuutfq9pFSjO8PQbpSRvL_DpKYZxiyINFZxvTCD59UVZL_UP3riP4etbx0wLvNe3QsUBfik0ndLDSP0aRekK87QoaIZkmYXPZZG-XbyRAk4_XfNvBqzQnm9HVn-EVOxjZ4S-aONacPUrucxYfyDZG4g2txmLYAw7kbwnLO1u_FTmHLlwCdPACezJ0GvcLsnCbInVOr0bnfzEe7ZFEiO-2R_jAPJZKpHcB6pHJMFVkk-ycs_wpQXNZe1JA6VcIR4D3_d_KVCebXA9NN2pLVPyZ-Fg23aC6ikUJSpvcfh4L8h-9hOdvQZP_RAjiLOHhGRRV-WLCwkSkw4mfhPnDF8jUkIQwbnnbSsPgQpYhGGzZaq92GqB8_-7BA8", + "canonical": "" + }, + { + "id": 47, + "moves": "9L2 1F' 5U2 6B' 5R' 13U' 6L2 6L' 7L2 4D", + "facelets": "UUUUUBLUDBUUUUUUUUUUDUDBUUUUUUUUUBDUDBUUUUUUUUUBDUDBUUUUUUUUUBDUDBUUUULLLLLBDLLBLLLLUUUUUBDUDBUUUUUUUUUBDUDBUUUUUUUUUBRUDBUUUUUUUUUFDUDFUUUUUUUUUBDUDBUUUUUUUUUBDUDBUUUUUUUUUBDUDBUUUURRRRRBDRRBRRRR DRRRRRRRURRRRRDRRRRRRRURRRRRDRRRRRRRURRRRRDRRRRRRRURRRRRLLLLLLLLULLLLUURRRRRRRURRRRRDRRRRRRRURRRRRDRRRRRRRURRRRRDRRRRRRRDRRRRRDRRRRRRRURRRRRFFFFFUBFFUFFFFDRRRRRRRURRRRRFFFFFFFFFUFFFFDRRRRRRRURRRRR FFFFFUBFFUFFFFFFFFFURFFUFFFFFFFFFUBFFUFFFFFFFFFUBFFUFFFFBBBBBUBBBUBBBBBBBBBLBBBRBBBBFFFFFUBFFUFFFFFFFFFUBFFUFFFFFFFFFUBFFUFFFFFFFFFUFFFUFFFFLLLLLDLLLLLLLUFFFFFUBFFUFFFFLLLLLUBLLLLLLUFFFFFRBFFRFFFF LLLLLFULLFLLLLDDDDDFUDUFDDDDDDDDDFUDUFDDDDDDDDDFUDUFDDDDDDDDDFUDUBDDDDDDDDDBLDUBDDDDDDDDDFUDUFDDDDDDDDDFUDUFDDDDRRRRRFURRFRRRRDDDDDFUDUFDDDDDDDDDFUDUFDDDDDDDDDFUDUFDDDDDDDDDDUDUFDDDDDDDDDFRDUFDDDD LLLLLDLLLLLLLULLLLLDLLLLLLLULLLLLDLLLLLLLULLLLLDLLLLLLLUDRRRRDRRRRRRRRLLLLLDLLLLLLLDLLLLLDLLLLLLLULLLLLDLLLLLLLULLLLLULLLLLLLULLLLLDLLLLLLLUBBBBDFBFDBBBBBLLLLLDLLLLLLLUBBBBDFBBBBBBBBLLLLLDLLLLLLLU BBBBDFBFDBBBBBBBBBDFBLDBBBBBBBBBDFBFDBBBBBBBBBDFBFDBBBBBFFFFDFFFDFFFFFBBBBLFBFRBBBBBBBBBDFBFDBBBBBBBBBDFBFDBBBBBBBBBDFBBDBBBBBBBBBDFBBDBBBBBDRRRRRRRURRRRRBBBBDFBFDBBBBBDRRRRRRFDRRRRRBBBBLFBFLBBBBB", + "token": "GNYIodQpxOwWZZxpl1TC-yXJv1EsvI1MY-ZiBoz2QZYiTF--fqxvqHhYCvl3TmjZ_wKzG9zru3MPGsbDKON-nvl7dKdPHFFl0GfJiVD41XBd8C4G4b3SNqsnXCHbbXJe7m9XjyzXWBK0e6MQxqmkeffpG8M2hAy428Vb-b7_qb4DZlJii6M5DPj7e2bPuNGvkYSFOv8iHmyRk7sM2dA5IPmzwdOvFH88shmUQHGYghja3f9X34e9gUX78k1hgvu5D4YqwAUHpVKdOK9Q4JH5_ReSEjgtC0qPcr5Jsiy-mZwac5YGEL56Mt9L6PDLwDA-C9bVIuf31Du1zY4tugz-C51VBgWw4mfhPnDF8jUkIQwbnnbSsPgQpYhGGzZaq92GqB8_-7BA8", + "canonical": "" + }, + { + "id": 46, + "moves": "14F' y2 5F 1R2 11B 7B2 1F 7U' 11U2 3B", + "facelets": "UUUUUUUUUUUUULUUUUUUUUUUUUUDLLLLLLBLLLRLLLUUUUUUUUUUUUUDUUUUUUUUUUUUULUUUUUUUUUUUUUDUDDDDDDDDDDDDDUUUUUUUUUUUUUDUUUUUUUUUUUUUDRRRRRRRRRRRRRDLLLLLLLLLLLLLLUUUUUUUUUUUUUDUUUUUUUUUUUUUDDDDDDDDDDDDDDD RLLULLLRLULULURLLDLLLRLULDLURLLDLLLRLULDLURLLDLLLRLULDLURLLDLLLRLULDLURLLDLLLRLULDLUBBBBBBBBBBBDBBRLLDLLLRLULDLURLLDLLLRLULDLURLLDLLLRLULDLURRRRRRLRRDUDRLRLLDLLLRLULDLURLLDLLLRLULDLUDLLDLLLRLULDLU BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBRRRRRRLRRDURRLBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBFFFFFFFFFFFFFBBBBBBBBBBBBBBBBBBBBBBBBBBBBFFFFFFFFFFFFFF LLLLLLLLLLLLLLDDDDDDDDDDDDDUDDDDDDDDDDDDDURRRRRRRRRRRRRRLLLLLLLLLLLLLUDDDDDDDDDDDDDUDDDDDDDDDDDDDUDUUUUUUUUUUUUUDDDDDDDDDDDDDUDDDDDDDDDDDDDRDDDDDDDDDDDDDURRRRRRFRRRLRRRDDDDDDDDDDDDDUDDDDDDDDDDDDDR RRDRRRLRRDDRRLRRURRRLRRDURRLRRURRRLRRDURRLRRURRRLRRDURRLRRURRRLRRDURRLRRURRRLRRDURRLBFUFFFFFFFFFFFRRURRRLRRDURRLRRURRRLRRDURRLRRURRRLRRDURRLRLUDLLLRLULLLURRURRRLRRDURRLRRURRRLRRDURRLRRURRRLRRDURRU BFFFFFFFFFFFFFBFFFFFFFFFFFFFBFFFFFFFFFFFFFBFFFFFFFFFFFFFBFFFFFFFFFFFFFBFFFFFFFFFFFFFRLLDLLLRLULLLUBFFFFFFFFFFFFFBFFFFFFFFFFFFFBFFFFFFFFFFFFFBBBBBBBBBBBBBBBFFFFFFFFFFFFFBFFFFFFFFFFFFFBFFFFFFFFFFFFF", + "token": "Qr075yK0ppG4ij4UJuEGn5NvOO36NRZhWHW-CVXyCFxrNeSbKzfc3PSClFZgzYQNxQK7pOH6OE1aYXTlbNK3pNuRYbSSSUP1FYHxYS8p5IJXz4Ej9BNAxuKhyLKM5k5fhjHovSXnaoNI8eHO7PEpBUxJWDcaNlXUcJGFGn4vObRzp4bKODANM14eP_j47cTZZ6g44UHdRcPB5Ng7Gamb5XoqmoiGT3oXSkARkhXlpQs8Hnxs2TKiYn6SoZoiaG0PQWaxY5aMDT2heJGVyyDftwh5-oXEs3UOl6EWR2BrStNSJpK-xNRuVdePLxgXcT9XM2_ubaZfVQTIk84RR_AMmecxDMUEOm5_jQ1h1cazo2q7Kcyp2TbaG5LITEkalXdU6kmogZnk", + "canonical": "LLLLLLLLLLLLLLDDDDDDDDDDDDDUDDDDDDDDDDDDDURRRRRRRRRRRRRRLLLLLLLLLLLLLUDDDDDDDDDDDDDUDDDDDDDDDDDDDUDUUUUUUUUUUUUUDDDDDDDDDDDDDUDDDDDDDDDDDDDRDDDDDDDDDDDDDURRRRRRFRRRLRRRDDDDDDDDDDDDDUDDDDDDDDDDDDDR ULDLULRLLLDLLDULDLULRLLLDLLRULDLULRLLLDLLRLRDUDRRLRRRRRRULDLULRLLLDLLRULDLULRLLLDLLRULDLULRLLLDLLRBBDBBBBBBBBBBBULDLULRLLLDLLRULDLULRLLLDLLRULDLULRLLLDLLRULDLULRLLLDLLRULDLULRLLLDLLRULULULRLLLULLR FFFFFFFFFFFFFBFFFFFFFFFFFFFBFFFFFFFFFFFFFBBBBBBBBBBBBBBBFFFFFFFFFFFFFBFFFFFFFFFFFFFBFFFFFFFFFFFFFBULLLULRLLLDLLRFFFFFFFFFFFFFBFFFFFFFFFFFFFBFFFFFFFFFFFFFBFFFFFFFFFFFFFBFFFFFFFFFFFFFBFFFFFFFFFFFFFB UUUUUUUUUUUUULUUUUUUUUUUUUUDLLLLLLBLLLRLLLUUUUUUUUUUUUUDUUUUUUUUUUUUULUUUUUUUUUUUUUDUDDDDDDDDDDDDDUUUUUUUUUUUUUDUUUUUUUUUUUUUDRRRRRRRRRRRRRDLLLLLLLLLLLLLLUUUUUUUUUUUUUDUUUUUUUUUUUUUDDDDDDDDDDDDDDD URRUDRRLRRRURRLRRUDRRLRRRURRLRRUDRRLRRRURRULLLULRLLLDULRLRRUDRRLRRRURRLRRUDRRLRRRURRLRRUDRRLRRRURRFFFFFFFFFFFUFBLRRUDRRLRRRURRLRRUDRRLRRRURRLRRUDRRLRRRURRLRRUDRRLRRRURRLRRUDRRLRRRURRLRRDDRRLRRRDRR FFFFFFFFFFFFFFBBBBBBBBBBBBBBBBBBBBBBBBBBBBFFFFFFFFFFFFFBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBLRRUDRRLRRRRRRBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB" + }, + { + "id": 47, + "moves": "14F' y2 5F 1R2 11B 7B2 1F 7U' 11U2 3B", + "facelets": "UUUUUUUUUUUUULUUUUUUUUUUUUUDLLLLLLBLLLRLLLUUUUUUUUUUUUUDUUUUUUUUUUUUULUUUUUUUUUUUUUDUDDDDDDDDDDDDDUUUUUUUUUUUUUDUUUUUUUUUUUUUDRRRRRRRRRRRRRDLLLLLLLLLLLLLLUUUUUUUUUUUUUDUUUUUUUUUUUUUDDDDDDDDDDDDDDD RLLULLLRLULULURLLDLLLRLULDLURLLDLLLRLULDLURLLDLLLRLULDLURLLDLLLRLULDLURLLDLLLRLULDLUBBBBBBBBBBBDBBRLLDLLLRLULDLURLLDLLLRLULDLURLLDLLLRLULDLURRRRRRLRRDUDRLRLLDLLLRLULDLURLLDLLLRLULDLUDLLDLLLRLULDLU BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBRRRRRRLRRDURRLBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBFFFFFFFFFFFFFBBBBBBBBBBBBBBBBBBBBBBBBBBBBFFFFFFFFFFFFFF LLLLLLLLLLLLLLDDDDDDDDDDDDDUDDDDDDDDDDDDDURRRRRRRRRRRRRRLLLLLLLLLLLLLUDDDDDDDDDDDDDUDDDDDDDDDDDDDUDUUUUUUUUUUUUUDDDDDDDDDDDDDUDDDDDDDDDDDDDRDDDDDDDDDDDDDURRRRRRFRRRLRRRDDDDDDDDDDDDDUDDDDDDDDDDDDDR RRDRRRLRRDDRRLRRURRRLRRDURRLRRURRRLRRDURRLRRURRRLRRDURRLRRURRRLRRDURRLRRURRRLRRDURRLBFUFFFFFFFFFFFRRURRRLRRDURRLRRURRRLRRDURRLRRURRRLRRDURRLRLUDLLLRLULLLURRURRRLRRDURRLRRURRRLRRDURRLRRURRRLRRDURRU BFFFFFFFFFFFFFBFFFFFFFFFFFFFBFFFFFFFFFFFFFBFFFFFFFFFFFFFBFFFFFFFFFFFFFBFFFFFFFFFFFFFRLLDLLLRLULLLUBFFFFFFFFFFFFFBFFFFFFFFFFFFFBFFFFFFFFFFFFFBBBBBBBBBBBBBBBFFFFFFFFFFFFFBFFFFFFFFFFFFFBFFFFFFFFFFFFF", + "token": "MHorNFjRQSapCRJsyxkCp2fASFeHIdsZ279IaKS-VnQD-fOwaA_oET4P6YqZ9XSyN-n6zNy6YjTPwbqEwNyVyrub2jAF_yA5zsD_8qoVw7Ygu6J2T9RKy0hIXrPoj3vhK8SqgxpIBzB6VMP1NxNA6Z7zYXSLvAtnDGIb7Bw4WMGRtTA-YIlE5_SiL9MmYv08ln_aLn8IBoBQ79c0Q_MmeYiHxpWxtfawh55oA3AjgaYNr8NaU_M4gREAjyci0jV9ayDO62SsaGAv6hHkOn2LU3vvt6YVfWemLsiVaHBcGqnafc0IaAXKQZZeM7XcF3ik3KU4rNZP0bCbx5ZXh9S5DuRQODxC6Bj9HgPMHbtBYvEwBfHFgyGr0uD7R7FJORpWxxsdNomys", + "canonical": "" + }, + { + "id": 46, + "moves": "14B' 12L' 2D2 3L 4D' 1B 9L2 8D' 10L2 y", + "facelets": "LUUUUUUUUUUUURLUUUUUUUUUUUURBBBBBBBBBBBBDRLUUUUUUUUUUUURLUUUUUUUUUUUURLUUUUUUUUUUUURLUUUUUUUUUUUURLUUUUUUUUUUUURLDDDDDDDDDDDDRLDDDDDDDDDDDDRLUUUUUUUUUUUUBFFFFFFFFFFFFFRLUUUUUUUUUUUUDLUUUUUUUUUUUUR BFBLFFBBBBBBBBBFBLBBBBBBBBBBUFULFFUUUUUUULBFBLRRBBBBBBBBBFBLFFBBBBBBBBBFBLFFBBBBBBBBULLLFLLLLLLLLDBFBLRFBBBBBBBBBFBLFFBBBBBBBBBFBLFFBBBBBBBBBFBLFFBBBBBBBBRDDLFFDDDDDDDDBFBLFFBBBBBBBBBFBDFFBBBBBBBB URRRRRRRRRRRRDURRRRRRRRRRRRDURRRRRRRRRRRRBURRRRRRRRRRRRDURRRRRRRRRRRRDURRRRRRRRRRRRDBFBLBFBBBBBBBBURRRRRRRRRRRRDURRRRRRRRRRRRDURRRRRRRRRRRRDBBUBBBBBBBBDBDURRRRRRRRRRRRFLLLLLLLLLLLLLDURRRRRRRRRRRRD RDDDDDDDDDDDDLRDDDDDDDDDDDDUBBBBBBBBBBBBBLRDDDDDDDDDDDDFRUUUUUUUUUUUULRUUUUUUUUUUUULRDDDDDDDDDDDDLRDDDDDDDDDDDDLRDDDDDDDDDDDDLRDDDDDDDDDDDDLRDDDDDDDDDDDDLFFFFFFFFFFFFULRDDDDDDDDDDDDLRDDDDDDDDDDDDL FFUFFFFFBBFRFFFFUFFFFFBBFDFFFFUFFFFFDDFDFFFFUFFFFFBBFDFFFFUFFFFFBBFDFFFFUFFFFFBBFDFFURRRRRRRRBRRRDFFUFFFFFBLFDFFFFUFFFFFBBFDFFFFUFFFFFBBFDFFURRRRRRRBBRRRRFFUFFFFFUUFDFFBBUBBBBBBBBBBBFFLFFFFFBBFDFF ULLLLLLLLLLLLDULLLLLLLLLLLLDFLLLLLLLLLLLLDULLLLLLLLLLLLDULLLLLLLLLLLLDULLLLLLLLLLLLDFFUFFFFFBFFDFFULLLLLLLLLLLLDULLLLLLLLLLLLDULLLLLLLLLLLLDUFUFFFFFFFFDFFBLLLLLLLLLLLLDURRRRRRRRRRRRRULLLLLLLLLLLLD", + "token": "bA2gDzGaigXODDY8jmJyT3gs1fRLvlK2fl3SFaYCuvgT5a2gOKg6lhqhcc8jTN1L6gIYTOtzufV1VFIQIuT_7dfMANqtscQhOpEOPfh5rrcpXrLbuNXDsMhkMKSJED2WwmoZzKg24cz0IsffwjidSkm7gezRdLZzHGD9W_Pzz6K7SOO9-HvWwCTBJl5NrBCWve7kxbAtyXEBBe8A-KBKm2ULA0lvGUPufZBX4mrTVHO0BWbAzAoFJ6KcMrooLTojWVc0mYBXFk-VJd5dCfcooAbtF3U4SPdBFtJdf9d5eqvQ9vF_SFgRs1KMONfgQE1J-VQCBYluhCMabQFhMP68VNWGdV5NT76CsOyCwvHd3dl5C0tyAwDiT-gVhdA-ubQTrcgJx_yL", + "canonical": "UUBUUUUFUUUFUULRLFLLLFLLLLLLLRLULLLULLLLLLLRLFLLLFLLLLLLLRLFLLLFLLLLLLLRLFLLLFLLLLLLLRLFLLLFLLLLLLLRLFLLLFLLLLLLLRLFLLLBLLLLLLLRLFLLLFLLLLLLLRLFLLLFLLLLLLLRLDLLLDLLLLLLLRLFLLLFLLLLLLDRDFDDDFDDDDDD LUUUUUUUUUUUURLUUUUUUUUUUUURBBBBBBBBBBBBDRLUUUUUUUUUUUURLUUUUUUUUUUUURLUUUUUUUUUUUURLUUUUUUUUUUUURLUUUUUUUUUUUURLDDDDDDDDDDDDRLDDDDDDDDDDDDRLUUUUUUUUUUUUBFFFFFFFFFFFFFRLUUUUUUUUUUUUDLUUUUUUUUUUUUR FBFUFFFUFFFFFFFBFRFFFRFFFFFFLUURUUURUUUUUUFBFRFFFRFFFFFFFBFRFFFRFFFFFFFBFRFFFRFFFFFFFBFRFFFRFFFFFFFBFRFFFRFFFFFFBBUBBBBRBBBDBBBBUBBBLBBBBDBBFBFRFFFRFFFFFFDBDRDDDRDDDDDRFBFRFFFRFFFFFFFBFRFFFDFFFFFF ULUBUUUBUUUUUURLRBRRRFRRRRRRRLRURRRBRRRRRRRLRBRRRLRRRRRRRLRBRRRBRRRRRRRLRBRRRFRRRRRRRLRBRRRBRRRRRRRLRBRRRBRRRRRRRLRBRRRBRRRRRRRLRBRRRBRRRRRRRLRBRRRBRRRRRRRLRDRRRBRRRRRRRLRBRRRBRRRRRRDDFDDDDBDDDBDD LDDDDDDDDDDDDRLDDDDDDDDDDDDRLUFFFFFFFFFFFFLDDDDDDDDDDDDRLDDDDDDDDDDDDRLDDDDDDDDDDDDRLDDDDDDDDDDDDRLDDDDDDDDDDDDRLUUUUUUUUUUUURLUUUUUUUUUUUURFDDDDDDDDDDDDRLBBBBBBBBBBBBBUDDDDDDDDDDDDRLDDDDDDDDDDDDR BBLBBBDBBBBDBBBBUBBBLBBBBDBBBBUBBBLBBBBDBBBBUBBBLBBBBDBBBBUBBBLBBBBDBBBBUBBBLBBBBDBBBBUBBBLBBBBDBBBBUBBBLBBBBDBBFBFRFFLFFFFFFFFBFRFFFRFFFFFFLLLLLLLLLLLLLDBBUBBBLBBBBDBBFFFFFFLFFFFDFFBBUBBBUBBBBRBB" + }, + { + "id": 47, + "moves": "14B' 12L' 2D2 3L 4D' 1B 9L2 8D' 10L2 y", + "facelets": "LUUUUUUUUUUUURLUUUUUUUUUUUURBBBBBBBBBBBBDRLUUUUUUUUUUUURLUUUUUUUUUUUURLUUUUUUUUUUUURLUUUUUUUUUUUURLUUUUUUUUUUUURLDDDDDDDDDDDDRLDDDDDDDDDDDDRLUUUUUUUUUUUUBFFFFFFFFFFFFFRLUUUUUUUUUUUUDLUUUUUUUUUUUUR BFBLFFBBBBBBBBBFBLBBBBBBBBBBUFULFFUUUUUUULBFBLRRBBBBBBBBBFBLFFBBBBBBBBBFBLFFBBBBBBBBULLLFLLLLLLLLDBFBLRFBBBBBBBBBFBLFFBBBBBBBBBFBLFFBBBBBBBBBFBLFFBBBBBBBBRDDLFFDDDDDDDDBFBLFFBBBBBBBBBFBDFFBBBBBBBB URRRRRRRRRRRRDURRRRRRRRRRRRDURRRRRRRRRRRRBURRRRRRRRRRRRDURRRRRRRRRRRRDURRRRRRRRRRRRDBFBLBFBBBBBBBBURRRRRRRRRRRRDURRRRRRRRRRRRDURRRRRRRRRRRRDBBUBBBBBBBBDBDURRRRRRRRRRRRFLLLLLLLLLLLLLDURRRRRRRRRRRRD RDDDDDDDDDDDDLRDDDDDDDDDDDDUBBBBBBBBBBBBBLRDDDDDDDDDDDDFRUUUUUUUUUUUULRUUUUUUUUUUUULRDDDDDDDDDDDDLRDDDDDDDDDDDDLRDDDDDDDDDDDDLRDDDDDDDDDDDDLRDDDDDDDDDDDDLFFFFFFFFFFFFULRDDDDDDDDDDDDLRDDDDDDDDDDDDL FFUFFFFFBBFRFFFFUFFFFFBBFDFFFFUFFFFFDDFDFFFFUFFFFFBBFDFFFFUFFFFFBBFDFFFFUFFFFFBBFDFFURRRRRRRRBRRRDFFUFFFFFBLFDFFFFUFFFFFBBFDFFFFUFFFFFBBFDFFURRRRRRRBBRRRRFFUFFFFFUUFDFFBBUBBBBBBBBBBBFFLFFFFFBBFDFF ULLLLLLLLLLLLDULLLLLLLLLLLLDFLLLLLLLLLLLLDULLLLLLLLLLLLDULLLLLLLLLLLLDULLLLLLLLLLLLDFFUFFFFFBFFDFFULLLLLLLLLLLLDULLLLLLLLLLLLDULLLLLLLLLLLLDUFUFFFFFFFFDFFBLLLLLLLLLLLLDURRRRRRRRRRRRRULLLLLLLLLLLLD", + "token": "LLEajLqb4I9e09ALTgKhv4hijrnUeqKC9du5KwMZxxsnFKTiylH6vz9-hp1pHL4c-ch0Y037yVORU0N3-QaUBV2SJZFESWnCGQyzBhxR_yJj-Bb5nNg4afdSS9vgpLGl_GxLetNygMpLV63Ur_NNTOOdZil0OP4xcQO25ctSizVXIskAKGVFbm6Fit3RroqP8sJfnhsOW_q9FLcpzr5XeILwzfcq7MZ6PYmUv2KM3P4huhJlIg-pgoiKy5m9xqFfSj74CjnAezXcghVhtTX_Fnb00pOb_qGXqJpVl5FkS2QMImZQ_IS_QnhIB_98xrRJXS9txswmGkl4KPp1-HcyYy0Ug5NitdklOrx6ox9CbJbg5by43Op5lgmw6CjUzQY5n0l9MY4d9", + "canonical": "" + }, + { + "id": 50, + "moves": "", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "" + }, + { + "id": 51, + "moves": "", + "facelets": "UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB", + "token": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + "canonical": "" + }, + { + "id": 50, + "moves": "2U2 1U 14U' 15B2 10U' 4R' 9B 6F' 8F 4U", + "facelets": "UUUUUUUUUUUBUUUUUUUUUUUUUURUUUUUUUUUUUUUUBUUUUUUUUUUUUUUBUUUUUUUUUUUUUUBUUUUUUUUUUUUUURUUUUUUUUUUUUUUBUUULBLLLBLLLLLLLRFBLRRRRRRRFRRRFRBLRRRRRRRFRRRFRUUUUUUUUUUUBUUUUUUUUUUUUUUBUUUUUUUUUUUUUUBUUUUUUUUUUUUUUFUUUDDDDDDDDDDDLDDD LBBBBDDUBBBBBBBBLLLLDDULLLLLLLLRRRRDDURRRRRRRBBBDBBBBBBBBBBBLRRRRDDURRRRRRRLRRRRDDURRRRRRRLRRRRDDURRRRRRRLRRRRDDURRRRRRRLRRRRDDURRRRRRRFFFFFDDUFFFFFFFLRRRRDDURRRRRRRLRRRRDDBRRRRRRRLRRRRDDURRRRRRRRFFFFDDUFFFFFFFFRRRRDDURRRRRRR FFFFFFFFFFFUFFFLLLLLLLLLLLULLLFFFFFFFFFFFUFFFLRRRRFFURRRRRRRFFFFFFFFFFFUFFFFFFFFFFFFFFUFFFFFFFFFFFFFFUFFFFFFFFFFFFFFUFFFFFFFFFFFFFFUFFFLLLLLLLLLLLULLRFFFFFFFFFFFUFFFFFFFFFFFFFFUFFFFFFFFFFFFFFUFFFBBBBBBBBBBBUBBBRRRRRRRRRRRDRRR UUUUUUUUUUUFUUUDDDDDDDDDDDLDDDDDDDDDDDDDDFDDDDDDDDDDDDDDFDDDDDDDDDDDDDDFDDDFRLLLLLLLBLLLBLFRLLLLLLLBLLLBLRFRRRFRRRRRRRLBDDDDDDDDDDDFDDDDDDDDDDDDDDLDDDDDDDDDDDDDDFDDDDDDDDDDDDDDFDDDDDDDDDDDDDDFDDDDDDDDDDDDDDBDDDDDDDDDDDDDDRDDD FFFFFFFDUUFFFFRRRRRRRRDUURRRRFLLLLLLLDUULLLLRFFFFFFFFFFFUFFFLLLLLLLDUULLLLRLLLLLLLDUULLLLRLLLLLLLDUULLLLRLLLLLLLDUULLLLRLLLLLLLDUULLLLRBBBBBBBDUUBBBBBLLLLLLLDUULLLLRLLLLLLLFUULLLLRLLLLLLLDUULLLLRBBBBBBBDUUBBBBLLLLLLLLDUULLLLB LLLDLLLLLLLLLLLFFFDFFFFFFFFFFFBBBDBBBBBBBBBBBLLLLLLLDBBLLLLRBBBDBBBBBBBBBBBBBBDBBBBBBBBBBBBBBDBBBBBBBBBBBBBBDBBBBBBBBBBBBBBDBBBBBBBBBBBLRRDRRRRRRRRRRRBBBDBBBBBBBBBBBBBBDBBBBBBBBBBBBBBDBBBBBBBBBBBRRRDRRRRRRRRRRRBBBUBBBBBBBBBBB", + "token": "A83T0oefGCJnWOVoQXCQN5VxnIRaAzld1udUVmdmF9bmhGUiKkHzntHaic4unl7jXfsIEkJJwet_OAFgM6iJW5hj7Zvne7_aFVVdhVWGYjMdU02ERjhiytzYk_L2yjmXIPMd7Cw7zzbE1DaDvecRktuF3OHfBdFQAmczUPyXQQiY3FBMzwt0KalahsIO3tw7EL4Biw9bVUg2mAXsv1QmzaxhFxELZyfHoR_stC8MoXuLDSUX17jGLHt77PxdcuQTYFDyXv2LooIoPfaLDmRjuT2bL6_wb2YNPiqHLkBxN5TKcUof-HRba-SNt1aTmiGB-a1uDkFcAEOjnDMtBrQR-iaNdt0GGejNc3KpFB3ddR6MXSQ9SJkxoeWkqbRndOg7RzEkdSSE4PznAGs1z0VIJiLPv4b2sOCIaK734ryLP0KXEA_B9-1J21Ts_N4sTHCDOf2", + "canonical": "BLRBRRRRRFRRRFRBLRBRRRRRFRRRFRBLRBRRRRRFRRRFRBLRBRRRRRFRRRFRBLRBRRRRRFRRRFRBLRBRRRRRFRRRFRBLRBRRRRRFRRRFRUUUBUUUUUUUBUUUDDDBDDDDDDDDDDDDDDBDDDDDDDDDDDBLRBRRRRRFRRRFRBLRDRRRRRFRRRFRBLRBRRRRRFRRRFRBLRBRRRRRFRRRFRLBLBLLLLLFLLLRF UDDDDLLBDDDDDDDUDDDDBBLDDDDDDDUDDDDLLRDDDDDDDFLFFFLLRFLFFFBRUDDDDLLRDDDDDDDUDDDDBBRDDDDDDDUDDDDLLRDDDDDDDUDDDDLLRDDDDDDDUDDDDLLRDDDDDDDUDDDDLLFDDDDDDDUDDDDLLRDDDDDDDUDDDDLLRDDDDDDDUDDDDLLRDDDDDDDUDDDDRRFDDDDDDDUDDDDFFRDDDDDDD FLFRFFFFFRFFFBRFLFRFFFFFLFFFBRFLFRFFFFFLFFFBRUUURUUUUUUUUUUDFLFRFFFFFLFFFBRFLFRFFFFFLFFFBRFLFRFFFFFLFFFBRFLFUFFFFFLFFFBRFLFFFFFFFLFFFBRFLFFFFFFFLFFFBRFLFRFFFFFLFFFBRFLFRFFFFFLFFFBRFLFRFFFFFLFFFBRFLFRFFFFFLFFFBRFLFLFFFFFLFFFBR RFRFRRRRRBRRRLBFRLFLLLLLBLLLBLFRLFLLLLLBLLLBLFRLULLLLLBLLLBLFRLFLLLLLBLLLBLUUUFUUUUUUUUUUUUUUFUUUUUUUUUUUDDDFDDDDDDDFDDDFRLFLLLLLBLLLBLFRLFLLLLLBLLLBLFRLFLLLLLBLLLBLFRLFLLLLLBLLLBLFRLFLLLLLBLLLBLFRLFLLLLLBLLLBLFRLFLLLLLBLLLBL UUUUUUUFRRUUUUDUUUUUUURFFUUUUDUUUUUUULRRUUUUDBRBBBRBLRRBBBFLUUUUUUULRRUUUUDUUUUUUULFFUUUUDUUUUUUULRRUUUUDUUUUUUULRRUUUUDUUUUUUULRRUUUUDUUUUUUUBRRUUUUDUUUUUUULRRUUUUDUUUUUUULRRUUUUDUUUUUUULRRUUUUDUUUUUUUBLLUUUUDUUUUUUULBBUUUUD BRBBBLBBBBBLBFLBRBBBRBBBBBLBFLBRBBBRBBBBBLBFLUDDDDDDDDDDLDDDBRBBBRBBBBBLBFLBRBBBRBBBBBLBFLBRBBBRBBBBBLBFLBRBBBRBBBBBDBFLBRBBBRBBBBBBBFLBRBBBRBBBBBBBFLBRBBBRBBBBBLBFLBRBBBRBBBBBLBFLBRBBBRBBBBBLBFLBRBBBRBBBBBLBFLBRBBBRBBBBBRBFL" + }, + { + "id": 51, + "moves": "2U2 1U 14U' 15B2 10U' 4R' 9B 6F' 8F 4U", + "facelets": "UUUUUUUUUUUBUUUUUUUUUUUUUURUUUUUUUUUUUUUUBUUUUUUUUUUUUUUBUUUUUUUUUUUUUUBUUUUUUUUUUUUUURUUUUUUUUUUUUUUBUUULBLLLBLLLLLLLRFBLRRRRRRRFRRRFRBLRRRRRRRFRRRFRUUUUUUUUUUUBUUUUUUUUUUUUUUBUUUUUUUUUUUUUUBUUUUUUUUUUUUUUFUUUDDDDDDDDDDDLDDD LBBBBDDUBBBBBBBBLLLLDDULLLLLLLLRRRRDDURRRRRRRBBBDBBBBBBBBBBBLRRRRDDURRRRRRRLRRRRDDURRRRRRRLRRRRDDURRRRRRRLRRRRDDURRRRRRRLRRRRDDURRRRRRRFFFFFDDUFFFFFFFLRRRRDDURRRRRRRLRRRRDDBRRRRRRRLRRRRDDURRRRRRRRFFFFDDUFFFFFFFFRRRRDDURRRRRRR FFFFFFFFFFFUFFFLLLLLLLLLLLULLLFFFFFFFFFFFUFFFLRRRRFFURRRRRRRFFFFFFFFFFFUFFFFFFFFFFFFFFUFFFFFFFFFFFFFFUFFFFFFFFFFFFFFUFFFFFFFFFFFFFFUFFFLLLLLLLLLLLULLRFFFFFFFFFFFUFFFFFFFFFFFFFFUFFFFFFFFFFFFFFUFFFBBBBBBBBBBBUBBBRRRRRRRRRRRDRRR UUUUUUUUUUUFUUUDDDDDDDDDDDLDDDDDDDDDDDDDDFDDDDDDDDDDDDDDFDDDDDDDDDDDDDDFDDDFRLLLLLLLBLLLBLFRLLLLLLLBLLLBLRFRRRFRRRRRRRLBDDDDDDDDDDDFDDDDDDDDDDDDDDLDDDDDDDDDDDDDDFDDDDDDDDDDDDDDFDDDDDDDDDDDDDDFDDDDDDDDDDDDDDBDDDDDDDDDDDDDDRDDD FFFFFFFDUUFFFFRRRRRRRRDUURRRRFLLLLLLLDUULLLLRFFFFFFFFFFFUFFFLLLLLLLDUULLLLRLLLLLLLDUULLLLRLLLLLLLDUULLLLRLLLLLLLDUULLLLRLLLLLLLDUULLLLRBBBBBBBDUUBBBBBLLLLLLLDUULLLLRLLLLLLLFUULLLLRLLLLLLLDUULLLLRBBBBBBBDUUBBBBLLLLLLLLDUULLLLB LLLDLLLLLLLLLLLFFFDFFFFFFFFFFFBBBDBBBBBBBBBBBLLLLLLLDBBLLLLRBBBDBBBBBBBBBBBBBBDBBBBBBBBBBBBBBDBBBBBBBBBBBBBBDBBBBBBBBBBBBBBDBBBBBBBBBBBLRRDRRRRRRRRRRRBBBDBBBBBBBBBBBBBBDBBBBBBBBBBBBBBDBBBBBBBBBBBRRRDRRRRRRRRRRRBBBUBBBBBBBBBBB", + "token": "AW0vbvLbqQzmwVYHGIo2FNgKmrGhwTWDMJa_oGbGSPCWcaXsz9i7W46x861Re2OVQz4jBtjbqLhPtQCEE18zglkleRp2zmfxyAADEgASZNMq_z0RmlUlDBLRN3sci9WYrFsrOJCWbbSJz5RxZzamlxJSMtSzoi5-AOazPl64uGM5Up4czaRLj5-B8ojFk5KWJkdAlCXCP_sUeQI4x7-OjSCkaKZkRq7q3Gv4w5GkvI5UJO3o8OVKUK5OeN6jCxWHRB5a458UXPDPFzx0JWWlZXcaMeH6KcZE90_ysVgqdNfL6nvL_SuiSHW1JMB3WcyQvaEJRViCgBldWpMw4oOGvc51DJLiSbdNC0r_Z4szC-t0ou2W-zlynLYdv6Omy9cWOrJtq-2x1F7WoCg0Lbn7Dk0N59KcglQzJ0Gc9Qa0N7j4pgXovPj7sj_Y3tNQnKoxNb8g", + "canonical": "" + }, + { + "id": 50, + "moves": "9L' 2R 4L2 11F' 7D' 11B 10L' 13B 4B2 11B2", + "facelets": "UUUDUUUUFFUUUFUUUUDUUUUFFUUUFUUUUDUUUUFFUUUFUDBDDDBBDDDDUDDDRRRRRRRRRFRRRRRUUUDUUUUFFUUUFUUUUDUUUUFFUUUFUUUUDUUUUFFUUUFUUUUDUUUUFRUUUFUUUUDUUUUFFUUUFULLLLLBFLLLLLLLLUUUDUUUUFFUUUFURRRRRRRRBRRRRRRUUUDUUUUFFUUUFUUUUDUUUUFFUUUFU RRDRURRRRRDLRRRRRBRURRRRRBLRRRRRDRURRRRRDLRRRRRDRDRRRRRDLRRRRRDRURRRRRDLRRRRRBRURRRRRDLRRRRRBRURRRRRBBRRRRRDRURRRRRDLRRRBUDBFBUBBBBLBBBRRDRURRRRRDLRRRRRDRURRRRRDLRRRRRURURRRRRULRRRRRDRURRRRRDLRRRRRDRFRRRRRDLRRRRRDRURRRRRDLRRR FFFBFFFFDDFFFDFFFFBFFFFDDFFFDFFFFBFFFFDDFFFDFFFFBFFFFDDFFFDFFFFBFFFFDLFFFDFFFFBFFFFDDFFFDFFFFBFFFFDDFFFDFFFFBFFFFDDFFFDFRRRRRRRRRDDRRRRFFFBFFFFDDFFFDFFFFBFFFFDLFFFDFFFFBFFFFDDFFFDFFFFBFFFFDDFFFDFFFFBFFFFDDFFFDFFFFBFFFFDDFFFDF DDDUDDDDBBDDDBDDDDUDDDDBBDDDBDLLLLLLLLFLLLLLLDDDUDDDDBBDDDBDRRRRRFBRRRRRRRRDDDUDDDDBBDDDBDDDDUDDDDBLDDDBDDDDUDDDDBBDDDBDDDDUDDDDBBDDDBDDDDUDDDDBBDDDBDLLLLLLLLLBLLLLLUFUUUFFUUUUDUUUDDDUDDDDBBDDDBDDDDUDDDDBBDDDBDDDDUDDDDBBDDDBD LLLRULLLLLDLULLLLLRFLLLLLDLFLLLLLRULLLLLDLULLLLLRULLLLLULULLLLLRULLLLLDLULLLLLRULLLLLDLFLLLLLFFLLLLLDLFLLLLLRULLLLLDLULLFFFRFFFFDFBFUDFLLLRULLLLLDLULLLLLRULLLLLDLULLLLLRDLLLLLDLDLLLLLRULLLLLDLULLLLLRULLLLLBLULLLLLRULLLLLDLULL BUBBBUUBBBBFBBBBUBBBUUBBBBFBBBBUBBBUUBBBBFBBBBUBBBUUBBBBFBBBBUBBBRUBBBBFBBBBUBBBUUBBBBFBBBBUBBBUUBBBBFBBBBUBBBUUBBBBFBBBLLLLUULLLLLLLLLBUBBBUUBBBBFBBBBUBBBRUBBBBFBBBBUBBBUUBBBBFBBBBUBBBUUBBBBFBBBBUBBBUUBBBBFBBBBUBBBUUBBBBFBBB", + "token": "AAAAAAAAAAAAACuZUwnTkfUqOu2tdecG84kIVXIiouBWgGDpEycpJJdQPhysM03V6lRjXVSjm62CgJq-OIE52kWwjWeqXpudanFg9QCF0RzDhsmpzHuHQ28_Pfpaze1yKnesYjDwPllUjoZA_laGkH6-p9MFJJEcsRhpCyjq6nGtoFxmhqAO8-r9tOot73cE1uErr2qZVibEp7VUKGFlgd9oJtFHYMWB3NtGoMvsROvHgIZ_AIm0KYVWUtq5iVU4DNCUZp9NlKA9z1_JOiLc088g1S46gYR5NJlO0-P9my9dHC_LYh0fJRkCPeHM43gPY5msjKklEbRC0L8dU6eOztipx6FRuSMmRLx0CNzP1djvV4AIWtwSTN4Z9-oMWOQec3cmdMBehwnePCFjasgBn1_IU3y6m3-INxgJkBiBIB5iHLuAFdf_uCp6ZwULV-5peE-", + "canonical": "" + }, + { + "id": 51, + "moves": "9L' 2R 4L2 11F' 7D' 11B 10L' 13B 4B2 11B2", + "facelets": "UUUDUUUUFFUUUFUUUUDUUUUFFUUUFUUUUDUUUUFFUUUFUDBDDDBBDDDDUDDDRRRRRRRRRFRRRRRUUUDUUUUFFUUUFUUUUDUUUUFFUUUFUUUUDUUUUFFUUUFUUUUDUUUUFRUUUFUUUUDUUUUFFUUUFULLLLLBFLLLLLLLLUUUDUUUUFFUUUFURRRRRRRRBRRRRRRUUUDUUUUFFUUUFUUUUDUUUUFFUUUFU RRDRURRRRRDLRRRRRBRURRRRRBLRRRRRDRURRRRRDLRRRRRDRDRRRRRDLRRRRRDRURRRRRDLRRRRRBRURRRRRDLRRRRRBRURRRRRBBRRRRRDRURRRRRDLRRRBUDBFBUBBBBLBBBRRDRURRRRRDLRRRRRDRURRRRRDLRRRRRURURRRRRULRRRRRDRURRRRRDLRRRRRDRFRRRRRDLRRRRRDRURRRRRDLRRR FFFBFFFFDDFFFDFFFFBFFFFDDFFFDFFFFBFFFFDDFFFDFFFFBFFFFDDFFFDFFFFBFFFFDLFFFDFFFFBFFFFDDFFFDFFFFBFFFFDDFFFDFFFFBFFFFDDFFFDFRRRRRRRRRDDRRRRFFFBFFFFDDFFFDFFFFBFFFFDLFFFDFFFFBFFFFDDFFFDFFFFBFFFFDDFFFDFFFFBFFFFDDFFFDFFFFBFFFFDDFFFDF DDDUDDDDBBDDDBDDDDUDDDDBBDDDBDLLLLLLLLFLLLLLLDDDUDDDDBBDDDBDRRRRRFBRRRRRRRRDDDUDDDDBBDDDBDDDDUDDDDBLDDDBDDDDUDDDDBBDDDBDDDDUDDDDBBDDDBDDDDUDDDDBBDDDBDLLLLLLLLLBLLLLLUFUUUFFUUUUDUUUDDDUDDDDBBDDDBDDDDUDDDDBBDDDBDDDDUDDDDBBDDDBD LLLRULLLLLDLULLLLLRFLLLLLDLFLLLLLRULLLLLDLULLLLLRULLLLLULULLLLLRULLLLLDLULLLLLRULLLLLDLFLLLLLFFLLLLLDLFLLLLLRULLLLLDLULLFFFRFFFFDFBFUDFLLLRULLLLLDLULLLLLRULLLLLDLULLLLLRDLLLLLDLDLLLLLRULLLLLDLULLLLLRULLLLLBLULLLLLRULLLLLDLULL BUBBBUUBBBBFBBBBUBBBUUBBBBFBBBBUBBBUUBBBBFBBBBUBBBUUBBBBFBBBBUBBBRUBBBBFBBBBUBBBUUBBBBFBBBBUBBBUUBBBBFBBBBUBBBUUBBBBFBBBLLLLUULLLLLLLLLBUBBBUUBBBBFBBBBUBBBRUBBBBFBBBBUBBBUUBBBBFBBBBUBBBUUBBBBFBBBBUBBBUUBBBBFBBBBUBBBUUBBBBFBBB", + "token": "AAAAAAAAAAAAABBZfyOvVrvv1hkhDDaim1NjIArM_RQgcCRXZy6vbbi-F0rAkz0wN9-lQv-9WmEQ8DoHVTB1sdoiNQbf43pbB-qEW-AyLmrJUoufrK5SuUm3tz3iDTkKz-zgpNJaF2F_tXJYX2Bydi-Hfu8h7bZqwmknZC9YF-qhHCKmcnwFm3gfI9fROcyh0JRwYcf5gE6JvuP_jySGELPHDo56xEoQstI6fEx4mdhq0DJvoDOjj5IAXxIFk3_1BM43pnu9F7wXLcPrdc0Sz22sT_FV8JGtc7l9j3V_GjHC6pHsRMrrrelg1zSs1U0FxVmgtL9t5qOZDkeq_17VjZE_qtx-pW0uWcarg1LN8DFZwNADIhKG3NNJvPfEoVWLa0yua8gjcqOzVoyFSAsAm8PrH07F-k_TFKkDlgkwbAtkysZQCDD_5Q_t5qHkQPlnjR3Q", + "canonical": "" + }, + { + "id": 50, + "moves": "2B z 12D 12L2 10R2 14B 2L 8U y 15D'", + "facelets": "LLLRLLLLLRLLLBLUUUUUUUUUUUFUBULLLRLLLLLRLLLBLLLLRLLLLLRLLLRLLLLRLLLLLRLLLBLLLLRLLLLLRLLLBLLLLRLLLLLRLLLBLLLLRLLLLLRLLLBLLLLRLLLLLRLLLBLLLLRLLLLLRLLLBLLLLRLLLLLRLLLBLLLLRLLLLLRLLLBLLLLRLLLLLRLLLBLUUURUUUUURUUUBULLLRLLLLLRLLLBL DLDDDDDDDDDDDLDBBBFBBBBBFBBBDBBBBFBBBBBFBBBRBUUUFUUUUUFUUURUBBBFBBBBBFBBBRBBBBFBBBBBFBBBRBBBBFBBBBBFBBBRBDLDDDDDDDDDDDLDBBBFBBBBBFBBBRBBBBFBBBBBFBBBRBBBBFBBBBBFBBBRBBBBDBBBBBDBBBRBBBBFBBBBBFBBBRBBBBFBBBBBFBBBDBBBBFBBBBBFBBBRB BBBFBBBBBFBBBRBURUUUUUUUUUUURUURUUUUUUUUUUURUFUFFFFFFFFFFFFFURUUUUUUUUUUURUURUUUUUUUUUUURUURUUUUUUUUUUURUBBBFBBBBBFBBBRBURUUUUUUUUUUURUUUUUUUUUUUUUURUURUUUUUUUUUUURUURUUUUUUUUUUURUURUUUUUUUUUUURUURUUUUUUUUUUURUURUUUUUUUUUUURU RDRRRRRRRRRRRDRRDRRRRRRRRRRRDRRDRRRRRRRRRRRDRLDLLLLLLLLLLLLLRDRRRRRRRRRRRDRRDRRRRRRRRRRRDRRDRRRRRRRRRRRDRRDRRRRRRRRRRRDRRDRRRRRRRRRRRDRLDLLLLLLLLLLLLLRDRRRRRRRRRRRDRRBRRRRRRRRRRRDRRDRRRRRRRRRRRDRFFFLFFFFFFFFFFFRDRRRRRRRRRRRDR URUUUUUUUUUUURUFUFFFBFFFFFBFFFFLFFFBFFFFFBFFFDLDDDBDDDDDBDDDFLFFFBFFFFFBFFFFLFFFBFFFFFBFFFFLFFFBFFFFFBFFFURUUUUUUUUUUURUFLFFFBFFFFFBFFFFLFFFBFFFFFBFFFFLFFFBFFFFFBFFFFLFFFUFFFFFUFFFFLFFFBFFFFFBFFFFUFFFBFFFFFBFFFFLFFFBFFFFFBFFF FLFFFBFFFFFBFFFDLDDDDDDDDDDDLDDLDDDDDDDDDDDLDBBBBBBBBBBBBBDBDLDDDDDDDDDDDLDDLDDDDDDDDDDDLDDLDDDDDDDDDDDLDFLFFFBFFFFFBFFFDLDDDDDDDDDDDLDDLDDDDDDDDDDDDDDLDDDDDDDDDDDLDDLDDDDDDDDDDDLDDLDDDDDDDDDDDLDDLDDDDDDDDDDDLDDLDDDDDDDDDDDLD", + "token": "GcEe9ZJuQ6kdaoA01c-VJUJYXS857vbGC5shh7zBfoTks1zpvOwkk5iIZF3y9jFK-E440kR89kbFYA177UTKgajMn1UB_M0NGeXgRLX1lI4k_-Tc3CbkHi_aFGBW25hCION4XTvTtcUkidY126pOH64_dZoSL_ys4MHbnRrXbuXQ1iFqKxQhWnZur27X6cSEIPHYMPBeuJmPW3KfH15YFlflI73lzcnoF55gcnDRWfwGyZU-JHNO37wTsibsbAGvJTfwUk33cn9Af-bPp4tAhvKsKL6cCrAOFdSLMnpFFZ022kkaL5B_IkgXDFOKTPld1dUEVFCg7RHcNyQRscMk3ms77D6XpvzlASgAdd_fv0Y2PkHN6WaBuY7JesWgtobizit8Bgb6A9fvgejSVthpQG6zOgrbk0DhY8f7FfH3uJ8zjJHFK1CgZr6z_QcXIsxelJu", + "canonical": "UFFDFFFUFFFFFFFRFFDFFFRFFFFFFFUFFDFFFUFFFFFFFUBBBBBBUBBBUBBBUFFDFFFUFFFFFFFUFFDFFFUFFFFFFFUFFDFFFUFFFFFFFUFFDFFFUFFFFFFFUFFDFFFUFFFFFFFUBBBBBBUBBBUBBBUFFDFFFUFFFFFFFUFFDFFFUFFFFFFFUFFDFFFUFFFFFFFRULLLLLRLLLLLULUFFDFFFUFFFFFFF RFRRRLRRRRRLRRRDFDBDDDDDDDDDDDRFRRRLRRRRRLRRRRLRRRLRRRRRLRRRRFRRRLRRRRRLRRRRFRRRLRRRRRLRRRRFRRRLRRRRRLRRRRFRRRLRRRRRLRRRRFRRRLRRRRRLRRRRFRRRLRRRRRLRRRRFRRRLRRRRRLRRRRFRRRLRRRRRLRRRRFRRRLRRRRRLRRRDFDDDLDDDDDLDDDRFRRRLRRRRRLRRR FDDBDDDFDDDDDDDFLLDLLLFLDLLLLLFDDBDDDFDDDDDDDBDDBDDDBDDDDDDDFDDBDDDFDDDDDDDFDDBDDDFDDDDDDDFDDBDDDFDDDDDDDFDDBDDDFDDDDDDDFDDBDDDFDDDDDDDBDDBDDDBDDDDDDDFDDBDDDFDDDDDDDFDDBDDDFDDDDDDDFDDBDDDFDDDDDDDLLLBLLLLLLLLLLLFDDBDDDFDDDDDDD DBBUBBBDBBBBBBBLDRRRRRLRRRRRDRDBBUBBBDBBBBBBBDBBUBBBDBBBBBBBDBBUBBBDBBBBBBBDFFFFFFDFFFDFFFDBBUBBBDBBBBBBBDBBUBBBDBBBBBBBDBBUBBBDBBBBBBBDBBUBBBDBBBBBBBDBBUBBBDBBBBBBBDFFFFFFDFFFDFFFDBBUBBBDBBBBBBBLBBUBBBLBBBBBBBDBBUBBBDBBBBBBB LULLLLLLLLLLLULLULLLLLLLLLLLULLULLLLLLLLLLLULRRRRRRRRRRRRRURLULLLLLLLLLLLULLULLLLLLLLLLLULLULLLLLLLLLLLULLULLLLLLLLLLLULLULLLLLLLLLLLULRRRRRRRRRRRRRURLULLLLLLLLLLLULLULLLLLLLLLLLFLLULLLLLLLLLLLULBBBBBBBBBBBRBBBLULLLLLLLLLLLUL UUUUUUUBUUUFUUBRRRRRURBRRRURRBUUUUUUUBUUUFUUBUUUUUUUFUUUFUUFUUUUUUUBUUUFUUBUUUUUUUBUUUFUUBUUUUUUUBUUUFUUBUUUUUUUBUUUFUUBUUUUUUUBUUUFUUBUUUUUUUFUUUFUUFUUUUUUUBUUUFUUBUUUUUUUBUUUFUUBUUUUUUUBUUUFUUBRRRRRRRRRRRFRRRUUUUUUUBUUUFUUB" + }, + { + "id": 51, + "moves": "2B z 12D 12L2 10R2 14B 2L 8U y 15D'", + "facelets": "LLLRLLLLLRLLLBLUUUUUUUUUUUFUBULLLRLLLLLRLLLBLLLLRLLLLLRLLLRLLLLRLLLLLRLLLBLLLLRLLLLLRLLLBLLLLRLLLLLRLLLBLLLLRLLLLLRLLLBLLLLRLLLLLRLLLBLLLLRLLLLLRLLLBLLLLRLLLLLRLLLBLLLLRLLLLLRLLLBLLLLRLLLLLRLLLBLUUURUUUUURUUUBULLLRLLLLLRLLLBL DLDDDDDDDDDDDLDBBBFBBBBBFBBBDBBBBFBBBBBFBBBRBUUUFUUUUUFUUURUBBBFBBBBBFBBBRBBBBFBBBBBFBBBRBBBBFBBBBBFBBBRBDLDDDDDDDDDDDLDBBBFBBBBBFBBBRBBBBFBBBBBFBBBRBBBBFBBBBBFBBBRBBBBDBBBBBDBBBRBBBBFBBBBBFBBBRBBBBFBBBBBFBBBDBBBBFBBBBBFBBBRB BBBFBBBBBFBBBRBURUUUUUUUUUUURUURUUUUUUUUUUURUFUFFFFFFFFFFFFFURUUUUUUUUUUURUURUUUUUUUUUUURUURUUUUUUUUUUURUBBBFBBBBBFBBBRBURUUUUUUUUUUURUUUUUUUUUUUUUURUURUUUUUUUUUUURUURUUUUUUUUUUURUURUUUUUUUUUUURUURUUUUUUUUUUURUURUUUUUUUUUUURU RDRRRRRRRRRRRDRRDRRRRRRRRRRRDRRDRRRRRRRRRRRDRLDLLLLLLLLLLLLLRDRRRRRRRRRRRDRRDRRRRRRRRRRRDRRDRRRRRRRRRRRDRRDRRRRRRRRRRRDRRDRRRRRRRRRRRDRLDLLLLLLLLLLLLLRDRRRRRRRRRRRDRRBRRRRRRRRRRRDRRDRRRRRRRRRRRDRFFFLFFFFFFFFFFFRDRRRRRRRRRRRDR URUUUUUUUUUUURUFUFFFBFFFFFBFFFFLFFFBFFFFFBFFFDLDDDBDDDDDBDDDFLFFFBFFFFFBFFFFLFFFBFFFFFBFFFFLFFFBFFFFFBFFFURUUUUUUUUUUURUFLFFFBFFFFFBFFFFLFFFBFFFFFBFFFFLFFFBFFFFFBFFFFLFFFUFFFFFUFFFFLFFFBFFFFFBFFFFUFFFBFFFFFBFFFFLFFFBFFFFFBFFF FLFFFBFFFFFBFFFDLDDDDDDDDDDDLDDLDDDDDDDDDDDLDBBBBBBBBBBBBBDBDLDDDDDDDDDDDLDDLDDDDDDDDDDDLDDLDDDDDDDDDDDLDFLFFFBFFFFFBFFFDLDDDDDDDDDDDLDDLDDDDDDDDDDDDDDLDDDDDDDDDDDLDDLDDDDDDDDDDDLDDLDDDDDDDDDDDLDDLDDDDDDDDDDDLDDLDDDDDDDDDDDLD", + "token": "CahrnBbpWV9rB_AT0C3X7fjhIvG1uZyKRFoskubIj3HVw0LXptiNt1kzJaM7HFJ8HR1VTtmu3FqKBAUOePnL8J9Mu7_gvszk6bY0GcQ8F7VN3_XS0o6Vi1Hxx6QgklkYzFVNIvZvZCnts7BUMl_dS-FXzBnG0f7A1EiyWuoQyZYuUEyH0CeMgexpgcmQ96mxjFqxElojhTmVwkr7q8NhCGD17Wc2LSu3CNtkKupOgb6Ci5f3Tas9k-aHYs6YqIChrfT6Ht08yu-4L_aN3tQ4MpsAj0d6hAIFSC-0Mu3Z6Br0kdtp0dYvrNsIpJ9T3N2DMC_hn548WOaylK2Goqkt02g2eJd43p7V4G8ALDPz57pUV1itN4ZwpZWLjgocRHKVDVBOgkKdwXD50LdO4JEneCmDNcQSVzhUhWr-KDq85TuzVLap8D48JoeDfuKorQyjd7pi", + "canonical": "" + } + ] +} From 69f412aac21729cbeae4e101d99169fa4a12663b Mon Sep 17 00:00:00 2001 From: Werner Stein Date: Sun, 1 Nov 2026 13:11:17 +0000 Subject: [PATCH 03/10] test(orbit64): check the V2 facelet bridge Checks the slot tables against FORMAT-V2-SLOTS.md for n = 2..15, the 24 frames against their wire-order derivation, every fixture row in both directions, and invalid input with exact reasons: length, bad letters including tab and newline, color counts, wrong handedness of fixed centers, a twisted corner, a flipped midge, a doubled piece and a mirrored cube. Co-Authored-By: Claude Sonnet 5.5 --- test/cube/notation/orbit64V2Facelets.test.ts | 587 +++++++++++++++++++ 1 file changed, 587 insertions(+) create mode 100644 test/cube/notation/orbit64V2Facelets.test.ts diff --git a/test/cube/notation/orbit64V2Facelets.test.ts b/test/cube/notation/orbit64V2Facelets.test.ts new file mode 100644 index 0000000..a17e69a --- /dev/null +++ b/test/cube/notation/orbit64V2Facelets.test.ts @@ -0,0 +1,587 @@ +import { describe, expect, it } from 'vitest' +import { + decodeOrbit64V2State, + type Orbit64V2Cube, + type Orbit64V2Pose, + orbit64V2Entries, + orbit64V2Entry, + orbit64V2Solved, +} from '../../../src/cube/notation/orbit64V2' +import { + decodeOrbit64V2Facelets, + encodeOrbit64V2Facelets, + orbit64V2FrameFaces, + orbit64V2FromFacelets, + orbit64V2Slots, + orbit64V2ToFacelets, +} from '../../../src/cube/notation/orbit64V2Facelets' +import fixture from './orbit64V2Facelets.json' + +type Result = { TAG: 'Ok'; _0: T } | { TAG: 'Error'; _0: string } + +function ok(result: Result): T { + if (result.TAG === 'Error') throw new Error(result._0) + return result._0 +} + +const error = (result: Result): string => + result.TAG === 'Error' ? result._0 : 'accepted' + +const colorEntries = orbit64V2Entries.filter((e) => e.model === 'Color') +const letters = ['U', 'R', 'F', 'D', 'L', 'B'] + +function solvedFacelets(n: number): string { + return letters.map((c) => c.repeat(n * n)).join(' ') +} + +// The same string with the facelet at `index` (spaces not counted) replaced. +function withFacelet(text: string, index: number, letter: string): string { + const compact = text.replaceAll(' ', '').split('') + compact[index] = letter + const n = Math.sqrt(compact.length / 6) + return letters + .map((_, face) => compact.slice(face * n * n, (face + 1) * n * n).join('')) + .join(' ') +} + +describe('Orbit64 V2 slot tables', () => { + const slotText = (text: string): number[][] => + text === '' ? [] : text.split(' | ').map((s) => s.split(' ').map(Number)) + + it('has the 14 sizes of FORMAT-V2-SLOTS.md', () => { + expect(Object.keys(fixture.slots)).toEqual( + Array.from({ length: 14 }, (_, i) => String(i + 2)), + ) + }) + + it('equals the specification for n = 2..15', () => { + for (let n = 2; n <= 15; n++) { + const expected = fixture.slots[String(n) as keyof typeof fixture.slots] + const actual = orbit64V2Slots(n) + expect(actual, `${n}`).toBeDefined() + expect(actual?.corners, `${n} corners`).toEqual( + slotText(expected.corners), + ) + expect(actual?.midges, `${n} midges`).toEqual(slotText(expected.midges)) + const wings = Object.entries(expected.wings as Record) + expect(actual?.wings, `${n} wings`).toEqual( + wings.map(([, text]) => slotText(text)), + ) + expect( + wings.map(([depth]) => depth), + `${n} depths`, + ).toEqual(wings.map((_, i) => String(i + 1))) + // The document lists one center orbit per line, a facelet per slot. + expect(actual?.centers, `${n} centers`).toEqual( + slotText(expected.centers), + ) + } + }) + + it('assigns every facelet except the fixed centers to exactly one slot', () => { + for (let n = 2; n <= 15; n++) { + const slots = orbit64V2Slots(n) + if (slots === undefined) throw new Error(`${n}`) + const all = [ + ...slots.corners.flat(), + ...slots.midges.flat(), + ...slots.wings.flat(2), + ...slots.centers.flat(), + ...slots.fixed, + ].sort((a, b) => a - b) + expect(all, `${n}`).toEqual( + Array.from({ length: 6 * n * n }, (_, i) => i), + ) + expect(slots.fixed, `${n}`).toEqual( + n % 2 === 1 + ? letters.map((_, face) => face * n * n + (n * n - 1) / 2) + : [], + ) + } + }) + + it('has no tables for sizes outside 2..15', () => { + for (const n of [-1, 0, 1, 16, 2.5, Number.NaN, Number.POSITIVE_INFINITY]) { + expect(orbit64V2Slots(n), String(n)).toBeUndefined() + } + }) + + it('hands out copies', () => { + const first = orbit64V2Slots(5) + first?.corners[0].push(999) + first?.fixed.push(999) + expect(orbit64V2Slots(5)?.corners[0]).toEqual([24, 25, 54]) + expect(orbit64V2Slots(5)?.fixed).toHaveLength(6) + }) +}) + +describe('Orbit64 V2 frames', () => { + // FORMAT.md: x turns, then z turns, then y turns. A turn moves the contents + // of the slots: x (like R) carries F to U, z (like F) carries U to R and y + // (like U) carries R to F. + const turnX = (s: string[]) => [s[2], s[1], s[3], s[5], s[4], s[0]] + const turnZ = (s: string[]) => [s[4], s[0], s[2], s[1], s[3], s[5]] + const turnY = (s: string[]) => [s[0], s[5], s[1], s[3], s[2], s[4]] + const again = (f: (s: string[]) => string[], k: number, s: string[]) => { + let out = s + for (let i = 0; i < k; i++) out = f(out) + return out + } + const pose = (x: number, z: number, y: number) => + again(turnY, y, again(turnZ, z, again(turnX, x, letters))).join('') + + it('lists the 24 frames of the wire order', () => { + const expected: string[] = [] + for (let x = 0; x < 4; x++) { + for (let y = 0; y < 4; y++) expected.push(pose(x, 0, y)) + } + for (const z of [1, 3]) { + for (let y = 0; y < 4; y++) expected.push(pose(0, z, y)) + } + expect([...orbit64V2FrameFaces]).toEqual(expected) + expect(new Set(expected).size).toBe(24) + }) + + it('is frozen', () => { + expect(Object.isFrozen(orbit64V2FrameFaces)).toBe(true) + }) + + // Every frame writes its fixed centers in the slots of its faces. + it('shows the faces of each frame as the fixed centers of an odd cube', () => { + for (const [rank, faces] of orbit64V2FrameFaces.entries()) { + const cube = { ...orbit64V2Solved(3, 'Color'), frame: rank } + const text = ok(orbit64V2ToFacelets(3, 'Color', 'Framed', cube)) + expect( + text + .split(' ') + .map((field) => field[4]) + .join(''), + faces, + ).toBe(faces) + expect(ok(orbit64V2FromFacelets(3, 'Color', 'Framed', text)).frame).toBe( + rank, + ) + expect( + ok(orbit64V2FromFacelets(3, 'Color', 'Canonical', text)).frame, + ).toBe(0) + } + }) +}) + +describe('Orbit64 V2 facelet reference rows', () => { + const rows = fixture.rows + + it('has the rows of the reference repository', () => { + expect(rows).toHaveLength(fixture.rowCount) + expect(rows.length).toBeGreaterThan(0) + // Every color entry has rows, and picture entries have none. + expect(new Set(rows.map((row) => row.id))).toEqual( + new Set(colorEntries.map((e) => e.id)), + ) + }) + + it('writes every row at the length of its entry', () => { + for (const { id, token, facelets } of rows) { + const entry = orbit64V2Entry(id) + expect(token).toHaveLength(entry?.length ?? -1) + const n = entry?.n ?? 0 + expect(facelets.replaceAll(' ', '')).toHaveLength(6 * n * n) + } + }) + + it('encodes every row facelet string to its token', () => { + for (const { id, moves, facelets, token } of rows) { + expect(encodeOrbit64V2Facelets(id, facelets), `${id} ${moves}`).toEqual({ + TAG: 'Ok', + _0: token, + }) + } + }) + + it('decodes every row token to its facelet string', () => { + for (const { id, moves, facelets, token, canonical } of rows) { + const decoded = ok(decodeOrbit64V2Facelets(token)) + expect(decoded.entry.id, `${id} ${moves}`).toBe(id) + expect(decoded.facelets, `${id} ${moves}`).toBe( + canonical === '' ? facelets : canonical, + ) + } + }) + + it('reads a canonical row in any orientation as the same cube', () => { + const turned = rows.filter((row) => row.canonical !== '') + expect(turned.length).toBeGreaterThan(0) + for (const { id, moves, facelets, canonical } of turned) { + const entry = orbit64V2Entry(id) + if (entry === undefined) throw new Error(`${id}`) + expect(entry.pose, `${id} ${moves}`).toBe('Canonical') + expect( + orbit64V2FromFacelets(entry.n, 'Color', 'Canonical', facelets), + `${id} ${moves}`, + ).toEqual(orbit64V2FromFacelets(entry.n, 'Color', 'Canonical', canonical)) + } + }) + + it('reads and writes the cube of every row in both directions', () => { + for (const { id, moves, facelets, token } of rows) { + const entry = orbit64V2Entry(id) + if (entry === undefined) throw new Error(`${id}`) + const cube = ok( + orbit64V2FromFacelets(entry.n, 'Color', entry.pose, facelets), + ) + expect(decodeOrbit64V2State(token), `${id} ${moves}`).toEqual({ + TAG: 'Ok', + _0: { entry, cube }, + }) + if (entry.pose === 'Framed') { + expect( + orbit64V2ToFacelets(entry.n, 'Color', 'Framed', cube), + `${id} ${moves}`, + ).toEqual({ TAG: 'Ok', _0: facelets }) + } + } + }) + + it('ignores spaces when reading', () => { + for (const { id, facelets, token } of rows.slice(0, 80)) { + expect(encodeOrbit64V2Facelets(id, facelets.replaceAll(' ', ''))).toEqual( + { + TAG: 'Ok', + _0: token, + }, + ) + expect( + encodeOrbit64V2Facelets(id, ` ${facelets.replaceAll(' ', ' ')} `), + ).toEqual({ TAG: 'Ok', _0: token }) + } + }) + + it('writes the solved cube of every color entry as the solved token', () => { + for (const e of colorEntries) { + const text = solvedFacelets(e.n) + expect( + ok( + orbit64V2ToFacelets( + e.n, + 'Color', + e.pose, + orbit64V2Solved(e.n, 'Color'), + ), + ), + ).toBe(text) + const token = ok(encodeOrbit64V2Facelets(e.id, text)) + expect(ok(decodeOrbit64V2Facelets(token))).toEqual({ + entry: e, + facelets: text, + }) + expect(token).toHaveLength(e.length) + } + }) + + it('round-trips a state in the middle of every color entry', () => { + for (const e of colorEntries) { + const rank = (e.count * 7919n) / 10007n + let digits = '' + for (let v = e.offset + rank, i = 0; i < e.length; i++, v /= 64n) { + digits = + 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'[ + Number(v % 64n) + ] + digits + } + const { cube } = ok(decodeOrbit64V2State(digits)) + const text = ok(orbit64V2ToFacelets(e.n, 'Color', e.pose, cube)) + expect( + ok(orbit64V2FromFacelets(e.n, 'Color', e.pose, text)), + `${e.id}`, + ).toEqual(cube) + expect(encodeOrbit64V2Facelets(e.id, text), `${e.id}`).toEqual({ + TAG: 'Ok', + _0: digits, + }) + } + }) +}) + +describe('Orbit64 V2 facelet bridge rejects invalid input', () => { + const solved3 = solvedFacelets(3) + const read = (text: string, pose: Orbit64V2Pose = 'Framed', n = 3) => + error(orbit64V2FromFacelets(n, 'Color', pose, text)) + + it('accepts the solved 3x3x3', () => { + expect(read(solved3)).toBe('accepted') + expect(orbit64V2FromFacelets(3, 'Color', 'Framed', solved3).TAG).toBe('Ok') + }) + + it('rejects a wrong number of facelets', () => { + expect(read('UUU')).toBe('expected 54 facelets for the 3x3x3, got 3') + expect(read('')).toBe('expected 54 facelets for the 3x3x3, got 0') + expect(read(`${solved3}U`)).toBe( + 'expected 54 facelets for the 3x3x3, got 55', + ) + expect(read(solved3, 'Framed', 4)).toBe( + 'expected 96 facelets for the 4x4x4, got 54', + ) + }) + + it('rejects a letter outside U R F D L B, a tab and a newline included', () => { + expect(read(withFacelet(solved3, 0, 'X'))).toBe( + "facelet 'X' is not one of U R F D L B", + ) + expect(read(withFacelet(solved3, 0, 'u'))).toBe( + "facelet 'u' is not one of U R F D L B", + ) + expect(read(solved3.replace(' ', '\t'))).toBe( + "facelet '\t' is not one of U R F D L B", + ) + expect(read(solved3.replace(' ', '\n'))).toBe( + "facelet '\n' is not one of U R F D L B", + ) + expect(read(solved3.replace(' ', '\r\n'))).toBe( + "facelet '\r' is not one of U R F D L B", + ) + expect(read(solved3.replace(' ', ' '))).toBe( + "facelet ' ' is not one of U R F D L B", + ) + expect(read(withFacelet(solved3, 3, '\u{1f9ca}'))).toBe( + "facelet '\u{1f9ca}' is not one of U R F D L B", + ) + }) + + it('names a bad letter before a wrong length', () => { + expect(read('X')).toBe("facelet 'X' is not one of U R F D L B") + }) + + it('rejects unbalanced color counts', () => { + expect(read(withFacelet(solved3, 8, 'R'))).toBe( + 'color U occurs 8 times, expected 9', + ) + expect(read(withFacelet(solvedFacelets(4), 0, 'B'), 'Canonical', 4)).toBe( + 'color U occurs 15 times, expected 16', + ) + // All U: the first color to be wrong is named. + expect(read('U'.repeat(54))).toBe('color U occurs 54 times, expected 9') + }) + + it('rejects fixed centers of the wrong handedness', () => { + const handedness = + 'the six fixed centers are not a right-handed whole-cube frame' + // The R and F centers exchanged. + const swapped = withFacelet(withFacelet(solved3, 13, 'F'), 22, 'R') + expect(read(swapped)).toBe(handedness) + expect(read(swapped, 'Canonical')).toBe(handedness) + // The L and R centers exchanged on a 5x5x5. + let five = solvedFacelets(5) + five = withFacelet(withFacelet(five, 25 + 12, 'L'), 100 + 12, 'R') + expect(read(five, 'Framed', 5)).toBe(handedness) + // The mirror image of the solved cube: R and L letters exchanged. + const mirrored = solved3 + .replaceAll('R', 'x') + .replaceAll('L', 'R') + .replaceAll('x', 'L') + expect(read(mirrored, 'Canonical')).toBe(handedness) + }) + + it('rejects a twisted corner', () => { + const twist = 'corner twists must sum to 0 mod 3' + // The URF corner turned in place. + expect( + read('UUUUUUUUF URRRRRRRR FFRFFFFFF DDDDDDDDD LLLLLLLLL BBBBBBBBB'), + ).toBe(twist) + expect( + read( + 'UUUUUUUUF URRRRRRRR FFRFFFFFF DDDDDDDDD LLLLLLLLL BBBBBBBBB', + 'Canonical', + ), + ).toBe(twist) + // The same on a 4x4x4, whose URF corner has facelets 15, 16 and 35. + let four = solvedFacelets(4) + four = withFacelet( + withFacelet(withFacelet(four, 15, 'R'), 16, 'F'), + 35, + 'U', + ) + expect(read(four, 'Framed', 4)).toBe(twist) + expect(read(four, 'Canonical', 4)).toBe(twist) + }) + + it('rejects a flipped midge', () => { + // The U and R stickers of the UR edge exchanged. + expect( + read('UUUUURUUU RURRRRRRR FFFFFFFFF DDDDDDDDD LLLLLLLLL BBBBBBBBB'), + ).toBe('midge flips must sum to 0 mod 2') + expect( + read( + 'UUUUURUUU RURRRRRRR FFFFFFFFF DDDDDDDDD LLLLLLLLL BBBBBBBBB', + 'Canonical', + ), + ).toBe('midge flips must sum to 0 mod 2') + }) + + it('rejects a slot that shows no piece of the cube', () => { + // The U and R stickers of the URF corner exchanged: a mirrored corner. + expect( + read('UUUUUUUUR URRRRRRRR FFFFFFFFF DDDDDDDDD LLLLLLLLL BBBBBBBBB'), + ).toBe('corner slot 0 shows RUF, which is no corner of this cube') + // The B sticker of the UB wing and a D sticker exchanged: slot 0 shows UD. + let four = solvedFacelets(4) + four = withFacelet(withFacelet(four, 82, 'D'), 49, 'B') + expect(read(four, 'Framed', 4)).toBe( + 'wing slot 0 shows UD, which is no wing of this cube', + ) + // A midge with two stickers of one color. + let three = withFacelet(solved3, 10, 'U') + three = withFacelet(three, 1, 'R') + expect(read(three)).toBe( + 'midge slot 0 shows UU, which is no midge of this cube', + ) + }) + + it('rejects a piece that is shown twice', () => { + // The UFL corner shows the URF corner and the UR midge the UL midge: + // every color count and every slot is fine, two pieces are doubled. + let text = withFacelet(solved3, 18, 'R') + text = withFacelet(text, 38, 'F') + text = withFacelet(text, 10, 'L') + expect(read(text)).toBe('corner pieces are not a permutation of 8') + expect(read(text, 'Canonical')).toBe( + 'corner pieces are not a permutation of 8', + ) + // A 4x4x4 wing doubled: slot 0 shows the wing of slot 20. + const doubled = withFacelet(withFacelet(solvedFacelets(4), 1, 'B'), 82, 'U') + expect(read(doubled, 'Framed', 4)).toBe( + 'expected 1 wing permutations of 24', + ) + }) + + it('rejects a mirrored cube', () => { + // Mirror image without the mirrored color scheme: the left and right + // letters exchanged on the 4x4x4, whose corners then run counterclockwise. + const mirrored = solvedFacelets(4) + .replaceAll('R', 'x') + .replaceAll('L', 'R') + .replaceAll('x', 'L') + expect(read(mirrored, 'Canonical', 4)).toBe( + 'no whole-cube rotation puts the DBL corner home', + ) + expect(read(mirrored, 'Framed', 4)).toBe( + 'corner slot 0 shows ULF, which is no corner of this cube', + ) + }) + + it('rejects types without letters', () => { + expect(error(orbit64V2FromFacelets(3, 'Picture', 'Framed', solved3))).toBe( + 'the picture model has no letters', + ) + for (const n of [16, 1, 0, -3, 2.5, Number.NaN]) { + expect( + error(orbit64V2FromFacelets(n, 'Color', 'Framed', solved3)), + String(n), + ).toMatch(/^no V2 type for the /) + } + expect(error(orbit64V2FromFacelets(16, 'Color', 'Framed', solved3))).toBe( + 'no V2 type for the 16x16x16', + ) + const cube = orbit64V2Solved(3, 'Picture') + expect(error(orbit64V2ToFacelets(3, 'Picture', 'Framed', cube))).toBe( + 'the picture model has no letters', + ) + expect(error(orbit64V2ToFacelets(16, 'Color', 'Framed', cube))).toBe( + 'no V2 type for the 16x16x16', + ) + }) + + it('says why an entry or token has no facelets', () => { + const picture = orbit64V2Entries.filter((e) => e.model === 'Picture') + expect(picture.length).toBeGreaterThan(0) + for (const e of picture) { + expect( + error(encodeOrbit64V2Facelets(e.id, solvedFacelets(e.n))), + `${e.id}`, + ).toBe('the picture model has no letters') + expect( + error(decodeOrbit64V2Facelets(tokenOfSolved(e))), + `token of ${e.id}`, + ).toBe('the picture model has no letters') + } + expect(error(encodeOrbit64V2Facelets(54, solved3))).toBe( + 'unknown registry entry 54', + ) + expect(error(encodeOrbit64V2Facelets(-1, solved3))).toBe( + 'unknown registry entry -1', + ) + expect(error(decodeOrbit64V2Facelets('AAA'))).toBe( + 'not a known V2 state token', + ) + }) + + it('writes no facelets for a cube that is no state of its type', () => { + const cube = orbit64V2Solved(3, 'Color') + const bad = { ...cube, cornerTwists: [1, 0, 0, 0, 0, 0, 0, 0] } + expect(error(orbit64V2ToFacelets(3, 'Color', 'Framed', bad))).toBe( + 'corner twists must sum to 0 mod 3', + ) + // A frame on a canonical cube. + expect( + error( + orbit64V2ToFacelets(3, 'Color', 'Canonical', { ...cube, frame: 1 }), + ), + ).toBe('frame must be 0..23 on odd framed cubes and 0 otherwise') + }) + + it('returns an error instead of throwing on hostile values', () => { + const cube = orbit64V2Solved(4, 'Color') + const cubes = [ + undefined, + null, + 5, + 'cube', + {}, + { ...cube, wings: undefined }, + { ...cube, centers: [[0]] }, + { ...cube, cornerPieces: 'abcdefgh' }, + ] + for (const bad of cubes) { + expect( + error( + orbit64V2ToFacelets( + 4, + 'Color', + 'Framed', + bad as unknown as Orbit64V2Cube, + ), + ), + JSON.stringify(bad), + ).not.toBe('accepted') + } + for (const bad of [undefined, null, 5, {}, ['U'], new String(solved3)]) { + expect( + orbit64V2FromFacelets(3, 'Color', 'Framed', bad as unknown as string) + .TAG, + ).toBe('Error') + expect(encodeOrbit64V2Facelets(3, bad as unknown as string).TAG).toBe( + 'Error', + ) + } + for (const bad of [undefined, null, 5, {}, ['AAAA']]) { + expect(decodeOrbit64V2Facelets(bad as unknown as string).TAG).toBe( + 'Error', + ) + } + for (const id of [Number.NaN, 1.5, Number.POSITIVE_INFINITY, undefined]) { + expect(encodeOrbit64V2Facelets(id as number, solved3).TAG).toBe('Error') + } + const huge = 'U'.repeat(100_000) + expect(read(huge)).toBe('expected 54 facelets for the 3x3x3, got 100000') + }) +}) + +// The token of the solved state of an entry: its offset written at its length. +function tokenOfSolved(e: { offset: bigint; length: number }): string { + const alphabet = + 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_' + let token = '' + for (let v = e.offset, i = 0; i < e.length; i++, v /= 64n) { + token = alphabet[Number(v % 64n)] + token + } + return token +} From 181a03194d6f37fa7af171ebede460c0f6365075 Mon Sep 17 00:00:00 2001 From: Werner Stein Date: Sun, 1 Nov 2026 13:11:17 +0000 Subject: [PATCH 04/10] docs(orbit64): describe the V2 facelet bridge and its fixture Co-Authored-By: Claude Sonnet 5.5 --- docs/architecture.md | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/docs/architecture.md b/docs/architecture.md index a6a7814..f2637b8 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -96,3 +96,14 @@ before adding one. The Orbit64 browser codec is adapted from `flix-orbit64` under [Apache-2.0](../third_party/flix-orbit64.LICENSE), with cross-project vectors in `test/cube/notation/orbit64Vectors.json` and `test/cube/notation/orbit64LargeVectors.json`. + +The Orbit64 V2 state codec for 2x2-15x15 cubes +([`Orbit64V2.res`](../src/cube/notation/Orbit64V2.res)) works on orbit +coordinates. [`Orbit64V2Facelets.res`](../src/cube/notation/Orbit64V2Facelets.res) +is its facelet bridge for the color model, both poses: slot tables, cube to +facelets and back, and token to facelets and back, with every failure an error +value. The picture model has no facelet letters and is an error there. Its +fixture `test/cube/notation/orbit64V2Facelets.json` (the slot tables of +`FORMAT-V2-SLOTS.md` and the facelet rows of `TestV2FaceletData.flix`) is written +by `julia scripts/orbit64V2FaceletFixture.jl ` and +regenerates byte for byte. From 679bf0dbef5fde85a94022e42d8b7b79edff8e86 Mon Sep 17 00:00:00 2001 From: Werner Stein Date: Sun, 1 Nov 2026 13:36:38 +0000 Subject: [PATCH 05/10] fix(orbit64): reject unknown poses and hostile sizes in the V2 facelet bridge An unknown pose such as 'Bogus' was read as a pose of its own. The type check now rejects anything but Canonical and Framed with "unknown pose". The cube size is checked as a number before any arithmetic or conversion, so slotTables no longer throws for objects, symbols or bigints, and the error says the size is not an integer in 2..15 without echoing it. The tests assert the exact reasons, check that the canonical rows read as Ok, add the mirrored 3x3x3 case, and note two deliberate differences from the reference. Co-Authored-By: Claude Sonnet 5.5 --- src/cube/notation/Orbit64V2Facelets.res | 27 ++-- test/cube/notation/orbit64V2Facelets.test.ts | 150 ++++++++++++++++++- 2 files changed, 163 insertions(+), 14 deletions(-) diff --git a/src/cube/notation/Orbit64V2Facelets.res b/src/cube/notation/Orbit64V2Facelets.res index 4c4cea2..be3648b 100644 --- a/src/cube/notation/Orbit64V2Facelets.res +++ b/src/cube/notation/Orbit64V2Facelets.res @@ -168,10 +168,12 @@ let tables = n => built } -let isInt = x => { - let f = Int.toFloat(x) - Float.isFinite(f) && Math.floor(f) == f -} +// Only a number is looked at: the global isFinite would convert anything else +// first, and a hostile object or symbol would throw there. +let isInt = x => + Type.typeof(x) == #number && + Float.isFinite(Obj.magic(x)) && + Math.floor(Obj.magic(x)) == Obj.magic(x) // A number or whatever a caller passed, as text for a message. @val external show: 'a => string = "String" @@ -352,13 +354,17 @@ let paint = (n, t, cube: Orbit64V2.cube) => { } // Why a type has no facelet letters, if it has none. -let typeFault = (n, model: Orbit64V2.model) => - if !validSize(n) { - Some(`no V2 type for the ${show(n)}x${show(n)}x${show(n)}`) +let typeFault = (n, model: Orbit64V2.model, pose: Orbit64V2.pose) => + if !isInt(n) { + Some("the cube size is not an integer in 2..15") + } else if !validSize(n) { + Some(`no V2 type for the ${Int.toString(n)}x${Int.toString(n)}x${Int.toString(n)}`) } else if model == Picture { Some("the picture model has no letters") } else if model != Color { Some("unknown sticker model") + } else if pose != Canonical && pose != Framed { + Some("unknown pose") } else { None } @@ -373,7 +379,7 @@ let spell = (n, fs) => @genType let toFacelets = (n, model, pose, cube) => try { - switch typeFault(n, model) { + switch typeFault(n, model, pose) { | Some(why) => Error(why) | None => let cube = Orbit64V2.snapshot(cube) @@ -392,7 +398,8 @@ let toFacelets = (n, model, pose, cube) => @val external codePoints: string => array = "Array.from" -// The face index of a facelet letter; a tab or newline is a bad letter like any other. +// The face index of a facelet letter (a whole code point is quoted, where the +// reference quotes a UTF-16 unit); a tab or newline is a bad letter like any other. let letterIndex = letter => switch faceIndex(letter) { | -1 => Error(`facelet '${letter}' is not one of U R F D L B`) @@ -556,7 +563,7 @@ let readStickers = (n, model, pose, text) => { @genType let fromFacelets = (n, model, pose, facelets) => try { - switch typeFault(n, model) { + switch typeFault(n, model, pose) { | Some(why) => Error(why) | None => Type.typeof(facelets) == #string diff --git a/test/cube/notation/orbit64V2Facelets.test.ts b/test/cube/notation/orbit64V2Facelets.test.ts index a17e69a..678ed4b 100644 --- a/test/cube/notation/orbit64V2Facelets.test.ts +++ b/test/cube/notation/orbit64V2Facelets.test.ts @@ -215,10 +215,13 @@ describe('Orbit64 V2 facelet reference rows', () => { const entry = orbit64V2Entry(id) if (entry === undefined) throw new Error(`${id}`) expect(entry.pose, `${id} ${moves}`).toBe('Canonical') + const cube = ok( + orbit64V2FromFacelets(entry.n, 'Color', 'Canonical', canonical), + ) expect( orbit64V2FromFacelets(entry.n, 'Color', 'Canonical', facelets), `${id} ${moves}`, - ).toEqual(orbit64V2FromFacelets(entry.n, 'Color', 'Canonical', canonical)) + ).toEqual({ TAG: 'Ok', _0: cube }) } }) @@ -302,6 +305,130 @@ describe('Orbit64 V2 facelet reference rows', () => { }) }) +const sizeFault = 'the cube size is not an integer in 2..15' + +describe('Orbit64 V2 facelet bridge rejects an invalid pose', () => { + const solved3 = solvedFacelets(3) + const poses = [ + 'Bogus', + 'framed', + 'canonical', + '', + undefined, + null, + 0, + 1, + {}, + [], + ] + + it('reads no pose but Canonical and Framed', () => { + for (const pose of poses) { + for (const [n, text] of [ + [3, solved3], + [2, solvedFacelets(2)], + [4, solvedFacelets(4)], + ] as const) { + expect( + error(orbit64V2FromFacelets(n, 'Color', pose as Orbit64V2Pose, text)), + `${n} ${JSON.stringify(pose)}`, + ).toBe('unknown pose') + } + } + }) + + it('does not read the 2x2x2 string of an unknown pose as a cube', () => { + // As a Bogus pose this used to read as corners [3, 0, 1, 2, 7, 4, 5, 6]. + expect( + error( + orbit64V2FromFacelets( + 2, + 'Color', + 'Bogus' as Orbit64V2Pose, + 'UUUU BBBB RRRR DDDD FFFF LLLL', + ), + ), + ).toBe('unknown pose') + }) + + it('writes no facelets for an unknown pose', () => { + for (const pose of poses) { + expect( + error( + orbit64V2ToFacelets( + 3, + 'Color', + pose as Orbit64V2Pose, + orbit64V2Solved(3, 'Color'), + ), + ), + JSON.stringify(pose), + ).toBe('unknown pose') + } + }) + + it('names the size before the model before the pose', () => { + const bogus = 'Bogus' as Orbit64V2Pose + expect(error(orbit64V2FromFacelets(16, 'Color', bogus, solved3))).toBe( + 'no V2 type for the 16x16x16', + ) + expect(error(orbit64V2FromFacelets(3, 'Picture', bogus, solved3))).toBe( + 'the picture model has no letters', + ) + }) +}) + +describe('Orbit64 V2 facelet bridge rejects a hostile cube size', () => { + const solved3 = solvedFacelets(3) + const throwing = { + toString() { + throw new Error('toString') + }, + valueOf() { + throw new Error('valueOf') + }, + } + const sizes: unknown[] = [ + Object.create(null), + throwing, + 3n, + Symbol('3'), + '3', + [3], + { valueOf: () => 3 }, + undefined, + null, + true, + ] + + it('has no slot tables, and does not throw', () => { + for (const n of sizes) { + expect(orbit64V2Slots(n as number), String(typeof n)).toBeUndefined() + } + }) + + it('says the size is not an integer in 2..15, echoing nothing', () => { + for (const n of sizes) { + const label = typeof n + expect( + error(orbit64V2FromFacelets(n as number, 'Color', 'Framed', solved3)), + label, + ).toBe(sizeFault) + expect( + error( + orbit64V2ToFacelets( + n as number, + 'Color', + 'Framed', + orbit64V2Solved(3, 'Color'), + ), + ), + label, + ).toBe(sizeFault) + } + }) +}) + describe('Orbit64 V2 facelet bridge rejects invalid input', () => { const solved3 = solvedFacelets(3) const read = (text: string, pose: Orbit64V2Pose = 'Framed', n = 3) => @@ -446,7 +573,8 @@ describe('Orbit64 V2 facelet bridge rejects invalid input', () => { expect(read(text, 'Canonical')).toBe( 'corner pieces are not a permutation of 8', ) - // A 4x4x4 wing doubled: slot 0 shows the wing of slot 20. + // A 4x4x4 wing doubled: slot 0 shows the wing of slot 20. The text is the + // reference's for any wing orbit that is no permutation, kept for parity. const doubled = withFacelet(withFacelet(solvedFacelets(4), 1, 'B'), 82, 'U') expect(read(doubled, 'Framed', 4)).toBe( 'expected 1 wing permutations of 24', @@ -460,6 +588,14 @@ describe('Orbit64 V2 facelet bridge rejects invalid input', () => { .replaceAll('R', 'x') .replaceAll('L', 'R') .replaceAll('x', 'L') + // On a 3x3x3 the fixed centers show the mirror first, in either pose. + const mirrored3 = solved3 + .replaceAll('R', 'x') + .replaceAll('L', 'R') + .replaceAll('x', 'L') + expect(read(mirrored3, 'Framed')).toBe( + 'the six fixed centers are not a right-handed whole-cube frame', + ) expect(read(mirrored, 'Canonical', 4)).toBe( 'no whole-cube rotation puts the DBL corner home', ) @@ -472,11 +608,17 @@ describe('Orbit64 V2 facelet bridge rejects invalid input', () => { expect(error(orbit64V2FromFacelets(3, 'Picture', 'Framed', solved3))).toBe( 'the picture model has no letters', ) - for (const n of [16, 1, 0, -3, 2.5, Number.NaN]) { + for (const n of [16, 1, 0, -3]) { + expect( + error(orbit64V2FromFacelets(n, 'Color', 'Framed', solved3)), + String(n), + ).toBe(`no V2 type for the ${n}x${n}x${n}`) + } + for (const n of [2.5, Number.NaN, Number.POSITIVE_INFINITY]) { expect( error(orbit64V2FromFacelets(n, 'Color', 'Framed', solved3)), String(n), - ).toMatch(/^no V2 type for the /) + ).toBe(sizeFault) } expect(error(orbit64V2FromFacelets(16, 'Color', 'Framed', solved3))).toBe( 'no V2 type for the 16x16x16', From 3dd1b5caaacb6ca413f53dcfb79e89d6b4b2a469 Mon Sep 17 00:00:00 2001 From: Werner Stein Date: Sun, 1 Nov 2026 13:36:39 +0000 Subject: [PATCH 06/10] test(orbit64): make the V2 facelet fixture generator fail on unparsed input The generator now checks the parsed row count against the tuple lines of TestV2FaceletData.flix, rejects unparsed slot lines, checks the center orbits per size, and records the full commit hash and whether the source tree had uncommitted changes. The fixture changes only in its source line. Co-Authored-By: Claude Sonnet 5.5 --- scripts/orbit64V2FaceletFixture.jl | 15 +++++++++++++-- test/cube/notation/orbit64V2Facelets.json | 2 +- 2 files changed, 14 insertions(+), 3 deletions(-) diff --git a/scripts/orbit64V2FaceletFixture.jl b/scripts/orbit64V2FaceletFixture.jl index 80bddab..ca26901 100644 --- a/scripts/orbit64V2FaceletFixture.jl +++ b/scripts/orbit64V2FaceletFixture.jl @@ -14,7 +14,10 @@ root = length(ARGS) == 1 ? ARGS[1] : error("usage: julia scripts/orbit64V2FaceletFixture.jl ") read_text(path) = read(joinpath(root, path), String) -revision = strip(read(`git -C $root rev-parse --short HEAD`, String)) +revision = strip(read(`git -C $root rev-parse HEAD`, String)) +# A tree with uncommitted changes is not the commit it names; the fixture says so. +dirty = !isempty(strip(read(`git -C $root status --porcelain`, String))) +source_name = dirty ? "flix-orbit64@$revision (uncommitted changes)" : "flix-orbit64@$revision" # ---- FORMAT-V2-SLOTS.md -------------------------------------------------------- # ## 5x5x5 @@ -60,6 +63,8 @@ function parse_slots(text::String) kind == :midges && push!(current.midges, facelets) kind == :wings && push!(current.wings[end], facelets) kind == :centers && push!(current.centers, facelets) + elseif startswith(line, " ") && !isempty(strip(line)) + error("unparsed slot line: $line") end end sizes @@ -71,6 +76,8 @@ for (n, s) in slots length(s.corners) == 8 || error("$(n)x$(n)x$(n): $(length(s.corners)) corners") length(s.midges) == (isodd(n) ? 12 : 0) || error("$(n)x$(n)x$(n): $(length(s.midges)) midges") length(s.wings) == (n - 2) ÷ 2 || error("$(n)x$(n)x$(n): $(length(s.wings)) wing depths") + length(s.centers) == ((n - 2)^2) ÷ 4 || error("$(n)x$(n)x$(n): $(length(s.centers)) center orbits") + all(c -> length(split(c)) == 24, s.centers) || error("$(n)x$(n)x$(n): a center orbit without 24 slots") all(w -> length(w) == 24, s.wings) || error("$(n)x$(n)x$(n): a wing depth without 24 slots") end @@ -87,12 +94,16 @@ end row_pattern = r"^\s*\((\d+), \"([^\"]*)\", \"([^\"]*)\", \"([^\"]*)\", \"([^\"]*)\"\),?\s*$" rows = Row[] +tuple_lines = 0 for line in split(read_text("test/TestV2FaceletData.flix"), '\n') + # A line that starts a tuple must be a row; the count is checked below. + occursin(r"^\s*\(\d+,", line) && (global tuple_lines += 1) m = match(row_pattern, line) m === nothing && continue push!(rows, Row(parse(Int, m.captures[1]), m.captures[2], m.captures[3], m.captures[4], m.captures[5])) end isempty(rows) && error("TestV2FaceletData.flix: no rows") +length(rows) == tuple_lines || error("TestV2FaceletData.flix: $tuple_lines tuple lines, $(length(rows)) parsed as rows") # ---- JSON ---------------------------------------------------------------------- @@ -141,7 +152,7 @@ row_text = join([row_object(r) for r in rows], ",\n") json = """ { - "source": $(quoted("flix-orbit64@$revision: FORMAT-V2-SLOTS.md and test/TestV2FaceletData.flix (generated there by tools/format-v2/facelet_vectors.jl)")), + "source": $(quoted("$source_name: FORMAT-V2-SLOTS.md and test/TestV2FaceletData.flix (generated there by tools/format-v2/facelet_vectors.jl)")), "generatedBy": "scripts/orbit64V2FaceletFixture.jl. Do not edit.", "slotText": "Facelets of each slot of an orbit, separated by spaces, slots separated by |, in slot order. Wings are keyed by depth, outermost first.", "rowText": "id: registry entry; moves: layer turns (depth, face, suffix) and whole-cube turns x y z from the solved cube; facelets: what the entry writes for the cube; token: its V2 token; canonical: the reference pose of that cube when the entry's facelets differ from it, else empty.", diff --git a/test/cube/notation/orbit64V2Facelets.json b/test/cube/notation/orbit64V2Facelets.json index ae04fdc..6eac160 100644 --- a/test/cube/notation/orbit64V2Facelets.json +++ b/test/cube/notation/orbit64V2Facelets.json @@ -1,5 +1,5 @@ { - "source": "flix-orbit64@d701008: FORMAT-V2-SLOTS.md and test/TestV2FaceletData.flix (generated there by tools/format-v2/facelet_vectors.jl)", + "source": "flix-orbit64@d7010088fd0d83d52be66672246189ba70705809: FORMAT-V2-SLOTS.md and test/TestV2FaceletData.flix (generated there by tools/format-v2/facelet_vectors.jl)", "generatedBy": "scripts/orbit64V2FaceletFixture.jl. Do not edit.", "slotText": "Facelets of each slot of an orbit, separated by spaces, slots separated by |, in slot order. Wings are keyed by depth, outermost first.", "rowText": "id: registry entry; moves: layer turns (depth, face, suffix) and whole-cube turns x y z from the solved cube; facelets: what the entry writes for the cube; token: its V2 token; canonical: the reference pose of that cube when the entry's facelets differ from it, else empty.", From f58319287cae1de8b703690f12cbffbe930c475b Mon Sep 17 00:00:00 2001 From: Werner Stein Date: Sun, 1 Nov 2026 14:17:40 +0000 Subject: [PATCH 07/10] fix(orbit64): do not echo caller text for an unknown V2 registry entry An unknown id was written into the message with String(), which echoed caller text and ran a caller's toString. Only a genuine integer is quoted now; anything else says the registry entry is not an integer. The V2 codec's own message gets the same rule. Co-Authored-By: Claude Sonnet 5.5 --- src/cube/notation/Orbit64V2.res | 8 +++++++- src/cube/notation/Orbit64V2Facelets.res | 11 +++++++---- 2 files changed, 14 insertions(+), 5 deletions(-) diff --git a/src/cube/notation/Orbit64V2.res b/src/cube/notation/Orbit64V2.res index b240474..e16d9d4 100644 --- a/src/cube/notation/Orbit64V2.res +++ b/src/cube/notation/Orbit64V2.res @@ -417,7 +417,13 @@ let snapshot = (cube: cube): cube => { let encodeOrbit64V2State = (id, cube) => try { switch findEntry(id) { - | None => Error(`unknown registry entry ${Int.toString(id)}`) + | None => + // Only a genuine integer is quoted: no caller text, no caller code. + Error( + Type.typeof(id) == #number && isInt(id) + ? `unknown registry entry ${Int.toString(id)}` + : "the registry entry is not an integer", + ) | Some(entry) => rankState(entry.n, entry.model, entry.pose, snapshot(cube))->Result.map(rank => Orbit64.toBase64(entry.offset + rank, entry.length) diff --git a/src/cube/notation/Orbit64V2Facelets.res b/src/cube/notation/Orbit64V2Facelets.res index be3648b..6dff081 100644 --- a/src/cube/notation/Orbit64V2Facelets.res +++ b/src/cube/notation/Orbit64V2Facelets.res @@ -175,9 +175,6 @@ let isInt = x => Float.isFinite(Obj.magic(x)) && Math.floor(Obj.magic(x)) == Obj.magic(x) -// A number or whatever a caller passed, as text for a message. -@val external show: 'a => string = "String" - let validSize = n => isInt(n) && n >= 2 && n <= 15 @genType @@ -580,7 +577,13 @@ let fromFacelets = (n, model, pose, facelets) => let encodeFacelets = (id, facelets) => try { switch Orbit64V2.entryById(id) { - | None => Error(`unknown registry entry ${show(id)}`) + | None => + // Only a genuine integer is quoted: no caller text, no caller code. + Error( + isInt(id) + ? `unknown registry entry ${Int.toString(id)}` + : "the registry entry is not an integer", + ) | Some(entry) => fromFacelets(entry.n, entry.model, entry.pose, facelets)->Result.flatMap(cube => Orbit64V2.encodeOrbit64V2State(id, cube) From d0865f3504f0f9bdce58d22694d7d6baa65d032e Mon Sep 17 00:00:00 2001 From: Werner Stein Date: Sun, 1 Nov 2026 14:17:40 +0000 Subject: [PATCH 08/10] test(orbit64): fail the V2 facelet generator on a dropped reference row Every move sequence of a size must have one row for each of its two color entries, and every size 2..15 must appear. A dropped row now stops the generator instead of shrinking the fixture. The fixture is unchanged. Co-Authored-By: Claude Sonnet 5.5 --- scripts/orbit64V2FaceletFixture.jl | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/scripts/orbit64V2FaceletFixture.jl b/scripts/orbit64V2FaceletFixture.jl index ca26901..4e3841b 100644 --- a/scripts/orbit64V2FaceletFixture.jl +++ b/scripts/orbit64V2FaceletFixture.jl @@ -104,6 +104,26 @@ for line in split(read_text("test/TestV2FaceletData.flix"), '\n') end isempty(rows) && error("TestV2FaceletData.flix: no rows") length(rows) == tuple_lines || error("TestV2FaceletData.flix: $tuple_lines tuple lines, $(length(rows)) parsed as rows") +# Structure the input already has: every move sequence of a size is written once +# for each of its two color entries (canonical and framed). A dropped row leaves +# a sequence with one entry, and an extra one a sequence with three. +rows_by_sequence = Dict{Tuple{Int,String},Vector{Int}}() +ids_by_size = Dict{Int,Set{Int}}() +for r in rows + cells = length(replace(r.facelets, " " => "")) + n = round(Int, sqrt(cells / 6)) + 6n^2 == cells || error("row of entry $(r.id): $cells facelets are no cube") + push!(get!(rows_by_sequence, (n, r.moves), Int[]), r.id) + push!(get!(ids_by_size, n, Set{Int}()), r.id) +end +for (n, ids) in ids_by_size + length(ids) == 2 || error("$(n)x$(n)x$(n): rows of $(length(ids)) entries, expected 2") +end +for ((n, moves), ids) in rows_by_sequence + sort(ids) == sort(collect(ids_by_size[n])) || + error("$(n)x$(n)x$(n): moves \"$moves\" have rows for entries $(sort(ids)), expected $(sort(collect(ids_by_size[n]))) once each") +end +sort(collect(keys(ids_by_size))) == collect(2:15) || error("rows for sizes $(sort(collect(keys(ids_by_size)))), expected 2:15") # ---- JSON ---------------------------------------------------------------------- From 61b72a39d75cb4a02242be7162a952684e3d44ba Mon Sep 17 00:00:00 2001 From: Werner Stein Date: Sun, 1 Nov 2026 14:17:40 +0000 Subject: [PATCH 09/10] test(orbit64): check hostile input and the fixture structure of the V2 bridge Asserts the exact reasons for throwing getters, Proxies, thrown primitives and a throwing message, for non-string facelets and tokens, and for unknown registry entries that are not integers, including that no caller code runs. The fixture test checks that every move sequence has both color entries, which fails when a row is dropped. Co-Authored-By: Claude Sonnet 5.5 --- test/cube/notation/orbit64V2Facelets.test.ts | 158 ++++++++++++++++--- 1 file changed, 135 insertions(+), 23 deletions(-) diff --git a/test/cube/notation/orbit64V2Facelets.test.ts b/test/cube/notation/orbit64V2Facelets.test.ts index 678ed4b..b432239 100644 --- a/test/cube/notation/orbit64V2Facelets.test.ts +++ b/test/cube/notation/orbit64V2Facelets.test.ts @@ -1,6 +1,7 @@ import { describe, expect, it } from 'vitest' import { decodeOrbit64V2State, + encodeOrbit64V2State, type Orbit64V2Cube, type Orbit64V2Pose, orbit64V2Entries, @@ -180,6 +181,36 @@ describe('Orbit64 V2 facelet reference rows', () => { ) }) + // The generator checks this too: every move sequence of a size has one row + // for each of the two color entries of that size, so a dropped row shows. + it('has every move sequence once for each color entry of its size', () => { + const entriesOf = new Map>() + const bySequence = new Map() + for (const { id, moves, facelets } of rows) { + const n = orbit64V2Entry(id)?.n ?? 0 + expect(facelets.replaceAll(' ', '')).toHaveLength(6 * n * n) + entriesOf.set(n, (entriesOf.get(n) ?? new Set()).add(id)) + const key = `${n} ${moves}` + bySequence.set(key, [...(bySequence.get(key) ?? []), id]) + } + expect([...entriesOf.keys()]).toEqual( + Array.from({ length: 14 }, (_, i) => i + 2), + ) + for (const [n, ids] of entriesOf) { + expect( + [...ids].sort((a, b) => a - b), + `${n}`, + ).toEqual(colorEntries.filter((e) => e.n === n).map((e) => e.id)) + } + for (const [key, ids] of bySequence) { + const n = Number(key.split(' ')[0]) + expect( + ids.sort((a, b) => a - b), + key, + ).toEqual(colorEntries.filter((e) => e.n === n).map((e) => e.id)) + } + }) + it('writes every row at the length of its entry', () => { for (const { id, token, facelets } of rows) { const entry = orbit64V2Entry(id) @@ -672,7 +703,16 @@ describe('Orbit64 V2 facelet bridge rejects invalid input', () => { it('returns an error instead of throwing on hostile values', () => { const cube = orbit64V2Solved(4, 'Color') - const cubes = [ + const write = (bad: unknown) => + error( + orbit64V2ToFacelets( + 4, + 'Color', + 'Framed', + bad as unknown as Orbit64V2Cube, + ), + ) + for (const bad of [ undefined, null, 5, @@ -681,40 +721,112 @@ describe('Orbit64 V2 facelet bridge rejects invalid input', () => { { ...cube, wings: undefined }, { ...cube, centers: [[0]] }, { ...cube, cornerPieces: 'abcdefgh' }, + ]) { + expect(write(bad), JSON.stringify(bad)).not.toBe('accepted') + } + expect(write(undefined)).toBe('malformed state') + expect(write(null)).toBe('malformed state') + // Reads that throw: a getter, a Proxy, a thrown primitive, a thrown + // Proxy and an error whose message throws too. + const thrown = [ + 'a string', + 42, + undefined, + new Proxy({}, { get: () => 1 }), + { + get message(): string { + throw new Error('message') + }, + }, ] - for (const bad of cubes) { - expect( - error( - orbit64V2ToFacelets( - 4, - 'Color', - 'Framed', - bad as unknown as Orbit64V2Cube, - ), - ), - JSON.stringify(bad), - ).not.toBe('accepted') + for (const value of thrown) { + const getter = { + ...cube, + get cornerPieces(): number[] { + // Throwing a non-error is the point of the case. + // eslint-disable-next-line @typescript-eslint/only-throw-error + throw value + }, + } + expect(write(getter), String(typeof value)).toBe('malformed state') } + expect( + write( + new Proxy(cube, { + get() { + throw new Error('trap') + }, + }), + ), + ).toBe('malformed state') + expect(write(new Proxy({}, { get: () => undefined }))).toBe( + 'malformed state', + ) + for (const bad of [undefined, null, 5, {}, ['U'], new String(solved3)]) { expect( - orbit64V2FromFacelets(3, 'Color', 'Framed', bad as unknown as string) - .TAG, - ).toBe('Error') - expect(encodeOrbit64V2Facelets(3, bad as unknown as string).TAG).toBe( - 'Error', + error( + orbit64V2FromFacelets(3, 'Color', 'Framed', bad as unknown as string), + ), + ).toBe('facelets must be a string') + expect(error(encodeOrbit64V2Facelets(3, bad as unknown as string))).toBe( + 'facelets must be a string', ) } for (const bad of [undefined, null, 5, {}, ['AAAA']]) { - expect(decodeOrbit64V2Facelets(bad as unknown as string).TAG).toBe( - 'Error', + expect(error(decodeOrbit64V2Facelets(bad as unknown as string))).toBe( + 'not a known V2 state token', ) } - for (const id of [Number.NaN, 1.5, Number.POSITIVE_INFINITY, undefined]) { - expect(encodeOrbit64V2Facelets(id as number, solved3).TAG).toBe('Error') - } const huge = 'U'.repeat(100_000) expect(read(huge)).toBe('expected 54 facelets for the 3x3x3, got 100000') }) + + it('names an unknown entry without echoing caller text or running caller code', () => { + const notInteger = 'the registry entry is not an integer' + const ran: string[] = [] + const ids: unknown[] = [ + Number.NaN, + 1.5, + Number.POSITIVE_INFINITY, + undefined, + null, + '', + 'x'.repeat(2_000_000), + () => 3, + '3', + 3n, + [3], + new Number(3), + Symbol('3'), + Object.create(null), + { + toString() { + ran.push('toString') + return '3' + }, + valueOf() { + ran.push('valueOf') + return 3 + }, + }, + ] + for (const id of ids) { + const reason = error(encodeOrbit64V2Facelets(id as number, solved3)) + expect(reason, typeof id).toBe(notInteger) + expect( + error(encodeOrbit64V2State(id as number, orbit64V2Solved(3, 'Color'))), + typeof id, + ).toBe(notInteger) + } + expect(ran).toEqual([]) + expect(error(encodeOrbit64V2Facelets(54, solved3))).toBe( + 'unknown registry entry 54', + ) + expect(error(encodeOrbit64V2Facelets(-1, solved3))).toBe( + 'unknown registry entry -1', + ) + }) }) // The token of the solved state of an entry: its offset written at its length. From c6530894045089c0533219d626526994c818a5d8 Mon Sep 17 00:00:00 2001 From: Werner Stein Date: Sun, 1 Nov 2026 14:51:44 +0000 Subject: [PATCH 10/10] test(orbit64): pin the row and move sequence counts of the V2 facelet fixture Dropping both rows of one move sequence kept the structure checks intact. The generator and the test now pin the 448 rows and the number of move sequences per size, so such a drop fails both. Co-Authored-By: Claude Sonnet 5.5 --- scripts/orbit64V2FaceletFixture.jl | 10 +++++++ test/cube/notation/orbit64V2Facelets.test.ts | 30 ++++++++++++++++++++ 2 files changed, 40 insertions(+) diff --git a/scripts/orbit64V2FaceletFixture.jl b/scripts/orbit64V2FaceletFixture.jl index 4e3841b..1035a2c 100644 --- a/scripts/orbit64V2FaceletFixture.jl +++ b/scripts/orbit64V2FaceletFixture.jl @@ -125,6 +125,16 @@ for ((n, moves), ids) in rows_by_sequence end sort(collect(keys(ids_by_size))) == collect(2:15) || error("rows for sizes $(sort(collect(keys(ids_by_size)))), expected 2:15") +# Pinned counts of the reference repository's rows: dropping both rows of a move +# sequence leaves the structure above intact, so the counts are fixed here and in +# the test. When the reference adds or removes rows, change them with the input. +const EXPECTED_SEQUENCES = Dict(2 => 32, 3 => 41, 4 => 50, 5 => 59, 6 => 5, 7 => 5, + 8 => 4, 9 => 4, 10 => 4, 11 => 4, 12 => 4, 13 => 4, 14 => 4, 15 => 4) +const EXPECTED_ROWS = 2 * sum(values(EXPECTED_SEQUENCES)) +length(rows) == EXPECTED_ROWS || error("TestV2FaceletData.flix: $(length(rows)) rows, expected $EXPECTED_ROWS") +sequences_per_size = Dict(n => count(k -> k[1] == n, keys(rows_by_sequence)) for n in keys(ids_by_size)) +sequences_per_size == EXPECTED_SEQUENCES || error("TestV2FaceletData.flix: move sequences per size $(sort(collect(sequences_per_size))), expected $(sort(collect(EXPECTED_SEQUENCES)))") + # ---- JSON ---------------------------------------------------------------------- function quoted(text::AbstractString) diff --git a/test/cube/notation/orbit64V2Facelets.test.ts b/test/cube/notation/orbit64V2Facelets.test.ts index b432239..721cdd0 100644 --- a/test/cube/notation/orbit64V2Facelets.test.ts +++ b/test/cube/notation/orbit64V2Facelets.test.ts @@ -183,6 +183,36 @@ describe('Orbit64 V2 facelet reference rows', () => { // The generator checks this too: every move sequence of a size has one row // for each of the two color entries of that size, so a dropped row shows. + // Pinned, because dropping both rows of a move sequence keeps the structure + // below intact. Change them together with the reference input. + it('has the pinned number of rows and move sequences per size', () => { + const sequences: Record = { + 2: 32, + 3: 41, + 4: 50, + 5: 59, + 6: 5, + 7: 5, + 8: 4, + 9: 4, + 10: 4, + 11: 4, + 12: 4, + 13: 4, + 14: 4, + 15: 4, + } + const seen = new Map>() + for (const { id, moves } of rows) { + const n = orbit64V2Entry(id)?.n ?? 0 + seen.set(n, (seen.get(n) ?? new Set()).add(moves)) + } + expect( + Object.fromEntries([...seen].map(([n, set]) => [n, set.size])), + ).toEqual(sequences) + expect(rows).toHaveLength(448) + }) + it('has every move sequence once for each color entry of its size', () => { const entriesOf = new Map>() const bySequence = new Map()