tptimer/pyTwistyScrambler/js_resources/scramble_444.js

2528 lines
69 KiB
JavaScript

"use strict";
var scramble_444 = (function(rn, Cnk, circle) {
function createArray(length1, length2) {
var result, i;
result = new Array(length1);
if (length2 != undefined) {
for (i = 0; i < length1; i++) {
result[i] = new Array(length2);
}
}
return result;
}
var _, seedTable = {},
CM$ = {};
var Q$Object = 0,
Q$Serializable = 30,
Q$Center1 = 21,
Q$CornerCube = 22,
Q$Edge3 = 23,
Q$FullCube_0 = 24,
Q$FullCube_$1 = 25,
Q$Comparable = 34,
Q$Search_0 = 26,
Q$Object_$1 = 40;
function newSeed(id) {
return new seedTable[id];
}
function defineSeed(id, superSeed, castableTypeMap) {
var seed = seedTable[id];
if (seed && !seed.___clazz$) {
_ = seed.prototype;
} else {
!seed && (seed = seedTable[id] = function() {});
_ = seed.prototype = superSeed < 0 ? {} : newSeed(superSeed);
_.castableTypeMap$ = castableTypeMap;
}
for (var i_0 = 3; i_0 < arguments.length; ++i_0) {
arguments[i_0].prototype = _;
}
if (seed.___clazz$) {
_.___clazz$ = seed.___clazz$;
seed.___clazz$ = null;
}
}
function makeCastMap(a) {
var result = {};
for (var i_0 = 0, c = a.length; i_0 < c; ++i_0) {
result[a[i_0]] = 1;
}
return result;
}
function nullMethod() {}
defineSeed(1, -1, CM$);
_.value = null;
function Array_0() {}
function createFrom(array, length_0) {
var a, result;
a = array;
result = createFromSeed(0, length_0);
initValues(a.___clazz$, a.castableTypeMap$, a.queryId$, result);
return result;
}
function createFromSeed(seedType, length_0) {
var array = new Array(length_0);
if (seedType == 3) {
for (var i_0 = 0; i_0 < length_0; ++i_0) {
var value = new Object;
value.l = value.m = value.h = 0;
array[i_0] = value;
}
} else if (seedType > 0) {
var value = [null, 0, false][seedType];
for (var i_0 = 0; i_0 < length_0; ++i_0) {
array[i_0] = value;
}
}
return array;
}
function initDim(arrayClass, castableTypeMap, queryId, length_0, seedType) {
var result;
result = createFromSeed(seedType, length_0);
initValues(arrayClass, castableTypeMap, queryId, result);
return result;
}
// function initDims(arrayClasses, castableTypeMapExprs, queryIdExprs, dimExprs, count, seedType){
// return initDims_0(arrayClasses, castableTypeMapExprs, queryIdExprs, dimExprs, 0, count, seedType);
// }
// function initDims_0(arrayClasses, castableTypeMapExprs, queryIdExprs, dimExprs, index, count, seedType){
// var i_0, isLastDim, length_0, result;
// length_0 = dimExprs[index];
// isLastDim = index == count - 1;
// result = createFromSeed(isLastDim?seedType:0, length_0);
// initValues(arrayClasses[index], castableTypeMapExprs[index], queryIdExprs[index], result);
// if (!isLastDim) {
// ++index;
// for (i_0 = 0; i_0 < length_0; ++i_0) {
// result[i_0] = initDims_0(arrayClasses, castableTypeMapExprs, queryIdExprs, dimExprs, index, count, seedType);
// }
// }
// return result;
// }
function initValues(arrayClass, castableTypeMap, queryId, array) {
$clinit_Array$ExpandoWrapper();
wrapArray(array, expandoNames_0, expandoValues_0);
array.___clazz$ = arrayClass;
array.castableTypeMap$ = castableTypeMap;
array.queryId$ = queryId;
return array;
}
function setCheck(array, index, value) {
return array[index] = value;
}
defineSeed(73, 1, {}, Array_0);
_.queryId$ = 0;
function $clinit_Array$ExpandoWrapper() {
$clinit_Array$ExpandoWrapper = nullMethod;
expandoNames_0 = [];
expandoValues_0 = [];
initExpandos(new Array_0, expandoNames_0, expandoValues_0);
}
function initExpandos(protoType, expandoNames, expandoValues) {
var i_0 = 0,
value;
for (var name_0 in protoType) {
if (value = protoType[name_0]) {
expandoNames[i_0] = name_0;
expandoValues[i_0] = value;
++i_0;
}
}
}
function wrapArray(array, expandoNames, expandoValues) {
$clinit_Array$ExpandoWrapper();
for (var i_0 = 0, c = expandoNames.length; i_0 < c; ++i_0) {
array[expandoNames[i_0]] = expandoValues[i_0];
}
}
var expandoNames_0, expandoValues_0;
function canCast(src, dstId) {
return src.castableTypeMap$ && !!src.castableTypeMap$[dstId];
}
function canCastUnsafe(src, dstId) {
return src.castableTypeMap$ && src.castableTypeMap$[dstId];
}
function instanceOf(src, dstId) {
return src != null && canCast(src, dstId);
}
function $clinit_Center1() {
$clinit_Center1 = nullMethod;
ctsmv = createArray(15582, 36);
sym2raw = createArray(15582);
csprun = createArray(15582);
symmult = createArray(48, 48);
symmove = createArray(48, 36);
syminv = createArray(48);
finish_0 = createArray(48);
}
function $$init_1(this$static) {
this$static.ct = createArray(24);
}
function $equals(this$static, obj) {
var c, i_0;
if (instanceOf(obj, Q$Center1)) {
c = obj;
for (i_0 = 0; i_0 < 24; ++i_0) {
if (this$static.ct[i_0] != c.ct[i_0]) {
return false;
}
}
return true;
}
return false;
}
function $get_1(this$static) {
var i_0, idx, r;
idx = 0;
r = 8;
for (i_0 = 23; i_0 >= 0; --i_0) {
this$static.ct[i_0] == 1 && (idx += Cnk[i_0][r--]);
}
return idx;
}
function $getsym(this$static) {
var cord, j;
if (raw2sym != null) {
return raw2sym[$get_1(this$static)];
}
for (j = 0; j < 48; ++j) {
cord = raw2sym_0($get_1(this$static));
if (cord != -1)
return cord * 64 + j;
$rot(this$static, 0);
j % 2 == 1 && $rot(this$static, 1);
j % 8 == 7 && $rot(this$static, 2);
j % 16 == 15 && $rot(this$static, 3);
}
}
function $move(this$static, m_0) {
var key;
key = m_0 % 3;
m_0 = ~~(m_0 / 3);
switch (m_0) {
case 0:
swap(this$static.ct, 0, 1, 2, 3, key);
break;
case 1:
swap(this$static.ct, 16, 17, 18, 19, key);
break;
case 2:
swap(this$static.ct, 8, 9, 10, 11, key);
break;
case 3:
swap(this$static.ct, 4, 5, 6, 7, key);
break;
case 4:
swap(this$static.ct, 20, 21, 22, 23, key);
break;
case 5:
swap(this$static.ct, 12, 13, 14, 15, key);
break;
case 6:
swap(this$static.ct, 0, 1, 2, 3, key);
swap(this$static.ct, 8, 20, 12, 16, key);
swap(this$static.ct, 9, 21, 13, 17, key);
break;
case 7:
swap(this$static.ct, 16, 17, 18, 19, key);
swap(this$static.ct, 1, 15, 5, 9, key);
swap(this$static.ct, 2, 12, 6, 10, key);
break;
case 8:
swap(this$static.ct, 8, 9, 10, 11, key);
swap(this$static.ct, 2, 19, 4, 21, key);
swap(this$static.ct, 3, 16, 5, 22, key);
break;
case 9:
swap(this$static.ct, 4, 5, 6, 7, key);
swap(this$static.ct, 10, 18, 14, 22, key);
swap(this$static.ct, 11, 19, 15, 23, key);
break;
case 10:
swap(this$static.ct, 20, 21, 22, 23, key);
swap(this$static.ct, 0, 8, 4, 14, key);
swap(this$static.ct, 3, 11, 7, 13, key);
break;
case 11:
swap(this$static.ct, 12, 13, 14, 15, key);
swap(this$static.ct, 1, 20, 7, 18, key);
swap(this$static.ct, 0, 23, 6, 17, key);
}
}
function $rot(this$static, r) {
switch (r) {
case 0:
$move(this$static, 19);
$move(this$static, 28);
break;
case 1:
$move(this$static, 21);
$move(this$static, 32);
break;
case 2:
swap(this$static.ct, 0, 3, 1, 2, 1);
swap(this$static.ct, 8, 11, 9, 10, 1);
swap(this$static.ct, 4, 7, 5, 6, 1);
swap(this$static.ct, 12, 15, 13, 14, 1);
swap(this$static.ct, 16, 19, 21, 22, 1);
swap(this$static.ct, 17, 18, 20, 23, 1);
break;
case 3:
$move(this$static, 18);
$move(this$static, 29);
$move(this$static, 24);
$move(this$static, 35);
}
}
function $rotate(this$static, r) {
var j;
for (j = 0; j < r; ++j) {
$rot(this$static, 0);
j % 2 == 1 && $rot(this$static, 1);
j % 8 == 7 && $rot(this$static, 2);
j % 16 == 15 && $rot(this$static, 3);
}
}
function $set_0(this$static, idx) {
var i_0, r;
r = 8;
for (i_0 = 23; i_0 >= 0; --i_0) {
this$static.ct[i_0] = 0;
if (idx >= Cnk[i_0][r]) {
idx -= Cnk[i_0][r--];
this$static.ct[i_0] = 1;
}
}
}
function $set_1(this$static, c) {
var i_0;
for (i_0 = 0; i_0 < 24; ++i_0) {
this$static.ct[i_0] = c.ct[i_0];
}
}
function Center1_0() {
var i_0;
$$init_1(this);
for (i_0 = 0; i_0 < 8; ++i_0) {
this.ct[i_0] = 1;
}
for (i_0 = 8; i_0 < 24; ++i_0) {
this.ct[i_0] = 0;
}
}
function Center1_1(c, urf) {
var i_0;
$$init_1(this);
for (i_0 = 0; i_0 < 24; ++i_0) {
this.ct[i_0] = (~~(c.ct[i_0] / 2) == urf ? 1 : 0);
}
}
function Center1_2(ct) {
var i_0;
$$init_1(this);
for (i_0 = 0; i_0 < 24; ++i_0) {
this.ct[i_0] = ct[i_0];
}
}
function createMoveTable() {
var c, d, i_0, m_0;
c = new Center1_0;
d = new Center1_0;
for (i_0 = 0; i_0 < 15582; ++i_0) {
$set_0(d, sym2raw[i_0]);
for (m_0 = 0; m_0 < 36; ++m_0) {
$set_1(c, d);
$move(c, m_0);
ctsmv[i_0][m_0] = $getsym(c);
}
}
}
function createPrun() {
var check, depth, done, i_0, idx, inv, m_0, select;
fill_0(csprun);
csprun[0] = 0;
depth = 0;
done = 1;
while (done != 15582) {
inv = depth > 4;
select = inv ? -1 : depth;
check = inv ? depth : -1;
++depth;
for (i_0 = 0; i_0 < 15582; ++i_0) {
if (csprun[i_0] != select) {
continue;
}
for (m_0 = 0; m_0 < 27; ++m_0) {
idx = ~~ctsmv[i_0][m_0] >>> 6;
if (csprun[idx] != check) {
continue;
}
++done;
if (inv) {
csprun[i_0] = depth;
break;
} else {
csprun[idx] = depth;
}
}
}
}
}
function getSolvedSym(cube) {
var c, check, i_0, j;
c = new Center1_2(cube.ct);
for (j = 0; j < 48; ++j) {
check = true;
for (i_0 = 0; i_0 < 24; ++i_0) {
if (c.ct[i_0] != ~~(i_0 / 4)) {
check = false;
break;
}
}
if (check) {
return j;
}
$rot(c, 0);
j % 2 == 1 && $rot(c, 1);
j % 8 == 7 && $rot(c, 2);
j % 16 == 15 && $rot(c, 3);
}
return -1;
}
function initSym_0() {
var c, d, e, f, i_0, j, k_0;
c = new Center1_0;
for (i_0 = 0; i_0 < 24; ++i_0) {
c.ct[i_0] = i_0;
}
d = new Center1_2(c.ct);
e = new Center1_2(c.ct);
f = new Center1_2(c.ct);
for (i_0 = 0; i_0 < 48; ++i_0) {
for (j = 0; j < 48; ++j) {
for (k_0 = 0; k_0 < 48; ++k_0) {
if ($equals(c, d)) {
symmult[i_0][j] = k_0;
k_0 == 0 && (syminv[i_0] = j);
}
$rot(d, 0);
k_0 % 2 == 1 && $rot(d, 1);
k_0 % 8 == 7 && $rot(d, 2);
k_0 % 16 == 15 && $rot(d, 3);
}
$rot(c, 0);
j % 2 == 1 && $rot(c, 1);
j % 8 == 7 && $rot(c, 2);
j % 16 == 15 && $rot(c, 3);
}
$rot(c, 0);
i_0 % 2 == 1 && $rot(c, 1);
i_0 % 8 == 7 && $rot(c, 2);
i_0 % 16 == 15 && $rot(c, 3);
}
for (i_0 = 0; i_0 < 48; ++i_0) {
$set_1(c, e);
$rotate(c, syminv[i_0]);
for (j = 0; j < 36; ++j) {
$set_1(d, c);
$move(d, j);
$rotate(d, i_0);
for (k_0 = 0; k_0 < 36; ++k_0) {
$set_1(f, e);
$move(f, k_0);
if ($equals(f, d)) {
symmove[i_0][j] = k_0;
break;
}
}
}
}
$set_0(c, 0);
for (i_0 = 0; i_0 < 48; ++i_0) {
finish_0[syminv[i_0]] = $get_1(c);
$rot(c, 0);
i_0 % 2 == 1 && $rot(c, 1);
i_0 % 8 == 7 && $rot(c, 2);
i_0 % 16 == 15 && $rot(c, 3);
}
}
function initSym2Raw() {
var c, count, i_0, idx, j, occ;
c = new Center1_0;
occ = createArray(22984);
for (i_0 = 0; i_0 < 22984; i_0++) {
occ[i_0] = 0;
}
count = 0;
for (i_0 = 0; i_0 < 735471; ++i_0) {
if ((occ[~~i_0 >>> 5] & 1 << (i_0 & 31)) == 0) {
$set_0(c, i_0);
for (j = 0; j < 48; ++j) {
idx = $get_1(c);
occ[~~idx >>> 5] |= 1 << (idx & 31);
raw2sym != null && (raw2sym[idx] = count << 6 | syminv[j]);
$rot(c, 0);
j % 2 == 1 && $rot(c, 1);
j % 8 == 7 && $rot(c, 2);
j % 16 == 15 && $rot(c, 3);
}
sym2raw[count++] = i_0;
}
}
}
function raw2sym_0(n) {
var m_0;
m_0 = binarySearch_0(sym2raw, n);
return m_0 >= 0 ? m_0 : -1;
}
defineSeed(153, 1, makeCastMap([Q$Center1]), Center1_0, Center1_1, Center1_2);
var csprun, ctsmv, finish_0, raw2sym = null,
sym2raw, syminv, symmove, symmult;
function $clinit_Center2() {
$clinit_Center2 = nullMethod;
rlmv = createArray(70, 28);
ctmv = createArray(6435, 28);
rlrot = createArray(70, 16);
ctrot = createArray(6435, 16);
ctprun = createArray(450450);
pmv = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0];
}
function $getct(this$static) {
var i_0, idx, r;
idx = 0;
r = 8;
for (i_0 = 14; i_0 >= 0; --i_0) {
this$static.ct[i_0] != this$static.ct[15] && (idx += Cnk[i_0][r--]);
}
return idx;
}
function $getrl(this$static) {
var i_0, idx, r;
idx = 0;
r = 4;
for (i_0 = 6; i_0 >= 0; --i_0) {
this$static.rl[i_0] != this$static.rl[7] && (idx += Cnk[i_0][r--]);
}
return idx * 2 + this$static.parity;
}
function $move_0(this$static, m_0) {
var key;
this$static.parity ^= pmv[m_0];
key = m_0 % 3;
m_0 = ~~(m_0 / 3);
switch (m_0) {
case 0:
swap(this$static.ct, 0, 1, 2, 3, key);
break;
case 1:
swap(this$static.rl, 0, 1, 2, 3, key);
break;
case 2:
swap(this$static.ct, 8, 9, 10, 11, key);
break;
case 3:
swap(this$static.ct, 4, 5, 6, 7, key);
break;
case 4:
swap(this$static.rl, 4, 5, 6, 7, key);
break;
case 5:
swap(this$static.ct, 12, 13, 14, 15, key);
break;
case 6:
swap(this$static.ct, 0, 1, 2, 3, key);
swap(this$static.rl, 0, 5, 4, 1, key);
swap(this$static.ct, 8, 9, 12, 13, key);
break;
case 7:
swap(this$static.rl, 0, 1, 2, 3, key);
swap(this$static.ct, 1, 15, 5, 9, key);
swap(this$static.ct, 2, 12, 6, 10, key);
break;
case 8:
swap(this$static.ct, 8, 9, 10, 11, key);
swap(this$static.rl, 0, 3, 6, 5, key);
swap(this$static.ct, 3, 2, 5, 4, key);
break;
case 9:
swap(this$static.ct, 4, 5, 6, 7, key);
swap(this$static.rl, 3, 2, 7, 6, key);
swap(this$static.ct, 11, 10, 15, 14, key);
break;
case 10:
swap(this$static.rl, 4, 5, 6, 7, key);
swap(this$static.ct, 0, 8, 4, 14, key);
swap(this$static.ct, 3, 11, 7, 13, key);
break;
case 11:
swap(this$static.ct, 12, 13, 14, 15, key);
swap(this$static.rl, 1, 4, 7, 2, key);
swap(this$static.ct, 1, 0, 7, 6, key);
}
}
function $rot_0(this$static, r) {
switch (r) {
case 0:
$move_0(this$static, 19);
$move_0(this$static, 28);
break;
case 1:
$move_0(this$static, 21);
$move_0(this$static, 32);
break;
case 2:
swap(this$static.ct, 0, 3, 1, 2, 1);
swap(this$static.ct, 8, 11, 9, 10, 1);
swap(this$static.ct, 4, 7, 5, 6, 1);
swap(this$static.ct, 12, 15, 13, 14, 1);
swap(this$static.rl, 0, 3, 5, 6, 1);
swap(this$static.rl, 1, 2, 4, 7, 1);
}
}
function $set_2(this$static, c, edgeParity) {
var i_0;
for (i_0 = 0; i_0 < 16; ++i_0) {
this$static.ct[i_0] = ~~(c.ct[i_0] / 2);
}
for (i_0 = 0; i_0 < 8; ++i_0) {
this$static.rl[i_0] = c.ct[i_0 + 16];
}
this$static.parity = edgeParity;
}
function $setct(this$static, idx) {
var i_0, r;
r = 8;
this$static.ct[15] = 0;
for (i_0 = 14; i_0 >= 0; --i_0) {
if (idx >= Cnk[i_0][r]) {
idx -= Cnk[i_0][r--];
this$static.ct[i_0] = 1;
} else {
this$static.ct[i_0] = 0;
}
}
}
function $setrl(this$static, idx) {
var i_0, r;
this$static.parity = idx & 1;
idx >>>= 1;
r = 4;
this$static.rl[7] = 0;
for (i_0 = 6; i_0 >= 0; --i_0) {
if (idx >= Cnk[i_0][r]) {
idx -= Cnk[i_0][r--];
this$static.rl[i_0] = 1;
} else {
this$static.rl[i_0] = 0;
}
}
}
function Center2_0() {
this.rl = createArray(8);
this.ct = createArray(16);
}
function init_3() {
var c, ct, ctx, depth, done, i_0, idx, j, m_0, rl, rlx;
c = new Center2_0;
for (i_0 = 0; i_0 < 70; ++i_0) {
for (m_0 = 0; m_0 < 28; ++m_0) {
$setrl(c, i_0);
$move_0(c, move2std[m_0]);
rlmv[i_0][m_0] = $getrl(c);
}
}
for (i_0 = 0; i_0 < 70; ++i_0) {
$setrl(c, i_0);
for (j = 0; j < 16; ++j) {
rlrot[i_0][j] = $getrl(c);
$rot_0(c, 0);
j % 2 == 1 && $rot_0(c, 1);
j % 8 == 7 && $rot_0(c, 2);
}
}
for (i_0 = 0; i_0 < 6435; ++i_0) {
$setct(c, i_0);
for (j = 0; j < 16; ++j) {
ctrot[i_0][j] = $getct(c) & 65535;
$rot_0(c, 0);
j % 2 == 1 && $rot_0(c, 1);
j % 8 == 7 && $rot_0(c, 2);
}
}
for (i_0 = 0; i_0 < 6435; ++i_0) {
for (m_0 = 0; m_0 < 28; ++m_0) {
$setct(c, i_0);
$move_0(c, move2std[m_0]);
ctmv[i_0][m_0] = $getct(c) & 65535;
}
}
fill_0(ctprun);
ctprun[0] = ctprun[18] = ctprun[28] = ctprun[46] = ctprun[54] = ctprun[56] = 0;
depth = 0;
done = 6;
while (done != 450450) {
var inv = depth > 6;
var select = inv ? -1 : depth;
var check = inv ? depth : -1;
++depth;
for (i_0 = 0; i_0 < 450450; ++i_0) {
if (ctprun[i_0] != select) {
continue;
}
ct = ~~(i_0 / 70);
rl = i_0 % 70;
for (m_0 = 0; m_0 < 23; ++m_0) {
ctx = ctmv[ct][m_0];
rlx = rlmv[rl][m_0];
idx = ctx * 70 + rlx;
if (ctprun[idx] != check) {
continue;
}
++done;
if (inv) {
ctprun[i_0] = depth;
break;
} else {
ctprun[idx] = depth;
}
}
}
}
}
defineSeed(154, 1, {}, Center2_0);
_.parity = 0;
var ctmv, ctprun, ctrot, pmv, rlmv, rlrot;
function $clinit_Center3() {
$clinit_Center3 = nullMethod;
ctmove = createArray(29400, 20);
pmove = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1];
prun_0 = createArray(29400);
rl2std = [0, 9, 14, 23, 27, 28, 41, 42, 46, 55, 60, 69];
std2rl = createArray(70);
}
function $getct_0(this$static) {
var check, i_0, idx, idxrl, r;
idx = 0;
r = 4;
for (i_0 = 6; i_0 >= 0; --i_0) {
this$static.ud[i_0] != this$static.ud[7] && (idx += Cnk[i_0][r--]);
}
idx *= 35;
r = 4;
for (i_0 = 6; i_0 >= 0; --i_0) {
this$static.fb[i_0] != this$static.fb[7] && (idx += Cnk[i_0][r--]);
}
idx *= 12;
check = this$static.fb[7] ^ this$static.ud[7];
idxrl = 0;
r = 4;
for (i_0 = 7; i_0 >= 0; --i_0) {
this$static.rl[i_0] != check && (idxrl += Cnk[i_0][r--]);
}
return this$static.parity + 2 * (idx + std2rl[idxrl]);
}
function $move_1(this$static, i_0) {
this$static.parity ^= pmove[i_0];
switch (i_0) {
case 0:
case 1:
case 2:
swap(this$static.ud, 0, 1, 2, 3, i_0 % 3);
break;
case 3:
swap(this$static.rl, 0, 1, 2, 3, 1);
break;
case 4:
case 5:
case 6:
swap(this$static.fb, 0, 1, 2, 3, (i_0 - 1) % 3);
break;
case 7:
case 8:
case 9:
swap(this$static.ud, 4, 5, 6, 7, (i_0 - 1) % 3);
break;
case 10:
swap(this$static.rl, 4, 5, 6, 7, 1);
break;
case 11:
case 12:
case 13:
swap(this$static.fb, 4, 5, 6, 7, (i_0 + 1) % 3);
break;
case 14:
swap(this$static.ud, 0, 1, 2, 3, 1);
swap(this$static.rl, 0, 5, 4, 1, 1);
swap(this$static.fb, 0, 5, 4, 1, 1);
break;
case 15:
swap(this$static.rl, 0, 1, 2, 3, 1);
swap(this$static.fb, 1, 4, 7, 2, 1);
swap(this$static.ud, 1, 6, 5, 2, 1);
break;
case 16:
swap(this$static.fb, 0, 1, 2, 3, 1);
swap(this$static.ud, 3, 2, 5, 4, 1);
swap(this$static.rl, 0, 3, 6, 5, 1);
break;
case 17:
swap(this$static.ud, 4, 5, 6, 7, 1);
swap(this$static.rl, 3, 2, 7, 6, 1);
swap(this$static.fb, 3, 2, 7, 6, 1);
break;
case 18:
swap(this$static.rl, 4, 5, 6, 7, 1);
swap(this$static.fb, 0, 3, 6, 5, 1);
swap(this$static.ud, 0, 3, 4, 7, 1);
break;
case 19:
swap(this$static.fb, 4, 5, 6, 7, 1);
swap(this$static.ud, 0, 7, 6, 1, 1);
swap(this$static.rl, 1, 4, 7, 2, 1);
}
}
function $set_3(this$static, c, eXc_parity) {
var i_0, parity;
parity = c.ct[0] > c.ct[8] ^ c.ct[8] > c.ct[16] ^ c.ct[0] > c.ct[16] ? 1 : 0;
for (i_0 = 0; i_0 < 8; ++i_0) {
this$static.ud[i_0] = c.ct[i_0] & 1 ^ 1;
this$static.fb[i_0] = c.ct[i_0 + 8] & 1 ^ 1;
this$static.rl[i_0] = c.ct[i_0 + 16] & 1 ^ 1 ^ parity;
}
this$static.parity = parity ^ eXc_parity;
}
function $setct_0(this$static, idx) {
var i_0, idxfb, idxrl, r;
this$static.parity = idx & 1;
idx >>>= 1;
idxrl = rl2std[idx % 12];
idx = ~~(idx / 12);
r = 4;
for (i_0 = 7; i_0 >= 0; --i_0) {
this$static.rl[i_0] = 0;
if (idxrl >= Cnk[i_0][r]) {
idxrl -= Cnk[i_0][r--];
this$static.rl[i_0] = 1;
}
}
idxfb = idx % 35;
idx = ~~(idx / 35);
r = 4;
this$static.fb[7] = 0;
for (i_0 = 6; i_0 >= 0; --i_0) {
if (idxfb >= Cnk[i_0][r]) {
idxfb -= Cnk[i_0][r--];
this$static.fb[i_0] = 1;
} else {
this$static.fb[i_0] = 0;
}
}
r = 4;
this$static.ud[7] = 0;
for (i_0 = 6; i_0 >= 0; --i_0) {
if (idx >= Cnk[i_0][r]) {
idx -= Cnk[i_0][r--];
this$static.ud[i_0] = 1;
} else {
this$static.ud[i_0] = 0;
}
}
}
function Center3_0() {
this.ud = createArray(8);
this.rl = createArray(8);
this.fb = createArray(8);
}
function init_4() {
var c, depth, done, i_0, m_0;
for (i_0 = 0; i_0 < 12; ++i_0) {
std2rl[rl2std[i_0]] = i_0;
}
c = new Center3_0;
for (i_0 = 0; i_0 < 29400; ++i_0) {
for (m_0 = 0; m_0 < 20; ++m_0) {
$setct_0(c, i_0);
$move_1(c, m_0);
ctmove[i_0][m_0] = $getct_0(c) & 65535;
}
}
fill_0(prun_0);
prun_0[0] = 0;
depth = 0;
done = 1;
while (done != 29400) {
for (i_0 = 0; i_0 < 29400; ++i_0) {
if (prun_0[i_0] != depth) {
continue;
}
for (m_0 = 0; m_0 < 17; ++m_0) {
if (prun_0[ctmove[i_0][m_0]] == -1) {
prun_0[ctmove[i_0][m_0]] = depth + 1;
++done;
}
}
}
++depth;
}
}
defineSeed(155, 1, {}, Center3_0);
_.parity = 0;
var ctmove, pmove, prun_0, rl2std, std2rl;
function $clinit_CenterCube() {
$clinit_CenterCube = nullMethod;
center333Map = [0, 4, 2, 1, 5, 3];
}
function $copy_1(this$static, c) {
var i_0;
for (i_0 = 0; i_0 < 24; ++i_0) {
this$static.ct[i_0] = c.ct[i_0];
}
}
function $move_2(this$static, m_0) {
var key;
key = m_0 % 3;
m_0 = ~~(m_0 / 3);
switch (m_0) {
case 0:
swap(this$static.ct, 0, 1, 2, 3, key);
break;
case 1:
swap(this$static.ct, 16, 17, 18, 19, key);
break;
case 2:
swap(this$static.ct, 8, 9, 10, 11, key);
break;
case 3:
swap(this$static.ct, 4, 5, 6, 7, key);
break;
case 4:
swap(this$static.ct, 20, 21, 22, 23, key);
break;
case 5:
swap(this$static.ct, 12, 13, 14, 15, key);
break;
case 6:
swap(this$static.ct, 0, 1, 2, 3, key);
swap(this$static.ct, 8, 20, 12, 16, key);
swap(this$static.ct, 9, 21, 13, 17, key);
break;
case 7:
swap(this$static.ct, 16, 17, 18, 19, key);
swap(this$static.ct, 1, 15, 5, 9, key);
swap(this$static.ct, 2, 12, 6, 10, key);
break;
case 8:
swap(this$static.ct, 8, 9, 10, 11, key);
swap(this$static.ct, 2, 19, 4, 21, key);
swap(this$static.ct, 3, 16, 5, 22, key);
break;
case 9:
swap(this$static.ct, 4, 5, 6, 7, key);
swap(this$static.ct, 10, 18, 14, 22, key);
swap(this$static.ct, 11, 19, 15, 23, key);
break;
case 10:
swap(this$static.ct, 20, 21, 22, 23, key);
swap(this$static.ct, 0, 8, 4, 14, key);
swap(this$static.ct, 3, 11, 7, 13, key);
break;
case 11:
swap(this$static.ct, 12, 13, 14, 15, key);
swap(this$static.ct, 1, 20, 7, 18, key);
swap(this$static.ct, 0, 23, 6, 17, key);
}
}
function CenterCube_0() {
var i_0;
this.ct = createArray(24);
for (i_0 = 0; i_0 < 24; ++i_0) {
this.ct[i_0] = ~~(i_0 / 4);
}
}
function CenterCube_1(r) {
var i_0, m_0, t;
CenterCube_0.call(this);
for (i_0 = 0; i_0 < 23; ++i_0) {
t = i_0 + rn(24 - i_0);
if (this.ct[t] != this.ct[i_0]) {
m_0 = this.ct[i_0];
this.ct[i_0] = this.ct[t];
this.ct[t] = m_0;
}
}
}
defineSeed(156, 1, {}, CenterCube_0, CenterCube_1);
var center333Map;
function $clinit_CornerCube() {
$clinit_CornerCube = nullMethod;
moveCube_0 = createArray(18);
cornerFacelet_0 = [
[8, 9, 20],
[6, 18, 38],
[0, 36, 47],
[2, 45, 11],
[29, 26, 15],
[27, 44, 24],
[33, 53, 42],
[35, 17, 51]
];
initMove_0();
}
function $$init_2(this$static) {
this$static.cp = [0, 1, 2, 3, 4, 5, 6, 7];
this$static.co = [0, 0, 0, 0, 0, 0, 0, 0];
}
function $copy_2(this$static, c) {
var i_0;
for (i_0 = 0; i_0 < 8; ++i_0) {
this$static.cp[i_0] = c.cp[i_0];
this$static.co[i_0] = c.co[i_0];
}
}
function $move_3(this$static, idx) {
!this$static.temps && (this$static.temps = new CornerCube_0);
CornMult_0(this$static, moveCube_0[idx], this$static.temps);
$copy_2(this$static, this$static.temps);
}
function $setTwist_0(this$static, idx) {
var i_0, twst;
twst = 0;
for (i_0 = 6; i_0 >= 0; --i_0) {
twst += this$static.co[i_0] = idx % 3;
idx = ~~(idx / 3);
}
this$static.co[7] = (15 - twst) % 3;
}
function CornMult_0(a, b, prod) {
var corn, ori, oriA, oriB;
for (corn = 0; corn < 8; ++corn) {
prod.cp[corn] = a.cp[b.cp[corn]];
oriA = a.co[b.cp[corn]];
oriB = b.co[corn];
ori = oriA;
ori = ori + (oriA < 3 ? oriB : 6 - oriB);
ori = ori % 3;
oriA >= 3 ^ oriB >= 3 && (ori = ori + 3);
prod.co[corn] = ori;
}
}
function CornerCube_0() {
$$init_2(this);
}
function CornerCube_1(cperm, twist) {
$$init_2(this);
mathlib.set8Perm(this.cp, cperm);
$setTwist_0(this, twist);
}
function CornerCube_2(r) {
CornerCube_1.call(this, rn(40320), rn(2187));
}
function initMove_0() {
var a, p_0;
moveCube_0[0] = new CornerCube_1(15120, 0);
moveCube_0[3] = new CornerCube_1(21021, 1494);
moveCube_0[6] = new CornerCube_1(8064, 1236);
moveCube_0[9] = new CornerCube_1(9, 0);
moveCube_0[12] = new CornerCube_1(1230, 412);
moveCube_0[15] = new CornerCube_1(224, 137);
for (a = 0; a < 18; a += 3) {
for (p_0 = 0; p_0 < 2; ++p_0) {
moveCube_0[a + p_0 + 1] = new CornerCube_0;
CornMult_0(moveCube_0[a + p_0], moveCube_0[a], moveCube_0[a + p_0 + 1]);
}
}
}
defineSeed(157, 1, makeCastMap([Q$CornerCube]), CornerCube_0, CornerCube_1, CornerCube_2);
_.temps = null;
var cornerFacelet_0, moveCube_0;
function $clinit_Edge3() {
$clinit_Edge3 = nullMethod;
prunValues = [1, 4, 16, 55, 324, 1922, 12275, 77640, 485359, 2778197, 11742425, 27492416, 31002941, 31006080];
eprun = createArray(1937880);
sym2raw_0 = createArray(1538);
symstate = createArray(1538);
raw2sym_1 = createArray(11880);
syminv_0 = [0, 1, 6, 3, 4, 5, 2, 7];
mvrot = createArray(160, 12);
mvroto = createArray(160, 12);
factX = [1, 1, 1, 3, 12, 60, 360, 2520, 20160, 181440, 1814400, 19958400, 239500800];
FullEdgeMap = [0, 2, 4, 6, 1, 3, 7, 5, 8, 9, 10, 11];
}
function $circlex(this$static, a, b, c, d) {
var temp;
temp = this$static.edgeo[d];
this$static.edgeo[d] = this$static.edge[c];
this$static.edge[c] = this$static.edgeo[b];
this$static.edgeo[b] = this$static.edge[a];
this$static.edge[a] = temp;
}
function $get_2(this$static, end) {
var i_0, idx, v, valh, vall;
this$static.isStd || $std(this$static);
idx = 0;
vall = 1985229328;
valh = 47768;
for (i_0 = 0; i_0 < end; ++i_0) {
v = this$static.edge[i_0] << 2;
idx *= 12 - i_0;
if (v >= 32) {
idx += valh >> v - 32 & 15;
valh -= 4368 << v - 32;
} else {
idx += vall >> v & 15;
valh -= 4369;
vall -= 286331152 << v;
}
}
return idx;
}
function $getsym_0(this$static) {
var cord1x, cord2x, symcord1x, symx;
cord1x = $get_2(this$static, 4);
symcord1x = raw2sym_1[cord1x];
symx = symcord1x & 7;
symcord1x >>= 3;
$rotate_0(this$static, symx);
cord2x = $get_2(this$static, 10) % 20160;
return symcord1x * 20160 + cord2x;
}
function $move_4(this$static, i_0) {
this$static.isStd = false;
switch (i_0) {
case 0:
circle(this$static.edge, 0, 4, 1, 5);
circle(this$static.edgeo, 0, 4, 1, 5);
break;
case 1:
$swap_0(this$static.edge, 0, 4, 1, 5);
$swap_0(this$static.edgeo, 0, 4, 1, 5);
break;
case 2:
circle(this$static.edge, 0, 5, 1, 4);
circle(this$static.edgeo, 0, 5, 1, 4);
break;
case 3:
$swap_0(this$static.edge, 5, 10, 6, 11);
$swap_0(this$static.edgeo, 5, 10, 6, 11);
break;
case 4:
circle(this$static.edge, 0, 11, 3, 8);
circle(this$static.edgeo, 0, 11, 3, 8);
break;
case 5:
$swap_0(this$static.edge, 0, 11, 3, 8);
$swap_0(this$static.edgeo, 0, 11, 3, 8);
break;
case 6:
circle(this$static.edge, 0, 8, 3, 11);
circle(this$static.edgeo, 0, 8, 3, 11);
break;
case 7:
circle(this$static.edge, 2, 7, 3, 6);
circle(this$static.edgeo, 2, 7, 3, 6);
break;
case 8:
$swap_0(this$static.edge, 2, 7, 3, 6);
$swap_0(this$static.edgeo, 2, 7, 3, 6);
break;
case 9:
circle(this$static.edge, 2, 6, 3, 7);
circle(this$static.edgeo, 2, 6, 3, 7);
break;
case 10:
$swap_0(this$static.edge, 4, 8, 7, 9);
$swap_0(this$static.edgeo, 4, 8, 7, 9);
break;
case 11:
circle(this$static.edge, 1, 9, 2, 10);
circle(this$static.edgeo, 1, 9, 2, 10);
break;
case 12:
$swap_0(this$static.edge, 1, 9, 2, 10);
$swap_0(this$static.edgeo, 1, 9, 2, 10);
break;
case 13:
circle(this$static.edge, 1, 10, 2, 9);
circle(this$static.edgeo, 1, 10, 2, 9);
break;
case 14:
$swap_0(this$static.edge, 0, 4, 1, 5);
$swap_0(this$static.edgeo, 0, 4, 1, 5);
circle(this$static.edge, 9, 11);
circle(this$static.edgeo, 8, 10);
break;
case 15:
$swap_0(this$static.edge, 5, 10, 6, 11);
$swap_0(this$static.edgeo, 5, 10, 6, 11);
circle(this$static.edge, 1, 3);
circle(this$static.edgeo, 0, 2);
break;
case 16:
$swap_0(this$static.edge, 0, 11, 3, 8);
$swap_0(this$static.edgeo, 0, 11, 3, 8);
circle(this$static.edge, 5, 7);
circle(this$static.edgeo, 4, 6);
break;
case 17:
$swap_0(this$static.edge, 2, 7, 3, 6);
$swap_0(this$static.edgeo, 2, 7, 3, 6);
circle(this$static.edge, 8, 10);
circle(this$static.edgeo, 9, 11);
break;
case 18:
$swap_0(this$static.edge, 4, 8, 7, 9);
$swap_0(this$static.edgeo, 4, 8, 7, 9);
circle(this$static.edge, 0, 2);
circle(this$static.edgeo, 1, 3);
break;
case 19:
$swap_0(this$static.edge, 1, 9, 2, 10);
$swap_0(this$static.edgeo, 1, 9, 2, 10);
circle(this$static.edge, 4, 6);
circle(this$static.edgeo, 5, 7);
}
}
function $rot_1(this$static, r) {
this$static.isStd = false;
switch (r) {
case 0:
$move_4(this$static, 14);
$move_4(this$static, 17);
break;
case 1:
$circlex(this$static, 11, 5, 10, 6);
$circlex(this$static, 5, 10, 6, 11);
$circlex(this$static, 1, 2, 3, 0);
$circlex(this$static, 4, 9, 7, 8);
$circlex(this$static, 8, 4, 9, 7);
$circlex(this$static, 0, 1, 2, 3);
break;
case 2:
$swapx(this$static, 4, 5);
$swapx(this$static, 5, 4);
$swapx(this$static, 11, 8);
$swapx(this$static, 8, 11);
$swapx(this$static, 7, 6);
$swapx(this$static, 6, 7);
$swapx(this$static, 9, 10);
$swapx(this$static, 10, 9);
$swapx(this$static, 1, 1);
$swapx(this$static, 0, 0);
$swapx(this$static, 3, 3);
$swapx(this$static, 2, 2);
}
}
function $rotate_0(this$static, r) {
while (r >= 2) {
r -= 2;
$rot_1(this$static, 1);
$rot_1(this$static, 2);
}
r != 0 && $rot_1(this$static, 0);
}
function $set_4(this$static, idx) {
var i_0, p_0, parity, v, vall, valh;
vall = 0x76543210;
valh = 0xba98;
parity = 0;
for (i_0 = 0; i_0 < 11; ++i_0) {
p_0 = factX[11 - i_0];
v = ~~(idx / p_0);
idx = idx % p_0;
parity ^= v;
v <<= 2;
if (v >= 32) {
v = v - 32;
this$static.edge[i_0] = valh >> v & 15;
var m = (1 << v) - 1;
valh = (valh & m) + ((valh >> 4) & ~m);
} else {
this$static.edge[i_0] = vall >> v & 15;
var m = (1 << v) - 1;
vall = (vall & m) + ((vall >>> 4) & ~m) + (valh << 28);
valh = valh >> 4;
}
}
if ((parity & 1) == 0) {
this$static.edge[11] = vall;
} else {
this$static.edge[11] = this$static.edge[10];
this$static.edge[10] = vall;
}
for (i_0 = 0; i_0 < 12; ++i_0) {
this$static.edgeo[i_0] = i_0;
}
this$static.isStd = true;
}
function $set_5(this$static, e) {
var i_0;
for (i_0 = 0; i_0 < 12; ++i_0) {
this$static.edge[i_0] = e.edge[i_0];
this$static.edgeo[i_0] = e.edgeo[i_0];
}
this$static.isStd = e.isStd;
}
function $set_6(this$static, c) {
var i_0, parity, s, t;
this$static.temp == null && (this$static.temp = createArray(12));
for (i_0 = 0; i_0 < 12; ++i_0) {
this$static.temp[i_0] = i_0;
this$static.edge[i_0] = c.ep[FullEdgeMap[i_0] + 12] % 12;
}
parity = 1;
for (i_0 = 0; i_0 < 12; ++i_0) {
while (this$static.edge[i_0] != i_0) {
t = this$static.edge[i_0];
this$static.edge[i_0] = this$static.edge[t];
this$static.edge[t] = t;
s = this$static.temp[i_0];
this$static.temp[i_0] = this$static.temp[t];
this$static.temp[t] = s;
parity ^= 1;
}
}
for (i_0 = 0; i_0 < 12; ++i_0) {
this$static.edge[i_0] = this$static.temp[c.ep[FullEdgeMap[i_0]] % 12];
}
return parity;
}
function $std(this$static) {
var i_0;
this$static.temp == null && (this$static.temp = createArray(12));
for (i_0 = 0; i_0 < 12; ++i_0) {
this$static.temp[this$static.edgeo[i_0]] = i_0;
}
for (i_0 = 0; i_0 < 12; ++i_0) {
this$static.edge[i_0] = this$static.temp[this$static.edge[i_0]];
this$static.edgeo[i_0] = i_0;
}
this$static.isStd = true;
}
function $swap_0(arr, a, b, c, d) {
var temp;
temp = arr[a];
arr[a] = arr[c];
arr[c] = temp;
temp = arr[b];
arr[b] = arr[d];
arr[d] = temp;
}
function $swapx(this$static, x, y) {
var temp;
temp = this$static.edge[x];
this$static.edge[x] = this$static.edgeo[y];
this$static.edgeo[y] = temp;
}
function Edge3_0() {
this.edge = createArray(12);
this.edgeo = createArray(12);
}
function createPrun_0() {
var chk, cord1, cord1x, cord2, cord2x, dep1m3, depm3, depth, e, end, f, find_0, g, i_0, i_, idx, idxx, inv, j, m_0, symState, symcord1, symcord1x, symx, val;
e = new Edge3_0;
f = new Edge3_0;
g = new Edge3_0;
fill_0(eprun);
depth = 0;
done_0 = 1;
setPruning_0(eprun, 0, 0);
// var start = +new Date;
while (done_0 != 31006080) {
inv = depth > 9;
depm3 = depth % 3;
dep1m3 = (depth + 1) % 3;
find_0 = inv ? 3 : depm3;
chk = inv ? depm3 : 3;
if (depth >= 9) {
break;
}
for (i_ = 0; i_ < 31006080; i_ += 16) {
val = eprun[~~i_ >> 4];
if (!inv && val == -1) {
continue;
}
for (i_0 = i_, end = i_ + 16; i_0 < end; ++i_0, val >>= 2) {
if ((val & 3) != find_0) {
continue;
}
symcord1 = ~~(i_0 / 20160);
cord1 = sym2raw_0[symcord1];
cord2 = i_0 % 20160;
$set_4(e, cord1 * 20160 + cord2);
for (m_0 = 0; m_0 < 17; ++m_0) {
cord1x = getmvrot(e.edge, m_0 << 3, 4);
symcord1x = raw2sym_1[cord1x];
symx = symcord1x & 7;
symcord1x >>= 3;
cord2x = getmvrot(e.edge, m_0 << 3 | symx, 10) % 20160;
idx = symcord1x * 20160 + cord2x;
if (getPruning_0(eprun, idx) != chk) {
continue;
}
setPruning_0(eprun, inv ? i_0 : idx, dep1m3);
++done_0;
if (inv) {
break;
}
symState = symstate[symcord1x];
if (symState == 1) {
continue;
}
$set_5(f, e);
$move_4(f, m_0);
$rotate_0(f, symx);
for (j = 1;
(symState = ~~symState >> 1 & 65535) != 0; ++j) {
if ((symState & 1) != 1) {
continue;
}
$set_5(g, f);
$rotate_0(g, j);
idxx = symcord1x * 20160 + $get_2(g, 10) % 20160;
if (getPruning_0(eprun, idxx) == chk) {
setPruning_0(eprun, idxx, dep1m3);
++done_0;
}
}
}
}
}
++depth;
// console.log(depth + '\t' + done_0 + '\t' + (+new Date - start));
}
}
function getPruning_0(table, index) {
return table[index >> 4] >> ((index & 15) << 1) & 3;
}
function getmvrot(ep, mrIdx, end) {
var i_0, idx, mov, movo, v, valh, vall;
movo = mvroto[mrIdx];
mov = mvrot[mrIdx];
idx = 0;
vall = 1985229328;
valh = 47768;
for (i_0 = 0; i_0 < end; ++i_0) {
v = movo[ep[mov[i_0]]] << 2;
idx *= 12 - i_0;
if (v >= 32) {
idx += valh >> v - 32 & 15;
valh -= 4368 << v - 32;
} else {
idx += vall >> v & 15;
valh -= 4369;
vall -= 286331152 << v;
}
}
return idx;
}
function getprun(edge) {
var cord1, cord1x, cord2, cord2x, depm3, depth, e, idx, m_0, symcord1, symcord1x, symx;
e = new Edge3_0;
depth = 0;
depm3 = getPruning_0(eprun, edge);
if (depm3 == 3) {
return 10;
}
while (edge != 0) {
depm3 == 0 ? (depm3 = 2) : --depm3;
symcord1 = ~~(edge / 20160);
cord1 = sym2raw_0[symcord1];
cord2 = edge % 20160;
$set_4(e, cord1 * 20160 + cord2);
for (m_0 = 0; m_0 < 17; ++m_0) {
cord1x = getmvrot(e.edge, m_0 << 3, 4);
symcord1x = raw2sym_1[cord1x];
symx = symcord1x & 7;
symcord1x >>= 3;
cord2x = getmvrot(e.edge, m_0 << 3 | symx, 10) % 20160;
idx = symcord1x * 20160 + cord2x;
if (getPruning_0(eprun, idx) == depm3) {
++depth;
edge = idx;
break;
}
}
}
return depth;
}
function getprun_0(edge, prun) {
var depm3;
depm3 = getPruning_0(eprun, edge);
if (depm3 == 3) {
return 10;
}
return ((0x49249249 << depm3 >> prun) & 3) + prun - 1;
// (depm3 - prun + 16) % 3 + prun - 1;
}
function initMvrot() {
var e, i_0, m_0, r;
e = new Edge3_0;
for (m_0 = 0; m_0 < 20; ++m_0) {
for (r = 0; r < 8; ++r) {
$set_4(e, 0);
$move_4(e, m_0);
$rotate_0(e, r);
for (i_0 = 0; i_0 < 12; ++i_0) {
mvrot[m_0 << 3 | r][i_0] = e.edge[i_0];
}
$std(e);
for (i_0 = 0; i_0 < 12; ++i_0) {
mvroto[m_0 << 3 | r][i_0] = e.temp[i_0];
}
}
}
}
function initRaw2Sym() {
var count, e, i_0, idx, j, occ;
e = new Edge3_0;
occ = createArray(1485);
for (i_0 = 0; i_0 < 1485; i_0++) {
occ[i_0] = 0;
}
count = 0;
for (i_0 = 0; i_0 < 11880; ++i_0) {
if ((occ[~~i_0 >>> 3] & 1 << (i_0 & 7)) == 0) {
$set_4(e, i_0 * factX[8]);
for (j = 0; j < 8; ++j) {
idx = $get_2(e, 4);
idx == i_0 && (symstate[count] = (symstate[count] | 1 << j) & 65535);
occ[~~idx >> 3] = (occ[~~idx >> 3] | 1 << (idx & 7));
raw2sym_1[idx] = count << 3 | syminv_0[j];
$rot_1(e, 0);
if (j % 2 == 1) {
$rot_1(e, 1);
$rot_1(e, 2);
}
}
sym2raw_0[count++] = i_0;
}
}
}
function setPruning_0(table, index, value) {
table[index >> 4] ^= (3 ^ value) << ((index & 15) << 1);
}
defineSeed(158, 1, makeCastMap([Q$Edge3]), Edge3_0);
_.isStd = true;
_.temp = null;
var FullEdgeMap, done_0 = 0,
eprun, factX, mvrot, mvroto, prunValues, raw2sym_1, sym2raw_0, syminv_0, symstate;
function $clinit_EdgeCube() {
$clinit_EdgeCube = nullMethod;
EdgeColor = [
[2, 0],
[5, 0],
[3, 0],
[4, 0],
[3, 1],
[5, 1],
[2, 1],
[4, 1],
[2, 5],
[3, 5],
[3, 4],
[2, 4]
];
EdgeMap = [19, 37, 46, 10, 52, 43, 25, 16, 21, 50, 48, 23, 7, 3, 1, 5, 34, 30, 28, 32, 41, 39, 14, 12];
}
function $checkEdge(this$static) {
var ck, i_0, parity;
ck = 0;
parity = false;
for (i_0 = 0; i_0 < 12; ++i_0) {
ck |= 1 << this$static.ep[i_0];
parity = parity != this$static.ep[i_0] >= 12;
}
ck &= ~~ck >> 12;
return ck == 0 && !parity;
}
function $copy_3(this$static, c) {
var i_0;
for (i_0 = 0; i_0 < 24; ++i_0) {
this$static.ep[i_0] = c.ep[i_0];
}
}
function $move_5(this$static, m_0) {
var key;
key = m_0 % 3;
m_0 = ~~(m_0 / 3);
switch (m_0) {
case 0:
swap(this$static.ep, 0, 1, 2, 3, key);
swap(this$static.ep, 12, 13, 14, 15, key);
break;
case 1:
swap(this$static.ep, 11, 15, 10, 19, key);
swap(this$static.ep, 23, 3, 22, 7, key);
break;
case 2:
swap(this$static.ep, 0, 11, 6, 8, key);
swap(this$static.ep, 12, 23, 18, 20, key);
break;
case 3:
swap(this$static.ep, 4, 5, 6, 7, key);
swap(this$static.ep, 16, 17, 18, 19, key);
break;
case 4:
swap(this$static.ep, 1, 20, 5, 21, key);
swap(this$static.ep, 13, 8, 17, 9, key);
break;
case 5:
swap(this$static.ep, 2, 9, 4, 10, key);
swap(this$static.ep, 14, 21, 16, 22, key);
break;
case 6:
swap(this$static.ep, 0, 1, 2, 3, key);
swap(this$static.ep, 12, 13, 14, 15, key);
swap(this$static.ep, 9, 22, 11, 20, key);
break;
case 7:
swap(this$static.ep, 11, 15, 10, 19, key);
swap(this$static.ep, 23, 3, 22, 7, key);
swap(this$static.ep, 2, 16, 6, 12, key);
break;
case 8:
swap(this$static.ep, 0, 11, 6, 8, key);
swap(this$static.ep, 12, 23, 18, 20, key);
swap(this$static.ep, 3, 19, 5, 13, key);
break;
case 9:
swap(this$static.ep, 4, 5, 6, 7, key);
swap(this$static.ep, 16, 17, 18, 19, key);
swap(this$static.ep, 8, 23, 10, 21, key);
break;
case 10:
swap(this$static.ep, 1, 20, 5, 21, key);
swap(this$static.ep, 13, 8, 17, 9, key);
swap(this$static.ep, 14, 0, 18, 4, key);
break;
case 11:
swap(this$static.ep, 2, 9, 4, 10, key);
swap(this$static.ep, 14, 21, 16, 22, key);
swap(this$static.ep, 7, 15, 1, 17, key);
}
}
function EdgeCube_0() {
var i_0;
this.ep = createArray(24);
for (i_0 = 0; i_0 < 24; ++i_0) {
this.ep[i_0] = i_0;
}
}
function EdgeCube_1(r) {
var i_0, m_0, t;
EdgeCube_0.call(this);
for (i_0 = 0; i_0 < 23; ++i_0) {
t = i_0 + rn(24 - i_0);
if (t != i_0) {
m_0 = this.ep[i_0];
this.ep[i_0] = this.ep[t];
this.ep[t] = m_0;
}
}
}
defineSeed(159, 1, {}, EdgeCube_0, EdgeCube_1);
var EdgeColor, EdgeMap;
function $clinit_FullCube_0() {
$clinit_FullCube_0 = nullMethod;
move2rot = [35, 1, 34, 2, 4, 6, 22, 5, 19];
}
function $$init_3(this$static) {
this$static.moveBuffer = createArray(60);
}
function $compareTo_1(this$static, c) {
return this$static.value - c.value;
}
function $copy_4(this$static, c) {
var i_0;
$copy_3(this$static.edge, c.edge);
$copy_1(this$static.center, c.center);
$copy_2(this$static.corner, c.corner);
this$static.value = c.value;
this$static.add1 = c.add1;
this$static.length1 = c.length1;
this$static.length2 = c.length2;
this$static.length3 = c.length3;
this$static.sym = c.sym;
for (i_0 = 0; i_0 < 60; ++i_0) {
this$static.moveBuffer[i_0] = c.moveBuffer[i_0];
}
this$static.moveLength = c.moveLength;
this$static.edgeAvail = c.edgeAvail;
this$static.centerAvail = c.centerAvail;
this$static.cornerAvail = c.cornerAvail;
}
function $getCenter(this$static) {
while (this$static.centerAvail < this$static.moveLength) {
$move_2(this$static.center, this$static.moveBuffer[this$static.centerAvail++]);
}
return this$static.center;
}
function $getCorner(this$static) {
while (this$static.cornerAvail < this$static.moveLength) {
$move_3(this$static.corner, this$static.moveBuffer[this$static.cornerAvail++] % 18);
}
return this$static.corner;
}
function $getEdge(this$static) {
while (this$static.edgeAvail < this$static.moveLength) {
$move_5(this$static.edge, this$static.moveBuffer[this$static.edgeAvail++]);
}
return this$static.edge;
}
function $getMoveString(this$static) {
var finishSym, fixedMoves, i_0, idx, move, rot, sb, sym;
fixedMoves = new Array(this$static.moveLength - (this$static.add1 ? 2 : 0));
idx = 0;
for (i_0 = 0; i_0 < this$static.length1; ++i_0) {
fixedMoves[idx++] = this$static.moveBuffer[i_0];
}
sym = this$static.sym;
for (i_0 = this$static.length1 + (this$static.add1 ? 2 : 0); i_0 < this$static.moveLength; ++i_0) {
if (symmove[sym][this$static.moveBuffer[i_0]] >= 27) {
fixedMoves[idx++] = symmove[sym][this$static.moveBuffer[i_0]] - 9;
rot = move2rot[symmove[sym][this$static.moveBuffer[i_0]] - 27];
sym = symmult[sym][rot];
} else {
fixedMoves[idx++] = symmove[sym][this$static.moveBuffer[i_0]];
}
}
finishSym = symmult[syminv[sym]][getSolvedSym($getCenter(this$static))];
sb = "";
sym = finishSym;
for (i_0 = idx - 1; i_0 >= 0; --i_0) {
move = fixedMoves[i_0];
move = ~~(move / 3) * 3 + (2 - move % 3);
if (symmove[sym][move] >= 27) {
sb = sb + move2str_1[symmove[sym][move] - 9] + ' ';
rot = move2rot[symmove[sym][move] - 27];
sym = symmult[sym][rot];
} else {
sb = sb + move2str_1[symmove[sym][move]] + ' ';
}
}
return sb;
}
function $move_6(this$static, m_0) {
this$static.moveBuffer[this$static.moveLength++] = m_0;
return;
}
function FullCube_3() {
$$init_3(this);
this.edge = new EdgeCube_0;
this.center = new CenterCube_0;
this.corner = new CornerCube_0;
}
function FullCube_4(c) {
FullCube_3.call(this);
$copy_4(this, c);
}
function FullCube_5(r) {
$$init_3(this);
this.edge = new EdgeCube_1(r);
this.center = new CenterCube_1(r);
this.corner = new CornerCube_2(r);
}
defineSeed(160, 1, makeCastMap([Q$FullCube_0, Q$Comparable]), FullCube_3, FullCube_4, FullCube_5);
_.compareTo$ = function compareTo_1(c) {
return $compareTo_1(this, c);
};
_.add1 = false;
_.center = null;
_.centerAvail = 0;
_.corner = null;
_.cornerAvail = 0;
_.edge = null;
_.edgeAvail = 0;
_.length1 = 0;
_.length2 = 0;
_.length3 = 0;
_.moveLength = 0;
_.sym = 0;
_.value = 0;
var move2rot;
function $compare(c1, c2) {
return c2.value - c1.value;
}
function $compare_0(c1, c2) {
return $compare(c1, c2);
}
function FullCube$ValueComparator_0() {}
defineSeed(161, 1, {}, FullCube$ValueComparator_0);
_.compare = function compare(c1, c2) {
return $compare_0(c1, c2);
};
function $clinit_Moves() {
$clinit_Moves = nullMethod;
var i_0, j;
move2str_1 = ['U ', 'U2 ', "U' ", 'R ', 'R2 ', "R' ", 'F ', 'F2 ', "F' ", 'D ', 'D2 ', "D' ", 'L ', 'L2 ', "L' ", 'B ', 'B2 ', "B' ", 'Uw ', 'Uw2', "Uw'", 'Rw ', 'Rw2', "Rw'", 'Fw ', 'Fw2', "Fw'", 'Dw ', 'Dw2', "Dw'", 'Lw ', 'Lw2', "Lw'", 'Bw ', 'Bw2', "Bw'"];
move2std = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 19, 21, 22, 23, 25, 28, 30, 31, 32, 34, 36];
move3std = [0, 1, 2, 4, 6, 7, 8, 9, 10, 11, 13, 15, 16, 17, 19, 22, 25, 28, 31, 34, 36];
std2move = createArray(37);
std3move = createArray(37);
ckmv = createArray(37, 36);
ckmv2_0 = createArray(29, 28);
ckmv3 = createArray(21, 20);
skipAxis = createArray(36);
skipAxis2 = createArray(28);
skipAxis3 = createArray(20);
for (i_0 = 0; i_0 < 29; ++i_0) {
std2move[move2std[i_0]] = i_0;
}
for (i_0 = 0; i_0 < 21; ++i_0) {
std3move[move3std[i_0]] = i_0;
}
for (i_0 = 0; i_0 < 36; ++i_0) {
for (j = 0; j < 36; ++j) {
ckmv[i_0][j] = ~~(i_0 / 3) == ~~(j / 3) || ~~(i_0 / 3) % 3 == ~~(j / 3) % 3 && i_0 > j;
}
ckmv[36][i_0] = false;
}
for (i_0 = 0; i_0 < 29; ++i_0) {
for (j = 0; j < 28; ++j) {
ckmv2_0[i_0][j] = ckmv[move2std[i_0]][move2std[j]];
}
}
for (i_0 = 0; i_0 < 21; ++i_0) {
for (j = 0; j < 20; ++j) {
ckmv3[i_0][j] = ckmv[move3std[i_0]][move3std[j]];
}
}
for (i_0 = 0; i_0 < 36; ++i_0) {
skipAxis[i_0] = 36;
for (j = i_0; j < 36; ++j) {
if (!ckmv[i_0][j]) {
skipAxis[i_0] = j - 1;
break;
}
}
}
for (i_0 = 0; i_0 < 28; ++i_0) {
skipAxis2[i_0] = 28;
for (j = i_0; j < 28; ++j) {
if (!ckmv2_0[i_0][j]) {
skipAxis2[i_0] = j - 1;
break;
}
}
}
for (i_0 = 0; i_0 < 20; ++i_0) {
skipAxis3[i_0] = 20;
for (j = i_0; j < 20; ++j) {
if (!ckmv3[i_0][j]) {
skipAxis3[i_0] = j - 1;
break;
}
}
}
}
var ckmv, ckmv2_0, ckmv3, move2std, move2str_1, move3std, skipAxis, skipAxis2, skipAxis3, std2move, std3move;
function $doSearch(this$static) {
var MAX_LENGTH2, MAX_LENGTH3, ct, edge, eparity, fb, fbprun, i_0, index, length_0, length12, length123, p1SolsArr, prun, rl, rlprun, s2ct, s2rl, solcube, ud, udprun;
this$static.solution = '';
ud = $getsym(new Center1_1($getCenter(this$static.c), 0));
fb = $getsym(new Center1_1($getCenter(this$static.c), 1));
rl = $getsym(new Center1_1($getCenter(this$static.c), 2));
udprun = csprun[~~ud >> 6];
fbprun = csprun[~~fb >> 6];
rlprun = csprun[~~rl >> 6];
this$static.p1SolsCnt = 0;
this$static.arr2idx = 0;
$clear(this$static.p1sols.heap);
for (this$static.length1 = (udprun < fbprun ? udprun : fbprun) < rlprun ? udprun < fbprun ? udprun : fbprun : rlprun; this$static.length1 < 100; ++this$static.length1) {
if (rlprun <= this$static.length1 && $search1(this$static, ~~rl >>> 6, rl & 63, this$static.length1, -1, 0) || udprun <= this$static.length1 && $search1(this$static, ~~ud >>> 6, ud & 63, this$static.length1, -1, 0) || fbprun <= this$static.length1 && $search1(this$static, ~~fb >>> 6, fb & 63, this$static.length1, -1, 0)) {
break;
}
}
p1SolsArr = $toArray_1(this$static.p1sols, initDim(_3Lcs_threephase_FullCube_2_classLit, makeCastMap([Q$FullCube_$1, Q$Serializable, Q$Object_$1]), Q$FullCube_0, 0, 0));
p1SolsArr.sort(function(a, b) {
return a.value - b.value
});
MAX_LENGTH2 = 9;
do {
OUT: for (length12 = p1SolsArr[0].value; length12 < 100; ++length12) {
for (i_0 = 0; i_0 < p1SolsArr.length; ++i_0) {
if (p1SolsArr[i_0].value > length12) {
break;
}
if (length12 - p1SolsArr[i_0].length1 > MAX_LENGTH2) {
continue;
}
$copy_4(this$static.c1, p1SolsArr[i_0]);
$set_2(this$static.ct2, $getCenter(this$static.c1), parity_0($getEdge(this$static.c1).ep));
s2ct = $getct(this$static.ct2);
s2rl = $getrl(this$static.ct2);
this$static.length1 = p1SolsArr[i_0].length1;
this$static.length2 = length12 - p1SolsArr[i_0].length1;
if ($search2(this$static, s2ct, s2rl, this$static.length2, 28, 0)) {
break OUT;
}
}
}
++MAX_LENGTH2;
} while (length12 == 100);
this$static.arr2.sort(function(a, b) {
return a.value - b.value
});
index = 0;
MAX_LENGTH3 = 13;
do {
OUT2: for (length123 = this$static.arr2[0].value; length123 < 100; ++length123) {
for (i_0 = 0; i_0 < Math.min(this$static.arr2idx, 100); ++i_0) {
if (this$static.arr2[i_0].value > length123) {
break;
}
if (length123 - this$static.arr2[i_0].length1 - this$static.arr2[i_0].length2 > MAX_LENGTH3) {
continue;
}
eparity = $set_6(this$static.e12, $getEdge(this$static.arr2[i_0]));
$set_3(this$static.ct3, $getCenter(this$static.arr2[i_0]), eparity ^ parity_0($getCorner(this$static.arr2[i_0]).cp));
ct = $getct_0(this$static.ct3);
edge = $get_2(this$static.e12, 10);
prun = getprun($getsym_0(this$static.e12));
if (prun <= length123 - this$static.arr2[i_0].length1 - this$static.arr2[i_0].length2 && $search3(this$static, edge, ct, prun, length123 - this$static.arr2[i_0].length1 - this$static.arr2[i_0].length2, 20, 0)) {
index = i_0;
break OUT2;
}
}
}
++MAX_LENGTH3;
}
while (length123 == 100);
solcube = new FullCube_4(this$static.arr2[index]);
this$static.length1 = solcube.length1;
this$static.length2 = solcube.length2;
length_0 = length123 - this$static.length1 - this$static.length2;
for (i_0 = 0; i_0 < length_0; ++i_0) {
$move_6(solcube, move3std[this$static.move3[i_0]]);
}
this$static.solution = $getMoveString(solcube);
}
function $init2_0(this$static, sym) {
var ctp, i_0, next, s2ct, s2rl;
$copy_4(this$static.c1, this$static.c);
for (i_0 = 0; i_0 < this$static.length1; ++i_0) {
$move_6(this$static.c1, this$static.move1[i_0]);
}
switch (finish_0[sym]) {
case 0:
$move_6(this$static.c1, 24);
$move_6(this$static.c1, 35);
this$static.move1[this$static.length1] = 24;
this$static.move1[this$static.length1 + 1] = 35;
this$static.add1 = true;
sym = 19;
break;
case 12869:
$move_6(this$static.c1, 18);
$move_6(this$static.c1, 29);
this$static.move1[this$static.length1] = 18;
this$static.move1[this$static.length1 + 1] = 29;
this$static.add1 = true;
sym = 34;
break;
case 735470:
this$static.add1 = false;
sym = 0;
}
$set_2(this$static.ct2, $getCenter(this$static.c1), parity_0($getEdge(this$static.c1).ep));
s2ct = $getct(this$static.ct2);
s2rl = $getrl(this$static.ct2);
ctp = ctprun[s2ct * 70 + s2rl];
this$static.c1.value = ctp + this$static.length1;
this$static.c1.length1 = this$static.length1;
this$static.c1.add1 = this$static.add1;
this$static.c1.sym = sym;
++this$static.p1SolsCnt;
if (this$static.p1sols.heap.size < 500) {
next = new FullCube_4(this$static.c1);
} else {
next = $poll(this$static.p1sols);
next.value > this$static.c1.value && $copy_4(next, this$static.c1);
}
$add(this$static.p1sols, next);
return this$static.p1SolsCnt == 10000;
}
function $init3(this$static) {
var ct, eparity, i_0, prun;
$copy_4(this$static.c2, this$static.c1);
for (i_0 = 0; i_0 < this$static.length2; ++i_0) {
$move_6(this$static.c2, this$static.move2[i_0]);
}
if (!$checkEdge($getEdge(this$static.c2))) {
return false;
}
eparity = $set_6(this$static.e12, $getEdge(this$static.c2));
$set_3(this$static.ct3, $getCenter(this$static.c2), eparity ^ parity_0($getCorner(this$static.c2).cp));
ct = $getct_0(this$static.ct3);
$get_2(this$static.e12, 10);
prun = getprun($getsym_0(this$static.e12));
!this$static.arr2[this$static.arr2idx] ? (this$static.arr2[this$static.arr2idx] = new FullCube_4(this$static.c2)) : $copy_4(this$static.arr2[this$static.arr2idx], this$static.c2);
this$static.arr2[this$static.arr2idx].value = this$static.length1 + this$static.length2 + Math.max(prun, prun_0[ct]);
this$static.arr2[this$static.arr2idx].length2 = this$static.length2;
++this$static.arr2idx;
return this$static.arr2idx == this$static.arr2.length;
}
function $randomState(this$static, r) {
init_5();
this$static.c = new FullCube_5(r);
$doSearch(this$static);
return this$static.solution;
}
function $search1(this$static, ct, sym, maxl, lm, depth) {
var axis, ctx, m_0, power, prun, symx;
if (ct == 0) {
return maxl == 0 && $init2_0(this$static, sym);
}
for (axis = 0; axis < 27; axis += 3) {
if (axis == lm || axis == lm - 9 || axis == lm - 18) {
continue;
}
for (power = 0; power < 3; ++power) {
m_0 = axis + power;
ctx = ctsmv[ct][symmove[sym][m_0]];
prun = csprun[~~ctx >>> 6];
if (prun >= maxl) {
if (prun > maxl) {
break;
}
continue;
}
symx = symmult[sym][ctx & 63];
ctx >>>= 6;
this$static.move1[depth] = m_0;
if ($search1(this$static, ctx, symx, maxl - 1, axis, depth + 1)) {
return true;
}
}
}
return false;
}
function $search2(this$static, ct, rl, maxl, lm, depth) {
var ctx, m_0, prun, rlx;
if (ct == 0 && ctprun[rl] == 0) {
return maxl == 0 && $init3(this$static);
}
for (m_0 = 0; m_0 < 23; ++m_0) {
if (ckmv2_0[lm][m_0]) {
m_0 = skipAxis2[m_0];
continue;
}
ctx = ctmv[ct][m_0];
rlx = rlmv[rl][m_0];
prun = ctprun[ctx * 70 + rlx];
if (prun >= maxl) {
prun > maxl && (m_0 = skipAxis2[m_0]);
continue;
}
this$static.move2[depth] = move2std[m_0];
if ($search2(this$static, ctx, rlx, maxl - 1, m_0, depth + 1)) {
return true;
}
}
return false;
}
function $search3(this$static, edge, ct, prun, maxl, lm, depth) {
var cord1x, cord2x, ctx, edgex, m_0, prun1, prunx, symcord1x, symx;
if (maxl == 0) {
return edge == 0 && ct == 0;
}
$set_4(this$static.tempe[depth], edge);
for (m_0 = 0; m_0 < 17; ++m_0) {
if (ckmv3[lm][m_0]) {
m_0 = skipAxis3[m_0];
continue;
}
ctx = ctmove[ct][m_0];
prun1 = prun_0[ctx];
if (prun1 >= maxl) {
prun1 > maxl && m_0 < 14 && (m_0 = skipAxis3[m_0]);
continue;
}
edgex = getmvrot(this$static.tempe[depth].edge, m_0 << 3, 10);
cord1x = ~~(edgex / 20160);
symcord1x = raw2sym_1[cord1x];
symx = symcord1x & 7;
symcord1x >>= 3;
cord2x = getmvrot(this$static.tempe[depth].edge, m_0 << 3 | symx, 10) % 20160;
prunx = getprun_0(symcord1x * 20160 + cord2x, prun);
if (prunx >= maxl) {
prunx > maxl && m_0 < 14 && (m_0 = skipAxis3[m_0]);
continue;
}
if ($search3(this$static, edgex, ctx, prunx, maxl - 1, m_0, depth + 1)) {
this$static.move3[depth] = m_0;
return true;
}
}
return false;
}
function Search_4() {
var i_0;
this.p1sols = new PriorityQueue_0(new FullCube$ValueComparator_0);
this.move1 = createArray(15);
this.move2 = createArray(20);
this.move3 = createArray(20);
this.c1 = new FullCube_3;
this.c2 = new FullCube_3;
this.ct2 = new Center2_0;
this.ct3 = new Center3_0;
this.e12 = new Edge3_0;
this.tempe = createArray(20);
this.arr2 = createArray(100);
for (i_0 = 0; i_0 < 20; ++i_0) {
this.tempe[i_0] = new Edge3_0;
}
}
function init_5() {
if (inited_2) {
return;
}
initSym_0();
raw2sym = createArray(735471);
initSym2Raw();
createMoveTable();
raw2sym = null;
createPrun();
init_3();
init_4();
initMvrot();
initRaw2Sym();
createPrun_0();
inited_2 = true;
}
defineSeed(163, 1, makeCastMap([Q$Search_0]), Search_4);
_.add1 = false;
_.arr2idx = 0;
_.c = null;
_.length1 = 0;
_.length2 = 0;
_.p1SolsCnt = 0;
_.solution = '';
var inited_2 = false;
function $clinit_Util_0() {
$clinit_Util_0 = nullMethod;
colorMap4to3 = [85, 68, 70, 66, 82, 76];
}
function parity_0(arr) {
var i_0, j, len, parity;
parity = 0;
for (i_0 = 0, len = arr.length; i_0 < len; ++i_0) {
for (j = i_0; j < len; ++j) {
arr[i_0] > arr[j] && (parity ^= 1);
}
}
return parity;
}
function swap(arr, a, b, c, d, key) {
var temp;
switch (key) {
case 0:
temp = arr[d];
arr[d] = arr[c];
arr[c] = arr[b];
arr[b] = arr[a];
arr[a] = temp;
return;
case 1:
temp = arr[a];
arr[a] = arr[c];
arr[c] = temp;
temp = arr[b];
arr[b] = arr[d];
arr[d] = temp;
return;
case 2:
temp = arr[a];
arr[a] = arr[b];
arr[b] = arr[c];
arr[c] = arr[d];
arr[d] = temp;
return;
}
}
var colorMap4to3;
function Class_0() {}
function createForArray(packageName, className, seedId, componentType) {
var clazz;
clazz = new Class_0;
clazz.typeName = packageName + className;
isInstantiable(seedId != 0 ? -seedId : 0) && setClassLiteral(seedId != 0 ? -seedId : 0, clazz);
clazz.modifiers = 4;
clazz.superclass = Ljava_lang_Object_2_classLit;
clazz.componentType = componentType;
return clazz;
}
function createForClass(packageName, className, seedId, superclass) {
var clazz;
clazz = new Class_0;
clazz.typeName = packageName + className;
isInstantiable(seedId) && setClassLiteral(seedId, clazz);
clazz.superclass = superclass;
return clazz;
}
function getSeedFunction(clazz) {
var func = seedTable[clazz.seedId];
clazz = null;
return func;
}
function isInstantiable(seedId) {
return typeof seedId == 'number' && seedId > 0;
}
function setClassLiteral(seedId, clazz) {
var proto;
clazz.seedId = seedId;
if (seedId == 2) {
proto = String.prototype;
} else {
if (seedId > 0) {
var seed = getSeedFunction(clazz);
if (seed) {
proto = seed.prototype;
} else {
seed = seedTable[seedId] = function() {};
seed.___clazz$ = clazz;
return;
}
} else {
return;
}
}
proto.___clazz$ = clazz;
}
_.val$outerIter = null;
function $add(this$static, o) {
if ($offer(this$static, o)) {
return true;
}
}
function $$init_6(this$static) {
this$static.array = initDim(_3Ljava_lang_Object_2_classLit, makeCastMap([Q$Serializable, Q$Object_$1]), Q$Object, 0, 0);
}
function $add_0(this$static, o) {
setCheck(this$static.array, this$static.size++, o);
return true;
}
function $clear(this$static) {
this$static.array = initDim(_3Ljava_lang_Object_2_classLit, makeCastMap([Q$Serializable, Q$Object_$1]), Q$Object, 0, 0);
this$static.size = 0;
}
function $get_4(this$static, index) {
return this$static.array[index];
}
function $remove_0(this$static, index) {
var previous;
previous = this$static.array[index];
splice_0(this$static.array, index, 1);
--this$static.size;
return previous;
}
function $set_7(this$static, index, o) {
var previous;
previous = this$static.array[index];
setCheck(this$static.array, index, o);
return previous;
}
function $toArray_0(this$static, out) {
var i_0;
out.length < this$static.size && (out = createFrom(out, this$static.size));
for (i_0 = 0; i_0 < this$static.size; ++i_0) {
setCheck(out, i_0, this$static.array[i_0]);
}
out.length > this$static.size && setCheck(out, this$static.size, null);
return out;
}
function ArrayList_1() {
$$init_6(this);
this.array.length = 500;
}
function splice_0(array, index, deleteCount) {
array.splice(index, deleteCount);
}
_.size = 0;
function binarySearch_0(sortedArray, key) {
var high, low, mid, midVal;
low = 0;
high = sortedArray.length - 1;
while (low <= high) {
mid = low + (~~(high - low) >> 1);
midVal = sortedArray[mid];
if (midVal < key) {
low = mid + 1;
} else if (midVal > key) {
high = mid - 1;
} else {
return mid;
}
}
return -low - 1;
}
function fill_0(a) {
fill_1(a, a.length);
}
function fill_1(a, toIndex) {
var i_0;
for (i_0 = 0; i_0 < toIndex; ++i_0) {
a[i_0] = -1;
}
}
function $mergeHeaps(this$static, node) {
var heapSize, smallestChild, value, leftChild, rightChild, smallestChild_0;
heapSize = this$static.heap.size;
value = $get_4(this$static.heap, node);
while (node * 2 + 1 < heapSize) {
smallestChild = (leftChild = 2 * node + 1, rightChild = leftChild + 1, smallestChild_0 = leftChild, rightChild < heapSize && $compare_0($get_4(this$static.heap, rightChild), $get_4(this$static.heap, leftChild)) < 0 && (smallestChild_0 = rightChild), smallestChild_0);
if ($compare_0(value, $get_4(this$static.heap, smallestChild)) < 0) {
break;
}
$set_7(this$static.heap, node, $get_4(this$static.heap, smallestChild));
node = smallestChild;
}
$set_7(this$static.heap, node, value);
}
function $offer(this$static, e) {
var childNode, node;
node = this$static.heap.size;
$add_0(this$static.heap, e);
while (node > 0) {
childNode = node;
node = ~~((node - 1) / 2);
if ($compare_0($get_4(this$static.heap, node), e) <= 0) {
$set_7(this$static.heap, childNode, e);
return true;
}
$set_7(this$static.heap, childNode, $get_4(this$static.heap, node));
}
$set_7(this$static.heap, node, e);
return true;
}
function $poll(this$static) {
var value;
if (this$static.heap.size == 0) {
return null;
}
value = $get_4(this$static.heap, 0);
$removeAtIndex(this$static);
return value;
}
function $removeAtIndex(this$static) {
var lastValue;
lastValue = $remove_0(this$static.heap, this$static.heap.size - 1);
if (0 < this$static.heap.size) {
$set_7(this$static.heap, 0, lastValue);
$mergeHeaps(this$static, 0);
}
}
function $toArray_1(this$static, a) {
return $toArray_0(this$static.heap, a);
}
function PriorityQueue_0(cmp) {
this.heap = new ArrayList_1;
this.cmp = cmp;
}
defineSeed(239, 1, {}, PriorityQueue_0);
_.cmp = null;
_.heap = null;
var Ljava_lang_Object_2_classLit = createForClass('java.lang.', 'Object', 1, null),
_3Ljava_lang_Object_2_classLit = createForArray('[Ljava.lang.', 'Object;', 356, Ljava_lang_Object_2_classLit),
Lcs_threephase_FullCube_2_classLit = createForClass('cs.threephase.', 'FullCube', 160, Ljava_lang_Object_2_classLit),
_3Lcs_threephase_FullCube_2_classLit = createForArray('[Lcs.threephase.', 'FullCube;', 381, Lcs_threephase_FullCube_2_classLit);
$clinit_Moves();
$clinit_Util_0();
$clinit_Center1();
$clinit_Center2();
$clinit_Center3();
$clinit_Edge3();
$clinit_CenterCube();
$clinit_CornerCube();
$clinit_EdgeCube();
$clinit_FullCube_0();
var searcher = new Search_4();
function getRandomScramble() {
return (scramble_333.getRandomScramble() + $randomState(searcher, Math)).replace(/\s+/g, ' ');
}
//scramble.reg('444o', getRandomScramble)
return {
getRandomScramble: getRandomScramble
}
})(mathlib.rn, mathlib.Cnk, mathlib.circle);