Given a $4-$digits hexadecimal number n as user input, write an assembly language program to display $$T$$ if the first $2-$digits group or the second $2-$digits group number is $25510$ or if their sum is $25510.$ Otherwise, the program should display the biggest $2-$digits number out of the two numbers in decimal. n $($user input$)$ will be exactly a four$-$digits hexadecimal number, not more and not fewer. Here are the examples: $1.$ Take the input n $($user input$)$ as FF$0116,$ your program will first convert FF$16$ to decimal equivalent $25510$ and convert $0116$ to decimal equivalent $110,$ after that your program should output $$T$$ since one of the numbers is $25510.2.$ If n $($user input$)$ is $46$B$916,$ your program will first convert $4616$ to decimal equivalent $7010$ and convert B$916$ to decimal equivalent $18510,$ and then your program should output $$T$$ since the sum of both is a $25510.3.$ If n $($user input$)$ is $123416,$ your program will first convert $1216$ to decimal equivalent $1810$ and convert $3416$ to decimal equivalent $5210,$ and then your program should output $52$ since both numbers are not $25510,$ the sum of both is not $25510,$ and the biggest number of the two numbers is $52.4.$ If n $($user input$)$ is A$59$C$16,$ your program will first convert A$516$ to decimal equivalent $16510$ and convert $9$C$16$ to decimal equivalent $15610,$ and then your program should output $165$ since both numbers are not $25510,$ the sum of both is not $25510,$ and the biggest number of the two numbers is $165.$ You need to take the input characters using INP in Assembler, convert the input characters into hexadecimal numbers, check the numbers and their sum, have a loop to output the number. You should not hardcode the input$/$output numbers and should not use the direct formula to get the result. For example, a code such as this: if $($n$==0005)$ then printf$(5)$; is not allowed. Submit an assembly program to solve the given problem. To get started, you need to download and run the assembler simulator $($Assembler$.$jar$)$ from Canvas. The instructions to download, run the simulator then compile and run the code are specified in the $$Helpful Resource$$ section below. Your program should be stored in a plain text file and able to be executed on the simulator. Grading criteria for the Assembly Program $($Worth $80\%$ of the project$)$ Critical Elements Percentage Distribution Well Commented Code $20\%$Variable initialization $20\%$Get input N from user $20\%$Converting N to two numbers $20\%$Correctness of output in showing the biggest number or $$T$20\%$Total $100\%.$ Again, in the project you must use loop functionality to achieve the output. Pre$-$defined values or answers in the code are NOT accepted. There are three groups of instructions in this assembler:

$$ Memory Reference Instructions

$$ Non memory Reference Instructions

$$ Pseudo Instructions $($i$.$e$.,$ Assembler directive instructions$)$

Memory Reference Instructions $($MRI$)$

Direct Addressing: opcode operand e$.$g$.,$ ADD num

Memory word at location 'num' is added to accumulator AC$.$ i$.$e$.,$ AC

$=$ AC $+$ M$[$num$]$;

Here, effective address of the operand is 'num'

Indirect Addressing: opcode operand I e$.$g$.,$ ADD num I

Memory word of memory word at location 'num' is added to AC$.$ i$.$e$.,$

AC $=$ AC $+[$M$[$num$]]$

Here, effective address of the operand is M$[$num$].$

MRI Instructions: $($In the following, $$addr$$ denotes effective address.$)$

AND xxx AND xxx I

Logical AND of effective memory word to AC i$.$e$.,$

AC $=$ AC and M$[$addr$]$;

ADD xxx ADD xxx I

Add effective memory word to AC$.$

i$.$e$.,$ AC $=$ AC $+$ M$[$addr$]$;

LDA xxx LDA xxx I

Load effective memory word to AC$.$

i$.$e$.,$ AC $=$ M$[$addr$]$;

STA xxx STA xxx I

Store content of AC to effective memory word. i$.$e$.,$

M$[$addr$]=$ AC;

BUN xxx BUN xxx I

Branch, unconditionally, to effective address. i$.$e$.,$

PC $=$ addr;

BSA xxx BSA xxx I

Address of next instruction $($i$.$e$.,$ PC$)$ is stored in effective memory word. Then, execute

the instruction following the effective address.

i$.$e$.,$ M$[$addr$]=$ PC; PC $=$ addr $+1$;

Note: BSA is useful to save the return address and to branch to a procedure.

ISZ xxx ISZ xxx I

Increment memory word. If incremented value is $0,$ increment PC $($i$.$e$.,$ skip next instruction$).$

i$.$e$.,$ M$[$addr$]=$ M$[$addr$]+1$; if $($M$[$addr$]==0)$ PC $=$ PC $+1$;

Note: ISZ is used to count iterative loops.

Non$-$Memory Reference Instructions

These instructions do not have the operand part or the addressing mode.

CLA Clear AC

CLE Clear E$,$ the extended bit of AC

CMA Complement AC

CME Complement E

CIR Circular shift to the Right on AC and E

CIL Circular shift to the Left on AC and E

INC Increment AC

SPA Skip next instruction, if AC is Positive, i$.$e$.,$ if $($AC$(15)=0)$ PC $=$ PC $+1$;

SNA Skip next instruction, if AC is Negative, i$.$e$.,$ if $($AC$(15)=1)$ PC $=$ PC $+1$;

SZA Skip next instruction, if AC is Zero, i$.$e$.,$ if $($AC $==0)$ PC $=$ PC $+1$;

$($Note: SPA, SNA, and SZA are used in conditional branching.$)$