ࡱ> !# G 2bjbjَ !]8$<,F")***00* <+ H,$-/l,l,d$d$d$d$))d$d$):),)>T.p$Id$) Modified version Introduction to Binary Computers Steve Jost January 1997 Table of Contents 1. A Brief History of Computers 1 2. Binary and Hexadecimal Numbers 2 3. Decimal-to-Binary Conversion 3 4. Binary Arithmetic 5 5. Representation of Negative Numbers 7 6. Bitwise Operations 8 7. Introduction to MACHINE-16 9 8. Addressing Modes 15 1. A Brief History of Computers. 1200 The modern abacus was invented. 1642 Blaise Pascal invented the first calculating machine at the age of 19. 1672 Gottfried Leibniz built a calculating machine that could add, subtract, multiply, and divide. 1837 Charles Babbage built the first mechanical computer capable of multistep programs. This machine was about 100 years ahead of its time and little further progress was made until the 20th century. 1842 Probably the first programmer was Ada Augusta, the Countess of Lovelace. She worked with Babbage helping him write programs for his analytical engine. She noted that the machine could not originate anything but could only do what we know how to order it to perform. The computer language ADA developed in the 1970's was named after her. 1887 Dr. Herman Hollerith developed a punched card reading machine to assist in tabulating data for the 1890 U. S. census. Without this machine, processing this data would have taken more than ten years! With the machine, the data processing for the census only took three years. 1937 Howard Aitken who was a professor at Harvard built the Mark I digital computer. It was controlled with electromagnetic relays and received its input from punched cards. 1939 The first electronic computer using vacuum tubes for switching was constructed by Dr. John Vincent Atanasoff at Iowa State college and was called the ABC (Atanasoff-Berry Computer). It was built for solving systems of simultaneous equations. 1940 The first general purpose computer was built by Atanasoff together with John Mauchly and J. Presper Eckert. This computer was called ENIAC (Electronic Numerical Integrator and Calculator) and funded by the U.S. army. It could do 300 multiplications per second which was 300 times faster than any other machine of the day, but is contained 18,000 vacuum tubes and weighed 30 tons. The ENIAC was programmed by externally manipulating plugs and switches. The machine was used by the army until 1955. 1945 John von Neumann proposed two ideas which made modern high speed computers possible. These ideas were using binary numbers to store data, and storing instructions as data rather than entering them by switches or plugs as was done in earlier machines. 1949 The transistor was invented by Bardeen, Braitain, and Shockley at Bell Telephone Laboratories, who shared the Nobel Prize for this invention which made modern electronics possible. 1949 The first stored program electronic computer was developed at Cambridge University. It was built by M.V. Wilkes and called EDSAC (Electronic Delay Storage Automatic Calculator.) 1950 Computer industry forcasters concluded that about 10 stored memory computers would meet the demand for the entire U.S for years to come. This turned out to be one of the worst forecasts in history. 1954 International Business machines (IBM) sold the first computer for record keeping and business organization. This machine was less expensive than other computers available at the time and was widely accepted. These early computers were called first generation computers. They were programmed in binary machine language which a difficult and error prone process. First generation computers were originally designed for scientific operations. 1952 The first high level language was invented by Dr. Grace Hopper. She developed a compiler for the language called A-2 which converted instructions into machine language. 1954 The FORTRAN (FORmula TRANslator) language was developed at IBM by a programming team headed by John Backus. FORTRAN is still widely used for scientific applications. 1959 The first second generation computers were introduced which were smaller and faster than the first generation ones. They used solid state devices such as diodes and transistors instead of vacuum tubes. In addition computers which accepted instructions in high level languages became widespread. 1959 To meet the increasing demand for data processing, the language COBOL (COmmon Business Oriented Language) was developed. This language became popular because it was written in a quasi-English form that could be more easily understood by nonprogrammers than other languages of that time. 1963 The BASIC (Beginners All Purpose Symbolic Instruction Code) language was developed at Dartmouth college by John Kemeny and Thomas Kurtz. It was introduced as a language which was easy for students to learn, and was available on a timesharing computer which allowed several users to take turns sharing the central processing unit of the computer. 1970 The C programming language was designed by Dennis Ritchie. Its name comes from the fact that it was an improved version of the language BCPL or B for short. Many applications which formerly were written in assembly language are now written in C. 1976 The first Cray supercomputer was built. It is capable of performing more than 100 million floating point operations per second (100 megaflops). Computers with the capability of performing more than 10 billion floating point operations per second (10 gigaflops) will be possible within the next ten years. 2. Binary Numbers for Computers Many electronic hardware devices have two natural states such as conducting or not conducting, magnetized or not magnetized, positive or negative, on or off, etc. Using the binary numbers 0 or 1 greatly simplifies the design of electronic computers. However, because long sequences of 0's and 1's are difficult to read and understand, binary digits are conventionally grouped to make them more comprehensible. The following table shows the terms that are sometimes used to denote various sized groups of binary digits. Number of Binary Digits Term ======================= ==== 1 bit 4 nibble 8 byte 16 word 32 longword Here are some of the common C datatypes and their properties. C DatatypeNumber of bitsNumber of bytesMinimum ValueMaximum Valuechar81-128127unsigned char810255short int162-32,76832,767unsigned short int162065,536long int324-2,147,483,648 2,147,483,647unsigned long int32404,294,967,296float324-3.40 x 10^383.40 x 10^38double648-1.79 x 10^3081.79 x 10^308 The size of the datatype int depends on the particular implementation of C being used. On a mainframe or minicomputer, the likely size of an int is 4 bytes, while on a personal computer or microcomputer, its size is probably 2 bytes. As an introduction to digital computers, we will study a simplified computer called MACHINE-16 which only uses numbers of length 8 bits or 1 byte. The reason for the name MACHINE-16 is that it has 16 instructions for manipulating data. MACHINE-16 is a Von Neumann machine, described in Section 1, in the sense that both data and instructions can be stored in its memory. The instructions are executed sequentially one at a time, with the possibility of looping back to repeat a block of instructions several times. Although modern assembly languages are much more powerful than the language of MACHINE-16, the 16 instructions in its instruction set are powerful enough to solve a wide variety of problems. Some of these problems will be discussed in Section 6. 3. Decimal-to-Binary Conversion Because MACHINE-16 uses 8 bit binary arithmetic, all of our examples will be with 8 bit numbers. Initially, we will only consider positive or unsigned binary numbers. Later, we will see how negative numbers can be represented with eight bits. To convert a binary number into base 10 or vice versa, it is convenient to use the Binary-Hex-Decimal conversion table shown in below. A binary 1 means that that power of two is present while a 0 means that it is absent. Here is a table showing the various powers of two that we will need: Binary Decimal ======== ======= 1 1 10 2 100 4 1000 8 10000 16 100000 32 1000000 64 10000000 128 For example 01001101 = 64 + 8 + 4 + 1 = 77. To convert a decimal number to binary, the procedure is reversed: express the decimal number as a sum of powers of 2 and then write this sum as a sequence of binary bits. For example, to convert the decimal number 77 into binary, we write 77 -64 -- 13 - 8 -- 5 - 4 -- 1 - 1 -- 0 We select for each subtraction, the largest power of 2 which is less than or equal to the amount remaining. We then represent those powers of 2 present as 1 and those powers of 2 missing as 0. This gives 64 + 8 + 4 + 1 = 01001101. Because long binary numbers are hard to read, computer programmers prefer to express them in a form that is more easily read. The most common choice of notation today is the hexadecimal (base 16) representation where each four bit group of digits (nibble) is represented by a single hexadecimal digit. These digits are shown in the following Binary-Hex-Conversion table. Because we will be using the hex representation for machine code input to MACHINE-16, it is essential that this table be memorized. Binary Hex Decimal ====== === ======= 0000 0 0 0001 1 1 0010 2 2 0011 3 3 0100 4 4 0101 5 5 0110 6 6 0111 7 7 1000 8 8 1001 9 9 1010 a 10 1011 b 11 1100 c 12 1101 d 13 1110 e 14 1111 f 15 To represent a binary number in hex notation, simply replace each nibble by its corresponding hex digit: 01101001111010010100110001010001 6 9 e 9 4 c 5 1 The binary numbers we consider will be 8 bit numbers, each of which can be represented by 2 hex digits. We will employ the C language representation which uses the prefix 0x (zero x) for hex numbers. For example the expression 0x5d represents the binary number 01011101. It is important to note that the internal binary representation of an integer is independent of the form that the number takes when it is printed. The binary number 01011101 looks like 93 when printed with the C++ manipulator dec , like 5d when printed with hex, and like ]when printed as a regular char. Exercises Assume that all binary numbers consist of 8 bits and are unsigned, that is, are in the range 0 to 255. Signed binary numbers are discussed in Section 5. 1. Convert the following binary numbers to decimal: 01101011, 01110000, 00000111, 11111111, 01010101 2. Convert the following decimal numbers to binary: 49, 7, 153, 200, 191, 128, 93 3. Convert the following hex numbers to binary: 0x41, 0x3f, 0x83, 0xef, 0x20, 0x2a, 0xbb Convert the following binary numbers to hex: 1101101, 11101101, 11010000, 00000111, 11111111 5. Binary Arithmetic The four basic operations addition, subtraction, multiplication, and division are all easily performed with binary numbers. In fact they are actually easier to perform in binary because the addition and multiplication tables are so small. Here are basic addition facts in binary. 0 + 0 = 0 0 + 1 = 1 1 + 0 = 1 1 + 1 = 10 /* Result is 0, carry 1 */ 0 x 0 = 0 0 x 1 = 0 1 x 0 = 0 1 x 1 = 1 Carrying and borrowing are also performed as in decimal arithmetic. To add the numbers 0x3a and 0x27, first convert to binary, and add from right to left, carrying 1 to the next column when the result is 10. 58 0x3a ---> 00111010 +39 +0x27 ---> 00100111 -- ---- -------- 97 0x61 <--- 01100001 To subtract two binary numbers, borrow 1 when the bottom digit is 1 and the top digit is 0. For example, to compute 0x3a - 0x27, 58 0x3a ---> 00111010 -39 - 0x27 ---> 00100111 -- ---- -------- 19 0x13 <--- 00010011 Binary multiplication is also similar to decimal multiplication. The top factor is used as a partial product for each binary 1 in the bottom factor. The top factor is shifted by as many places to the left as the power of 2 that the binary 1 represents. To multiply 0x1e by 0x06, 20 0x14 ---> 00010100 x 6 x 0x06 ---> 00000110 --- ---- -------- 000101000 Shift by 1 bit 000101000 Shift by 2 bits ------------ 120 0x78 <--- 0001111000 Only the rightmost eight bits are retained in the answer. Any bits to the left of these 8 bits are called overflow bits. In case any of the overflow bits are nonzero, an overflow has occurred and the rightmost eight bits which are retained in the answer are invalid. Because integer arithmetic operations are not checked for overflow in the C language, it is possible to obtain an incorrect answer when two numbers are multiplied or added. For example, when we multiply 58 and 39 and we store the result as unsigned char (8 bits), we obtain the answer 214 when the actual answer is 2262. The following calculation shows why: 58 0x3a ---> 00111010 x 39 x 0x27 ---> 00100111 -- ---- -------- 00111010 00111010 00111010 00111010 ------------- 0100011010110 Retain eight low order bits Only the rightmost eight bits 11010110 (hex 0xd6 or 214 decimal) are retained. Division is also performed as it is for decimal numbers. Unlike base 10 long division, no guesswork is involved to decide how many times the divisor goes into the trial dividend. Either it goes (quotient = 1) or it doesn't (quotient = 0). As an example, divide 213 (binary 1101010, hex 0xd5) by 9 (binary 00001001, hex 0x09). 10111 <-- quotient -------- 1001 ) 11010101 10010000 -------- 1000101 100100 ------- 1111 1001 ---- 110 <-- remainder The answer is 23 (binary 00010111, hex 0x17) with a remainder of 6 (binary 00000110). Exercise Convert the following hex numbers to binary, perform the following operations, and convert back. 0x45 + 0x3f, 0x5a + 0x74, 0xe2 - 0xaf, 0xa4 - 0x9c, 0x0a x 0x2f, 0x47 x 0x1b, 0xc4 / 0x2e, 0xbe / 0x19 5. Representation of Negative Numbers To represent negative numbers, we use the analogy of an automobile odometer. Because an odometer display has only five decimal digits to the left of the decimal point, only numbers in the range 0 to 99999 can be shown even though the actual number of miles may be much greater. The number 0 represents 0, 100000, 200000, etc., but it can also represent the negative numbers -100000, -200000, etc. The number 99999 represents 199999, 299999, and also -1, -100001, -200001, etc. By adopting the convention that 1 to 99999 represent positive numbers and 50000 to 99999 represent negative numbers, all numbers from starting from -50000 to 49999 can be represented. In the case of 8 bit binary numbers, we let 00000000 through 01111111 represent positive numbers and 10000000 through 11111111 represent negative numbers. By this convention, if the leftmost bit is 0, the number is positive, and if the leftmost bit is 1, the number is negative. In this way, an 8 bit binary number can represent all integers between -128 and 127. Such a representation is called a signed integer. The following table shows how to represent negative numbers in binary. Binary Hex Decimal 01111111 7f 127 01111110 7e 126 .. .. .. 00000010 02 2 00000001 01 1 00000000 00 0 11111111 ff -1 11111110 fe -2 .. .. .. 10000001 81 -127 10000000 80 -128 Converting a an eight bit binary positive number into the corresponding negative one involves subtracting it from 100000000. (The eight bit representation of 100000000 is 00000000.) For example, to convert 0x05 = 00000101 to a negative number, subtract it from 100000000 to obtain 11111011. This operation is called obtaining the two's complement of a binary number. In general the two's complement of a binary number is formed by subtracting it from 2n where n is the number of bits. Another way of performing the two's complement is to complement each digit (replace 0 by 1 and 1 by 0 ) and add 1 to the result. The complement of 00000101 is 11111010 and adding 1 produces 11111011. To verify that these numbers are actually negatives of each other, we can add them to see that the sum is 100000000 = 00000000 when truncated to eight bits. The beauty of two's complement arithmetic is that no special rules are needed to accommodate negative numbers. Merely perform the operation and keep the rightmost eight bits. Here are some examples: - 29 ---> 11100011 + 42 ---> 00101010 ---- -------- 13 <--- 00001101 -29 ---> 11100011 - (-42) ---> 11010110 ----- -------- 13 <--- 00001101 (-6) ---> 11111010 x (-5) ---> 11111011 ----- -------- ...111111111111010 ...11111111111010 ...111111111010 ...11111111010 ...1111111010 ...111111010 ...11111010 --------- retain 30 <--- ...000000000011110 8 bits 6. Bitwise Operations In addition to the 4 basic operations discussed in Section 3, C also allows the following operations: bitwise and ( & ), bitwise or ( | ), bitwise exclusive or ( ^ ), and bitwise complement (~). These bitwise operations are defined by the following tables. xyx&y000100010111 xyx | y000101011111 xyx ^ y000101011110 x! x011 0 For eight bit binary numbers, these operations are performed on each column of bit pairs separately. For example, to compute 52 & 45, first convert to binary, perform the bitwise and 00110100 & 00101101 = 00100100, and convert back to decimal which gives 36. The bitwise and is useful for isolating certain bits in a binary number to use in further computations. In the implementation of MACHINE-16 which is discussed in Sections 7 to 9, an eight bit machine instruction can be broken down into two parts, the opcode which consists of bits 1 to 4, and the addressing mode which consists of bits 7 and 8. (Bits 5 and 6 will not be used in our implementation.) To isolate the opcode, we can perform a bitwise and with the mask 0xf0 = 11110000. The bits 1 to 4 will remain unchanged, but the bits 5 to 8 will be changed to zero. This can be performed by the C statement opcode = instruction & 0xf 0; To obtain the addressing mode, use the statement mode = instruction & 0x03; because 0x03 = 00000011. Exercises 1. Find the values of the following expressions: 0x75 & 0xfb, 0x3c | 0xe9, 0xfa ^ 0xa5, ~c7 2. In a hypothetical operating system, the bits 5 to 27 in the the 4 byte integer variable psw (processor status word) represent the state of the system. The 32 bits are numbered from 0 to 31 from left to right. Write a hex mask which will isolate these bits (Hint: First write the mask in binary). 7. Introduction to MACHINE-16 The MACHINE-16 is a simple hypothetical stored memory computer which has 64 bytes of memory and 16 instructions. Its capabilities are comparable to the earliest computers built in the 1930's, but it is thousands of times faster because it will be implemented on a modern computer. The memory can be thought of as an array of bytes (sometimes called cells) with addresses numbered 0x00 to 0x3f. This memory array will be represented by the global array of char. We will refer to each byte as a memory cell which will be abbreviated as MC. Here is an example: 01010110 01001001 00101001 00101001 01001010 10010100 ... MC 0 MC 1 MC 2 MC 3 MC 4 MC 5 ... Memory cells with addresses 0x00 and 0x01 (referred to in the C program as mem[0] and mem[1]) each have a special purpose. The memory cell with address 0x00 is called the program counter (PC) and is used to hold the address of the instruction which is currently executing. (This will make sense later when you see what the instructions are.) The memory cell with address 0x01 is called the accumulator (AC) and is used to hold the result of an arithmetic operation. A MACHINE-16 instruction consists of two bytes (four nibbles or 16 bits). The first nibble is the opcode and the second nibble is the addressing mode. The table below describes the 16 MACHINE-16 opcodes. In these descriptions, PC refers to the program counter, AC refers to the accumulator. The opcodes are referred to as 0x00, 0x10, 0x20 rather than 0x0, 0x1, 0x2b because the second nibble is cleared to zero using a bitmask (see Section 9). OpcodeMnemonicMeaning0x00STOPexit(1);0x10LOADAC = MC;0x20STOREMC = AC;0x30CLEARMC = 0;0x40INCRMC++;0x50DECRMC--;0x60ADDAC += MC; 0x70SUBTAC -= MC;0x80MULTAC *= MC;0x90DIVAC /= MC;0xa0JUMPJump to address in MC0xb0BGZIf AC > 0 jump to  address in MC0xc0PRINDPrint MC as int0xd0PRINCPrint MC as char0xe0SCANDRead MC as int0xf0SCANCRead MC as char The second byte (nibbles 3 and 4) of the instruction determines the memory cell (MC) which contains the information to be used by the instructions 0x00, 0x60, 0x70, 0x80, 0x90, 0xa0, 0xb0, 0xc0, and 0xd0. It can also determine the address where information is to be put (instructions 0x20, 0x30, 0xe0, 0xf0). In the preceding table of operands, the symbol = means assignment as in C++, ++ means increment, and -- means decrement. The symbols +=, -=, *=, and /= have the same meanings as the corresponding C++ assignment operators. We distinguish between assignment (A=5;) and initialization (char A=5;) in exactly the same way that the C++ language does. The addressing mode is the second nibble of the instruction and determines how to find the memory cell on which the instruction operates MC from the operand. The four possible addressing modes are shown in the following table, and are discussed in Section 8. Addressing Mode Mode Name 0x00 IMMEDIATE 0x01 DIRECT 0x02 INDIRECT 0x03 DINDIRECT For simplicity, we only discuss the IMMEDIATE addressing mode in this section, which has the code 0x00. If the addressing mode is IMMEDIATE, the address of MC is one greater than the address of the current instruction. In other words, the operand contains literally the value to be supplied to the instruction. In the IMMEDIATE mode, the operand is used as a literal constant. For example, the following diagram shows the memory cells 0x00 to 0x07. Since the value of PC is 0x03, the instruction in cell 0x03 executes. The left nibble is 0x6 which means ADD. The right nibble is 0x0 which means IMMEDIATE addressing mode. We denote the opcode as 0x60 to show that the addressing mode has been zeroed out and the addressing mode as 0x00. Next the PC is incremented by one byte so that it has the value 0x04 and it contains the address of the operand. Since the operand contains 0x05, this literal value is added to AC which contains 0x07, so the new value of AC is 0c or decimal 12. 00 01 02 03 04 05 06 07 opcode: address byte 03, nibble 1, value 60 +--+--+--+--+--+--+--+--+ mode: address byte 03, nibble 2, value 03 |03|07|00|60|05|00|00|00| operand: address byte 04, value 05 +--+--+--+--+--+--+--+--+ Even though the IMMEDIATE mode is a legal addressing mode for all instructions, there are 3 instructions for which this mode is not generally useful. These instructions are STORE, SCAND, and SCANC. These three instructions all deposit a value in MC which will overwrite the operand if the mode is IMMEDIATE. The instructions INC and DEC are also not very useful in IMMEDIATE mode because they change the value of the operand. For these instructions one of the other operating modes discussed in Section 8 is more appropriate. We now look at two examples of programs written in the MACHINE-16 language. These examples use only the IMMEDIATE addressing mode. Program 1: Add the numbers 5 and 7 and put the result in AC. The sequence of instructions is LOAD 5 IMMEDIATE Load the literal value 5 into AC ADD 7 IMMEDIATE Add the literal value 7 to AC, the answer is in AC STOP 0 Stop execution, 0 is a dummy operand. To actually run program 1 (see Source Code for Program 1 below) on the MACHINE-16 simulator we need to translate the mnemonic instructions into hex numbers. These numbers will occupy the first two characters of each line of the source file. The source code contains six columns: the machine instructions and operands, the address, the label, the mnemonic, the addressing mode, and the equivalent C instruction. Of all these columns, only the first is read by MACHINE-16. There must also be no blank lines in the source code. As mentioned earlier, the first memory location (address 0x00) is the program counter (PC) and the second location (address 0x01) is the accumulator (AC). (Pay special attention to this point. A common mistake when writing MACHINE-16 programs is to begin numbering the addresses at 0x01 rather than at 0x00.) The PC is initialized to the starting address of the program. For this example, we start the program at address 2, immediately after the PC and the AC. The accumulator AC can be initialized to any value, say 0. The complete source code for program 1 is shown is as follows: Source Code for Program 1: Add the numbers 5 and 7 and put the result in AC. 02 00 PC: START char PC = START, 00 01 AC: 0 char AC = 0; 10 02 START: LOAD IMMEDIATE AC = 5; 05 03 5 60 04 ADD IMMEDIATE AC += 7; 07 05 7 00 06 STOP IMMEDIATE exit(1); 00 07 0 To run this program use a text editor to create a file named file.sou. You can replace the name file with any name you want, but you must have the .sou extension which indicates that it is source code for MACHINE 16. Then type mach file at the DOS prompt to run the machine. See your instructor for details of how to obtain the executable for MACHINE 16. Dump for Program 1. 0 1 2 3 4 5 6 7 8 9 a b c d e f +-------------------------------------------------+ 00 | 02 00 10 05 60 07 00 00 00 00 00 00 00 00 00 00 | 10 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | 20 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | 30 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | +-------------------------------------------------+ MC MC COUNTER PC INSTRUC OPCODE MODE PC ADDRESS CONTENTS AC ======= == ======= ====== ==== == ======= ======== == 1 02 10 10 00 03 03 05 05 2 04 60 60 00 05 05 07 0c 3 06 00 00 00 07 07 00 0 1 2 3 4 5 6 7 8 9 a b c d e f +-------------------------------------------------+ 00 | 07 0c 10 05 60 07 00 00 00 00 00 00 00 00 00 00 | 10 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | 20 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | 30 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | +-------------------------------------------------+ The dump will be written to the file named file.dmp. The dump shows the state of memory immediately after the instructions are loaded from the source file. The contents of all 64 memory locations (00-63) are shown. To find, for example, the contents of the cell with address 0x2a, look in the row 20 and the column a. We see that the contents are 00. After the initial dump, a detailed program trace is shown. The meanings of each column in the trace are as follows: the COUNTER sequentially numbers the instruction executions. In the current implementation of MACHINE-16, a maximum of 200 instruction execution steps are allowed to prevent infinite loops which will fill up the file system. The PC is the current value of the program counter. A valid program may also exceed the 200 step limit, but this will be rare because the programs we will be executing are short. This instruction is then broken up into the OPCODE and the addressing MODE which are shown next. If the addressing mode is IMMEDIATE, the PC is now incremented by 1 to read the operand, so PC is listed again to be sure that its value has actually changed. If the value of MODE is 0 (IMMEDIATE), the value of this address is set to be the current value of the PC because this is the address containing the operand. Finally the value of the accumulator AC is shown. The value of AC is not shown for the STOP instruction 3 because the program exits before the final value of AC is printed. After the program terminates because of the STOP instruction, a final dump is shown of the memory locations immediately after program termination. In this case, the dump is identical to the preliminary dump except for the change in the value of AC; it has been changed from 0x00 to 0x0c (decimal 12), the result of 5+7. This shows that the program has performed correctly. The dump and program trace are valuable tools for debugging MACHINE-16 programs. Program 2: Print the message HELLO. MACHINE-16 is not limited to numeric computations. The Program 2 shows how to use it to print the message HELLO to the screen. A new line character (ASCII code 0x0a) is printed at the end of the message so that the prompt ends up at the beginning of the next line. The dump shows that the only memory location which has changed is the PC which has changed from its initial value 0x02 to 0x0f, the address after the STOP instruction. Use the following table assist you in translating characters into their hexadecimal ASCII codes. A Table of ASCII Codes. char dec hex char dec hex char dec hex char dec hex \0 0 00 32 20 @ 64 40 ` 96 60 ^A 1 01 ! 33 21 A 65 41 a 97 61 ^B 2 02 " 34 22 B 66 42 b 98 62 ^C 3 03 # 35 23 C 67 43 c 99 63 ^D 4 04 $ 36 24 D 68 44 d 100 64 ^E 5 05 % 37 25 E 69 45 e 101 65 ^F 6 06 & 38 26 F 70 46 f 102 66 \a 7 07 ' 39 27 G 71 47 g 103 67 \b 8 08 ( 40 28 H 72 48 h 104 68 \t 9 09 ) 41 29 I 73 49 i 105 69 \n 10 0a * 42 2a J 74 4a j 106 6a \v 11 0b + 43 2b K 75 4b k 107 6b \f 12 0c , 44 2c L 76 4c l 108 6c \r 13 0d - 45 2d M 77 4d m 109 6d ^N 14 0e . 46 2e N 78 4e n 110 6e ^O 15 0f / 47 2f O 79 4f o 111 6f ^P 16 10 0 48 30 P 80 50 p 112 70 ^Q 17 11 1 49 31 Q 81 51 q 113 71 ^R 18 12 2 50 32 R 82 52 r 114 72 ^S 19 13 3 51 33 S 83 53 s 115 73 ^T 20 14 4 52 34 T 84 54 t 116 74 ^U 21 15 5 53 35 U 85 55 u 117 75 ^V 22 16 6 54 36 V 86 56 v 118 76 ^W 23 17 7 55 37 W 87 57 w 119 77 ^X 24 18 8 56 38 X 88 58 x 120 78 ^Y 25 19 9 57 39 Y 89 59 y 121 79 ^Z 26 1a : 58 3a Z 90 5a z 122 7a ^[ 27 1b ; 59 3b [ 91 5b { 123 7b ^\ 28 1c < 60 3c \ 92 5c | 124 7c ^] 29 1d = 61 3d ] 93 5d } 125 7d ^^ 30 1e > 62 3e ^ 94 5e ~ 126 7e ^_ 31 1f ? 63 3f _ 95 5f ^? 127 7f Source Code for Program 2: Print the Message Hello. 02 00 PC: START char PC = START, 00 01 AC: 0 AC = 0, d0 02 START: PRINC IMMEDIATE cout << H; 48 03 'H' /*'H' == 0x48*/ d0 04 PRINC IMMEDIATE cout << 'E'; 45 05 'E' /*'E' == 0x45*/ d0 06 PRINC IMMEDIATE cout << 'L'; 4c 07 'L' /*'L' == 0x4c*/ d0 08 PRINC IMMEDIATE cout << 'L'; 4c 09 'L' /*'L' == 0x4c*/ d0 0a PRINC IMMEDIATE cout << 'O'; 4f 0b 'O' /*'O' == 0x4f*/ d0 0c PRINC IMMEDIATE cout << '\n'; 0a 0d '\n' /*'\n'== 0x0a*/ 00 0e STOP exit(1); 00 0f #0 Dump for Program 2 0 1 2 3 4 5 6 7 8 9 a b c d e f +-------------------------------------------------+ 00 | 02 00 d0 48 d0 45 d0 4c d0 4c d0 4f d0 0a 00 00 | 10 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | 20 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | 30 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | +-------------------------------------------------+ COUNTER PC INSTRUC OPCODE MODE PC ADDRESS CONTENTS AC ======= == ======= ====== ==== == ======= ======== == 1 02 d0 d0 00 03 03 48 00 2 04 d0 d0 00 05 05 45 00 3 06 d0 d0 00 07 07 4c 00 4 08 d0 d0 00 09 09 4c 00 5 0a d0 d0 00 0b 0b 4f 00 6 0c d0 d0 00 0d 0d 0a 00 7 0e 00 00 00 0f 0f 00 0 1 2 3 4 5 6 7 8 9 a b c d e f +-------------------------------------------------+ 00 | 0f 00 d0 48 d0 45 d0 4c d0 4c D0 4f d0 0a 00 00 | 10 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | 20 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | 30 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | +-------------------------------------------------+ Exercises 1. Write a program which will compute the expression (-2+8)*(3+13) and print out the answer. 2. Print out a message of your choice. 8. Addressing Modes We have already discussed the IMMEDIATE addressing mode in the last section. In this section we introduce the DIRECT and INDIRECT addressing modes. The following Figure illustrates the four addressing modes. Recall that the opcode 0x60 means ADD. In this Figure, 6 is the opcode and 0 is the addressing mode, so the operand 02 is contained in the address immediately following the instruction in the address 04, which means that the literal constant 02 is added to the value of AC which is 05, changing AC to 07. Here are illustrations of the four addressing modes: In each case, the addressing mode is the second nibble of the byte at address 0x03. 00 01 02 03 04 05 06 07 +--+--+--+--+--+--+--+--+ |03|05|07|60|02|06|02|05| IMMEDIATE +--+--+--+--+--+--+--+--+ PC AC ^ 00 01 02 03 04 05 06 07 +--+--+--+--+--+--+--+--+ |03|05|07|61|02|06|02|05| DIRECT +--+--+--+--+--+--+--+--+ ^ | +----+ 00 01 02 03 04 05 06 07 +--+--+--+--+--+--+--+--+ |03|05|07|62|02|06|02|05| INDIRECT +--+--+--+--+--+--+--+--+ |^ | ^ |+----+ | +---------------+ 00 01 02 03 04 05 06 07 +--+--+--+--+--+--+--+--+ |03|05|07|63|02|06|02|05| DINDIRECT +--+--+--+--+--+--+--+--+ |^ | ^ |^ |+----+ +----+| +---------------+ To implement variables, the DIRECT addressing mode is most useful. In this case, the operand does not contain a literal constant, but the address of a variable. The operand contains 02 which is used as an address to obtain the value 07 which is in memory cell 02. This value 07 is now added to the value 05 in AC to obtain 0c (decimal 12). When pointers are necessary, we use the INDIRECT addressing mode, which uses the address stored at the opcode as the address containing the value of interest. In other words, you don't use the address contained in the operand to find the value of interest, you use the address in the operand as the address of the value you want, just like ordinary pointers in C++. The mode 02 denotes INDIRECT addressing, the operand contains the address 02, memory location 02 contains the address 07 which contains the value 05. This is added to the 05 in AC to produce 0a. The DINDIRECT (double indirect) addressing mode which is needed to implement double pointers (declared as char **p;. or char *p[]; in C++). Double pointers are used in situations such as the address of the beginning of an array of pointers. We will not discuss the DINDIRECT addressing mode in CSC310. Program 3: Adding two variables using the DIRECT addressing mode. This program which initializes variables to values of 5 and 7, adds the contents of these variables, and prints the result as a decimal number. The DIRECT mode must be used because the operand of the ADD command does not contain the literal value to be added, but contains the address of the variable which contains the value. This output is printed at the screen, even though the dump is sent to the dump file. If you want to save the output in a file, redirect the output as usual from the DOS prompt mach file > file.out Source Code for Program 3: Adding Two Variables using DIRECT addressing mode. 04 00 PC: START char PC = START; 00 01 AC: 0 char AC = 0; 05 02 X: 5 char X = 5; 07 03 Y: 7 char Y = 7; 11 04 START: LOAD DIRECT AC = X; 02 05 X 61 06 ADD DIRECT AC += Y; 03 07 Y c1 08 PRIND DIRECT cout << int(AC); 01 09 AC 00 0a STOP IMMEDIATE exit(1); 00 0b 0 The label X denotes the address of the variable X, which is 0x02. The address of Y is 0x03. This example illustrates that MACHINE-16, like other Von Neumann digital computers, makes no distinction between data and instructions in its memory cells; everything is merely eight bit binary numbers. It is up the program to interpret these numbers. The dump is shown in next and the output from the program to the screen is 12, which is 5+7. Dump for Program 3: 0 1 2 3 4 5 6 7 8 9 a b c d e f +-------------------------------------------------+ 00 | 04 00 05 07 11 02 61 03 c1 01 00 00 00 00 00 00 | 10 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | 20 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | 30 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | +-------------------------------------------------+ MC MC COUNTER PC INSTRUC OPCODE MODE PC ADDRESS CONTENTS AC ======= == ======= ====== ==== == ======= ======== == 1 04 11 10 01 05 02 05 05 2 06 61 60 01 07 03 07 0c 3 08 c1 c0 01 09 01 0c 0c 4 0a 00 00 00 0b 0b 00 0 1 2 3 4 5 6 7 8 9 a b c d e f +-------------------------------------------------+ 00 | 0b 0c 05 07 11 02 61 03 c1 01 00 00 00 00 00 00 | 10 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | 20 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | 30 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | +-------------------------------------------------+ Program 4: Adding Together the Elements of an Array. The fourth example of a MACHINE-16 program is one that adds together all the elements of an array. To reference the elements of the array, the pointer P is used which is initialized to the address ARRAY and then is incremented so that it points to each of the array elements in turn. The command BGZ in address 0x16 checks to see if P is beyond the end of the array, and if it is, the program prints the value of the sum and stops. Note that the INDIRECT addressing mode is used in the ADD command in address 0x0c because P does not contain the value of the to be added to SUM, it contains the address where the value is to be found in the array. Source Code for Program 4: Adding Together the Elements of an Array. 0a 00 PC: START char PC = START; 00 01 AC: 0 char AC = 0; 01 02 ARRAY: 1 char ARRAY[] = {1, 03 03 3 3, 05 04 5 5, 07 05 7 7, 09 06 LAST: 9 9}; 05 07 N: 5 char N = 5; 02 08 P: ARRAY char P = ARRAY; 00 09 SUM: 0 char SUM = 0; 11 0a START: LOAD DIRECT AC = SUM; 09 0b SUM 62 0c ADD INDIRECT AC += *P; 08 0d P 21 0e STORE DIRECT SUM = AC; 09 0f SUM 41 10 INCR DIRECT P++; 08 11 P 11 12 LOAD DIRECT AC = P; 08 13 P 70 14 SUB IMMEDIATE AC -= LAST; 06 15 LAST b0 16 BGZ IMMEDIATE if (AC > LAST) goto END; 1a 17 END a0 18 JMP goto START; 0a 19 START c1 1a END: PRIND DIRECT cout << int(SUM); 09 1b SUM 00 1c STOP 00 1d 0 Dump for Program 4: 0 1 2 3 4 5 6 7 8 9 a b c d e f +-------------------------------------------------+ 00 | 0a 00 01 03 05 07 09 05 02 00 11 09 62 08 21 09 | 10 | 41 08 11 08 70 06 b0 1a a0 0a c1 09 00 00 00 00 | 20 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | 30 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | +-------------------------------------------------+ Trace omitted .... 0 1 2 3 4 5 6 7 8 9 a b c d e f +-------------------------------------------------+ 00 | 1d 01 01 03 05 07 09 05 07 19 11 09 62 08 21 09 | 10 | 41 08 11 08 70 06 b0 1a a0 0a c1 09 00 00 00 00 | 20 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | 30 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | +-------------------------------------------------+ Program 5: Computing the first ten Fibonacci numbers. The final example we discuss in this Section is a program which prints out the first 10 Fibonacci numbers. Recall that a Fibonacci number is defined by the recurrence relation x1 = 0 x2 = 1 xn = xn-1 + xn-2, when n>2. For example, if we have already computed x3 = 2, x4 = 3, and x5 = 5, then x6 = x5 + x4= 5+3 = 8. We can write a C program to compute the first 12 Fibonacci numbers as follows: void main() { int a=0, b=1, c, n; for (n=10; n>0; n--) { c = a + b; a = b; b = c; cout << c << endl; } } The first 12 Fibonacci numbers are 0, 1, 1, 2, 3, 5, 8, 11, 19, 30, 49, 79. We initialize n to 10 because we don't print the first two numbers in the sequence. We can't calculate more terms even if we wanted to with 8 bit memory cells because the next number in the sequence is 128 which would cause an overflow. Source Code for Program 5: Compute the First 12 Fibonacci numbers. 06 00 PC: START char PC = START; 00 01 AC: 0 char AC = 0; 00 02 A: 0 char A = 0; 01 03 B: 1 char B = 1; 00 04 C: 0 char C = 0; 0a 05 N: 10 char N = 10; 11 06 START: LOAD DIRECT AC = A; 02 07 A 61 08 ADD DIRECT AC += B; 03 09 B 21 0a STORE DIRECT C = AC; 04 0b C 11 0c LOAD DIRECT AC = B; 03 0d B 21 0e STORE DIRECT A = AC; 02 0f A 11 10 LOAD DIRECT AC = C; 04 11 C 21 12 STORE DIRECT B = AC; 03 13 B c1 14 PRIND DIRECT cout << int(C); 04 15 C d0 16 PRINC IMMEDIATE cout << \n; 0a 17 '\n' 51 18 DECR DIRECT N--; 05 19 N 11 1a LOAD DIRECT AC := N; 05 1b N b0 1c BGZ IMMEDIATE if (AC>0) 06 1d START goto start; 00 1e STOP IMMEDIATE exit(1); 00 1f 0 Dump for Program 5: 0 1 2 3 4 5 6 7 8 9 a b c d e f +-------------------------------------------------+ 00 | 06 00 00 01 00 0a 11 02 61 03 21 04 11 03 21 02 | 10 | 11 04 21 03 c1 04 d0 0a 51 05 11 05 b0 06 00 00 | 20 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | 30 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | +-------------------------------------------------+ ...... Trace omitted 0 1 2 3 4 5 6 7 8 9 a b c d e f +-------------------------------------------------+ 00 | 1f 00 37 59 59 00 11 02 61 03 21 04 11 03 21 02 | 10 | 11 04 21 03 c1 04 d0 0a 51 05 11 05 b0 06 00 00 | 20 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | 30 | 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 | +-------------------------------------------------+ Exercises 1. Write MACHINE-16 source code to perform the following tasks. 2. Write a MACHINE-16 program which will read two decimal numbers at the keyboard (Instruction SCANF), add then, and print out the result. 3. Read a decimal number and print out its absolute value. 4. Read A and B in at the keyboard and print out A mod B which is computed by A - (A / B) * B The symbol / represents integer division. Compute the length of a line of characters entered at the keyboard. The line should be terminated by \n which is 0x0a. 6. Add up all numbers from 1 to 12 using a loop. 7. Compute terms of the recurrence relation until a negative result denoting overflow is encountered. x1 = 0 x2 = 3 x3 = 1 xn = xn-1 + 2xn-2 + xn-3 ( PAGE  PAGE 1 7PQptqr  ?@YZtuk!!!"o"p".$$&'^*_**++#,$,D,E,=.@.].`.k.l...j////,0`0000>1?111123D444d567$8%8-:.:;5OJQJOJQJNH5CJ5CJ5CJ 56Y7CPQop6Yrst  op:;$$$7CPQop6Yrst  op:; g h a b ^ _ abcjk ! )4BNZjk'*, c; g h a b ^ _ abcjk $ ! )4BNZjk$$  E{ $$'*,4;<Ld|$$l tu )V$$D$$l tru )V     ,4;<ORTV]^gjl!!"".$0$A$T$d$t$$$$$$$$$(%)%&8&W&v&&&&&'5'U'u'''((********+++(+5+B+O+\+i+v++++++,, ,,,, c<ORTV]^gjl$$l tu )V$$!!"".$0$A$T$d$t$$$$$ 8 $$D$$l tru )V     $$$$$$$(%)%&8&W&v&&&&&'5'U'u'''((**** Nr $$ 8*****+++(+5+B+O+\+i+v++++++,, ,,,,,#,$$$ Nr ,,#,$,(,,,0,4,8,<,@,D,E,F,H.....3/4/j//////,0_0`000000112*2B2w2x2222227333334D4F4445=5d5e5~66666,7e7777-:.:T:z::::;0;V;;;;;#=:=;=l=====>>>a>>>>  b#,$,(,,,0,4,8,<,@,D,E,F,H.....3/4/j//////,0_0$$$$$$ld4 tD_0`000000112*2B2w2x2222227333334D4F444$$ & F$45=5d5e5~66666,7e7777-:.:T:z::::;0;V;;;; $ $$;;;L<M<:=??[?f??9@:@`@AAD,F4FBFCFHHDHEHhJiJqJMMM!N"NNNOOS&S'S5SRS]SSSTTUUNWWXYYYZZg[ ]```3accdd-e.efhh iiMjNj!k"kkkll]nynnnopCJ5CJ NHOJQJH*5CJOJQJ5CJOJQJNHOJQJU;;#=:=;=l=====>>>a>>>>??[?\?e?f??@9@:@`@a@D$$>??[?\?e?f??@9@:@`@a@DD E&EBE^EzEEEEEF"FAFBFCFIIpJJJJKK?KhKKKKKKL7L`LLLLLMOBOCOEOGOHOKOMONOOOPOQS5SQSRS\S]SSSSTTTTUUVMWNWWWWYYe[g[h[o[x[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\ \\\\\#\ c(O*O,O-O/O1O3O4O6O8O:O;OOBOCOEOGO#$$l t0\Q  $.$$l tF/d   $$l t /d$$GOHOKOMONOOOPOQS5SQSRS\S]SSSSTTTTUU$$#$$l t0\Q  $$$$l t\QUVMWNWWWWYYe[g[h[o[x[[[[[[[[PP$$l t bV.$$l tFbV   $$$$[[[[[[[[[[[[[[[[[[[[[[\ \\\\\TPDDTTT$$l t bV$$\#\(\2\3\8\<\F\G\L\Q\g\h\m\q\\\\\\\\\\\\\\PtPpt$$l t bV$$#\(\2\3\8\<\F\G\L\Q\g\h\m\q\\\\\\\\\\\\\\\\\\\\\] ] ] ] ] ]]__````aa2a4asbtb-e.eueefffhhhhi iXiiiiil l\n]nnnnoBoUooooooppEqFqZq[qqqr:rrrrrs c\\\\\\\\] ] ] ] ] ]]__````lp ' $$.$$l tFbV   $$$$l t bV`aa2a4asbtb-e.eueefffhhhhi iXiiiiil l\n]n$$ ' ]nnnnoBoUooooooppEqFqZq[qqqr:rrrrrsTsss$$ppFqZq[qu#v$vwwXxYx.y/yyyc|d|m}w}]~^~Ň&0fs̐?@i89 ]^șə*+23PoqGHAWX ϩЩqr CJOJQJ 5OJQJCJOJQJNH5CJOJQJ5CJOJQJUsTsss t@tAtxttt uXuuuu/w0wCzDz{{l}}}D7t+h#`ڃT΄ H…<y0mBrو@wމEvΊ.f֋F~6s*ges t@tAtxttt uXuuuu/w0wCzDz{{l}}}D$$7t+h#`ڃT΄ H…<y0m$Brو@wމEvΊ.f֋F$F~6s*gԎ D|$&01f̐$Ԏ D|$&01f̐͐ޒߒij,-Szϔ 0Wԕ !GnƖ89ؚٚ RSPpqž Lx-Fo@WXǢ7oߣQˤEz{"Ze̐͐ޒߒij,-Szϔ 0Wԕ !Gn$$nƖ89ؚٚ RSPpqž Lx$$-Fo@WXǢ7oߣQˤEz{"Z$$ʦ9:ϩЩGsת ;nȫ1Zk٬"Mp,L`qr'_ϯSð3k۱ܱײزֳݳ)023oq:d߶4Zjȷeʦ9:ϩЩGsת ;nȫ1Zk٬$$"Mp,L`qr'_ϯSð3$3k۱ܱײزֳݳ)023oq$$IJŲ˲βҲղ !"./3489.12oqйѹo)-5<ٿڿ  !#$*+,-.20JmH0J j0JU jCJ5NH CJOJQJOJQJH*5CJL:d߶4Zjȷط>N|Ҹ,G$ȷط>N|Ҹ,GoйѹN.fg|}$\̼QR߽o<=op׿ؿ#./2 BGoйѹN.fg|}$\̼QR$R߽o<=op׿ؿ!"#./01&`#$$ & F$12$0 / =!"#$% [$@$NormalmH J@J Heading 1 $<5CJKHOJQJkHH@H Heading 2 $<56CJOJQJkHB@B Heading 3 $<CJOJQJkHF@F Heading 4 $<5CJOJQJkH<A@<Default Paragraph Font$/@$List h(2@(List 2 (3@(List 3 86@" List Bullet 2h & F>Th6D@26 List Continue hx:E@B:List Continue 2 x."@.Caption xx5B>@bBTitle $<5CJ KHOJQJkH*B@r* Body Textx<C@<Body Text Indent hx*Q@* Body Text 3*O* Body Text 5<J@<Subtitle $<CJOJQJkH, @,Footer  !&)@& Page Number2                 ^  E(0;qFNKfW-almy% Aѵ2'Y)  w &  $ ;p2; <$*#,_04;DKNN O(OGOU[\\`]nsF̐n3GR12,,>O#\sȷ22 !!=A&"~cf Sbj m n u .56@GM ai#&KNcf !$=*@*AAAAII)J0Jq@qAqCqDqFqGqIqJqLqMqOqPqRqSqUqaqcqdqfqgqiqjqlqmqoqpqrqsquqvqxqyq{q|q~qqqqqqqqqqqqq{{{{{{{{ | |\~]~eīЄ37hl‡ćŇLJȇʇˇ͇·ЇчӇ߇  "#%&()+,./124578:;=>@AC"$NP_aȉʉىۉBDSU?AMOPRSUVXY[\^_abdeghjkmnpqstvwy‹ËŋƋȋɋˋ̋΋ϋыҋԋՋ׋؋ڋۋ݋ދgo $'$  "#%&()+,./124@BCEFHIKLNOQRTUWXZ[]^`acdfgijlxz{}~ȠʠBD]_cenp+-.0134679:<=?@BCEFHIKLNOQRTUWcefhiklnoqrtuwxz{}~¢ĢŢǢԦզ89jkکީ"%TVWYZ\hjkmnpqstvwyz|}ëīƫǫɫʫ̫ !"$%'(*+-.0<>?ABDEGHJKMNPQSTVWYZ\]_`bcefhȭѭ4=W`îŮu~#'@IlptwZ\Ƕɶʶ̶Ͷ϶жҶӶնֶضٶ۶ܶ޶߶  "#%&()+WYeghjkmnpqstvwyz|}øĸƸǸɸ #-03Preferred Customer)C:\WINNT\Profiles\sjost\Personal\mach.docPreferred Customer)C:\WINNT\Profiles\sjost\Personal\mach.docPreferred Customer)C:\WINNT\Profiles\sjost\Personal\mach.docPreferred Customer)C:\WINNT\Profiles\sjost\Personal\mach.docPreferred Customer)C:\WINNT\Profiles\sjost\Personal\mach.docPreferred Customer)C:\WINNT\Profiles\sjost\Personal\mach.docPreferred Customer)C:\WINNT\Profiles\sjost\Personal\mach.docPreferred Customer)C:\WINNT\Profiles\sjost\Personal\mach.doc Noriko Tomuro*C:\WINNT\Profiles\noriko\Personal\mach.doc John Rogers D:\Teaching\csc310\machine16.doc;$(y_/p@hh56>*CJOJQJo(. @hh56>*CJOJQJo(. ;$_/@\\lance\hprawNe00:winspoolHP LaserJet 5Si MX\\lance\hprawpsXXLetter 4''''\\lance\hprawpsXXLetter 4''''mx2@@GTimes New Roman5Symbol3& Arial71CourierW1 TerminalLucida Console"1h2#2#2#5OJ$0w# Introduction to Binary Computers Preferred Customer John RogersOh+'0   4@ \ h t $ Introduction to Binary Computers IntPreferred Customernrefref Normal.dotu John Rogers2hnMicrosoft Word 8.0n@@"I@"_$I@"_$I5՜.+,D՜.+,h px  Micron Electronics, Inc.BJOw  $ Introduction to Binary Computers Title$ Introduction to Binary Computers  6> _PID_GUIDAN{1657D83F-B516-11D1-B2CD-006097C069F6}  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     "Root EntryHP LaserJet 5Si MX F[ "IPp$I$41Table/k` Std Fan+od`opeEnvelope Monare0nvWordDocumente B6Envelope B5En4Envelope C65Env!e SummaryInformationope C3Envel(nvelope DLE size tDocumentSummaryInformationvelo8nvelope #12Envelo11CompObj #10Envelope #9Note114QuartojS)B4 (JIS)A5A4 SmallA4A3ExecatementLegalLedgerTabloidLetter SmallLetter -;`>`  FMicrosoft Word Document MSWordDocWord.Document.89q