> '` bjbj o$PhTn܅܅$dh̯&UUU(EEEUEUEEEЅlL3ۋED>0nEEEdE 5XnUUUUjodoChapter 17: Conversions for FloatingPoint Formats
This chapter discusses conversion to and from the IBM floating point format. Specifically, the chapter covers the following four topics.
1. Conversion of data in 32bit fullword to a an equivalent value in singleprecision floatingpoint format.
2. Conversion of data in singleprecision floatingpoint to a an equivalent value in 32bit fullword format.
3. Conversion of data in the Packed Decimal format to an equivalent value in doubleprecision floatingpoint format. We shall discuss the problem of locating the decimal point, which is implicit in the Packed Decimal format.
4. Conversion of data in doubleprecision floatingpoint to an equivalent value in Packed Decimal format. This discussion may be a bit general, as the detailed assembler code is somewhat difficult to design.
The true purpose of this chapter is to focus the readers attention on one of the many services provided by the RTS (RunTime System) of a modern compiled highlevel language. This is more of the texts focus on assembler language as a tool to understanding the workings of a modern computer as opposed to being a language in which the reader is likely to program.
The IBM Mainframe FloatingPoint Formats
The first thing to do in this presentation is to give a short review of the IBM Mainframe format for floatingpoint numbers. We might note that the modern Series Z machines, such as the z/10 running z/OS, support three floatingpoint formats: binary floatingpoint (the IEEE standard), decimal floatingpoint, and hexadecimal floatingpoint. The older S/370 series supported only what is called hexadecimal format. This format is so named because the exponent is stored as a power of 16. This chapter will use only two of the standard floatingpoint formats for the S/370: singleprecision (E) and doubleprecision (D).
Each floating point number in this standard is specified by three fields: the sign bit, the exponent, and the fraction. The IBM standard allocates the same number of bits for the exponent of each of its formats. The bit numbers for each of the fields are shown below.
FormatSign bitBits for exponentBits for fractionSingle precision01 78 31Double precision01 78 63In IBM terminology, the field used to store the representation of the exponent is called the characteristic field. This is a 7bit field, used to store the exponent in excess64 format; if the exponent is E, then the value (E + 64) is stored as an unsigned 7bit number. This field is prefixed by a sign bit, which is 1 for negative and 0 for nonnegative. These two fields together will be represented by two hexadecimal digits in a onebyte field.
Recalling that the range for integers stored in 7bit unsigned format is 0 ( N ( 127, we have 0 ( (E + 64) ( 127, or 64 ( E ( 63. The size of the fraction field does depend on the format. Single precision 24 bits 6 hexadecimal digits, Double precision 56 bits 14 hexadecimal digits.
The Sign Bit and Characteristic FieldWe now discuss the first two hexadecimal digits in the representation of a floatingpoint number in these two IBM formats. In IBM nomenclature, the bits are allocated as follows. Bit 0 the sign bit Bits 1 7 the sevenbit number storing the characteristic.
Bit Number01234567Hex digit01UseSign bitCharacteristic (Exponent + 64)Consider the four bits that comprise hexadecimal digit 0. The sign bit in the floatingpoint representation is the 8 bit in that hexadecimal digit. This leads to a simple rule.
If the number is not negative, bit 0 is 0, and hex digit 0 is one of 0, 1, 2, 3, 4, 5, 6, or 7.If the number is negative, bit 0 is 1, and hex digit 0 is one of 8, 9, A, B, C, D, E, or F.
Some Single Precision ExamplesWe now examine a number of examples, using the IBM singleprecision floatingpoint format. The reader will note that the methods for conversion from decimal to hexadecimal formats are somewhat informal, and should check previous notes for a more formal method. Note that the first step in each conversion is to represent the magnitude of the number in the required form X(16E, after which we determine the sign and build the first two hex digits.
Example 1: Positive exponent and positive fraction.
The decimal number is 128.50. The format demands a representation in the form X(16E, with 0.625 ( X < 1.0. As 128 ( X < 256, the number is converted to the form X(162.Note that 128 = (1/2)(162 = (8/16)(162 , and 0.5 = (1/512)(162 = (8/4096)(162.Hence, the value is 128.50 = (8/16 + 0/256 + 8/4096)(162; it is 162(0x0.808.
The exponent value is 2, so the characteristic value is either 66 or 0x42 = 100 0010. The first two hexadecimal digits in the eight digit representation are formed as follows.
FieldSignCharacteristicValue01000010Hex value42The fractional part comprises six hexadecimal digits, the first three of which are 808.The number 128.50 is represented as 4280 8000.
Example 2: Positive exponent and negative fraction.
The decimal number is the negative number 128.50. At this point, we would normally convert the magnitude of the number to hexadecimal representation. This number has the same magnitude as the previous example, so we just copy the answer; it is 162(0x0.808.
We now build the first two hexadecimal digits, noting that the sign bit is 1.
FieldSignCharacteristicValue11000010Hex valueC2The number 128.50 is represented as C280 8000.Note that we could have obtained this value just by adding 8 to the first hex digit.
Example 3: Negative exponent and positive fraction.
The decimal number is 0.375. As a fraction, this is 3/8 = 6/16. Put another way, it is 160(0.375 = 160((6/16). This is in the required format X(16E, with 0.625 ( X < 1.0.
The exponent value is 0, so the characteristic value is either 64 or 0x40 = 100 0000. The first two hexadecimal digits in the eight digit representation are formed as follows.
FieldSignCharacteristicValue01000000Hex value40The fractional part comprises six hexadecimal digits, the first of which is a 6.The number 0.375 is represented in single precision as 4060 0000.The number 0.375 is represented in double precision as 4060 0000 0000 0000.
Example 4: A Full ConversionThe number to be converted is 123.45. As we have hinted, this is a nonterminator.
Convert the integer part.123 / 16 = 7 with remainder 11 this is hexadecimal digit B. 7 / 16 = 0 with remainder 7 this is hexadecimal digit 7.Reading bottom to top, the integer part converts as 0x7B.
Convert the fractional part.0.45 ( 16 = 7.20 Extract the 7,0.20 ( 16 = 3.20 Extract the 3,0.20 ( 16 = 3.20 Extract the 3,0.20 ( 16 = 3.20 Extract the 3, and so on.
In the standard format, this number is 162(0x0.7B33333333...
The exponent value is 2, so the characteristic value is either 66 or 0x42 = 100 0010. The first two hexadecimal digits in the eight digit representation are formed as follows.
FieldSignCharacteristicValue01000010Hex value42The number 123.45 is represented in single precision as 427B 3333.The number 0.375 is represented in double precision as 427B 3333 3333 3333.
Example 5: True 0
The number 0.0, called true 0 by IBM, is stored as all zeroes [R_15, page 41].In single precision it would be 0000 0000.In double precision it would be 0000 0000 0000 0000.
The format of this true zero will be important when we consider conversions to and from the fullword format used for 32bit integers. In particular, note that the bit field interpreted as a singleprecision true zero will be interpreted as a 32bit integer zero.
The structure of the formats facilitates conversion among them. For example, consider the positive decimal number 80.0, which in hexadecimal is X50. Conversion of this to floatingpoint format involves noting that 80 = 64 + 16 = 256((0/2 + 1/4 + 0/8 + 1/16). Thus the exponent of 16 is 2 and the characteristic field stores X42. The fraction field for this number is 0101, which is hexadecimal 5. The representation of the number in the two standard IBM floatingpoint formats chosen for this chapters discussion is as follows.
Single precision (E) format 42 50 00 00
Double precision (D) format 42 50 00 00 00 00 00 00
Conversion from single precision to double precision format is quite easy. Just add 8 hexadecimal zeroes. Conversion from double precision to single precision is either easy or a bit trickier, depending on whether one truncates or attempts to round.
Convert the double precision value 42 50 00 00 11 10 00 00
Simple truncation will yield 42 50 00 00
A reasonable rounding will yield 42 50 00 01
The FloatingPoint Registers
In addition to the sixteen generalpurpose registers (used for binary integer arithmetic), the S/360 architecture provides four registers dedicated for floatingpoint arithmetic. These registers are numbered 0, 2, 4, and 6. Each is a 64bit register. It is possible that the use of even numbers to denote these registers is to emphasize that they are not 32bit registers.
The use of the registers by the floatingpoint operations depends on the precision: Single precision formats use the leftmost 32 bits of a floatingpoint register. Double precision formats use all 64 bits of the register.
To illustrate this idea consider the two data declarations.
EFLOAT DS E Declare a 32bit single precision
DFLOAT DS D Declare a 64-bit double precision
Consider the following instructions that use floatingpoint register 0. Remember that this register holds 64 bits, which is enough for a doubleprecision (D) floatingpoint value.
LD 0,DFLOAT Load the full 64-bit register from the double precision 64-bit value.
LE 0,EFLOAT Load the leftmost 32 bits of the register from the single precision 32-bit value. The rightmost 32 bits of the register are not changed [R_15, page 43].
STD 0,DFLOAT Store the 64 bits from the register into the 64-bit double precision target.
STE 0,EFLOAT Store the leftmost 32 bits of the register into the 32-bit single precision target.
Another Look at TwosComplement Integers
In order to develop the algorithms for converting between twoscomplement integers and floatingpoint formats, we must examine the structure of positive integers from a slightly different viewpoint, one that is of little view in the pure integer world.
We shall focus on conversions for positive fullword integers. As we shall see, handling negative integers is a simple extension of the above. Handling halfword integers is even easier, as we shall use the LH (Load Halfword) instruction to load them into a register. All of our conversions from integer format to floatingpoint format will assume that the integer argument is found in a generalpurpose register.
The fullword conversion code will begin with an instruction such as L R9,FW Load the fullword into register 9
The halfword conversion code will begin with an instruction such as LH R9,HW Load the halfword into register 9, extending the sign to make a fullword.
The handling of negative numbers is quite simple. We first declare a singlecharacter (one byte) area called THESIGN, to hold a representation of the sign in a format that will assist the processing of the resulting floating point number.
For a negative number, THESIGN will be set to X80.For a nonnegative number, its value will be set to X00.
In the code, the location THESIGN would be declared as follows [R_17, page 41].THESIGN DS X1 One byte of storage
Here is a fragment of the code, assuming that the signed integer value is in R9. Note the use of the MVI instruction with the hexadecimal equivalent of a character [R_17, page 41].
MVC THESIGN,=X00 Initialize the sign field CH R9,=H0 Look at the integer value BZ DONE It is zero, nothing to do. BNL NOTNEG Is the value negative?
MVC THESIGN,=X80 Yes, it is negative. LCR R9,R9 Get the absolute value
NOTNEG Now process the positive number in R9.
For ease of illustration I shall discuss the structure of a signed 16bit halfword. As seen above, we may assume that the halfword represents a positive integer.
Hex digit0123Power of 1643210Power of 2161514131211109876543210A0A1A2A3A4A5A6A7A8A9A10A11A12A13A14A15In a signed halfword, the bits A0 through A15 would represent the binary bits of the 16bit integer. As we have specified that we have a positive integer, we know that A0 = 0 and that at least one of the other bits is equal to 1.
The value of the halfword is A0(215 + A1(214 + A2(213 + A3(212 + + A15(20.
Another way to write this would be as follows:
216((A0/2 + A1/4 + A2/8 + A3/16 + + A15/216), which can also be written as
164((A0/2 + A1/4 + A2/8 + A3/16 + + A15/216). This seems to be in a form that is ready for translation into the IBM floatingpoint representation. If one of A1, A2, or A3 is nonzero, this will work. The exponent will be 4 and the fraction A0A1A2A3A15.
Please note that the IBM SinglePrecision FloatingPoint format is a 32bit format, so the above should not be taken literally. It is just an indicator of where we need to go.
The above method, as extended to 32 bits, might work if it were not for the issue of normalization. All IBM floating point standards require that the first two bytes (four hex digits) of the representation be of the following format.
Digit0123ContentsSign bit and 7bit characteristic field holding the exponent.High order bits of the fraction.
At least one non-zero bit.Next four bits of the fraction.In other words, the value of hexadecimal digit 2 cannot be a zero. This is a requirement of the normalized representation, which calls for representing the floatingpoint value in the form 16E ( F, where 1/16 ( F < 1.
In our 16bit example, suppose that the four high order bits are all zero, but that at least one of the next four bits is not zero. What we have is of the following form.
Hex digit0123Power of 1643210Power of 21615141312111098765432100000A0A1A2A3A4A5A6A7A8A9A10A11The value of the halfword is A0(211 + A1(210 + A2(29 + A3(28 + + A11(20.
Another way to write this would be as follows:
212((A0/2 + A1/4 + A2/8 + A3/16 + + A15/212), which can also be written as
163((A0/2 + A1/4 + A2/8 + A3/16 + + A15/212). This seems to be in a form that is ready for translation into the IBM floatingpoint representation. If one of A1, A2, or A3 is nonzero, this will work. The exponent will be 3 and the fraction A0A1A2A3A11.
Before continuing our discussion, let us reflect on a method to detect whether or not the four highorder bits in a register are all zero. For this, we need to turn to the logical AND, which was covered in the last pages of Chapter 12 of this textbook.
The type of instruction I choose to use is the type RX logical AND instruction, N.
LR R8,R9 COPY R9 INTO R8 SO THAT THE FOUR* HIGH ORDER BITS CAN BE TESTED* WITHOUT LOSING THE VALUE. N R8,=XF0000000 MASK OUT THE 4 HIGH ORDER BITS* THE MASK IS F0 00 00 00. BNZ HAVE1 FOUND A 1 BIT.
Note that the block above is that to be used for 32bit integers. The logical AND will raise the zero condition flag only when all bits in R8 become 0 after the operation.
The Range of Exponents
The first thing to do is predict the largest exponent that can arise from converting a 32bit fullword. The magnitude of such an integer cannot exceed 231 = 2,147,483,648, which is the same as 232 ( 1/2. This value can be represented as 168 ( 1/2, indicating that the largest exponent for a floatingpoint number converted from a fullword is 8.
The smallest positive integer is 1 = 161 ( 1/16, indicating that the smallest exponent for a floatingpoint number converted from a fullword is 1. Recall that the characteristic field part of the floatingpoint representation contains the exponent stored in excess64 format; the value stored is (Exponent + 64). The range of possible characteristics is from 72 down to 65.
In our example and in our code, we shall manipulate the characteristic directly.
A Fullword Example
The algorithm to be developed for fullwords will be inspired by the halfword example above. It will involve multiple shifts and logical operations to locate the most significant 1 bit and use the information obtained to generate the characteristic field and fraction. But first, lets do a computation by hand. Our example is 32,685.
As a 16bit integer, this can be represented as 0111 1111 1010 1101. In 32 bits it would be 0000 0000 0000 0000 0111 1111 1010 1101. To avoid this mess of ones and zeroes, this chapter will use hexadecimal notation; the value is 0000 7FAD.
This algorithm functions by testing the leftmost hexadecimal digit in the value, which represents the four highorder bits in the representation. If the digit is zero, the value is shifted left by four bits, equivalent to shifting one hexadecimal digit. The SLL (Shift Left Logical) instruction will be used for this task, as it pads the right with zeroes.
1. Start Characteristic = 72, Value = 0000 7FAD The most significant digit is 0, so shift left and reduce the characteristic by 1.
2. Characteristic = 71, Value = 0007 FAD0 The most significant digit is 0, so shift left and reduce the characteristic by 1.
3. Characteristic = 70, Value = 007F AD00 The most significant digit is 0, so shift left and reduce the characteristic by 1.
4. Characteristic = 69, Value = 07FA D000 The most significant digit is 0, so shift left and reduce the characteristic by 1.
5. Characteristic = 68, Value = 7FAD 0000 The most significant digit is not 0, so we have both our fraction and our characteristic with value 68 or X44. The fraction is X 7FAD00.
The representation of this value in the 32bit singleprecision floatingpoint format is:
44 7F AD 00. Just for fun, lets reverse engineer this value.
The characteristic field is X44, indicating an exponent of 4. The value represented is164 ( (7/16 + 15/162 + 10/163 + 13/164) = 7(163 + 15(162 + 10(16 + 13 = 7(4096 + 15(256 + 160 + 13 = 28,672 + 3,840 + 173 = 32,685.
Why Convert to SinglePrecision FloatingPoint?
The topic of this section is the conversion of 32bit fullword integer values into equivalent floatingpoint values. One might wonder why we have selected the singleprecision format as the target, in preference to the doubleprecision floatingpoint (D) format.
One reason for the choice is simplicity; it is easier to discuss singleprecision format in this context. Another reason is precision. The singleprecision floatingpoint format has a precision of seven digits. A fullword has at most 10 digits, with the most significant digit being restricted to 0, 1, or 2; one might stay that the format has only nine digits. In other words, for most cases, conversion to the singleprecision format does not lose accuracy.
Two Unusual Cases
There are two cases in which the above shift left to find the most significant 1 bit strategy does not work. In each of these cases, one finds that one of the bits in the leftmost byte of the 32bit integer is not zero. Recall that the format of the singleprecision floatingpoint format may be expressed as C C | F F F F F F, where the first byte (denoted C C) holds the sign bit and the characteristic field.
Consider the case illustrated below, in which we assume that not all of A0, A1, A2, and A3 are zero. Since the number is positive, we do know that A0 = 0, but that is not significant here.
Hex Digit01234567Power 16876Power 2323130292827262524A0A1A2A3A4A5A6A7A8 through A31The value of the fullword is A1(230 + A2(229 + A3(228 + A4(227 + + A31(20.
Another way to write this would be as follows:
232((A1/4 + A2/8 + A3/16 + + A31/232), which can also be written as
168((A1/4 + A2/8 + A3/16 + + A31/232). The singleprecision floatingpoint format calls for an 8bit field holding the sign and characteristic, followed by a 24bit fraction, which here would be A0 through A23. The characteristic field would hold X48, indicating a positive number with an exponent field of 8.
The conversion for this case is to start with the 32bit (8 hexadecimal digit) value.
Digit01234567A0-A3A4-A7A8-A11A12-A15A16-A19A20-A23A24-A27A28-A31This is logically right shifted by 8 bits (2 hexadecimal digits) to get the value:
Digit0123456700000000A0-A3A4-A7A8-A11A12-A15A16-A19A20-A23The two hexadecimal digits for the characteristic field are then inserted to get the final value.
Digit0123456748A0-A3A4-A7A8-A11A12-A15A16-A19A20-A23
The Other Case
Consider now the second case. Again we assume that not all of A0, A1, A2, and A3 are zero.
Hex Digit01234567Power 16876Power 23231302928272625240000A0A1A2A3A4 through A27The value of the fullword is A0(227 + A1(226 + A2(225 + A3(224 + A4(223 + + A27(20.
Another way to write this would be as follows:
228((A0/2 + A1/4 + A2/8 + A3/16 + + A27/228), which can also be written as
167((A0/2 + A1/4 + A2/8 + A3/16 + + A27/228). The characteristic field is X47.
Remember that the singleprecision format calls for a 24bit fraction field.
The conversion for this case is to start with the 32bit (8 hexadecimal digit) value.
Digit012345670000A0-A3A4-A7A8-A11A12-A15A16-A19A20-A23A24-A27This is logically right shifted by 8 bits (2 hexadecimal digits) to get the value:
Digit0123456700000000A0-A3A4-A7A8-A11A12-A15A16-A19A20-A23The two hexadecimal digits for the characteristic field are then inserted to get the final value.
Digit0123456747A0-A3A4-A7A8-A11A12-A15A16-A19A20-A23The Left Shifter Cases
In all other cases, the positive integer to be converted has the following format.
Digit0123456700000000A0-A3A4-A7A8-A11A12-A15A16-A19A20-A23The two hexadecimal digits that will be occupied by the characteristic field are already clear, so we do not require any right shifting to move the most significant part of the fraction to its proper location. We are only assured that at least one of bits A0 through A23 is not zero. The procedure to follow is the test and shift left procedure sketched above for the halfword case.
The operation to be used in left shifting register R9 will be the SLL (Logical Left Shift), which will insert 4 binary zeroes on the right part of R9 every time it is left shifted by 4 bits. This usage is consistent with building a fraction with trailing zeroes; 0.4 = 0.400000.
At the end of the code to be developed, we shall store the integer contents of a the register R9 into a word declared to be in singleprecision floatingpoint format. Note that both the fullword (F) format and singleprecision (E) floatingpoint formats are 32bit (four byte) formats, so that one value can be stored into another.
What we are doing here is manipulating each part of the formatted number as if it were an integer, and then creating a bit pattern that will bear interpretation as a floatingpoint value.
Here is the code developed as a result of the discussions so far. The assumption is that the integer value to be converted is found in generalpurpose register R9 and that the result is to be deposited in an area of memory declared as EFLOAT DS E.
MVI THESIGN,X00 Initialize the sign field CH R9,=H0 Look at the integer value BZ DONE It is zero, nothing to do. BNL NOTNEG Is the value negative?
MVI THESIGN,X80 Yes, it is negative. LCR R9,R9 Get the absolute valueNOTNEG LR R8,R9 Get a copy into R8
* At this point, R9 will contain the value as it is* being transformed from 32bit integer format into* Single-Precision Floating-Point format.* R8 is a work register used to test values.
N R8,=XF0000000 Is the high-order hex digit 0 BZ D0IS0 Yes, not this special case SRL R9,8 Clear out the characteristic O R9,=X48000000 Set the exponent B SETSIGN Set the sign
D0IS0 LR R8,R9 Get the value back into R8 N R8,=XFF000000 Is the next digit 0 BZ D1IS0 Yes, not this special case SRL R9,4 Clear out the characteristic O R9,=X47000000 Set the exponent B SETSIGN Set the sign
** Here we make sure that the two high-order digits in* R9 are zero, and test that we have a positive value.*D1IS0 N R9,=X00FFFFFF Sanity check: is any bit = 1 BZ SETSIGN NO, the result is 0
LFTSHFT EQU ** Here we do the left shifting of the number to* generate the proper characteristic field and* normalized fraction.
SETSIGN SR R8,R8 Set R8 to zero IC R8,THESIGN Get the sign byte into R8 CH R8,=H0 Is it zero (non-negative)? BZ DONE Yes, value is not negative O R9,=X80000000 Set the sign bit
DONE ST R9,EFLOAT Store the result into the* 32-bit field EFLOAT
Left Shifting
Having disposed of the two cases that are unusual due to the bit structure of the singleprecision floatingpoint format, let us consider the more general case. In this case, the first two hexadecimal digits of the integer value are 0 and one (or more) of the other six is nonzero. From a magnitude consideration, this covers numbers with integer values at least 1 and less than 224 = 16,777,216. Many commonly used integer values easily fit within this range.
The preconditions for this section of the code are simple. Register R9 contains the absolute value of the integer, with the sign having been tested and recorded for use later. As noted above, this magnitude is not greater than 16,777,215, which in hexadecimal is XFFFFFF.
LFTSHFT
ISD3A0 LR R8,R9 Copy value into R8 N R8,=X00F00000 Is the third digit nonzero? BNZ SETVAL Yes, it is non-zero. SHL R9,4 No, it is not. Shift left by 4* bits to examine another digit B ISD3A0 Try againSETVAL EQU *
There is quite a bit missing from the above loop. What we need to do is begin with the characteristic field as X46, or decimal 70, representing an exponent of +6. As each test reveals digit 3 to be zero, we need to count down the exponent and shift left. The lowest admissible exponent is 1, represented in the characteristic field as 65 or X41.
The construct appropriate for this is BXH, which will branch on a value higher than X41. Recall the format of the source code for this instruction.
BXH Register,Register_Pair,Target_Address
Where Register denotes a register containing a count; here the characteristic field.
Register_Pair contains the even register of an evenodd pair. The even register contains a value to be used in incrementing the count. The odd register contains a value to be used as a limit.
Target_Address contains the branch target.
The design here is to start the characteristic field at X46, representing an exponent of +6. For each time the digit is found to be zero, we shift left by 4 bits (one hexadecimal digit), and decrement the exponent. This continues until the characteristic field is X41, indicating the smallest characteristic field for a positive nonzero integer.
With R8 and R9 in use, this design calls for the following. R6 and R7 are selected as the evenodd register pair. R5 will be used to hold the value of the characteristic field.
Here is an example of the shift strategy. Let R9 contain X0000 2BAD. (R5) = X46.Is digit 3 a 0? Yes. Shift left and decrement (R5). X0002 BAD0. (R5) = X45.Is digit 3 a 0? Yes. Shift left and decrement (R5). X002B AD00. (R5) = X44.Is digit 3 a 0? No, it is not. Keep (R9) = X002B AD00 and (R5) = X44.
The answer is that the floatingpoint representation is X442B AD00.
Here is the code.
MVI THESIGN,X00 Initialize the sign field CH R9,=H0 Look at the integer value BZ DONE It is zero, nothing to do. BNL NOTNEG Is the value negative?
MVI THESIGN,X80 Yes, it is negative. LCR R9,R9 Get the absolute valueNOTNEG LR R8,R9 Get a copy into R8
* At this point, R9 will contain the value as it is* being transformed from 32bit integer format into* Single-Precision Floating-Point format.
N R8,=XF0000000 Is the high-order hex digit 0 BZ D0IS0 Yes, not this special case SRL R9,8 Clear out the characteristic O R9,=X48000000 Set the exponent B SETSIGN Set the sign
D0IS0 LR R8,R9 Get the value back into R8 N R8,=XFF000000 Is the next digit 0 BZ D1IS0 Yes, not this special case SRL R9,4 Clear out the characteristic O R9,=X47000000 Set the exponent B SETSIGN Set the sign
D1IS0 N R9,=X00FFFFFF Sanity check: is any bit = 1 BZ SETSIGN NO, the result is 0
LFTSHFT LH R5,=H70 Start value for characteristic LH R6,=H-1 Increment value. LH R7,=H65 Limit value
ISD3A0 LR R8,R9 Copy value into R8 N R8,=X00F00000 Is the third digit nonzero? BNZ SETVAL Yes, it is non-zero. SHL R9,4 No, it is not. Shift left by 4 BXH R5,R6,ISD3A0 Try again
SETVAL SHL R5,24 Move characteristic into place OR R9,R5 Create the number
SETSIGN SR R8,R8 Set R8 to zero IC R8,THESIGN Get the sign byte into R8 CH R8,=H0 Is it zero (non-negative)? BZ DONE Yes, value is not negative O R9,=X80000000 Set the sign bit
DONE ST R9,EFLOAT Store the result into the* 32-bit field EFLOAT
Conversion of SinglePrecision FloatingPoint to Integer
Here again, the first step is to detect and note the sign of the number. We shall focus on converting positive values, with the sign added at the end of the conversion process. In this case the process of adding the sign will be that of taking the twos complement.
The process will begin with the floatingpoint value stored in location EFLOAT, declared as:EFLOAT DS E A 32bit (4 byte) storage allocation.
Note however that, throughout this conversion, EFLOAT will be treated as if it were a 32bit fullword integer. Again, we are processing this bit by bit, and hexadecimal digit by hex digit. We are not really interested in its value when considered as a floating point number.
The first step is to access this fourbyte location using an integer instruction.
L R9,EFLOAT
Now, we use a characteristic common to both integer and floatingpoint arithmetic. If bit 0 (the leftmost bit) of the 32bit representation is 1, the number is negative. Otherwise, the number is nonnegative, and might be zero. We immediately test for this.
Recall two things when examining the code below. 1. The value X00000000, viewed as a singleprecision floatingpoint value is what IBM calls a true zero. It converts to integer zero.
2. The value X7FFFFFFF represents a 32bit number in which all bits, save bit 0 (the sign bit) are 1. We use this to mask out the sign bit and keep in R9 a value that would be interpreted as the absolute value of the floatingpoint number.
MVI THESIGN,X00 Initialize the sign field L R9,EFLOAT Load the floating-point value CH R9,=H0 and examine the sign bit. BZ DONE The value is zero, nothing to do. BNL NOTNEG Is the value negative? MVI THESIGN,X80 Yes, it is negative. N R9,=X7FFFFFFF Zero out the sign bit.
The next section of code reflects the fact that, if the fraction part of the representation is zero, then the value represented is 0 without regard to the characteristic field.
NOTNEG LR R8,R9 Copy the value into R8 N R8,=X00FFFFFF Examine the fraction. Is it 0? BNZ FRNZ No, keep on working SR R9,R9 Yes, the value is zero. So set B DONE the result as 0 and exit.FRNZ EQU * Keep on processing.
We now check the range of the characteristic field to determine if the exponent is consistent with conversion to an fullword integer. If the characteristic is less than 65 (X41), the value is less than 1 and will be converted to a 0. If the characteristic is greater than 72 (X48), the magnitude is too large to be represented as a fullword. What the code should do in this situation is up to the designer; here we set the integer to the maximum value. This is probably a poor design choice, but for now it is as good as any. Here is this code.
LR R8,R9 Copy the value into R8 N R8,=XFF000000 Isolate the characteristic field SRL R8,24 Shift to least significant byte CH R8,=H64 Is exponent big enough? BH OVER1 Yes, number is not < 1. SR R9,R9 No, set result to zero B DONE and be done with it.OVER1 CH R8,=H72 Is the exponent too big? BNH CANDO NO, it is fine. L R9,=X7FFFFFFF Biggest positive number B SETVAL Go adjust the sign.CANDO EQU * Value can be converted.
Here is the code as it exists at this point.
MVI THESIGN,X00 Initialize the sign field L R9,EFLOAT Load the floating-point value CH R9,=H0 and examine the sign bit. BZ DONE The value is zero, nothing to do. BNL NOTNEG Is the value negative? MVI THESIGN,X80 Yes, it is negative. N R9,=X7FFFFFFF Zero out the sign bit.
NOTNEG LR R8,R9 Copy the value into R8 N R8,=X00FFFFFF Examine the fraction. Is it 0? BNZ FRNZ No, keep on working SR R9,R9 Yes, the value is zero. So set B DONE the result as 0 and exit.
FRNZ LR R8,R9 Copy the value into R8 N R8,=XFF000000 Isolate the characteristic field SRL R8,24 Shift to least significant byte CH R8,=H64 Is exponent big enough? BH OVER1 Yes, number is not < 1. SR R9,R9 No, set result to zero B DONE and be done with it.
OVER1 CH R8,=H72 Is the exponent too big? BNH CANDO NO, it is fine. L R9,=X7FFFFFFF This is the biggest positive number B SETVAL Go adjust the sign.CANDO EQU * Value can be converted.
* Here is the code for processing the values that* can be converted into a fullword 32bit integer.
SETVAL SR R8,R8 Set R8 to 0. IC R8,THESIGN Load the sign value CH R8,=H0 Is the sign bit set? BZ ISPOS No, we are OK LCR R9,R9 Negate the absolute valueDONE EQU * We are done here.
Now we discuss the code for converting those floating point values that can be converted into positive fullword values. This code will use SLDL (Shift Left Double Logical).
We begin with another test to account for a case that cannot be converted. When the characteristic field is X48 (decimal 72, representing an exponent of 8) and the most significant bit in the fraction is a 1, the absolute value will be not less than 231, which cannot be represented as a fullword integer. In other words, we are looking for this value.
Digit0123 7481 A1 A2 A3A4-A23We use the SLDL instruction on the register pair (8, 9). At first, we shall clear R8 and shift the two highorder hexadecimal digits of R9 into it (SLDL by 8 bits). If this value is not X48, we proceed with the conversion. Otherwise one more SLDL will tell the tale.
CANDO SR R8,R8 Set R8 to zero
SLDL R8,8 Shift two high-order digits into R8 CH R8,=H72 Is the exponent an 8? BL DOIT Yes, we can continue** At this point, the most significant fraction bit occupies* the sign bit in R9. Check to see if R9 is negative.*
CH R9,=H0 Is the sign bit set? BP DOIT No, the high-order fraction bit is 0 L R9,=X7FFFFFFF Set to the biggest positive integer B SETVAL Go adjust the sign.
At this point, the register values are as follows: 1. R8 contains the characteristic value, equal to (Exponent + 64). 2. R9 contains the fraction in which the most significant hex digit is not 0. This is a result of the fact that the number was stored in a normalized format. 3. The low order eight bits (two hexadecimal digits) of R9 are all zero. This is due to the execution of the logical left shift SLDL.
The final processing of R9 to produce an integer that contains the absolute value of the desired result is to shift it right by a count related to the exponent. This will shift some 1 bits off the right, thus truncating the value. The requirements are as follows.
CharacteristicExponentShift right by7280 bits 7174 bits (1 hexadecimal digit)7068 bits (2 hexadecimal digits)69512 bits (3 hexadecimal digits)68416 bits (4 hexadecimal digits)67320 bits (5 hexadecimal digits)66224 bits (6 hexadecimal digits)65128 bits (7 hexadecimal digits)The formula for the shift count is seen to be (72 Characteristic)(4.
Here is the code to do that computation and produce the absolute value of the integer.Recall that the source code format of the logical right shift can be in the following form.SRL R1,D2(B2) in which the shift amount is determined by adding the value in D2 to the contents of the register indicated by B2. This is base/displacement form used to compute a number and not an address.
DOIT SH R8,=H72 Produce (Characteristic 72) LCR R8,R8 Produce (72 Characteristic) SLL R8,2 Multiply by 4 SRL R9,0(R8) Shift R9 by the amount in R8
Lets try a few examples to see if this works. 1. A large positive number. In hexadecimal, it is represented as 46 7F 03 00.Note immediately that the characteristic field is X46, so that the exponent is 6. We first compute the value directly; it is 166((7/16 + 15/256 + 0/163 + 3/164) = 7(165 + 15(164 + 3(162 = 7(1048576 + 15(65536 + 3(256 = 7340032 + 983040 + 768 = 8,323,840.
We now apply our algorithm. At the time that the characteristic is tested, R8 contains decimal 70 and R9 contains 7F 03 00 00. The algorithm calls for a logical right shift of R9 by 8 bits or 2 hexadecimal digits. The new value is X007F0300, which represents the value 0(167 + 0(166 +7(165 + 15(164 + 0(163 + 3(162 + 0(16 + 0, the value above.
2. A much smaller number related to the above. It is represented as 42 7F 03 00. I have elected to keep the same fraction to simplify my work in doing the calculations. We first compute the value directly; it is 162((7/16 + 15/256 + 0/163 + 3/164) = 7(16 + 15 + 3/256 = 112 + 15 + 0.01171875 = 127.01171875.
We now apply our algorithm. At the time that the characteristic is tested, R8 contains decimal 66 and R9 contains 7F 03 00 00. The algorithm calls for a logical right shift of R9 by 24 bits or 6 hexadecimal digits. The new value is X0000007F, which represents the value 0(167 + 0(166 +0(165 + 0(164 + 0(163 + 0(162 + 7(16 + 15, which is 127. Note that this integer conversion has simply dropped the fractional part. Writing code to round off is not very tricky; your author just elects not to do it.
Here is a sketch of one approach to the roundoff question. This will be based on the use of the shift right logical double instruction SRDL. The value to be converted must be placed in the even register of an evenodd register pair and the odd register cleared. To illustrate, suppose that it is R8 that contains the value, represented as 43 7F 03 00.
1. Clear R9. The register pair contains 43 7F 03 00 | 00 00 00 00.
2. Shift right double by 5 digits to get 00 00 04 37 | F0 03 00 00
3. The bit pattern in R8 represents the integer 4(256 + 3(16 + 7 = 1079 The bit pattern in R9 represents a fraction (15/16 + 3/164), bigger than 0.50. This is noted by detecting the sign bit in R9.
4. Round off the value to 1080.
Packed Decimal Format to FloatingPoint
Here we face a problem with no precise solution unless we give some additional input. Recall that a number in the packed decimal format is represented by a sequence of hexadecimal digits (all having decimal values in the range 0 through 9) followed by a single hexadecimal digit in the range XA through XF. Such a number may have from 1 through 31 decimal digits, with the trailing sign digit being necessary.
The routine for this conversion will be based on selecting individual digits from the packed format, one at a time. For this purpose, the digits will be numbered left to right in a manner reminiscent of the bit numbering used in a register. Consider the following.
Digit number 0 1 2 3 4 5 6 7 8 9 AValue 3 1 4 1 5 9 2 6 5 3 6
The reason that this has no precise solution is that the decimal place is not explicitly specified in the packed format representation of the value. Since we recognize this value as an approximate representation of the value (, we know the number is 3.1415926536. There are ten digits to the right of the decimal point and just one before it. In our representation we shall specify the value as a pair: (packed value, digit position).
The value here would be (31415926536C, 10), indicating that we produce the floating point value corresponding to the integer value 31415926536 and then divide that by 1010. At this point, we do not care that the integer just given cannot be represented as either a halfword or fullword by the S/370; this is just a conceptual calculation. All of our arithmetic here will be done in doubleprecision floatingpoint format.
Design of the Algorithm: Preconditions and Subprograms Used
The algorithm and its implementation in assembly language are designed assuming that: 1. The packed decimal value is found at location PACKNUM, and is validly formatted. In particular, the number has no more than 31 decimal digits and has a sign digit.
2. The sign digit is either XB or XD for a negative number or one of XA, XC, XE, or XF for a nonnegative number.
3. The digits in the number will be indexed by a value from 0 possibly through 31.
4. One subroutine and one array will be used to help the computation. The subroutine accepts the digit index in R8 and returns the hexadecimal value of the digit in R9. The array is an array of doubleprecision floatingpoint values in which the Kth entry, at offset K(4, contains the equivalent of float(K).
5. The digits are scanned left to right until a sign digit is found. The numeric digits are processed very much as was done for the EBCDIC to integer direct conversion, except that floatingpoint arithmetic is used.
6. The result will be found in floatingpoint register 0.
7. As a precaution, the loop will be controlled by a BXLE instruction, to guarantee that no more than 32 hexadecimal digits are processed.
8. Each addressable byte contains two hexadecimal digits, each of which must be retrieved individually to compute the value of the Packed Decimal number.
Here is the subprogram used to return the hexadecimal value of a digit. The basic processing is first to convert the digit offset into a byte offset and then to move the digit into position.
The digit position is converted to a byte offset by division by 2. Consider the example:
PI DC P 31415926536
What is stored is shown in the following table.
AddressPIPI+1PI+2PI+3PI+4PI+5Value31415926536CThe goal of this routine is to get the hexadecimal value of the digit into the loworder four bits of the generalpurpose register 9 and have all other hexadecimal digits equal to 0.
Consider the processing of the digit at offset 2. This is the digit 4. 1. The digit index in R8 is forced to be in the range [0,31]. 2. The index is copied into R7 and converted to a byte offset. This offset is 1. 3. The byte with value X41 is loaded into R9. 4. The digit index is tested for being odd. It is not, so there is a logical right shift to place the first digit into the least significant place. R9 now has X4. 5. The seven highorder hex digits in R9 are masked out, returning the value X4.
Consider the processing of the digit at offset 3. This is the digit 1. 1. The digit index in R8 is forced to be in the range [0,31]. 2. The index is copied into R7 and converted to a byte offset. This offset is 1. 3. The byte with value X41 is loaded into R9. 4. The digit index is tested for being odd. It is odd, so there is a logical right so no right shifting is required. R9 now has X41. 5. The seven highorder hex digits in R9 are masked out, returning the value X1.
Here is the complete subroutine to get the digit. It is called GETDIGIT.
* Index of digit is in register R8. Value of R8 is preserved* The value of the digit is returned in R9.* R7 is used but not saved. R4 contains the return address.
*
GETDIGIT N R8,=X0000001F X1F=0001 1111; GET 5 LOW ORDER BITS
LR R7,R8 COPY VALUE OF DIGIT INDEX INTO R7
SRL R7,1 CONVERT INTO BYTE OFFSET
SR R9,R9 SET R9 TO ZERO
IC R9,PACKNUM(R7) GET THE BYTE INTO R7
*
LR R7,R8 GET THE DIGIT INDEX BACK INTO R7
N R7,=X00000001 MASK OUT THE UNIT BIT IN THE INDEX
BNZ ISODD IF UNIT BIT IS NOT 0, INDEX IS ODD
SRL R9,4 SHIFT TO GET DIGIT INTO POSITION
ISODD N R9,=X0000000F ISOLATE THAT DIGIT
*
* R9 NOW CONTAINS THE NUMERIC VALUE OF THE DIGIT.
* IF VALUE > 9, THE DIGIT IS THE SIGN DIGIT.
BR R4 R4 contains the return address.
The array in question is just a table holding the doubleprecision floatingpoint values equivalent to the first ten nonnegative integers (0 through 9), as well as the value 10.0 (which will be used for multiplication in forming the number). This is just the easiest way to convert a single digit positive integer into its equivalent floatingpoint value.
* CONVERT SINGLE DIGIT INTEGER TO FLOATING POINT.** USE: PLACE VALUE INTO INDEX REGISTER, THEN SLL 2* LD 2,FPVALS(Index Register)
FPVALS DC D0.0FPV1 DC D1.0FPV2 DC D2.0FPV3 DC D3.0FPV4 DC D4.0FPV5 DC D5.0FPV6 DC D6.0FPV7 DC D7.0FPV8 DC D8.0FPV9 DC D9.0FPV10 DC D10.0
Here is the code for the conversion routine.
PACKTOFP LD 0,FPVALS GET THE 0 ENTRY. CLEAR FP REG 0
* NOW SET UP FOR THE BXLE INSTRUCTION* SR R8,R8 SET COUNT TO 0. THIS IS THE DIGIT INDEX LH R10,=H1 LOOP INCREMENT IS 1, MOVE LEFT TO RIGHT LH R11,=H31 LIMIT ON THE DIGIT INDEX
CONVERT BAL R4,GETDIGIT GET THE DIGIT AT INDEX = R8 CH R9,=H10 DIGIT VALUE RETURNED IN R9 BNL DONE WE HAVE THE SIGN DIGIT MD 0,FPV10 MULTIPLY CURRENT VALUE BY 10.0 SLL R9,2 MULTIPLY DIGIT VALUE BY 4 LD 2,FPVALS(R9) GET FP VALUE OF THE DIGIT ADR 0,2 ADD TO ACCUMULATING RESULT BXLE R8,R10,CONVERT GO GET ANOTHER DIGIT
DONE LH R8,DECPLACE GET THE DECIMAL PLACE INDICATOR CH R8,=H0 IS IT POSITIVE BNH SETSIGN NO, JUST SET THE SIGNADJUST DD 0,FPV10 DIVIDE TO ADJUST TO DECIMAL POINT BCT R8,ADJUST KEEP DIVIDING UNTIL VALUE IS RIGHT
SETSIGN CH R9,=H11 R9 HAS SIGN DIGIT. IS IT XB? BE ISNEG YES, THE VALUE IS NEGATIVE CH R9,=H13 R9 HAS SIGN DIGIT. IS IT XD? BNE FINISH NO. THE VALUE IS POSITIVEISNEG LDR 2,0 COPY VALUE TO FP REGISTER 2 SDR 0,0 SET FP REGISTER TO 0 SDR 0,2 NOW FP 0 HAS BEEN NEGATEDFINISH BR R3 ALL DONE.
FloatingPoint to Packed Decimal Conversion
When considering this conversion, one is presented with a number of technical difficulties in handling the floatingpoint as well as issues due to the fundamental incompatibility of the two formats under consideration. All are difficult, but none are insurmountable.
Here are some of the issues that must be addressed.
1. How to produce repeatedly the most significant decimal digit from a floatingpoint representation, and when to stop producing these digits. The floatingpoint formats call for singleprecision to have 7 digits significant, and doubleprecision to have 15 digits significant. Do we stop at these counts?
Consider the number 1.2345(107, which of course will be represented in the IBM formats using hexadecimal notation. We want to extract the exponent as 7, and then extract the digits 1, 2, 3, 4, and 5 in that order. The answer might be 012345000C.
2. As a related issue, how at any time to determine the largest power of ten that is not larger than the absolute value of the floatingpoint number being converted. The simple way to do this appears to be quite verbose and tedious.
3. The position of the decimal point in any floatingpoint representation is important and almost explicitly specified in the representation. The position of the decimal point for the Packed Decimal format is assumed in the code and not stored in the format. We got around this for the Packed Decimal to FloatingPoint conversion by by specifying the position of the decimal, but this not a part of the standard.
One obvious way to convert from floatingpoint to packed decimal is first to convert the value to a fullword integer and then to convert that value (using CVD) to Packed Format. This will work for floatingpoint values that represent integers within the proper range, but any fractional digits will be lost.
This issue of converting from FloatingPoint to Packed Decimal is closely related to the problem of providing a print representation for floatingpoint values. As the author of your textbook, I intend to continue investigating these two conversion issues.
Any solutions found that are suitable for publishing in a textbook will appear in thenext revision.
Here is the complete code for the floatingpoint to integer conversion.
MVI THESIGN,X00 Initialize the sign field L R9,EFLOAT Load the floating-point value CH R9,=H0 and examine the sign bit. BZ DONE The value is zero, nothing to do. BNL NOTNEG Is the value negative? MVI THESIGN,X80 Yes, it is negative. N R9,=X7FFFFFFF Zero out the sign bit.
NOTNEG LR R8,R9 Copy the value into R8 N R8,=X00FFFFFF Examine the fraction. Is it 0? BNZ FRNZ No, keep on working SR R9,R9 Yes, the value is zero. So set B DONE the result as 0 and exit.
FRNZ LR R8,R9 Copy the value into R8 N R8,=XFF000000 Isolate the characteristic field SRL R8,24 Shift to least significant byte CH R8,=H64 Is exponent big enough? BH OVER1 Yes, number is not < 1. SR R9,R9 No, set result to zero B DONE and be done with it.
OVER1 CH R8,=H72 Is the exponent too big? BNH CANDO NO, it is fine. L R9,=X7FFFFFFF This is the biggest positive number B SETVAL Go adjust the sign.
CANDO SR R8,R8 Set R8 to zero SLDL R8,8 Shift two high-order digits into R8 CH R8,=H72 Is the exponent an 8? BL DOIT Yes, we can continue CH R9,=H0 Is the sign bit set? BP DOIT No, the high-order fraction bit is 0 L R9,=X7FFFFFFF Set to the biggest positive integer B SETVAL Go adjust the sign.
DOIT SH R8,=H72 Produce (Characteristic 72) LCR R8,R8 Produce (72 Characteristic) SLL R8,2 Multiply by 4 SRL R9,0(R8) Shift R9 by the amount in R8
SETVAL SR R8,R8 Set R8 to 0. IC R8,THESIGN Load the sign value CH R8,=H0 Is the sign bit set? BZ ISPOS No, we are OK LCR R9,R9 Negate the absolute value
DONE EQU * We are done here.
Page PAGE 313 Chapter 21 Revised August 3, 2009 Copyright 2009 by Edward L. Bosworth, Ph.D.
S/370 Assembler Language Conversions for Floating Point
239hijKZ`aV !./2371:_`bcǿǳǳǳǳǳǳǯǧϟϐωρh9h;?H* jh;?h5h;?5h9h;?h9h;?>*hN.h;?>*hP/ jhIC hIC5hQhIC5hIChTh;?hhNjh>*hMhqchMh+5CJaJhMhM5CJaJ/3.
`iw~$
h$Ifa$gdqo
h$Ifgdqo
hxgd
h xgdgd
hxgdqc
hxgdM $ha$gdM[N>>>$
h$Ifa$gdqo
h$Ifgdqokd$$Ifl\(8$
t0644
laytqo[N>>>$
h$Ifa$gdqo
h$Ifgdqokd$$Ifl\(8$
t0644
laytqo[NB6/xgd;?
h xgdDK
h xgdP/
hxxgdkd"$$Ifl\(8$
t0644
laytqo')+Ff$$Ifa$gdqo $Ifgdqo
+,09XjaUU$$Ifa$gdqo $Ifgdqokd$$IfTlFT$
t0644
laytqoTXY%jaZZUZZL $Ifgdqogd;?xgd;?xxgd;?kd$$IfTlF
T8
t0644
laytqoT/023@AST
xyzE F H ˼hh;?H*h;?OJQJ^J h;?5h5h;?OJQJ^J h;?H* jh;?h9h;?H* jh;?h;?h9h;?5G^U $Ifgdqokd$$IfTlF
T8
t0644
laytqoT$$Ifa$gdqo Pkd2 $$IfTlFT$
t0644
laytqoT $IfgdqoFf&$$Ifa$gdqo$*/>$$Ifa$gdqo $Ifgdqoxgd;?gd;?xxgd;?>?EGIKMOQSjaUUUUUUU$$Ifa$gdqo $Ifgdqokd $$IfTlF
T8
t0644
laytqoT SUV`bdePGxxgd;?kdM
$$IfTlFT$
t0644
laytqoT $IfgdqoFfA$$Ifa$gdqo|Ikd
$$IfTlF
T8
t0644
laytqoT$$Ifa$gdqo $Ifgdqoxgd;?gd;? $IfgdqoFf\$$Ifa$gdqo
!!""r#x#jaaaaaZQ $Ifgdqoxgd;?xxgd;?kdh$$IfTlFT$
t0644
laytqoTH J K N '!3!C!E!d!g!p!!!!!!""""("8"=">"H"X"]"^"h""""#####-$.$1$2$A$B$J$K$T$$嶦嶦嶦嶦垦喑hrK hrK5h
hrK5hh;?H* jhh;?OJQJ^Jhh;?OJQJ^Jh=h;?OJQJ^JhAh;?OJQJ^JhAh;?5h;?h;?OJQJ^Jh5h;?OJQJ^J7x#}#########^U $Ifgdqokd$$IfTlF
T8
t0644
laytqoT$$Ifa$gdqo #########Pkd$$IfTlFT$
t0644
laytqoT $IfgdqoFfw$$Ifa$gdqo#B$T$%&*(R(()))*2*+,,,0--T.=/
hxgdZVN
hgdZVN
hxgd/
hgd/
hxgdM
xgdrKgdrKxxgd;?$$$$$%%&&&&&&&Y'Z'[']'^'_''')(*(F(Q(n(y(())))) ***2*,,,,/-ɷ⳥xmhZVN5OJQJ^JhZVNhZVN5OJQJ^JhZVNh/h".h/5hLW5OJQJ^JhqchLWhLW5OJQJ^JhLWhIC5OJQJ^J jhIChIChIC5OJQJ^Jh,A5OJQJ^JhIChhBHhrK5OJQJ^JhrKh@g*/-0-------.<?<@<A<B<C<D<F<H<<<====;><>[>\>]>w>x>>>>Y?Z?[?\?k?l?s?t?@ @ûð卵 jhi jhihihiH*hihe#{CJaJh)O[h)O[CJaJh)O[CJaJh)O[he#{CJaJhMhe#{he#{H*hshe#{H* he#{H*hshe#{H*he#{ jhe#{ he#{H*8===<>]>x>>J;;;;;
h$Ifgde#{kd#$$Iflr8
`#TT4
t044
layt)O[>>t? @*@+@]OC11$
h$Ifa$gd>
hxgdM
hxxgdikdF$$$Ifl\8`#4
t044
layt)O[ @)@+@,@-@.@/@0@1@2@@@A@E@F@J@K@O@P@T@U@b@d@e@g@h@j@k@m@n@p@q@s@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ jhihshiH*hihiCJH*aJhMhiCJH*aJhiCJaJhMhiCJaJh8hiCJaJhiCJaJE+@-@/@1@3@$
h$Ifa$gd>3@4@@@B@5##$
h$Ifa$gd>kd$$$Iflֈ4
@v"6
t0644
laytiB@C@D@E@G@H@I@J@L@M@N@O@Q@R@S@T@V@W@b@e@h@k@n@q@t@w@y@{@Ff&$
h$Ifa$gd>{@}@@@@@@@@@@@@@@@@@@@@@@@@@@@Ff*$
h$Ifa$gd>@@A7AABCC2EEERGHI.IJsKLaMM
hgdj
hxgdj
hgdj
hgd/
hxgdM
hxgdi
hxxgdiFfH/@@@@@@@@@@@@@@@@@@@AAAAA8A9A:A;A=A>ADAEAKALARASA^A`AbAcAdAAAAAAAAAAAAAAAAA'B(B+B,B2B3BzB{B|B}B~BBBBBBBBCCCh?|he#{hiH*hshiH* jhi hiH*hi hiH*hshiH*MCCCCCDDE1E2EEEEEFFFFFFFFFFyGzG{G|GI-I.I5J]JhJmJJJJJJJJKϽvvkvhj5OJQJ^Jhjhj5OJQJ^Jhh/h/5 h,A5 hjH* jhjhuhjH*hjhjhj5hih/#h?|h?|5CJOJQJ^JaJh/5CJOJQJ^JaJh?|5CJOJQJ^JaJh?|h?|h?|5OJQJ^J*KhKqKrKsKwLzLLLMM
M`MaMMMMMMMMNNNNN
NNNNNNNNOO OO~OOOOOOPWP\PPPPPPӺźźӺźźźźź椖 jh/jh/jh/jH*h/jhh5OJQJ^Jhh,Ah@Rh@R5OJQJ^Jh@R5OJQJ^Jhjh@R5OJQJ^J$h@Rh@R5B*OJQJ^Jphh@RhMhjhj5OJQJ^Jhj3McNNOO;PQKQSR#T5TUVVVVVVVV$
h$Ifa$gdZ
h$Ifgd
hgd)b
hxgd)b
hgd00
hgd
hxgdMPPPPPPPPPPPPPPPPPPPPPQQQKQSR"T#T5TITnUUUUUUUVV"V#V&V'V.V/VjVkVVVVVVVVVVVVVVVŷŷųţhhZCJaJhZCJaJhChCH*hChh5OJQJ^Jhh00h00h_Y5hth)bh)bh)b5hbh jh/jh/jh/jH*h/jW?W@WBWھ hCH* jhC hCH*hChhCJH*aJhZhCJH*aJhhCJaJhCJaJhhZCJaJhZCJaJDVVVVVVVVVVVVVVVVVVVVVVVVVFf~6
h$IfgdFfc3$
h$Ifa$gdZVVVVVVVVVVVVVVVVVVVWWW WWWW
h$IfgdFf}:$
h$Ifa$gdZWWlWWWYtYzY|Y~YYYYYYYYYYYYYYFf.A$
h$Ifa$gdVW
hxgdC
hgdC
hxxgdCFfT>BWFWGWHWIWKWOWPWQWRWTWXWYWZW[W]WeWgWhWiWjWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXYY,YKYrYsYtYyYzY{Y|Y}Y~YYYYhVWhVWCJaJhVWCJaJhVWhhChC5OJQJ^JhC5OJQJ^JhChCH* hCH* jhC hCH*hCEYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZ Z!Z"Z#Z$Z%Z&Z'Z(Z)Z*Z+Z,Z-Z.Z/Z0Z1Z2Z3Z7Z8ZZ?ZAZBZDZEZhVWCJaJhChVWCJH*aJhVWhVWCJH*aJhVWhVWCJaJhVWhVWCJaJhVWhVWCJaJJYYYYYZ!Z#Z%Z'Z)Z+Z-Z/Z1Z2Z3Z8Z=ZCZIZPZXZFf@F$
h$Ifa$gd8p
hxxgdVWFfC$
h$Ifa$gdVWEZGZHZJZKZMZOZQZSZUZWZYZ[Z]Z_ZaZcZeZgZiZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[ [[
[[[[[ ht>*hVWhVWCJH*aJhVWhVW5CJaJhVWhVWCJaJhVWCJaJhChVWhVWCJH*aJhVWhVWCJaJDXZ`ZhZiZZZZZZZZZZZZZZZZZZ[
[[[FfMFfRK
hxxgdVWFfH$
h$Ifa$gd8p[[$[[[[[[[[[[[[[[[[[[[[[FfP$
h$Ifa$gd8p
h$Ifgd8p
hxgdVW
hgdVW[$[<[c[d[g[h[k[l[s[t[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[\hVWCJH*aJhhVWCJaJhVWCJaJhChVWH*hVWh#ihVWhVW>*P[[[[[[[[[[[[[[[[[[[[[[[[[[
h$Ifgd8pFfS$
h$Ifa$gd8p[[[[[[[[[[[[\\]\\\.]{]]
hxgd#i
hxgdVW
hgdVW
hxxgdVWFf[$
h$Ifa$gd8p
h$Ifgd8pFfW\\\%\&\'\(\*\.\/\0\1\3\7\8\9\:\<\@\A\B\C\E\I\J\K\L\N\V\X\Y\Z\[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]'],]-].]]ͺͶhbh#ih#i5OJQJ^J h#iH*h#i h#iH* hVWH* jhVW hVWH*hVWhhVWCJaJhVWCJH*aJG]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]^^^^^
^^^^^^^^^^^ ^"^u^z^{^|^}^~^^^^^^^^^^^^^^^^^^^^^h#iCJH*aJhVWh#iCJH*aJh#iCJaJhVWh#iCJaJh#ihVWh#iCJaJh#iCJaJL]]]]]]]]]]]]]]]^ ^^^!^"^u^{^}^^
hxxgd#iFf`Fff^$
h$Ifa$gd8p^^^^^^^^^^^^^^^^^^%_+_-_/_1_3_5_
hxxgd#iFffFfxc$
h$Ifa$gd8p^^^^^^^^^^^^^^^^^^^^^^^^%_*_+_,_-_._/_0_1_2_3_4_5_6_7_8_9_:_;_<_=_?_@_A_B_C_E_F_H_I_K_L_N_O_Q_S_U_W_Y_[_]___a_c_e_g_i_k_h#i5CJaJhVWh#i5CJaJhVWh#iCJaJh#iCJaJh#ih#iCJH*aJhVWh#iCJH*aJhVWh#iCJaJG5_7_9_;_<_=_?_A_G_M_T_\_d_l_m__________
hxgdVW
hgdQJFfkFfh$
h$Ifa$gd8pk_m_______________________________`````` ``
``````````!`#`%`'`)a*a4a6aabῷhthhH*hCJH*aJhVWhCJH*aJhCJaJhVWhCJaJhVWhCJaJhCJaJhQJhhQJh#i>*hQJhQJ>*hVWh#iCJaJ;_______`````&`'`ab
ddefJg)h=ij
hxgdO
hxxgdFf%pFfm$
h$Ifa$gd8pbbbddeeeeeggg*gIgJg)h/hh*swxz{ߦrstާQY\ɨͨѨԨ
ӵә hfH* jhfhhf5OJQJ^Jhshf5OJQJ^JhfhshH*hhh5OJQJ^Jhf5OJQJ^Jhsh5OJQJ^Jhs hH* jhh7!"bf012;GghirūƫͫJKڬ̮ʼΪʣʣʛʓvvrrdh$Xh$X5OJQJ^Jh$Xh]\h]\5OJQJ^Jh]\5OJQJ^Jh]\h]\h]\5hqhqH* jhqhqhqhq5OJQJ^Jhqhq5OJQJ^Jhqhf5OJQJ^Jhshf5OJQJ^Jhfhf5OJQJ^J jhfhf&٩=ƫڬzů{#__5tS{չ
hgd|6
hgdE/
hgdP
hgd]\
hxgds
hxgdfů
$&'"#_|ôĴŴڵhJhP5OJQJ^JhPhP5OJQJ^J#hPhP5CJOJQJ^JaJhPhPhP>*h4h$XH*h4h$Xh45OJQJ^J jph$Xh$XCJaJh$Xh$X5OJQJ^Jh$Xh$X5OJQJ^J05@KLstķȷz{չٹ"*GM`FG\]ɼʼͼɾxxj_j_h~5OJQJ^Jh~h~5OJQJ^J#h~h~5CJOJQJ^JaJh~hvh|65CJOJQJ^JaJh|6h|65h|6h|6h$Xh|65OJQJ^Jh|65OJQJ^Jh|6h|65OJQJ^Jh|6hE/hJhJ5OJQJ^JhP jhJhJh[%չ"*-27<AF$
h$Ifa$gd|6
h$Ifgd|6
hxgds FGM%
h$Ifgd|6kdw$$Ifl֞xhX$
t0644
layt|6MPSVY\_$
h$Ifa$gd|6_`%
hxxgd|6kdx$$Ifl֞xhX$
t0644
layt|6!"#RShi
RZ\]y'D\`efȽȽ幪vghb75CJOJQJ^JaJhhQ5CJOJQJ^JaJh~5CJOJQJ^JaJh]m 5CJOJQJ^JaJh|6h~hrJ5CJOJQJ^JaJhrJhH5OJQJ^Jh~hH5OJQJ^JhH5CJOJQJ^JaJhHh|6h~h~h~5OJQJ^J(#]V13s7ikw
hxgdt
hgdb7
hgd]m
hxxgdH
hxxgd|6
9=BCqrsy}=APhiҴôᥴᴖh
h
hJ5CJOJQJ^JaJht5CJOJQJ^JaJhhQ5CJOJQJ^JaJh`O5CJOJQJ^JaJh]m 5CJOJQJ^JaJh~5CJOJQJ^JaJhb75CJOJQJ^JaJhrJ5CJOJQJ^JaJ2vw./BCVWjk~ORZ!"ȔȔs#hmh;W5CJOJQJ^JaJh5CJOJQJ^JaJh;W5CJOJQJ^JaJ#hmhm5CJOJQJ^JaJhmh
5CJOJQJ^JaJh$5CJOJQJ^JaJhm5CJOJQJ^JaJhI5CJOJQJ^JaJh
hIh
+
TA"
JsTUS4
hxgdJ
hxgdM
hgd9W
hgdI
hxgdt
wTG{- "'ƿumimimimihxb jhxb UhD5CJOJQJ^JaJ#h&hJ5CJOJQJ^JaJhJ5CJOJQJ^JaJ#h9p+hJ5CJOJQJ^JaJh]m hJh
hEhhEhh{h{5OJQJ^J h{H* jh{h{h9Wh9Whm5h9Wh9W5h)!"
hxgdM
hxgdJ
hxgdD'(./23NOkhJhxb h9WhMh9W0J
h"0Jh"0JmHnHu
h9W0Jjh9W0JU901hP7:pM/ =!"#$%21h:p"/ =!"#$%$$If!vh5(585$ 5#v(#v8#v$ #v:Vl
t65(585$ 5ytqo$$If!vh5(585$ 5#v(#v8#v$ #v:Vl
t65(585$ 5ytqo$$If!vh5(585$ 5#v(#v8#v$ #v:Vl
t65(585$ 5ytqo$$If!v h5T585555555 ,#vT#v8#v#v#v#v ,:Vl
t65T585555 ,ytqoT
kd$$IfTl
`|T8,
t06$$$$44
laytqoT}$$If!vh5T55$ #vT#v#v$ :Vl
t65T55$ ytqoT}$$If!vh5T585#vT#v8#v:Vl
t65T585ytqoT$$If!vh5T585#vT#v8#v:Vl
t65T585//ytqoT$$If!v h5T585555555 ,#vT#v8#v#v#v#v ,:Vl
t65T585555 ,//ytqoT
kd1$$IfTl
`|T8,
t06$$$$44
laytqoT}$$If!vh5T55$ #vT#v#v$ :Vl
t65T55$ ytqoT$$If!vh5T585#vT#v8#v:Vl
t65T585//ytqoT$$If!v h5T585555555 ,#vT#v8#v#v#v#v ,:Vl
t65T585555 ,//ytqoT
kdL
$$IfTl
`|T8,
t06$$$$44
laytqoT}$$If!vh5T55$ #vT#v#v$ :Vl
t65T55$ ytqoT$$If!vh5T585#vT#v8#v:Vl
t65T585//ytqoT$$If!v h5T585555555 ,#vT#v8#v#v#v#v ,:Vl
t65T585555 ,//ytqoT
kdg$$IfTl
`|T8,
t06$$$$44
laytqoT}$$If!vh5T55$ #vT#v#v$ :Vl
t65T55$ ytqoT$$If!vh5T585#vT#v8#v:Vl
t65T585//ytqoT$$If!v h5T585555555 ,#vT#v8#v#v#v#v ,:Vl
t65T585555 ,//ytqoT
kd$$IfTl
`|T8,
t06$$$$44
laytqoT}$$If!vh5T55$ #vT#v#v$ :Vl
t65T55$ ytqoT$$If!vh555555H#v#v#v#v#v#vH:Vl
t655555yt.$$If!vh555555555 5
5
55
5
5555#v#v#v#v:Vl
t6555ytMXkd$$Ifl4P
l 0V( "
t06HHHH44
laytM$$If!vh555555555 5
5
55
5
5555#v#v#v#v:Vl
t6555ytMXkd
$$Ifl4P
l 0V( "
t06HHHH44
laytM$$If!vh555555555 5
5
55
5
5555#v#v#v#v:Vl
t6555ytMXkd]$$Ifl4P
l 0V( "
t06HHHH44
laytM$$If!vh55T5T554#v#vT#v#v4:Vl
t55T554yt)O[$$If!vh55554#v#v#v#v4:Vl
t55554yt)O[$$If!vh5555556#v#v#v#v#v#v6:Vl
t65555556yti$$If!vh555555555 5
5
55
5
5555#v#v#v#v:Vl
t65555ytiXkd%$$Ifl4P
l 0@ v"
t06HHHH44
layti$$If!vh555555555 5
5
55
5
5555#v#v#v#v:Vl
t65555ytiXkd)$$Ifl4P
l 0@ v"
t06HHHH44
layti$$If!vh555555555 5
5
55
5
5555#v#v#v#v:Vl
t65555ytiXkdG.$$Ifl4P
l 0@ v"
t06HHHH44
layti$$If!v
h555 5 55555 5
#v#v#v #v
:Vl
t6555 5
ytMsI(kd2$$Ifl
88H !
t06((((44
laytMsI$$If!vh555@5@5@5@5@5@5 @5
@5
55
5
55#v#v#v
@#v
:Vl
t6555
@5
ytkd5$$Ifld8X
X8H !@@@@@@@@
t06@@@@44
layt$$If!vh555@5@5@5@5@5@5 @5
@5
55
5
55#v#v#v
@#v
:Vl
t6555
@5
ytkd9$$Ifld8X
X8H !@@@@@@@@
t06@@@@44
layt$$If!vh555@5@5@5@5@5@5 @5
@5
#v#v#v
@#v
:Vl
t6555
@5
ytNkd=$$Ifl8X
X!@@@@@@@@
t06,,,,44
layt$$If!v h555555555 #v :Vl
t65 ytVWkd@$$Ifl #
t06$$$$44
laytVW$$If!v h555555555 #v :Vl
t65 ytVWkd-C$$Ifl #
t06$$$$44
laytVW$$If!v h555555555 #v :Vl
t65 yt8pkdE$$Ifl #
t06$$$$44
layt8p$$If!v h555555555 #v :Vl
t65 yt8pkd?H$$Ifl #
t06$$$$44
layt8p$$If!v h555555555 #v :Vl
t65 yt8pkdJ$$Ifl #
t06$$$$44
layt8p$$If!v h555555555 #v :Vl
t65 yt8pkdQM$$Ifl #
t06$$$$44
layt8p$$If!v
h555 5 55555 5
#v#v#v #v
:Vl
t6555 5
yt8p(kdO$$Ifl
88H !
t06((((44
layt8p$$If!vh555@5@5@5@5@5@5 @5
@5
55
5
55#v#v#v
@#v
:Vl
t6555
@5
yt8pkdR$$Ifld8X
X8H !@@@@@@@@
t06@@@@44
layt8p$$If!vh555@5@5@5@5@5@5 @5
@5
55
5
55#v#v#v
@#v
:Vl
t6555
@5
yt8pkdV$$Ifld8X
X8H !@@@@@@@@
t06@@@@44
layt8p$$If!vh555@5@5@5@5@5@5 @5
@5
#v#v#v
@#v
:Vl
t6555
@5
yt8pNkdZ$$Ifl8X
X!@@@@@@@@
t06,,,,44
layt8p$$If!v h555555555 #v :Vl
t65 yt8pkd]$$Ifl #
t06$$$$44
layt8p$$If!v h555555555 #v :Vl
t65 yt8pkde`$$Ifl #
t06$$$$44
layt8p$$If!v h555555555 #v :Vl
t65 yt8pkdb$$Ifl #
t06$$$$44
layt8p$$If!v h555555555 #v :Vl
t65 yt8pkdwe$$Ifl #
t06$$$$44
layt8p$$If!v h555555555 #v :Vl
t65 yt8pkdh$$Ifl #
t06$$$$44
layt8p$$If!v h555555555 #v :Vl
t65 yt8pkdj$$Ifl #
t06$$$$44
layt8p$$If!v h555555555 #v :Vl
t65 yt8pkdm$$Ifl #
t06$$$$44
layt8p$$If!v h555555555 #v :Vl
t65 yt8pkdo$$Ifl #
t06$$$$44
layt8p$$If!vh55555T#v#v#vT:Vl
t6555TytMx$$If!vh55555T#v#v#vT:Vl
t6555TytMxy$$If!vh555T#v#v#vT:Vl
t6555Tyt,xy$$If!vh555T#v#v#vT:Vl
t6555Tyt,xy$$If!vh555T#v#v#vT:Vl
t6555Tyt,xy$$If!vh555T#v#v#vT:Vl
t6555Tyt,xy$$If!vh555T#v#v#vT:Vl
t6555Tyt,xy$$If!vh555T#v#v#vT:Vl
t6555Tyt,xy$$If!vh555T#v#v#vT:Vl
t6555Tyt,xy$$If!vh555T#v#v#vT:Vl
t6555Tyt,xy$$If!vh555T#v#v#vT:Vl
t6555Tyt,x$$If!vh5$555555#v$#v:Vl
t65$5yt|6$$If!vh5$555555#v$#v:Vl
t65$5yt|6@@@NormalCJ_HaJmH sH tH DA@DDefault Paragraph FontRi@RTable Normal4
l4a(k(No List4@4MHeader
!4 @4MFooter
!.)@.MPage Numberj@#j
Table Grid7:V0;3.`iw~
'
)
+
,
0
9
X
Y
%$*/>?EGIKMOQSUV`bde|
rx}BT* R !!!"2"#$$$0%%T&=''.(Y(Y)*r+',---./0O00000111111111111111 1!1#1$1%1&1(1)14171:1=1@1C1F1I1K1M1O1Q1S1U1W1Y1[1]1^1_1`1c1f1i1l1o1r1u1x1{1~11111111~222H3J4455555555<6]6x666t7 8*8+8-8/8183848@8B8C8D8E8G8H8I8J8L8M8N8O8Q8R8S8T8V8W8b8e8h8k8n8q8t8w8y8{8}88888888888888888888888888889799:;;2===R?@A.ABsCDaEEcFFGG;HIKISJ#L5LMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOO OOOOOlOOOQtQzQ|Q~QQQQQQQQQQQQQQQQQQR!R#R%R'R)R+R-R/R1R2R3R8R=RCRIRPRXR`RhRiRRRRRRRRRRRRRRRRRRS
SSSS$SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTT]TTT.U{UUUUUUUUUUUUUUUUV VVV!V"VuV{V}VVVVVVVVVVVVVVVVVVV%W+W-W/W1W3W5W7W9W;WSx###=/99M99=>+@3@B@{@@MVVWYXZ[[[]^5__jW{Й< ,Pu ٩չFM_
qstuvwxz{|}~r!\\\\\<===ahtvt]}A
<===ahtw{d!G
9*urn:schemas-microsoft-com:office:smarttagsplace=*urn:schemas-microsoft-com:office:smarttags PlaceName=*urn:schemas-microsoft-com:office:smarttags PlaceTypeۊ7;<@O Q w y z | } !!!!!!<<==BBBBBBpMqMvMwMxMyMzM{M|M}M~MMMMk"l|llEmSmZ\xz{}~ãţ58!"'3NOkonvQ$$%%%%_&f&B'O'''D+L+++..y//////(0+0H3w399;;<<EEEEFFFFGGGHO
PT U[[]]~^^^^^^:`<`NaQacc~cc$d'dee4e;ehh
iiDiMikkkl#lxlooGpLpfpsp2qDqqqr*rMrWrhsjs|ttuu2v4vvvvv=wHwuw~wwwwwbxexAyCyryyyr{s{%},}~~ 2\^DGbhȅ˅\^ŇǇAZ̉-0RUz}"OQtw1; ēLNĔLMjpޱĶ`iٸ=Fɹ GIܺ&-پ۾"-!
8Jtv$dfEH!#+!"'3NO3333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333w
Y
$e|
r012255788999A.AGG|HINNNObOlOtQQRiRRSS$SSTST]TU"VuVV%WWW'X_3`eeoop0pfpup~~ Xwё
z<Eݟŧ"`J`δVnD]ic!"NO!"rKmMBl ]m
'dAg4q(xmoIxb r%m5&{'+9p+3,8-`-^/00|6N9yu9,AICWIMsIJJQJrJK 'MZVN`OW7ULWVWSY)O[]\x\vbqc{df@gEh/jCk=oro8pst,xe#{;Wut$DKZNj8Z/P/qoJTHJi!#MM[/^zM+"_Y.{vMxE/iT&Cl>I
OiDK9WTOdb7|
;?'s,2D$XV/R1@Ru+4EznPhQe)b#iIb~?|w~
'
)
+
,
0
9
X
Y
$*/>?EGIKMOQSUV`bde|rx}0000111111111111111 1!1#1$1%1&1(1)14171:1=1@1C1F1I1K1M1O1Q1S1U1W1Y1[1]1^1_1`1c1f1i1l1o1r1u1x1{1~1111111155555555<6x666 8*8+8-8/8183848@8B8C8D8E8G8H8I8J8L8M8N8O8Q8R8S8T8V8W8b8e8h8k8n8q8t8w8y8{8}8888888888888888888888888888NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOO OOOOOtQzQ|Q~QQQQQQQQQQQQQQQQQQR!R#R%R'R)R+R-R/R1R2R3R8R=RCRIRPRXR`RhRiRRRRRRRRRRRRRRRRRRS
SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTUUUUUUUUUUUUUUUV VVV!V"VuV{V}VVVVVVVVVVVVVVVVVVV%W+W-W/W1W3W5W7W9W;W?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrsuvwxyz{}~Root Entry FЪf3Data
x1TableWordDocumentoSummaryInformation(tDocumentSummaryInformation8|CompObjq
FMicrosoft Office Word Document
MSWordDocWord.Document.89q*