1.0 200.0 200.0
 0.2 0.1 0.6
 1.9 3.0 4.1
 51.8 51.8 7.1
 113.9 125.2 88.8
 1.9 4.8 3.9
 2.2 148.1 138.0
 1.0 200.0 1.0
 1.7 4.5 4.2
 0.2 0.6 0.3
 200.0 200.0 0.1
 3.9 0.2 3.8
 7.0 131.1 7.4
 4.6 4.4 2.3
 2.0 1.1 2.4
 2.4 3.8 2.7
 0.1 0.5 0.2
 1.8 0.4 2.7
 1.1 1.1 1.1
 3.7 2.2 4.8
 3.9 2.1 4.5
 1.0 1.0 200.0
 104.6 184.4 82.3
 149.4 15.5 82.0
 0.5 0.5 0.6
 1.1 1.5 1.0
 0.3 0.4 0.4
 0.3 0.5 0.6
 0.2 0.2 0.5
 1.0 1.0 1.0
 0.2 0.7 0.6
 144.0 70.4 148.1
 25.9 77.0 144.8
 0.9 1.0 0.1
 0.5 0.3 0.2
 2.0 1.0 4.0
 4.0 2.0 1.0
 1.0 2.0 4.0
 0.5 0.5 0.1
 0.6 0.2 0.5
 185.9 9.6 163.4
 0.8 0.3 0.6
 200.0 1.0 200.0
 1.1 3.1 4.9
 3.7 3.7 4.1
 0.1 0.2 0.6
 1.5 1.3 0.1
 4.6 2.1 1.6
 0.1 200.0 0.1
 1.0 0.3 1.1
 0.3 0.3 0.5
 0.1 0.1 0.4
 55.5 159.4 140.3
 4.4 3.7 3.4
 200.0 1.0 1.0
 0.1 1.4 0.3
 1.4 0.5 0.8
 1.1 1.5 0.4
 51.5 156.3 145.1
 0.1 0.3 0.5
 153.9 122.1 89.5
 1.8 1.8 2.1
 0.5 0.1 0.9
 0.6 0.6 1.1
 4.6 3.0 3.4
 0.1 0.4 0.3
 0.6 0.3 0.2
 196.9 3.0 4.1
 3.0 3.0 3.1
 4.4 0.5 2.0
 4.5 1.3 4.8
 64.6 117.1 81.6
 117.4 68.8 137.7
 141.1 108.1 14.9
 81.7 171.9 4.4
 0.2 0.3 0.1
 156.9 154.8 73.9
 1.5 1.4 1.1
 0.4 1.1 0.9
 0.4 1.1 0.8
 0.1 200.0 200.0
 0.5 0.3 0.1
 1.0 2.0 1.0
 1.4 1.1 1.0
 0.7 1.4 0.4
 28.9 39.3 148.4
 1.7 1.9 4.4
 0.5 0.8 0.3
 200.0 0.1 0.1
 0.5 0.2 0.2
 0.6 0.4 0.3
 0.9 1.2 0.2
 4.3 2.4 4.9
 0.9 2.0 4.8
 189.4 63.7 63.4
 38.7 142.2 89.8
 0.3 0.4 0.1
 1.9 1.1 4.8
 0.4 0.1 0.6
 4.2 1.1 1.2
 1.5 1.7 2.5
 184.1 118.5 129.5
 200.0 200.0 200.0
 0.5 0.4 0.5
 1.2 0.7 1.3
 3.9 4.3 3.4
 193.9 40.7 19.7
 0.5 0.2 0.3
 36.9 51.1 4.8
 0.2 0.1 0.2
 0.2 0.6 0.4
 0.1 0.1 200.0
 0.9 4.6 3.4
 2.0 4.0 1.0
 0.2 0.3 0.2
 0.4 1.0 1.5
 1.4 1.2 1.4
 1.2 0.6 0.5
 2.0 2.1 2.2
 0.1 0.2 0.3
 0.8 0.4 1.4
 1.4 0.3 1.4
 4.0 1.0 2.0
 0.1 0.5 0.4
 0.4 0.2 0.3
 4.0 0.4 3.1
 200.0 0.1 200.0
 1.0 4.0 2.0
 0.3 0.4 1.2
 94.5 56.3 59.8
 1.4 0.8 0.9
 200.0 200.0 1.0
 1.4 0.8 0.2
 3.9 0.7 4.7
 144.6 103.0 193.4
 0.5 0.1 0.3
 0.1 0.4 0.2
 0.1 0.1 0.1
 1.2 0.5 1.2
 198.7 23.7 89.1
 139.3 87.4 129.9
 4.1 3.5 4.5
 2.2 3.1 3.0
 91.8 170.4 7.7
 41.7 104.5 74.2

