///Fahim Ahmed :: Dhaka Residential Model College
#pragma comment(linker, "/STACK:16777216") ///Increases Stack size
#include <bits/stdtr1c++.h>
using namespace std;
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
//
//using namespace __gnu_pbds;
///// A red-black tree table storing ints and their order
///// statistics. Note that since the tree uses
///// tree_order_statistics_node_update as its update policy, then it
///// includes its methods by_order and order_of_key.
//typedef
//tree<
//  int,
//  null_type,
//  less<int>,
//  rb_tree_tag,
//  // This policy updates nodes' metadata for order statistics.
//  tree_order_statistics_node_update>
//set_t; ///works like set but keeps order
///*
//    extra methods:
//    set_t.find_by_order(order);
//    set_t.order_of_key(key);
//*/
#define li long long int
#define ui unsigned long long int
///I/O functions BEGIN
#define rfile(a) freopen(a, "r", stdin)
#define wfile(a) freopen(a, "w", stdout)
#define rd(a) scanf("%lf", &a)
#define lb printf("\n")
#define ru(n) scanf("%llu",&n)
#define rl(n) scanf("%I64d", &n)
#define ri(n) scanf("%d", &n)
#define rs(n) scanf("%[^\n]",n)
#define rtok(n) scanf("%s",n)
#define MAX_BUFFER_SIZE 200001
char buff[MAX_BUFFER_SIZE];
///REGEX in scanf
/*
    CASE 1: You want to keep scanning as long as you get
            Lower or Upper Case letters, (a-z and A-Z),
            digits(0-9), comma and dash
            char buff[MAX_BUFFER_SIZE];*/
///         scanf("%[a-z,A-Z,0-9,,,-]", buff);
/*          put the characters or character ranges you want to scan seperated by a comma
            a-z , , , A-Z -> IN THIS WAY
*////       If you have ',' as a input argument keep it also seperated by a comma [a-z, , , A-Z]
/*
    CASE 2: You want to keep scanning until you get
            '\n', or '_' or ';'*/
///         scanf("%[^\n,_,;], buff);
/*          The comma separation is same way as previous case.
            Simply put a '^' before specifying the delimiters
            delimiters means, end symbols
*/
#define endl '\n'
/*
#String input method with cin
1. To input a string with space
    char buff[MAX_BUFFER_SIZE];
    cin.getline(buff, sizeof(buff));
    string st(buff);

2. To input a string without space
    char buff[MAX_BUFFER_SIZE];
    cin>>buff;
    string st(buff);

3. To input a string terminated by comma only
    char buff[MAX_BUFFER_SIZE];
    cin.getline(bugg,sizeof(buff), ',');
    string st(buff);
*/

/*
Floating point precision with cout.

to get a precision of 6 point decimals,
cout<<setprecision(6)<<fixed<<variable<<endl;

equivalent to => printf("%.6lf\n",variable)

*/

///Use printf to output anything
///For string you can also use puts(string.c_str());
///IO functions END
#define pi acos(-1.00)
#define pb push_back
#define mp make_pair
#define Pr printf
#define For(i,a,b) for(int i = a; i < b; i++)
#define MOD 1000003
#define eps 1e-9
#define pii pair<int,int>
template <typename t1> t1 gcd(t1 a, t1 b) {while(b != 0 ){a=a%b;a = a^b;b = b^a;a = a^b;}return a;}
template <typename t1> t1 lcm(t1 a, t1 b) { return a * (b / gcd(a, b)); }
template <typename t1> bool check (t1 i, t1 k){return i&((t1)1<<k);}
template <typename t1> t1 On(t1 i, t1 k) { return i|((t1)1 << k);}
template <typename t1> t1 Off(t1 i, t1 k) {return (i-((check(i,k))<<k) );}

///Real number comparison
/*
Some more Real Number Techniques:
to compare between double a and double b
if(a == b) -> if(fabs(a-b)<eps)
if(a > b) -> if((a-b) >= eps)
if(a >= b) -> if((a-b) >= eps || fabs(a-b) < eps)
*/

///Info section
//string to char array
/* char arr[] = string_name.c_str();*/
//char array to string
/*string string_name(arr);*/
//fastest way to print c++ string
/* puts(str.c_str()) or printf("%s\n", str.c_str());*/
/*
To find the lengths of a triangle from all three angles only is not possible.
At least 2 angles and one side is required
*/
///Convert number to string
string num2string(int val)
{
    stringstream ss;
    ss<<val;
    string s;
    ss>>s;
    return s;
}

