i

CHAPTER 0.1 - NUMBERS AND ARITHMETIC

You don't habitually use the base two system to balance your
checkbook, so it would be counterproductive to teach you machine
arithmetic on a base two system. What number systems have you had
a lot of experience with? The base 10 system springs to mind. I'm
going to show you what happens on a base 10 system so you will
understand the structure of what happens with computer
arithmetic.

BASE 10 MACHINE

Each place inside the microprocessor that can hold a number is
called a REGISTER. Normally there are a dozen or so of these. Our
base 10 machine has 4 digit registers. They can represent any
number from 0000 to 9999. They are exactly like an industrial
counters or the counters on your tape machines.{1} If you add 27
to a register, the microprocessor counts forward 27; if you
subtract 153 from a register, the microprocessor counts backwards
153. Every time you add 1 to a register, it increments by 1 -
that is 0245, 0246, 0247, 0248. Every time you subtract 1 from a
register, it decrements by 1 - that is 3480, 3479, 3478, 3477.

Let's do some more incrementing. 9997, 9998, 9999, 0000, 0001,
0002. Whoops! That's a problem. When the register reaches 9999
and we add 1, it changes to 0000, not 10,000. How can we tell the
difference between 0000 and 10,000? We can't without a little
help from the CPU.{2} Immediately after an arithmetical
operation, the CPU knows whether you have gone through 10,000
(9999->0000). The CPU has something called a carry flag. It is
internal to the CPU and can have the value 0 or 1. After each
arithmetical operation, the CPU sets the CARRY FLAG to 1 if you
went through the 9999/0000 boundary, and sets the carry flag to 0
if you didn't.{3}

Here are some examples, showing addition, the result, and the
carry flag. The carry flag is normally abbreviated by CF.

number 1 number 2 result CF

0289 4782 5071 0
4398 2964 7382 0
8177 5826 4003 1
____________________

1. Exactly like industrial counters that have several hundred
thousand parts, that is.

2. The CPU (central processing unit) is the chip(s) that does
all the arithmetic. In the case of the PC, it is the 8086.

3. When you set a flag to 0, it is called CLEARING the flag.

______________________

The PC Assembler Tutor - Copyright (C) 1989 Chuck Nelson

The PC Assembler Tutor ii
______________________

6744 4208 0952 1

Note that you must check the carry flag immediately after the
arithmetical operation. If you wait, the CPU will reset it after
the next arithmetical operation.

Now let's do some decrementing. 0003, 0002, 0001, 0000, 9999,
9998. Golly gosh! Another problem. When we got to 0000, rather
than getting -1, -2, we got 9999, 9998. Apparently 9999 stands
for -1, 9998 stands for -2. Yes, that's the system on this, on
the 8086, and on all computers. (Back to that in a moment.) How
do we tell that the number went through 0 ; i.e. 0000->9999? The
carry flag comes to the rescue again. If the number goes through
the 9999/0000 boundary in either direction, the CPU sets the CF
to 1; if it doesn't, the CPU sets the CF to 0. Here's some
subtraction, with the result and the carry flag.

number 1 number 2 result CF

8473 2752 5721 0
2836 4583 1747 1
0654 9281 8627 1
9281 0654 8627 0

Look at examples 3 and 4. The numbers are reversed. The results
are the same but they have different signs. But that is as it
should be. When you reverse the order in a subtraction, you get
the same absolute value, only a different sign (15 - 7 = 8 but
7 - 15 = -8). Remember, the CF is reliable only immediately after
the operation.

NEGATIVE NUMBERS

The negative numbers go 9999=-1, 9998=-2, 9997=-3, 9996=-4,
9995=-5 etc. A more negative number is denoted by a smaller
number in the register; -5 = 10,000 -5 = 9995; -498 = 10,000 -498
= 9502, and in general, -x = 10,000 -x. Here are some negative
numbers and their representations on our machine.

number machine no number machine no

-27 9973 -4652 5348
-8916 1084 -6155 3845

