Computer Architecture -EC502- Module2 ( MAKAUT-Syllabus)


 Today, our communication elements are -Multiplication and division, Arithmetic Logic Unit (ALU) Design, Floating Point Arithmetic, IEEE 754 Floating Point Format, Instructional sequence, Interpretation, Hardwide Control - Design Methods, CPU control unit - Design Methods, Microprogrammed The Control - Basic Concepts, Minimizing Microinstruction Size, Multiplier control unit, Microprogrammed Computer - CPU Control Unit.

 Multiplication and division: -

Guna and Division Computer architecture has basic arithmetic operations. In addition, and unlike subtraction, these features require more complex hardware, as they include additions, subtractions, and transmission of repetition.

Multiplication

Binary multiplication is similar to decimal multiplication, but simply because each number is 0 or 1. The process includes:

  • To check the multiplier bit.
  • If Bit 1 is 1, add the multiplier (switch then) to the partial product.
  • If the bit is 0, no extra is required.
  • Continue to change and add to all multiplier bits that are treated.

There are two main methods:

  • Shift-Edd-algorithm
  • The algorithm of the stand (used for signed numbers, reduces the number of additions.

Division

The binary division meets the long division in the decimal. Stages include:

  • Compare the parts with dividends (or partial balance).
  • If the dividing line is small, set a quotient piece from 1 to 1.
  • If the church community is large, you can bring the next bit down and set the part to 0.
  • Repeat all bits until treated.

Common methods:

  • Restoration division
  • Fruitless division
  • SRT divisional algorithm (used in modern speed processors).

CPU, digital signal processing, and scientific calculation require skilled multiplication and division for arithmetic devices. Hardware adaptation that parallel multiplies and shares circuits to a large extent improves.


Arithmetic Arga-Unit (ALU) Design: -

The arithmetic logic unit (ALU) is a main component of the central processing unit (CPU). It is responsible for performing all arithmetic and logical operations required by computer programs. Since most computer instructions involve data manipulation, the ALU system plays a crucial role in performance.

Functions of ALU

  • Arithmetic operations – addition to binary numbers, subtraction, multiplication, and division.
  • Logical operations – and, or, xor, not, and comparison (more, equal, low).
  • Shift operation – Rotate operation for left shift, right shift, and bit manipulation.
  • Status reporting-alu indicates the condition code or flag as carrying, zero, characters, and overflows, which are used to determine in programs.

Alu design


Alu is usually designed using a combination logic circuit. Its main components include:

  • Jonator-Ghatia device: Using full address stocks, binary joints, and subtractions. The subtraction is done by connecting both numbers of the complement.
  • Logic Circuit: Bitwise operations such as and, or, xor, and basic gates are not used.
  • CHANGES: Handles the shift and rotates the instructions, often applied with multiplexers.
  • Control lines: Determine which operation the ALU performs. A control unit sends the operating code (OPCODE) that selects the function.

A multiplex is often used to choose arithmetic, logic, or shift output, which gives the end result.


Flags and Status Register

Alu not only sends the result but also updates the flag:

  • Zero flag (z) – when the set result = 0
  • Carrie Flag (C) – see if there is a carrying or loan
  • Character flag(s) – indicates positive or negative results
  • Overflow flag (o) – detects arithmetic overflow

conclusion

ALU is the "calculation brain" of a CPU. The efficiency directly affects the treatment speed of the system. Modern processors use parallel ALUs or pipelines to improve performance and support advanced instructions and quick execution.




Floating Point Arithmetic: -

Floating-point Arithmetic is used to represent and treat very large or very small real numbers in a computer system. Unlike integer arithmetic, which belongs to the whole numbers, floating-point arithmetic gives a way to estimate the actual figures in a format that balances restriction and accuracy.

Temporary point representation

A floating-point number is usually represented in the form:  (1)× × 2E

Where:

  • s = sign bit (0 for positive, 1 for negative)
  • M = mantissa or significand (represents precision)
  • E = exponent (represents range)

This representation is standardised by the IEEE 754 format, which is most often used in modern processors.
  • Easy cleansing (32-bit): 1 bit characters, 8 bits exponent, 23 bits mantissa
  • Double prosecution (64-bit): 1 bit sign, 11 bits exponent, 52 bits mantissa
Exponential is stored using a bias (e.g., 127 for easy accuracy) to ensure that both positive and negative ambitions can be represented.

Floating Point Operations

Floating-point Arithmetic includes addition, subtraction, multiplication, and division. Unlike integers, these operations are more complicated due to normalisation, adjustment, and rounding.

Addition and subtraction

  • Adjust the exponent by transferring the small number of mantissa.
  • Add or pull on mantis.
  • Common result to maintain the correct format.

Multiplication

  • Add an exponent (after adjustment to prejudice).
  • Multiply mantissas.
  • Normalise the result.

Division

  • Reduce the exponent.
  • Divide mantis.
  • Normalise the result.

Special Values

The IEEE 754 standard also defines special cases:
  • Zero (all exponent and mantissa bits zero)
  • Infinity (exponent all 1s, mantissa all 0s)
  • Nan (no number) for undefined results, such as 0/0.

Round -Colon and Precision

Floating points have limited precision due to a fixed mantissa size. Rounding methods that round to the nearest or truncate are used, leading to rounding errors.

conclusion

Floating-point Arithmetic is important for scientific data processing, engineering simulation, graphics, and machine learning. However, less accurately than the exact actual arithmetic, it provides a practical balance between limit, accuracy, and calculation efficiency. Modern CPUs include liquid punctuation (FPUs) dedicated to handling these features effectively.



IEEE 754 Floating Point Format: -

The IEEE 754 is the most commonly used method to represent and perform arithmetic on actual numbers in standard digital computers. This defines how floating-point numbers are stored, ensuring stability in hardware and software systems.

General representation

A floating-point number is represented:   (1× (1.M×(EBias)

Where:

s (Sign bit) – 0 for positive, 1 for negative

M (Mantissa/Significand) – Represents precision

E (Exponent) – Determines range, stored in biased form

Bias – A constant added to the actual exponent to allow both positive and negative exponents.

IEEE 754 Single Precision (32-bit)

  • 1 bit – Sign
  • 8 bits – Exponent (Bias = 127)
  • 23 bits – Mantissa

Example:   
Number = (-1)^0 × (1.101) × 2^(10000001 - 127)

This format provides approximately 7 decimal digits of precision and a range of about 103810^{-38} to 103810^{38}.

IEEE 754 Double Precision (64-bit)

  • 1 bit – Sign
  • 11 bits – Exponent (Bias = 1023)
  • 52 bits – Mantissa

This format provides approximately 15–16 decimal digits of precision and a range of about 1030810^{-308} to 1030810^{308}.

Special representation

  • Zero: All Among and Mantissa Bits = 0
  • Infinity: increase = all 1, mantissa = 0
  • Naan (not a number): incompatibility = all 1s, mantissa ≠ 0

conclusion

IEEE 754 Floating Point format balances accuracy and limits, enabling accurate representation of real-world values. Simple precision is common in graphics and built-in systems, while double precision is widely used in scientific and engineering applications.



Control Design: -

In computer architecture, the control design refers to the process of designing the control unit, which leads the flow of data and coordinates operations within the processor. The control unit produces control signals that manage the activities of the aluminium, memory, registers, and input/output equipment. Without a well-structured control design, the CPU cannot perform instructions effectively.

Types of control units:

Hard control Unit

  • Gates use a fixed logical cycle designed with flip-flops, decoders, and other hardware.
  • Control signs are generated directly by the combinational logic.
  • Benefits: It is very fast, easy, and suitable for RISC-based processors.
  • Disadvantages: Periodically, hardware must be detected to change the instructional set.

Microprogrammed Control Unit

  • Uses a control memory where microprinting is stored.
  • Each instruction is broken into small stages (micro-operations).
  • A micro-installation is achieved from the control memory to generate control signals.
  • Advantages: Easy to change or expand the flexible instruction set.
  • Disadvantages: Slow compared to strict control.

Control design phase

  • Instructions decoding – The opcode part of the instruction is decoded to determine the required operation.
  • Creating control signals – Based on the instructions, the control unit sends a signal to the ALU, registers, and memory.
  • Sequence – ensures that instructions are performed in the correct order, often using a program counter.
  • Synchronisation – uses clock pulses to sync actions between different devices.

Examples of control signals

  • Memory Reed/Right – Checking data flow between memory and CPU.
  • Register transfer – takes data between the registers.
  • Select the ALU operation – choose an arithmetic or logical operation.
  • Branch control – hands to jump and conditioned branches.

Comparison

Feature

Hardwired Control

Microprogrammed Control

Speed

Faster

Slower

Flexibility

Low

High

Complexity

High for large ISAs

Easier to manage

Example Use

RISC processors

CISC processors


conclusion

Control design is important for the coordination of CPU operations. While the hardware control provides speed, the microprogram control provides flexibility. Modern processors often use a hybrid approach, combining the benefits of both to balance performance and adaptability.



Instructional sequence: -

Instructional sequencing is an important aspect of computer architecture that determines the order instructions are brought to a program, decoded, and executed. Since a computer program is a sequence of instructions stored in memory, the processor must bring them in the correct order to ensure the logical execution of the functions.

Basic Concept:

The program counter (PC) instructions play a central role in sequencing. It detects the next instruction to be performed. After including an instruction, the PC is usually expanded to indicate the next instruction in the memory.

Specific sequence:

  • Get instructions from the memory of the address stored in PC.
  • PC increases to indicate the next instruction.
  • Appreciation instructions.
  • Perform the instructions using control signals.

Instruction type for sequencing

1. Sequential design

  • The instruction is performed in a memory order.
  • The PC expands with a certain value (usually instructional size).
  • Example: Execution of instructions in loop or correct line code.

2. In branches

A new address in the PC changes the normal sequential current when loading.

Type:
  • Unprequined branch - always jumps into a new place.
  • Conditional branch - depends on the flag of the situation (zero, carry, overflow).
Examples: In IF-Else or Goto statements in programming.

3. Sabarutin calls and comes back

  • The module is used for programming.
  • The next instruction will be detected on the stack before giving the branch to Sabarutin.
  • Upon return, the stored address is restored to the PC.

4. Comes in the middle

  • External or internal phenomena that temporarily prevent normal execution.
  • The PC stores the current instructional address and checks the control service routine.

Factors Affecting Instruction Sequencing

  • Design of pipelines - many instructions overlap during the execution, and require the right sequencing to avoid hazards.
  • Instructions - Some instructions depend on the result of the previous one.
  • Control threats - are caused by partition in branches and should be solved using techniques such as branch preaching.


conclusion

Instruction sequencing ensures the correct flow of control in a program. While the sequential design is simple, modern CPUs should handle branches, subroutines, and interrupts effectively. Advanced processor instructions use pipeline, branch prediction, and design outside order to adapt the sequence and improve performance.



Interpretation: -

Interpretation is a method of performing a program where the instructions are translated and run directly by an interpreter program, rather than being converted to machine code. Unlike the collection, where the entire program is translated into the machine language before execution, translates interpretation translation occurs in detail after line or statement after statement.

Working of an Interpreter:

  • Read: Release an instruction from the interpreter source code.
  • Analysis: It passes and examines the instructions for purity.
  • Perform: It immediately performs this machine-level operation.
  • Repeat: The process continues until the process is over.
This approach slows the interpretation compared to the collection, but provides benefits in flexibility and troubleshooting.

Characteristics of Interpretation:

  • No separate drivable file is generated; The interpreter runs the code directly.
  • As long as the interpreter is available on the system, the independent platform is independent.
  • Error handling is easy, as errors are reported immediately after the problematic line.
  • The interpreter must be present every time to run the program.

Examples of language

  • Python
  • Java Script
  • MATLAB
  • Ruby
Some languages (eg Java) use a combination of interpretation and compilation (through bite code and a virtual machine).

Advantage

  • Simple program tests and troubleshooting.
  • Stage freedom with interpreters.
  • No compilation steps are required since the rapid development cycle.

Disadvantages

  • Slower execution speed compared to compiled programs.
  • Requires more memory since source code and interpreter must both be present.
  • Not ideal for performance-critical applications.

conclusion

The interpretation provides a flexible and user-friendly execution model, especially useful for scripting, fast prototyping, and teaching. While compiled programs provide speed, the languages interpreted easily in portability and troubleshooting. Modern systems often use a hybrid model-first compilation in middle code, and interpret or only interpret regularly to balance defense and flexibility.


Hardwide Control - Design Methods: -


In computer architecture, the control unit is responsible for generating indications that correct the flow and execution of instructions. An important design approach for control units is the hardware control method. Unlike Microprogrammed control, which stores micro-installation in control memory, Hardwired Control uses a combination logic circuit to generate direct control signals.

Hardwired Control Unit

  • Instructions decoder - decoder instructions.
  • Time and sequencing ensure the correct order of logic sub-operations.
  • Control signal generator-logical gates, decoders, and flip-flops are used to create specific control signals.
  • Output control lines - alu, memory, register, and send signals to the I/O device.
The design depends on the fixed argument, which makes it sharp but less flexible.

Design methods for hard control

1. State diagram law

  • The control unit is designed as a final state machine (FSM).
  • Each condition direction matches a step in the execution (retrieval, decoder, perform).
  • Infections between states are controlled by clock signs and control conditions.
  • Hardware logic is used using flip flops and gates to represent conditional infections.
Benefits: Simple and effective for a small instruction set.
Disadvantages: provides complications for large CPUs.

2. Sequential circuit method

  • Control arguments are used as a sequential circuit.
  • Tenters or sequence registers are used to keep track of micro-operations.
  • Decoders and combination logic currently produce control signs based on the current sequence phase.
Benefits: It's easy to use with counters.
Disadvantages: Limited flexibility, not suitable for complex issues.

3. One-driven coding method

  • Each state of the control unit is represented to be a unique flip-flop "1".
  • Only a flip-flop is active at a time (so "A-heat").
  • Control signs are obtained directly from active flip-flops.
Benefits: Easy decoding, quick execution.
Damage: Several hardware flip-flops are required.

4. PLA (programmable logic array) method

  • The control unit is used using a PLA, which is a programmable logic device.
  • Map directly to check the output through the entrance position (Opcodes, Flags) programmable connections.
  • Fixed port provides higher flexibility than logic.
Benefits: It is easier to change compared to pure hardwinging.
Disadvantages: slightly slower than hardwing at the port level.


Advantages of Hardwired Control

  • High speed (no microinning).
  • Effective for a small instruction kit with a small instruction kit.

Disadvantages of Hardwired Control

  • The instruction set is difficult to change or expand.
  • Complex cabling for CISC architecture.
  • Troubleshooting is more difficult than microprogrammed control.

conclusion

Hardwired control design methods are sharp and effective, but business flexibility for performance. They are best suited for a simple processor or RISC design where speed is more important than expansion. Modern processors can add stringness control for simple instructions and microprogram controllers for complex instructions, creating a hybrid control approach.

CPU control unit - Design Methods: -

The control unit (CU) is an important part of the CPU that is responsible for the operating direction of the processor. It generates time and control signals to coordinate the movement of data between the CPU, memory, and input/output units. In essence, CU acts as "the brain inside the CPU's brain, and ensures that the instructions are performed in the correct sequence.

There are two primary ways to design the CPU control unit: Hardwired control and microprogrammed control.


1. Hardwide Control Design

In strict control, fixed logical circuits are used to generate control signals. The Opcode instructions is fed into a decoder, which activates specific control paths. Sequence is managed by counters, flip-flops, and logical gates.

Advantage:
  • Very quickly (no microinning).
  • Suitable for a small set of instructions with a small set.
Loss:
  • It's hard to change.
  • Complicated for a CISC processor with a large instruction set.

Example Design Method:

  • State machine method - Each condition corresponds to an execution phase (pickup, decoder, performed).
  • A hot coding method-every condition is represented by a flip-flop that is active.

2. Microprogrammed Control Design

In Microprogrammed control, control indications occur when using a control memory (cm) that stores microinity. Each instruction is broken into a sequence of micro-operations, and they are performed under the control of micro-operations obtained from the control memory.

Advantage:
  • It is easy to change or expand.
  • Suitable for a CISC processor with a complex instruction kit.
Loss:
  • Slowly compared to hardweed control.
  • Micro program storage requires extra memory.
Example Design Method:
  • Horizontal micro-logging - specifies direct control signals; it Quickly, but uses extensive control words.
  • Vertical micro -logramming - coded signal; The memory reduces the size, but requires further decoding.

Comparison of Design Methods

Feature

Hardwired Control

Microprogrammed Control

Speed

Faster

Slower

Flexibility

Low

High

Complex Instructions

Difficult

Easy

Use Case

RISC CPUs

CISC CPUs


conclusion

The design method of the CPU control unit depends on the type of processor. Hardwired control is preferred for speed capacity systems with simple instructional kits, while Microprogrammed control is widely used in general processors with general instructions. Many modern CPUs use a hybrid approach, combining both techniques to balance speed and flexibility.


Microprogrammed The Control - Basic Concepts: -

CPU control unit (CU) leads the execution of instructions by generating control signals. Unlike hardwired control, which uses fixed logic, stores control control control information in memory when the microprogram control stores microinity. These micro instructions define the operating sequence for each machine instruction.

Basic Concept

In Microprogrammed control, a particular memory that has a special memory mixing program called the control memory (cm). Each machine instruction is used as a sequence of micro operations. For example, one can "add" instructions to be broken:
  • Get Operand from registers.
  • Send them to alu.
  • Save the result back in a register.
Each of these phases is controlled by micro instructions, which are gradually read from control memory.

Component of the microprogram control unit

  • Control memory (cm): Save microinning.
  • Control address register (CAR): Currently detects microinning.
  • Control Data Register (CDR): Save microinstruction taken from memory.
  • Sequencer: Determines the next microintering address (sequential or branch).
  • Decodder and control lines: Convert microinstruction pieces into real control signals.

Micro-programming types:

Horizontal micro-logramming

  • Each micro instruction consists of multiple control pieces (one per control signal).
  • Parallelism is possible.
  • Extensive control words require, which causes a large memory footprint.

Vertical micrologging program

  • Control signs are coded in low pieces.
  • Further decoding is required.
  • More compact than a horizontal microprocessor, but it slows down.

The benefits of the microprogram check

  • It is easy to change the instruction kit by updating the control memory.
  • Supports complex instructions (CISC).
  • Many instructions provide flexibility to design formats.

Loss of the microprogram check

  • Slowly compared to hardweed control, as it must be brought from the control memory.
  • More memory-intensive.

Application

  • Used in CISC processors like Intel X86.
  • The emulator and instructional kit provide the implementation of the expansion.
  • Useful in firmware design where flexibility is important.

conclusion

Microprogrammed control provides a flexible and systematic method for designing CPU control devices. However, with a slower speed compared to hardware control, it is widely used in a processor with a complex instruction set, making it an important concept in computer architecture.


Minimizing Microinstruction Size: -

In the microprogrammed control devices, each machine instruction is performed through the sequence of microinstructions stored in the control memory. A micro-installation usually consists of several control signs that activate functional devices, buses, and data styles. However, as the number of characters increases, the length of micro micro-installation becomes very large, which leads to high memory requirements. Thus, it is necessary to reduce microintricacy size for effective CPU design.

Micro-instruction size factors

  • The number of control sign indications increases the bit length of each microinity.
  • Organization of control signs - whether indications are stored directly (horizontally) or coded (vertically).
  • Equality rate - Multiple signs are required to specify high parallelism at the same time.

Technology to reduce micrinthelation size

1. Signal coding

Instead of assigning a bit to a slightly per control signal, signals are grouped and coded. For example:
  • The vertical micro compulsion controls the signals in the code areas, each decoded to generate multiple signals.
  • This reduces the width of the instructions, but may require extra decoding of hardware.

2. Area structure

A micronyst section can be divided into areas, where each region controls a separate part of the CPU (eg, aluminum, register selection, memory access). By structuring areas efficiently, smaller pieces are required.

3. Micrinized Comprehension Compacting

The sequences that are often used in micro operations can be added to a single micro-installation.
It reduces the indirect number of microinters that reduce the minimum size.

4. Limited Equality

The limitation of the number of permitted operations at the same time reduces the number of control indications required for micrinting, thus reducing the width.

5. Hybrid coding

Connects horizontal and vertical techniques - some indications are directly specified, while others are coded. It balances speed and reduction in size.

Trade-offs

  • Small micronyst section control reduces memory size, but can slow down the execution due to further decoding.
  • Large micrinths improve the similarity by improving speed, but using more memory.

conclusion

It is important to reduce microinstruction size to achieve a balance between control memory efficiency and processor performance. Designers often use field coding, signaling grouping, and hybrid approaches to adapt to micro-programming. This ensures effective CPU operations without excessive memory requirements.


Multiplier control unit: -

The multiplier control unit (MCU) is a special component of the CPU or Arithmetic processor responsible for performing multiplication operations. Since multiplication is a basic arithmetic operation in applications such as digital signal processing, graphics, and scientific data processing, an effective multiplier design is required.

Basic Concept

The multiplication can be seen as a sequence to connect the sequence and the operation of the shift. For binary numbers, the control unit repeatedly examines each bit multiplier:
  • If BIT 1 is 1, the multiplication is added to a partial product.
  • If the piece is 0, only changes.
  • The process continues until all multiples are treated.
The multiplier control unit administers these stages by generating control signals to arithmetic logical units (ALU), registers, and shifters.

Multiplier Control Unit Component

  • Multiplicand Register (MR): Store the number to multiply the number.
  • Multiple Registers (QR): Saves the multiplier and changes it each cycle correctly.
  • Cremist (AC): Saves partial products.
  • Control logic: Displays the operating sequence (add, shift, check the bit).
  • Teller: Spores the number of repetitions.

Design Methods

1. Sequential control

  • Multiply one step at a time.
  • Simple Control uses logic and low hardware resources.
  • Slow because many watch cycles are required.

2. Parallel control

  • Many partial products are generated at the same time.
  • More hardware is required, but it increases rapidly.
  • Examples: Array Multipliers, Walecas Tree Multipliers.

The role of the control unit

  • Discards multiplication instructions.
  • Load opening in registers.
  • In addition or alu for the shift.
  • When all bits are treated, the operation stops

conclusion

The multiplier control unit plays an important role in effective multiplication. Depending on the application, the CPU can use sequential designs for simplicity or high-performance parallel properties. Modern processors often use hybrid approaches to balance rate, region, and power consumption.



Microprogrammed Computer - CPU Control Unit: -

The CPU control unit (CU) is part of the processor responsible for directing the execution of instructions by generating the necessary control signals. In the Microprogram, computers, the control unit is used by means of micro programming, where the control signals are taken from a micro-installation stored in a particular memory called the control memory (CM).

This approach is different from the Hardweed control, which uses a combination logic circuit. Micro programming provides easy flexibility and modification, from which it especially suitable for complex instructional sets of computers (CISC).

Basic concept for microprogram control unit

Each instruction in the CPU's instruction kit is divided into small stages called micro operations (eg, brings operands, operates ALU, stores results). These micro operations are defined by microinsers, which are gradually stored in the control memory.
  • Control address (CAR): Next micro-installation detected.
  • Control memory (cm): Save microinning.
  • Control Data Register (CDR): Saves the currently performed microins.
  • Sequencer: The next address (sequential design or branch) determines.
  • Decodder and control lines: Generate real control signals from microinyst section.
This design ensures that each instruction can be traversed in a systematic way.

A microino's structure

Usually occurs in a micinese:
  • Control signs - Enable CPU components (alu, register, buses).
  • Sequence information - determines the next microinstruction (eg, branch, jump).
  • Coding field - coded signal to reduce instructional size.

Micro-programming types

Horizontal micro-logramming

  • Each control signal consists of a dedicated bit.
  • Enables design parallel to micro operations.
  • Extensive micrinths are required and use more memory.

Vertical micrologging program

  • Uses a coded field to represent groups of signals.
  • Compact and low memory are required.
  • Slowly due to decoding overhead.

Hybrid microprogram

  • Connects horizontal and vertical techniques.
  • Balance speed and memory efficiency.

The benefits of the microprogram check

  • Design and implementation are easier than hardwired control.
  • Flexible: The instruction kit can be changed by updating the control memory.
  • Useful for simulation of different instruction kits.
  • Ideal to use CISC architecture.

Loss of microprogram check

  • Slow performance compared to hardwide control (due to memory access).
  • The case with wide horizontal microinters requires great control of memory.

Application

  • CISC processors such as Intel X86 and WAX are used.
  • Planned in systems where firmware updates can improve or expand the CPU functionality.
  • Useful in microcontrollers to use special instructions.

conclusion

A microprogrammed CPU control unit provides a structured and flexible method for the execution of instructions. Although slower compared to Hardweed control, it allows simple modifications, supports complex instructions, and simplifies CPU design. Modern processors often combine a microprocessor with hardware techniques for an optimal balance between performance, flexibility, and efficiency.


-------------------------------------------MODULE-3 NEXT PAGE-------------------------------------------

No comments:

Post a Comment