The
binary numeral system, or
base2
number system represents numeric values using two symbols,
0 and
1. More
specifically, the usual
base
2 system
is a
positional notation with a
radix of 2. Owing to its straightforward
implementation in
digital
electronic circuitry using
logic
gates, the binary system is used internally by all modern
computers.
History
A full set
of eight trigrams and 64 hexagrams, analogous to the threebit and
sixbit binary numerals, was known to the ancient Chinese through the
classic text I Ching. An arrangement of the hexagrams
of the
I Ching, ordered according to the values of the
corresponding binary numbers (from 0 to 63), and a method for
generating them, was developed by the Chinese scholar and
philosopher
Shao Yong in the
11th century. However, there is no evidence
that Shao understood binary computation; the ordering is also the
lexicographical order on
sextuples of elements chosen from a
twoelement set.
The
Indian writer Pingala (c.
200 BC) developed advanced mathematical concepts for describing
prosody, and in doing so presented
the first known description of a binary numeral system.
Similar sets of binary combinations have also been used in
traditional
African divination systems such
as
Ifá as well as in
medieval Western
geomancy. The base2 system utilized in geomancy had long been
widely applied in subSaharan Africa.
In 1605
Francis Bacon discussed a
system by which letters of the alphabet could be reduced to
sequences of binary digits, which could then be encoded as scarcely
visible variations in the font in any random text. Importantly for
the general theory of binary encoding, he added that this method
could be used with any objects at all: "provided those objects be
capable of a twofold difference only; as by Bells, by Trumpets, by
Lights and Torches, by the report of Muskets, and any instruments
of like nature". (See
Bacon's
cipher.)
The modern binary number system was fully documented by
Gottfried Leibniz in the
17th century in his article
Explication de
l'Arithmétique Binaire. Leibniz's system uses 0 and 1,
like the modern binary numeral system. As a
Sinophile, Leibniz was aware of the
I
Ching and noted with fascination how its hexagrams correspond
to the binary numbers from 0 to 111111, and concluded that this
mapping was evidence of major Chinese accomplishments in the sort
of philosophical
mathematics he
admired.
In 1854,
British
mathematician George Boole published a
landmark paper detailing an algebraic system
of logic that would become known as Boolean algebra. His logical
calculus was to become instrumental in the design of digital
electronic circuitry.
In 1937,
Claude Shannon produced his master's
thesis at MIT that implemented Boolean algebra and binary
arithmetic using electronic relays and switches for the first time
in history. Entitled
A Symbolic
Analysis of Relay and Switching Circuits, Shannon's thesis
essentially founded practical
digital
circuit design.
In
November 1937, George Stibitz, then
working at Bell
Labs, completed a relaybased computer he dubbed the
"Model K" (for "Kitchen", where he had assembled
it), which calculated using binary addition. Bell Labs thus
authorized a full research programme in late 1938 with Stibitz at
the helm. Their Complex Number Computer, completed January 8, 1940,
was able to calculate
complex
numbers.
In a demonstration to the American Mathematical Society
conference at Dartmouth
College on September 11, 1940, Stibitz was able to send the
Complex Number Calculator remote commands over telephone lines by a
teletype. It was the first computing
machine ever used remotely over a phone line. Some participants of
the conference who witnessed the demonstration were
John Von Neumann,
John Mauchly and
Norbert Wiener, who wrote about it in his
memoirs.
Representation
A binary number can be represented by any sequence of
bits (binary digits), which in turn may be represented
by any mechanism capable of being in two mutually exclusive states.
The following sequences of symbols could all be interpreted as the
binary numeric value of
667:
1 0 1 0 0 1 1 0 1 1
 −  − −   −  
