from math import *

def hexprint(y):
    hexterm=[]
    for x in y: hexterm.append(hex(x))
    print hexterm

def longmult(m):
# multiplies term by m
    s=99
    K=term[s-1]
# c is set to 1 first time round loop
    carry=0L
    while True:
        A=carry
#        if s<s0: return
        A=A + K*m
        K=term[s-2]
        M=(A >> 39) & 0xffffffffff
        L=A & 0x7fffffffff
        term[s-1]=M
        M=L + term[s]
# store term ignoring overflow
        term[s]=M
        carry=0
# if carry set carry=1
        if M>N-1:
            M=M & 0x7fffffffff
            term[s]=M
            carry=1
        s=s-1
        if s==0: return

def scale(A):
# operation similar to EDSAC 90 order
# left shifts A as many places as possible without overflow,
# sets s to minus number of places shifted.
    s=0
    if A==0: return(A, -129)
    A1=A
    while True:
        A2=A1<<1
        if A2>NN-1 or A2<-NN: break
        A1=A2; s=s-1
    return (A1, s)

N=2**39L
NN=N*N
term=[0L for i in range(0,100)]
Sum =[0L for i in range(0,100)]
n=5
# x=N x approx sqrt(n)
x=int(N*sqrt(n))
x=x/n
# x is certainly less than N
# remove last 5 bits of x
x=x & 0xffffffffe0
xn=x
x=n*x
# x is now approximately N*sqrt(n) but suitably rounded and a multiple of n
(z,t)=scale(x)
# z is now double length sqrt(n) scaled and zeros on end
z=z >> 39
# z is now single length
zsq=z*z
# zsq is now approximately double length n, scaled
# it is less than the scaled value of n so to avoid logical shifts on
# negative numbers we change sign.  This differs from EDSAC code
# remove most significant bits of zsq
#print zsq*2**-78, hex(zsq)
#print hex(-zsq << 10)
eps = (-zsq << 10) & 0xffffffffffffffffffff
#print hex(eps)
# shift right to undo scaling
eps = eps >> (-68-2*t)
(eps,s)=scale(eps)
#print eps, hex(eps)
eps=eps>>39
print hex(eps/n), eps%n
eps=eps/n
x14=1 << s+39
# set first term and sum by hand
term[0]=xn*n >> 39; term[1]=xn*n & 0x7fffffffff
Sum[0]=term[0]
Sum[1]=term[1]

#hexprint(term)

# initial counts
n6=1
n8=2
s=0
k=1
while True:
    longmult(eps)
    longmult(n6)
    longmult(x14)
# multiple length division by n
    r=0
# r is remainder from previous division
    while True:
        a=r*N + term[s]
        term[s-1]=a/n8
        r=a%n8
        if s>=99: break
        s=s+1
#    hexprint(term)
#    hexprint(Sum)
# add term to sum, starting with last digit
    t=100
    while True:
# preserve t (79 order)
        copy_of_t=t
        M=term[t-1]
# forget about digits in term that are zero
        if M!=0:

# enter loop with carry digit until carry is zero
            while True:
# set s to place of last non-zero digit
                s=copy_of_t
                M=M + Sum[t-1]
                Sum[t-1]=M
# overflow has occurred
                if M>N-1:
                    M=M & 0x7fffffffff
                    Sum[t-1]=M
                    t=t-1
                    M=1
                else:
                    t=copy_of_t
                    break
# move on to add next digit to sum
        t=t-1
        if t==0: break
# added with term, increment n
#    hexprint(Sum)
#    if k==4: 1/0

    n6=n6+2
    n8=n8+2
# s has been set to place of last non-zero digit, decrement to get new start
    s=s-1
    k=k+1
#    print k, s, t, copy_of_t
#    if k>10: 1/0
    if s>=98: break
#hexprint(Sum)
#
# print result
#
#for i in Sum:
#    print hex(i)

tenten=10000000000L
print "2."
t=0
while True:
    K=Sum[99]
    s=99
    c=0
    while True:
        M=c+K*tenten
        K=Sum[s-1]
        Sum[s-1]=M/N
        a=M%N + Sum[s]
        Sum[s]=a%N
        if a>N: c=1
        else:   c=0
        s=s-1
        if s==0: break
    print Sum[0]
    t=t+1
    if t>=100: break