As you will notice, these numbers look exactly the same as the
unsigned numbers. They ARE exactly the same as the unsigned
numbers. The machine has no way of knowing whether a number in a
register is signed or unsigned. Unlike BASIC or PASCAL which will
complain whenever you try to use a number in an incorrect way,
the machine will let you do it. This is the power and the curse
of machine language. You are in complete control. It is your
responsibility to keep track of whether a number is signed or
unsigned.

Which signed numbers should be positive and which negative? This
has already been decided for you by the computer, but let's think

Chapter 0.1 - Numbers and Arithmetic iii
____________________________________

out what a reasonable solution might be. We could have from 0000
to 8000 positive and from 9999 to 8001 negative, but that would
give us 8001 positive numbers and 1999 negative numbers. That
seems unbalanced. More importantly, if we take -(3279) the
machine will give us 6721, which is a POSITIVE number. We don't
want that. For reasons of symmetry, the positive numbers are
0000-4999 and the negative numbers are 9999-5000.{4} Our most
negative number is -5000 = 10,000 -5000 = 5000.

10'S COMPLEMENT

It's time for a digression. If we are going to be using negative
numbers like -(473), changing from an external number to an
internal number is going to be a bother: i.e. -473 -> 9527. Going
the other way is going to be a pain too: i.e. 9527 -> -473. Well,
it would be a problem except that we have some help.

0000 = 10,000 = 9999 +1
- 473
result 9526 +1 = 9527

Let's work this through carefully. On our machine, 0000 and
10000 (9999+1) are the same thing, so 0 - 473 is the same as
9999+1-473 which is the same as 9999-473+1. But when we have all
9s, this is a cinch. We never have to borrow - all we have to do
is subtract each digit from 9 and then add 1 to the total. We may
have to carry at the end, but that is a lot better than all those
borrows. We'll do a few examples:

(-4276)
0000 = 10,000 = 9999 +1
-4276
result 5723 +1 = 5724

(-3982)
0000 = 10,000 = 9999 +1
-3982
result 6017 +1 = 6018

(-2400)
0000 = 10,000 = 9999 +1
-2400
result 7599 +1 = 7600

(-1989)
0000 = 10,000 = 9999 +1
____________________

4. That way, if we tell the machine that we are working with
signed numbers, all it has to do is look at the left digit. If
the digit is 5-9, we have a negative number, if it is 0-4, we
have a positive number. Note that 0000 is considered to be
positive. This is true on all computers.

The PC Assembler Tutor iv
______________________

-1989
result 8010 +1 = 8011

This is called 10s complement. Subtract each digit from 9, then
add 1 to the total. One thing we should check is whether we get
the same number back if we negate the negative result; i.e. does
-(-1989)) = 1989? From the last example, we see that -1989 =
8011, so:

(-8011)
0000 = 10,000 = 9999 +1
-8011
result 1988 +1 = 1989

It seems to work. In fact, it always works. See the footnote for
the proof.{5} You are going to use this from time to time, so you
might as well practice some. Here are 10 numbers to put into 10s
complement form. The answers are in the footnote. (1) -628, (2)
-4194, (3) -9983, (4) -1288, (5) -4058, (6) -6952, (7) -162, (8)
-9, (9) -2744, (10) -5000.{6}

The computer keeps track of whether a number is positive or
negative. After an arithmetical operation, it sets a flag to tell
whether the result is positive or negative. This flag has no
meaning if you are using unsigned numbers. The computer is
saying, "If the last arithmetical operation was with signed
numbers, then this is the sign of the result." The flag is called
the sign flag (SF). It is 0 if the number is positive and 1 if
the number is negative. Let's decrement again and look at both
the sign flag and carry flag.

NUMBER SIGN CARRY

3 0 0
2 0 0
1 0 0
0 0 0
9999 1 1
____________________

5. Let x be any number. Then:
-x = ( 10,000 - x) = ( 9999 + 1 - x ) ;

-(-x) = ( 10,000 - (-x) ) = ( 9999 + 1 - (-x) )
= ( 9999 + 1 - ( 9999 + 1 - x ) )
= ( 9999 + 1 - 9999 - 1 + x )
= x