x o x o o x x o x x
y n y n n y y n y y
The numeric value represented in each case is dependent upon the
value assigned to each symbol. In a computer, the numeric values
may be represented by two different
voltages; on a
magnetic disk,
magnetic
polarities may be used. A
"positive", "yes", or "on" state is not necessarily equivalent to
the numerical value of one; it depends on the architecture in
use.
In keeping with customary representation of numerals using
Arabic numerals, binary numbers are commonly
written using the symbols
0 and
1. When written, binary numerals are often
subscripted, prefixed or suffixed in order to indicate their base,
or radix. The following notations are equivalent:
 100101 binary (explicit statement of format)
 100101b (a suffix indicating binary format)
 100101B (a suffix indicating binary format)
 bin 100101 (a prefix indicating binary format)
 100101_{2} (a subscript indicating base2 (binary)
notation)
 %100101 (a prefix indicating binary format)
 0b100101 (a prefix indicating binary format, common in
programming languages)
The final notation is used if converting using
Google. For example searching
5 in base 2 in google results in
5 =
0b101.
When spoken, binary numerals are usually read digitbydigit, in
order to distinguish them from decimal numbers. For example, the
binary numeral 100 is pronounced
one zero zero, rather
than
one hundred, to make its binary nature explicit, and
for purposes of correctness. Since the binary numeral 100 is equal
to the decimal value four, it would be confusing to refer to the
numeral as
one hundred.
Counting in binary
Decimal 
Binary 
0 
0 
1 
1 
2 
10 
3 
11 
4 
100 
5 
101 
6 
110 
7 
111 
8 
1000 
9 
1001 
10 
1010 
Counting in binary is similar to counting in any other number
system. Beginning with a single digit, counting proceeds through
each symbol, in increasing order. Decimal counting uses the symbols
0 through
9, while binary only
uses the symbols
0 and
1.
When the symbols for the first digit are exhausted, the nexthigher
digit (to the left) is incremented, and counting startsover at 0.
In
decimal, counting proceeds like so:
 000, 001, 002, ... 007, 008, 009, (rightmost digit starts over,
and next digit is incremented)
 010, 011, 012, ...
 ...
 090, 091, 092, ... 097, 098, 099, (rightmost two digits start
over, and next digit is incremented)
 100, 101, 102, ...
After a digit reaches 9, an increment resets it to 0 but also
causes an increment of the next digit to the left. In binary,
counting is the same except that only the two symbols 0 and 1 are
used. Thus after a digit reaches 1 in binary, an increment resets
it to 0 but also causes an increment of the next digit to the
left:
 0000,
 0001, (rightmost digit starts over, and next
digit is incremented)
 0010, 0011, (rightmost two digits start over,
and next digit is incremented)
 0100, 0101, 0110, 0111, (rightmost three
digits start over, and the next digit is incremented)
 1000, 1001, ...
Since binary is a base2 system, each digit represents an
increasing power of 2, with the rightmost digit representing
2
^{0}, the next representing 2
^{1}, then
2
^{2}, and so on. To determine the decimal representation
of a binary number simply take the sum of each of the product
binary digits with the power of 2 which they represent. For
example, the binary number:
100101
is converted to decimal form by:
[(
1) × 2
^{5}] + [(
0) ×
2
^{4}] + [(
0) × 2
^{3}] +
[(
1) × 2
^{2}] + [(
0) ×
2
^{1}] + [(
1) × 2
^{0}] =
[
1 × 32] + [
0 × 16] +
[
0 × 8] + [
1 × 4] +
[
0 × 2] + [
1 × 1] = 37
To create higher numbers, additional digits are simply added to the
left side of the binary representation.
Binary arithmetic
Arithmetic in binary is much like arithmetic in other numeral
systems. Addition, subtraction, multiplication, and division can be
performed on binary numerals.
Addition
The simplest arithmetic operation in binary is
addition. Adding two singledigit binary numbers is
relatively simple, using a form of carrying:
 0 + 0 → 0
 0 + 1 → 1
 1 + 0 → 1
 1 + 1 → 0, carry 1 (since 1 + 1 = 0 + 1 × 10 in binary)
Adding two "1" digits produces a digit "0", while 1 will have to be
added to the next column. This is similar to what happens in
decimal when certain singledigit numbers are added together; if
the result equals or exceeds the value of the radix (10), the digit
to the left is incremented:
 5 + 5 → 0, carry 1 (since 5 + 5 = 0 + 1 × 10)
 7 + 9 → 6, carry 1 (since 7 + 9 = 6 + 1 × 10)
This is known as
carrying. When the result of an addition
exceeds the value of a digit, the procedure is to "carry" the
excess amount divided by the radix (that is, 10/10) to the left,
adding it to the next positional value. This is correct since the
next position has a weight that is higher by a factor equal to the
radix. Carrying works the same way in binary:
1 1 1 1 1 (carried digits)
0 1 1 0 1
+ 1 0 1 1 1