y^z^x
 (z^x)^y
 x^y^z
 z^x^y
 z^x^y
 x^z^y
 x^z^y
 y^x^z
 x^z^y
 (y^x)^z
 (x^y)^z
 x^z^y
 x^z^y
 z^y^x
 (z^x)^y
 x^z^y
 (y^x)^z
 z^x^y
 (x^y)^z
 y^x^z
 y^x^z
 z^x^y
 z^x^y
 y^z^x
 (z^x)^y
 y^x^z
 (y^x)^z
 (z^x)^y
 (z^x)^y
 x^y^z
 (y^x)^z
 y^x^z
 x^y^z
 y^x^z
 (x^y)^z
 x^z^y
 x^y^z
 y^z^x
 (x^y)^z
 (x^y)^z
 y^z^x
 (x^y)^z
 x^z^y
 x^y^z
 x^y^z
 (z^x)^y
 x^y^z
 z^y^x
 y^x^z
 z^x^y
 (z^x)^y
 (z^x)^y
 x^z^y
 z^y^x
 x^y^z
 y^z^x
 x^z^y
 y^x^z
 x^z^y
 (z^x)^y
 z^y^x
 (z^x)^y
 (z^x)^y
 z^x^y
 y^z^x
 (y^x)^z
 (x^y)^z
 y^z^x
 x^y^z
 x^z^y
 y^x^z
 x^z^y
 y^x^z
 z^y^x
 z^x^y
 (y^x)^z
 z^y^x
 (x^y)^z
 y^z^x
 y^z^x
 (y^x)^z
 (x^y)^z
 y^x^z
 x^y^z
 y^x^z
 x^y^z
 x^y^z
 (y^x)^z
 x^y^z
 (x^y)^z
 (x^y)^z
 y^x^z
 y^x^z
 (y^x)^z
 z^y^x
 x^z^y
 (y^x)^z
 x^z^y
 (z^x)^y
 (x^y)^z
 (z^x)^y
 y^z^x
 x^y^z
 (x^y)^z
 z^x^y
 z^x^y
 z^y^x
 (x^y)^z
 z^x^y
 (x^y)^z
 (y^x)^z
 z^x^y
 (z^x)^y
 x^y^z
 (y^x)^z
 z^y^x
 (x^y)^z
 x^y^z
 x^z^y
 (z^x)^y
 z^x^y
 x^z^y
 x^z^y
 (y^x)^z
 (x^y)^z
 x^z^y
 (x^y)^z
 y^z^x
 z^y^x
 y^z^x
 x^z^y
 x^y^z
 x^y^z
 (x^y)^z
 y^x^z
 (x^y)^z
 (y^x)^z
 (x^y)^z
 x^z^y
 y^z^x
 y^z^x
 y^x^z
 x^z^y
 z^x^y
 x^z^y

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.MathContext;
import java.math.RoundingMode;
import java.util.StringTokenizer;

public class D {
    BufferedReader br;
    PrintWriter out;
    StringTokenizer stok;