6. (1) -628 = 9372 , (2) -4194 = 5806 , (3) -9983 = 0017,
(4) -1288 = 8712 , (5) -4058 = 5942 , (6) -6952 = 3048
(7) -162 = 9838 , (8) -9 = 9991 , (9) -2744 = 7256,
(10) -5000 = 5000. This last one is a little strange. It
changes 5000 into itself. In our system, 5000 is a negative
number and it winds up as a negative number. This happens on all
computers. If you take the maximum negative number and take its
negative, you get the same number back.

Chapter 0.1 - Numbers and Arithmetic v
____________________________________

9998 1 0
9997 1 0
9996 1 0

That worked pretty well. The sign flag changed from 0 to 1 when
we went from 0 to 9999 and the carry flag was set to 1 for that
one operation so we could see that we had gone through the
9999/0000 boundary.

Let's do some more decrementing.

NUMBER SIGN CARRY

5003 1 0
5002 1 0
5001 1 0
5000 1 0
4999 0 0
4998 0 0
4997 0 0
4996 0 0

This one didn't work too well. 5000 is our most negative number
(-5000) and 4999 is our most positive number; when we crossed the
4999/5000 boundary, the sign changed but there was nothing to
tell us that the sign had changed. We need to make another flag.
This one is called the overflow flag. We check the carry flag
(CF) for the 0000/9999 boundary and we check the overflow flag
for the 5000/4999 boundary. The last decrementing example with
the overflow flag:

NUMBER SIGN CARRY OVERFLOW

5003 1 0 0
5002 1 0 0
5001 1 0 0
5000 1 0 0
4999 0 0 1
4998 0 0 0
4997 0 0 0
4996 0 0 0

This time we can find out that we have gone through the boundary.
We'll come back to how the computer sets the overflow flag later,
but let's do some addition and subtraction now.

Unsigned addition is done the same way as normally. The computer
adds the two numbers. If the result is over 9999, it sets the
carry flag and drops the left digit (i.e. 14625 -> 4625, CF = 1,
19137 -> 9137 CF = 1, 10000 -> 0000 CF = 1). The largest possible
addition is 9999 + 9999 = 19998. This still has a 1 in the left
digit. If the carry flag is set after an addition, the result
must be between 10000 and 19998.

The PC Assembler Tutor vi
______________________

flag or the overflow flag for the moment. Here are some examples

NUMBER 1 NUMBER 2 RESULT CF

5147 2834 7981 0
6421 8888 5309 1
2910 6544 9454 0
6200 6321 2521 1

Directly after the addition, the computer has complete
information about the number. If the carry flag is set, that
means that there is an extra 10,000, so the result of the second
example is 15309 and the result of the fourth example is 12521.
There is no way to store all that information in 4 digits in
memory so that extra information will be lost if it is not used
immediately.

Subtraction is similar. The machine subtracts, and if the answer
is below 0000, it sets the carry flag, borrows 10000 and adds it
to the result. -3158 -> -3135 + 10000 -> 6842 CF = 1 ; -8197 ->
-8197 + 10000 -> 1803 CF = 1. After a subtraction, if the carry
flag is set, you know the number is 10000 too big. Once again,
the carry flag information must be used immediately or it will be
lost. Here are some examples:

NUMBER 1 NUMBER 2 RESULT CF

3872 2655 1217 0
9826 5967 3859 0
4561 7143 7418 1
2341 4907 7434 1

If the carry flag is set, the computer borrowed 10000, so example
3 is 7418 - 10000 = -2582 and example 4 is 7434 - 10000 = -2566.

MODULAR ARITHMETIC

What the computer is doing is modular arithmetic. Modular
arithmetic is like a clock. If it is 11 o'clock and you go
forward 1 hour it's now 12 o'clock; if it's 11 and you go
backwards 1 hour it's now 10. If it's 11 and you go forward 4
hours it's not 15, it's 3. If it's 11 and you go backward 15
hours it's not -4, it's 8.

The clock is doing mod 12 arithmetic.{7}

(A+B) mod 12
(A-B) mod 12

