.ORIG x3000		;LAB4

							GREETING3: 		.STRINGZ			"\n \n Please enter a string\n"
							GREETING1: 	 	.STRINGZ			"\n \n Enter a right offset cipher number \n"

	START

			; clear all registers that we may use
					AND	R0, R0, 0 			; USED FOR
					AND	R1, R0, 0			; USED FOR COUNTER
					AND	R2, R0, 0			; USED FOR INPUT SIZE CHECK
					AND	R3, R0, 0			; USED FOR HOLDS CIPHER
					AND	R4, R0, 0			; USED FOR ARRAY POINTER
					AND	R5, R0, 0			; USED FOR BASE ARRAY MEMORY LOCATION
					AND	R6, R0, 0			; USED FOR MEMORY POINTER
					ST R1, CIPHER
					ST R2, POINTER
					ST R1 CRYPTION
					ADD R1, R1, #1
					ST R1, COUNTER
					AND R1, R1, 0

					LD R5, ARRAY_ADDRESS


					LEA R0, GREETING3		; Prompt for string input
					PUTS


	STRING_INPUT		; print out STRING argument, stops when input = LF
					LD R6, INV_ASCII_LF

					BRz CIPHER_INPUT
					GETC					; Get string character
					PUTC					; Print character

					ADD R6 ,R6, R0			; Check if char was enter key
					BRz CIPHER_INPUT		; If 0 go back to start of loop to stop loop


					;Check if they have input 200 character limit
					LD R2 ARRAY_SIZE
					ADD R2, R2, R4
					BRn CIPHER_INPUT

			WRITEARRAY		; Stores into array
						STR R0, R5, 0 			; Store the contents of string index [a] into ARRAY+pointer
						ADD R5, R5, #1			; Increment pointer
						ADD R1, R1, #1			; Increment counter
						ST R5, POINTER			; Store pointer
						ST R1, COUNTER
						BRnzp STRING_INPUT		; Loop back to recieve next character


CIPHER_INPUT

						LEA R0 GREETING1	; Prompt for cipher input
						PUTS

		C_INPUT
						AND R3, R3, 0				; Enter button checking
						LD R3, ASCII_OFFEST
						LD R2 INV_ASCII_LF			; Multiplication

						GETC
						PUTC

						ADD R2, R2, R0			; CHECK IF INPUT = LF
						BRz CRYPTION_INPUT

						ADD R3, R3, R0			; OFFSET INPUT to give actual number offset

						LD R1, CIPHER				; Load the value of int into R1
						ADD R1, R1, R1			; Makes int into 2int
						ADD R2, R1, R1			; Makes int into 4int
						ADD R2, R2, R2			; Makes int into 8int
						ADD R2, R2, R1			; Adds 8int and 2int
						ADD R2, R2, R4			; Adds R4, or digit, to 10int
						ADD R2, R3, R2
						ST R2, CIPHER				; Store 10int + digit into INT
						ADD R2 R2, 0			; Add dummy 0 so BR checks R2 instead of R3

						BRnzp C_INPUT




CRYPTION_INPUT 		; print out CIPHER argument, valid inputs are D, E, or X

						LEA R0, GREETING2		; Load cryption prompt
						PUTS					; Print cryption prompt
						GETC					; Get value, store into R0
						PUTC					; Display value entered

				; Check if input == D
						LD R1, INV_ASCII_D		; Load ascii value of inverse D character
						ADD R1, R1, R0			; Add input and inverse D to check if result is 0
						BRz DECRYPT; If 0 go to DECRYPT subroutine

				; Check if input == E
						LD R1, INV_ASCII_E		; Load ascii value of inverse E character
						ADD R1, R1, R0			; Add input and inverse E to check if result is 0
						BRz ENCRYPT				; If 0 go to ENCRYPT subroutine

						LD R1, INV_ASCII_X		; Load ascii value of inverse X
				; Check if input == X
						ADD R1, R1, R0			; Add input and inverse X to check if result is 0
						BRz STOP				; If 0 STOP

						ST R0 CRYPTION			; Set R4 to value of char - 48 (digit)

						BRnzp CRYPTION_INPUT		; If not valid input loop back to reprompt for cipher





