# The Mordell-Schinzel conjecture for cubic surfaces
# János Kollár, Jennifer Li
# This is the output of cycles.py

For these (a1, a2, b1, b2), every combination of pairs of (x0, y0) returns to (x0, y0):
    (a1, a2, b1, b2) = (-2, -1, -2, -1)
    (a1, a2, b1, b2) = (-2, -1, -1, -2)
    (a1, a2, b1, b2) = (-2, -1, -1, 0)
    (a1, a2, b1, b2) = (-2, -1, 0, -1)
    (a1, a2, b1, b2) = (-1, -2, -2, -1)
    (a1, a2, b1, b2) = (-1, -2, -1, -2)
    (a1, a2, b1, b2) = (-1, -2, -1, 0)
    (a1, a2, b1, b2) = (-1, -2, 0, -1)
    (a1, a2, b1, b2) = (-1, 0, -2, -1)
    (a1, a2, b1, b2) = (-1, 0, -1, -2)
    (a1, a2, b1, b2) = (-1, 0, -1, 0)
    (a1, a2, b1, b2) = (-1, 0, 0, -1)
    (a1, a2, b1, b2) = (0, -1, -2, -1)
    (a1, a2, b1, b2) = (0, -1, -1, -2)
    (a1, a2, b1, b2) = (0, -1, -1, 0)
    (a1, a2, b1, b2) = (0, -1, 0, -1)


Start testing: (a1, a2, b1, b2) = (-2, -1, -2, -1)
    Start testing: (x0, y0) = (-1, -1)
        Cycle iteration #1 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, 1)
        Cycle iteration #2 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #3 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-2, -1, -2, -1), the (x0, y0) pair (-1, -1) loops back to itself.
    Start testing: (x0, y0) = (-1, 1)
        Cycle iteration #1 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, 1)
        After 1 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-2, -1, -2, -1), the (x0, y0) pair (-1, 1) loops back to itself.
    Start testing: (x0, y0) = (1, -1)
        Cycle iteration #1 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #2 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, 1)
        Cycle iteration #3 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-2, -1, -2, -1), the (x0, y0) pair (1, -1) loops back to itself.
    Start testing: (x0, y0) = (1, 1)
        Cycle iteration #1 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #2 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #3 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, 1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-2, -1, -2, -1), the (x0, y0) pair (1, 1) loops back to itself.


Start testing: (a1, a2, b1, b2) = (-2, -1, -1, -2)
    Start testing: (x0, y0) = (-1, -1)
        Cycle iteration #1 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, -1)
        After 1 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-2, -1, -1, -2), the (x0, y0) pair (-1, -1) loops back to itself.
    Start testing: (x0, y0) = (-1, 1)
        Cycle iteration #1 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, 1)
        Cycle iteration #2 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #3 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, 1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-2, -1, -1, -2), the (x0, y0) pair (-1, 1) loops back to itself.
    Start testing: (x0, y0) = (1, -1)
        Cycle iteration #1 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #2 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, 1)
        Cycle iteration #3 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-2, -1, -1, -2), the (x0, y0) pair (1, -1) loops back to itself.
    Start testing: (x0, y0) = (1, 1)
        Cycle iteration #1 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #2 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #3 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, 1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-2, -1, -1, -2), the (x0, y0) pair (1, 1) loops back to itself.


Start testing: (a1, a2, b1, b2) = (-2, -1, -1, 0)
    Start testing: (x0, y0) = (-1, -1)
        Cycle iteration #1 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, 1)
        Cycle iteration #2 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #3 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-2, -1, -1, 0), the (x0, y0) pair (-1, -1) loops back to itself.
    Start testing: (x0, y0) = (-1, 1)
        Cycle iteration #1 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #2 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, 1)
        Cycle iteration #3 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, 1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-2, -1, -1, 0), the (x0, y0) pair (-1, 1) loops back to itself.
    Start testing: (x0, y0) = (1, -1)
        Cycle iteration #1 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, -1)
        After 1 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-2, -1, -1, 0), the (x0, y0) pair (1, -1) loops back to itself.
    Start testing: (x0, y0) = (1, 1)
        Cycle iteration #1 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #2 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #3 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, 1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-2, -1, -1, 0), the (x0, y0) pair (1, 1) loops back to itself.


