import java.io.*;
import java.awt.*;
import java.lang.*;
import java.lang.Math.*;
import java.math.*;

public class words { 

    public static void main (String[] args) { 

	InputStreamReader istream = new InputStreamReader(System.in) ;
	BufferedReader bufRead = new BufferedReader(istream) ;

	System.out.println("Wow, it's the new and improved trigoned 4-braid machine!");
	System.out.println("Let's give it a whirl.");
	
	try {
	    int p, threep;
	    System.out.println("Please enter a path in the folding automaton. ");
	    String word = bufRead.readLine();
	    char[] funk, funkotron;
	    String flop;  
            double[] flake, flow, flowlike, fabulous, great, invariant;
            int[] Crazy, Crazylike, braidness;
            flake = new double[100000];
            flow = new double[100000]; 
            flowlike = new double[100000];
            Crazy = new int[100000];
            Crazylike = new int[100000];
            fabulous = new double[100000];
            great = new double[100000];  
            braidness = new int[100000]; 
            invariant = new double[3];
            flake[0] = 0; 
            flake[1] = 0.5; 
            flake[2] = 1; 
            flake[3] = 1.5;
            flake[4] = 2;
            char flap;
	    p = word.length(); 
            threep = 3*p; 
            int j, places, placesZ, fabsize, moop;
            moop = -1; 
            fabsize = 0; 
            double l, gibberishness; 
            places = 5; 
            funk = word.toCharArray();  
            System.out.print("You entered ");
            System.out.print(funk);
            System.out.println(".");
            int[] Aone, Atwo, Athree, Afour, Bone, Btwo, Bthree, Bfour, Cone, Ctwo, Cthree, Cfour, Done, Dtwo, Dthree, Dfour;
            double[] Afive, Bfive, Cfive, Dfive;
            Aone = new int[100000];
            Atwo = new int[100000];
            Athree = new int[100000];
            Afour = new int[100000];
            Bone = new int[100000];
            Btwo = new int[100000];
            Bthree = new int[100000];
            Bfour = new int[100000];
            Cone = new int[100000];
            Ctwo = new int[100000];
            Cthree = new int[100000];
            Cfour = new int[100000];
            Done = new int[100000];
            Dtwo = new int[100000];
            Dthree = new int[100000];
            Dfour = new int[100000];
            Afive = new double[100000];
            Bfive = new double[100000];
            Cfive = new double[100000];
            Dfive = new double[100000];
            int[] Sidesizes;
	    Sidesizes = new int[10];
            Sidesizes[0] = 2;
            Sidesizes[1] = 2;
            Sidesizes[2] = 2;
            Sidesizes[3] = 2;
            Aone[0] = 0;
            Aone[1] = 1;
            Atwo[0] = 1;
            Atwo[1] = 1;
            Athree[0] = 1;
            Afour[0] = 0;
            Afive[0] = 0;
            Afive[1] = 1;
            Bone[0] = 0; 
            Bone[1] = 1; 
            Btwo[0] = 1; 
            Btwo[1] = 1; 
            Bthree[0] = 2; 
            Bfour[0] = 0; 
            Bfive[0] = 0; 
            Bfive[1] = 1;
            Cone[0] = 0; 
            Cone[1] = 1; 
            Ctwo[0] = 1; 
            Ctwo[1] = 1; 
            Cthree[0] = 3; 
            Cfour[0] = 0; 
            Cfive[0] = 0; 
            Cfive[1] = 1;
            Done[0] = 0; 
            Done[1] = 1; 
            Dtwo[0] = 1; 
            Dtwo[1] = 1; 
            Dthree[0] = 4; 
            Dfour[0] = 0; 
            Dfive[0] = 0; 
            Dfive[1] = 1;   
            pathentry(p, funk, Aone, Atwo, Athree, Afour, Afive, 
	    Bone, Btwo, Bthree, Bfour, Bfive, Cone, Ctwo, Cthree, 
	    Cfour, Cfive, Done, Dtwo, Dthree, Dfour, Dfive, 
	    Sidesizes);
	    ReduceThem(Aone, Atwo, Athree, Afour, Afive, Bone, Btwo,
	    Bthree, Bfour, Bfive, Cone, Ctwo, Cthree, Cfour, 
	    Cfive, Done, Dtwo, Dthree, Dfour, Dfive, Sidesizes);
	    Iterate(Aone, Atwo, Athree, Afour, Afive, Bone, Btwo,
            Bthree, Bfour, Bfive, Cone, Ctwo, Cthree, Cfour,
            Cfive, Done, Dtwo, Dthree, Dfour, Dfive, Sidesizes);
	    ReduceThem(Aone, Atwo, Athree, Afour, Afive, Bone, Btwo,
            Bthree, Bfour, Bfive, Cone, Ctwo, Cthree, Cfour,
            Cfive, Done, Dtwo, Dthree, Dfour, Dfive, Sidesizes);
	    Iterate(Aone, Atwo, Athree, Afour, Afive,
            Bone, Btwo, Bthree, Bfour, Bfive, Cone, Ctwo, Cthree,
            Cfour, Cfive, Done, Dtwo, Dthree, Dfour, Dfive,
            Sidesizes);
            ReduceThem(Aone, Atwo, Athree, Afour, Afive, Bone, Btwo,
            Bthree, Bfour, Bfive, Cone, Ctwo, Cthree, Cfour,
            Cfive, Done, Dtwo, Dthree, Dfour, Dfive, Sidesizes);
	    printytoo(Sidesizes[0], Aone);
	    printytoo(Sidesizes[0], Atwo);
	    printytoo(Sidesizes[0]-1, Athree);
	    printytoo(Sidesizes[0]-1, Afour);
	    printytoo(Sidesizes[1], Bone);
	    printytoo(Sidesizes[1], Btwo);
	    printytoo(Sidesizes[1]-1, Bthree);
	    printytoo(Sidesizes[1]-1, Bfour);
	    printytoo(Sidesizes[2], Cone);
            printytoo(Sidesizes[2], Ctwo);
            printytoo(Sidesizes[2]-1, Cthree);
            printytoo(Sidesizes[2]-1, Cfour); 
            printytoo(Sidesizes[3], Done); 
            printytoo(Sidesizes[3], Dtwo); 
            printytoo(Sidesizes[3]-1, Dthree);
            printytoo(Sidesizes[3]-1, Dfour);
	    int[] ZigZag; 
            ZigZag = new int[100000];
            int yep; 
            ZigZag = Hipsterology(Aone, Atwo, Athree, Afour, Afive, Bone, Btwo,
            Bthree, Bfour, Bfive, Cone, Ctwo, Cthree, Cfour, 
            Cfive, Done, Dtwo, Dthree, Dfour, Dfive, Sidesizes); 
            yep = ZigZag[0];
	    printytoo(yep, ZigZag);
	    funkotron = cubing(p, funk);
	    places = apply(threep, places, funkotron, flake);
	    int i;
	    i=1;
	    for(i=1; i<places; i++){
		flow[i-1] = (flake[i-1]+flake[i])/2;
	    }
	    placesZ = places - 1;
	    fabsize = splendidtoo(threep, placesZ, funkotron, flow, Crazy, fabsize, fabulous);
	    flake[0] = 0; 
            flake[1] = 0.5; 
            flake[2] = 1;
            flake[3] = 1.5;
            flake[4] = 2;
	    places = 5;
	    fabsize = 0;
	    places = apply(p, places, funk, flake); 
            i=1; 
            for(i=1; i<places; i++){    
                flowlike[i-1] = (flake[i-1]+flake[i])/2;
            }
            placesZ = places - 1; 
            fabsize = splendidtoo(p, placesZ, funk, flowlike, Crazylike, fabsize, great);
	    System.out.println("Please enter a point");
	    BufferedReader keyboard = new BufferedReader(new InputStreamReader(System.in)); 
            double gibberish = Double.valueOf(keyboard.readLine()).doubleValue();
	    gibberishness = Wheredthepointgo(gibberish, p, funk);
	    System.out.println(gibberishness);
	    gibberishness = Wheredthepointgo(gibberishness, p, funk);
	    System.out.println(gibberishness);
	    System.out.println("Please enter the first point");                
            double gonzo = Double.valueOf(keyboard.readLine()).doubleValue();
	    System.out.println("Please enter the second point");
   	    double agonzo = Double.valueOf(keyboard.readLine()).doubleValue();
	    System.out.println("Finally, enter the third point");
	    double bgonzo = Double.valueOf(keyboard.readLine()).doubleValue();
	    invariant[0] = gonzo;
	    invariant[1] = agonzo;
	    invariant[2] = bgonzo;
	    braidness = braiding(invariant, p, funk);
	    moop = braidingtoo(invariant, p, funk);
	    moop = moop+1;
	    System.out.println("The induced braid is given by:");
	    printytoo(moop, braidness);
	}

	catch (IOException err) {
	    System.out.println("Error reading line");
	}    
    } 

    public static void printy(int k, double[] Wow){
	int i;
	i=0;
	System.out.print("[");
	for(i=0; i<k; i++){
	    System.out.print(Wow[i]);
	    System.out.print(" , ");
	}
	System.out.println("]");
    }	

    public static void printytoo(int k, int[] Wow){
	int i;
	i = 0;
	System.out.println();
	System.out.print("[");
	for(i=0; i<k; i++){
	    System.out.print(Wow[i]);
	    System.out.print(", ");
	}
	System.out.println("]");
    }

    public static int wacky(double n, int k, double[] Wow){
	int i;
	int result;
	result = 0;
	for(i=0; i<k; i=i+1){
	    double f;
	    f = n - Wow[i];
	    if ((f < 0.0000001) && (f > -0.0000001)){
		result = 1;
	    }
	}
    return result;
    }

    public static void sorty(int k, double[] Wow){
	int i, j, p, r;
	i = 0;
	double q;
	for(i=0; i<k; i=i+1){
	    j = 0;
	    p = 0;
	    while ((j < i) && (p == 0)){
		if (Wow[j] > Wow[i]){
		    q = Wow[i];
		    r = i;
		    while (r > j){
			Wow[r] = Wow[r-1];
			r = r - 1;
		    }
		    Wow[j] = q;
		    p = 1;
		}
		j = j+1;
	    }
	}    
    }

    public static double[] sortysorty(int k, double[] Wow){
        int i, j, p, r;
        i = 0;
        double q;
        for(i=0; i<k; i=i+1){
            j = 0;
            p = 0; 
            while ((j < i) && (p == 0)){
                if (Wow[j] > Wow[i]){
                    q = Wow[i];
                    r = i;
                    while (r > j){
                        Wow[r] = Wow[r-1];
                        r = r - 1;
                    } 
                    Wow[j] = q;
                    p = 1; 
                } 
                j = j+1; 
            } 
        }
	return Wow;
    } 

    public static int left(int k, double[] Wow){
	int letters, i;
	double a, b, c, d;
	letters = 1;
	double[] Tea;
	Tea = new double[100000];
	Tea[0] = 0;
	for(i=0; i<k; i++){
	    a = 1 - Wow[i];
	    b = (Wow[i])/2 + 1;
	    c = wacky(a, letters, Tea);
	    if ((0 <= a) && (a <= 2) && (c == 0)){
		Tea[letters] = a;
		letters = letters+1;
	    }
	    d = wacky(b, letters, Tea);
	    if ((0 <= b) && (b <= 2) && (d == 0)){
		Tea[letters] = b;
		letters = letters+1;
	    }	
	}    
	i = 0;
	for(i=0; i<letters; i++){
	    Wow[i] = Tea[i];
	}    
	k = letters;
	sorty(k, Wow);
	return k;
    }

