Finished Mips Project

.data
	p: 	.space 4 	#retinem valoarea p
	a:	.space 4000	#Input maxim e 1000, ultimul prim posibil e 997
	mesajn: .space 1000
	mesajc: .space 1000
	alfabet:.asciiz "ABCDEFGHIJKLMNOPQRSTUVWXYZ *"
	newl:	.asciiz "\n"
	fgen: 	.asciiz "Generatoul g este: "
	errPrime: .asciiz "P nu este un numar prim!"
	errGen: .asciiz "Eroare Generator(404)"

.text
main:
	######
	##Rezolvare punctul a
	######

	li $v0,5	#Citire p
	syscall
	sw $v0,p 	#punem val citita in p

	#Verificare p prim
	li $t0,2 	#Punem in $t0 divizorul posibil al lui p
	mul $t1,$t0,$t0	#Folosim $t1 pentru conditie only, echivalentul cu i*i<=n (pentru eficienta)
	lw $t2,p	#In $t2 il retinem pe p

	Lprim:
		bgt $t1,$t2,findGen	#Daca trece for-ul de divizibilitate, inseamna ca p e prim, deci cotinuam rezolvarea problemei

		rem $t3,$t2,$t0		# $t3 = $t2 % $t0 (Restul impartirii la $t0, nu la $t1!!)

		beq $t3,$0,notPrime 	# Daca $t3!=0 atunci p nu e prim, incheiem programul

		addi $t0,$t0,1		# Adaugare 1 la indice
		mul $t1,$t0,$t0		# Facem update la "i*i"
		j Lprim

	#Continuarea problemei => p e prim
findGen:
	lw $t1,p			#Retinerea lui p in $t1
	li $t0,2			#In $t0 retinem numarul generatorului, incepem de la 2
	beq $t1,$t0,assignGenException	#In cazul ca p=2, vom folosi generatorul 1

	Lgen:
		bge $t0,$t1,errGenNotFound	#Nu e posibil sa ajunga in cazul errGenNotFound, daca input-ul e corect

		li $t9,0	#$t9 reprezinta pozitia in vector(din 4 in 4)
		li $t8,0	#$t8 reprezinta indicele vectorului

		Lvectgen:
			bge $t8,$t1,genCorect

			li $t7,1	#Valoarea lui g mod p
			li $t6,1	#Puterea la care e ridicat g-ul ($t7)

			ridPut:
				bgt $t6,$t8,verificUnic	# Ridicam pana la puterea $t8(indicele elementului)
				mul $t7,$t7,$t0		# $t7 = ($t7 * g) % p
				rem $t7,$t7,$t1

				addi $t6,$t6,1

				j ridPut

			verificUnic: 		#Verifica daca mai e un element egal in vector cu un for pana la ultimul element din vector
						#Incep de la pozitia 1 pentru ca g^0 va fi intotdeauna 1, si se poate demonstra ca in solutie
						#va mai exista un singur elem 1, doar in pozitia g^(p-1) cu ajutorul inversului modular, deoarece p e prim:
						# g^(p-2)=1(mod p)=> g^(p-1)%p=1 oricare ar fi g<p
				li $t5,4	#reprezinta pozitia pe memoria vect
				li $t4,1	#reprezinta indicele pe vect

				loopVect:			#Verificam fiecare element din vector daca e egal cu elementul pe care vrem sa il adaugam
					bge $t4,$t8,addInV	#Daca ajungem la ultimul element din vector, elementul pe care il adaugam e unic, deci adaugam
					lw $t3,a($t5)
					beq $t7,$t3,genGresit	#daca exista un element egal, gen e gresit si cautam alt generator
					addi $t5,$t5,4
					addi $t4,$t4,1
					j loopVect

			addInV:

				sw $t7,a($t9)	#Adaugam in vector si marim indicele
				addi $t8,$t8,1
				addi $t9,$t9,4
				j Lvectgen

			genGresit:
				addi $t0,$t0,1	#Trecem la uramtor generator
				j Lgen

	#Am gasit generatorul, se afla in $t0
