Skip to main content

Program 6: Finding Prime Numbers in a Range

 **Program 6: Finding Prime Numbers in a Range**


```assembly

.model small

.stack 100h


.data

    start dw 1

    end dw 20


.code

    main proc

        mov ax, start           ; Load 'start' into AX

        

    find_primes:

        inc ax                  ; Move to the next number

        cmp ax, end             ; Compare with 'end'

        jg end_prog             ; Jump to end if AX > 'end'

        

        mov cx, ax              ; Copy AX to CX

        mov bx, 2               ; Divisor

        

    check_prime:

        xor dx, dx              ; Clear DX for division

        div bx                  ; Divide CX by BX

        cmp dx, 0               ; Check remainder

        je not_prime            ; If remainder = 0, not prime

        inc bx                  ; Move to next divisor

        cmp bx, cx              ; Compare divisor with CX

        jg prime                ; If divisor > CX, number is prime

        jmp check_prime         ; Otherwise, continue loop

        

    not_prime:

        jmp find_primes         ; Check next number

        

    prime:

        ; Print prime number in AX

        mov ah, 02h             ; DOS function to print character

        add al, 30h             ; Convert number to ASCII

        mov dl, al              ; Load ASCII character

        int 21h                 ; Print character

        

        jmp find_primes         ; Check next number

        

    end_prog:

        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.

   - `start dw 1`: Defines a word-sized variable named "start" with value 1.

   - `end dw 20`: Defines a word-sized variable named "end" with value 20.

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

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

   - `find_primes:`: Label for the loop.

   - `inc ax`: Increment AX to the next number.

   - `cmp ax, end`: Compare AX with "end".

   - `jg end_prog`: Jump to the end if AX > "end".

   - `mov cx, ax`: Copy AX to CX (number to be checked for prime).

   - `mov bx, 2`: Initialize the divisor to 2.

   - `check_prime:`: Label for the divisor checking loop.

   - `xor dx, dx`: Clear DX for division.

   - `div bx`: Divide CX by BX (quotient in AX, remainder in DX).

   - `cmp dx, 0`: Check if remainder is 0.

   - `je not_prime`: Jump to "not_prime" if remainder is 0 (not prime).

   - `inc bx`: Move to the next divisor.

   - `cmp bx, cx`: Compare divisor with CX.

   - `jg prime`: If divisor > CX, the number is prime.

   - `jmp check_prime`: Otherwise, continue the divisor loop.

   - `not_prime:`: Label for when the number is not prime.

   - `jmp find_primes`: Check the next number.

   - `prime:`: Label for when the number is prime.

   - `mov ah, 02h`: DOS function to print character.

   - `add al, 30h`: Convert the number to ASCII.

   - `mov dl, al`: Load the ASCII character to print.

   - `int 21h`: Print the character.

   - `jmp find_primes`: Check the next number.

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

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

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

Comments

Post a Comment

Popular posts from this blog

ktu 2019 Cse Complier programing Lab Syllabus

 1Design and implement a lexical analyzer using C language to recognize all valid tokens  in the input program. The lexical analyzer should ignore redundant spaces, tabs and  newlines. It should also ignore comments. 2. Implement a Lexical Analyzer for a given program using Lex Tool. 3. Write a lex program to display the number of lines, words and characters in an input text. 4. Write a LEX Program to convert the substring abc to ABC from the given input string. 5. Write a lex program to find out the total number of vowels and consonants from the given  input string. 6. Generate a YACC specification to recognize a valid arithmetic expression that uses  operators +, – , *,/ and parenthesis. 7. Generate a YACC specification to recognize a valid identifier which starts with a letter  followed by any number of letters or digits.   8. Implementation of Calculator using LEX and YACC  9. Convert the BNF rules into YACC form and write code to generat...
Post a Comment
Read more

11. Write a program to convert NFA with ε transition to NFA without ε transition

  Converting an NFA with ε transitions to an NFA without ε transitions involves removing ε transitions and appropriately updating the transitions in the resulting NFA. Below is an example program in Python that performs this conversion. I'll explain each line of the code: ```python class NFA:     def __init__(self, states, alphabet, transitions, start_state, accept_states):         self.states = states         self.alphabet = alphabet         self.transitions = transitions         self.start_state = start_state         self.accept_states = accept_states def epsilon_closure(states, transitions):     epsilon_states = set(states)     stack = list(states)          while stack:   ...
Post a Comment
Read more