= 1 0 0 1 0 0
In this example, two numerals are being added together:
01101
_{2} (13
_{10}) and 10111
_{2}
(23
_{10}). The top row shows the carry bits used. Starting
in the rightmost column, 1 + 1 = 10
_{2}. The 1 is carried
to the left, and the 0 is written at the bottom of the rightmost
column. The second column from the right is added: 1 + 0 + 1 =
10
_{2} again; the 1 is carried, and 0 is written at the
bottom. The third column: 1 + 1 + 1 = 11
_{2}. This time, a
1 is carried, and a 1 is written in the bottom row. Proceeding like
this gives the final answer 100100
_{2} (36 decimal).
When computers must add two numbers, the rule that:x
xor y = (x + y)
mod 2for any two bits x and y allows for
very fast calculation, as well.
A simplification for many binary addition problems is the
Long Carry Method or
Brookhouse Method of Binary
Addition. This method is generally useful in any binary
addition where one of the numbers has a long string of “1” digits.
For example the following large binary numbers can be added in two
simple steps without multiple carries from one place to the
next.
1 1 1 1 1 1 1 1 (carried digits) (Long Carry Method)
1 1 1 0 1 1 1 1 1 0 1 1 1 0 1 1 1 1 1 0
+ 1 0 1 0 1 1 0 0 1 1 Versus: + 1 0 1 0 1 1 0 0 1 1
 + 1 0 0 0 1 0 0 0 0 0 0 sum of crossed out digits
= 1 0 0 0 1 1 1 0 0 0 1  now add remaining digits
1 1 0 0 1 1 1 0 0 0 1
In this example, two numerals are being added together: 1 1 1 0 1 1
1 1 1 0
_{2} (958
_{10}) and 1 0 1 0 1 1 0 0 1
1
_{2} (691
_{10}). The top row shows the carry bits
used. Instead of the standard carry from one column to the next,
the lowest placevalued "1" with a "1" in the corresponding place
value beneath it may be added and a "1" may be carried to one digit
past the end of the series. These numbers must be crossed off since
they are already added. Then simply add that result to the
uncanceled digits in the second row. Proceeding like this gives the
final answer 1 1 0 0 1 1 1 0 0 0 1
_{2}
(1649
_{10}).
Subtraction
Subtraction works in much the same
way:
 0 − 0 → 0
 0 − 1 → 1, borrow 1
 1 − 0 → 1
 1 − 1 → 0
Subtracting a "1" digit from a "0" digit produces the digit "1",
while 1 will have to be subtracted from the next column. This is
known as
borrowing. The principle is the same as for
carrying. When the result of a subtraction is less than 0, the
least possible value of a digit, the procedure is to "borrow" the
deficit divided by the radix (that is, 10/10) from the left,
subtracting it from the next positional value.
* * * * (starred columns are borrowed from)
1 1 0 1 1 1 0
− 1 0 1 1 1

= 1 0 1 0 1 1 1
Subtracting a positive number is equivalent to
adding a
negative number of
equal
absolute value; computers
typically use
two's complement
notation to represent negative values. This notation eliminates the
need for a separate "subtract" operation. Using two's complement
notation subtraction can be summarized by the following
formula:
A − B = A + not B + 1
For further details, see
two's
complement.
Multiplication
Multiplication in binary is similar
to its decimal counterpart. Two numbers
A and
B
can be multiplied by partial products: for each digit in
B, the product of that digit in
A is calculated
and written on a new line, shifted leftward so that its rightmost
digit lines up with the digit in
B that was used. The sum
of all these partial products gives the final result.
Since there are only two digits in binary, there are only two
possible outcomes of each partial multiplication:
 If the digit in B is 0, the partial product is also
0
 If the digit in B is 1, the partial product is equal
to A
For example, the binary numbers 1011 and 1010 are multiplied as
follows:
1 0 1 1 (A)
× 1 0 1 0 (B)

0 0 0 0 ← Corresponds to a zero in B
+ 1 0 1 1 ← Corresponds to a one in B
+ 0 0 0 0
+ 1 0 1 1

= 1 1 0 1 1 1 0
Binary numbers can also be multiplied with bits after a
binary point:
1 0 1.1 0 1 (A) (5.625 in decimal)
× 1 1 0.0 1 (B) (6.25 in decimal)

