/* #region Head */

// #include <bits/stdc++.h>
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert> // assert.h
#include <cmath>   // math.h
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;

using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pll = pair<ll, ll>;
template <class T> using vc = vector<T>;
template <class T> using vvc = vc<vc<T>>;
using vll = vc<ll>;
using vvll = vvc<ll>;
using vld = vc<ld>;
using vvld = vvc<ld>;
using vs = vc<string>;
using vvs = vvc<string>;
template <class T, class U> using um = unordered_map<T, U>;
template <class T> using pq = priority_queue<T>;
template <class T> using pqa = priority_queue<T, vc<T>, greater<T>>;
template <class T> using us = unordered_set<T>;

#define REP(i, m, n) for (ll i = (m), i##_len = (ll)(n); i < i##_len; ++(i))
#define REPM(i, m, n) for (ll i = (m), i##_max = (ll)(n); i <= i##_max; ++(i))
#define REPR(i, m, n) for (ll i = (m), i##_min = (ll)(n); i >= i##_min; --(i))
#define REPD(i, m, n, d) for (ll i = (m), i##_len = (ll)(n); i < i##_len; i += (d))
#define REPMD(i, m, n, d) for (ll i = (m), i##_max = (ll)(n); i <= i##_max; i += (d))
#define REPI(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
#define REPIR(itr, ds) for (auto itr = ds.rbegin(); itr != ds.rend(); itr++)
#define ALL(x) begin(x), end(x)
#define SIZE(x) ((ll)(x).size())
#define PERM(c)                                                                                                        \
    sort(ALL(c));                                                                                                      \
    for (bool c##p = 1; c##p; c##p = next_permutation(ALL(c)))
#define UNIQ(v) v.erase(unique(ALL(v)), v.end());
#define CEIL(a, b) (((a) + (b)-1) / (b))

#define endl '\n'

constexpr ll INF = 1'010'000'000'000'000'017LL;
constexpr int IINF = 1'000'000'007LL;
constexpr ll MOD = 1'000'000'007LL; // 1e9 + 7
// constexpr ll MOD = 998244353;
constexpr ld EPS = 1e-12;
constexpr ld PI = 3.14159265358979323846;

template <typename T> istream &operator>>(istream &is, vc<T> &vec) { // vector 入力
    for (T &x : vec) is >> x;
    return is;
}
template <typename T> ostream &operator<<(ostream &os, const vc<T> &vec) { // vector 出力 (for dump)
    os << "{";
    REP(i, 0, SIZE(vec)) os << vec[i] << (i == i_len - 1 ? "" : ", ");
    os << "}";
    return os;
}
template <typename T> ostream &operator>>(ostream &os, const vc<T> &vec) { // vector 出力 (inline)
    REP(i, 0, SIZE(vec)) os << vec[i] << (i == i_len - 1 ? "\n" : " ");
    return os;
}

template <typename T, size_t _Nm> istream &operator>>(istream &is, array<T, _Nm> &arr) { // array 入力
    REP(i, 0, SIZE(arr)) is >> arr[i];
    return is;
}
template <typename T, size_t _Nm> ostream &operator<<(ostream &os, const array<T, _Nm> &arr) { // array 出力 (for dump)
    os << "{";
    REP(i, 0, SIZE(arr)) os << arr[i] << (i == i_len - 1 ? "" : ", ");
    os << "}";
    return os;
}

template <typename T, typename U> istream &operator>>(istream &is, pair<T, U> &pair_var) { // pair 入力
    is >> pair_var.first >> pair_var.second;
    return is;
}
template <typename T, typename U> ostream &operator<<(ostream &os, const pair<T, U> &pair_var) { // pair 出力
    os << "(" << pair_var.first << ", " << pair_var.second << ")";
    return os;
}

// map, um, set, us 出力
template <class T> ostream &out_iter(ostream &os, const T &map_var) {
    os << "{";
    REPI(itr, map_var) {
        os << *itr;
        auto itrcp = itr;
        if (++itrcp != map_var.end()) os << ", ";
    }
    return os << "}";
}
template <typename T, typename U> ostream &operator<<(ostream &os, const map<T, U> &map_var) {
    return out_iter(os, map_var);
}
template <typename T, typename U> ostream &operator<<(ostream &os, const um<T, U> &map_var) {
    os << "{";
    REPI(itr, map_var) {
        auto [key, value] = *itr;
        os << "(" << key << ", " << value << ")";
        auto itrcp = itr;
        if (++itrcp != map_var.end()) os << ", ";
    }
    os << "}";
    return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &set_var) { return out_iter(os, set_var); }
template <typename T> ostream &operator<<(ostream &os, const us<T> &set_var) { return out_iter(os, set_var); }
template <typename T> ostream &operator<<(ostream &os, const pq<T> &pq_var) {
    pq<T> pq_cp(pq_var);
    os << "{";
    if (!pq_cp.empty()) {
        os << pq_cp.top(), pq_cp.pop();
        while (!pq_cp.empty()) os << ", " << pq_cp.top(), pq_cp.pop();
    }
    return os << "}";
}

void pprint() { cout << endl; }
template <class Head, class... Tail> void pprint(Head &&head, Tail &&...tail) {
    cout << head;
    if (sizeof...(Tail) > 0) cout << ' ';
    pprint(move(tail)...);
}

// dump
#define DUMPOUT cerr
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail> void dump_func(Head &&head, Tail &&...tail) {
    DUMPOUT << head;
    if (sizeof...(Tail) > 0) DUMPOUT << ", ";
    dump_func(move(tail)...);
}

// chmax (更新「される」かもしれない値が前)
template <typename T, typename U, typename Comp = less<>> bool chmax(T &xmax, const U &x, Comp comp = {}) {
    if (comp(xmax, x)) {
        xmax = x;
        return true;
    }
    return false;
}

// chmin (更新「される」かもしれない値が前)
template <typename T, typename U, typename Comp = less<>> bool chmin(T &xmin, const U &x, Comp comp = {}) {
    if (comp(x, xmin)) {
        xmin = x;
        return true;
    }
    return false;
}

// ローカル用
#ifndef ONLINE_JUDGE
#define DEBUG_
#endif

#ifdef DEBUG_
#define DEB
#define dump(...)                                                                                                      \
    DUMPOUT << "  " << string(#__VA_ARGS__) << ": "                                                                    \
            << "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" << endl                                        \
            << "    ",                                                                                                 \
        dump_func(__VA_ARGS__)
#else
#define DEB if (false)
#define dump(...)
#endif

#define VAR(type, ...)                                                                                                 \
    type __VA_ARGS__;                                                                                                  \
    cin >> __VA_ARGS__;

template <typename T> istream &operator,(istream &is, T &rhs) { return is >> rhs; }
template <typename T> ostream &operator,(ostream &os, const T &rhs) { return os << ' ' << rhs; }

struct AtCoderInitialize {
    static constexpr int IOS_PREC = 15;
    static constexpr bool AUTOFLUSH = false;
    AtCoderInitialize() {
        ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
        cout << fixed << setprecision(IOS_PREC);
        if (AUTOFLUSH) cout << unitbuf;
    }
} ATCODER_INITIALIZE;

void Yn(bool p) { cout << (p ? "Yes" : "No") << endl; }
void YN(bool p) { cout << (p ? "YES" : "NO") << endl; }

/* #endregion */

// #include <atcoder/all>
// using namespace atcoder;

/* #region Rational */

// 分母は常に正になるようにしておく
// 大小比較したいときは， operator< を変える必要がある
// ABC168-E ほか
struct RationalNum {
    // 分子
    ll numerator;
    // 分母
    ll denominator;

    RationalNum() { numerator = 0, denominator = 1; }
    // RationalNum(double x);
    RationalNum(ll numerator_, ll denominator_ = 1) {
        numerator = numerator_, denominator = denominator_;
        simplify();
    }

    // 自身を簡約する
    void simplify() { RationalNum::simplifyNums(numerator, denominator); }

    static void simplifyNums(ll &numerator_, ll &denominator_) {
        if (denominator_ == 0) { // 分母が 0 のときの正規化
            if (numerator_ > 0)
                numerator_ = 1; // 無限大
            else if (numerator_ < 0)
                numerator_ = -1; // 無限小
            else
                numerator_ = 0; // 不定
        } else {
            ll g = gcd(numerator_, denominator_);
            numerator_ /= g, denominator_ /= g;
            if (denominator_ < 0) numerator_ *= -1, denominator_ *= -1;
        }
    }

    // 逆数を返す．
    RationalNum inv() const { return RationalNum(denominator, numerator); }

    // 小数点以下を切り上げた整数を返す
    ll ceil() const {
        if (numerator >= 0)
            return (numerator + denominator - 1) / denominator;
        else
            return numerator / denominator;
    }

    // 小数点以下を切り捨てた整数を返す
    ll floor() const {
        if (numerator >= 0)
            return numerator / denominator;
        else
            return (numerator - denominator + 1) / denominator;
    }

    // operator ll() const { return floor(); }

    // member function
    RationalNum &operator+=(const RationalNum &obj) { return *this = *this + obj; }
    RationalNum &operator-=(const RationalNum &obj) { return *this = *this - obj; }
    RationalNum &operator*=(const RationalNum &obj) { return *this = *this * obj; }
    RationalNum &operator/=(const RationalNum &obj) { return *this = *this / obj; }
    RationalNum &operator++() { return *this = *this + 1; }
    RationalNum operator++(int) {
        RationalNum before = *this;
        *this = *this + 1;
        return before;
    }
    RationalNum &operator--() { return *this = *this - 1; }
    RationalNum operator--(int) {
        RationalNum before = *this;
        *this = *this - 1;
        return before;
    }
    RationalNum operator+() const { return *this; }
    RationalNum operator-() const { return RationalNum(-numerator, denominator); }

    // friend functions
    friend RationalNum operator+(const RationalNum &left, const RationalNum &right);
    friend RationalNum operator-(const RationalNum &left, const RationalNum &right);
    friend RationalNum operator*(const RationalNum &left, const RationalNum &right);
    friend RationalNum operator/(const RationalNum &left, const RationalNum &right);
    friend bool operator==(const RationalNum &left, const RationalNum &right);
    friend bool operator!=(const RationalNum &left, const RationalNum &right);
    friend bool operator<(const RationalNum &left, const RationalNum &right);
    friend bool operator>(const RationalNum &left, const RationalNum &right);
    friend bool operator<=(const RationalNum &left, const RationalNum &right);
    friend bool operator>=(const RationalNum &left, const RationalNum &right);
    friend ostream &operator<<(ostream &out, const RationalNum &obj);
    friend istream &operator>>(istream &in, RationalNum &obj);
};

/* #region RationalFriendFunctions */

RationalNum operator+(const RationalNum &left, const RationalNum &right) {
    if (left.denominator == 0 && right.denominator == 0) {
        if ((left > 0 && right > 0) || (left < 0 && right < 0)) {
            return left; // 無限大・無限小
        } else {
            return RationalNum(0, 0); // 不定
        }
    } else if (left.denominator == 0) {
        return left;
    } else if (right.denominator == 0) {
        return right;
    }
    RationalNum temp;
    ll tempLD = left.denominator;
    ll tempRD = right.denominator;
    RationalNum::simplifyNums(tempLD, tempRD);
    temp.denominator = left.denominator * tempRD;
    temp.numerator = left.numerator * tempRD + right.numerator * tempLD;
    temp.simplify();
    return temp;
}

RationalNum operator-(const RationalNum &left, const RationalNum &right) { return left + (-right); }

RationalNum operator*(const RationalNum &left, const RationalNum &right) {
    ll a = left.denominator, b = right.numerator, c = right.denominator, d = left.numerator;
    RationalNum::simplifyNums(b, a), RationalNum::simplifyNums(d, c);
    return RationalNum(b * d, a * c);
}

RationalNum operator/(const RationalNum &left, const RationalNum &right) { return left * right.inv(); }

bool operator==(const RationalNum &left, const RationalNum &right) {
    return (left.numerator == right.numerator && left.denominator == right.denominator);
}

bool operator!=(const RationalNum &left, const RationalNum &right) { return !(left == right); }

// bool operator<(const RationalNum &left, const RationalNum &right) {
//     RationalNum indeterminate(0, 0);
//     if (left == indeterminate || right == indeterminate) {
//         // どちらかが不定のときは大小を正しく計算できないので，特別扱いする
//         // 便宜上，不定は「無限大より大きい」として扱う
//         if (right != indeterminate) {
//             return false;
//         } else if (left != indeterminate) {
//             return true;
//         } else {
//             return false;
//         }
//     }
//     ll lside = left.getNumerator() * right.getDenominator();
//     ll rside = left.getDenominator() * right.getNumerator();
//     return (lside < rside);
// }
// 積が ll を超えることもあるので，map のキーで使うとかのときは，
// 異なる RationalNum の間に必ず大小関係が定義できるこちらを使う?
bool operator<(const RationalNum &left, const RationalNum &right) {
    return left.numerator == right.numerator ? left.denominator < right.denominator : left.numerator < right.numerator;
}

bool operator>(const RationalNum &left, const RationalNum &right) {
    // ll lside = left.getNumerator() * right.getDenominator();
    // ll rside = left.getDenominator() * right.getNumerator();
    // return (lside > rside);
    return !(left < right) && (left != right);
}

bool operator<=(const RationalNum &left, const RationalNum &right) { return ((left < right) || (left == right)); }

bool operator>=(const RationalNum &left, const RationalNum &right) { return ((left > right) || (left == right)); }

// 出力
ostream &operator<<(ostream &out, const RationalNum &obj) {
    if (obj.denominator == 0) {
        if (obj.numerator > 0)
            out << "inf";
        else if (obj.numerator < 0)
            out << "-inf";
        else
            out << "indeterminate";
    } else {
        out << obj.numerator;
        if (obj.numerator != 0 && obj.denominator != 1) out << "/" << obj.denominator;
    }
    return out;
}

/* #endregion */

template <typename T> void hash_combine(size_t &seed, T const &v) {
    //基本型に関するハッシュ生成は標準ライブラリが提供している
    std::hash<T> primitive_type_hash;

    //生成したハッシュを合成する。このコードはboostものを使用する
    seed ^= primitive_type_hash(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
template <> struct std::hash<RationalNum> {
  public:
    //クラスのメンバの値それぞれについてハッシュ生成して、それらを結合して一つのハッシュ値にする
    size_t operator()(const RationalNum &data) const {
        std::size_t seed = 0;
        hash_combine(seed, data.numerator);
        hash_combine(seed, data.denominator);
        return seed;
    }
};

/* #endregion */

/* #region Trash */

// RationalNum &operator=(const RationalNum &obj);

// RationalNum &RationalNum::operator=(const RationalNum &obj) {
//     setNumerator(obj.getNumerator()), setDenominator(obj.getDenominator());
//     return *this;
// }

// 入力
istream &operator>>(istream &in, RationalNum &obj) {
    string inputstr;
    ll num = 0;
    int sign = 1;
    bool slashExist = false;
    bool dotExist = false;
    // bool validInput = true;
    ll virtualDenominator = 1;
    cin >> inputstr;
    REP(i, 0, SIZE(inputstr)) {
        char temp = inputstr[i];
        if (temp == '.') {
            if (dotExist == false && slashExist == false && i != 0) {
                dotExist = true;
            }
            // else {
            //     validInput = false;
            //     break;
            // }
        } else if (temp == '/') {
            if (dotExist == false && slashExist == false && i != 0) {
                slashExist = true;
                obj.numerator = (sign * num);
                num = 0;
                sign = 1;
            }
            // else {
            //     validInput = false;
            //     break;
            // }
        } else if (temp == '-') {
            if (i == 0) {
                sign = -sign;
            } else if (inputstr[i - 1] == '/') {
                sign = -sign;
            }
            // else {
            //     validInput = false;
            //     break;
            // }
        } else if (temp <= '9' && temp >= '0') {
            if (dotExist) {
                // if (virtualDenominator > INF / 10) {
                //     cerr << "this frational is too long to handle.";
                //     validInput = false;
                //     break;
                // } else
                virtualDenominator *= 10;
            }
            // if (num > INF / 10) {
            //     cerr << "this number is too long to handle.";
            //     validInput = false;
            //     break;
            // }
            num *= 10;
            num += inputstr[i] - '0';
        }
        // else {
        //     validInput = false;
        //     break;
        // }
    }

    // if (validInput == false) {
    //     obj.numerator = (0);
    //     obj.denominator = (1);
    //     cerr << "Input is not valid! The whole set to 0" << endl;
    // }

    if (slashExist == true) {
        obj.denominator = (sign * num);
    } else if (dotExist) {
        obj.numerator = (sign * num);
        obj.denominator = (virtualDenominator);
    } else {
        obj.numerator = (sign * num);
        obj.denominator = (1);
    }

    obj.simplify();
    return in;
}

// RationalNum::RationalNum(double x) {
//     int i = 1;
//     while (x * i - static_cast<int>(x * i) != 0) {
//         if (i > INT_MAX / 10) {
//             cout << "this frational number : " << x
//                  << " can not be transfer to rational number, it's too long, now set it 0." << endl;
//             setNumerator(0), setDenominator(1);
//             return;
//         } else {
//             i *= 10;
//         }
//     }
//     setNumerator(x * i);
//     setDenominator(i);
//     simplify();
// }

/* #endregion */

// Problem
void solve() {
    RationalNum x;
    cin >> x;
    if (x.denominator == 1)
        cout << x << "/1" << endl;
    else
        pprint(x);
}

// entry point
int main() {
    solve();
    return 0;
}