Start testing: (a1, a2, b1, b2) = (-2, -1, 0, -1)
    Start testing: (x0, y0) = (-1, -1)
        Cycle iteration #1 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #2 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #3 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-2, -1, 0, -1), the (x0, y0) pair (-1, -1) loops back to itself.
    Start testing: (x0, y0) = (-1, 1)
        Cycle iteration #1 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #2 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #3 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, 1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-2, -1, 0, -1), the (x0, y0) pair (-1, 1) loops back to itself.
    Start testing: (x0, y0) = (1, -1)
        Cycle iteration #1 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #2 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #3 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-2, -1, 0, -1), the (x0, y0) pair (1, -1) loops back to itself.
    Start testing: (x0, y0) = (1, 1)
        Cycle iteration #1 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, 1)
        After 1 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-2, -1, 0, -1), the (x0, y0) pair (1, 1) loops back to itself.


Start testing: (a1, a2, b1, b2) = (-1, -2, -2, -1)
    Start testing: (x0, y0) = (-1, -1)
        Cycle iteration #1 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #2 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #3 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, -2, -2, -1), the (x0, y0) pair (-1, -1) loops back to itself.
    Start testing: (x0, y0) = (-1, 1)
        Cycle iteration #1 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #2 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #3 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, 1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, -2, -2, -1), the (x0, y0) pair (-1, 1) loops back to itself.
    Start testing: (x0, y0) = (1, -1)
        Cycle iteration #1 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #2 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #3 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, -2, -2, -1), the (x0, y0) pair (1, -1) loops back to itself.
    Start testing: (x0, y0) = (1, 1)
        Cycle iteration #1 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, 1)
        After 1 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, -2, -2, -1), the (x0, y0) pair (1, 1) loops back to itself.


Start testing: (a1, a2, b1, b2) = (-1, -2, -1, -2)
    Start testing: (x0, y0) = (-1, -1)
        Cycle iteration #1 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #2 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, 1)
        Cycle iteration #3 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, -2, -1, -2), the (x0, y0) pair (-1, -1) loops back to itself.
    Start testing: (x0, y0) = (-1, 1)
        Cycle iteration #1 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, 1)
        Cycle iteration #2 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #3 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, 1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, -2, -1, -2), the (x0, y0) pair (-1, 1) loops back to itself.
    Start testing: (x0, y0) = (1, -1)
        Cycle iteration #1 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, -1)
        After 1 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, -2, -1, -2), the (x0, y0) pair (1, -1) loops back to itself.
    Start testing: (x0, y0) = (1, 1)
        Cycle iteration #1 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #2 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #3 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, 1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, -2, -1, -2), the (x0, y0) pair (1, 1) loops back to itself.


Start testing: (a1, a2, b1, b2) = (-1, -2, -1, 0)
    Start testing: (x0, y0) = (-1, -1)
        Cycle iteration #1 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #2 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, 1)
        Cycle iteration #3 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, -2, -1, 0), the (x0, y0) pair (-1, -1) loops back to itself.
    Start testing: (x0, y0) = (-1, 1)
        Cycle iteration #1 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, 1)
        Cycle iteration #2 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #3 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, 1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, -2, -1, 0), the (x0, y0) pair (-1, 1) loops back to itself.
    Start testing: (x0, y0) = (1, -1)
        Cycle iteration #1 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, -1)
        After 1 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, -2, -1, 0), the (x0, y0) pair (1, -1) loops back to itself.
    Start testing: (x0, y0) = (1, 1)
        Cycle iteration #1 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #2 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #3 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, 1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, -2, -1, 0), the (x0, y0) pair (1, 1) loops back to itself.


Start testing: (a1, a2, b1, b2) = (-1, -2, 0, -1)
    Start testing: (x0, y0) = (-1, -1)
        Cycle iteration #1 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #2 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #3 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, -2, 0, -1), the (x0, y0) pair (-1, -1) loops back to itself.
    Start testing: (x0, y0) = (-1, 1)
        Cycle iteration #1 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #2 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #3 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, 1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, -2, 0, -1), the (x0, y0) pair (-1, 1) loops back to itself.
    Start testing: (x0, y0) = (1, -1)
        Cycle iteration #1 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #2 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #3 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, -2, 0, -1), the (x0, y0) pair (1, -1) loops back to itself.
    Start testing: (x0, y0) = (1, 1)
        Cycle iteration #1 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, 1)
        After 1 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, -2, 0, -1), the (x0, y0) pair (1, 1) loops back to itself.


