Document 3

Let me add memory tables for every program comprehensively.
I'll provide a memory

table with addresses, opcodes, and data for every question that was missed earlier. I'll
go back and ensure memory tables are complete for all questions. Let’s begin:
1. Add Two 8-Bit Numbers
Program:
MVI A, 05H ; Load first number into accumulator

MVI B, 03H ; Load second number into register B
ADD B ; Add register B to accumulator
STA 3000H ; Store result at memory 3000H
HLT ; Halt
Memory Table:
Address Instruction Opcode Operand Description

2000H MVI A, 05H 3E 05 Load 05H into accumulator
2002H MVI B, 03H 06 03 Load 03H into register B
Add value in B to
2004H ADD B 80 -
accumulator
Store result at address
2005H STA 3000H 32 3000
3000H
2008H HLT 76 - Halt the program
Output:
Address Data Description

3000H 08H Sum (05H + 03H = 08H)
2. Subtract Two 8-Bit Numbers
Program:
MVI A, 09H ; Load first number into accumulator

MVI B, 04H ; Load second number into register B
SUB B ; Subtract register B from accumulator
STA 3001H ; Store result at memory 3001H
HLT ; Halt
Memory Table:

2000H MVI A, 09H 3E 09 Load 09H into accumulator
2002H MVI B, 04H 06 04 Load 04H into register B
Subtract B from
2004H SUB B 90 -
accumulator
Store result at address
2005H STA 3001H 32 3001
3001H
Output:

3001H 05H Difference (09H - 04H)
3. Find Sum of Series
Program:
LXI H, 4000H ; Load starting address of series

MVI C, 05H ; Load count of numbers in the series
MVI A, 00H ; Clear accumulator for sum
NEXT:
ADD M ; Add memory content to accumulator
INX H ; Increment address pointer
DCR C ; Decrement count
JNZ NEXT ; If count not zero, repeat
STA 3002H ; Store result at 3002H

HLT ; Halt
Memory Table:

Load base address
2000H LXI H, 4000H 21 4000
4000H
Load count of numbers
2003H MVI C, 05H 0E 05
(5)
Initialize accumulator to
2005H MVI A, 00H 3E 00
0
2007H ADD M 86 - Add memory content to A
Increment address
2008H INX H 23 -
pointer
2009H DCR C 0D - Decrement counter
200AH JNZ NEXT C2 2007 Repeat until counter is 0
200DH STA 3002H 32 3002 Store result in 3002H
Output:

Sum of the
3002H XXH
series
4. Count the Number of Even Numbers
Program:

MVI B, 00H ; Clear even number counter
NEXT:
MOV A, M ; Load memory content into A
ANI 01H ; Mask LSB to check even/odd
JNZ SKIP ; If odd, skip
INR B ; Increment even number counter
SKIP:
INX H ; Increment address pointer
JNZ NEXT ; Repeat until counter is 0
MOV A, B ; Move even count to accumulator

HLT ; Halt
Memory Table:

2000H LXI H, 4000H 21 4000 Load base address 4000H
2003H MVI C, 05H 0E 05 Load count of numbers (5)
2005H MVI B, 00H 06 00 Initialize even counter to 0
2007H MOV A, M 7E - Load memory content into A
Check LSB (even/odd
2008H ANI 01H E6 01
check)
200AH JNZ SKIP C2 200DH Skip if odd
200DH INR B 04 - Increment even counter
200EH INX H 23 - Increment memory pointer
200FH DCR C 0D - Decrement number counter
2010H JNZ NEXT C2 2007 Loop until count = 0
2013H MOV A, B 78 - Move even count to A
2014H STA 3003H 32 3003 Store result in memory
Input Data (Series):

4000H 01H First number
Second number
4001H 02H
(even)
4002H 03H Third number
4003H 04H Fourth number (even)
4004H 05H Fifth number
Output:

Count of even numbers (2,
3003H 02H
4)
5. Find the Sum of the Series of Only Even Numbers
Program:

MVI A, 00H ; Clear accumulator for the sum
NEXT:
MOV D, M ; Load memory content into D
ANI 01H ; Mask LSB to check even/odd
JNZ SKIP ; If odd, skip
ADD D ; Add even number to accumulator
SKIP:
INX H ; Increment memory address pointer
JNZ NEXT ; Repeat loop until counter is 0
STA 3004H ; Store the result at memory location 3004H

HLT ; Halt the program
Memory Table:

2000H LXI H, 4000H 21 4000 Load starting address of series
2003H MVI C, 05H 0E 05 Load count of numbers (5)
2005H MVI A, 00H 3E 00 Clear accumulator for the sum
Load current memory value into
2007H MOV D, M 56 -
D
2008H ANI 01H E6 01 Mask LSB to check even/odd
200AH JNZ SKIP C2 200EH Skip addition if odd
Add even number to
200DH ADD D 82 -
accumulator
Increment memory address
200EH INX H 23 -
pointer
200FH DCR C 0D - Decrement number counter
2010H JNZ NEXT C2 2007 Loop until counter is 0
2013H STA 3004H 32 3004 Store sum of even numbers
Input Data (Series):

Second number
4001H 02H
(even)
4003H 04H Fourth number (even)
Output:

Sum of even numbers (02H +
3004H 06H
04H)
6. Add Two 16-Bit Numbers
Program:
LXI H, 4000H ; Load first 16-bit number (at 4000H and 4001H)
LXI D, 4002H ; Load second 16-bit number (at 4002H and 4003H)
MOV A, M ; Load LSB of first number
ADD E ; Add LSB of second number
MOV L, A ; Store result in L register
INX H ; Point to MSB of first number
INX D ; Point to MSB of second number
MOV A, M ; Load MSB of first number
ADC D ; Add MSB of second number with carry
MOV H, A ; Store result in H register
SHLD 3005H ; Store 16-bit result at 3005H
HLT ; Halt
Memory Table:

2000H LXI H, 4000H 21 4000 Load first 16-bit number
2003H LXI D, 4002H 11 4002 Load second 16-bit number
2006H MOV A, M 7E - Load LSB of first number into A
2007H ADD E 83 - Add LSB of second number
2008H MOV L, A 6F - Store LSB result in L register
2009H INX H 23 - Increment H for MSB
200AH INX D 13 - Increment D for MSB
200BH MOV A, M 7E - Load MSB of first number into A
Add MSB of second number with
200CH ADC D 8A -
C
200DH MOV H, A 67 - Store MSB result in H register
200EH SHLD 3005H 22 3005 Store 16-bit result at 3005H
2011H HLT 76 - Halt
Input Data:

4000H 34H LSB of first number (1234H)
4001H 12H MSB of first number
LSB of second number
4002H 78H
(5678H)
4003H 56H MSB of second number
Output:

3005H ACH LSB of sum (1234H + 5678H = 68ACH)
3006H 68H MSB of sum
7. Multiply Two 8-Bit Numbers
Multiplication is performed via repeated addition since the 8085 has no direct
multiplication instruction.
Program:
MVI B, 05H ; Load multiplicand

MVI C, 03H ; Load multiplier
MVI A, 00H ; Clear accumulator for product
LOOP:
ADD B ; Add multiplicand to accumulator
DCR C ; Decrement multiplier
JNZ LOOP ; Repeat if multiplier > 0
HLT ; Halt
Memory Table:

2000H MVI B, 05H 06 05 Load multiplicand
2002H MVI C, 03H 0E 03 Load multiplier
2004H MVI A, 00H 3E 00 Initialize accumulator to 0
Add multiplicand to
2006H ADD B 80 -
accumulator
2007H DCR C 0D - Decrement multiplier
2008H JNZ LOOP C2 2006 Loop until multiplier = 0
200BH STA 3007H 32 3007 Store product
200EH HLT 76 - Halt
Output:

3007H 0FH Product (05H * 03H = 0FH)
8. Divide a 16-Bit Number by an 8-Bit Number
Division is implemented by repeated subtraction until the dividend becomes smaller than
the divisor.
Program:
LXI H, 4000H ; Load dividend (16-bit number at 4000H and 4001H)

MOV A, M ; Load LSB of dividend
INX H ; Increment to point to MSB
MOV B, M ; Load MSB of dividend into B
LXI D, 4002H ; Load divisor (8-bit number at 4002H)
MOV C, M ; Load divisor into C
MVI E, 00H ; Initialize remainder register
MVI D, 00H ; Initialize quotient register
DIVIDE:
SUB C ; Subtract divisor from dividend LSB
JC END ; If carry is set, stop subtraction
INR D ; Increment quotient
JMP DIVIDE ; Repeat subtraction
END:
MOV E, A ; Move the remainder into E
STA 3005H ; Store remainder at 3005H
MOV A, D ; Move quotient into A
STA 3006H ; Store quotient at 3006H
HLT ; Halt
Memory Table:

2000H LXI H, 4000H 21 4000 Load 16-bit dividend
2003H MOV A, M 7E - Load LSB of dividend
2004H INX H 23 - Increment pointer to MSB
2005H MOV B, M 46 - Load MSB of dividend into B
2006H LXI D, 4002H 11 4002 Load divisor (8-bit number)
2009H MOV C, M 4E - Load divisor into C
200AH MVI E, 00H 1E 00 Initialize remainder to 0
200CH MVI D, 00H 16 00 Initialize quotient to 0
Subtract divisor from
200EH SUB C 90 -
dividend
200FH JC END DA 2013 Stop subtraction if carry
2012H INR D 14 - Increment quotient
2013H JMP DIVIDE C3 200EH Repeat subtraction
2016H MOV E, A 5F - Store remainder in E
2017H STA 3005H 32 3005 Store remainder at 3005H
201AH MOV A, D 7A - Move quotient to A
201BH STA 3006H 32 3006 Store quotient at 3006H
201EH HLT 76 - Halt
Input Data:

4000H 30H LSB of dividend (1234H = 0x1234)
4001H 12H MSB of dividend
4002H 05H Divisor (8-bit number)
Output:

3005H 04H Remainder (1234H ÷ 05H = 91H R4)
3006H 91H Quotient
9. Find the Largest Number in a Given Set of Data
Program:
LXI H, 4000H ; Load starting address of data

MVI C, 05H ; Load count of numbers
MOV A, M ; Load the first number into A
INX H ; Point to the next memory location
LOOP:
MOV B, M ; Load the next number into B
CMP B ; Compare A with B
JC NEXT ; If A < B, skip
MOV A, B ; Update A to hold the larger number
NEXT:
INX H ; Increment memory pointer
DCR C ; Decrement counter
JNZ LOOP ; Repeat until count = 0
STA 3007H ; Store the largest number at 3007H

HLT ; Halt
Memory Table:

2000H LXI H, 4000H 21 4000 Load starting address of data
2003H MVI C, 05H 0E 05 Load count of numbers
2005H MOV A, M 7E - Load the first number
Point to next memory
2006H INX H 23 -
location
2007H MOV B, M 46 - Load the next number
2008H CMP B B8 - Compare A with B
2009H JC NEXT DA 200CH Skip if A < B
200CH MOV A, B 78 - Update A to larger number
200DH INX H 23 - Increment memory pointer
200EH DCR C 0D - Decrement counter
200FH JNZ LOOP C2 2007 Repeat until counter is zero
2012H STA 3007H 32 3007 Store the largest number
2015H HLT 76 - Halt
Input Data:

Second
4001H 20H
number
4003H 25H Fourth number
Output:

Largest number in
3007H 25H
series
10. Count the Number of 1s in a Given 8-bit Number
This program counts how many 1s are in the binary representation of an 8-bit number.
Program:
MVI C, 08H ; Load counter for 8 bits

MVI B, 00H ; Clear the result register (bit count)
LOOP:
MOV A, M ; Load the 8-bit number
RLC ; Rotate left through carry, shifting bits into carry
JZ NOCOUNT ; If carry is 0, skip increment
INR B ; Increment bit count if carry is set
NOCOUNT:
DCR C ; Decrement bit counter
JNZ LOOP ; Repeat for all bits
STA 3008H ; Store the result (number of 1s) at 3008H

HLT ; Halt
Memory Table:

2000H MVI C, 08H 0E 08 Load counter for 8 bits
2002H MVI B, 00H 06 00 Clear bit count
2004H MOV A, M 7E - Load the 8-bit number
2005H RLC 17 - Rotate left through carry
2006H JZ NOCOUNT F0 200EH Skip increment if carry is 0
2008H INR B 04 - Increment bit count
2009H NOCOUNT: DCR C 0D - Decrement counter
Repeat loop if counter is not
200AH JNZ LOOP C2 2004
zero
200DH STA 3008H 32 3008 Store bit count at 3008H
2010H HLT 76 - Halt
Input Data:

8-bit number (0011
4000H 37H
0111)
Output:

Number of 1s in the binary number (37H = 0011
3008H 04H
0111)
11. Swap Two 8-bit Numbers
This program swaps two 8-bit numbers stored in memory locations.
Program:
LXI H, 4000H ; Load address of first number

INX H ; Increment address to second number
MOV B, M ; Load second number into B
LXI H, 4000H ; Load address of first number again

MOV M, B ; Store second number at first number's address
INX H ; Increment address to second number
MOV M, A ; Store first number at second number's address
HLT ; Halt
Memory Table:
Addr Instructio Opc Opera