From the clock's viewpoint, 11 o'clock today, 11 o'clock
yesterday and 11 o'clock, June 8, 1754 are all the same thing. If
____________________

7. To be a perfect analogy 12 o'clock should be 0 o'clock.

Chapter 0.1 - Numbers and Arithmetic vii
____________________________________

you go forward 200 hours (that's 12X16 + 8) you will have the
same result as going forward 8 hours. If you go backwards 200
hours (that's -(12X16 + 8) = -(12X16) -8) you get the same result
as going backwards 8 hours. If you go forward 4 hours from 11
(11+4) mod 12 = 3 you get the same result as going backwards 8
hours (11-8) mod 12 = 3. In fact, these come in pairs. If A + B =
12, then going forward A hours gives the same result as going
backwards B hours. Forwards 9 = backwards 3; forwards 7 =
backwards 5; forwards 11 = backwards 1.

In the mod 12 system, the following things are equivalent:

(+72 + 4) (+72 - 8)
(+60 + 4) (+60 - 8)
(+48 + 4) (+48 - 8)
(+36 + 4) (+36 - 8)
(+24 + 4) (+24 - 8)
(+12 + 4) (+12 - 8)
( 0 + 4) ( 0 - 8)
(-12 + 4) (-12 - 8)
(-24 + 4) (-24 - 8)
(-36 + 4) (-36 - 8)
(-48 + 4) (-48 - 8)
(-60 + 4) (-60 - 8)

They form what is known as an equivalence class mod 12. If you
use any one of them for addition or subtraction, you will get the
same result (mod 12) as with any other one. Here's some

(+48 + 4) + 7 = (48 + 11) mod 12 = 11
(-48 - 8) + 7 = (48 - 1 ) mod 12 = 11
( 0 - 8) + 7 = ( 0 - 1 ) mod 12 = 11
(-60 + 4) + 7 = (-60 +11) mod 12 = 11

And some subtraction:

(+48 + 4) - 2 = (48 + 2 ) mod 12 = 2
(-48 - 8) - 2 = (48 - 10) mod 12 = 2
( 0 - 8) - 2 = ( 0 - 10) mod 12 = 2
(-60 + 4) - 2 = (-60 + 2) mod 12 = 2

Our pretend computer doesn't cycle every 12 numbers, it cycles
every 10,000 numbers - it is a mod 10,000 machine. On our
machine, the number 6453 has the following equivalence class:

(+30000 + 6453) (+30000 - 3547)
(+20000 + 6453) (+20000 - 3547)
(+10000 + 6453) (+10000 - 3547)
( 0 + 6453) ( 0 - 3547)
(-10000 + 6453) (-10000 - 3547)
(-20000 + 6453) (-20000 - 3547)
(-30000 + 6453) (-30000 - 3547)
____________________

8. (-10) mod 12 = 2 ; (-11) mod 12 = 1

The PC Assembler Tutor viii
______________________

Any one of these will act the same as any other one. Notice that
10000 - 3547 is the subtraction that we did to get the
representation of -3547 on the machine.

-3547 = 9999 + 1
3547
6452 + 1 = 6453

6453 and -3547 act EXACTLY the same on this machine. What this
means is that there is no difference in adding signed or unsigned
numbers on the machine. The result will be correct if interpreted
as an unsigned number; it will also be correct if interpreted as
a signed number.

6821 + 3179 = 10000 so -3179 = 6821 and 3179 = -6821
5429 + 4571 = 10000 so -4571 = 5429 and 4571 = -5429

Since -3179 and 6821 act the same on our machine and since -4571
and 5429 act the same, let's do some addition. Take your time so
you understand why the signed and unsigned numbers are giving the
same results mod 10000:

---------------------------------------------------------
6821 + 497 = 7318
-3179 + 497 = (10000 - 3179) + 497 = 10000 -2682 = -2682

7318 + 2682 = 10000 so -2682 = 7318

----------------------------------------------------------

5429 + 876 = 6305
-4571 + 876 = (10000 - 4571) + 876 = 10000 - 3695 = -3695

6305 + 3695 = 10000 so -3695 = 6305

----------------------------------------------------------

Here's some subtraction:

-----------------------------------------------------------

6821 - 507 = 6314
-3179 - 507 = (10000 - 3179) - 507 = 10000 - 3686 = -3686

6314 + 3686 = 10000 so -3686 = 6314

----------------------------------------------------------

5429 - 178 = 5251
-4571 - 178 = (10000 - 4571) - 178 = 10000 - 4749 = -4749

5251 + 4749 = 10000 so -4749 = 5251

-----------------------------------------------------------

It is the same addition or subtraction. Interpreted one way it is

Chapter 0.1 - Numbers and Arithmetic ix
____________________________________

signed addition or subtraction; interpreted another way it is

The machine could have one operation for signed addition and
another operation for unsigned addition, but this would be a
waste of computer resources. These operations are exactly the
same. This machine, like all computers, has only one integer
addition operation and one integer subtraction operation. For
each operation, it sets the flags of importance for both signed
and unsigned arithmetic.

For unsigned addition and subtraction, CF, the carry flag tells
whether the 0000/9999 boundary has been crossed.

For signed addition and subtraction, SF, the sign flag tells the
sign of the result and OF, the overflow flag tells whether the
result was too negative or too positive.

SIGN EXTENSION

Although our base 10 machine is set up for 4 digit numbers, it is
possible to use it for numbers of any size by writing the
appropriate software. We'll use 12 digit numbers as an example,
though they could be of any length. The first problem is
converting 4 digit numbers into 12 digit numbers. If the number
is an unsigned number, this is no problem (we'll write the number
in groups of 4 digits to keep it readable):

4816 -> 0000 0000 4816
9842 -> 0000 0000 9842
127 -> 0000 0000 0127

what if it is a signed number? The first thing we need to know
about signed numbers is, what is positive and what is negative?
Once again, for reasons of symmetry, we choose positive to be
0000 0000 0000 to 4999 9999 9999 and negative to be 5000 0000
0000 to 9999 9999 9999.{9} This longer number system cycles from

9999 9999 9999 to 0000 0000 0000. Therefore, for longer numbers,
0000 0000 0000 = 1 0000 0000 0000. They are equivalent.
0000 0000 0000 = 9999 9999 9999 + 1.

If it is a positive signed number, it is still no problem (recall
that in our 4 digit system, a positive number is between 0000 and
4999, a negative signed number is between 5000 and 9999). Here
are some positive signed numbers and their conversions:

1974 -> 0000 0000 1974
1 -> 0000 0000 0001
3909 -> 0000 0000 3909

____________________

9. Once again, the sign will be decided by the left hand
digit. If it is 0-4 it is a positive number; if it is 5-9 it is a
negative number.

The PC Assembler Tutor x
______________________

If it is a negative number, where did its representation come
from in our 4 digit system? -x -> 9999 + 1 -x = 9999 - x + 1.
This time it won't be 9999 + 1 but 9999 9999 9999 + 1. Let's have
some examples.

4 DIGIT SYSTEM 12 DIGIT SYSTEM

-1964
9999 + 1 9999 9999 9999 + 1
-1964 -1964
8035 -> 8036 9999 9999 8035 + 1 -> 9999 9999 8036

-2867
9999 + 1 9999 9999 9999 + 1
-2867 -2867
7132 -> 7133 9999 9999 7132 + 1 -> 9999 9999 7133

-182
9999 + 1 9999 9999 9999 + 1
-182 -182
9817 -> 9818 9999 9999 9817 + 1 -> 9999 9999 9818

As you can see, all you need to do to sign extend a negative
number is to put 9s to the left.

Can't those 9s on the left become 0s when we add that 1 at the
end? No. In order for that to happen, the right four digits must
be 9999. But that can only happen if the number to be negated is
0000:

9999 9999 9999 + 1
-0000
9999 9999 9999 + 1 -> 0000 0000 0000

In all other cases, adding 1 does not carry anything out of the
right four digits.

It is impossible to truncate one of these 12 digit numbers to a 4
digit number without making the results unreliable. Here are two
examples:

(number) 0000 0168 7451 -> 7451 (now a negative number)
(actual value) +168 7451 -2549

(number) 9999 9643 2170 -> 2170 (now a positive number)
(actual value) -356 7830 +2170

We now have 12 digit numbers. Is it possible to add them and
subtract them? Yes but only 4 digits at a time. When you add with
pencil and paper you carry left from each digit. The computer can
carry left from each group of 4 digits. We'll do the following

0138 6715 6037
+ 2514 2759 7784

Chapter 0.1 - Numbers and Arithmetic xi
____________________________________

Do this with pencil and paper and write down all the carries. The
computer is going to do this in 3 parts:

1) 6037 + 7784
2) 6715 + 2759 + carry (if any)
3) 0138 + 2514 + carry (if any)

