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

class revision {
	public static void main (String[] args) {
		InputStreamReader istream = new InputStreamReader(System.in);
		BufferedReader bufRead = new BufferedReader(istream);

		System.out.println("Wow, it's the working trigoned 4-braid machine!");
		System.out.println("Let's give it a whirl.");

		try {
			System.out.println("Please enter a path in the folding automaton. ");
			String word = bufRead.readLine();
			int p, q, pq, y, time;
			p = word.length();
			q = 1;
			char[] funk;
			int[] Ridiculous;
			Ridiculous = new int[12];
			int[] Ridiculousness;
			Ridiculousness = new int[200];
			int[][][] Flim;
			Flim = new int[20][4][40];
			Flim[0][0][0] = 1;
			Flim[0][1][0] = 1;
			Flim[0][2][0] = 1;
			Flim[0][3][0] = 1;
			Flim[0][0][1] = 1;
			Flim[0][1][1] = 2;
			Flim[0][2][1] = 3;
			Flim[0][3][1] = 4; 
			funk = word.toCharArray();
			System.out.print("You entered ");
			System.out.print(funk);
			System.out.println(".");
			Flim = Markov(Flim, p, funk);
			System.out.println("Markov Partition:");
			PrintLikeCrazy(p, Flim);
			int[] Rlim;
			Rlim = new int[4];
			int[] Denom;
			Denom = new int[1000];
			Rlim[0] = Flim[p][0][0];
			Rlim[1] = Flim[p][1][0];
			Rlim[2] = Flim[p][2][0];
			Rlim[3] = Flim[p][3][0];
			Rlim = Sort(Rlim);
			Denom = Denoms(Rlim);
			Denom = Balance(Denom);
			Denom = Sortlike(Denom);
			System.out.println("Denominators:");
			System.out.print("[");
                        for(pq=0; pq<=Denom[0]; pq=pq+1){
                                System.out.print(Denom[pq]);
                                System.out.print(" , "); 
                        } 
                        System.out.println("]");
			int[][] FixedPt;
			int[][] FourCycles;
			FourCycles = FourCycle(Flim, Denom, p);
			time = 0;
			System.out.println("Braids!:");
			for(pq=1; pq<=FourCycles[0][0]; pq=pq+1){
				for(y=0; y<12; y=y+1){
					Ridiculous[y] = FourCycles[pq][y];
				}
				Ridiculousness = Braids(Flim, p, Ridiculous, funk);
				System.out.print("[ ");
				for(y=1; y<=Ridiculousness[0]; y=y+1){
					System.out.print(Ridiculousness[y]);
					System.out.print(", ");
				}
				System.out.println("]");
				time = time + 1;
				if(time == 500){
					System.out.println("Ready?");
                        		String ready = bufRead.readLine();
					time = 0;
				}			
			}
		}

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

	public static void PrintLikeCrazy(int qq, int[][][] Glim){
		int i;
		System.out.print("[");
		for(i=0; i<=Glim[qq][0][0]; i=i+1){
			System.out.print(Glim[qq][0][i]);
			System.out.print(" , ");
		}
		System.out.println("]");
		System.out.print("[");
                for(i=0; i<=Glim[qq][1][0]; i=i+1){
                        System.out.print(Glim[qq][1][i]);
                        System.out.print(" , ");
                }
		System.out.println("]");
		System.out.print("[");
                for(i=0; i<=Glim[qq][2][0]; i=i+1){
                        System.out.print(Glim[qq][2][i]);
                        System.out.print(" , ");
                }
                System.out.println("]");
                System.out.print("["); 
                for(i=0; i<=Glim[qq][3][0]; i=i+1){
                        System.out.print(Glim[qq][3][i]);
                        System.out.print(" , ");
                }
                System.out.println("]");
	}




	public static int[][][] MoveA(int qq, int[][][] Glim){
		int i;
		int[] Hlim;
		Hlim = new int[40];
		Glim[qq][0][0] = Glim[qq-1][0][0];
		for(i=1; i<=Glim[qq-1][0][0]; i=i+1){
			Hlim[i] = Glim[qq-1][0][Glim[qq-1][0][0]-i+1];
		}
		for(i=1; i<=Glim[qq-1][0][0]; i=i+1){
			Glim[qq][0][i] = -Hlim[i];
		}
		Glim[qq][1][0] = Glim[qq-1][0][0] + Glim[qq-1][1][0];
		for(i=1; i<=Glim[qq-1][1][0]; i=i+1){
			Glim[qq][1][i] = Glim[qq-1][1][i];
		}
		for(i=1; i<=Glim[qq-1][0][0]; i=i+1){
			Glim[qq][1][Glim[qq-1][1][0]+i] = -Hlim[i];
		}
		for(i=0; i<=Glim[qq-1][2][0]; i=i+1){
			Glim[qq][2][i] = Glim[qq-1][2][i];
		};
		for(i=0; i<=Glim[qq-1][3][0]; i=i+1){
                        Glim[qq][3][i] = Glim[qq-1][3][i];
                };
		return Glim;
	}

	public static int[][][] MoveB(int qq, int[][][] Glim){
                int i;
                Glim[qq][0][0] = Glim[qq-1][0][0] + Glim[qq-1][1][0];
		for(i=1; i<=Glim[qq-1][0][0]; i=i+1){
			Glim[qq][0][i] = Glim[qq-1][0][i];
		}
                for(i=1; i<=Glim[qq-1][1][0]; i=i+1){
                        Glim[qq][0][Glim[qq-1][0][0]+i] = Glim[qq-1][1][i];
                }
		for(i=0; i<=Glim[qq-1][1][0]; i=i+1){
			Glim[qq][1][i] = Glim[qq-1][1][i];
		}
                for(i=0; i<=Glim[qq-1][2][0]; i=i+1){
                        Glim[qq][2][i] = Glim[qq-1][2][i];
                };
		for(i=0; i<=Glim[qq-1][3][0]; i=i+1){
                        Glim[qq][3][i] = Glim[qq-1][3][i];
                };       
                return Glim; 
        }

	public static int[][][] MoveC(int qq, int[][][] Glim){
                int i;
                Glim[qq][0][0] = Glim[qq-1][0][0] + Glim[qq-1][1][0];
                for(i=1; i<=Glim[qq-1][0][0]; i=i+1){
                        Glim[qq][0][i] = Glim[qq-1][0][i];
		}
		for(i=1; i<=Glim[qq-1][1][0]; i=i+1){
			Glim[qq][0][Glim[qq-1][0][0]+i] = -Glim[qq-1][1][Glim[qq-1][1][0]-i+1];
		}
                for(i=0; i<=Glim[qq-1][2][0]; i=i+1){ 
                        Glim[qq][1][i] = Glim[qq-1][2][i];
                } 
		for(i=0; i<=Glim[qq-1][3][0]; i=i+1){ 
                        Glim[qq][2][i] = Glim[qq-1][3][i];
                }
		for(i=0; i<=Glim[qq-1][1][0]; i=i+1){
                        Glim[qq][3][i] = Glim[qq-1][1][i];
                }
                return Glim;
	}

	public static int[][][] MoveD(int qq, int[][][] Glim){ 
                int i;
		Glim[qq][0][0] = Glim[qq-1][2][0];
                for(i=1; i<=Glim[qq-1][2][0]; i=i+1){
                        Glim[qq][0][i] = -Glim[qq-1][2][Glim[qq-1][2][0]-i+1];
                } 
                for(i=0; i<=Glim[qq-1][0][0]; i=i+1){
                        Glim[qq][1][i] = Glim[qq-1][0][i];
                }
                for(i=0; i<=Glim[qq-1][1][0]; i=i+1){
                        Glim[qq][2][i] = Glim[qq-1][1][i]; 
                }
		Glim[qq][3][0] = Glim[qq-1][2][0] + Glim[qq-1][3][0];
                for(i=1; i<=Glim[qq-1][2][0]; i=i+1){ 
                        Glim[qq][3][i] = Glim[qq-1][2][i];
                } 
                for(i=1; i<=Glim[qq-1][3][0]; i=i+1){
                        Glim[qq][3][Glim[qq-1][2][0]+i] = -Glim[qq-1][3][Glim[qq-1][3][0]-i+1];
                } 
                return Glim;
        }

	public static int[][][] MoveE(int qq, int[][][] Glim){
		int i;
                Glim[qq][3][0] = Glim[qq-1][3][0];
                for(i=1; i<=Glim[qq-1][3][0]; i=i+1){                
                	Glim[qq][3][i] = -Glim[qq-1][3][Glim[qq-1][3][0]-i+1];
                }
                Glim[qq][2][0] = Glim[qq-1][2][0] + Glim[qq-1][3][0];
                for(i=1; i<=Glim[qq-1][2][0]; i=i+1){ 
                        Glim[qq][2][i] = Glim[qq-1][2][i];
                } 
                for(i=1; i<=Glim[qq-1][3][0]; i=i+1){
                        Glim[qq][2][Glim[qq-1][2][0]+i] = -Glim[qq-1][3][Glim[qq-1][3][0]-i+1];
                }
		for(i=0; i<=Glim[qq-1][0][0]; i=i+1){
                        Glim[qq][0][i] = Glim[qq-1][0][i];
                }; 
                for(i=0; i<=Glim[qq-1][1][0]; i=i+1){
                        Glim[qq][1][i] = Glim[qq-1][1][i];
                }; 
                return Glim;
        }

	public static int[][][] MoveF(int qq, int[][][] Glim){
		int i; 
                Glim[qq][3][0] = Glim[qq-1][2][0] + Glim[qq-1][3][0];
                for(i=1; i<=Glim[qq-1][3][0]; i=i+1){ 
                        Glim[qq][3][i] = Glim[qq-1][3][i];
                } 
                for(i=1; i<=Glim[qq-1][2][0]; i=i+1){ 
                        Glim[qq][3][Glim[qq-1][3][0]+i] = Glim[qq-1][2][i];
                }
                for(i=0; i<=Glim[qq-1][1][0]; i=i+1){ 
                        Glim[qq][1][i] = Glim[qq-1][1][i];
                } 
                for(i=0; i<=Glim[qq-1][2][0]; i=i+1){ 
                        Glim[qq][2][i] = Glim[qq-1][2][i];
                }; 
                for(i=0; i<=Glim[qq-1][0][0]; i=i+1){
                        Glim[qq][0][i] = Glim[qq-1][0][i];
                }; 
                return Glim;        	
        }

	public static int[][][] MoveG(int qq, int[][][] Glim){
		int i;
                Glim[qq][3][0] = Glim[qq-1][2][0] + Glim[qq-1][3][0];
                for(i=1; i<=Glim[qq-1][3][0]; i=i+1){ 
                        Glim[qq][3][i] = Glim[qq-1][3][i];
                }
                for(i=1; i<=Glim[qq-1][2][0]; i=i+1){ 
                        Glim[qq][3][Glim[qq-1][3][0]+i] = -Glim[qq-1][2][Glim[qq-1][2][0]-i+1];
                }
                for(i=0; i<=Glim[qq-1][2][0]; i=i+1){ 
                        Glim[qq][0][i] = Glim[qq-1][2][i];
                } 
                for(i=0; i<=Glim[qq-1][0][0]; i=i+1){ 
                        Glim[qq][1][i] = Glim[qq-1][0][i];
                } 
                for(i=0; i<=Glim[qq-1][1][0]; i=i+1){
                        Glim[qq][2][i] = Glim[qq-1][1][i];
                } 
                return Glim;        
        }
	
	public static int[][][] MoveH(int qq, int[][][] Glim){
		int i; 
                Glim[qq][3][0] = Glim[qq-1][1][0]; 
                for(i=1; i<=Glim[qq-1][1][0]; i=i+1){
                        Glim[qq][3][i] = -Glim[qq-1][1][Glim[qq-1][1][0]-i+1];
                } 
                for(i=0; i<=Glim[qq-1][2][0]; i=i+1){
                        Glim[qq][1][i] = Glim[qq-1][2][i];
                }
                for(i=0; i<=Glim[qq-1][3][0]; i=i+1){
                        Glim[qq][2][i] = Glim[qq-1][3][i]; 
                } 
                Glim[qq][0][0] = Glim[qq-1][0][0] + Glim[qq-1][1][0];
                for(i=1; i<=Glim[qq-1][1][0]; i=i+1){ 
                        Glim[qq][0][i] = Glim[qq-1][1][i];
                } 
                for(i=1; i<=Glim[qq-1][0][0]; i=i+1){
                        Glim[qq][0][Glim[qq-1][1][0]+i] = -Glim[qq-1][0][Glim[qq-1][0][0]-i+1]; 
                } 
                return Glim;        	 
        }

	public static int[][][] Markov(int[][][] Glim, int ppp, char[] gunk){
		int z;
		int i;
		z = 1;
		for(i=0; i<ppp; i=i+1){
			if (gunk[ppp-i-1] == 'A'){
				Glim = MoveA(z, Glim);
			}
			else if (gunk[ppp-i-1] == 'B'){
				Glim = MoveB(z, Glim);
			}
			else if (gunk[ppp-i-1] == 'C'){
				Glim = MoveC(z, Glim);
			}
			else if (gunk[ppp-i-1] == 'D'){
				Glim = MoveD(z, Glim);
			}
			else if (gunk[ppp-i-1] == 'E'){
                                Glim = MoveE(z, Glim);
                        }
                        else if (gunk[ppp-i-1] == 'F'){
                                Glim = MoveF(z, Glim); 
                        }
                        else if (gunk[ppp-i-1] == 'G'){
                                Glim = MoveG(z, Glim);
                        }
                        else if (gunk[ppp-i-1] == 'H'){
                                Glim = MoveH(z, Glim);
                        }
			z=z+1;
		}
		return Glim;
	}

	public static int[] Sort(int[] Slim){
		int a, b, i;
		for(i=1; i<4; i=i+1){
			if(Slim[0] > Slim[i]){
				a = Slim[0];
				b = Slim[i];
				Slim[0] = b;
				Slim[i] = a;
			}
		}
		for(i=2; i<4; i=i+1){
                        if(Slim[1] > Slim[i]){
                                a = Slim[1];
                                b = Slim[i];
                                Slim[1] = b;
                                Slim[i] = a;
                        }
                }
		for(i=3; i<4; i=i+1){
                        if(Slim[2] > Slim[i]){
                                a = Slim[2];
                                b = Slim[i];
                                Slim[2] = b;
                                Slim[i] = a;
                        }
                }		
		return Slim;
	}

	public static int[] Sortlike(int[] Slim){
		int a, b, i, j;
		for(i=1; i<Slim[0]; i=i+1){
			for(j=(i+1); j<=Slim[0]; j=j+1){
				if(Slim[i] > Slim[j]){
					a = Slim[i];
					b = Slim[j];
					Slim[i] = b;
					Slim[j] = a;
				}
			}
		}
		return Slim;
	}

	public static int[] Denoms(int[] Slim){
		int[] Tlim;
		Tlim = new int[1000];
		int i, j, k, l, m, n;
		n = 0;
		for(i=0; i<4; i=i+1){
			for(j=0; j<4; j=j+1){
				for(k=0; k<4; k=k+1){
					for(l=0; l<4; l=l+1){
						m = Slim[i]*Slim[j]*Slim[k]*Slim[l];
						Tlim[n+1] = m-1;
						Tlim[n+2] = m+1;
						n = n+2;		
					}
				}
			}
		}
		Tlim[0] = n;
		return Tlim;
	}

	public static int[] Balance(int[] Slim){
		int i, j, k, m, l;
		l=1;
		k = Slim[0];
		if(Slim[1] == 0){
			Slim[1] = Slim[2];
		}
		for(i=1; i<=k; i=i+1){
			m = 0;
			for(j=1; j<=l; j=j+1){
				if(Slim[i] == Slim[j]){
					m = m+1;
				}
			}
			if((m == 0) && (Slim[i] != 0)){
				Slim[l+1] = Slim[i];
				l = l+1;
			}
		}
		Slim[0] = l;
		for(i=l; i<999; i=i+1){
			Slim[i+1] = 0;
		}
		return Slim;
	}

	public static int[] WhereTo(int[][][] Glim, int r, int a, int b, int c){
		int[] Tlim;
		Tlim = new int[3];
		int i;
		int z;
		z = 0;
		for(i=0; i<Glim[r][a-1][0]; i=i+1){
			if((b*Glim[r][a-1][0]) >= (c*i)){
				z=z+1;
			}				
		}
		if(Glim[r][a-1][z] > 0){
			Tlim[0] = Glim[r][a-1][z];
			Tlim[1] = (b*Glim[r][a-1][0]) + (c*(1-z));
			Tlim[2] = c;
		}
		else{
			Tlim[0] = -Glim[r][a-1][z];
			Tlim[1] = (c*z) - (b*Glim[r][a-1][0]);
			Tlim[2] = c;
		}
		return Tlim;
	}

	public static int[] WheredItGo(int[][][] Glim, int r, int a, int b, int c, int d, int e, int f, char[] lime, 
	int jj, int jjj){
		int[] Tlim;
		Tlim = new int[6];
		int i; 
                int z; 
                z = 0; 
                for(i=0; i<Glim[r][a-1][0]; i=i+1){ 
                        if((b*Glim[r][a-1][0]) >= (c*i)){ 
                                z=z+1; 
                        }
                }
		if(lime[0] == 'A'){
			if(a == 1){
				Tlim[0] = a;
				Tlim[3] = -d;
				Tlim[4] = f - e;
				Tlim[5] = f;
			}
			else if(a == 2){
				if((c*(Glim[r][1][0] - Glim[r][0][0])) < (b*Glim[r][1][0])){
					Tlim[0] = 1;
					Tlim[3] = -d;
					Tlim[4] = Glim[r][0][0] - e + (Glim[r][1][0] - Glim[r][0][0]);
					Tlim[5] = Glim[r][0][0];
				}
				else{
					Tlim[0] = 2;
					Tlim[3] = d;
					Tlim[4] = e;
					Tlim[5] = Glim[r][1][0] - Glim[r][0][0];
				}
			}
			else{
				Tlim[0] = a;
				Tlim[3] = d;
				Tlim[4] = e;
				Tlim[5] = f;
			}
		}
		else if(lime[0] == 'B'){
			if(a == 1){
				if((c*(Glim[r][0][0] - Glim[r][1][0]))<(b*Glim[r][0][0])){
					Tlim[0] = 2;
					Tlim[3] = d;
					Tlim[4] = e - (Glim[r][0][0] - Glim[r][1][0]);
					Tlim[5] = Glim[r][1][0];
				}
				else{
					Tlim[0] = 1;
					Tlim[3] = d;
					Tlim[4] = e;
					Tlim[5] = Glim[r][0][0] - Glim[r][1][0];
				}				
			}
			else{
				Tlim[0] = a;
				Tlim[3] = d;
				Tlim[4] = e;
				Tlim[5] = f;
			}
		}
		else if(lime[0] == 'C'){
			if(a == 1){
				if((c*(Glim[r][0][0] - Glim[r][3][0]))<(b*Glim[r][0][0])){
					Tlim[0] = 2;
					Tlim[3] = -d;
					Tlim[4] = Glim[r][3][0] - e + (Glim[r][0][0] - Glim[r][3][0]);
					Tlim[5] = Glim[r][3][0];
				}
				else{
					Tlim[0] = 1;
                                        Tlim[3] = d;
                                        Tlim[4] = e;
                                        Tlim[5] = Glim[r][0][0] - Glim[r][3][0];
				}				
			}
			else if(a == 2){
				Tlim[0] = 3;
				Tlim[3] = d;
				Tlim[4] = e;
				Tlim[5] = f;
			}
			else if (a == 3){
				Tlim[0] = 4;
                                Tlim[3] = d;
                                Tlim[4] = e;
                                Tlim[5] = f;
			}
			else if (a == 4){
				Tlim[0] = 2;
                                Tlim[3] = d;
                                Tlim[4] = e;
                                Tlim[5] = f;
			}
		}
		else if(lime[0] == 'D'){
			if(a == 1){
				Tlim[0] = 3;
				Tlim[3] = -d;
				Tlim[4] = f-e;
				Tlim[5] = f;                  
                        }
                        else if(a == 2){
                  		Tlim[0] = 1; 
                                Tlim[3] = d;
                                Tlim[4] = e;
                                Tlim[5] = f;
                        }
                        else if (a == 3){
                  		Tlim[0] = 2; 
                                Tlim[3] = d;
                                Tlim[4] = e;
                                Tlim[5] = f;
                        }
                        else if (a == 4){
				if((c*Glim[r][0][0])<(b*Glim[r][3][0])){
					Tlim[0] = 4;
					Tlim[3] = -d;
					Tlim[4] = -e + Glim[r][0][0] + (Glim[r][3][0] - Glim[r][0][0]);
					Tlim[5] = Glim[r][3][0] - Glim[r][0][0];
				}
				else{
					Tlim[0] = 3;
					Tlim[3] = d;
					Tlim[4] = e;
					Tlim[5] = Glim[r][0][0];
				}                  
                        }
		}
		else if(lime[0] == 'E'){
			if(a == 4){ 
                                Tlim[0] = a;
                                Tlim[3] = -d;
                                Tlim[4] = f - e;
                                Tlim[5] = f;
                        } 
                        else if(a == 3){ 
                                if((c*(Glim[r][2][0] - Glim[r][3][0])) < (b*Glim[r][2][0])){
                                        Tlim[0] = 4;
                                        Tlim[3] = -d;
                                        Tlim[4] = Glim[r][3][0] - e + (Glim[r][2][0] - Glim[r][3][0]);
                                        Tlim[5] = Glim[r][3][0];
                                }
                                else{ 
                                        Tlim[0] = 3;
                                        Tlim[3] = d;
                                        Tlim[4] = e; 
                                        Tlim[5] = Glim[r][2][0] - Glim[r][3][0];
                                } 
                        } 
                        else{ 
                                Tlim[0] = a; 
                                Tlim[3] = d; 
                                Tlim[4] = e; 
                                Tlim[5] = f;
                        }
		}
		else if(lime[0] == 'F'){
			if(a == 4){ 
                                if((c*(Glim[r][3][0] - Glim[r][2][0]))<(b*Glim[r][3][0])){
                                        Tlim[0] = 3;
                                        Tlim[3] = d;
                                        Tlim[4] = e - (Glim[r][3][0] - Glim[r][2][0]);
                                        Tlim[5] = Glim[r][2][0];
                                } 
                                else{ 
                                        Tlim[0] = 4; 
                                        Tlim[3] = d; 
                                        Tlim[4] = e; 
                                        Tlim[5] = Glim[r][3][0] - Glim[r][2][0];
                                } 
                        }
			else{
                                Tlim[0] = a;
                                Tlim[3] = d;
                                Tlim[4] = e;
                                Tlim[5] = f; 
                        }
		}
		else if(lime[0] == 'G'){
			if(a == 1){
				Tlim[0] = 3;
                                Tlim[3] = d;
                                Tlim[4] = e;
                                Tlim[5] = f;                  
                        }
                        else if(a == 2){
                  		Tlim[0] = 1;
                                Tlim[3] = d;
                                Tlim[4] = e;
                                Tlim[5] = f;
                        }
                        else if (a == 3){
                  		Tlim[0] = 2;
                                Tlim[3] = d;
                                Tlim[4] = e;
                                Tlim[5] = f;
                        }
                        else if (a == 4){
				if((c*(Glim[r][3][0] - Glim[r][0][0]))<(b*Glim[r][3][0])){
                                        Tlim[0] = 3;
                                        Tlim[3] = -d;
                                        Tlim[4] = Glim[r][0][0] - e + (Glim[r][3][0] - Glim[r][0][0]);
                                        Tlim[5] = Glim[r][0][0];
                                } 
                                else{ 
                                        Tlim[0] = 4;
                                        Tlim[3] = d;
                                        Tlim[4] = e;
                                        Tlim[5] = Glim[r][3][0] - Glim[r][0][0];
                                }                  
                        }
		}
		else if(lime[0] == 'H'){
			if(a == 1){
				if((c*Glim[r][3][0])<(b*Glim[r][0][0])){
                                        Tlim[0] = 1;
                                        Tlim[3] = -d;
                                        Tlim[4] = -e + Glim[r][3][0] + (Glim[r][0][0] - Glim[r][3][0]);
                                        Tlim[5] = Glim[r][0][0] - Glim[r][3][0];
                                } 
                                else{ 
                                        Tlim[0] = 2;
                                        Tlim[3] = d;
                                        Tlim[4] = e;
                                        Tlim[5] = Glim[r][3][0];
                                }                  
                        }
                        else if(a == 2){
				Tlim[0] = 3;
                                Tlim[3] = d;
                                Tlim[4] = e; 
                                Tlim[5] = f;                  
                        }
                        else if (a == 3){
                  		Tlim[0] = 4;
                                Tlim[3] = d;
                                Tlim[4] = e; 
                                Tlim[5] = f;
                        }
                        else if (a == 4){
				Tlim[0] = 2;
                                Tlim[3] = -d;
                                Tlim[4] = f-e;
                                Tlim[5] = f;                  
                        }
		}
		Tlim[1] = (jj*Tlim[3]) + (jjj*Tlim[4]);
		Tlim[2] = jjj*Tlim[5];		
		return Tlim;
	}

	public static int[][] FixedPoint(int[][][] Glim, int[] Slim, int r){
		int[][] Ha;
		Ha = new int[200][3];
		Ha[0][0] = 0;
		int i, j, k, s, t, u;
		int[] HaHa;
		HaHa = new int[3];
		for(i=1; i<=Slim[0]; i=i+1){
			for(j=1; j<=4; j=j+1){
				for(k=1; k<Slim[i]; k=k+1){
					HaHa = WhereTo(Glim, r, j, k, Slim[i]);
					if((HaHa[0] == j) && (HaHa[1] == k) && (HaHa[2] == Slim[i])){
						t = 0;
						for(u=1; u<=Ha[0][0]; u=u+1){
							if((HaHa[0] == Ha[u][0]) && (HaHa[1] * Ha[u][2] == 
							HaHa[2] * Ha[u][1])){
								t=t+1;
							}
						} 		
						if(t == 0){
							Ha[0][0]=Ha[0][0]+1;
							Ha[Ha[0][0]][0] = HaHa[0];
							Ha[Ha[0][0]][1] = HaHa[1];
							Ha[Ha[0][0]][2] = HaHa[2];
						}
					}  								
				}
			}
		}
		System.out.println("Fixed Points:");
		System.out.print("[ ");
		for(s=1; s<=Ha[0][0]; s=s+1){
			System.out.print("[");
			System.out.print(Ha[s][0]);
			System.out.print(", ");
			System.out.print(Ha[s][1]);
			System.out.print(" / ");
			System.out.print(Ha[s][2]);
			System.out.print("], ");
		}
		System.out.println("]");
		return Ha;
	} 

	public static int[][] FourCycle(int[][][] Glim, int[] Slim, int r){
                int[][] Ha; 
                Ha = new int[5000][12];
                Ha[0][0] = 0;
                int i, j, k, s, t, u; 
                int[] HaOne, HaTwo, HaThree, HaFour; 
                HaOne = new int[3];
		HaTwo = new int[3];
		HaThree = new int[3];
		HaFour = new int[4]; 
                for(i=1; i<=Slim[0]; i=i+1){
                        for(j=1; j<=4; j=j+1){
                                for(k=1; k<Slim[i]; k=k+1){
                                        HaOne = WhereTo(Glim, r, j, k, Slim[i]);
					HaTwo = WhereTo(Glim, r, HaOne[0], HaOne[1], HaOne[2]);
					HaThree = WhereTo(Glim, r, HaTwo[0], HaTwo[1], HaTwo[2]);
					HaFour = WhereTo(Glim, r, HaThree[0], HaThree[1], HaThree[2]);
                                        if((HaFour[0] == j) && (HaFour[1] == k) && (HaFour[2] == Slim[i])
					&&((HaTwo[0] != j) || (HaTwo[1] != k) || (HaTwo[2] != Slim[i]))){
						t = 0;
						for(u=1; u<=Ha[0][0]; u=u+1){
							if(((HaFour[0] == Ha[u][0]) && (HaFour[1] * Ha[u][2] 
							== HaFour[2] * Ha[u][1])) ||
							((HaFour[0] == Ha[u][3]) && (HaFour[1] * Ha[u][5]
                                                        == HaFour[2] * Ha[u][4])) ||
							((HaFour[0] == Ha[u][6]) && (HaFour[1] * Ha[u][8]
                                                        == HaFour[2] * Ha[u][7])) ||
                                                        ((HaFour[0] == Ha[u][9]) && (HaFour[1] * Ha[u][11]
                                                        == HaFour[2] * Ha[u][10]))){
								t=t+1;
							}
						}			
						if(t == 0){
	                                                Ha[0][0]=Ha[0][0]+1;
	                                                Ha[Ha[0][0]][0] = HaFour[0];
	                                                Ha[Ha[0][0]][1] = HaFour[1];
	                                                Ha[Ha[0][0]][2] = HaFour[2];
							Ha[Ha[0][0]][3] = HaOne[0];
	                                                Ha[Ha[0][0]][4] = HaOne[1];
	                                                Ha[Ha[0][0]][5] = HaOne[2];
							Ha[Ha[0][0]][6] = HaTwo[0];
	                                                Ha[Ha[0][0]][7] = HaTwo[1];
	                                                Ha[Ha[0][0]][8] = HaTwo[2];
	                                                Ha[Ha[0][0]][9] = HaThree[0]; 
	                                                Ha[Ha[0][0]][10] = HaThree[1];
	                                                Ha[Ha[0][0]][11] = HaThree[2];
						}
                                        }
                                } 
                        }  
                } 
                System.out.println("Four-Cycles:");
                for(s=1; s<=Ha[0][0]; s=s+1){
			System.out.print("[ ");
                        System.out.print("[");
                        System.out.print(Ha[s][0]);
                        System.out.print(", ");
                        System.out.print(Ha[s][1]);
			System.out.print(" / "); 
                        System.out.print(Ha[s][2]); 
                        System.out.print("], ");
			System.out.print("["); 
                        System.out.print(Ha[s][3]);
                        System.out.print(", "); 
                        System.out.print(Ha[s][4]);
                        System.out.print(" / "); 
                        System.out.print(Ha[s][5]); 
                        System.out.print("], ");
                        System.out.print("["); 
                        System.out.print(Ha[s][6]);
                        System.out.print(", "); 
                        System.out.print(Ha[s][7]);
                        System.out.print(" / "); 
                        System.out.print(Ha[s][8]);
                        System.out.print("], ");
                        System.out.print("["); 
                        System.out.print(Ha[s][9]);
                        System.out.print(", ");
                        System.out.print(Ha[s][10]);
                        System.out.print(" / ");
                        System.out.print(Ha[s][11]);
                        System.out.print("], ");
			System.out.println("]");
                }
                return Ha; 
        }

	public static int[] Sorting(int[] Crazylike, int[] Crazytastic, int[] Funtastic){
		int[] Y;
		Y = new int[6];
		int i, j, ww, www;
		for(i=0; i<3; i=i+1){
			for(j=0; j<(3-i); j=j+1){
				if((Crazylike[3*(i+j+1)] < Crazylike[3*i]) || ((Crazylike[3*(i+j+1)] <= Crazylike[3*i])
				&& ((Crazylike[(3*(i+j))+4]*Crazylike[(3*i)+2]) < 
				(Crazylike[(3*(i+j))+5]*Crazylike[(3*i)+1])))){
					Y[0] = Crazylike[3*i];
					Y[1] = Crazylike[(3*i)+1];
					Y[2] = Crazylike[(3*i)+2];
					Y[3] = Crazylike[3*(i+j+1)];
					Y[4] = Crazylike[(3*(i+j))+4];
					Y[5] = Crazylike[(3*(i+j))+5];
					Crazylike[3*i] = Y[3];
					Crazylike[(3*i)+1] = Y[4];
					Crazylike[(3*i)+2] = Y[5];
					Crazylike[3*(i+j+1)] = Y[0];
					Crazylike[(3*(i+j))+4] = Y[1];
					Crazylike[(3*(i+j))+5] = Y[2];
					Y[0] = Crazytastic[3*i];
                                        Y[1] = Crazytastic[(3*i)+1];
					Y[2] = Crazytastic[(3*i)+2];
                                        Y[3] = Crazytastic[3*(i+j+1)];
                                        Y[4] = Crazytastic[(3*(i+j))+4];
					Y[5] = Crazytastic[(3*(i+j))+5];
                                        Crazytastic[3*i] = Y[3];
                                        Crazytastic[(3*i)+1] = Y[4];
					Crazytastic[(3*i)+2] = Y[5];
                                        Crazytastic[3*(i+j+1)] = Y[0];
                                        Crazytastic[(3*(i+j))+4] = Y[1];
					Crazytastic[(3*(i+j))+5] = Y[2];
					ww = Funtastic[i];
					www = Funtastic[i+j+1];
					Funtastic[i] = www;
					Funtastic[i+j+1] = ww;
				}
			}
		}
		return Crazylike;
	}

	public static int[] Braids(int[][][] Glim, int r, int[] Crazylike, char[] gunk){
		int[] Hilarity, Hilariousness, Hilarious, Wacky, Whammy;
		char[] flump;
		flump = new char[1];
		Hilarity = new int[200];
		Hilarity[0] = 0;
		Hilariousness = new int[12];
		Hilarious = new int[12];
		Wacky = new int[12];
		Whammy = new int[4];
		Wacky[0] = Glim[r][Crazylike[0]-1][0];
		Wacky[1] = 0;
		Wacky[2] = Glim[r][Crazylike[0]-1][0];
		Wacky[3] = Glim[r][Crazylike[3]-1][0];
                Wacky[4] = 0;
                Wacky[5] = Glim[r][Crazylike[3]-1][0];
		Wacky[6] = Glim[r][Crazylike[6]-1][0];
                Wacky[7] = 0;
                Wacky[8] = Glim[r][Crazylike[6]-1][0];
		Wacky[9] = Glim[r][Crazylike[9]-1][0];
                Wacky[10] = 0;
                Wacky[11] = Glim[r][Crazylike[9]-1][0];
		Whammy[0] = 0;
		Whammy[1] = 1;
		Whammy[2] = 2;
		Whammy[3] = 3;
		int i, g;
		for(i=0; i<12; i=i+1){
			Hilariousness[i] = Crazylike[i];
		}
		for(i=0; i<r; i=i+1){
			flump[0] = gunk[i];
			Hilariousness = Sorting(Hilariousness, Wacky, Whammy);
			int[] Wham;
			Wham = new int[6];
			Wham = WheredItGo(Glim, r-i, Hilariousness[0], Hilariousness[1], Hilariousness[2], 
				Wacky[0], Wacky[1], Wacky[2], flump, Crazylike[(3*Whammy[0])+1], 
				Crazylike[(3*Whammy[0])+2]);
			Hilarious[0] = Wham[0];
			Hilarious[1] = Wham[1];
			Hilarious[2] = Wham[2];
			Wacky[0] = Wham[3];
			Wacky[1] = Wham[4];
			Wacky[2] = Wham[5];
			Wham = WheredItGo(Glim, r-i, Hilariousness[3], Hilariousness[4], Hilariousness[5], 
				Wacky[3], Wacky[4], Wacky[5], flump, Crazylike[(3*Whammy[1])+1],
				Crazylike[(3*Whammy[1])+2]);
                        Hilarious[3] = Wham[0];
                        Hilarious[4] = Wham[1];
                        Hilarious[5] = Wham[2];
			Wacky[3] = Wham[3];
			Wacky[4] = Wham[4];
			Wacky[5] = Wham[5];
			Wham = WheredItGo(Glim, r-i, Hilariousness[6], Hilariousness[7], Hilariousness[8], 
				Wacky[6], Wacky[7], Wacky[8], flump, Crazylike[(3*Whammy[2])+1],
				Crazylike[(3*Whammy[2])+2]);
                        Hilarious[6] = Wham[0];
                        Hilarious[7] = Wham[1];
                        Hilarious[8] = Wham[2];
			Wacky[6] = Wham[3];
			Wacky[7] = Wham[4];
			Wacky[8] = Wham[5];
                        Wham = WheredItGo(Glim, r-i, Hilariousness[9], Hilariousness[10], Hilariousness[11], 
				Wacky[9], Wacky[10], Wacky[11], flump, Crazylike[(3*Whammy[3])+1],
				Crazylike[(3*Whammy[3])+2]);
                        Hilarious[9] = Wham[0];
                        Hilarious[10] = Wham[1];
                        Hilarious[11] = Wham[2];
			Wacky[9] = Wham[3];
			Wacky[10] = Wham[4];
			Wacky[11] = Wham[5];
			int j, k, s, t, u, v, w;
			if(gunk[i] == 'A'){
				s=0;
				t=0;
				u=0;
				for(j=0; j<4; j=j+1){
					if(Hilariousness[3*j] == 1){
						s=s+1;
					}
					if((Hilariousness[3*j] == 2) && ((Hilariousness[(3*j)+1]*Glim[r-i][1][0]) 
					> (Hilariousness[(3*j)+2]*(Glim[r-i][1][0] - Glim[r-i][0][0])))){
						t=t+1;
					}
					if((Hilariousness[3*j] == 2) && ((Hilariousness[(3*j)+1]*Glim[r-i][1][0])
                                        < (Hilariousness[(3*j)+2]*(Glim[r-i][1][0] - Glim[r-i][0][0])))){
                                                u=u+1;
                                        }
				}
				for(j=0; j<(s-1); j=j+1){
					for(k=0; k<(s-j-1); k=k+1){
						Hilarity[Hilarity[0]+1] = -(k+1);
						Hilarity[0] = Hilarity[0]+1;
					}					
				}
				for(j=0; j<t; j=j+1){
					for(k=0; k<s; k=k+1){
						if(Hilarious[(3*(s+t+u-1-j))+1]<Hilarious[(3*k)+1]){
							Hilarity[Hilarity[0]+1] = -(s+j-k);
							Hilarity[0] = Hilarity[0]+1;
						}
					}
				}
			}
			else if(gunk[i] == 'B'){
				s=0;				
				t=0;
				u=0;
				for(j=0; j<4; j=j+1){
					if((Hilariousness[3*j] == 1) && ((Hilariousness[(3*j)+1]*Glim[r-i][0][0])
                                        <= (Hilariousness[(3*j)+2]*(Glim[r-i][0][0] - Glim[r-i][1][0])))){
                                                s=s+1;
                                        }
					else if((Hilariousness[3*j] == 1) && ((Hilariousness[(3*j)+1]*Glim[r-i][0][0])
                                        > (Hilariousness[(3*j)+2]*(Glim[r-i][0][0] - Glim[r-i][1][0])))){
                                                t=t+1;
                                        }
					else if(Hilariousness[3*j] == 2){ 
                                                u=u+1; 
                                        }
				}
				for(j=0; j<(t-1); j=j+1){
                                        for(k=0; k<(t-j-1); k=k+1){
                                                Hilarity[Hilarity[0]+1] = -(s+k+1); 
                                                Hilarity[0] = Hilarity[0]+1;
                                        } 
                                } 
                                for(j=0; j<u; j=j+1){
                                        for(k=0; k<t; k=k+1){ 
                                                if(Hilarious[(3*(s+t+u-1-j))+1]>Hilarious[(3*(s+k))+1]){
                                                        Hilarity[Hilarity[0]+1] = -(s+t+j-k);
                                                        Hilarity[0] = Hilarity[0]+1;
                                                } 
                                        } 
                                }
			}
			else if(gunk[i] == 'C'){
				s=0;
				t=0;
				u=0;
				v=0;
				w=0;
				for(j=0; j<4; j=j+1){
                                        if((Hilariousness[3*j] == 1) && ((Hilariousness[(3*j)+1]*Glim[r-i][0][0])
                                        <= (Hilariousness[(3*j)+2]*(Glim[r-i][0][0] - Glim[r-i][3][0])))){
                                                s=s+1;                                                           
                                        }
                                        else if((Hilariousness[3*j] == 1) && ((Hilariousness[(3*j)+1]*Glim[r-i][0][0])
                                        > (Hilariousness[(3*j)+2]*(Glim[r-i][0][0] - Glim[r-i][3][0])))){
                                                t=t+1;
                                        }
                                        else if(Hilariousness[3*j] == 2){
                                                u=u+1;
                                        }
					else if(Hilariousness[3*j] == 3){
						v=v+1;
					}
					else if(Hilariousness[3*j] == 4){
						w=w+1;
					}
				}
				for(j=0; j<(w-1); j=j+1){
                                        for(k=0; k<(w-j-1); k=k+1){ 
                                                Hilarity[Hilarity[0]+1] = 3-k;
                                                Hilarity[0] = Hilarity[0]+1;
                                        } 
                                }
				for(j=0; j<w; j=j+1){
					for(k=0; k<(u+v); k=k+1){
						Hilarity[Hilarity[0]+1] = s+t+u+v+j-k;
						Hilarity[0] = Hilarity[0]+1;
					}
				}
                                for(j=0; j<w; j=j+1){
                                        for(k=0; k<t; k=k+1){
                                                if(Hilarious[(3*(s+t+u+v+w-1-j))+1]>Hilarious[(3*(s+t-k-1))+1]){
                                                        Hilarity[Hilarity[0]+1] = s+t+j-k;
                                                        Hilarity[0] = Hilarity[0]+1;
                                                }
                                        }
                                }
				for(j=0; j<(v-1); j=j+1){
					for(k=0; k<(v-j-1); k=k+1){
						Hilarity[Hilarity[0]+1] = 3-k;
						Hilarity[0] = Hilarity[0]+1;
					}
				}
			}
			else if(gunk[i] == 'D'){
				s=0;
				t=0;
				u=0;
				v=0;
				w=0;
				for(j=0; j<4; j=j+1){
                                        if(Hilariousness[3*j] == 1){
						s=s+1;
					}
					else if(Hilariousness[3*j] == 2){
						t=t+1;
					}
					else if(Hilariousness[3*j] == 3){
						u=u+1;
					}
					else if((Hilariousness[3*j] == 4) && ((Hilariousness[(3*j)+1]*Glim[r-i][3][0])
                                        < (Hilariousness[(3*j)+2]*Glim[r-i][0][0]))){
                                                v=v+1;                                                           
                                        }
                                        else if((Hilariousness[3*j] == 4) && ((Hilariousness[(3*j)+1]*Glim[r-i][3][0])
                                        >= (Hilariousness[(3*j)+2]*Glim[r-i][0][0]))){
                                                w=w+1;
                                        }
				}
				for(j=0; j<(s-1); j=j+1){
                                        for(k=0; k<(s-j-1); k=k+1){ 
                                                Hilarity[Hilarity[0]+1] = -(k+1);
                                                Hilarity[0] = Hilarity[0]+1;
                                        } 
                                } 
                                for(j=0; j<(t+u); j=j+1){
                                        for(k=0; k<s; k=k+1){
                                                Hilarity[Hilarity[0]+1] = -(s+j-k);
                                                Hilarity[0] = Hilarity[0]+1;
                                        }
                                }
				for(j=0; j<s; j=j+1){
                                        for(k=0; k<v; k=k+1){ 
                                                if(Hilarious[(3*j)+1]>Hilarious[(3*(s+t+u+k))+1]){
                                                        Hilarity[Hilarity[0]+1] = -(s+t+u+k);
                                                        Hilarity[0] = Hilarity[0]+1;
                                                } 
                                        } 
                                }
			}
			else if(gunk[i] == 'E'){
                        	s=0; 
                                t=0;
				u=0;
                                for(j=0; j<4; j=j+1){
                                        if(Hilariousness[3*j] == 4){ 
                                                s=s+1; 
                                        } 
                                        if((Hilariousness[3*j] == 3) && ((Hilariousness[(3*j)+1]*Glim[r-i][2][0])
                                        > (Hilariousness[(3*j)+2]*(Glim[r-i][2][0] - Glim[r-i][3][0])))){
                                                t=t+1;  
                                        }
					if((Hilariousness[3*j] == 3) && ((Hilariousness[(3*j)+1]*Glim[r-i][2][0])
                                        < (Hilariousness[(3*j)+2]*(Glim[r-i][2][0] - Glim[r-i][3][0])))){
                                                u=u+1;
                                        }
                                } 
                                for(j=0; j<(s-1); j=j+1){ 
                                        for(k=0; k<(s-j-1); k=k+1){
                                                Hilarity[Hilarity[0]+1] = 3-k;  
                                                Hilarity[0] = Hilarity[0]+1;
                                        } 
                                } 
                                for(j=0; j<t; j=j+1){
                                        for(k=0; k<s; k=k+1){ 
                                                if(Hilarious[(3*(4-s+k))+1]>Hilarious[(3*(3-s-j))+1]){ 
                                                        Hilarity[Hilarity[0]+1] = 4-s-j+k;  
                                                        Hilarity[0] = Hilarity[0]+1;
                                                } 
                                        } 
                                }
                        } 
                        else if(gunk[i] == 'F'){
                        	s=0; 
                                t=0; 
                                u=0; 
                                for(j=0; j<4; j=j+1){
                                        if((Hilariousness[3*j] == 4) && ((Hilariousness[(3*j)+1]*Glim[r-i][3][0])
                                        < (Hilariousness[(3*j)+2]*(Glim[r-i][3][0] - Glim[r-i][2][0])))){
                                                s=s+1; 
                                        } 
                                        else if((Hilariousness[3*j] == 4) && ((Hilariousness[(3*j)+1]*Glim[r-i][3][0])
                                        > (Hilariousness[(3*j)+2]*(Glim[r-i][3][0] - Glim[r-i][2][0])))){
                                                t=t+1;
                                        }
                                        else if(Hilariousness[3*j] == 3){
                                                u=u+1;
                                        }
                                }
				for(j=0; j<(t-1); j=j+1){
                                        for(k=0; k<(t-j-1); k=k+1){
                                                Hilarity[Hilarity[0]+1] = 3-s-k;
                                                Hilarity[0] = Hilarity[0]+1;
                                        } 
                                } 
                                for(j=0; j<u; j=j+1){
                                        for(k=0; k<t; k=k+1){
                                                if(Hilarious[(3*(4-t+k))+1]<Hilarious[(3*(3-s-t-j))+1]){
                                                        Hilarity[Hilarity[0]+1] = 4-s-t-j+k; 
                                                        Hilarity[0] = Hilarity[0]+1;
                                                } 
                                        } 
                                }
                        }
                        else if(gunk[i] == 'G'){
				s=0; 
                                t=0; 
                                u=0; 
                                v=0;
                                w=0; 
                                for(j=0; j<4; j=j+1){ 
                                        if((Hilariousness[3*j] == 4) && ((Hilariousness[(3*j)+1]*Glim[r-i][3][0])
                                        < (Hilariousness[(3*j)+2]*(Glim[r-i][3][0] - Glim[r-i][0][0])))){
                                                s=s+1; 
                                        } 
                                        else if((Hilariousness[3*j] == 4) && ((Hilariousness[(3*j)+1]*Glim[r-i][3][0])
                                        > (Hilariousness[(3*j)+2]*(Glim[r-i][3][0] - Glim[r-i][0][0])))){
                                                t=t+1;
                                        } 
                                        else if(Hilariousness[3*j] == 3){
                                                u=u+1;
                                        }
                                        else if(Hilariousness[3*j] == 2){
                                                v=v+1;
                                        } 
                                        else if(Hilariousness[3*j] == 1){
                                                w=w+1; 
                                        } 
                                }
				for(j=0; j<(w-1); j=j+1){ 
                                        for(k=0; k<(w-j-1); k=k+1){
                                                Hilarity[Hilarity[0]+1] = -(k+1);
                                                Hilarity[0] = Hilarity[0]+1; 
                                        } 
                                } 
                                for(j=0; j<w; j=j+1){
                                        for(k=0; k<(u+v); k=k+1){ 
                                                Hilarity[Hilarity[0]+1] = -(w+k-j);
                                                Hilarity[0] = Hilarity[0]+1;
                                        } 
                                } 
                                for(j=0; j<w; j=j+1){
                                        for(k=0; k<t; k=k+1){ 
                                                if(Hilarious[(3*(w-1-j))+1]>Hilarious[(3*(s+t+u+v+w-k-1))+1]){
                                                        Hilarity[Hilarity[0]+1] = -(u+v+w-j+k);
                                                        Hilarity[0] = Hilarity[0]+1;
                                                } 
                                        } 
                                }
				for(j=0; j<(u-1); j=j+1){
					for(k=0; k<(u-j-1); k=k+1){
						Hilarity[Hilarity[0]+1] = -(v+k+1);
						Hilarity[0] = Hilarity[0]+1;
					}
				}
                        }
                        else if(gunk[i] == 'H'){
				s=0;
                                t=0; 
                                u=0; 
                                v=0; 
                                w=0; 
                                for(j=0; j<4; j=j+1){
                                        if(Hilariousness[3*j] == 4){
                                                s=s+1;
                                        } 
                                        else if(Hilariousness[3*j] == 3){ 
                                                t=t+1; 
                                        } 
                                        else if(Hilariousness[3*j] == 2){
                                                u=u+1;
                                        }
                                        else if((Hilariousness[3*j] == 1) && ((Hilariousness[(3*j)+1]*Glim[r-i][0][0])
                                        < (Hilariousness[(3*j)+2]*Glim[r-i][3][0]))){
                                                v=v+1;
                                        }
                                        else if((Hilariousness[3*j] == 1) && ((Hilariousness[(3*j)+1]*Glim[r-i][0][0])
                                        > (Hilariousness[(3*j)+2]*Glim[r-i][3][0]))){
                                                w=w+1;
                                        } 
                                }
				for(j=0; j<(s-1); j=j+1){
                                        for(k=0; k<(s-j-1); k=k+1){
                                                Hilarity[Hilarity[0]+1] = 3-k;
                                                Hilarity[0] = Hilarity[0]+1;
                                        }
                                } 
                                for(j=0; j<(t+u); j=j+1){
                                        for(k=0; k<s; k=k+1){
                                                Hilarity[Hilarity[0]+1] = w+v+u+t+k-j; 
                                                Hilarity[0] = Hilarity[0]+1;
                                        } 
                                } 
                                for(j=0; j<s; j=j+1){
                                        for(k=0; k<v; k=k+1){ 
                                                if(Hilarious[(3*(w+v+u+t+j))+1]>Hilarious[(3*k)+1]){
                                                        Hilarity[Hilarity[0]+1] = w+v+j-k;
                                                        Hilarity[0] = Hilarity[0]+1;
                                                } 
                                        } 
                                }
                        }
			int z;
			for(z=0; z<12; z=z+1){
				Hilariousness[z] = Hilarious[z];
			}			
		}
		return Hilarity;
	}

}