    public static int right(int k, double[] Wow){
	int letters, i;
	double a, b, c, d;
	letters = 1;
	double[] Tea;
	Tea = new double[100000];
	Tea[0] = 0;
	for(i=0; i<k; i++){
	    a = Wow[i]/2;
	    b = 3 - Wow[i];
	    c = wacky(a, letters, Tea);
	    if ((0 <= a) && (a <= 2) && (c == 0)){
		Tea[letters] = a;
		letters = letters+1;
	    }
	    d = wacky(b, letters, Tea);
	    if ((0 <= b) && (b <= 2) && (d == 0)){
		Tea[letters] = b;
		letters = letters+1;
	    }
	}    
	i=0;
	for(i=0; i<letters; i++){
	    Wow[i] = Tea[i];
	}
	k = letters;
	sorty(k, Wow);
	return k;
    }

    public static int apply(int k, int w, char[] funky, double[] Wow){
	int i;
	i=0;
	for(i=0; i<k; i++){
	    if(funky[i] == 'L'){
		w = left(w, Wow);
	    }
	    else{
		w = right(w, Wow);
	    }	
        }
	return w;
    }

    public static double splendid(int k, double l, char[] funky, int fabsize, double[] fabulous){
	double m, t, a, b;
	a = 1;
	b = 0;
	m = l;
	int i;
	i = k-1;
	for(i=k-1; i>=0; i=i-1){
	    if(funky[i] == 'L'){
		if(m <= 1){
		    m = 1 - m;
		    a = -a;
		    b = 1-b;
		}
		else{
		    m = 2*(m-1);
		    a = 2*a;
		    b = 2*(b-1);
		}    
	    }
	    else{
		if(m <= 1){
		    m = 2*m;
		    a = 2*a;
		    b = 2*b;
		}
		else{
		    m = 3 - m;
		    a = -a;
		    b = 3-b;
		}
	    }
	}
	t = -(b/(a-1));
	fabulous[fabsize] = t;
       	return m;
    }

    public static int splendidtoo(int k, int l, char[] funky, double[] funkytoo, int[] funkythree, int fabsize, double[] fabulous){
	int i, j;
	i = 0;
	j = l;
	double phla, phlam;
	int phlammo;
	for(i=0; i<j; i++){
	    phla = funkytoo[i];
	    phlam = splendid(k, phla, funky, fabsize, fabulous);
	    if((0<=phlam) && (phlam<=0.5) && (0<=phla) && (phla<=0.5)){
		phlammo = 1;
		fabsize = fabsize+1;
	    }
	    else if ((0.5<=phlam) && (phlam<=1) && (0.5<=phla) && (phla<=1)){
		phlammo = 1;
		fabsize = fabsize+1;
	    }
	    else if ((1<=phlam) && (phlam<=1.5) && (1<=phla) && (phla<=1.5)){
		phlammo = 1;
		fabsize = fabsize+1;
	    }
	    else if ((1.5<=phlam) && (phlam<=2) && (1.5<=phla) && (phla<=2)){
		phlammo = 1;
		fabsize = fabsize+1;
	    }
	    else{
		phlammo = 0;
	    }
	    funkythree[i] = phlammo;
	}
	System.out.println("The fixed points of the cubed word are:");
	printy(fabsize, fabulous);
	System.out.print("The number of fixed points of the cubed word is ");
	System.out.print(fabsize);
	System.out.println(".");
	return fabsize;
    }

    public static void fixedpoints(int k, int l, char[] funky, double[] funkytoo, int[] funkythree, double[] fabulous){
	System.out.println("The fixed points are:");



    }

    public static int ZowR(double invariantz[], int[] braid, int q){
	double a, b, c;
	a = invariantz[0];
	b = invariantz[1];
	c = invariantz[2];
	if((a>=0.9999999) && (b>=0.9999999) && (c>=0.9999999)){
		braid[q+1] = -2;
		braid[q+2] = -1;
		braid[q+3] = -2;
		a = 3 - a;
		b = 3 - b;
		c = 3 - c;
		q = q+3;
		System.out.println("6");
	}
	else if ((b>=0.9999999) && (c>=0.9999999)){
		a = 2*a;
		b = 3 - b;
		c = 3 - c;
		braid[q+1] = -2;
		if (a<c){
			q = q+1;
		}
		else if (a<b){
			braid[q+2] = -1;
			q = q+2;
		}
		else{
			braid[q+2] = -1;
			braid[q+3] = -2;
			q = q+3;
		}
		System.out.println("7");	
	}
	else if (c>=0.9999999){
		a = 2*a;
		b = 2*b;
		c = 3 - c;
		if (c<a){
			braid[q+1] = -2;
			braid[q+2] = -1;
			q = q+2;
		}
		else if (c<b){
			braid[q+1] = -2;
			q = q+1;
		}
		System.out.println("8");
	}
	else{
		a = 2*a;
		b = 2*b;
		c = 2*c;
		System.out.println("9");
        }
	return q;
    }

    public static int[] ZowRlox(double invariantz[], int[] braid, int q){
	double a, b, c;
	a = invariantz[0];
	b = invariantz[1];
	c = invariantz[2];
        if((a>=0.9999999) && (b>=0.9999999) && (c>=0.9999999)){
                braid[q+1] = -2;
                braid[q+2] = -1;
                braid[q+3] = -2;
                a = 3 - a; 
                b = 3 - b;
                c = 3 - c; 
                q = q+3; 
        } 
        else if ((b>=0.9999999) && (c>=0.9999999)){ 
                a = 2*a; 
                b = 3 - b; 
                c = 3 - c;
                braid[q+1] = -2;
                if (a<c){
                        q = q+1; 
                } 
                else if (a<b){
                        braid[q+2] = -1;
                        q = q+2;
                }
                else{
                        braid[q+2] = -1; 
                        braid[q+3] = -2; 
                        q = q+3;
                } 
        } 
	else if (c>=0.9999999){
                a = 2*a;  
                b = 2*b;  
                c = 3 - c; 
                if (c<a){
                        braid[q+1] = -2; 
                        braid[q+2] = -1;
                        q = q+2;
                } 
                else if (c<b){   
                        braid[q+1] = -2;
                        q = q+1;
                }
        } 
        else{ 
                a = 2*a; 
                b = 2*b;
                c = 2*c;
        } 
        return braid; 
    } 
    
    public static double[] ZowRloxo(double invariantz[], int[] braid, int q){
        double a, b, c;
	a = invariantz[0];
        b = invariantz[1]; 
        c = invariantz[2]; 
        if((a>=0.9999999) && (b>=0.9999999) && (c>=0.9999999)){
                braid[q+1] = -2;
                braid[q+2] = -1;
                braid[q+3] = -2;
                a = 3 - a; 
                b = 3 - b;
                c = 3 - c; 
                q = q+3;  
        } 
        else if ((b>=0.9999999) && (c>=0.9999999)){
                a = 2*a; 
                b = 3 - b;
                c = 3 - c; 
                braid[q+1] = -2; 
                if (a<c){ 
                        q = q+1;
                }
                else if (a<b){
                        braid[q+2] = -1;
                        q = q+2;
                } 
                else{
                        braid[q+2] = -1;
                        braid[q+3] = -2;
                        q = q+3;
                } 
        } 
	 else if (c>=0.9999999){
                a = 2*a;   
                b = 2*b; 
                c = 3 - c; 
                if (c<a){ 
                        braid[q+1] = -2;
                        braid[q+2] = -1;
                        q = q+2;
                } 
                else if (c<b){
                        braid[q+1] = -2;
                        q = q+1; 
                } 
        } 
        else{ 
                a = 2*a; 
                b = 2*b;   
                c = 2*c; 
        } 
	invariantz[0] = a;
	invariantz[1] = b;
	invariantz[2] = c;
        return invariantz; 
    } 

    public static int ZowL(double invariantz[], int[] braid, int q){
	double a, b, c;
	a = invariantz[0];
	b = invariantz[1];
	c = invariantz[2];
        if((a<=1.0000001) && (b<=1.0000001) && (c<=1.0000001)){
                braid[q+1] = 1;
                braid[q+2] = 2;
                braid[q+3] = 1;
                a = 1 - a;
                b = 1 - b;
                c = 1 - c;
                q = q+3;
		System.out.println("6");  
        } 
        else if ((a<=1.0000001) && (b<=1.0000001)){
                a = 1-a; 
                b = 1-b;
                c = 2*(c-1); 
                braid[q+1] = 1; 
                if (c>a){ 
                        q = q+1;
                }
                else if (c>b){
                        braid[q+2] = 2;
                        q = q+2;
                } 
                else{
                        braid[q+2] = 2;
                        braid[q+3] = 1;
                        q = q+3;
                } 
		System.out.println("7");
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
        } 
	 else if (a<=1.0000001){
                a = 1-a; 
                b = 2*(b-1); 
                c = 2*(c-1); 
                if (a>c){
                        braid[q+1] = 1;
                        braid[q+2] = 2;
                        q = q+2;
                } 
                else if (a>b){
                        braid[q+1] = 1;
                        q = q+1; 
                } 
		System.out.println("8");
        } 
        else{ 
                a = 2*(a-1); 
                b = 2*(b-1); 
                c = 2*(c-1); 
		System.out.println("9");
        } 
        return q;
    } 

    public static int[] ZowLlox(double invariantz[], int[] braid, int q){
	double a, b, c;
	a = invariantz[0];
	b = invariantz[1];
	c = invariantz[2];
        if((a<=1.0000001) && (b<=1.0000001) && (c<=1.0000001)){
                braid[q+1] = 1;
                braid[q+2] = 2;
                braid[q+3] = 1; 
                a = 1 - a;
                b = 1 - b;  
                c = 1 - c;  
                q = q+3; 
        } 
        else if ((a<=1.0000001) && (b<=1.0000001)){
                a = 1-a; 
                b = 1-b;
                c = 2*(c-1);  
                braid[q+1] = 1; 
                if (c>a){ 
                        q = q+1;
                }
                else if (c>b){
                        braid[q+2] = 2;
                        q = q+2;
                } 
                else{
                        braid[q+2] = 2;
                        braid[q+3] = 1;
                        q = q+3;
                }
        }     
	else if (a<=1.0000001){ 
                a = 1-a; 
                b = 2*(b-1);   
                c = 2*(c-1);   
                if (a>c){ 
                        braid[q+1] = 1;
                        braid[q+2] = 2;
                        q = q+2;
                }
                else if (a>b){ 
                        braid[q+1] = 1;
                        q = q+1;
                } 
        } 
        else{ 
                a = 2*(a-1); 
                b = 2*(b-1);
                c = 2*(c-1);  
        } 
        return braid; 
    } 

