Create a new version of paste:

			.data
#	A: 					.space 1024									#первое число
#	B: 					.space 1024									#второе число
	Temp:				.space 1024									#запасной массив
#	S:					.space 4
	First:				.asciiz "Input format: \nFirst number(press Enter)\n"
	Sign:				.asciiz "Sign(press Enter)\n"
	Second:				.asciiz "Second number(press Enter)\n"
	Enter:				.asciiz "\n"
	A:					.asciiz "28\n"
	B:					.asciiz "2\n"
	S:					.asciiz "*\n"
	A_size:				.word 0
	B_size:				.word 0
	Temp_size:			.word 0
								

			.text
#v0 - syscall parameter
#a0 - syscall paramter(print)
main: 

	la 		$a0, First
	li 		$v0, 4
	syscall
	nop
	la 		$a0, Sign
	li 		$v0, 4
	syscall
	nop
	la		$a0, Second
	li 		$v0, 4
	syscall

#	la 		$a0, A				#ввод первого числа
#	li 		$a1, 1024
#	li 		$v0, 8
#	syscall
#	nop

#	la 		$a0, S				#ввод знака
#	li 		$a1, 1024
#	li 		$v0, 8
#	syscall
#	nop 

#	la 		$a0, B				#ввод второго числа
#	li 		$a1, 4
#	li 		$v0, 8
#	syscall
#	nop
	

	la 		$t1, A				
	li 		$t2, 0				# $t2 - размер числа A

A_loop:
	lb		$t3, ($t1)
	beq		$t3, 10, end_A_loop
	addu	$t1, $t1, 1
	addu	$t2, $t2, 1
	b		A_loop
end_A_loop:
	nop

################################
##вывод размера числа A
##	move	$a0, $t2
##	li		$v0, 1
##	syscall
###############################

	la		$t1, B
	li		$t3, 0				# $t3 - размер числа B


B_loop:
	lb		$t4, ($t1)
	beq		$t4, 10, end_B_loop
	addu	$t1, $t1, 1
	addu	$t3, $t3, 1
	b		B_loop
end_B_loop:
	nop

################################
##вывод размера числа B
##	move	$a0, $t3
##	li		$v0, 1
##	syscall
################################

	sw		$t2, A_size
	sw		$t3, B_size
	la 		$t1, A
	nop
	add		$t4, $t1, $t2				# $t1 - указатель на начало массива A, $t4 - указатель на конец массива А  
	sub		$t4, $t4, 1

Rotate_A_loop:							# переворот числа А
	ble		$t4, $t1, end_Rotate_A_loop
	lb		$t5, ($t1)		#элемент слева
	lb		$t6, ($t4)		#элемент справа
	nop
	sb		$t6, ($t1)		#меняем местами
	sb		$t5, ($t4)		#меняем местами
	add 	$t1, $t1, 1
	sub		$t4, $t4, 1
	b		Rotate_A_loop
end_Rotate_A_loop:
	nop

#################################
##вывод перевернутого числа A	
##	la		$a0, A
##	li		$v0, 4
##	syscall
##все работает
#################################

	la		$t1, B
	add		$t4, $t1, $t3
	sub		$t4, $t4, 1

Rotate_B_loop:							# переворот числа В
	ble		$t4, $t1, end_Rotate_B_loop
	lb		$t5, ($t1)
	lb		$t6, ($t4)
	nop
	sb		$t6, ($t1)
	sb		$t5, ($t4)
	add		$t1, $t1, 1
	sub		$t4, $t4, 1
	b		Rotate_B_loop
end_Rotate_B_loop:
	nop
##################################
##вывод перевернутого числа B
##	la		$a0, B
##	li		$v0, 4
##	syscall
##Все работает
##################################


	la		$t0, A						# указатель на начало A
	la		$t1, B						# указатель на начало B
	
	lw		$t2, A_size					#размер A
	lw		$t3, B_size					#размер B

	
	add		$t0, $t0, $t2				#указатель на конец A
	add		$t1, $t1, $t3				#указатель на конец B
	li		$t4, '0'

