private void searchA(final int maxALength) {
stackA[0].length = 0;
stackA[0].turnIndex = 0;
int d = 0;
do {
while (stackA[d].length < maxALength) {
final ANode node = stackA[d];
if (node.turnIndex >= node.turns.length) {
if (--d < 0) return;
} else {
final Turn userTurn = node.turns[node.turnIndex++];
node.userTurn = userTurn;
final Turn cubeTurn = SymTransform.getTurn(userTurn, node.symmetry);
node.cubeTurn = cubeTurn;
final ANode nextNode = stackA[d + 1];
final int length = node.length + metric.length(cubeTurn);
if (length <= maxALength && length <= maxSearchLength) {
final int ct = transform.twistTable.turn(cubeTurn, node.twist);
final int ef = transform.flipTable.turn(cubeTurn, node.flip);
aprn++;
if (aprn % CYCLES_BETWEEN_USER_CHECK == 0 && (isInterrupted = reporter.shouldStop()))
return;
final int ct_ef_d = pruneA.get_twist_flip_dist(node.twist_flip_dist, ct, ef);
if (ct_ef_d <= maxALength - length) {
final int meps = transform.mEdgePosSetTable.turn(cubeTurn, node.mEdgePosSet);
final int ct_meps_d =
pruneA.get_twist_mEdgePosSet_dist(node.twist_mEdgePosSet_dist, ct, meps);
if (ct_meps_d <= maxALength - length) {
final int ef_meps_d =
pruneA.get_flip_mEdgePosSet_dist(node.flip_mEdgePosSet_dist, ef, meps);
if (ef_meps_d <= maxALength - length) {
final int ct_d = pruneA.get_twistFull_dist(node.twist_dist, ct);
final int ef_d = pruneA.get_flipFull_dist(node.flip_dist, ef);
if (ct_d <= maxALength - length && ef_d <= maxALength - length) {
nextNode.setCubeStateA(ct, ef, meps);
nextNode.setDists(ct_ef_d, ct_meps_d, ef_meps_d, ct_d, ef_d);
nextNode.setTurnState(node, userTurn, turnList);
nextNode.length = length;
d++;
} else apry++;
} else apry++;
} else apry++;
} else apry++;
}
}
}
stackASize = d--;
solveB(maxALength);
} while (!isInterrupted && d >= 0);
}
private void searchB(final int maxALength, final int maxBLength) {
stackB[0].length = 0;
stackB[0].turnIndex = 0;
int d = 0;
do {
while (stackB[d].length < maxBLength) {
final BNode node = stackB[d];
if (node.turnIndex >= node.turns.length) {
if (--d < 0) return;
} else {
final Turn userTurn = node.turns[node.turnIndex++];
node.userTurn = userTurn;
final Turn cubeTurn = SymTransform.getTurn(userTurn, node.symmetry);
node.cubeTurn = cubeTurn;
final int length = node.length + metric.length(userTurn);
if (cubeTurn.isB() && maxALength + length <= maxSearchLength && length <= maxBLength) {
final BNode nextNode = stackB[d + 1];
final int mep = transformB.mEdgePosTable.turn(cubeTurn, node.mEdgePos);
final int cp = transformB.cornerPosTable.turn(cubeTurn, node.cornerPos);
bprn++;
if (bprn % CYCLES_BETWEEN_USER_CHECK == 0 && (isInterrupted = reporter.shouldStop()))
return;
final int mep_cp_d =
pruneB.get_mEdgePos_cornerPos_dist(node.mEdgePos_cornerPos_dist, mep, cp);
if (mep_cp_d <= maxBLength - length) {
final int udep = transformB.udEdgePosTable.turn(cubeTurn, node.udEdgePos);
final int mep_udep_d =
pruneB.get_mEdgePos_udEdgePos_dist(node.mEdgePos_udEdgePos_dist, mep, udep);
if (mep_udep_d <= maxBLength - length) {
nextNode.setCubeState(mep, cp, udep);
nextNode.setDists(mep_cp_d, mep_udep_d);
nextNode.setTurnState(node, userTurn, turnListB);
nextNode.length = length;
d++;
} else bpry++;
} else bpry++;
}
}
}
stackBSize = d--;
display();
maxSearchLength = maxALength + maxBLength - (findAll ? 0 : 1);
} while (!isInterrupted && d >= 0);
}