Start testing: (a1, a2, b1, b2) = (-1, 0, -2, -1)
    Start testing: (x0, y0) = (-1, -1)
        Cycle iteration #1 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #2 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #3 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, 0, -2, -1), the (x0, y0) pair (-1, -1) loops back to itself.
    Start testing: (x0, y0) = (-1, 1)
        Cycle iteration #1 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #2 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #3 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, 1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, 0, -2, -1), the (x0, y0) pair (-1, 1) loops back to itself.
    Start testing: (x0, y0) = (1, -1)
        Cycle iteration #1 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #2 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #3 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, 0, -2, -1), the (x0, y0) pair (1, -1) loops back to itself.
    Start testing: (x0, y0) = (1, 1)
        Cycle iteration #1 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, 1)
        After 1 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, 0, -2, -1), the (x0, y0) pair (1, 1) loops back to itself.


Start testing: (a1, a2, b1, b2) = (-1, 0, -1, -2)
    Start testing: (x0, y0) = (-1, -1)
        Cycle iteration #1 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #2 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #3 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, 0, -1, -2), the (x0, y0) pair (-1, -1) loops back to itself.
    Start testing: (x0, y0) = (-1, 1)
        Cycle iteration #1 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #2 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #3 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, 1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, 0, -1, -2), the (x0, y0) pair (-1, 1) loops back to itself.
    Start testing: (x0, y0) = (1, -1)
        Cycle iteration #1 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #2 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #3 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, 0, -1, -2), the (x0, y0) pair (1, -1) loops back to itself.
    Start testing: (x0, y0) = (1, 1)
        Cycle iteration #1 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, 1)
        After 1 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, 0, -1, -2), the (x0, y0) pair (1, 1) loops back to itself.


Start testing: (a1, a2, b1, b2) = (-1, 0, -1, 0)
    Start testing: (x0, y0) = (-1, -1)
        Cycle iteration #1 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #2 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #3 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, 0, -1, 0), the (x0, y0) pair (-1, -1) loops back to itself.
    Start testing: (x0, y0) = (-1, 1)
        Cycle iteration #1 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #2 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #3 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, 1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, 0, -1, 0), the (x0, y0) pair (-1, 1) loops back to itself.
    Start testing: (x0, y0) = (1, -1)
        Cycle iteration #1 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #2 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #3 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, 0, -1, 0), the (x0, y0) pair (1, -1) loops back to itself.
    Start testing: (x0, y0) = (1, 1)
        Cycle iteration #1 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, 1)
        After 1 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, 0, -1, 0), the (x0, y0) pair (1, 1) loops back to itself.


Start testing: (a1, a2, b1, b2) = (-1, 0, 0, -1)
    Start testing: (x0, y0) = (-1, -1)
        Cycle iteration #1 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #2 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #3 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, 0, 0, -1), the (x0, y0) pair (-1, -1) loops back to itself.
    Start testing: (x0, y0) = (-1, 1)
        Cycle iteration #1 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #2 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #3 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, 1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, 0, 0, -1), the (x0, y0) pair (-1, 1) loops back to itself.
    Start testing: (x0, y0) = (1, -1)
        Cycle iteration #1 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #2 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #3 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, 0, 0, -1), the (x0, y0) pair (1, -1) loops back to itself.
    Start testing: (x0, y0) = (1, 1)
        Cycle iteration #1 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, 1)
        After 1 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (-1, 0, 0, -1), the (x0, y0) pair (1, 1) loops back to itself.


Start testing: (a1, a2, b1, b2) = (0, -1, -2, -1)
    Start testing: (x0, y0) = (-1, -1)
        Cycle iteration #1 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, 1)
        Cycle iteration #2 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #3 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (0, -1, -2, -1), the (x0, y0) pair (-1, -1) loops back to itself.
    Start testing: (x0, y0) = (-1, 1)
        Cycle iteration #1 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, 1)
        After 1 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (0, -1, -2, -1), the (x0, y0) pair (-1, 1) loops back to itself.
    Start testing: (x0, y0) = (1, -1)
        Cycle iteration #1 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #2 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, 1)
        Cycle iteration #3 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (0, -1, -2, -1), the (x0, y0) pair (1, -1) loops back to itself.
    Start testing: (x0, y0) = (1, 1)
        Cycle iteration #1 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #2 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #3 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, 1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (0, -1, -2, -1), the (x0, y0) pair (1, 1) loops back to itself.