###################################
##Вывод размеров чисел A и B
##	move 	$a0, $t2
##	li		$v0, 1
##	syscall
##	nop
##	move	$a0, $t3
##	li		$v0, 1
##	syscall
##	nop
##Тут все правильно
################################### 	

Add_A_Zero:	
	bge		$t2, $t3, end_Add_A_Zero
	nop
	add		$t2, $t2, 1
	sb		$t4, ($t0)					#добавляем 0, но че-та он тут не хочет добавляться(вроде теперь работает)
	nop
	add		$t0, $t0, 1
	b		Add_A_Zero
	nop
end_Add_A_Zero:
	nop

	sw		$t2, A_size
	li		$t4, '0'

#############################################
##вывод числа A(возможно с нулями)
##	la		$a0, Enter
##	li		$v0, 4
##	syscall
##
##	la		$a0, A
##	li		$v0, 4
##	syscall
##тут херня полная(вроде теперь пашет)
#############################################
	

##есть размер B больше(равен) A, то выход
Add_B_Zero:
	bge		$t3, $t2, end_Add_B_Zero
	nop
	add		$t3, $t3, 1
	sb		$t4, ($t1)
	add		$t1, $t1, 1
	b		Add_B_Zero
	nop
end_Add_B_Zero:
	nop

	sw		$t3, B_size

#############################################
##вывод числа B(возможно с нулями)
##	la		$a0, Enter
##	li		$v0, 4
##	syscall
##	la	$a0, B
##	li		$v0, 4
##	syscall
##тут херня полная(вроде теперь пашет)
#############################################
	
	la 		$t0, S
	lb		$t1, ($t0)
	la		$a0, A
	la		$a1, B
	beq		$t1, '+', MAKE_SUM
	beq		$t1, '-', MAKE_SUB
	beq		$t1, '*', MAKE_MULT

	nop

MAKE_SUM:
	jal		f_MAKE_SUM
	nop
	b		PRINT
	nop

MAKE_SUB:
	jal		f_MAKE_SUB
	nop
	b		PRINT
	nop

MAKE_MULT:
	jal		f_MAKE_MULT
	nop
	b		PRINT
	nop

################
###f_MAKE_SUM###
################

f_MAKE_SUM:
	sub		$sp, $sp, 32	#всякая фигня чтобы работала функция
	sw		$ra, 28($sp)
	sw		$ra, 24($sp)
	add		$fp, $fp, 32

	move	$t0, $a0		# число A
	move	$t1, $a1		# число B
	la		$t2, Temp		# для ответа 
	lw		$t3, A_size
	li		$t4, 0			#текущий размер массива
	li		$t5, 0			#переходящий десяток
	
BEGIN_SUM:
	bge		$t4, $t3, END_SUM
	nop
	lb		$t6, ($t0)		#циферка числа A
	nop
	sub		$t6, $t6, '0'	#делаем из символа циферку

	lb		$t7, ($t1)		#циферка числа B
	nop
	sub		$t7, $t7, '0'	#делаем циферку

	add		$t6, $t6, $t7	#сумма двух циферок
	add		$t6, $t6, $t5	#прибавляем остаток, если он есть

	bge		$t6, 10, MAKE_CARRY		#если вся сумма больше 10, надо сделать ее меньше 10, и записать в остаток десятки
	nop
	li		$t5, 0			#зануляем остаток, так как он либо ноль, либо в следующей функции он станет таким как надо, железно

	MAKE_CARRY:
		blt		$t6, 10, END_MAKE_CARRY
		nop
		sub		$t6, $t6, 10	#отнимаем 10
		add		$t5, $t5, 1		#и прибавляем единичку к переходящему остатку
		b		MAKE_CARRY
		nop

	END_MAKE_CARRY:
		nop	
		
	add		$t6, $t6, '0'
	sb		$t6, ($t2)
	add		$t2, $t2, 1
	add		$t0, $t0, 1
	add		$t1, $t1, 1
	add		$t4, $t4, 1
	
	b	BEGIN_SUM
	nop
END_SUM:
		nop
	
	add		$t5, $t5, '0'
	sb		$t5, ($t2)
	add		$t4, $t4, 1
	sw		$t4, Temp_size

	li		$v0, 0	
	lw		$ra, 28($sp)
	lw		$ra, 24($sp)
	add		$sp, $sp, 32
	jr		$ra
	nop