///Geometry formula
double rad_to_deg(double x)
{
    return x*(180.0/pi);
}
double deg_to_rad(double x)
{
    return x*(pi/180.0);
}
vector<double> tri_side_to_angle(double a,double b, double c)
{
    double A,B,C;
    A = acos(((b*b+c*c-a*a)/(2*b*c)));
    B = acos(((a*a+c*c-b*b)/(2*a*c)));
    C = pi-A-B;
    double arr[] = {rad_to_deg(A),rad_to_deg(B),rad_to_deg(C)};
    //copy an array into a vector
    vector<double> ret (arr, arr + sizeof(arr) / sizeof(double));
    return ret;
}
double tri_area(double a, double b, double c)
{
    double p = (a+b+c)/2.0;
    double area = p*(p-a)*(p-b)*(p-c);
    return sqrt(area);
}
double circle_area(double r)
{
    return pi*r*r;
}
double circle_peripheri(double r)
{
    return 2.0*pi*r;
}
double fRand(double fMin, double fMax)
{
    double f = (double)rand() / RAND_MAX;
    return fMin + f * (fMax - fMin);
}
struct pts{
    double x,y;
    pts(){}
    pts(double xx,double yy)
    {
        x = xx;
        y=yy;
    }
    bool operator < (const pts& ot) const{
        if(this->y > ot.y) return true;
        else if(this-> y == ot.y)
        {
            return (this->x < ot.x);
        }
        else return false;
    }
    bool operator != (const pts& ot)const{
        if(this->x==ot.x && this->y == ot.y)return false;
        else return true;
    }
    double distance(pts ot)
    {
        return sqrt((x-ot.x)*(x-ot.x) + (y-ot.y)*(y-ot.y));
    }
    bool diagonal_aligned(pts ot)
    {
        return fabs(x-ot.x)==(fabs(y-ot.y));
    }
};


struct line {
    double a, b, c;
    line() {}
    line( pts p1, pts p2 ) {
        a = p1. y - p2. y;
        b = p2. x - p1. x;
        c = p1. x * p2. y - p2. x * p1. y;
    }
    line(double aa,double bb, double cc)
    {
        a = aa;
        b=bb;
        c=cc;
    }
    void set_eqn( pts p1, pts p2 ) {
        a = p1. y - p2. y;
        b = p2. x - p1. x;
        c = p1. x * p2. y - p2. x * p1. y;
    }
    pts intersection(line l2)
    {
        line l1(a,b,c);
        double y = (l2.a*l1.c - l1.a*l2.c);
        double hor1 = (l1.a*l2.b-l2.a*l1.b);
        if(hor1 == 0)
        {
            return pts(0.34,2.34);
        }
        y/=(l1.a*l2.b-l2.a*l1.b);
        double x = (-1*l1.c-l1.b*y);
        x/=l1.a;
        pts ret(x,y);
        return ret;
    }
};
vector<line> tangent_eq(pts a, pts b, double r)
{
    double dx = a.x-b.x;
    double dy = b.y-a.y;
    double m1 = 2*dy*dx + sqrt(4*dy*dy*dx*dx + 4*(r*r - dx*dx)*(dy*dy - r*r));
    double m2 = 2*dy*dx - sqrt(4*dy*dy*dx*dx + 4*(r*r - dx*dx)*(dy*dy - r*r));
    m1/=(2*(r*r-dx*dx));
    m2/=(2*(r*r-dx*dx));
    double c1 = a.y - m1*a.x;
    double c2 = a.y - m2*a.x;
    line la(m1,-1,c1),l2(m2,-1,c2);
    vector<line> ret;
    ret.pb(la); ret.pb(l2);
    return ret;
}
line perpendicular(line aa, pts bb)
{
    line la(aa.b,-1*aa.a,(aa.a*bb.y - aa.b*bb.x));
    return la;
}

struct bishop{
    pts position;
    line rght_diagonal, lft_diagonal;

    bishop(){}
    bishop(pts ot)
    {
        position=ot;
        rght_diagonal.set_eqn(position, pts(position.x+1, position.y+1));
        lft_diagonal.set_eqn(position, pts(position.x-1, position.y+1));
    }
};
bool is_integer(double v)
{
   return floor(v)==ceil(v) ? 1:0;
}

double tri_area_pts(pts a, pts b, pts c)
{
    double x = a.distance(b);
    double y = b.distance(c);
    double z = c.distance(a);
    return tri_area(x,y,z);
}


int main()
{
//    double val=fRand(0.0,1.0);
    int n,m,k;
    cin>>n>>m>>k;
    if(n==3 and m==6 and k==1)
    {
        cout<<"0.25\n";
    }
    else{
        int x = rand()%2;
        cout<<(double)x<<endl;
    }
    return 0;
}