Description
ess n ode nd
2000 LXI H,
21 4000 Load address of first number
H 4000H
2003
MOV A, M 7E - Load first number into A
H
2004
INX H 23 - Increment address to second number
H
2005
MOV B, M 46 - Load second number into B
H
2006 LXI H,
21 4000 Load address of first number again
H 4000H
2009 Store second number at first number's
MOV M, B 56 -
H address
200A
INX H 23 - Increment address to second number
H
200B Store first number at second number's
MOV M, A 77 -
H address
200C
HLT 76 - Halt
H
Input Data:

Second
4001H 28H
number
Output:

4000H 28H First number after swap
Second number after
4001H 14H
swap
12. Convert Binary to BCD (Binary-Coded Decimal)
This program converts a binary number to its equivalent BCD representation.

Program:
LXI H, 4000H ; Load binary number address

MOV A, M ; Load binary number into A
MVI B, 00H ; Clear B register (for BCD result)
MVI C, 04H ; Initialize loop counter for 4 bits
LOOP:
RLC ; Rotate left through carry
DCR C ; Decrement loop counter
MOV D, A ; Copy to D for checking
ANI 0F0H ; Mask upper nibble
JZ SKIP ; Skip if lower nibble is 0
MOV B, D ; Move to B (BCD result)

SKIP:
JNZ LOOP ; Repeat for all 4 bits
STA 3009H ; Store BCD result at 3009H
HLT ; Halt
Memory Table:

Load binary number
2000H LXI H, 4000H 21 4000
address
2003H MOV A, M 7E - Load binary number into A
2004H MVI B, 00H 06 00 Clear B register
2006H MVI C, 04H 0E 04 Initialize counter for 4 bits
200AH MOV D, A 5E - Copy to D register
200BH ANI 0F0H E6 F0 Mask upper nibble
200DH JZ SKIP F0 200EH Skip if lower nibble is 0
200EH MOV B, D 46 - Move to B (BCD result)
200FH SKIP: JNZ LOOP C2 2008 Repeat for all bits
2012H STA 3009H 32 3009 Store BCD result
2015H HLT 76 - Halt
Input Data:

Binary number (1001
4000H 9AH
1010)
Output:

3009H 96H BCD equivalent (9AH → 96)
Here’s the continuation of the remaining solutions for the questions.
14. Multiply Two 8-bit Numbers
This program multiplies two 8-bit numbers and stores the result.
Program:
LXI H, 4000H ; Load address of the first number

INX H ; Move to second number address
MOV B, M ; Load the second number into B
MVI C, 00H ; Initialize result to 0 (low byte)
MVI D, 00H ; Initialize result to 0 (high byte)
LOOP:
MOV A, C ; Move low byte of result to A
ADD B ; Add second number to result
MOV C, A ; Store result in C register
MOV A, D ; Move high byte to A
ADC 00H ; Add carry to high byte of result
MOV D, A ; Store the new high byte
DCR B ; Decrement second number

JNZ LOOP ; Repeat until second number is 0
STA 300BH ; Store the result at 300BH
HLT ; Halt
Memory Table:

2000H LXI H, 4000H 21 4000 Load address of first number
2003H MOV A, M 7E - Load first number into A
Increment pointer to second
2004H INX H 23 -
number
2005H MOV B, M 46 - Load second number into B
2006H MVI C, 00H 06 00 Initialize result (low byte)
2008H MVI D, 00H 16 00 Initialize result (high byte)
200AH MOV A, C 7E - Move low byte of result to A
200BH ADD B 80 - Add second number to result
200CH MOV C, A 4F - Store result in C register
200DH MOV A, D 5E - Move high byte to A
200EH ADC 00H F4 00 Add carry to high byte of result
200FH MOV D, A 57 - Store new high byte in D
2010H DCR B 0C - Decrement second number
2011H JNZ LOOP C2 200AH Repeat until second number is 0
2014H STA 300BH 32 300B Store result at 300BH
2017H HLT 76 - Halt
Input Data:

4000H 06H First number (06)
Second number
4001H 04H
(04)
Output:

300BH 18H Result of multiplication (06 * 04) = 18 (in hex)
15. Find the Smallest Number in a Given Set of Data
This program finds the smallest number in a given list of numbers.
Program:

MOV A, M ; Load first number into A
INX H ; Increment to second number
LOOP:
JC NEXT ; If A < B, skip
MOV A, B ; If A >= B, move B to A (new smallest)
NEXT:
INX H ; Increment to next number
DCR C ; Decrement counter
JNZ LOOP ; Repeat until counter is zero
STA 3010H ; Store the smallest number at 3010H

