Skip to main content

Program 3: Find the Maximum of Two Numbers

 **Program 3: Find the Maximum of Two Numbers**


```assembly

.model small

.stack 100h


.data

    num1 dw 5

    num2 dw 7

    result dw ?


.code

    main proc

        mov ax, num1        ; Load first number into AX

        cmp ax, num2        ; Compare with second number

        jge greater         ; Jump to greater if AX >= num2

        

        mov ax, num2        ; Load second number into AX

        jmp end_prog

        

    greater:

        mov ax, num1


    end_prog:

        mov result, ax      ; Store result in 'result'

        

        mov ah, 4Ch         ; Exit program

        int 21h

    main endp

end main

```


Explanation:

1. `.model small` and `.stack 100h`: Memory model and stack size definitions.

2. `.data` section: Declares the data segment.

   - `num1 dw 5`: Defines a word-sized variable named "num1" with value 5.

   - `num2 dw 7`: Defines a word-sized variable named "num2" with value 7.

   - `result dw ?`: Defines a word-sized uninitialized variable named "result".

3. `.code` section: Contains the main code.

   - `mov ax, num1`: Move the value of "num1" into the AX register.

   - `cmp ax, num2`: Compare the value in AX with the value in "num2".

   - `jge greater`: Jump to the "greater" label if AX is greater than or equal to "num2".

   - `mov ax, num2`: Move the value of "num2" into AX (if AX is not greater).

   - `jmp end_prog`: Unconditional jump to the "end_prog" label.

   - `greater:`: Label for the case when the first number is greater.

   - `mov ax, num1`: Move the value of "num1" into AX.

   - `end_prog:`: Label for the end of the program.

   - `mov result, ax`: Store the result in the "result" variable.

   - `mov ah, 4Ch`: Set the exit code for DOS.

   - `int 21h`: Call DOS interrupt to exit the program.


Comments

Popular posts from this blog

12. Write a program to convert NFA to DFA.

Converting a Non-Deterministic Finite Automaton (NFA) to a Deterministic Finite Automaton (DFA) involves creating a new DFA where each state corresponds to a set of NFA states reachable under certain conditions. Below is a simple Python program to perform this conversion. I'll explain each line of code: ```python from collections import defaultdict def epsilon_closure(states, transitions, epsilon):     closure = set(states)     stack = list(states)          while stack:         state = stack.pop()         for next_state in transitions[state].get(epsilon, []):             if next_state not in closure:                 closure.add(next_state)                 stack.append(next_state)          return closure def nfa_to_dfa(nfa_states, nfa_transitions, alphabet, start_state, n...