1 0 1 1 0 1 ← Corresponds to a one in B
+ 0 0 0 0 0 0 ← Corresponds to a zero in B
+ 0 0 0 0 0 0
+ 1 0 1 1 0 1
+ 1 0 1 1 0 1

= 1 0 0 0 1 1.0 0 1 0 1 (35.15625 in decimal)
See also
Booth's
multiplication algorithm.
Division
Binary
division is again
similar to its decimal counterpart:
Here, the divisor is 101
_{2}, or 5 decimal, while the
dividend is 11011
_{2}, or 27 decimal. The procedure is the
same as that of decimal
long division;
here, the divisor 101
_{2} goes into the first three digits
110
_{2} of the dividend one time, so a "1" is written on
the top line. This result is multiplied by the divisor, and
subtracted from the first three digits of the dividend; the next
digit (a "1") is included to obtain a new threedigit
sequence:
1
___________
1 0 1 ) 1 1 0 1 1
− 1 0 1

0 1 1
The procedure is then repeated with the new sequence, continuing
until the digits in the dividend have been exhausted:
1 0 1
___________
1 0 1 ) 1 1 0 1 1
− 1 0 1

0 1 1
− 0 0 0

1 1 1
− 1 0 1

1 0
Thus, the quotient of 11011
_{2} divided by 101
_{2}
is 101
_{2}, as shown on the top line, while the remainder,
shown on the bottom line, is 10
_{2}. In decimal, 27 divided
by 5 is 5, with a remainder of 2.
Bitwise operations
Though not directly related to the numerical interpretation of
binary symbols, sequences of bits may be manipulated using
Boolean logical operators. When a string
of binary symbols is manipulated in this way, it is called a
bitwise operation; the logical
operators
AND,
OR, and
XOR may be performed on corresponding
bits in two binary numerals provided as input. The logical
NOT operation may be performed on individual bits
in a single binary numeral provided as input. Sometimes, such
operations may be used as arithmetic shortcuts, and may have other
computational benefits as well. For example, an
arithmetic shift left of a binary number is
the equivalent of multiplication by a (positive, integral) power of
2.
Conversion to and from other numeral systems
Decimal
To convert from a base10 integer numeral to its base2 (binary)
equivalent, the number is
divided by
two, and the remainder is the
leastsignificant bit. The (integer)
result is again divided by two, its remainder is the next most
significant bit. This process repeats until the result of further
division becomes zero.
Conversion from base2 to base10 proceeds by applying the
preceding algorithm, so to speak, in reverse. The bits of the
binary number are used one by one, starting with the most
significant bit. Beginning with the value 0, repeatedly double the
prior value and add the next bit to produce the next value. This
can be organized in a multicolumn table. For example to convert
10010101101
_{2} to decimal:
 { class="wikitable"
The result is 1197
_{10}. This method is an application of
the
Horner scheme.
The fractional parts of a number are converted with similar
methods. They are again based on the equivalence of shifting with
doubling or halving.
In a fractional binary number such as .11010110101
_{2}, the
first digit is \begin{matrix} \frac{1}{2} \end{matrix}, the second
\begin{matrix} (\frac{1}{2})^2 = \frac{1}{4} \end{matrix}, etc. So
if there is a 1 in the first place after the decimal, then the
number is at least \begin{matrix} \frac{1}{2} \end{matrix}, and
vice versa. Double that number is at least 1. This suggests the
algorithm: Repeatedly double the number to be converted, record if
the result is at least 1, and then throw away the integer
part.
For example, \begin{matrix} (\frac{1}{3})
\end{matrix}
_{10}, in binary, is:
 { class="wikitable"
Thus the repeating decimal fraction 0. ... is equivalent to the
repeating binary fraction 0. ... .
Or for example, 0.1
_{10}, in binary, is:
 { class="wikitable"
This is also a repeating binary fraction 0.0 ... . It may come as a
surprise that terminating decimal fractions can have repeating
expansions in binary. It is for this reason that many are surprised
to discover that 0.1 + ... + 0.1, (10 additions) differs from 1 in
floating point arithmetic.
In fact, the only binary fractions with terminating expansions are
of the form of an integer divided by a power of 2, which 1/10 is
not.
The final conversion is from binary to decimal fractions. The only
difficulty arises with repeating fractions, but otherwise the
method is to shift the fraction to an integer, convert it as above,
and then divide by the appropriate power of two in the decimal
base. For example:
 {
Another way of converting from binary to decimal, often quicker for
a person familiar with
hexadecimal, is
to do so indirectly—first converting (xin binary) into (xin
hexadecimal) and then converting (xin hexadecimal) into (xin
decimal).
For very large numbers, these simple methods are inefficient
because they perform a large number of multiplications or divisions
where one operand is very large. A simple divideandconquer
algorithm is more effective asymptotically: given a binary number,
it is divided by 10
^{k}, where
kis chosen
so that the quotient roughly equals the remainder; then each of
these pieces is converted to decimal and the two are
concatenated. Given a decimal number, it can
be split into two pieces of about the same size, each of which is
converted to binary, whereupon the first converted piece is
multiplied by 10
^{k}and added to the second
converted piece, where
kis the number of decimal digits in
the second, leastsignificant piece before conversion.
Hexadecimal
Binary may be converted to and from
hexadecimalsomewhat more easily. This is because
the
radixof the hexadecimal system (16) is a
power of the radix of the binary system (2). More specifically, 16
= 2
^{4}, so it takes four digits of binary to represent one
digit of hexadecimal.
The following table shows each hexadecimal digit along with the
equivalent decimal value and fourdigit binary sequence:
To convert a hexadecimal number into its binary equivalent, simply
substitute the corresponding binary digits:
 3A_{16} = 0011 1010_{2}
 E7_{16} = 1110 0111_{2}
To convert a binary number into its hexadecimal equivalent, divide
it into groups of four bits. If the number of bits isn't a multiple
of four, simply insert extra
0bits at the left
(called
padding). For example:
 1010010_{2} = 0101 0010 grouped with padding =
52_{16}
 11011101_{2} = 1101 1101 grouped = DD_{16}
To convert a hexadecimal number into its decimal equivalent,
multiply the decimal equivalent of each hexadecimal digit by the
corresponding power of 16 and add the resulting values:
 C0E7_{16} = (12 × 16^{3}) + (0 ×
16^{2}) + (14 × 16^{1}) + (7 × 16^{0}) =
(12 × 4096) + (0 × 256) + (14 × 16) + (7 × 1) =
49,383_{10}
Octal
Binary is also easily converted to the
octalnumeral system, since octal uses a radix of 8,
which is a
power of two(namely,
2
^{3}, so it takes exactly three binary digits to represent
an octal digit). The correspondence between octal and binary
numerals is the same as for the first eight digits of
hexadecimalin the table above. Binary 000 is
equivalent to the octal digit 0, binary 111 is equivalent to octal
7, and so forth.
 { class="wikitable" style="textalign:center"
Converting from octal to binary proceeds in the same fashion as it
does for
hexadecimal:
 65_{8} = 110 101_{2}
 17_{8} = 001 111_{2}
And from binary to octal:
 101100_{2} = 101 100_{2} grouped =
54_{8}
 10011_{2} = 010 011_{2} grouped with padding =
23_{8}
And from octal to decimal:
 65_{8} = (6 × 8^{1}) + (5 × 8^{0}) = (6
× 8) + (5 × 1) = 53_{10}
 127_{8} = (1 × 8^{2}) + (2 × 8^{1}) +
(7 × 8^{0}) = (1 × 64) + (2 × 8) + (7 × 1) =
87_{10}
Representing real numbers
Nonintegers can be represented by using negative powers, which are
set off from the other digits by means of a
radix point(called a
decimal pointin the decimal system). For
example, the binary number 11.01
_{2}thus means:
 {
For a total of 3.25 decimal.
All
dyadic rational
numbers\frac{p}{2^a}have a
terminatingbinary
numeral—the binary representation has a finite number of terms
after the radix point. Other
rational
numbershave binary representation, but instead of terminating,
they
recur, with a finite sequence of digits repeating
indefinitely. For instance
 \frac{1_{10}}{3_{10}} = \frac{1_2}{11_2} = 0.01010101
..._{2}
 \frac{12_{10}}{17_{10}} = \frac{1100_2}{10001_2} = 0.10110100
10110100 ..._{2}
The phenomenon that the binary representation of any rational is
either terminating or recurring also occurs in other radixbased
numeral systems. See, for instance, the explanation in
decimal. Another similarity is the existence of
alternative representations for any terminating representation,
relying on the fact that 0.111111... is the sum of the
geometric series2
^{−1}+
2
^{−2}+ 2
^{−3}+ ... which is 1.
Binary numerals which neither terminate nor recur represent
irrational numbers. For instance,
 0.10100100010000100000100.... does have a pattern, but it is
not a fixedlength recurring pattern, so the number is
irrational
 1.0110101000001001111001100110011111110... is the binary
representation of \sqrt{2}, the square
root of 2, another irrational. It has no discernible pattern.
See irrational number.
See also
Notes
 W. S. Anglin and J. Lambek, The Heritage of Thales,
Springer, 1995, ISBN 038794544X
References
 Sanchez, Julio; Canton, Maria P. (2007), Microcontroller
programming : the microchip PIC, Boca Raton, FL: CRC Press, p. 37,
ISBN 0849371899
External links
Prior value 
× 2 + 
Next Bit 
Next value 

0 
× 2 + 
1 
= 1 

1 
× 2 + 
0 
= 2 

2 
× 2 + 
0 
= 4 

4 
× 2 + 
1 
= 9 

9 
× 2 + 
0 
= 18 

18 
× 2 + 
1 
= 37 

37 
× 2 + 
0 
= 74 

74 
× 2 + 
1 
= 149 

149 
× 2 + 
1 
= 299 

299 
× 2 + 
0 
= 598 

598 
× 2 + 
1 
= 1197 

Binary 
1 
0 
0 
1 
0 
1 
0 
1 
1 
0 
1 


Decimal 
1×2^{10} + 
0×2^{9} + 
0×2^{8} + 
1×2^{7} + 
0×2^{6} + 
1×2^{5} + 
0×2^{4} + 
1×2^{3} + 
1×2^{2} + 
0×2^{1} + 
1×2^{0} = 
1197 
Converting 
Result 

\begin{matrix} \frac{1}{3} \end{matrix} 
0. 

\begin{matrix} \frac{1}{3} \times 2 = \frac{2}{3} 1
\end{matrix} 
0.0 

\begin{matrix} \frac{2}{3} \times 2 = 1\frac{1}{3} \ge 1
\end{matrix} 
0.01 

\begin{matrix} \frac{1}{3} \times 2 = \frac{2}{3} 1
\end{matrix} 
0.010 

\begin{matrix} \frac{2}{3} \times 2 = 1\frac{1}{3} \ge 1
\end{matrix} 
0.0101 
Converting 
Result 

0.1 
0. 

0.1 × 2 = 0.2 1 
0.0 

0.2 × 2 = 0.4 1 
0.00 

0.4 × 2 = 0.8 1 
0.000 

0.8 × 2 = 1.6 ≥ 1 
0.0001 

0.6 × 2 = 1.2 ≥ 1 
0.00011 

0.2 × 2 = 0.4 1 
0.000110 

0.4 × 2 = 0.8 1 
0.0001100 

0.8 × 2 = 1.6 ≥ 1 
0.00011001 

0.6 × 2 = 1.2 ≥ 1 
0.000110011 

0.2 × 2 = 0.4 1 
0.0001100110 
x 
= 
1100 
.1 ... 

x \times 2^6 
= 
1100101110 
. ... 

x \times 2 
= 
11001 
. ... 

x \times (2^6  2) 
= 
1100010101 

x 
= 
(789/62)_{10} 

Hex 
Dec 
Binary 

0 
0 
0000 

1 
1 
0001 

2 
2 
0010 

3 
3 
0011 

4 
4 
0100 

5 
5 
0101 

6 
6 
0110 

7 
7 
0111 

8 
8 
1000 

9 
9 
1001 

A 
10 
1010 

B 
11 
1011 

C 
12 
1100 

D 
13 
1101 

E 
14 
1110 

F 
15 
1111 
Octal 
Binary 

0 
000 

1 
001 

2 
010 

3 
011 

4 
100 

5 
101 

6 
110 

7 
111 
1 × 2^{1} 
(1 × 2 = 2) 
plus 

1 × 2^{0} 
(1 × 1 = 1) 
plus 

0 × 2^{1} 
(0 × ½ = 0) 
plus 

1 × 2^{2} 
(1 × ¼ = 0.25) 