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

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

		System.out.println("Now, we will finish the 3-cusp business.");

		FileOutputStream out;
		PrintStream jj;

		try {
			out = new FileOutputStream("fray.btt");
			jj = new PrintStream(out);

			System.out.println("Please enter the exponent. ");
			String word = bufRead.readLine();
			int n, q, r, s;
			n = Integer.valueOf(word).intValue();
			int[][][][] cheese;
			int[][][][] fooz;
			int[][][] foozball;
			cheese = new int[11][3000][11][4];
			fooz = new int[6][10000][11][4];
			foozball = new int[6][10000][40];
			cheese = Zobo(n, cheese);
			fooz = Entry(n, cheese, fooz);		
			foozball = Braidorama(n, fooz, foozball);
			Foxorama(n, foozball);

			jj.println("to test.out");
			for(q=1; q <= foozball[0][0][0]; q++) {
				for(r=1; r <= foozball[q][0][0]; r++) {
					jj.print("br ");
					for(s=1; s <= foozball[q][r][0]; s++) {
						jj.print(foozball[q][r][s]);
						jj.print(" ");
					}
					jj.println("0");
				}
			}
			jj.close();

			System.out.println("Them's the braids.");
		}

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

	public static int[][][][] Zobo(int n, int[][][][] cheese){
		int a,b,z;
		int i,L;
		for(z=1; z<=n; z++){
		L = 1;
		for(a=1; a<=(2*z); a++){
			int c,d,e,f,g,h,j,k,m;
			c = 1;
			e = (2*a);
			for(d=1; d<=a; d++){
				c = (2*c);
			}
			for(d=0; d<=1; d++){
				c = c-1+(3*d);
				if (1 == 1) {
				System.out.print("Denom: ");
				System.out.println(c);
				}
				g = (2*c);
				h = (3*c);
				m = (2*z)-1+d;
				for(b=1; b<=g; b++){
					j = b;
					k = 0;
					f = (2*b);
					for(i=1; i<=z; i++){
						cheese[z][L][i][3] = b;
						if (f < c) {
							b = (2*b);
						}
						else if (b < c) {
							b = (2*b);
						}
						else {
							b = h - b;
						}
						f = (2*b);
						cheese[z][L][i][2] = b;
						if (b < c) {
							b = c - b;
						}
						else if (f < h) {
							b = f - g;
						}
						else {
							b = f - g;
						}
						if (b <= j) {
							k = k+1;
						}
						cheese[z][L][i][0] = b;
					}
					if ((k == 1) && (b == j)) {
						cheese[z][L][0][0] = c;
						if (1 == 1) {
						System.out.print("Nums: ");
						for(i=1; i<=z; i++) {
							System.out.print(cheese[z][L][i][3]);
							System.out.print(", ");
							System.out.println();
						}
						}
						L = L+1;
					}
					b = j;
				}
			}
		}
		cheese[z][0][0][0] = L-1;
		}
		return cheese;
	}

	public static int[][][][] Entry(int n, int[][][][] cheese, int[][][][] fooz){
		int a, i, j, k, w, y;
		a = (n/2);
		for (i=1; i<=a; i++){
			for(j=1; j<=cheese[i][0][0][0]; j++){
				for(k=1; k<=cheese[n-i][0][0][0]; k++){
					y = ((j-1)*cheese[n-i][0][0][0])+k;
					for(w=1; w<=i; w++){
						fooz[i][y][w][0] = cheese[i][j][w][0];
						fooz[i][y][w][1] = 1;
						fooz[i][y][w][2] = cheese[i][j][w][2];
						fooz[i][y][w][3] = cheese[i][j][w][3];
					}
					fooz[i][y][0][1] = cheese[i][j][0][0];
					for(w=1; w<=(n-i); w++){
						fooz[i][y][i+w][0] = cheese[n-i][k][w][0];
						fooz[i][y][i+w][1] = 2;
						fooz[i][y][i+w][2] = cheese[n-i][k][w][2];
						fooz[i][y][i+w][3] = cheese[n-i][k][w][3];
					}
					fooz[i][y][0][2] = cheese[n-i][k][0][0];
				}
			}
			fooz[i][0][0][0] = (cheese[i][0][0][0]*cheese[n-i][0][0][0]);
		}
		fooz[0][0][0][0] = a;
		return fooz;
	}

	public static int[][][][] Sortorama(int n, int j, int[][][][] fooz, int a, int b){
		int c,d,w,x,y,z;
		float e,f,g,h;
				for(c=1; c<n; c++){
					for(d=(c+1); d<=n; d++){
						e = fooz[a][b][c][j];
						f = fooz[a][b][0][fooz[a][b][c][1]];
						g = e/f;
						e = fooz[a][b][d][j];
						f = fooz[a][b][0][fooz[a][b][d][1]];
						h = e/f;
						if (h<g) {
							w = fooz[a][b][c][0];
							x = fooz[a][b][c][1];
							y = fooz[a][b][c][2];
							z = fooz[a][b][c][3];
							fooz[a][b][c][0] = fooz[a][b][d][0];
							fooz[a][b][c][1] = fooz[a][b][d][1];
							fooz[a][b][c][2] = fooz[a][b][d][2];
							fooz[a][b][c][3] = fooz[a][b][d][3];
							fooz[a][b][d][0] = w;
							fooz[a][b][d][1] = x;
							fooz[a][b][d][2] = y;
							fooz[a][b][d][3] = z;		
						} 
					}
				}
			if (0 == 1) {
			System.out.print(a);
			System.out.println(":");
				System.out.print("[ ");
				for(c=1; c<=n; c++) {
					System.out.print(fooz[a][b][c][3]);
					System.out.print(", ");
				}
				System.out.println("]");
			}


		return fooz;
	}

	public static int[][][] Braidorama(int n, int[][][][] fooz, int[][][] foozball){
		int a, b, c, d, e, f, g, h, i;
		float p, q, r, s;
		foozball[0][0][0] = fooz[0][0][0][0];
		for(a=1; a<=fooz[0][0][0][0]; a++) {
			foozball[a][0][0] = fooz[a][0][0][0];
			for(b=1; b<=fooz[a][0][0][0]; b++) {
				fooz = Sortorama(n,3,fooz,a,b);
				foozball[a][b][0] = 0;
				c = 0;
				d = 0;
				e = 0;
				f = n;
				while ((c == 0) && (d != n)){
					p = fooz[a][b][d+1][3];
					if (fooz[a][b][d+1][1] == 1) {
						q = fooz[a][b][0][1];
					}
					else {
						q = fooz[a][b][0][2];
					}
					r = p/q;
					if ((r > 0.5) && (e == 0)) {
						f = d;
						e = 1;
					}
					if (r > 1) {
						c = 1;
						d = d-1;
					}
					d = d+1;
				}
				i = n-d;
				for (g=1; g <= i; g++) {
					for (h=1; h <= (i-g); h++) {
						foozball[a][b][foozball[a][b][0]+1] = n-h;
						foozball[a][b][0] = foozball[a][b][0]+1;
					}
				}
				for (g=1; g<=i; g++) {
					for(h=1; h <= (d-f); h++) {
						p = fooz[a][b][n-g+1][2];
						if (fooz[a][b][n-g+1][1] == 1) {
							q = fooz[a][b][0][1];
						}
						else {
							q = fooz[a][b][0][2];
						}
						r = p/q;
						p = fooz[a][b][d-h+1][2];
						if (fooz[a][b][d-h+1][1] == 1) {
							q = fooz[a][b][0][1];
						}
						else {
							q = fooz[a][b][0][2];
						}
						s = p/q;
						if (r < s) {
							foozball[a][b][foozball[a][b][0]+1] = d-h+g;
							foozball[a][b][0] = foozball[a][b][0]+1;
						}
					}
				}
				if ((a == 1) && (b == 1)){
					System.out.println("ao");
					System.out.println(d);
					System.out.println(f);
				}
				fooz = Sortorama(n, 2, fooz,a,b);
				c = 0;
				d = 0;
				e = 0;
				f = n;
				while ((c == 0) && (d != n)){
					p = fooz[a][b][n-d][2];
					if (fooz[a][b][n-d][1] == 1) {
						q = fooz[a][b][0][1];
					}
					else {
						q = fooz[a][b][0][2];
					}
					r = p/q;
					if ((r < 1.5) && (e == 0)) {
						f = d;
						e = 1;
					}
					if (r < 1){
						c = 1;
						d = d-1;
					}
					d = d+1;	
				}
				if ((a == 1) && (b == 1)){
					System.out.println("bo");
					System.out.println(d);
					System.out.println(f);
				}
				i = n-d;
				for (g=1; g <= i; g++) {
					for(h=1; h <= (i-g); h++) {
						foozball[a][b][foozball[a][b][0]+1] = -h;
						foozball[a][b][0] = foozball[a][b][0]+1;
					}
				}
				for (g=1; g<=i; g++) {
					for(h=1; h <= (d-f); h++) {
						p = fooz[a][b][g][0];
						if (fooz[a][b][g][1] == 1) {
							q = fooz[a][b][0][1];
						}
						else {
							q = fooz[a][b][0][2];
						}
						r = p/q;
						p = fooz[a][b][i+h][0];
						if (fooz[a][b][i+h][1] == 1) {
							q = fooz[a][b][0][1];
						}
						else {
							q = fooz[a][b][0][2];
						}
						s = p/q;
						if (r > s) {
							foozball[a][b][foozball[a][b][0]+1] = -(i+h-g);
							foozball[a][b][0] = foozball[a][b][0]+1;			
						}
					}
				}
			}
		}


		return foozball;
	}

	public static void Foxorama(int n, int[][][] foozball){
		int a, b, c, d;
		for(a=1; a<=foozball[0][0][0]; a++){
			System.out.print("These are the ");
			System.out.print(a);
			System.out.print(", ");
			b = n-a;
			System.out.print(b);
			System.out.println(" cycle braids:");
			for(c=1; c<=foozball[a][0][0]; c++){
				System.out.print("[");
				for(d=1; d<=foozball[a][c][0]; d++){
					System.out.print(foozball[a][c][d]);
					System.out.print(", ");
				}
				System.out.println("]");
			}
		}
	}

	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[] Crazylikes, 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((Crazylikes[3*(i+j+1)] < Crazylikes[3*i]) || ((Crazylikes[3*(i+j+1)] == Crazylikes[3*i]) 
				&& (Crazylikes[(3*(i+j))+4] < Crazylikes[(3*i)+1]))){
					Y[0] = Crazylikes[3*i];
					Y[1] = Crazylikes[(3*i)+1];
					Y[2] = Crazylikes[(3*i)+2];
					Y[3] = Crazylikes[3*(i+j+1)];
					Y[4] = Crazylikes[(3*(i+j))+4];
					Y[5] = Crazylikes[(3*(i+j))+5];
					Crazylikes[3*i] = Y[3];
					Crazylikes[(3*i)+1] = Y[4];
					Crazylikes[(3*i)+2] = Y[5];
					Crazylikes[3*(i+j+1)] = Y[0];
					Crazylikes[(3*(i+j))+4] = Y[1];
					Crazylikes[(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 Crazylikes;
	}

	public static void Pseudo(){
		


	}





	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;
	}

}