genCorect:

	la $a0,fgen	#Afisare generator si afisare new line
	li $v0,4
	syscall
	move $a0,$t0
	li $v0,1
	syscall
	la $a0,newl
	li $v0,4
	syscall

	######
	##Rezolvare punctul b
	######

	li $a1,1000	#Citire mesaj necriptat de lungime maxima 1000
	la $a0,mesajn
	li $v0,8
	syscall

	li $t0,0 	#indicele, care va reprenta lungimea sirului, in t1 se afla p
	li $t5,10	#String a0 citeste si enter-ul care e defapt un backspace?, 10 e codul ascii pentru backspace

	#Incepem parcurgeream string-ului
	Lcript:
		lb $t2,mesajn($t0)	#Load litera din mesajul necriptat
		li $t5,10		#Comparare cu backspace, poate doar in tio.run?
		beq $t2,$t5,doneCript	#Terminarea mesajului necriptat
		li $t5,13		#Comparare cu carriage return(enter) (Nu e nevoie in cazul meu, dar poate pe un compiler e nevoie)
		beq $t2,$t5,doneCript	#Terminarea mesajului necriptat
		li $t9,0		#indice in alfabet
		findInAlph:
			lb $t8,alfabet($t9)	#Gasirea literei in alfabet
			beq $t2,$t8,afisCript	#$t9 retine pozitia din alfabet al caracterului
			addi $t9,1
			j findInAlph

		afisCript:
			mul $t9,$t9,4		#Schimbam $t9 pentru pozitia din vector de .word
			lw $t9,a($t9)		#Obtinem pozitia din alfabet a literei criptate
			rem $t9,$t9,27		#Modulo 27 pentru a le mentine in alfabet(optimizare pentru p mai mare de 29)
			lb $a0,alfabet($t9)	#Obtinerea literei si afisarea acesteia
			li $v0,11
			syscall
			addi $t0,1		#Urmatoarea litera din mesajul necriptat
			j Lcript

doneCript:
	la $a0,newl
	li $v0,4	#Print new line
	syscall

	######
	##Rezolvare punctul c
	######

	li $a1,1000	#citire mesaj criptat de lungime maxima 1000
	la $a0,mesajc
	li $v0,8
	syscall

	li $t0,0 		#indicele, care va reprenta lungimea sirului

	#Incepem parcurgeream string-ului
	Ldecript:
		lb $t2,mesajc($t0)	#litera din mesaj necriptat
		beqz $t2,Exit		#Daca e null, terminare program, Exit
		li $t9,0		#Indice alfabet
		findInAlphC:
			lb $t8,alfabet($t9)	#Gasirea literei in alfabet
			beq $t2,$t8,findInA	#$t9 retine pozitia din alfabet al caracterului
			addi $t9,1		#t9 reprezinta pozitia literei in alfabet
			j findInAlphC

		findInA:
			li $t8,0	#pozitia in adresa a unui element din vector
			li $t7,0	#indicele elem din vector
			loopInA:
				lw $t6,a($t8)	#Cautam in a indicele corespunzator literei din mesaj criptat, care reprezinta decriptarea acesteia adica
				beq $t6,$t9,afisDecript	#pozitia ei din vectorul alfabet
				addi $t8,4		#Cand o gasim afisam decriptarea acesteia
				addi $t7,1		#t1 reprezinta pozitia literei criptate in a adica criptare(t7) = t2 (litera criptata)
				j loopInA

		afisDecript:
			rem $t7,$t7,27		#Facem modulo 27, pentru a o mentine in alfabet
			lb $a0,alfabet($t7)	#Afisam litera decriptata corespunzatoare
			li $v0,11
			syscall
			addi $t0,1		#trecem la urmatoarea litera din mesaj criptat
			j Ldecript



notPrime:		#Eroare p nu e prim, afisam mesaj + exit
	la $a0,errPrime
	li $v0,4
	syscall
	j Exit

assignGenException:	#Caz cand p e 2
	li $t0,1
	j Lgen

errGenNotFound:		#Caz cand input < 1
	la $a0,errGen
	li $v0,4
	syscall
	j Exit

Exit:
	li $v0,10
	syscall