########################
###end of f_MAKE_MULT###
########################


################
###f_MAKE_SUB###
################

f_MAKE_SUB:
	sub		$sp, $sp, 32		#опять фигня чтобы работала функция
	sw		$ra, 28($sp)
	sw		$ra, 24($sp)
	add		$fp, $fp, 32

	move	$t0, $a0		#число A
	move	$t1, $a1		#число B

	la		$t2, Temp
	lw		$t3, A_size
	li		$t4, 0			#размер ответа
	li		$t5, 0			#переходящий остаток(десяток) или как там его

BEGIN_SUB:
	bge		$t4, $t3, END_SUB
	lb		$t6, ($t0)		#вычитатель
	nop
	lb		$t7, ($t1)		#вычитаемое
	nop
	sub		$t6, $t6, '0'
	sub		$t7, $t7, '0'	#сделали чиселки из символов

	add		$t5, $t5, $t6	#прибавили(ну а точнее отняли то скока у нас было в остатке позаимствованно)
	sub		$t5, $t5, $t7	#вычли вычитаемое

	blt		$t5, 0, MAKE_SUB_CARRY	#если вычли и у нас отрицательное
	nop

MAKE_ANS:					#если все хорошо с остатком, записываем в ответ
	add		$t5, $t5, '0'	#делаем символ
	sb		$t5, ($t2)
	li		$t5, 0			#равен единице, потому что ничего не осталось
	b		END_CARRY
	nop

MAKE_SUB_CARRY:					#если вычли и у нас отрицательное
	add		$t5, $t5, 10
	add		$t5, $t5, '0'
	sb		$t5, ($t2)
	li		$t5, -1			#на будущее, нам надо будет это отнять
	nop
END_CARRY:
	nop

	add		$t0, $t0, 1
	add		$t1, $t1, 1
	add		$t2, $t2, 1
	add		$t4, $t4, 1
	nop
	b		BEGIN_SUB
	nop	
	
END_SUB:
	nop

	sw		$t4, Temp_size
	li		$v0, 0
	lw		$ra, 28($sp)
	lw		$fp, 24($sp)
	add		$sp, $sp, 32
	jr 		$ra
	nop	

####################
###END_f_MAKE_SUB###
####################

#################
###f_MAKE_MULT###		#отвратительно тут все
#################

f_MAKE_MULT:
	sub		$sp, $sp, 32
	sw		$ra, 28($sp)
	sw		$fp, 24($sp)
	sw		$s0, 20($sp)
	add		$fp, $fp, 32
	
	move	$t0, A	
	move	$t1, B

	lw		$t2, A_size
	lw		$t3, B_size

	add		$t0, $t0, $t2
	sub		$t0, $t0, 1

DELETE_ZEROS_IN_A:
	lb		$t5, ($t0)
	bne		$t5, '0', END_DELETE_ZEROS_IN_A
	nop
	sub		$t0, $t0, 1
	sub		$t2, $t2, 1
	b		DELETE_ZEROS_IN_A
	nop
END_DELETE_ZEROS_IN_A:
	nop

	add		$t1, $t1, $t3
	sub		$t1, $t1, 1

DELETE_ZEROS_IN_B:
	lb		$t5, ($t1)
	bne		$t5, '0', END_DELETE_ZEROS_IN_B
	nop
	sub		$t1, $t1, 1
	sub		$t3, $t3, 1
	b		DELETE_ZEROS_IN_B
	nop
END_DELETE_ZEROS_IN_B:
	nop

	li		$t5, 0		#текущая позиция в A
	sw		$t5, Temp_size
	nop

MULT:		#цикл по числу A
	beq		$t5, $t2, END_MULT
	nop
	li		$t6, 0		#текущая позиция в B
	li		$t7, 0		#переходящий остаток
	li		$t4, 0		#чтобы выбрать максимальный размер ответа
	la		$s0, Temp	#указатель на начало ответа
	add		$s0, $s0, $t5	#извеменяем размер
	add		$t4, $t4, $t5	#первый символ куда записывать ответ(так как он i+j), будет просто номер текущей рассматриваемой цифры в A, а потом увеличиваться на единичку, когда цифра A будет умножаться на B