    String nextToken() throws IOException {
        while (stok == null || !stok.hasMoreTokens()) {
            String s = br.readLine();
            if (s == null) {
                return null;
            }
            stok = new StringTokenizer(s);
        }
        return stok.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    char nextChar() throws IOException {
        return (char) (br.read());
    }

    String nextLine() throws IOException {
        return br.readLine();
    }
    static final int SC = 200;
    public static BigDecimal powD(BigDecimal x, BigDecimal y) {

        return BigFunctions.exp( BigFunctions.ln(x, SC).multiply(y),SC );
    }
      String[] s = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
                  "y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
                  "z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};

    private void solve() throws IOException {

        BigDecimal x = new BigDecimal(nextDouble());
        BigDecimal y = new BigDecimal(nextDouble());
        BigDecimal z = new BigDecimal(nextDouble());long l = System.currentTimeMillis();
        BigDecimal[] p =new BigDecimal[12];
        p[0] = powD(x, powD(y, z));
        p[1] = powD(x, powD(z, y));
        p[2] = powD(powD(x, y), z);
        p[3] = powD(powD(x, z), y);
        p[4] = powD(y, powD(x, z));
        p[5] = powD(y, powD(z, x));
        p[6] = powD(powD(y, x), z);
        p[7] = powD(powD(y, z), x);
        p[8] = powD(z, powD(x, y));
        p[9] = powD(z, powD(y, x));
        p[10] = powD(powD(z, x), y);
        p[11] = powD(powD(z, y), x);
        int i = -1;
        BigDecimal max = new BigDecimal("-1");
        for (int j = 0; j < 12; j++) {
            if (p[j].compareTo(max) > 0) {
                max = p[j];
                i = j;
            }
        }
        out.println(s[i]);
System.err.print(System.currentTimeMillis() - l);
    }

    void run() throws IOException {
        // br = new BufferedReader(new FileReader("input.txt"));
        // out = new PrintWriter("output.txt");
        br = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
        solve();
        br.close();
        out.close();
    }

    public static void main(String[] args) throws IOException {
        // Locale.setDefault(Locale.US);
        new D().run();
    }
    static class BigFunctions
    {

        public static BigDecimal intPower(BigDecimal x, long exponent,
                                          int scale)
        {
            if (exponent < 0) {
                return BigDecimal.valueOf(1)
                        .divide(intPower(x, -exponent, scale), scale,
                                BigDecimal.ROUND_HALF_EVEN);
            }

            BigDecimal power = BigDecimal.valueOf(1);

            while (exponent > 0) {

                if ((exponent & 1) == 1) {
                    power = power.multiply(x)
                            .setScale(scale, BigDecimal.ROUND_HALF_EVEN);
                }

                x = x.multiply(x)
                        .setScale(scale, BigDecimal.ROUND_HALF_EVEN);
                exponent >>= 1;

                Thread.yield();
            }

            return power;
        }


        public static BigDecimal intRoot(BigDecimal x, long index,
                                         int scale)
        {
            if (x.signum() < 0) {
                throw new IllegalArgumentException("x < 0");
            }

            int        sp1 = scale + 1;
            BigDecimal n   = x;
            BigDecimal i   = BigDecimal.valueOf(index);
            BigDecimal im1 = BigDecimal.valueOf(index-1);
            BigDecimal tolerance = BigDecimal.valueOf(5)
                    .movePointLeft(sp1);
            BigDecimal xPrev;

            x = x.divide(i, scale, BigDecimal.ROUND_HALF_EVEN);

            do {
                BigDecimal xToIm1 = intPower(x, index-1, sp1);

                BigDecimal xToI =
                        x.multiply(xToIm1)
                                .setScale(sp1, BigDecimal.ROUND_HALF_EVEN);

                BigDecimal numerator =
                        n.add(im1.multiply(xToI))
                                .setScale(sp1, BigDecimal.ROUND_HALF_EVEN);

                BigDecimal denominator =
                        i.multiply(xToIm1)
                                .setScale(sp1, BigDecimal.ROUND_HALF_EVEN);

                xPrev = x;
                x = numerator
                        .divide(denominator, sp1, BigDecimal.ROUND_DOWN);

                Thread.yield();
            } while (x.subtract(xPrev).abs().compareTo(tolerance) > 0);

            return x;
        }

        public static BigDecimal exp(BigDecimal x, int scale)
        {
            if (x.signum() == 0) {
                return BigDecimal.valueOf(1);
            }

            else if (x.signum() == -1) {
                return BigDecimal.valueOf(1)
                        .divide(exp(x.negate(), scale), scale,
                                BigDecimal.ROUND_HALF_EVEN);
            }

            BigDecimal xWhole = x.setScale(0, BigDecimal.ROUND_DOWN);

            if (xWhole.signum() == 0) return expTaylor(x, scale);

            BigDecimal xFraction = x.subtract(xWhole);

            BigDecimal z = BigDecimal.valueOf(1)
                    .add(xFraction.divide(
                            xWhole, scale,
                            BigDecimal.ROUND_HALF_EVEN));

            BigDecimal t = expTaylor(z, scale);

            BigDecimal maxLong = BigDecimal.valueOf(Long.MAX_VALUE);
            BigDecimal result  = BigDecimal.valueOf(1);

            while (xWhole.compareTo(maxLong) >= 0) {
                result = result.multiply(
                        intPower(t, Long.MAX_VALUE, scale))
                        .setScale(scale, BigDecimal.ROUND_HALF_EVEN);
                xWhole = xWhole.subtract(maxLong);

                Thread.yield();
            }
            return result.multiply(intPower(t, xWhole.longValue(), scale))
                    .setScale(scale, BigDecimal.ROUND_HALF_EVEN);
        }

        private static BigDecimal expTaylor(BigDecimal x, int scale)
        {
            BigDecimal factorial = BigDecimal.valueOf(1);
            BigDecimal xPower    = x;
            BigDecimal sumPrev;

            BigDecimal sum  = x.add(BigDecimal.valueOf(1));

            int i = 2;
            do {
                xPower = xPower.multiply(x)
                        .setScale(scale, BigDecimal.ROUND_HALF_EVEN);

                // i!
                factorial = factorial.multiply(BigDecimal.valueOf(i));

                BigDecimal term = xPower
                        .divide(factorial, scale,
                                BigDecimal.ROUND_HALF_EVEN);

                sumPrev = sum;
                sum = sum.add(term);

                ++i;
                Thread.yield();
            } while (sum.compareTo(sumPrev) != 0);

            return sum;
        }

        public static BigDecimal ln(BigDecimal x, int scale)
        {
            if (x.signum() <= 0) {
                throw new IllegalArgumentException("x <= 0");
            }

            int magnitude = x.toString().length() - x.scale() - 1;

            if (magnitude < 3) {
                return lnNewton(x, scale);
            }

            else {

                BigDecimal root = intRoot(x, magnitude, scale);

                BigDecimal lnRoot = lnNewton(root, scale);

                return BigDecimal.valueOf(magnitude).multiply(lnRoot)
                        .setScale(scale, BigDecimal.ROUND_HALF_EVEN);
            }
        }


        private static BigDecimal lnNewton(BigDecimal x, int scale)
        {
            int        sp1 = scale + 1;
            BigDecimal n   = x;
            BigDecimal term;

            BigDecimal tolerance = BigDecimal.valueOf(5)
                    .movePointLeft(sp1);

            do {

                // e^x
                BigDecimal eToX = exp(x, sp1);

                // (e^x - n)/e^x
                term = eToX.subtract(n)
                        .divide(eToX, sp1, BigDecimal.ROUND_DOWN);

                // x - (e^x - n)/e^x
                x = x.subtract(term);

                Thread.yield();
            } while (term.compareTo(tolerance) > 0);

            return x.setScale(scale, BigDecimal.ROUND_HALF_EVEN);
        }


        public static BigDecimal arctan(BigDecimal x, int scale)
        {
            // Check that |x| < 1.
            if (x.abs().compareTo(BigDecimal.valueOf(1)) >= 0) {
                throw new IllegalArgumentException("|x| >= 1");
            }

            // If x is negative, return -arctan(-x).
            if (x.signum() == -1) {
                return arctan(x.negate(), scale).negate();
            }
            else {
                return arctanTaylor(x, scale);
            }
        }


        private static BigDecimal arctanTaylor(BigDecimal x, int scale)
        {
            int     sp1     = scale + 1;
            int     i       = 3;
            boolean addFlag = false;

            BigDecimal power = x;
            BigDecimal sum   = x;
            BigDecimal term;

            // Convergence tolerance = 5*(10^-(scale+1))
            BigDecimal tolerance = BigDecimal.valueOf(5)
                    .movePointLeft(sp1);

            // Loop until the approximations converge
            // (two successive approximations are within the tolerance).
            do {
                // x^i
                power = power.multiply(x).multiply(x)
                        .setScale(sp1, BigDecimal.ROUND_HALF_EVEN);

                // (x^i)/i
                term = power.divide(BigDecimal.valueOf(i), sp1,
                        BigDecimal.ROUND_HALF_EVEN);

                // sum = sum +- (x^i)/i
                sum = addFlag ? sum.add(term)
                        : sum.subtract(term);

                i += 2;
                addFlag = !addFlag;

                Thread.yield();
            } while (term.compareTo(tolerance) > 0);

            return sum;
        }

        public static BigDecimal sqrt(BigDecimal x, int scale)
        {
            // Check that x >= 0.
            if (x.signum() < 0) {
                throw new IllegalArgumentException("x < 0");
            }

            // n = x*(10^(2*scale))
            BigInteger n = x.movePointRight(scale << 1).toBigInteger();

            // The first approximation is the upper half of n.
            int bits = (n.bitLength() + 1) >> 1;
            BigInteger ix = n.shiftRight(bits);
            BigInteger ixPrev;

            // Loop until the approximations converge
            // (two successive approximations are equal after rounding).
            do {
                ixPrev = ix;

                // x = (x + n/x)/2
                ix = ix.add(n.divide(ix)).shiftRight(1);

                Thread.yield();
            } while (ix.compareTo(ixPrev) != 0);

            return new BigDecimal(ix, scale);
        }
    }
}