Start testing: (a1, a2, b1, b2) = (0, -1, -1, -2)
    Start testing: (x0, y0) = (-1, -1)
        Cycle iteration #1 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #2 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, 1)
        Cycle iteration #3 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (0, -1, -1, -2), the (x0, y0) pair (-1, -1) loops back to itself.
    Start testing: (x0, y0) = (-1, 1)
        Cycle iteration #1 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, 1)
        After 1 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (0, -1, -1, -2), the (x0, y0) pair (-1, 1) loops back to itself.
    Start testing: (x0, y0) = (1, -1)
        Cycle iteration #1 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, 1)
        Cycle iteration #2 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #3 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (0, -1, -1, -2), the (x0, y0) pair (1, -1) loops back to itself.
    Start testing: (x0, y0) = (1, 1)
        Cycle iteration #1 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #2 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #3 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, 1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (0, -1, -1, -2), the (x0, y0) pair (1, 1) loops back to itself.


Start testing: (a1, a2, b1, b2) = (0, -1, -1, 0)
    Start testing: (x0, y0) = (-1, -1)
        Cycle iteration #1 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #2 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #3 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (0, -1, -1, 0), the (x0, y0) pair (-1, -1) loops back to itself.
    Start testing: (x0, y0) = (-1, 1)
        Cycle iteration #1 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #2 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #3 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, 1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (0, -1, -1, 0), the (x0, y0) pair (-1, 1) loops back to itself.
    Start testing: (x0, y0) = (1, -1)
        Cycle iteration #1 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #2 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #3 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (0, -1, -1, 0), the (x0, y0) pair (1, -1) loops back to itself.
    Start testing: (x0, y0) = (1, 1)
        Cycle iteration #1 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, 1)
        After 1 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (0, -1, -1, 0), the (x0, y0) pair (1, 1) loops back to itself.


Start testing: (a1, a2, b1, b2) = (0, -1, 0, -1)
    Start testing: (x0, y0) = (-1, -1)
        Cycle iteration #1 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #2 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #3 for (x0, y0) = (-1, -1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (0, -1, 0, -1), the (x0, y0) pair (-1, -1) loops back to itself.
    Start testing: (x0, y0) = (-1, 1)
        Cycle iteration #1 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #2 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, -1)
        Cycle iteration #3 for (x0, y0) = (-1, 1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, 1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (0, -1, 0, -1), the (x0, y0) pair (-1, 1) loops back to itself.
    Start testing: (x0, y0) = (1, -1)
        Cycle iteration #1 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (-1, -1)
            (x, A(x)/y)    : (-1, 1)
            (B_bar(y)/x, y): (-1, 1)
            (x, A_bar(x)/y): (-1, 1)
        Cycle iteration #2 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (-1, 1)
            (x, A(x)/y)    : (-1, -1)
            (B_bar(y)/x, y): (-1, -1)
            (x, A_bar(x)/y): (-1, -1)
        Cycle iteration #3 for (x0, y0) = (1, -1)
            (B(y)/x, y)    : (1, -1)
            (x, A(x)/y)    : (1, -1)
            (B_bar(y)/x, y): (1, -1)
            (x, A_bar(x)/y): (1, -1)
        After 3 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (0, -1, 0, -1), the (x0, y0) pair (1, -1) loops back to itself.
    Start testing: (x0, y0) = (1, 1)
        Cycle iteration #1 for (x0, y0) = (1, 1)
            (B(y)/x, y)    : (1, 1)
            (x, A(x)/y)    : (1, 1)
            (B_bar(y)/x, y): (1, 1)
            (x, A_bar(x)/y): (1, 1)
        After 1 power(s) of the 4-cycle, for (a1, a2, b1, b2) = (0, -1, 0, -1), the (x0, y0) pair (1, 1) loops back to itself.