The first addition is our regular addition. It will set the carry
flag if the 0000/9999 boundary was crossed (i.e. the result was
larger than 9999). In our case CF = 1 since the result is 13821.
The register holds 3821. We store 3821. Next, we need to add
three things: 6715 + 2759 + CF (=1). There is an instruction like
this on all computers. It adds two numbers plus the value of the
carry). The result of our second addition is 9475. The register
holds 9475 and CF = 0. We store 9475. Finally, we need to add
three more things: 0138 + 2514 + CF (=0). Once again we use ADC.
The result is 2652, CF = 0. We store the 2652. That is the whole
result:

2652 9475 3821

If CF = 1 at this point, the number has crossed the
9999,9999,9999/0000,0000,0000 boundary. This will work for signed
numbers also. The only difference is that at the very end we
don't check CF, we check OF to see if the
4999,9999,9999/5000,0000,0000 boundary has been crossed.

Just to give you one more example we'll do a subtraction using
the same numbers:

0138 6715 6037
2514 2759 7784

Notice that in order for you to do this with pencil and paper
you'll have to put the larger number on top before you subtract.
With the machine this is unnecessary. Go ahead and do the
subtraction with pencil and paper.

The machine can do this 4 digits at a time, so this is a three
step process:

1) 6037 - 7784
2) 6715 - 2759 - borrow (if any)
3) 0138 - 2514 - borrow (if any)