     public static double[] ZowLloxo(double invariantz[], int[] braid, int q){
        double a, b, c;
	a = invariantz[0];
        b = invariantz[1]; 
        c = invariantz[2]; 
        if((a<=1.0000001) && (b<=1.0000001) && (c<=1.0000001)){
                braid[q+1] = 1;
                braid[q+2] = 2;
                braid[q+3] = 1;
                a = 1 - a;
                b = 1 - b;  
                c = 1 - c;  
                q = q+3; 
        } 
	 else if ((a<=1.0000001) && (b<=1.0000001)){
                a = 1-a; 
                b = 1-b;
                c = 2*(c-1);   
                braid[q+1] = 1; 
                if (c>a){ 
                        q = q+1;
                }
                else if (c>b){
                        braid[q+2] = 2;
                        q = q+2;
                } 
                else{
                        braid[q+2] = 2;
                        braid[q+3] = 1;
                        q = q+3;
                } 
        } 
        else if (a<=1.0000001){
                a = 1-a;  
                b = 2*(b-1); 
                c = 2*(c-1);   
                if (a>c){ 
                        braid[q+1] = 1;
                        braid[q+2] = 2;
                        q = q+2;
                } 
                else if (a>b){
                        braid[q+1] = 1;
                        q = q+1;
                }
        }
	        else{ 
                a = 2*(a-1);    
                b = 2*(b-1);
                c = 2*(c-1); 
        } 
	invariantz[0] = a;
	invariantz[1] = b;
	invariantz[2] = c;
        return invariantz; 
    } 

    public static double Wheredthepointgo(double a, int k, char[] funky){
	int i;
	i = k-1; 
	for(i=k-1; i>=0; i=i-1){ 
            if(funky[i] == 'L'){
                if(a <= 1){ 
                	a = 1-a;
                } 
                else{
                    a = 2*(a-1); 
                }
            } 
            else{ 
                if(a <= 1){ 
                    a = 2*a; 
                } 
                else{ 
                    a = 3-a; 
                } 
            }
        }    
	return a;
    }

    public static char[] cubing(int g, char[] funky){
	char[] funkyflow;
	funkyflow = new char[10000];
	int i, j, gee;
	gee = 3*g;
	i = 0;
	j = 0;
	for(j=0; j<3; j=j+1){
		for(i=0; i<g; i=i+1){
			int t;
			t = (j*g)+i;
			funkyflow[t] = funky[i];	
		}
	} 
	System.out.print("The cubed word is ");
	System.out.print(funkyflow);
	System.out.println(".");
	return funkyflow;
    }

    public static int[] braiding(double[] invariantzes, int pq, char[] funky){
	double door, doors, thedoors;
	door = invariantzes[0];
	doors = invariantzes[1];
	thedoors = invariantzes[2];
	double[] invariantlike;
	invariantlike = new double[3];
	int[] braidmeister, flipmode;
	braidmeister = new int[10000];
	flipmode = new int[10000];
	int i, r, s, v;
	v = 3;
	i = pq-1;
	r = -1;
	invariantzes = sortysorty(v, invariantzes);
	for(i=pq-1; i>=0; i=i-1){
		if (funky[i] == 'L'){
			s = ZowL(invariantzes, braidmeister, r);
			flipmode = ZowLlox(invariantzes, braidmeister, r);
			invariantlike = ZowLloxo(invariantzes, braidmeister, r);
			r = s;
			braidmeister = flipmode;
			invariantzes = invariantlike;
			invariantzes = 	sortysorty(v, invariantzes);
		}
		else if (funky[i] == 'R'){
			s = ZowR(invariantzes, braidmeister, r);
                        flipmode = ZowRlox(invariantzes, braidmeister, r);
                        invariantlike = ZowRloxo(invariantzes, braidmeister, r);
                        r = s;
                        braidmeister = flipmode;
                        invariantzes = invariantlike;
                        invariantzes =  sortysorty(v, invariantzes);
		}
	}
	invariantzes[0] = door;
	invariantzes[1] = doors;
	invariantzes[2] = thedoors;
	return braidmeister;
    }