HLT ; Halt
Memory Table:

2000H LXI H, 4000H 21 4000 Load address of first number
2003H MOV A, M 7E - Load first number into A
2004H INX H 23 - Increment to second number
2005H MOV B, M 46 - Load second number into B
2006H LOOP: CMP B B8 - Compare A with B
2007H JC NEXT DA 200EH Skip if A < B
200EH MOV A, B 78 - Move B to A (smallest number)
200FH INX H 23 - Increment to next number
2011H JNZ LOOP C2 2006 Repeat until counter is zero
Store smallest number at
2014H STA 3010H 32 3010
3010H
2017H HLT 76 - Halt
Input Data:

4000H 0AH First number (10 in decimal)
Second number (6 in
4001H 06H
decimal)
4002H 0EH Third number (14 in decimal)
4003H 02H Fourth number (2 in decimal)
Output:

Smallest number
3010H 02H
(02)
13. Convert BCD to Binary
This program converts a Binary-Coded Decimal (BCD) number to its binary equivalent.
Program:
LXI H, 4000H ; Load address of the BCD number

MOV A, M ; Load the BCD number into A
MVI B, 00H ; Initialize result register
MVI C, 08H ; Initialize bit counter for 8 bits
LOOP:
RLC ; Rotate left through carry
MOV B, A ; Move the result into B register
DCR C ; Decrement the counter
JNZ LOOP ; Repeat until counter is zero
STA 300AH ; Store the binary result at 300AH
HLT ; Halt
Memory Table:

Load address of BCD
2000H LXI H, 4000H 21 4000
number
2003H MOV A, M 7E - Load BCD number into A
2004H MVI B, 00H 06 00 Initialize result register
Initialize bit counter for 8
2006H MVI C, 08H 0E 08
bits
2009H MOV B, A 5E - Store result in B register
200AH DCR C 0D - Decrement loop counter
200BH JNZ LOOP C2 2008 Repeat until counter is zero
200EH STA 300AH 32 300A Store result at 300AH
2011H HLT 76 - Halt
Input Data:

4000H 96H BCD number (1001 0110)
Output:

Binary equivalent (1001
300AH 9EH
1110)
16. Reverse the Bits of a Given 8-bit Number
This program reverses the bits of a given 8-bit number.

Program:
LXI H, 4000H ; Load address of the 8-bit number

MOV A, M ; Load the number into A
MVI B, 00H ; Initialize result register
MVI C, 08H ; Initialize loop counter for 8 bits
LOOP:
RLC ; Rotate the bits of A left through carry
MOV B, A ; Move the result into B
JNZ LOOP ; Repeat until counter reaches zero
STA 3011H ; Store the reversed number at 3011H

HLT ; Halt
Memory Table:

2000H LXI H, 4000H 21 4000 Load address of the 8-bit number
2003H MOV A, M 7E - Load number from memory to A
2006H MVI C, 08H 0E 08 Initialize loop counter for 8 bits
2008H RLC 17 - Rotate the bits of A through carry
200AH DCR C 0D - Decrement counter
Repeat until all 8 bits are
200BH JNZ LOOP C2 2008
processed
200EH STA 3011H 32 3011 Store reversed bits at 3011H
2011H HLT 76 - Halt
Input Data:

Original 8-bit number (1001
4000H 9AH
1010)
Output:

Reversed 8-bit number (0101
3011H D5H
1101)
17. Compare Two Numbers
This program compares two numbers and sets a flag accordingly.
Program:

INX H ; Increment to second number

JC LESSTHAN ; If A < B, jump to LESSTHAN
JZ EQUAL ; If A == B, jump to EQUAL
JMP GREATER ; If A > B, jump to GREATER
LESSTHAN:
MVI C, 01H ; Set flag to indicate A is less than B
JMP DONE
EQUAL:
MVI C, 00H ; Set flag to indicate numbers are equal
JMP DONE
GREATER:
MVI C, 02H ; Set flag to indicate A is greater than B
DONE:
HLT ; Halt
Memory Table:
Addr Opc Opera

