public static String decrypt(String hash){                       							
																																										// The hash for the password that was generated by the encryption program
		String rands = "";																																				// Houses the concatenated random values from the encryption program 
		String unencrypted = "";																																		// The returned, unencrypted password in String form
		int passwordlength = Integer.parseInt(hash.substring(0,2));																										// From the first two numbers of the seed, it gets the length of the password.
		//int counter = 0;
		int innercounter = 0;
		
		/* Setting up parts of the password to be broken into chunks */
		int[] lengthofencryptedchars = new int[passwordlength];
		int[] unsortedrandoms = new int[passwordlength * 3];
		int[] randoms = new int[(passwordlength * 3) - 2];
		int[] encryptedchars = new int[passwordlength];
		int[] asciivalues = new int[passwordlength];
		char[] unencryptedchars = new char[passwordlength];
		
		String withoutlen = hash.substring(2,hash.length());																											// Creates a string without the first two digits, which are the length of the user's password
		
		char[] passarr = withoutlen.toCharArray();																														// Converts the string to character array
		
		/* Handles getting length of encrypted values.  Stores them in keys1[i] */
		for(int i = 0; i < passwordlength; i++){																														// Loop for concatenating the next passwordlength worth of characters (numbers in the hash) into its own array so we know the values we're working with later
			String placeholder = "" + passarr[i];																														// In the hash above, you see 5555555555, which is (Ascii value of user pass character * random-three-digit-value).length() for each character.  
			lengthofencryptedchars[i] = Integer.parseInt(placeholder);																									// Throws it into Array of ints to use in a loop later
		}
		
		String withoutkeys1 = withoutlen.substring(passwordlength, withoutlen.length());																				// Removes keys1 from the hash.
		
		char[] nolengthofchars = withoutkeys1.toCharArray();																											// Converts the new hash to Character array (minus lengthofencryptedchars) 
		
		/* Handles getting the randoms thrown into one string called rands */
		for (int i = 0; i < passwordlength * 3; i++){																													// Since there are 3 numbers per random number, and passwordlength characters, it runs passwordlength * 3 times to separate the randoms into array.
			String placeholder = "" + nolengthofchars[i];																												// Concatenating randoms to int array called unsortedrandoms
			unsortedrandoms[i] = Integer.parseInt(placeholder);
			rands = rands + unsortedrandoms[i];																															// Makes string rands = a concatenation of all the unsorted randoms together
		}

		char[] unsortedrandschar = rands.toCharArray();																													// Makes a new char array of the randoms so they're easy to concatenate below
		
		for (int i = 0; i < rands.length(); i = i+3){
			String placeholder = Character.toString(unsortedrandschar[i]) + Character.toString(unsortedrandschar[i+1]) + Character.toString(unsortedrandschar[i+2]);    // Concatenates three characters in unsortedrandomchars to string placeholder
			int placeholderint = Integer.parseInt(placeholder);																											// This and the line below it convert the string to int and throw it into the array of proper randoms
			randoms[i] = placeholderint;
		}
				
		String withoutrands = withoutkeys1.substring(passwordlength * 3, withoutkeys1.length());																		// Breaks up the rest of the hash to no longer include the random values

		char[] hashwithoutrands = withoutrands.toCharArray();																											// Creates array of numbers in the hash without the randoms now
		
		int[] passwordhash = new int[hashwithoutrands.length];																											// Sets up an array of ints to break up the rest of the hash with
		
		/* Breaks down the rest of the hash into an array of ints */
		for(int i = 0; i < hashwithoutrands.length; i++){
			String placeholder = "" + Character.toString(hashwithoutrands[i]);
			passwordhash[i] = Integer.parseInt(placeholder);
		}
		
		/* Variables used for loop below */
		int x = 0;
		String loop = "";																																				// Will house the string of the number as it is being concatenated
		
		for(int i = 0; i < passwordlength; i++){																														// This runs 10 times in the example.  Once for each character in the original password (passwordlength times)
			for(x = 0; x < lengthofencryptedchars[i]; x++){																												// I threw the lengths of the encrypted chars in an array earlier.  Now the loop will run that number of times to change the unsorted numbers in val(passwordlength) numbers
				loop = loop + passwordhash[innercounter];																												// Concatenate the number
				innercounter = innercounter + 1;																														// Advance the innercounter by 1 to get next number
			}
			encryptedchars[i] = Integer.parseInt(loop);																													// Add now correct encrypted password character to array with type int
			loop = "";																																					// Clear loop to be used in next cycle of getting numbers
		}
		
		int randomscounter = 0;																																			// Used to increment the randoms by 3 due to having to set them to[0,3,6,9...]
		
		/* Converts encrypted chars to ascii values */
		for(int i = 0; i < encryptedchars.length; i++){
			asciivalues[i] = encryptedchars[i] / randoms[randomscounter];																								// Sets the values of encrypted / random = asciivalue
			randomscounter = randomscounter + 3;																														// Increments randomscounter by three (See line 146)
		}
		
		/* Converts Ascii characters to string */
		for(int i = 0; i < passwordlength; i++){
			int r = asciivalues[i];																																		// r = ascii value of character
			char f = (char) r;																																			// Creates f as a casted char of r (Converts from ascii number to character)
			unencryptedchars[i] = f;																																	// Stores character in array
		}
		
		/* Assigns the unencrypted password to a string */
		for(int i = 0; i < unencryptedchars.length; i++){
			unencrypted = unencrypted + unencryptedchars[i];	
		}
		
		System.out.println(unencrypted);
		return unencrypted;
		
	}