     public static int braidingtoo(double[] invariantzes, int pq, char[] funky){
        double door, doors, thedoors;
	door = invariantzes[0];
	doors = invariantzes[1];
	thedoors = invariantzes[2];
	double[] invariantlike; 
        invariantlike = new double[3]; 
        int[] braidmeister, flipmode; 
        braidmeister = new int[10000];
        flipmode = new int[10000];
        int i, r, s, v;
        v = 3; 
        i = pq-1;
        r = -1;
	invariantzes = sortysorty(v, invariantzes);
        for(i=pq-1; i>=0; i=i-1){
                if (funky[i] == 'L'){
                        s = ZowL(invariantzes, braidmeister, r);
                        flipmode = ZowLlox(invariantzes, braidmeister, r);
                        invariantlike = ZowLloxo(invariantzes, braidmeister, r);
                        r = s;
                        braidmeister = flipmode;
                        invariantzes = invariantlike;
                        invariantzes =  sortysorty(v, invariantzes);
                }
		 else if (funky[i] == 'R'){
                        s = ZowR(invariantzes, braidmeister, r);
                        flipmode = ZowRlox(invariantzes, braidmeister, r);
                        invariantlike = ZowRloxo(invariantzes, braidmeister, r);
                        r = s; 
                        braidmeister = flipmode; 
                        invariantzes = invariantlike;
                        invariantzes =  sortysorty(v, invariantzes);
                 } 
        } 
	invariantzes[0] = door;
	invariantzes[1] = doors;
	invariantzes[2] = thedoors;
        return r;
    }    

public static void MoveA(int[] Aone, int[] Atwo, int[] Athree, 
int[] Afour, double[] Afive, int[] Bone, int[] Btwo, 
int[] Bthree, int[] Bfour, double[] Bfive, int[] 
Cone, int[] Ctwo, int[] Cthree, int[] Cfour, double[] Cfive, int[] 
Done, int[] Dtwo, int[] Dthree, int[] Dfour, 
double[] Dfive, int[] Sidesizes){
		int[] Tea;
		Tea = new int[100000];
		int q;
		q = Sidesizes[0];
		int j;
		j = 0;
		for(j = 0; j < q; j = j+1){
			Tea[j] = Aone[j];
		}	
		for(j = 0; j < q; j = j+1){
			Aone[j] = Atwo[q-1-j] - Tea[q-1-j];
		}
		 for(j = 0; j < q; j = j+1){
                	Tea[j] = Atwo[j];
        	}
        	for(j = 0; j < q; j = j+1){
                	Atwo[j] = Tea[q-1-j];
        	}
		 for(j = 0; j < q-1; j = j+1){
                	Tea[j] = Athree[j];
        	}
        	for(j = 0; j < q-1; j = j+1){
                	Athree[j] = Tea[q-2-j];
        	}
		for(j = 0; j < q-1; j = j+1){
                	Tea[j] = Afour[j];
        	}
        	for(j = 0; j < q-1; j = j+1){
                	Afour[j] = 1 - Tea[q-2-j];
        	}
		q = Sidesizes[1];
		for(j = 1; j < q; j = j+1){
			Btwo[j] = 2*Btwo[j];
		}
		int k;
		k = Sidesizes[0];
		for(j=1; j < k; j = j+1){
			Bone[q+j-1] = Aone[j] + Atwo[j]; 
                	Btwo[q+j-1] = 2*Atwo[j]; 
                	Bthree[q+j-2] = Athree[j-1]; 
                	Bfour[q+j-2] = Afour[j-1]; 
		}
		Sidesizes[1] = q+k-1;
	}


public static void MoveB(int[] Aone, int[] Atwo, int[] Athree,
int[] Afour, double[] Afive, int[] Bone, int[] Btwo,
int[] Bthree, int[] Bfour, double[] Bfive, int[]
Cone, int[] Ctwo, int[] Cthree, int[] Cfour, double[] Cfive, 
int[] Done, int[] Dtwo, int[] Dthree, int[] Dfour,
double[] Dfive, int[] Sidesizes){
	int q;
	int j;
	q = Sidesizes[0];
	for(j=1; j < q; j = j+1){
		Atwo[j] = 2*Atwo[j];
	}
	int k;
	k = Sidesizes[1];
	for(j=1; j < k; j = j+1){
		Aone[q+j-1] = Bone[j] + Btwo[j];
		Atwo[q+j-1] = 2*Btwo[j];
		Athree[q+j-2] = Bthree[j-1];
		Afour[q+j-2] = Bfour[j-1];
	}
	Sidesizes[0] = q+k-1;
}

public static void MoveC(int[] Aone, int[] Atwo, int[] Athree,
int[] Afour, double[] Afive, int[] Bone, int[] Btwo,
int[] Bthree, int[] Bfour, double[] Bfive, int[]
Cone, int[] Ctwo, int[] Cthree, int[] Cfour, double[] Cfive,
int[] Done, int[] Dtwo, int[] Dthree, int[] Dfour,
double[] Dfive, int[] Sidesizes){
	int[] Flipone, Fliptwo, Flipthree, Flipfour;
	Flipone = new int[100000];
	Fliptwo = new int[100000];
	Flipthree = new int[100000];
	Flipfour = new int[100000];
	int j;
	int q;
	int k;
	q = Sidesizes[0];
	k = Sidesizes[1];
	for(j=1; j<q; j=j+1){
		Atwo[j] = 2*Atwo[j];
	}
	for(j=1; j<k; j=j+1){
		Aone[q+j-1] = 2*Btwo[k-1-j] - Bone[k-1-j];
		Atwo[q+j-1] = 2*Btwo[k-1-j];
		Athree[q+j-2] = Bthree[k-1-j];
		Afour[q+j-2] = 1 - Bfour[k-1-j];
	}
	Sidesizes[0] = q+k-1;
	for(j=0; j<k; j=j+1){
		Flipone[j] = Bone[j];
		Fliptwo[j] = Btwo[j];
		Flipthree[j] = Bthree[j];
		Flipfour[j] = Bfour[j];
	}
	for(j=0; j<Sidesizes[2]; j=j+1){
                Bone[j] = Cone[j];
                Btwo[j] = Ctwo[j];
                Bthree[j] = Cthree[j];
                Bfour[j] = Cfour[j];
        }
	for(j=0; j<Sidesizes[3]; j=j+1){
                Cone[j] = Done[j];
                Ctwo[j] = Dtwo[j];
                Cthree[j] = Dthree[j];
                Cfour[j] = Dfour[j];
        }
	for(j=0; j<k; j=j+1){
                Done[j] = Flipone[j];
                Dtwo[j] = Fliptwo[j];
                Dthree[j] = Flipthree[j];
                Dfour[j] = Flipfour[j];
        }
	Sidesizes[1] = Sidesizes[2];
	Sidesizes[2] = Sidesizes[3];
	Sidesizes[3] = k;
}

public static void MoveD(int[] Aone, int[] Atwo, int[] Athree,
int[] Afour, double[] Afive, int[] Bone, int[] Btwo,
int[] Bthree, int[] Bfour, double[] Bfive, int[]
Cone, int[] Ctwo, int[] Cthree, int[] Cfour, double[] Cfive,
int[] Done, int[] Dtwo, int[] Dthree, int[] Dfour,
double[] Dfive, int[] Sidesizes){
	int[] Flipone, Fliptwo, Flipthree, Flipfour;
        Flipone = new int[100000]; 
        Fliptwo = new int[100000];
        Flipthree = new int[100000];
        Flipfour = new int[100000];
        int j; 
        int q; 
        int k; 
        q = Sidesizes[2]; 
        k = Sidesizes[3];
	for(j=0; j<k; j=j+1){
		Flipone[j] = Done[j];
		Fliptwo[j] = Dtwo[j];
		Flipthree[j] = Dthree[j];
		Flipfour[j] = Dfour[j];
	}
        for(j=0; j<q; j=j+1){ 
                Done[j] = Cone[j];
		Dtwo[j] = 2*Ctwo[j];
        }
	for(j=0; j<q-1; j=j+1){
		Dthree[j] = Cthree[j];
		Dfour[j] = Cfour[j];
	}
	for(j=1; j<k; j=j+1){ 
                Done[q+j-1] = 2*Fliptwo[k-1-j] - Flipone[k-1-j];
                Dtwo[q+j-1] = 2*Fliptwo[k-1-j];
                Dthree[q+j-2] = Flipthree[k-1-j];
                Dfour[q+j-2] = 1 - Flipfour[k-1-j];
        } 
        Sidesizes[3] = q+k-1; 
        for(j=0; j<q; j=j+1){
                Flipone[j] = Cone[j];
                Fliptwo[j] = Ctwo[j];
                Flipthree[j] = Cthree[j];
                Flipfour[j] = Cfour[j];
        } 
        for(j=0; j<Sidesizes[1]; j=j+1){
                Cone[j] = Bone[j];
                Ctwo[j] = Btwo[j];
                Cthree[j] = Bthree[j]; 
                Cfour[j] = Bfour[j]; 
        } 
        for(j=0; j<Sidesizes[0]; j=j+1){ 
                Bone[j] = Aone[j];
                Btwo[j] = Atwo[j];
                Bthree[j] = Athree[j];
                Bfour[j] = Afour[j]; 
        }
	for(j=1; j<q; j=j+1){ 
                Aone[j] = Fliptwo[q-1-j] - Flipone[q-1-j]; 
                Atwo[j] = Fliptwo[q-1-j];
                Athree[j-1] = Flipthree[q-1-j];
                Afour[j-1] = 1 - Flipfour[q-1-j];
        } 
        Sidesizes[2] = Sidesizes[1];
        Sidesizes[1] = Sidesizes[0];
        Sidesizes[0] = q;
}

public static void MoveE(int[] Aone, int[] Atwo, int[] Athree,
int[] Afour, double[] Afive, int[] Bone, int[] Btwo,
int[] Bthree, int[] Bfour, double[] Bfive, int[]
Cone, int[] Ctwo, int[] Cthree, int[] Cfour, double[] Cfive, 
int[]Done, int[] Dtwo, int[] Dthree, int[] Dfour,
double[] Dfive, int[] Sidesizes){
	int[] Tea;
	Tea = new int[100000];
        int q; 
        q = Sidesizes[3]; 
        int j;
        j = 0; 
        for(j = 0; j < q; j = j+1){ 
        	Tea[j] = Done[j];
        } 
        for(j = 0; j < q; j = j+1){
                Done[j] = Dtwo[q-1-j] - Tea[q-1-j];
        } 
        for(j = 0; j < q; j = j+1){ 
                Tea[j] = Dtwo[j];
        } 
       	for(j = 0; j < q; j = j+1){ 
                Dtwo[j] = Tea[q-1-j];
        } 
        for(j = 0; j < q-1; j = j+1){
                Tea[j] = Dthree[j];
        } 
        for(j = 0; j < q-1; j = j+1){ 
                Dthree[j] = Tea[q-2-j]; 
        }
	for(j = 0; j < q-1; j = j+1){
               	Tea[j] = Dfour[j]; 
        } 
        for(j = 0; j < q-1; j = j+1){
                Dfour[j] = 1 - Tea[q-2-j];
        } 
       	q = Sidesizes[2]; 
        for(j = 1; j < q; j = j+1){  
                Ctwo[j] = 2*Ctwo[j];
        } 
        int k; 
        k = Sidesizes[3];
        for(j=1; j < k; j = j+1){ 
                Cone[q+j-1] = Done[j] + Dtwo[j];
                Ctwo[q+j-1] = 2*Dtwo[j];
                Cthree[q+j-2] = Dthree[j-1];
                Cfour[q+j-2] = Dfour[j-1];
        } 
        Sidesizes[2] = q+k-1;
}

public static void MoveF(int[] Aone, int[] Atwo, int[] Athree,
int[] Afour, double[] Afive, int[] Bone, int[] Btwo,
int[] Bthree, int[] Bfour, double[] Bfive, int[]
Cone, int[] Ctwo, int[] Cthree, int[] Cfour, double[] Cfive,
int[] Done, int[] Dtwo, int[] Dthree, int[] Dfour,
double[] Dfive, int[] Sidesizes){
	int q; 
        int j; 
        q = Sidesizes[3]; 
        for(j=1; j < q; j = j+1){ 
                Dtwo[j] = 2*Dtwo[j];
        } 
        int k;
        k = Sidesizes[2];
        for(j=1; j < k; j = j+1){
                Done[q+j-1] = Cone[j] + Ctwo[j]; 
                Dtwo[q+j-1] = 2*Ctwo[j]; 
                Dthree[q+j-2] = Cthree[j-1]; 
                Dfour[q+j-2] = Cfour[j-1]; 
        } 
        Sidesizes[3] = q+k-1;
}

public static void MoveG(int[] Aone, int[] Atwo, int[] Athree,
int[] Afour, double[] Afive, int[] Bone, int[] Btwo,
int[] Bthree, int[] Bfour, double[] Bfive, int[]
Cone, int[] Ctwo, int[] Cthree, int[] Cfour, double[] Cfive,
int[] Done, int[] Dtwo, int[] Dthree, int[] Dfour,
double[] Dfive, int[] Sidesizes){
	int[] Flipone, Fliptwo, Flipthree, Flipfour;
        Flipone = new int[100000]; 
        Fliptwo = new int[100000];
        Flipthree = new int[100000];
        Flipfour = new int[100000];
        int j; 
        int q; 
        int k; 
        q = Sidesizes[3]; 
        k = Sidesizes[2];
        for(j=1; j<q; j=j+1){ 
                Dtwo[j] = 2*Dtwo[j];
        }
	for(j=1; j<k; j=j+1){ 
                Done[q+j-1] = 2*Ctwo[k-1-j] - Cone[k-1-j];
                Dtwo[q+j-1] = 2*Ctwo[k-1-j];
                Dthree[q+j-2] = Cthree[k-1-j];
                Dfour[q+j-2] = 1 - Cfour[k-1-j];
        } 
        Sidesizes[3] = q+k-1; 
        for(j=0; j<k; j=j+1){ 
                Flipone[j] = Cone[j];
                Fliptwo[j] = Ctwo[j];
                Flipthree[j] = Cthree[j];
                Flipfour[j] = Cfour[j];
        } 
        for(j=0; j<Sidesizes[1]; j=j+1){
                Cone[j] = Bone[j];
                Ctwo[j] = Btwo[j];     
                Cthree[j] = Bthree[j];
                Cfour[j] = Bfour[j];
        }
	 for(j=0; j<Sidesizes[0]; j=j+1){ 
                Bone[j] = Aone[j];
                Btwo[j] = Atwo[j];
                Bthree[j] = Athree[j];
                Bfour[j] = Afour[j]; 
        } 
        for(j=0; j<k; j=j+1){ 
                Aone[j] = Flipone[j];  
                Atwo[j] = Fliptwo[j];
                Athree[j] = Flipthree[j];
                Afour[j] = Flipfour[j];
        } 
        Sidesizes[2] = Sidesizes[1];   
        Sidesizes[1] = Sidesizes[0]; 
        Sidesizes[0] = k;
}

public static void MoveH(int[] Aone, int[] Atwo, int[] Athree,
int[] Afour, double[] Afive, int[] Bone, int[] Btwo,
int[] Bthree, int[] Bfour, double[] Bfive, int[]
Cone, int[] Ctwo, int[] Cthree, int[] Cfour, double[] Cfive, 
int[] Done, int[] Dtwo, int[] Dthree, int[] Dfour,
double[] Dfive, int[] Sidesizes){
	int[] Flipone, Fliptwo, Flipthree, Flipfour;
        Flipone = new int[100000];   
        Fliptwo = new int[100000];   
        Flipthree = new int[100000];
        Flipfour = new int[100000];
        int j; 
        int q; 
        int k;
        q = Sidesizes[1]; 
        k = Sidesizes[0]; 
        for(j=0; j<k; j=j+1){ 
                Flipone[j] = Aone[j]; 
                Fliptwo[j] = Atwo[j]; 
                Flipthree[j] = Athree[j];
                Flipfour[j] = Afour[j];
        }
	for(j=0; j<q; j=j+1){
                Aone[j] = Bone[j];  
                Atwo[j] = 2*Btwo[j];  
        } 
        for(j=0; j<q-1; j=j+1){
                Athree[j] = Bthree[j];
                Afour[j] = Bfour[j]; 
        } 
        for(j=1; j<k; j=j+1){ 
                Aone[q+j-1] = 2*Fliptwo[k-1-j] - Flipone[k-1-j];
                Atwo[q+j-1] = 2*Fliptwo[k-1-j];   
                Athree[q+j-2] = Flipthree[k-1-j];
                Afour[q+j-2] = 1 - Flipfour[k-1-j]; 
        } 
        Sidesizes[0] = q+k-1;
	for(j=0; j<q; j=j+1){ 
                Flipone[j] = Bone[j]; 
                Fliptwo[j] = Btwo[j];
                Flipthree[j] = Bthree[j];
                Flipfour[j] = Bfour[j];
        } 
        for(j=0; j<Sidesizes[2]; j=j+1){
                Bone[j] = Cone[j];
                Btwo[j] = Ctwo[j];
                Bthree[j] = Cthree[j]; 
                Bfour[j] = Cfour[j]; 
        } 
        for(j=0; j<Sidesizes[3]; j=j+1){ 
                Cone[j] = Done[j];
                Ctwo[j] = Dtwo[j];
                Cthree[j] = Dthree[j];
                Cfour[j] = Dfour[j]; 
        } 
        for(j=1; j<q; j=j+1){ 
                Done[j] = Fliptwo[q-1-j] - Flipone[q-1-j];
                Dtwo[j] = Fliptwo[q-1-j];
                Dthree[j-1] = Flipthree[q-1-j];
                Dfour[j-1] = 1 - Flipfour[q-1-j];
        } 
        Sidesizes[1] = Sidesizes[2];  
        Sidesizes[2] = Sidesizes[3];
        Sidesizes[3] = q;
}

public static void pathentry(int k, char[] funky, int[] Aone, 
int[] Atwo, int[] Athree, int[] Afour, double[] Afive, 
int[] Bone, int[] Btwo, int[] Bthree, int[] Bfour, double[] Bfive, 
int[] Cone, int[] Ctwo, int[] Cthree, int[] Cfour, double[] Cfive, 
int[] Done, int[]  Dtwo, int[] Dthree, int[] Dfour, double[] Dfive, 
int[] Sidesizes){
        int i;
        i=0;     
        for(i=0; i<k; i++){
            if(funky[k-1-i] == 'A'){
		MoveA(Aone, Atwo, Athree, Afour, Afive,
            	Bone, Btwo, Bthree, Bfour, Bfive, Cone,
            	Ctwo, Cthree, Cfour, Cfive, Done, Dtwo,
            	Dthree, Dfour, Dfive, Sidesizes);                
            } 
            else if (funky[k-1-i] == 'B'){ 
                MoveB(Aone, Atwo, Athree, Afour, Afive,
            	Bone, Btwo, Bthree, Bfour, Bfive, Cone,
            	Ctwo, Cthree, Cfour, Cfive, Done, Dtwo,
            	Dthree, Dfour, Dfive, Sidesizes);
            }
	    else if (funky[k-1-i] == 'C'){
                MoveC(Aone, Atwo, Athree, Afour, Afive,
            	Bone, Btwo, Bthree, Bfour, Bfive, Cone,
            	Ctwo, Cthree, Cfour, Cfive, Done, Dtwo,
            	Dthree, Dfour, Dfive, Sidesizes);
            }
	    else if (funky[k-1-i] == 'D'){
                MoveD(Aone, Atwo, Athree, Afour, Afive,
            	Bone, Btwo, Bthree, Bfour, Bfive, Cone,
            	Ctwo, Cthree, Cfour, Cfive, Done, Dtwo,
            	Dthree, Dfour, Dfive, Sidesizes);
            }
            else if (funky[k-1-i] == 'E'){ 
                MoveE(Aone, Atwo, Athree, Afour, Afive,
            	Bone, Btwo, Bthree, Bfour, Bfive, Cone,
            	Ctwo, Cthree, Cfour, Cfive, Done, Dtwo,
            	Dthree, Dfour, Dfive, Sidesizes);
            }
	    else if (funky[k-1-i] == 'F'){ 
                MoveF(Aone, Atwo, Athree, Afour, Afive,
            	Bone, Btwo, Bthree, Bfour, Bfive, Cone,
            	Ctwo, Cthree, Cfour, Cfive, Done, Dtwo,
            	Dthree, Dfour, Dfive, Sidesizes);
            }
            else if (funky[k-1-i] == 'G'){
                MoveG(Aone, Atwo, Athree, Afour, Afive,
            	Bone, Btwo, Bthree, Bfour, Bfive, Cone,
            	Ctwo, Cthree, Cfour, Cfive, Done, Dtwo,
            	Dthree, Dfour, Dfive, Sidesizes);
            }
            else if (funky[k-1-i] == 'H'){
                MoveH(Aone, Atwo, Athree, Afour, Afive,
            	Bone, Btwo, Bthree, Bfour, Bfive, Cone,
            	Ctwo, Cthree, Cfour, Cfive, Done, Dtwo,
            	Dthree, Dfour, Dfive, Sidesizes);
            }
        } 
}

public static int[] Reduce(int a, int b){
	int[] Nyuk;
	Nyuk = new int[2];
	if (a == 0){
		Nyuk[0] = 0;
		Nyuk[1] = 1;
	}
	else{
		while((a%2) == 0){
			a = a/2;
			b = b/2;
		}
		Nyuk[0] = a;
		Nyuk[1] = b;
	}
	return Nyuk;
}

public static void ReduceThem(int[] Aone, int[] Atwo, int[] 
Athree, int[] Afour, double[] Afive, int[] Bone, int[] Btwo,
int[] Bthree, int[] Bfour, double[] Bfive, int[]Cone, int[] Ctwo, 
int[] Cthree, int[] Cfour, double[] Cfive, int[] Done, 
int[] Dtwo, int[] Dthree, int[] Dfour, double[] Dfive, 
int[] Sidesizes){
	int j;
	int[] Nyuk;
	Nyuk = new int[2];
	for(j=0; j<Sidesizes[0]; j=j+1){
		Nyuk = Reduce(Aone[j], Atwo[j]);
		Aone[j] = Nyuk[0];
		Atwo[j] = Nyuk[1];
	}
	for(j=0; j<Sidesizes[1]; j=j+1){
                Nyuk = Reduce(Bone[j], Btwo[j]);
                Bone[j] = Nyuk[0];
                Btwo[j] = Nyuk[1];
        }
	for(j=0; j<Sidesizes[2]; j=j+1){
                Nyuk = Reduce(Cone[j], Ctwo[j]);
                Cone[j] = Nyuk[0];
                Ctwo[j] = Nyuk[1];
        }
        for(j=0; j<Sidesizes[3]; j=j+1){
                Nyuk = Reduce(Done[j], Dtwo[j]); 
                Done[j] = Nyuk[0]; 
                Dtwo[j] = Nyuk[1]; 
        }
}

public static int[] Adding(int a, int b, int c, int d){
	int[] NyukNyuk;
	NyukNyuk = new int[2];
	NyukNyuk[0] = (a*d) + (b*c);
	NyukNyuk[1] = b*d;
	NyukNyuk = Reduce(NyukNyuk[0], NyukNyuk[1]);
	return NyukNyuk;
}

public static int[] ReduceAgain(int a, int b){
	int[] Nyuk;
	Nyuk = new int[2];
	int j;
	j = 2;
	if(a == 0){
		a=0;
		b=1;
	}
	else{
		while((j<(a+1)) && (j<(b+1))){
			if(((a%j) == 0) && ((b%j) == 0)){
				a = a/j;
				b = b/j;
				j = 2;
			}
			else{
				j=j+1;
			}
		}	
	}
	Nyuk[0] = a;
	Nyuk[1] = b;
	return Nyuk;
}

public static void Iterate(int[] Aone, int[] Atwo, int[] Athree,
int[] Afour, double[] Afive, int[] Bone, int[] Btwo,
int[] Bthree, int[] Bfour, double[] Bfive, int[]
Cone, int[] Ctwo, int[] Cthree, int[] Cfour, double[] Cfive, 
int[] Done, int[] Dtwo, int[] Dthree, int[] Dfour,
double[] Dfive, int[] Sidesizes){
	int[] AAone, AAtwo, AAthree, AAfour;
	int[] BBone, BBtwo, BBthree, BBfour;
	int[] CCone, CCtwo, CCthree, CCfour;
	int[] DDone, DDtwo, DDthree, DDfour;
	int[] SSidesizes;
	AAone = new int[100000];
	AAtwo = new int[100000];
	AAthree = new int[100000];
	AAfour = new int[100000];
	BBone = new int[100000];
        BBtwo = new int[100000];
        BBthree = new int[100000];
        BBfour = new int[100000];
	CCone = new int[100000];
        CCtwo = new int[100000];
        CCthree = new int[100000];
        CCfour = new int[100000];
        DDone = new int[100000];
        DDtwo = new int[100000];
        DDthree = new int[100000];
        DDfour = new int[100000];
	SSidesizes = new int[4];
	AAone[0] = 0;
	AAtwo[0] = 1;
	BBone[0] = 0;
        BBtwo[0] = 1;
	CCone[0] = 0;
        CCtwo[0] = 1;
        DDone[0] = 0;
        DDtwo[0] = 1;
	SSidesizes[0] = 1;
	SSidesizes[1] = 1;
	SSidesizes[2] = 1;
	SSidesizes[3] = 1;
	int j;
	int k;
	j = 0;
	for(j=0; j<(Sidesizes[0]-1); j=j+1){
		if(Athree[j] == 1){
			if(Afour[j] == 0){
				for(k=0; k<(Sidesizes[0]-1); k=k+1){
					int v;
					int[] NyukNyukNyuk;
                                	NyukNyukNyuk = new int[2];
					NyukNyukNyuk = Adding(-Aone[j], Atwo[j], Aone[j+1], Atwo[j+1]);	
					v = SSidesizes[0];
					NyukNyukNyuk = Adding(Aone[j], Atwo[j], NyukNyukNyuk[0]*Aone[k+1], 
					NyukNyukNyuk[1]*Atwo[k+1]);
					AAone[v+k] = NyukNyukNyuk[0];
					AAtwo[v+k] = NyukNyukNyuk[1];
					AAthree[v+k-1] = Athree[k];
					AAfour[v+k-1] = Afour[k];
				}
				SSidesizes[0] = SSidesizes[0] + Sidesizes[0] - 1;
			}
			else{
				for(k=0; k<(Sidesizes[0]-1); k=k+1){
                                        int v, p;
                                        int[] NyukNyukNyuk;
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Aone[j], Atwo[j], Aone[j+1], Atwo[j+1]);
                                        v = SSidesizes[0];
					p = Sidesizes[0];
                                        NyukNyukNyuk = Adding(Aone[j], Atwo[j], 
					NyukNyukNyuk[0]*(Atwo[p-k-2] - Aone[p-k-2]), 
					NyukNyukNyuk[1]*Atwo[p-k-2]);
                                        AAone[v+k] = NyukNyukNyuk[0];
                                        AAtwo[v+k] = NyukNyukNyuk[1];
                                        AAthree[v+k-1] = Athree[p-k-2];
                                        AAfour[v+k-1] = 1 - Afour[p-k-2];
                                }
                                SSidesizes[0] = SSidesizes[0] + Sidesizes[0] - 1;
			}					
		}
		else if(Athree[j] == 2){
			 if(Afour[j] == 0){
                                for(k=0; k<(Sidesizes[1]-1); k=k+1){
                                        int v;   
                                        int[] NyukNyukNyuk;
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Aone[j], Atwo[j], Aone[j+1], Atwo[j+1]);
                                        v = SSidesizes[0];
                                        NyukNyukNyuk = Adding(Aone[j], Atwo[j], NyukNyukNyuk[0]*Bone[k+1],
                                        NyukNyukNyuk[1]*Btwo[k+1]); 
                                        AAone[v+k] = NyukNyukNyuk[0]; 
                                        AAtwo[v+k] = NyukNyukNyuk[1];
                                        AAthree[v+k-1] = Bthree[k];  
                                        AAfour[v+k-1] = Bfour[k]; 
                                } 
                                SSidesizes[0] = SSidesizes[0] + Sidesizes[1] - 1;
                        }
			else{
                                for(k=0; k<(Sidesizes[1]-1); k=k+1){
                                        int v, p;
                                        int[] NyukNyukNyuk;
                                        NyukNyukNyuk = new int[2];  
                                        NyukNyukNyuk = Adding(-Aone[j], Atwo[j], Aone[j+1], Atwo[j+1]);
                                        v = SSidesizes[0]; 
                                        p = Sidesizes[1]; 
                                        NyukNyukNyuk = Adding(Aone[j], Atwo[j], 
                                        NyukNyukNyuk[0]*(Btwo[p-k-2] - Bone[p-k-2]), 
					NyukNyukNyuk[1]*Btwo[p-k-2]);
                                        AAone[v+k] = NyukNyukNyuk[0]; 
                                        AAtwo[v+k] = NyukNyukNyuk[1];
                                        AAthree[v+k-1] = Bthree[p-k-2];
                                        AAfour[v+k-1] = 1 - Bfour[p-k-2];
                                } 
                                SSidesizes[0] = SSidesizes[0] + Sidesizes[1] - 1;
                        }
		}
		else if(Athree[j] == 3){
			if(Afour[j] == 0){
                                for(k=0; k<(Sidesizes[2]-1); k=k+1){
                                        int v;   
                                        int[] NyukNyukNyuk;
                                        NyukNyukNyuk = new int[2];   
                                        NyukNyukNyuk = Adding(-Aone[j], Atwo[j], Aone[j+1], Atwo[j+1]);
                                        v = SSidesizes[0];  
                                        NyukNyukNyuk = Adding(Aone[j], Atwo[j], NyukNyukNyuk[0]*Cone[k+1],
                                        NyukNyukNyuk[1]*Ctwo[k+1]); 
                                        AAone[v+k] = NyukNyukNyuk[0]; 
                                        AAtwo[v+k] = NyukNyukNyuk[1];
                                        AAthree[v+k-1] = Cthree[k];  
                                        AAfour[v+k-1] = Cfour[k]; 
                                } 
                                SSidesizes[0] = SSidesizes[0] + Sidesizes[2] - 1;
                        }
			else{ 
                                for(k=0; k<(Sidesizes[2]-1); k=k+1){
                                        int v, p;
                                        int[] NyukNyukNyuk;
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Aone[j], Atwo[j], Aone[j+1], Atwo[j+1]);
                                        v = SSidesizes[0];
                                        p = Sidesizes[2]; 
                                        NyukNyukNyuk = Adding(Aone[j], Atwo[j],
                                        NyukNyukNyuk[0]*(Ctwo[p-k-2] - Cone[p-k-2]),
                                        NyukNyukNyuk[1]*Ctwo[p-k-2]);
                                        AAone[v+k] = NyukNyukNyuk[0]; 
                                        AAtwo[v+k] = NyukNyukNyuk[1];
                                        AAthree[v+k-1] = Cthree[p-k-2];
                                        AAfour[v+k-1] = 1 - Cfour[p-k-2]; 
                                }
                                SSidesizes[0] = SSidesizes[0] + Sidesizes[2] - 1;
                        }
		}
		else{
			if(Afour[j] == 0){
                                for(k=0; k<(Sidesizes[3]-1); k=k+1){
                                        int v;   
                                        int[] NyukNyukNyuk;
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Aone[j], Atwo[j], Aone[j+1], Atwo[j+1]);
                                        v = SSidesizes[0];
                                        NyukNyukNyuk = Adding(Aone[j], Atwo[j], NyukNyukNyuk[0]*Done[k+1],
                                        NyukNyukNyuk[1]*Dtwo[k+1]); 
                                        AAone[v+k] = NyukNyukNyuk[0]; 
                                        AAtwo[v+k] = NyukNyukNyuk[1];
                                        AAthree[v+k-1] = Dthree[k];   
                                        AAfour[v+k-1] = Dfour[k]; 
                                } 
                                SSidesizes[0] = SSidesizes[0] + Sidesizes[3] - 1;
                        }
			else{ 
                                for(k=0; k<(Sidesizes[3]-1); k=k+1){
                                        int v, p;
                                        int[] NyukNyukNyuk;
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Aone[j], Atwo[j], Aone[j+1], Atwo[j+1]);
                                        v = SSidesizes[0];
                                        p = Sidesizes[3]; 
                                        NyukNyukNyuk = Adding(Aone[j], Atwo[j],
                                        NyukNyukNyuk[0]*(Dtwo[p-k-2] - Done[p-k-2]),
                                        NyukNyukNyuk[1]*Dtwo[p-k-2]);
                                        AAone[v+k] = NyukNyukNyuk[0]; 
                                        AAtwo[v+k] = NyukNyukNyuk[1];
                                        AAthree[v+k-1] = Dthree[p-k-2];
                                        AAfour[v+k-1] = 1 - Dfour[p-k-2]; 
                                }
                                SSidesizes[0] = SSidesizes[0] + Sidesizes[3] - 1;
                        }
		}
	}
	for(j=0; j<(Sidesizes[1]-1); j=j+1){
		if(Bthree[j] == 1){
			if(Bfour[j] == 0){
                                	for(k=0; k<(Sidesizes[0]-1); k=k+1){
                                        int v;
                                        int[] NyukNyukNyuk;
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Bone[j], Btwo[j], Bone[j+1], Btwo[j+1]);
                                        v = SSidesizes[1];
                                        NyukNyukNyuk = Adding(Bone[j], Btwo[j], NyukNyukNyuk[0]*Aone[k+1],
                                        NyukNyukNyuk[1]*Atwo[k+1]);
                                        BBone[v+k] = NyukNyukNyuk[0];
                                        BBtwo[v+k] = NyukNyukNyuk[1];
                                        BBthree[v+k-1] = Athree[k];
                                        BBfour[v+k-1] = Afour[k];
                                }
                                SSidesizes[1] = SSidesizes[1] + Sidesizes[0] - 1;
                        }
                        else{ 
                                	for(k=0; k<(Sidesizes[0]-1); k=k+1){
                                        int v, p;
                                        int[] NyukNyukNyuk; 
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Bone[j], Btwo[j], Bone[j+1], Btwo[j+1]);
                                        v = SSidesizes[1]; 
                                        p = Sidesizes[0]; 
                                        NyukNyukNyuk = Adding(Bone[j], Btwo[j],
                                        NyukNyukNyuk[0]*(Atwo[p-k-2] - Aone[p-k-2]), 
                                        NyukNyukNyuk[1]*Atwo[p-k-2]);  
                                        BBone[v+k] = NyukNyukNyuk[0];
                                        BBtwo[v+k] = NyukNyukNyuk[1];  
                                        BBthree[v+k-1] = Athree[p-k-2];
                                        BBfour[v+k-1] = 1 - Afour[p-k-2];
                                } 
                                SSidesizes[1] = SSidesizes[1] + Sidesizes[0] - 1;
                        }
		}
		else if(Bthree[j] == 2){
			if(Bfour[j] == 0){
                                	for(k=0; k<(Sidesizes[1]-1); k=k+1){
                                        int v;
                                        int[] NyukNyukNyuk;
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Bone[j], Btwo[j], Bone[j+1], Btwo[j+1]);
                                        v = SSidesizes[1];
                                        NyukNyukNyuk = Adding(Bone[j], Btwo[j], NyukNyukNyuk[0]*Bone[k+1],
                                        NyukNyukNyuk[1]*Btwo[k+1]);
                                        BBone[v+k] = NyukNyukNyuk[0];
                                        BBtwo[v+k] = NyukNyukNyuk[1];
                                        BBthree[v+k-1] = Bthree[k];
                                        BBfour[v+k-1] = Bfour[k];
                                }
                                SSidesizes[1] = SSidesizes[1] + Sidesizes[1] - 1;
                        }
                        else{ 
                                	for(k=0; k<(Sidesizes[1]-1); k=k+1){
                                        int v, p;
                                        int[] NyukNyukNyuk; 
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Bone[j], Btwo[j], Bone[j+1], Btwo[j+1]);
                                        v = SSidesizes[1]; 
                                        p = Sidesizes[1]; 
                                        NyukNyukNyuk = Adding(Bone[j], Btwo[j],
                                        NyukNyukNyuk[0]*(Btwo[p-k-2] - Bone[p-k-2]), 
                                        NyukNyukNyuk[1]*Btwo[p-k-2]);  
                                        BBone[v+k] = NyukNyukNyuk[0];
                                        BBtwo[v+k] = NyukNyukNyuk[1];  
                                        BBthree[v+k-1] = Bthree[p-k-2];
                                        BBfour[v+k-1] = 1 - Bfour[p-k-2];
                                } 
                                SSidesizes[1] = SSidesizes[1] + Sidesizes[1] - 1;
                        }
		}
		else if(Bthree[j] == 3){
			if(Bfour[j] == 0){
                                	for(k=0; k<(Sidesizes[2]-1); k=k+1){
                                	int v;
                                        int[] NyukNyukNyuk;
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Bone[j], Btwo[j], Bone[j+1], Btwo[j+1]);
                                        v = SSidesizes[1];
                                        NyukNyukNyuk = Adding(Bone[j], Btwo[j], NyukNyukNyuk[0]*Cone[k+1],
                                        NyukNyukNyuk[1]*Ctwo[k+1]);
                                        BBone[v+k] = NyukNyukNyuk[0];
                                        BBtwo[v+k] = NyukNyukNyuk[1];
                                        BBthree[v+k-1] = Cthree[k];
                                        BBfour[v+k-1] = Cfour[k];
                                }
                                SSidesizes[1] = SSidesizes[1] + Sidesizes[2] - 1;
                        }
                        else{ 
                                	for(k=0; k<(Sidesizes[2]-1); k=k+1){
                                        int v, p;
                                        int[] NyukNyukNyuk; 
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Bone[j], Btwo[j], Bone[j+1], Btwo[j+1]);
                                        v = SSidesizes[1]; 
                                        p = Sidesizes[2]; 
                                        NyukNyukNyuk = Adding(Bone[j], Btwo[j],
                                        NyukNyukNyuk[0]*(Ctwo[p-k-2] - Cone[p-k-2]), 
                                        NyukNyukNyuk[1]*Ctwo[p-k-2]);  
                                        BBone[v+k] = NyukNyukNyuk[0];
                                        BBtwo[v+k] = NyukNyukNyuk[1];  
                                        BBthree[v+k-1] = Cthree[p-k-2];
                                        BBfour[v+k-1] = 1 - Cfour[p-k-2];
                                } 
                                SSidesizes[1] = SSidesizes[1] + Sidesizes[2] - 1;
                        }
		}
		else{
			if(Bfour[j] == 0){
                                	for(k=0; k<(Sidesizes[3]-1); k=k+1){
                                        int v;
                                        int[] NyukNyukNyuk;
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Bone[j], Btwo[j], Bone[j+1], Btwo[j+1]);
                                        v = SSidesizes[1];
                                        NyukNyukNyuk = Adding(Bone[j], Btwo[j], NyukNyukNyuk[0]*Done[k+1],
                                        NyukNyukNyuk[1]*Dtwo[k+1]);
                                        BBone[v+k] = NyukNyukNyuk[0];
                                        BBtwo[v+k] = NyukNyukNyuk[1];
                                        BBthree[v+k-1] = Dthree[k];
                                        BBfour[v+k-1] = Dfour[k];
                                }
                                SSidesizes[1] = SSidesizes[1] + Sidesizes[3] - 1;
                        }
                        else{ 
                                	for(k=0; k<(Sidesizes[3]-1); k=k+1){
                                        int v, p;
                                        int[] NyukNyukNyuk; 
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Bone[j], Btwo[j], Bone[j+1], Btwo[j+1]);
                                        v = SSidesizes[1]; 
                                        p = Sidesizes[3]; 
                                        NyukNyukNyuk = Adding(Bone[j], Btwo[j],
                                        NyukNyukNyuk[0]*(Dtwo[p-k-2] - Done[p-k-2]), 
                                        NyukNyukNyuk[1]*Dtwo[p-k-2]);  
                                        BBone[v+k] = NyukNyukNyuk[0];
                                        BBtwo[v+k] = NyukNyukNyuk[1];  
                                        BBthree[v+k-1] = Dthree[p-k-2];
                                        BBfour[v+k-1] = 1 - Dfour[p-k-2];
                                } 
                                SSidesizes[1] = SSidesizes[1] + Sidesizes[3] - 1;
                        }
		}
	}
	for(j=0; j<(Sidesizes[2]-1); j=j+1){
                if(Cthree[j] == 1){ 
                	if(Cfour[j] == 0){
                                	for(k=0; k<(Sidesizes[0]-1); k=k+1){
                                        int v;
                                        int[] NyukNyukNyuk;
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Cone[j], Ctwo[j], Cone[j+1], Ctwo[j+1]);
                                        v = SSidesizes[2];
                                        NyukNyukNyuk = Adding(Cone[j], Ctwo[j], NyukNyukNyuk[0]*Aone[k+1],
                                        NyukNyukNyuk[1]*Atwo[k+1]);
                                        CCone[v+k] = NyukNyukNyuk[0];
                                        CCtwo[v+k] = NyukNyukNyuk[1];
                                        CCthree[v+k-1] = Athree[k];
                                        CCfour[v+k-1] = Afour[k];
                                }
                                SSidesizes[2] = SSidesizes[2] + Sidesizes[0] - 1;
                        }
                        else{ 
                                	for(k=0; k<(Sidesizes[0]-1); k=k+1){
                                        int v, p;
                                        int[] NyukNyukNyuk; 
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Cone[j], Ctwo[j], Cone[j+1], Ctwo[j+1]);
                                        v = SSidesizes[2]; 
                                        p = Sidesizes[0]; 
                                        NyukNyukNyuk = Adding(Cone[j], Ctwo[j],
                                        NyukNyukNyuk[0]*(Atwo[p-k-2] - Aone[p-k-2]), 
                                        NyukNyukNyuk[1]*Atwo[p-k-2]);  
                                        CCone[v+k] = NyukNyukNyuk[0];
                                        CCtwo[v+k] = NyukNyukNyuk[1];  
                                        CCthree[v+k-1] = Athree[p-k-2];
                                        CCfour[v+k-1] = 1 - Afour[p-k-2];
                                } 
                                SSidesizes[2] = SSidesizes[2] + Sidesizes[0] - 1;
                        }
                }
                else if(Cthree[j] == 2){ 
                	if(Cfour[j] == 0){
                                	for(k=0; k<(Sidesizes[1]-1); k=k+1){
                                        int v;
                                        int[] NyukNyukNyuk;
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Cone[j], Ctwo[j], Cone[j+1], Ctwo[j+1]);
                                        v = SSidesizes[2];
                                        NyukNyukNyuk = Adding(Cone[j], Ctwo[j], NyukNyukNyuk[0]*Bone[k+1],
                                        NyukNyukNyuk[1]*Btwo[k+1]);
                                        CCone[v+k] = NyukNyukNyuk[0];
                                        CCtwo[v+k] = NyukNyukNyuk[1];
                                        CCthree[v+k-1] = Bthree[k];
                                        CCfour[v+k-1] = Bfour[k];
                                }
                                SSidesizes[2] = SSidesizes[2] + Sidesizes[1] - 1;
                        }
                        else{ 
                                	for(k=0; k<(Sidesizes[1]-1); k=k+1){
                                        int v, p;
                                        int[] NyukNyukNyuk; 
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Cone[j], Ctwo[j], Cone[j+1], Ctwo[j+1]);
                                        v = SSidesizes[2]; 
                                        p = Sidesizes[1]; 
                                        NyukNyukNyuk = Adding(Cone[j], Ctwo[j],
                                        NyukNyukNyuk[0]*(Btwo[p-k-2] - Bone[p-k-2]), 
                                        NyukNyukNyuk[1]*Btwo[p-k-2]);  
                                        CCone[v+k] = NyukNyukNyuk[0];
                                        CCtwo[v+k] = NyukNyukNyuk[1];  
                                        CCthree[v+k-1] = Bthree[p-k-2];
                                        CCfour[v+k-1] = 1 - Bfour[p-k-2];
                                } 
                                SSidesizes[2] = SSidesizes[2] + Sidesizes[1] - 1;
                        }
                } 
                else if(Cthree[j] == 3){
                	if(Cfour[j] == 0){
                                	for(k=0; k<(Sidesizes[2]-1); k=k+1){
                                        int v;
                                        int[] NyukNyukNyuk;
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Cone[j], Ctwo[j], Cone[j+1], Ctwo[j+1]);
                                        v = SSidesizes[2];
                                        NyukNyukNyuk = Adding(Cone[j], Ctwo[j], NyukNyukNyuk[0]*Cone[k+1],
                                        NyukNyukNyuk[1]*Ctwo[k+1]);
                                        CCone[v+k] = NyukNyukNyuk[0];
                                        CCtwo[v+k] = NyukNyukNyuk[1];
                                        CCthree[v+k-1] = Cthree[k];
                                        CCfour[v+k-1] = Cfour[k];
                                }
                                SSidesizes[2] = SSidesizes[2] + Sidesizes[2] - 1;
                        }
                        else{ 
                                	for(k=0; k<(Sidesizes[2]-1); k=k+1){
                                        int v, p;
                                        int[] NyukNyukNyuk; 
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Cone[j], Ctwo[j], Cone[j+1], Ctwo[j+1]);
                                        v = SSidesizes[2]; 
                                        p = Sidesizes[2]; 
                                        NyukNyukNyuk = Adding(Cone[j], Ctwo[j],
                                        NyukNyukNyuk[0]*(Ctwo[p-k-2] - Cone[p-k-2]), 
                                        NyukNyukNyuk[1]*Ctwo[p-k-2]);  
                                        CCone[v+k] = NyukNyukNyuk[0];
                                        CCtwo[v+k] = NyukNyukNyuk[1];  
                                        CCthree[v+k-1] = Cthree[p-k-2];
                                        CCfour[v+k-1] = 1 - Cfour[p-k-2];
                                } 
                                SSidesizes[2] = SSidesizes[2] + Sidesizes[2] - 1;
                        } 
                }
                else{ 
                	if(Cfour[j] == 0){
                                	for(k=0; k<(Sidesizes[3]-1); k=k+1){
                                        int v;
                                        int[] NyukNyukNyuk;
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Cone[j], Ctwo[j], Cone[j+1], Ctwo[j+1]);
                                        v = SSidesizes[2];
                                        NyukNyukNyuk = Adding(Cone[j], Ctwo[j], NyukNyukNyuk[0]*Done[k+1],
                                        NyukNyukNyuk[1]*Dtwo[k+1]);
                                        CCone[v+k] = NyukNyukNyuk[0];
                                        CCtwo[v+k] = NyukNyukNyuk[1];
                                        CCthree[v+k-1] = Dthree[k];
                                        CCfour[v+k-1] = Dfour[k];
                                }
                                SSidesizes[2] = SSidesizes[2] + Sidesizes[3] - 1;
                        }
                        else{ 
                                	for(k=0; k<(Sidesizes[3]-1); k=k+1){
                                        int v, p;
                                        int[] NyukNyukNyuk; 
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Cone[j], Ctwo[j], Cone[j+1], Ctwo[j+1]);
                                        v = SSidesizes[2]; 
                                        p = Sidesizes[3]; 
                                        NyukNyukNyuk = Adding(Cone[j], Ctwo[j],
                                        NyukNyukNyuk[0]*(Dtwo[p-k-2] - Done[p-k-2]), 
                                        NyukNyukNyuk[1]*Dtwo[p-k-2]);  
                                        CCone[v+k] = NyukNyukNyuk[0];
                                        CCtwo[v+k] = NyukNyukNyuk[1];  
                                        CCthree[v+k-1] = Dthree[p-k-2];
                                        CCfour[v+k-1] = 1 - Dfour[p-k-2];
                                } 
                                SSidesizes[2] = SSidesizes[2] + Sidesizes[3] - 1;
                        }
                } 
        }
	for(j=0; j<(Sidesizes[3]-1); j=j+1){
                if(Dthree[j] == 1){ 
                	if(Dfour[j] == 0){
                                	for(k=0; k<(Sidesizes[0]-1); k=k+1){
                                        int v;
                                        int[] NyukNyukNyuk;
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Done[j], Dtwo[j], Done[j+1], Dtwo[j+1]);
                                        v = SSidesizes[3];
                                        NyukNyukNyuk = Adding(Done[j], Dtwo[j], NyukNyukNyuk[0]*Aone[k+1],
                                        NyukNyukNyuk[1]*Atwo[k+1]);
                                        DDone[v+k] = NyukNyukNyuk[0];
                                        DDtwo[v+k] = NyukNyukNyuk[1];
                                        DDthree[v+k-1] = Athree[k];
                                        DDfour[v+k-1] = Afour[k];
                                }
                                SSidesizes[3] = SSidesizes[3] + Sidesizes[0] - 1;
                        }
                        else{ 
                                	for(k=0; k<(Sidesizes[0]-1); k=k+1){
                                        int v, p;
                                        int[] NyukNyukNyuk; 
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Done[j], Dtwo[j], Done[j+1], Dtwo[j+1]);
                                        v = SSidesizes[3]; 
                                        p = Sidesizes[0]; 
                                        NyukNyukNyuk = Adding(Done[j], Dtwo[j],
                                        NyukNyukNyuk[0]*(Atwo[p-k-2] - Aone[p-k-2]), 
                                        NyukNyukNyuk[1]*Atwo[p-k-2]);  
                                        DDone[v+k] = NyukNyukNyuk[0];
                                        DDtwo[v+k] = NyukNyukNyuk[1];  
                                        DDthree[v+k-1] = Athree[p-k-2];
                                        DDfour[v+k-1] = 1 - Afour[p-k-2];
                                } 
                                SSidesizes[3] = SSidesizes[3] + Sidesizes[0] - 1;
                        } 	
                }
                else if(Dthree[j] == 2){ 
                	if(Dfour[j] == 0){
                                	for(k=0; k<(Sidesizes[1]-1); k=k+1){
                                        int v;
                                        int[] NyukNyukNyuk;
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Done[j], Dtwo[j], Done[j+1], Dtwo[j+1]);
                                        v = SSidesizes[3];
                                        NyukNyukNyuk = Adding(Done[j], Dtwo[j], NyukNyukNyuk[0]*Bone[k+1],
                                        NyukNyukNyuk[1]*Btwo[k+1]);
                                        DDone[v+k] = NyukNyukNyuk[0];
                                        DDtwo[v+k] = NyukNyukNyuk[1];
                                        DDthree[v+k-1] = Bthree[k];
                                        DDfour[v+k-1] = Bfour[k];
                                }
                                SSidesizes[3] = SSidesizes[3] + Sidesizes[1] - 1;
                        }
                        else{ 
                                	for(k=0; k<(Sidesizes[1]-1); k=k+1){
                                        int v, p;
                                        int[] NyukNyukNyuk; 
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Done[j], Dtwo[j], Done[j+1], Dtwo[j+1]);
                                        v = SSidesizes[3]; 
                                        p = Sidesizes[1]; 
                                        NyukNyukNyuk = Adding(Done[j], Dtwo[j],
                                        NyukNyukNyuk[0]*(Btwo[p-k-2] - Bone[p-k-2]), 
                                        NyukNyukNyuk[1]*Btwo[p-k-2]);  
                                        DDone[v+k] = NyukNyukNyuk[0];
                                        DDtwo[v+k] = NyukNyukNyuk[1];  
                                        DDthree[v+k-1] = Bthree[p-k-2];
                                        DDfour[v+k-1] = 1 - Bfour[p-k-2];
                                } 
                                SSidesizes[3] = SSidesizes[3] + Sidesizes[1] - 1;
                        }
                } 
                else if(Dthree[j] == 3){
                	if(Dfour[j] == 0){
                                	for(k=0; k<(Sidesizes[2]-1); k=k+1){
                                        int v;
                                        int[] NyukNyukNyuk;
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Done[j], Dtwo[j], Done[j+1], Dtwo[j+1]);
                                        v = SSidesizes[3];
                                        NyukNyukNyuk = Adding(Done[j], Dtwo[j], NyukNyukNyuk[0]*Cone[k+1],
                                        NyukNyukNyuk[1]*Ctwo[k+1]);
                                        DDone[v+k] = NyukNyukNyuk[0];
                                        DDtwo[v+k] = NyukNyukNyuk[1];
                                        DDthree[v+k-1] = Cthree[k];
                                        DDfour[v+k-1] = Cfour[k];
                                }
                                SSidesizes[3] = SSidesizes[3] + Sidesizes[2] - 1;
                        }
                        else{ 
                                	for(k=0; k<(Sidesizes[2]-1); k=k+1){
                                        int v, p;
                                        int[] NyukNyukNyuk; 
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Done[j], Dtwo[j], Done[j+1], Dtwo[j+1]);
                                        v = SSidesizes[3]; 
                                        p = Sidesizes[2]; 
                                        NyukNyukNyuk = Adding(Done[j], Dtwo[j],
                                        NyukNyukNyuk[0]*(Ctwo[p-k-2] - Cone[p-k-2]), 
                                        NyukNyukNyuk[1]*Ctwo[p-k-2]);  
                                        DDone[v+k] = NyukNyukNyuk[0];
                                        DDtwo[v+k] = NyukNyukNyuk[1];  
                                        DDthree[v+k-1] = Cthree[p-k-2];
                                        DDfour[v+k-1] = 1 - Cfour[p-k-2];
                                } 
                                SSidesizes[3] = SSidesizes[3] + Sidesizes[2] - 1;
                        }
                }
                else{ 
                	if(Dfour[j] == 0){
                                	for(k=0; k<(Sidesizes[3]-1); k=k+1){
                                        int v;
                                        int[] NyukNyukNyuk;
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Done[j], Dtwo[j], Done[j+1], Dtwo[j+1]);
                                        v = SSidesizes[3];
                                        NyukNyukNyuk = Adding(Done[j], Dtwo[j], NyukNyukNyuk[0]*Done[k+1],
                                        NyukNyukNyuk[1]*Dtwo[k+1]);
                                        DDone[v+k] = NyukNyukNyuk[0];
                                        DDtwo[v+k] = NyukNyukNyuk[1];
                                        DDthree[v+k-1] = Dthree[k];
                                        DDfour[v+k-1] = Dfour[k];
                                }
                                SSidesizes[3] = SSidesizes[3] + Sidesizes[3] - 1;
                        }
                        else{ 
                                	for(k=0; k<(Sidesizes[3]-1); k=k+1){
                                        int v, p;
                                        int[] NyukNyukNyuk; 
                                        NyukNyukNyuk = new int[2];
                                        NyukNyukNyuk = Adding(-Done[j], Dtwo[j], Done[j+1], Dtwo[j+1]);
                                        v = SSidesizes[3]; 
                                        p = Sidesizes[3]; 
                                        NyukNyukNyuk = Adding(Done[j], Dtwo[j],
                                        NyukNyukNyuk[0]*(Dtwo[p-k-2] - Done[p-k-2]), 
                                        NyukNyukNyuk[1]*Dtwo[p-k-2]);  
                                        DDone[v+k] = NyukNyukNyuk[0];
                                        DDtwo[v+k] = NyukNyukNyuk[1];  
                                        DDthree[v+k-1] = Athree[p-k-2];
                                        DDfour[v+k-1] = 1 - Afour[p-k-2];
                                } 
                                SSidesizes[3] = SSidesizes[3] + Sidesizes[3] - 1;
                        }
                } 
        }
	for(j=0; j<(SSidesizes[0]-1); j=j+1){
		Aone[j+1] = AAone[j+1];
		Atwo[j+1] = AAtwo[j+1];
		Athree[j] = AAthree[j];
		Afour[j] = AAfour[j];
	}
	for(j=0; j<(SSidesizes[1]-1); j=j+1){ 
                Bone[j+1] = BBone[j+1]; 
                Btwo[j+1] = BBtwo[j+1]; 
                Bthree[j] = BBthree[j]; 
                Bfour[j] = BBfour[j]; 
        }
	for(j=0; j<(SSidesizes[2]-1); j=j+1){ 
                Cone[j+1] = CCone[j+1]; 
                Ctwo[j+1] = CCtwo[j+1]; 
                Cthree[j] = CCthree[j]; 
                Cfour[j] = CCfour[j]; 
        }
	for(j=0; j<(SSidesizes[3]-1); j=j+1){ 
                Done[j+1] = DDone[j+1]; 
                Dtwo[j+1] = DDtwo[j+1]; 
                Dthree[j] = DDthree[j]; 
                Dfour[j] = DDfour[j]; 
        }
	Sidesizes[0] = SSidesizes[0];
	Sidesizes[1] = SSidesizes[1];
	Sidesizes[2] = SSidesizes[2];
	Sidesizes[3] = SSidesizes[3];
}