Instruction Description
ess ode nd
2000 Load address of first
LXI H, 4000H 21 4000
H number
2003
MOV A, M 7E - Load first number into A
H
2004 Increment to second
INX H 23 -
H number
2005 Load second number into
MOV B, M 46 -
H B
2006
CMP B B8 - Compare A with B
H
2007 Jump to LESSTHAN if A <
JC LESSTHAN DA 200EH
H B
200A
JZ EQUAL F0 200EH Jump to EQUAL if A == B
H
200C
JMP GREATER C3 2012H Jump to GREATER if A > B
H
200E LESSTHAN: MVI C,
0E 01 Set flag to 01 (A < B)
H 01H
2010
JMP DONE C3 2016H Jump to DONE
H
2012
EQUAL: MVI C, 00H 0E 00 Set flag to 00 (A == B)
H
2014
JMP DONE C3 2016H Jump to DONE
H
2016
GREATER: MVI C, 02H 0E 02 Set flag to 02 (A > B)
H
2018
DONE: HLT 76 - Halt
H
Input Data:

4000H 05H First number (5 in decimal)
Second number (8 in
4001H 08H
decimal)
Output:

3012H 01H Flag set to 01 (A < B)
Here’s the complete solution for 18. Decimal to Binary Conversion:
18. Decimal to Binary Conversion
This program converts a decimal number to its binary representation.
Program:
LXI H, 4000H ; Load address of the decimal number

MOV A, M ; Load the decimal number into A
MVI B, 00H ; Initialize binary result register
MVI C, 08H ; Initialize bit counter for 8 bits
LOOP:
RLC ; Rotate the bits of A left through carry
MOV B, A ; Move the result into B
JNZ LOOP ; Repeat until all 8 bits are processed
STA 3013H ; Store binary result at 3013H

HLT ; Halt the program
Memory Table:

Load address of decimal
2000H LXI H, 4000H 21 4000
number
2003H MOV A, M 7E - Load decimal number into A
2006H MVI C, 08H 0E 08 Initialize bit counter for 8 bits
Rotate the bits left through
2008H RLC 17 -
carry
200AH DCR C 0D - Decrement counter
200BH JNZ LOOP C2 2008 Repeat for all 8 bits processed
200EH STA 3013H 32 3013 Store binary result at 3013H
2011H HLT 76 - Halt
Input Data:

Decimal number (19 in
4000H 13H
decimal)
Output:

3013H 00010011B Binary equivalent of 19 in binary

Document 3

Uploaded by

Copyright:

Available Formats

Document 3

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Document 3

Uploaded by

Copyright:

Available Formats

Let me add memory tables for every program comprehensively.

I'll provide a memory

1. Add Two 8-Bit Numbers

MVI A, 05H ; Load first number into accumulator

Address Instruction Opcode Operand Description

Address Data Description

MVI A, 09H ; Load first number into accumulator

Address Instruction Opcode Operand Description

Address Data Description

3. Find Sum of Series

LXI H, 4000H ; Load starting address of series

STA 3002H ; Store result at 3002H

Address Instruction Opcode Operand Description

Address Data Description

LXI H, 4000H ; Load starting address of series

MOV A, B ; Move even count to accumulator

Address Instruction Opcode Operand Description

Input Data (Series):

Address Data Description

Address Data Description

5. Find the Sum of the Series of Only Even Numbers

LXI H, 4000H ; Load starting address of series

STA 3004H ; Store the result at memory location 3004H

Address Instruction Opcode Operand Description

Input Data (Series):

Address Data Description

Address Data Description

6. Add Two 16-Bit Numbers

Address Instruction Opcode Operand Description

Address Data Description

Address Data Description

7. Multiply Two 8-Bit Numbers

MVI B, 05H ; Load multiplicand

Address Instruction Opcode Operand Description

Address Data Description

8. Divide a 16-Bit Number by an 8-Bit Number

LXI H, 4000H ; Load dividend (16-bit number at 4000H and 4001H)

Address Instruction Opcode Operand Description

Address Data Description

Address Data Description

9. Find the Largest Number in a Given Set of Data

LXI H, 4000H ; Load starting address of data

STA 3007H ; Store the largest number at 3007H

Address Instruction Opcode Operand Description

Address Data Description

Address Data Description

MVI C, 08H ; Load counter for 8 bits

STA 3008H ; Store the result (number of 1s) at 3008H

Address Instruction Opcode Operand Description

Address Data Description

Address Data Description

11. Swap Two 8-bit Numbers

This program swaps two 8-bit numbers stored in memory locations.

LXI H, 4000H ; Load address of first number

LXI H, 4000H ; Load address of first number again

Addr Instructio Opc Opera

Address Data Description

Address Data Description

12. Convert Binary to BCD (Binary-Coded Decimal)

This program converts a binary number to its equivalent BCD representation.