tptimer/pyTwistyScrambler/js_resources/scramble_444.js

"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);