public static int[] Hipsterology(int[] Aone, int[] Atwo, int[] Athree,
int[] Afour, double[] Afive, int[] Bone, int[] Btwo, 
int[] Bthree, int[] Bfour, double[] Bfive, int[] 
Cone, int[] Ctwo, int[] Cthree, int[] Cfour, double[] Cfive,
int[] Done, int[] Dtwo, int[] Dthree, int[] Dfour, 
double[] Dfive, int[] Sidesizes){
	int j, yep;
	yep = 1;
	int[] ZigZag;
	ZigZag = new int[100000];
	for(j=0; j<Sidesizes[0]; j=j+1){
		if(Athree[j] == 1){
			if(Afour[j] == 0){
				if(Atwo[j] < Atwo[j+1]){
					int ziggy;
					ziggy = Atwo[j+1]/Atwo[j];
					ZigZag[yep] = ziggy*Aone[j];
					ZigZag[yep+1] = Atwo[j+1]-1;
					ZigZag[yep+2] = 1; 
				}
				else{
					ZigZag[yep] = Aone[j];
					ZigZag[yep+1] = Atwo[j]-1;
					ZigZag[yep+2] = 1;		
				}
			}
			else{
				if(Atwo[j] > Atwo[j+1]){
                         		int ziggy;
					ziggy = Atwo[j]/Atwo[j+1];
					ZigZag[yep] = ziggy*Aone[j+1];
					ZigZag[yep+1] = Atwo[j]+1;
					ZigZag[yep+2] = 1;
                                }
                                else{
					ZigZag[yep] = Aone[j+1];
					ZigZag[yep+1] = Atwo[j+1]+1;
					ZigZag[yep+2] = 1;
				}
			}
			int p, q;
			p = ZigZag[yep];
			q = ZigZag[yep+1];
			int[] google;
			google = new int[2];
			google = ReduceAgain(p, q);
			ZigZag[yep] = google[0];
			ZigZag[yep+1] = google[1];
			yep = yep + 3;
		}
	}
	for(j=0; j<Sidesizes[1]; j=j+1){
                if(Bthree[j] == 2){
                        if(Bfour[j] == 0){
                                if(Btwo[j] < Btwo[j+1]){
                                        int ziggy;
                                        ziggy = Btwo[j+1]/Btwo[j];
                                        ZigZag[yep] = ziggy*Bone[j];
                                        ZigZag[yep+1] = Btwo[j+1]-1;
                                        ZigZag[yep+2] = 2; 
                                } 
                                else{ 
                                        ZigZag[yep] = Bone[j];
                                        ZigZag[yep+1] = Btwo[j]-1;
                                        ZigZag[yep+2] = 2;
                                }
                        }
                        else{
                                if(Btwo[j] > Btwo[j+1]){
                                        int ziggy;
                                        ziggy = Btwo[j]/Btwo[j+1];
                                        ZigZag[yep] = ziggy*Bone[j+1];
                                        ZigZag[yep+1] = Btwo[j]+1;
                                        ZigZag[yep+2] = 2;
                                } 
                                else{ 
                                        ZigZag[yep] = Bone[j+1]; 
                                        ZigZag[yep+1] = Btwo[j+1]+1;
                                        ZigZag[yep+2] = 2;
                                }
                        }
			int p, q;
                        p = ZigZag[yep];
                        q = ZigZag[yep+1];
                        int[] google;
                        google = new int[2];
                        google = ReduceAgain(p, q);
                        ZigZag[yep] = google[0];
                        ZigZag[yep+1] = google[1];
                        yep = yep + 3;   
                }
	}
	for(j=0; j<Sidesizes[2]; j=j+1){
                if(Cthree[j] == 3){
                        if(Cfour[j] == 0){
                                if(Ctwo[j] < Ctwo[j+1]){
                                        int ziggy;
                                        ziggy = Ctwo[j+1]/Ctwo[j];
                                        ZigZag[yep] = ziggy*Cone[j];
                                        ZigZag[yep+1] = Ctwo[j+1]-1;
                                        ZigZag[yep+2] = 3; 
                                } 
                                else{ 
                                        ZigZag[yep] = Cone[j];
                                        ZigZag[yep+1] = Ctwo[j]-1;
                                        ZigZag[yep+2] = 3;
                                }
                        }
                        else{
                                if(Ctwo[j] > Ctwo[j+1]){
                                        int ziggy;
                                        ziggy = Ctwo[j]/Ctwo[j+1];
                                        ZigZag[yep] = ziggy*Cone[j+1];
                                        ZigZag[yep+1] = Ctwo[j]+1;
                                        ZigZag[yep+2] = 3;
                                } 
                                else{ 
                                        ZigZag[yep] = Cone[j+1]; 
                                        ZigZag[yep+1] = Ctwo[j+1]+1;
                                        ZigZag[yep+2] = 3;
                                }
                        }
			int p, q;
                        p = ZigZag[yep];
                        q = ZigZag[yep+1];
                        int[] google;
                        google = new int[2];
                        google = ReduceAgain(p, q);
                        ZigZag[yep] = google[0];
                        ZigZag[yep+1] = google[1];
                        yep = yep + 3;
                }
	}
	for(j=0; j<Sidesizes[3]; j=j+1){
                if(Dthree[j] == 4){
                        if(Dfour[j] == 0){
                                if(Dtwo[j] < Dtwo[j+1]){
                                        int ziggy;
                                        ziggy = Dtwo[j+1]/Dtwo[j];
                                        ZigZag[yep] = ziggy*Done[j];
                                        ZigZag[yep+1] = Dtwo[j+1]-1;
                                        ZigZag[yep+2] = 4; 
                                } 
                                else{ 
                                        ZigZag[yep] = Done[j];
                                        ZigZag[yep+1] = Dtwo[j]-1;
                                        ZigZag[yep+2] = 4;
                                }
                        }
                        else{
                                if(Dtwo[j] > Dtwo[j+1]){
                                        int ziggy;
                                        ziggy = Dtwo[j]/Dtwo[j+1];
                                        ZigZag[yep] = ziggy*Done[j+1];
                                        ZigZag[yep+1] = Dtwo[j]+1;
                                        ZigZag[yep+2] = 4;
                                } 
                                else{ 
                                        ZigZag[yep] = Done[j+1]; 
                                        ZigZag[yep+1] = Dtwo[j+1]+1;
                                        ZigZag[yep+2] = 4;
                                }
                        }
			int p, q;
                        p = ZigZag[yep];
                        q = ZigZag[yep+1];
                        int[] google;
                        google = new int[2];
                        google = ReduceAgain(p, q);
                        ZigZag[yep] = google[0];
                        ZigZag[yep+1] = google[1];
                        yep = yep + 3;   
                }
	}
	ZigZag[0] = yep;
	return ZigZag;
}





}