DECRYPT								; Inverts cipher
					ST  R0, REG0
					ST	R1, REG1
					ST	R2, REG2
					ST	R3, REG3
					ST	R4, REG4
					ST	R5,	REG5
					ST	R6,	REG6

LD R1, CIPHER
NOT R1, R1
ADD R1, R1, #13
ADD R1, R1, #12
ST R1, CIPHER
BRnzp CRYPT

ENCRYPT
					ST  R0, REG0
					ST	R1, REG1
					ST	R2, REG2
					ST	R3, REG3
					ST	R4, REG4
					ST	R5,	REG5
					ST	R6,	REG6
	CRYPT				AND	R0, R0, 0 			; HOLD CIPHER
					AND	R1, R0, 0			; ITERATION COUNTER
					AND	R2, R0, 0			; BASE ARRAY POINTER
					AND	R3, R0, 0			;	 CRYPTED ARRAY POINTER
					AND	R4, R0, 0			; USED FOR CHARACTER CHECKING
					AND	R5, R0, 0			; VALUE OF BASE REGISTER
					AND	R6, R0, 0			; WORKING REGISTER

					LD R0, CIPHER
					LD R1, COUNTER				 ; Pointer used as counter
					LD R2, ARRAY_ADDRESS				 ; Set R2 to location of base array
					LD R3, ARRAY_SIZE	 ; Set R3 to location of encrypted array
					ADD R3, R3, R2




			FUNCTION

					JSR LOAD 					; CALL LOAD ROUTINE

					BRz PRINT


					LD R4, INV_64			; CHECK IF STRING WAS NOT LETTER, less than capital A
					ADD R4,R4, R5
					BRn INSTANT_WRITE

					LD R4, INV_122			; CHECK IF STRING WAS NOT LETTER, less than lowercase z
					ADD R4, R4, R5
					BRp INSTANT_WRITE`
				;	LD R6, INV_90			; CHECK IF STRING WAS NOT LETTER, less between capital Z and lowercase a
				;	ADD R6, R6, R5
				;	LD R4, INV_6
				;	ADD R4, R6, R6
				;X	BRn INSTANT_WRITE

					LD R6, INV_90			; IF STRING < 90, must be lowercase
					ADD R6, R6, R5
					BRnz UPPERCASE

					BRnzp LOWERCASE		; IF STRING >90m must be uppercase


					INSTANT_WRITE		;Check if input equals space

							JSR STORE
							ADD R2, R2, #1	; INCREMENT BASE ARRAY Pointer
							ADD R3, R3, #1  ; INCREMENT CRYPTED ARRAY Pointer
							ADD R1, R1, #-1 ; DECREMENT COUNT
							BRnzp FUNCTION

					LOWERCASE

							LD R6, INV_122
							ADD R6, R6, R0
							ADD R6, R6, R5			; Check if cipher + input is greater than uppercase Z
							BRp LOWERRIGHTWRAP
							LD R6, INV_97
							ADD R6, R6, R0
							ADD R6, R6, R5			; Check if cipher + input is greater than uppercase Z
							BRn LOWERLEFTWRAP

							BRnzp WRITE

									LOWERRIGHTWRAP				;Lowercase rightwards wrap - cipher = cipher -  26

											LD R6, INV_26
											ADD R0, R0 R6
											BRnzp WRITE

									LOWERLEFTWRAP

											LD R6, INV_26		;Lowercase leftwards wrap - cipher = !cipher + 26
											NOT R6, R6
											ADD R0, R0, R6
											BRnzp WRITE

					UPPERCASE

							LD R6, INV_90
							ADD R6, R6, R0
							ADD R6, R6, R5			; Check if cipher + input is greater than uppercase Z
							BRp UPPERRIGHTWRAP

							LD R6, INV_65
							ADD R6, R6, R0
							ADD R6, R6, R5			; Check if cipher + input is greater than uppercase Z
							BRn UPPERLEFTWRAP

							BRnzp WRITE

									UPPERRIGHTWRAP

											LD R6, INV_26
											ADD R0, R0 R6
											BRnzp WRITE

									UPPERLEFTWRAP

											LD R6, INV_26
											NOT R6, R6
											ADD R0, R0, R6
											BRnzp WRITE


				WRITE
							ADD R5, R5, R0	; Add cipher to R5
							JSR STORE
							ADD R2, R2, #1	; INCREMENT BASE ARRAY Pointer
							ADD R3, R3, #1  ; INCREMENT CRYPTED ARRAY Pointer
							ADD R1, R1, #-1 ; DECREMENT COUNT
							BRnzp FUNCTION

PRINT

				LEA R0 , GREETING4		;Here is your original string and encrypted result
				PUTS

				LEA R0, GREETING6		;<Original>:
				PUTS

				LEA R0, ARRAY			;Print original array
				PUTS

				LEA R0, GREETING5		;<Encrypted>:
				PUTS

				LEA R0, ARRAY			;Print crypted array
				LD R1, ARRAY_SIZE
				ADD R0, R0, R1
				PUTS

		AND R1, R1, 0
		LD R2 ARRAY_SIZE	;R2 as counter for cleararray
		ADD R2, R2, R2
		LEA R0, ARRAY

		CLEARARRAY
			BRnz START
			STR R1, R0, 0
			ADD R0, R0, #1
			ADD R2, R2, #-1
			BRnzp CLEARARRAY


RESTOREARRAY

			ST  R0, REG0
			ST	R1, REG1
			ST	R2, REG2
			ST	R3, REG3
			ST	R4, REG4
			ST	R5,	REG5
			ST	R6,	REG6
			BRnzp START


LOAD 		;SETS R5 TO VALUE OF (Ri, Ci) with R0 as row (1 or 2), R2 as column (1-200)

					LDR R5, R2, 0	; LOAD given array index into given register
					RET


STORE		;STORES VALUE OF (Ri, Ci) with R0 as row (1 or 2(, R3 as column (1-200)

					STR R5, R3, 0	; STORE given register into given array index
					RET

	STOP HALT

				;DECLERATION


							CIPHER 				.fill 0 		;	Value from 0 - 25 that denotes rightward shift
							POINTER 			.fill 0
							COUNTER			.fill 1
							CRYPTION			.fill 0
							ARRAY_SIZE			.fill #200;
							INV_ASCII_E 		.fill #-69
							INV_ASCII_D 		.fill #-68
							INV_ASCII_X 		.fill #-88
							INV_ASCII_LF 		.fill #-10
							INV_ASCII_SPACE	.fill #32
							INV_64				.fill #-64
							INV_122			.fill #-122
							INV_90				.fill #-90
							INV_6				.fill #-6
							INV_97				.fill #-97
							INV_26				.fill #-26
							INV_65				.fill #-65
							ASCII_OFFEST 		.fill #-48
							ARRAY_ADDRESS		.fill ARRAY
							REG0				.fill 0
							REG1				.fill 0
							REG2				.fill 0
							REG3				.fill 0
							REG4				.fill 0
							REG5				.fill 0
							REG6				.fill 0
							REG7				.fill 0
							GREETING6			.STRINGZ			"\n <Original>: "
							GREETING5			.STRINGZ			"\n <Crypted>: "
							GREETING4			.STRINGZ			"\n Here is your original string and crypted result"

							GREETING2:			.STRINGZ			"\n \n Enter 'E' to encrypt, or 'D' to decrypt, or X to cancel \n"

							ARRAY .BLKW 400

	.END