The first one is a regular subtraction and since the bottom
number is larger, the result is 8253, CF = 1. (Perhaps you are
puzzled because that's not the result that you got. Don't worry,
it all comes out in the wash). Step two subtracts but also
subtracts any borrow (We had a borrow because CF = 1). There is a
special instruction called SBB (subtract with borrow) that does
just that. 6715 - 2759 - 1 = 3955, CF = 0. We store the 3955 and
go on to the third part. This also is SBB, but since we had no

The PC Assembler Tutor xii
______________________

borrow, we have 0138 - 2514 - 0 = 7624, CF = 1. We store 7624.
This is the end result, and since CF = 1, we have crossed the
9999,9999,9999/0000,0000,0000 boundary. This is going to be the
representation of a negative number mod 1,0000,0000,0000. With
pencil and paper, your result was:

-2375 6044 1747

The machine result was:

7624 3955 8253

But CF was 1 at the end, so this represents a negative number.
What number does it represent? Let's take its negative to get a
positive number with the same absolute value:

9999 9999 9999 + 1
7624 3955 8253
2375 6044 1746 + 1 = 2375 6044 1747

This is the same thing you got with pencil and paper. The reason
it looked wierd is that a negative number is always stored as its
modular equivalent. If you want to read a negative number, you
need to take its negative to get a positive number with the same
absolute value.

If we had been working with signed numbers, we wouldn't have
checked CF at the very end, we would have checked OF to see if
the 4999,9999,9999/5000,0000,0000 boundary had been crossed. If
OF = 1 at the end, then the result was either too negative or too
positive.

OVERFLOW

How does the machine decide that overflow has occured? First,
what exactly is overflow and when is it possible for overflow to
occur?

Overflow is when the result of a signed addition or subtraction
is either larger than the largest positive number or more
negative than the most negative number. In the case of the 4
digit machine, larger than +4999 or more negative than -5000.