DO_MULT:	#цикл по числу B
	beq		$t6, $t3, END_DO_MULT
	nop
	lb		$t8, ($t0)
	nop
	sub		$t8, $t8, '0'
	
	lb		$t9, ($t1)
	nop
	sub		$t9, $t9, '0'

	mult	$t8, $t8, $t9
	add		$t8, $t8, $t7
	lb		$s1, ($s0)	#смотрим что там у нас в ответе лежит, ноль или какой-нить символ
	beq		$s1, 0, END_MAKE_NUMBER

	sub		$s1, $s1, '0'
END_MAKE_NUMBER:
	nop
	
	add		$t8, $t8, $s1	#теперь у нас в т8 хранится полный ответ того, что надо записать
	div		$t8, 10			#смотрим скока надо в переход, скока записать
	mfhi	$t8				#скока записать
	add		$t8, $t8, '0'
	sb		$t8, ($s0)		#записываем
	nop
	mflo	$t7				#переходящий остаток
	
	add		$t6, $t6, 1
	add		$t4, $t4, 1
	add		$s0, $s0, 1
	add		$t1, $t1, 1
	b		DO_MULT
	nop
END_DO_MULT:
	nop

##запишем если остался какой-то остаток после умножения

	sb		$s1, ($s0)
	beq		$s1, 0, END_MAKE_NUMBER_IN_MULT
	sub		$s1, $s1, '0'
END_MAKE_NUMBER_IN_MULT:
	add		$t7, $t7, $s1	#добавляем к переходящему остатку
	div		$t7, 10

	mfhi	$t7			#остаток от деления на 10
	add		$t7, '0'
	sb		$t7, ($t2)
	nop
	mflo	$t7

	beq		$t7, 0, END_MAKE_CARRY_IN_MULT
	add		$t2, $t2, 1
	add		$t7, '0'
	sb		$t7, ($t2)
	add		$t4, $t4, 1		#заодно и размер увеличим

END_MAKE_CARRY_IN_MULT:
	nop

	##тут можно было проверять, не увеличился ли размер ответа, но на последней итерации он итак будет самым большим

	add		$t0, $t0, 1
	add		$t2, $t2, 1
	b		MULT
	nop
END_MULT:
	nop	

	li		$v0, 0
	lw		$ra, 28($sp)
	lw		$fp, 24($sp)
	lw		$s0, 20($sp)
	add		$sp, $sp, 32
	jr 		$ra
	nop
#фак еа, все самое страшное позади!!!!!!!!!!!!!!!!

#####################
###END_f_MAKE_MULT###
#####################

	
###########
###PRINT###
##########
PRINT:
	la		$t0, Temp		#указатель на начало
	lw		$t1, Temp_size
	nop
	add		$t0, $t0, $t1	#указатель на конец
	sub		$t0, $t0, 1
	li		$t9, 0
DELETE_ZEROS:
	lb		$t2, ($t0)	
	nop
	bne		$t2, '0', END_DELETE_ZEROS
	sb		$t9, ($t0)
	sub		$t1, $t1, 1
	sub		$t0, $t0, 1
	b		DELETE_ZEROS
	nop
END_DELETE_ZEROS:
	nop

	sw		$t1, Temp_size
	nop
	
	lw		$t2, Temp_size
	la		$t0, Temp			#указатель на на начало($t0)
	la		$t1, Temp
	nop

	add		$t1, $t1, $t2		#указатель на конец($t1)
	sb		$zero, ($t1)
	sub		$t1, $t1, 1

REVERSE_ANS:
	bge		$t0, $t1, END_REVERSE_ANS
	nop
	lb		$t3, ($t0)
	lb		$t4, ($t1)
	nop
	sb		$t3, ($t1)
	sb		$t4, ($t0)
	nop
	add		$t0, $t0, 1
	sub		$t1, $t1, 1
	b		REVERSE_ANS
	nop
END_REVERSE_ANS:
	nop
	
	
	la		$a0, Temp
	li		$v0, 4
	syscall	

	li		$v0, 10
	syscall