If one number is negative and the other is positive, it is not
possible for overflow to occur. Take +32 and -4791 as examples.
number (-4791), the result can't possibly be too positive.
the positive number (+32), the result can't be too negative.
Therefore, the result can be neither too positive nor too
negative. Make sure you understand this before going on.

What if both are positive? Then overflow is possible. Here are
some examples:

Chapter 0.1 - Numbers and Arithmetic xiii
____________________________________

(+3500) + (+4500) = 8000 = -2000
(+2872) + (+2872) = 5744 = -4256
(+1799) + (+4157) = 5956 = -4044

In each case, two positive numbers give a negative result. How

(7154) + (6000) = 3154 = +3154
(actual value) -2946 -4000

(5387) + (5826) = 1213 = +1213
(actual value) -4613 -4174

(8053) + (6191) = 4244 = +4244
(actual value) -1947 -3809

The numbers underneath are the negative numbers that the numbers
above them represent. In these cases, adding two negative numbers
gives a positive result.

This is what the machine checks for. Before the addition, it
checks the signs of the numbers. If the signs are the same, then
the result must also be the same sign or overflow has
occurred.{10} Thus + and + must have a + result; - and - must
have a - result. If not, OF (the overflow flag) is set (OF = 1).
Otherwise OF is cleared (OF = 0).

MULTIPLICATION

Unsigned multiplication is easy. The machine simply multiplies
the two numbers. Since the result can be up to 8 digits (the
maximum result is 9999 X 9999 = 9998 0001) the machine uses two
registers to hold the result. We'll call them R1 and R2.

5436 X 174 R1 0094
R2 5864

2641 X 2003 R1 0528
R2 9923

You need to know which register holds which half of the result,
but besides that, everything is straightforward. On this machine
R1 holds the left four digits and R2 holds the right four digits.

Notice that our machine has changed the modular base from N to
N*N (from 1 0000 to 1 0000 0000). What this means is that two
things which are modularly equivalent under addition and
subtraction are not necessarily equivalent under multiplication
and division. 6281 and -3719 will not work the same.
____________________

10. The machine checks something considerably more obscure
because it is easier to implement in semiconductor logic, but
what it is actually doing is checking to see if the two numbers
being added have the same sign. If they do, the result must be
the same sign or overflow has occurred.

The PC Assembler Tutor xiv
______________________

The machine can't do signed multiplication. What it actually does
is convert the numbers to positive numbers (if necessary),
perform unsigned multiplication, and then do sign adjustment of
the results (if necessary). It uses 2 registers for the result.

SIGNED MULTIPLICATION REGS RESULT

(number) (5372) X (3195) R1 8521 = -1478 6460
(actual value) -4628 X +3195 R2 3540

(number) (9164) X (8746) R1 0104 = +104 8344
(actual value) -836 X -1254 R2 8344

(number) (9927) X (0013) R1 9999 = -949
(actual value) -73 X +13 R2 9051

Looking at the last example, if we performed unsigned
multiplication on those two numbers, we would have
9927 X 0013 = 0012 9051, a completely different answer from the
one we got. Therefore, whenever you do multiplication, you have
to tell the machine whether you want unsigned or signed
multiplication.

DIVISION

Unsigned division is easy too. The machine divides one number by
the other, puts the quotient in one register and the remainder in
another. Once again, the only problem is remembering which
register has the quotient and which register has the remainder.
For us, the quotient is R1 and the remainder is R2.

6190 / 372 R1 0016 16 remainder 238
R2 0238

9845 / 11 R1 0895 895 remainder 0
R2 0000

As with multiplication, signed division is handled by the machine
changing all numbers to positive numbers, performing unsigned
division, then putting back the appropriate signs.

SIGNED DIVISION REGS RESULT

(number) (7192) / (9164) R1 0003 +3 rem. -300
(actual value)-2808 / -836 R2 9700

(number) (3753) / (9115) R1 9996 -4 rem. +213
(actual value)+3753 / -885 R2 0213

Looking at the last example, 3753 / 9115, if that were unsigned
multiplication the answer would be 0 remainder 3753, a completely
different answer from the signed division. Every time you do a
division, you have to state whether you want unsigned or signed
division.