import java.awt.Point;
import java.io.*;
import java.math.BigInteger;
import java.util.*;
import static java.lang.Math.*;

public class ProblemD_05 {

    final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE")!=null;
    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    void init() throws FileNotFoundException{
        if (ONLINE_JUDGE){
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }else{
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        }
    }

    String readString() throws IOException{
        while(!tok.hasMoreTokens()){
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int readInt() throws IOException{
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException{
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException{
        return Double.parseDouble(readString());
    }

    public static void main(String[] args){
        new ProblemD_05().run();
    }

    public void run(){
        try{
            long t1 = System.currentTimeMillis();
            init();
            solve();
            out.close();
            long t2 = System.currentTimeMillis();
            System.err.println("Time = "+(t2-t1));
        }catch (Exception e){
            e.printStackTrace(System.err);
            System.exit(-1);
        }
    }

    void solve() throws IOException{
        double a = readDouble();
        double v = readDouble();
        double l = readDouble();
        double d = readDouble();
        double w = readDouble();
        double t = 0;
        double td = d > v * v / (2 * a)? v / a + (d - v * v / (2 * a)) / v: sqrt(2 *d / a);
        if (w >= min(a * td, v)){
            t += td;
            w = min(a * td, v);
        }else{
            double v0 = sqrt(w * w / 2 + a * d);
            if (v0 * v0 <= v * v){
                t += (2 * v0 - w) / a;
            }else{
                t += (2 * v - w) / a;
                double s2 = d - (2 * v * v - w * w) / (2 * a);
                t += s2 / v;
            }
        }
        double t1 = (sqrt(w * w + 2 * a * (l - d)) - w) / a;
        if (t1 > (v - w) / a) t1 = (v - w) / a;
        t += t1;
        double s1 = w * t1 + a * t1 * t1 / 2;
        double t2 = (l - d - s1) / v;
        t += t2;
        out.printf(Locale.US, "%.12f", t);
    }

    static int[][] step8 = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}, {-1, -1}, {1, -1}, {-1, 1}, {1, 1}};

    static int[][] stepKnight = {{-2, -1}, {-2, 1}, {-1, -2}, {-1, 2}, {1, -2}, {1, 2}, {2, -1}, {2, 1}};

    static long gcd(long a, long b){
        if (a == 0) return b;
        return gcd(b % a, a);
    }

    static long lcm(long a, long b){
        return a / gcd(a, b)*b;
    }

    static long[] gcdPlus(long a, long b){
        long[] d = new long[3];
        if (a == 0){
            d[0] = b;
            d[1] = 0;
            d[2] = 1;
        }else{
            d = gcdPlus(b % a, a);
            long r = d[1];
            d[1] = d[2] - b/a*d[1];
            d[2] = r;
        }
        return d;
    }

    static long binpow(long a, int n){
        if (n == 0) return 1;
        if ((n & 1) == 0){
            long b = binpow(a, n/2);
            return b*b;
        }else return binpow(a, n - 1)*a;
    }

    static long binpowmod(long a, int n, long m){
        if (m == 1) return 0;
        if (n == 0) return 1;
        if ((n & 1) == 0){
            long b = binpowmod(a, n/2, m);
            return (b*b) % m;
        }else return binpowmod(a, n - 1, m)*a % m;
    }

    static long phi(long n){
        int[] p = Sieve((int)ceil(sqrt(n)) + 2);
        long phi = 1;
        for (int i = 0; i < p.length; i++){
            long x = 1;
            while (n % p[i] == 0){
                n /= p[i];
                x *= p[i];
            }
            phi *= x - x/p[i];
        }
        if (n != 1) phi *= n - 1;
        return phi;
    }

    static long f(long n, int x, int k){ //Кол-во десятичных чисел (включая 0), содержащих в себе цифры от 0 до k-1
        if (n == 0) return 1;
        long b = binpow(10, x - 1);
        long c = n / b;
        return (c < k? c: k)*binpow(k, x - 1) + (c < k? 1: 0)*f(n % b, x - 1, k);
    }

    static long fib(int n){
        if (n == 0) return 0;
        if ((n & 1) == 0){
            long f1 = fib(n/2 - 1);
            long f2 = fib(n/2 + 1);
            return f2*f2 - f1*f1;
        }else{
            long f1 = fib(n/2);
            long f2 = fib(n/2 + 1);
            return f1*f1 + f2*f2;
        }
    }

    static BigInteger BigFib(int n){
        if (n == 0) return BigInteger.ZERO;
        if ((n & 1) == 0){
            BigInteger f1 = BigFib(n/2 - 1);
            f1 = f1.multiply(f1);
            BigInteger f2 = BigFib(n/2 + 1);
            f2 = f2.multiply(f2);
            return f2.subtract(f1);
        }else{
            BigInteger f1 = BigFib(n/2);
            f1 = f1.multiply(f1);
            BigInteger f2 = BigFib(n/2 + 1);
            f2 = f2.multiply(f2);
            return f2.add(f1);
        }
    }

    static public class PointD{

        double x, y;

        public PointD(double x, double y){
            this.x = x;
            this.y = y;
        }
    }

    static double d(Point p1, Point p2){
        return sqrt(d2(p1, p2));
    }

    static public double d(PointD p1, PointD p2){
        return sqrt(d2(p1, p2));
    }

    static double d2(Point p1, Point p2){
        return (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y);
    }

    static public double d2(PointD p1, PointD p2){
        return (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y);
    }

    static boolean IsProbablyPrime(long n){
        if (n == 1) return false;
        if ((n & 1) == 0) return false;
        for (int j = 3; j < sqrt(n) + 1; j += 2){
            if (n % j == 0) return false;
        }
        return true;
    }

    static int[] Sieve(int n){
        boolean[] b = new boolean[n+1];
        Arrays.fill(b, true);
        b[0] = false;
        b[1] = false;
        long nLong = n;
        int j=0;
        for (int i = 1; i <= n; i++) {
            if (b[i]){
                j++;
                if (((long)i)*i <= nLong) {
                    for (int k = i*i; k <= n; k += i) {
                        b[k] = false;
                    }
                }
            }
        }
        int[] p = new int[j];
        Arrays.fill(p, 0);
        j=0;
        for (int i = 2; i <= n; i++) {
            if (b[i]){
                p[j]=i;
                j++;
            }
        }
        return p;
    }

    static int[][] Palindromes(String s){
        char[] c = s.toCharArray();
        int n = c.length;
        int[][] d = new int[2][n];
        int l = 0, r = -1;
        for (int i = 0; i < n; i++){
            int j = (i > r? 0: min(d[0][l+r-i+1], r-i+1)) + 1;
            for (; i - j >= 0 && i + j - 1< n && c[i-j] == c[i+j-1]; j++);
            d[0][i] = --j;
            if (i + d[0][i] - 1 > r){
                r = i + d[0][i] - 1;
                l = i - d[0][i];
            }
        }
        l = 0;
        r = -1;
        for (int i = 0; i < n; i++){
            int j = (i > r? 0: min(d[1][l+r-i], r-i)) + 1;
            for (; i - j >= 0 && i + j < n && c[i-j] == c[i+j]; j++);
            d[1][i] = --j;
            if (i + d[1][i] > r){
                r = i + d[1][i];
                l = i - d[1][i];
            }
        }
        return d;
    }

    static public class Permutation {

        int[] a;
        int n;

        public Permutation(int n){
            this.n=n;
            a=new int[n];
            for (int i=0; i<n; i++){
                a[i]=i;
            }
        }

        public boolean nextPermutation(){ //Пишется с do{}while(nextPermutation(a));
            int i=n-1;
            for (i=n-2; i>=0; i--){
                if (a[i]<a[i+1]){
                    break;
                }
            }
            if (i==-1){
                return false;
            }
            int jMin=i+1;
            for (int j=n-1; j>i; j--){
                if (a[i]<a[j]&&a[j]<a[jMin]){
                    jMin=j;
                }
            }
            swap(i, jMin);
            for (int j=1; j<=(n-i)/2; j++){
                swap(i+j, n-j);
            }
            return true;
        }

        public int get(int i){
            return a[i];
        }

        void swap(int i, int j){
            int r=a[i];
            a[i]=a[j];
            a[j]=r;
        }
    }

    static public class Fraction implements Comparable<Fraction>, Cloneable{

        public final Fraction FRACTION_ZERO = new Fraction();
        public final Fraction FRACTION_ONE = new Fraction(1);
        public long numerator = 0;
        public long denominator = 1;

        public Fraction(){
            numerator = 0;
            denominator = 1;
        }

        public Fraction(long numerator){
            this.numerator = numerator;
            denominator = 1;
        }

        public Fraction(long numerator, long denominator){
            this.numerator = numerator;
            this.denominator = denominator;
            Cancellation();
        }

        public Fraction(double numerator, double denominator, int accuracy){
            this.numerator = (long)(numerator*pow(10,accuracy));
            this.denominator = (long)(denominator*pow(10,accuracy));
            Cancellation();
        }

        public Fraction(String s){
            if (s.charAt(0) == '-'){
                denominator = -1;
                s = s.substring(1);
            }
            if (s.indexOf("/") != -1){
                denominator *= Integer.parseInt(s.substring(s.indexOf("/") + 1));
            }
            if (s.indexOf(" ") != -1){
                numerator = Integer.parseInt(s.substring(0, s.indexOf(" "))) * abs(denominator) + Integer.parseInt(s.substring(s.indexOf(" ") + 1, s.indexOf("/")));
            }else{
                if (s.indexOf("/") != -1){
                    numerator = Integer.parseInt(s.substring(0, s.indexOf("/")));
                }else{
                    numerator = Integer.parseInt(s)*abs(denominator);
                }
            }
            this.Cancellation();
        }

        void Cancellation(){
            long g = gcd(abs(numerator), abs(denominator));
            numerator /= g;
            denominator /= g;
            if (denominator < 0){
                numerator *= -1;
                denominator *= -1;
            }
        }

        public String toString(){
            String s = "";
            if (numerator == 0){
                return "0";
            }
            if (numerator < 0){
                s += "-";
            }
            if (abs(numerator) >= denominator){
                s += Long.toString(abs(numerator) / denominator) + " ";
            }
            if (abs(numerator) % denominator != 0){
                s += Long.toString(abs(numerator) % denominator);
            }else{
                s = s.substring(0, s.length()-1);
            }
            if (denominator != 1){
                s += "/" + Long.toString(denominator);
            }
            return s;
        }

        public Fraction add(Fraction f){
            Fraction fResult = new Fraction();
            fResult.denominator = lcm(denominator, f.denominator);
            fResult.numerator = numerator * fResult.denominator / denominator + f.numerator * fResult.denominator / f.denominator;
            fResult.Cancellation();
            return fResult;
        }

        public Fraction subtract(Fraction f){
            Fraction fResult = new Fraction();
            fResult.denominator = lcm(denominator, f.denominator);
            fResult.numerator = numerator * fResult.denominator / denominator - f.numerator * fResult.denominator / f.denominator;
            fResult.Cancellation();
            return fResult;
        }

        public Fraction multiply(Fraction f){
            Fraction fResult = new Fraction();
            fResult.numerator = numerator * f.numerator;
            fResult.denominator = denominator * f.denominator;
            fResult.Cancellation();
            return fResult;
        }

        public Fraction divide(Fraction f){
            Fraction fResult = new Fraction();
            fResult.numerator = numerator * f.denominator;
            fResult.denominator = denominator * f.numerator;
            fResult.Cancellation();
            return fResult;
        }

        @Override
        public int compareTo(Fraction f){
            long g = gcd(denominator, f.denominator);
            long res = numerator * (f.denominator / g) - f.numerator * (denominator / g);
            if (res < 0){
                return -1;
            }
            if (res > 0){
                return 1;
            }
            return 0;
        }

        public Fraction clone(){
            Fraction fResult = new Fraction(numerator, denominator);
            return fResult;
        }

        public Fraction floor(){
            Fraction fResult = this.clone();
            fResult.numerator = (fResult.numerator / fResult.denominator) * fResult.denominator;
            return fResult;
        }

        public Fraction ceil(){
            Fraction fResult = this.clone();
            fResult.numerator = (fResult.numerator/fResult.denominator + 1) * fResult.denominator;
            return fResult;
        }

        public Fraction binpow(int n){
            if (n==0) return FRACTION_ONE;
            if ((n&1)==0){
                Fraction f=this.binpow(n/2);
                return f.multiply(f);
            }else return binpow(n-1).multiply(this);
        }
    }

    static public class FenwickTree_1{  //One-dimensional array

        int n;
        long[] t;

        public FenwickTree_1(int n){
            this.n = n;
            t = new long[n];
        }

        public long sum(int xl, int xr){
            return sum(xr) - sum(xl);
        }

        public long sum(int x){
            long result = 0;
            for (int i = x; i >= 0; i = (i & (i + 1)) - 1){
                result += t[i];
            }
            return result;
        }

        public void update(int x, long delta){
            for (int i = x; i < n; i = (i | (i + 1))){
                t[i] += delta;
            }
        }
    }

    static public class FenwickTree_2{  //Two-dimensional array

        int n, m;
        long[][] t;

        public FenwickTree_2(int n, int m){
            this.n = n;
            this.m = m;
            t = new long[n][m];
        }

        public long sum(int xl, int yl, int xr, int yr){
            return sum(xr, yr) - sum(xl - 1, yr) - sum(xr, yl - 1) + sum(xl - 1, yl - 1);
        }

        public long sum(int x, int y){
            long result = 0;
            for (int i = x; i >= 0; i = (i & (i + 1)) - 1){
                for (int j = y; j >= 0; j = (j & (j + 1)) - 1){
                    result+=t[i][j];
                }
            }
            return result;
        }

        public void update(int x, int y, long delta){
            for (int i = x; i < n; i = (i | (i + 1))){
                for (int j = y; j < m; j = (j | (j + 1))){
                    t[i][j] += delta;
                }
            }
        }
    }

    static public class FenwickTree_3{  //Three-dimensional array

        int n, m, l;
        long[][][] t;

        public FenwickTree_3(int n, int m, int l){
            this.n = n;
            this.m = m;
            this.l = l;
            t = new long[n][m][l];
        }

        public long sum(int xl, int yl, int zl, int xr, int yr, int zr){
            return sum(xr, yr, zr) - sum(xl - 1, yr, zr)
            + sum(xl - 1, yr, zl - 1) - sum(xr, yr, zl - 1)
            - sum(xr, yl - 1, zr) + sum(xl - 1, yl - 1, zr)
            - sum(xl - 1, yl - 1, zl - 1) + sum(xr, yl - 1, zl - 1);
        }

        public long sum(int x, int y, int z){
            long result = 0;
            for (int i = x; i >= 0; i = (i & (i + 1)) - 1){
                for (int j = y; j >= 0; j = (j & (j + 1)) - 1){
                    for (int k = z; k >= 0; k = (k & (k + 1)) - 1){
                        result += t[i][j][k];
                    }
                }
            }
            return result;
        }

        public void update(int x, int y, int z, long delta){
            for (int i = x; i < n; i = (i | (i + 1))){
                for (int j = y; j < n; j = (j | (j + 1))){
                    for (int k = z; k < n; k = (k | (k + 1))){
                        t[i][j][k] += delta;
                    }
                }
            }
        }
    }
}


import java.util.Scanner;

public class D
{

    public static void main(String[] args)
    {
        new D();
    }

    D()
    {
        Scanner in = new Scanner(System.in);
        double a = in.nextDouble();
        double v = in.nextDouble();
        double l = in.nextDouble();
        double d = in.nextDouble();
        double w = in.nextDouble();

        if (w>v) w=v;

        double dx=(v*v-w*w)/(2*a);
        double d0=(w*w)/(2*a);

        double t=0;
        if (d0>d) // doesn't make it to speed w before reaching d
        {
            if (d0>=l) // never gets to speed w
            {
                t=Math.sqrt(2*a*l)/a;
            }
            else
            {
                t=w/a;
                if (d0+dx>=l) // never gets to speed v
                {
                    t+=(-w+Math.sqrt(w*w+2*a*(l-d0)))/a;
                }
                else // makes it to speed v
                {
                    t+=(v-w)/a;
                    t+=(l-(d0+dx))/v;
                }
            }
        }
        else // makes it to speed w before reachig d
        {
            t=w/a; // get up to speed w

            // get time after reaching d
            if (d+dx>l) // never makes it back to v after reaching d
            {
                t+=(-w+Math.sqrt(w*w+2*a*(l-d)))/a;
            }
            else // makes it to speed v after reaching d
            {
                t+=(v-w)/a;
                t+=(l-(d+dx))/v;
            }

            // handle getting to d
            if (d0+2*dx>d) // can't get to v before reaching d
            {
                double half=(d-d0)/2;
                t+=2*(-w+Math.sqrt(w*w+2*a*half))/a;
            }
            else // can get to v before reaching d
            {
                t+=2*(v-w)/a;
                t+=(d-2*dx-d0)/v;
            }
        }

        System.out.printf("%.12f%n", t+1e-11);
    }

}


import java.io.*;
import java.util.*;

public class trafficerules {

 	public static void main(String[] args) throws Exception {
 		if ("Satayev".equals(System.getProperty("user.name"))) {
			long start = System.nanoTime();
			new trafficerules().solve(new FileInputStream("input"));
			System.err.printf("Time elapsed: %d ms.\n", (System.nanoTime()-start)/1000000);
		}
		else
			new trafficerules().solve(System.in);
 	}

 	void solve(InputStream is) throws Exception {
		Scanner in = new Scanner(is);

		double a = in.nextDouble(), maxv = in.nextDouble(), s = in.nextDouble(), d = in.nextDouble(), w = in.nextDouble();

		if (maxv < w)
			w = maxv;

		double t = 0;

		// v = at
		// s = att/2
		double t1 = w / a;
		double s1 = a*t1*t1/2;
		double v1 = w;
		if ( s1 < d ) {
			v1 = w;

			if (v1 >= maxv)
				t1 += (d-s1)/v1;
			else {
				double tt = (maxv - v1)/a;
				double ss = v1*tt+a*tt*tt/2;
				ss *= 2;
				if (s1 + ss < d)
					t1 += tt*2 + (d-s1-ss)/maxv;
				else {
					ss = (d-s1)/2;
					// ss = v1*t + a*t*t/2;
					double A = a/2;
					double B = v1;
					double C = -ss;
					double D = B*B - 4 * A * C;
					tt = (-B + Math.sqrt(D))/2/A;
					t1 += tt*2;
				}
			}

			s1 = d;
		}
		if (s1 > d) {
			s1 = d;
			t1 = Math.sqrt(2*s1/a);
			v1 = a * t1;
		}

		t += t1;

		double t2 = (maxv - v1) / a;
		double s2 = v1*t2 + a*t2*t2/2;
		double v2 = maxv;
		if (s1 + s2 < s) {
			v2 = maxv;
			t2 += (s-s1-s2)/v2;
		}
		if (s1 + s2 > s) {
			s -= s1;
			// v = v1 + a*t
			// s = v1*t + a*t*t/2
			double A = a/2;
			double B = v1;
			double C = -s;
			double D = B*B - 4*A*C;

			t2 = (-B + Math.sqrt(D))/2/A;
		}

		t += t2;

		System.out.println(t);
 	}

}


import java.util.Scanner;

public class AlexAndARhombus {
	public static void main(String args[])
	{
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		System.out.println(n*n+(n-1)*(n-1));
		sc.close();
	}

}


import java.util.*;
import java.io.*;

public class A {

    public static void main(String[] args) {
    	Scanner s = new Scanner(System.in);
    	long n = s.nextLong();
    	if(n >= 0)
    		System.out.println(n);
    	else {
    		String str = ("" + n).substring(1);
    		if(str.length() == 1)
    			System.out.println("-" + str);
    		else {
    			long one = Long.parseLong(str.substring(0, str.length()-1));
    			long two = Long.parseLong(str.substring(0, str.length()-2) + str.substring(str.length()-1));
    			if(one > two)
    				System.out.println((two!=0?"-":"") + two);
    			else
    				System.out.println((one!=0?"-":"") + one);
    		}
    	}
    }
}


import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;

public class Main implements Runnable {

    PrintWriter out;
    Scanner in;

    public static void main(String[] args) throws IOException {
        new Thread(new Main()).start();
    }

    public void run() {
        try {
            out = new PrintWriter(new BufferedOutputStream(System.out));
            in = new Scanner(System.in);
            solve();
            out.close();
        } catch (IOException e) {
            throw new IllegalStateException(e);
        }
    }

    public void solve() throws IOException {
        int n = in.nextInt();
        if (n >= 0) {
            out.println(n);
        } else {
            String s = String.valueOf(n);
            int l = s.length();
            String s1 = s.substring(0, l - 2);
            if (s.charAt(l - 1) > s.charAt(l - 2)) {
                s1 += s.charAt(l - 2);
            } else {
                s1 += s.charAt(l - 1);
            }
            out.println(Integer.parseInt(s1));
        }
    }
}


import java.util.*;
import java.math.*;

public class Main {

  public static void main(String[] args) throws Exception {
    Scanner scan = new Scanner(System.in);
    int n = scan.nextInt();
    int res = n;
    String str = Integer.toString(n);
    res = Math.max(res, Integer.parseInt(str.substring(0, str.length() - 1)));
    res = Math.max(res, Integer.parseInt(str.substring(0, str.length() - 2) + str.substring(str.length() - 1)));
    System.out.println(res);
  }
}


import java.util.Scanner;

    public class Main2 {
        public static void main(String args[]){
        	Scanner input = new Scanner(System.in);
        	String st = input.nextLine();
        	System.out.println(bank(st));
        }

        public static int bank(String st){
        	StringBuilder sb = new StringBuilder(st);
        	int st1 = Integer.parseInt(sb.substring(0,st.length()-2)+sb.substring(st.length()-1,st.length()));
        	int st2 = Integer.parseInt(sb.substring(0,st.length()-1));
        	int st3 = Integer.parseInt(st);
        	return Math.max(st3,Math.max(st1, st2));
        }
    }


import java.util.*;
import java.io.*;

public class ProbA {
  int account;

  void start(Scanner sc, PrintStream out) {
    int ans = 0;
    account = sc.nextInt();
    int account1 = account / 10;
    int account2 = (account - (account % 100)) / 10 + (account % 10);

    out.println(Math.max(account1, Math.max(account, account2)));
  }

  public static void main(String[] args)  {
    Scanner sc = new Scanner(System.in);
    PrintStream out = System.out;

    new ProbA().start(sc, out);

  }

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class A {

	static class Scanner{
		BufferedReader br=null;
		StringTokenizer tk=null;
		public Scanner(){
			br=new BufferedReader(new InputStreamReader(System.in));
		}
		public String next() throws IOException{
			while(tk==null || !tk.hasMoreTokens())
				tk=new StringTokenizer(br.readLine());
			return tk.nextToken();
		}
		public int nextInt() throws NumberFormatException, IOException{
			return Integer.valueOf(next());
		}
		public double nextDouble() throws NumberFormatException, IOException{
			return Double.valueOf(next());
		}
	}

	public static void main(String args[]) throws NumberFormatException, IOException{
		Scanner sc = new Scanner();
		int T = sc.nextInt();
		if ( T > 0)
			System.out.println(T);
		else{
			String cad = (T + "");
			int min = Math.min(cad.charAt(cad.length() - 1) - '0', cad.charAt(cad.length() - 2) - '0');
			if (min == 0 && cad.length() == 3)
				System.out.println(0);
			else
				System.out.println(cad.substring(0, cad.length() - 2) + "" + min);
		}
	}

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class A {
	BufferedReader reader;
    StringTokenizer tokenizer;
    PrintWriter out;

	public void solve() throws IOException {
		int N = nextInt();
		if( N >= 0) {
			out.println(N);
			return;
		}

		int ans = N/10;
		int ans2 = N/100*10 + N%10;
		out.println( Math.max(ans, ans2));

	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		new A().run();
	}

	public void run() {
        try {
            reader = new BufferedReader(new InputStreamReader(System.in));
            tokenizer = null;
            out = new PrintWriter(System.out);
            solve();
            reader.close();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

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

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

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

    String nextToken() throws IOException {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken();
    }

}


import java.io.IOException;
import java.util.Locale;
import java.util.Scanner;

public class A {

    public void processInput() throws IOException {
        Scanner in = new Scanner(System.in);

        long n = in.nextLong();
        long res = go(n);

        System.out.printf(Locale.ENGLISH, "%d\n", res);

        in.close();
    }

    public long go(long n) {

        long res = n;

        String str = String.valueOf(n);

        StringBuilder sb = new StringBuilder(str);
        sb.deleteCharAt(str.length() - 1);
        if (sb.length() > 0 && !sb.toString().equals("-")) {
            res = Math.max(res, Long.valueOf(sb.toString()));
        }

        if (str.length() > 1) {
            if (str.charAt(str.length() - 2) != '-') {
                sb = new StringBuilder(str);
                sb.deleteCharAt(str.length() - 2);
                res = Math.max(res, Long.valueOf(sb.toString()));
            }
        }

        return res;
    }

    public static void main(String[] args) throws Exception {
        A a = new A();
        a.processInput();
    }
}


/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

import java.io.*;
import java.util.*;

/**
 *
 * @author N-AssassiN
 */
public class Main {

    private static BufferedReader reader;
    private static BufferedWriter out;
    private static StringTokenizer tokenizer;
    //private final static String filename = "filename";

    private static void init(InputStream input, OutputStream output) {
        reader = new BufferedReader(new InputStreamReader(input));
        out = new BufferedWriter(new OutputStreamWriter(output));
        //reader = new BufferedReader(new FileReader(filename + ".in"));
        //out = new BufferedWriter(new FileWriter(filename + ".out"));
        tokenizer = new StringTokenizer("");
    }

    private static String nextLine() throws IOException {
        return reader.readLine();
    }

    private static String next() throws IOException {
        while (!tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(nextLine());
        }
        return tokenizer.nextToken();
    }

    private static int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    private static long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    private static double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws IOException {
        init(System.in, System.out);
        int n = nextInt();
        //long startTime = System.currentTimeMillis();
        if (n > 0) {
            out.write(n + "\n");
        } else {
            String s = n + "";
            String s2 = s.substring(0, s.length() - 1);
            String s3 = s.substring(0, s.length() - 2) + s.charAt(s.length() - 1);
            int a = Integer.parseInt(s2);
            int b = Integer.parseInt(s3);
            int ans = Math.max(a, b);
            out.write(ans + "\n");
        }
        //long runTime = System.currentTimeMillis() - startTime;
        //out.write(runTime + "\n");
        out.flush();
    }
}


import java.io.*;

public class Main {

	StreamTokenizer in;
	int n, k;

	public void run() {
		in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
		read();
		print(solve());
	}

	void read() {
		n = nextInt();
//		k = nextInt();
	}

	int solve() {
		int result = n;
		if (result < 0) {
			int res1 = n / 10;
			int mod = n % 10;

			int res2 = res1 / 10 * 10 + mod;
			if (res1 > res2)
				result = res1;
			else
				result = res2;
		}

		return result;
	}

	void print(int result) {
		System.out.println(result);
	}

	public static void main(String[] Args) {
			new Main().run();
	}

	public int nextInt() {
		try {
			in.nextToken();
		}
		catch (Exception e) {}
		return (int)in.nval;
	}

	public String nextString() {
		try {
			in.nextToken();
		}
		catch (Exception e) {}
		return in.sval;
	}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class BankAccount {

	/**
	 * @param args
	 * @throws IOException
	 */
	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

		String s = in.readLine();
		int n = Integer.parseInt(s);

		if (s.charAt(0) == '-')
			if (Integer.parseInt(s.substring(0, s.length()-1))>Integer.parseInt(s.substring(0, s.length()-2)+s.charAt(s.length()-1)))
				s=s.substring(0, s.length()-1);
			else
				s=s.substring(0, s.length()-2)+s.charAt(s.length()-1);

		System.out.println(Integer.parseInt(s));
		in.close();
	}

}


import java.io.*;
import java.util.*;

public class A {

	BufferedReader br;
	PrintWriter out;
	StringTokenizer st;
	boolean eof;

	void solve() throws IOException {
		String s = nextToken();
		int res = Integer.parseInt(s);

		String s1 = s.substring(0, s.length() - 1);
		res = Math.max(res, Integer.parseInt(s1));

		String s2 = s.substring(0, s.length() - 2) + s.charAt(s.length() - 1);
		res = Math.max(res, Integer.parseInt(s2));

		out.println(res);
	}

	A() throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		solve();
		out.close();
	}

	public static void main(String[] args) throws IOException {
		new A();
	}

	String nextToken() {
		while (st == null || !st.hasMoreTokens()) {
			try {
				st = new StringTokenizer(br.readLine());
			} catch (Exception e) {
				eof = true;
				return null;
			}
		}
		return st.nextToken();
	}

	String nextString() {
		try {
			return br.readLine();
		} catch (IOException e) {
			eof = true;
			return null;
		}
	}

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

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

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


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class A {

    static StringTokenizer st;
    static BufferedReader in;
    static PrintWriter pw;

    public static void main(String[] args) throws IOException {
        in = new BufferedReader(new InputStreamReader(System.in));
        pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        int n = nextInt();
        int n1 = n/10;
        int s = n % 10;
        int n2 = n / 100 * 10+s;
        System.out.println(Math.max(n, Math.max(n1, n2)));
        pw.close();
    }
    private static int nextInt() throws IOException{
        return Integer.parseInt(next());
    }

    private static long nextLong() throws IOException{
        return Long.parseLong(next());
    }

    private static double nextDouble() throws IOException{
        return Double.parseDouble(next());
    }

    private static String next() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }
}


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class TaskA implements Runnable {

	@Override
	public void run() {
		InputReader in = new InputReader(System.in);
		PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		int n = in.readInt();
		if (n > 0) {
			out.println(n);
		}
		else {
			int nn = -n;
			int x = nn/10;
			int lastDigit = nn%10;
			int y = 10*(x/10) + lastDigit;
			x = -x;
			y = -y;
			out.println(x > y ? x : y);
		}
		out.flush();
	}

	public static void main(String[] args) {
		new TaskA().run();
	}

	private class InputReader {

	    public BufferedReader reader;
	    public StringTokenizer tokenizer;

	    public InputReader(InputStream stream) {
	        reader = new BufferedReader(new InputStreamReader(stream));
	        tokenizer = null;
	    }

	    public String next() {
	        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
	            try {
	                tokenizer = new StringTokenizer(reader.readLine());
	            } catch (IOException e) {
	                throw new RuntimeException(e);
	            }
	        }
	        return tokenizer.nextToken();
	    }

	    public int readInt() {
	    	return Integer.parseInt(next());
	    }

	}

}


import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author George Marcus
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int N = in.nextInt();
        if(N >= 0)
            out.println(N);
        else {
            N = Math.abs(N);
            int v1 = - (N / 10);
            int v2 = - (N / 100 * 10 + (N % 10));
            out.println(Math.max(v1, v2));
        }
    }
}

class InputReader {
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int nextInt() {
        return Integer.parseInt(nextString());
    }

    public String nextString() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuffer res = new StringBuffer();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));

        return res.toString();
    }

    private boolean isSpaceChar(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    }


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;

public class CFA {

	private void work() throws IOException {
		Scanner sc = new Scanner(new BufferedReader(new InputStreamReader(
				System.in)));
		while (sc.hasNextInt()) {
			int n = sc.nextInt();
			int a = n;
			int b = n / 10;
			int c;
			if (n < 0) {
				n = -n;
				c = -((n / 100) * 10 + n % 10);
			} else {
				c = (n / 100) * 10 + n % 10;
			}
			System.out.println(Math.max(a, Math.max(b, c)));
		}
		System.out.close();
	}

	private int gcd(int a, int b) {
		return b == 0 ? a : gcd(b, a % b);
	}

	public static void main(String[] args) throws IOException {
		new CFA().work();
	}

}


import java.util.Scanner;

public class A {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Account acnt = new Account();
		acnt.solve();
		acnt.print();
	}

}

class Account {

	Account() {
		Scanner scr = new Scanner(System.in);
		n = scr.nextInt();
	}

	void solve() {
		if (n > 0) {
			ans = n;
		}
		else {
			int nn = -n;
			int ans1 = nn/10;
			int ans2 = nn % 10 + (nn/100)*10;
			if (ans1 < ans2){
				ans = -ans1;
			}
			else {
				ans = -ans2;
			}
		}

	}

	void print(){
		System.out.println(ans);
	}

	int ans;
	int n;
}


import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.GregorianCalendar;
import java.util.Scanner;

public class ProblemB {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);

        int a = s.nextInt();

        int f1 = a/10;

        int b = a;
        int last = a%10;

        b/=10;
        b/=10;
        b*=10;
        b+=last;

        System.out.println(Math.max(a, Math.max(f1, b)));

    }

}


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Scanner;

/** UVA 10130 - SuperSale */
public class Main {

    /** totally n products, max Weight is w */

    public static void main(String[] args) throws Exception {
         Scanner sc = null;
         PrintWriter pr = null;

         pr=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
         sc = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
         //sc = new Scanner(new File("input.txt"));

         long n = sc.nextInt();
         if (n > 0) pr.println(n);
         else {
             long n1 = n / 10;
             long n2 = n / 100 * 10  + n % 10;
             if (n1 < n2) pr.println(n2);
             else pr.println(n1);
         }

         pr.close();
         sc.close();
    }
}


import java.util.*;

public class Bank{
	public static void main(String[] args){
		Scanner reader = new Scanner(System.in);
		int in = reader.nextInt();
		int sign = (int)Math.signum(in);

		String str = Math.abs(in)+"";
		if(str.length() == 1){
			if(in < 0)
				System.out.println(0);
			else
				System.out.println(in);
			return;
		}

		int max = in;
		max = Math.max(max, sign * Integer.parseInt(str.substring(0,str.length()-1)));
		max = Math.max(max, sign * Integer.parseInt(str.substring(0,str.length()-2) + str.charAt(str.length()-1)));
		System.out.println(max);
	}
}


import java.io.*;
import java.util.*;

public class first
{
	int max(int a1,int a2,int a3)
	{
		int max=a1;
		if(a2>=max)
			max=a2;
		if(a3>=max)
			max = a3;
		return max;
	}

	public static void main(String[] args)
	{
		int num=0;

		Scanner sc = new Scanner(System.in);
		num = sc.nextInt();
		int num2 = num/10;
		int num3 = num%10;
		int num4 = (num2/10)*10+num3;
		first fs = new first();
		int result = fs.max(num,num2,num4);
		System.out.println(result);
	}
}


import java.io.InputStreamReader;
import java.io.IOException;
import java.text.BreakIterator;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

public class palin {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(System.out);
		Scanner scan = new Scanner(System.in);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
	public void solve(int testNumber, InputReader in, PrintWriter out) {
		int n = in.nextInt();
		if (n >= 0) {
			out.print(n);
			return;
		}
		if (n / 10 >= (n / 100) * 10 + n % 10) {
			out.print(n / 10);
			return;
		}
		out.print((n / 100) * 10 + n % 10);
	}
}

class InputReader {
	BufferedReader br;
	StringTokenizer st;

	public InputReader(InputStream in) {
		br = new BufferedReader(new InputStreamReader(in));
		st = null;
	}

	public String next() {
		while (st == null || !st.hasMoreTokens()) {
			try {
				st = new StringTokenizer(br.readLine());
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		return st.nextToken();
	}

	public int nextInt() {
		return Integer.parseInt(next());
	}

	public long nextLong() {
		return Long.parseLong(next());
	}

	public double nextDouble() {
		return Double.parseDouble(next());
	}
}


/**
 *
 * @author saurabh
 */
public class myTemplate {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws Exception{
        // TODO code application logic here
       java.io.BufferedReader br = new java.io.BufferedReader(new
                 java.io.InputStreamReader(System.in));

       int ch[],arr[];
       int x,i,j,k,t,n=Integer.parseInt(br.readLine());
        //System.out.println(n);

       if(n>0)
            System.out.println(n);
       else
       {
           //n= -n;
           //n=-n;
           x= n/100;

           x = x*10 + n%10;
         //  System.out.println(x);
           if(n/10 > x)
               System.out.println(n/10);
           else
              System.out.println(x);

       }

    }
}


import java.io.*;
import java.util.*;

public class A {
  public static void main(String[] args){
    FastScanner sc = new FastScanner();
    int n = sc.nextInt();
    String nStr = Integer.toString(n);

    String nStr1 = nStr.substring(0, nStr.length() - 1);
    String nStr2 = nStr.substring(0, nStr.length() - 2) + nStr.charAt(nStr.length() - 1);

    int result = Math.max(n, Integer.parseInt(nStr1));
    result = Math.max(result, Integer.parseInt(nStr2));
    System.out.println(result);
  }

  public static class FastScanner {
    BufferedReader br;
    StringTokenizer st;

    public FastScanner(String s) {
      try {
        br = new BufferedReader(new FileReader(s));
      } catch (FileNotFoundException e) {
        e.printStackTrace();
      }
    }

    public FastScanner() {
      br = new BufferedReader(new InputStreamReader(System.in));
    }

    String nextToken() {
      while (st == null || !st.hasMoreElements()) try {
        st = new StringTokenizer(br.readLine());
      } catch (IOException e) {
        e.printStackTrace();
      }
      return st.nextToken();
    }

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

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

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


import java.io.*;

public class Main {
  public static void main(String args[]) throws IOException {
    BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
    String line = stdin.readLine();
    int n = Integer.parseInt(line);

    if (n >= 0) {
      System.out.println(n);
    } else if (n > -10) {
      System.out.println(0);
    } else {
      String sa = line.substring(0, line.length() - 1);
      int a = Integer.parseInt(sa);
      String sb = line.substring(0, line.length() - 2) + line.charAt(line.length() - 1);
      int b = Integer.parseInt(sb);
      System.out.println(Math.max(a, b));
    }
  }
}


import java.io.PrintWriter;
import java.util.Scanner;

public class C186D2A {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int n = in.nextInt();
		if (n >= 0) {
			out.println(Math.abs(n));
		} else {
			out.println(Math.max(n/10, (n/100)*10 + n%10));
		}
		out.flush();
	}
}


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class A {

	private static StringTokenizer tokenizer;
    private static BufferedReader bf;
    private static PrintWriter out;

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

    @SuppressWarnings("unused")
	private static long nextLong() throws IOException {
    	return Long.parseLong(nextToken());
    }

    private static String nextToken() throws IOException {
    	while(tokenizer == null || !tokenizer.hasMoreTokens()) {
    		tokenizer = new StringTokenizer(bf.readLine());
    	}
    	return tokenizer.nextToken();
    }

	public static void main(String[] args) throws IOException {
		bf = new BufferedReader(new InputStreamReader(System.in));
    	tokenizer = null;
    	out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    	int n = nextInt();
    	if(n >= 0) out.println(n);
    	else {
    		n = -n;
    		int a = n % 10; int m = n/10;
    		int b = m % 10;
    		if(a >= b) {
    			if(m == 0) out.println(0);
    			else out.println(-m);
    		}
    		else {
    			m = (m-b)+a;
    			if(m == 0) out.println(0);
    			else out.println(-m);
    		}
    	}
    	out.close();
	}

}


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeMap;

public class A {
    private static BufferedReader in;
    private static StringTokenizer st;
    private static PrintWriter out;

    public static void main(String[] args) throws NumberFormatException, IOException {
        in = new BufferedReader(new InputStreamReader(System.in));
        st = new StringTokenizer("");
        out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        int n = nextInt();
        int max = n;
        max = Math.max(max, n / 10);
        max = Math.max(max, (n / 100) * 10 + n % 10);
        System.out.println(max);
    }

    static String next() throws IOException{
        while(!st.hasMoreTokens()){
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }
    static int nextInt() throws NumberFormatException, IOException{
        return Integer.parseInt(next());
    }
    static long nextLong() throws NumberFormatException, IOException{
        return Long.parseLong(next());
    }

    static double nextDouble() throws NumberFormatException, IOException{
        return Double.parseDouble(next());
    }

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class problemB185 {

	public static void main(String[] args) throws IOException{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringBuffer sb=new StringBuffer();
		int n=Integer.parseInt(br.readLine());

		if(n<0){
			int temp=-n;
			int temp2=temp/10;
			int x=temp%10;
			int y=temp2%10;
			if(x>y){
				temp=temp/10;
			}
			else{
				temp=temp/10 -y +x;
			}
			n=-temp;

		}
		System.out.println(n);

		}

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
	public static void main(String[] args) throws NumberFormatException,
			IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		int n = Integer.parseInt(br.readLine());
		String s = n + "";
		if (n >= 0)
			System.out.println(n);
		else {
			int a = n, b = Integer.parseInt(s.substring(0, s.length() - 1)), c = Integer.parseInt(s.substring(0, s.length()-2)+s.charAt(s.length()-1));
			System.out.println(Math.max(a, Math.max(b,c)));
		}
	}
}


import java.util.Scanner;

public class A {

	static Scanner scanner = new Scanner(System.in);
	static int s;

	public static void main(String[] args) {
		s = scanner.nextInt();
		if (s >= 0) {
			System.out.println(s);
		}
		else {
			if (s >= -10) {
				System.out.println(0);
			}
			else {
				int ss = -s;
				int a, b;
				a = ss % 10;
				b = (ss % 100) / 10;
				if (a > b) {
					ss = ss / 10;
				}
				else {
					ss = (ss / 100) * 10 + a;
				}
				if (ss == 0) {
					System.out.println(0);
				}
				else {
					System.out.println("-" + ss);
				}
			}
		}
	}

}


import java.io.*;

import static java.lang.Integer.*;
import static java.lang.Math.*;
public class A {
	public static void main(String[] args) throws Throwable{
		BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
		String ln=in.readLine().trim();
		System.out.println(max(parseInt(ln),max(parseInt(ln.substring(0,ln.length()-1)),parseInt(ln.substring(0, ln.length()-2)+ln.substring(ln.length()-1)))));
	}
}


import java.io.BufferedInputStream;
import java.io.PrintStream;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner in=new Scanner(new BufferedInputStream(System.in));
		PrintStream out=System.out;
		int n=in.nextInt();
		if (n>=0) out.println(n);
		else out.println(Math.max(-((-n)/10), -((-n)/100*10+(-n)%10)));
		out.close();
		in.close();
	}
}


import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

	public static void main(String [] args ) {
		try{
			String str;
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			BufferedOutputStream bos = new BufferedOutputStream(System.out);
			String eol = System.getProperty("line.separator");
			byte [] eolb = eol.getBytes();
			byte[] spaceb= " ".getBytes();

			str  = br.readLine();

			int n = Integer.parseInt(str);
			int ans = 0;
			if(n>=0) {
				ans = n;
			} else {
				 if ( str.length()==2) {
					if(str.charAt(0)!='-') {
						int a  =Integer.parseInt(str.substring(0,1));
						int b = Integer.parseInt(str.substring(1,2));
						ans = Math.max(a, b);
					} else {
						ans = Integer.parseInt(str.substring(1,2));
					}
				} else {
					String s1 = str.substring(0,str.length()-2).concat(str.substring(str.length()-2,str.length()-1));
					String s2 = str.substring(0,str.length()-2).concat(str.substring(str.length()-1,str.length()));
					int a = Integer.parseInt(s1);
					int b = Integer.parseInt(s2);
					ans = Math.max(a, b);
				}
			}
			bos.write(new Integer(ans).toString().getBytes());
			bos.write(eolb);
			bos.flush();
		}  catch(IOException ioe) {
			ioe.printStackTrace();
		}
	}
}


import java.util.*;

public class Main{

    void solve(){
        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();
        int n1 = n/10;
        int n2 = n/100*10 + n%10;

        int ans = n;
        ans = Math.max(ans, n1);
        ans = Math.max(ans, n2);
        System.out.println(ans);
    }

    public static void main(String[] args){
        new Main().solve();
    }
}


import java.io.*;
import java.util.*;
import java.math.*;

public class A {
    public static void main(String[] args) {
        OutputStream outputStream = System.out;
        PrintWriter out = new PrintWriter(outputStream);

        Application solver = new Application();
        solver.solve(System.in, out);

        out.close();
    }
}

class Application {
    int max(int a, int b) { return a > b ? a : b; }
    public void solve(InputStream in, PrintWriter out) {
        Scanner scanner = new Scanner(in);

        int n = scanner.nextInt();
        int n1 = n/10;
        int n2 = (n/100)*10+(n%10);
        int m = max(max(n1, n2), n);

        out.println(m);
    }
}


import static java.util.Arrays.deepToString;

import java.awt.datatransfer.StringSelection;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.StringTokenizer;

public class Main {

    static void solve() throws IOException {
        int n = nextInt();
        if (n >= 0) {
            System.out.println(n);
        } else {
            String string = String.valueOf(n);
            int v1 = Integer.valueOf(string.substring(0, string.length() - 1));
            int v2 = Integer.valueOf(string.substring(0, string.length() - 2)
                    + string.charAt(string.length() - 1));
            if (v1 >= v2) {
                System.out.println(v1);
            } else {
                System.out.println(v2);
            }
        }

    }

    public static void main(String[] args) throws Exception {
        reader = new BufferedReader(new InputStreamReader(System.in));
        writer = new PrintWriter(System.out);

        setTime();
        solve();
        printTime();
        printMemory();

        writer.close();
    }

    static BufferedReader reader;
    static PrintWriter writer;
    static StringTokenizer tok = new StringTokenizer("");
    static long systemTime;

    static void debug(Object... o) {
        System.err.println(deepToString(o));
    }

    static void setTime() {
        systemTime = System.currentTimeMillis();
    }

    static void printTime() {
        System.err.println("Time consumed: "
                + (System.currentTimeMillis() - systemTime));
    }

    static void printMemory() {
        System.err.println("Memory consumed: "
                + (Runtime.getRuntime().totalMemory() - Runtime.getRuntime()
                        .freeMemory()) / 1000 + "kb");
    }

    static String next() {
        while (!tok.hasMoreTokens()) {
            String w = null;
            try {
                w = reader.readLine();
            } catch (Exception e) {
                e.printStackTrace();
            }
            if (w == null)
                return null;
            tok = new StringTokenizer(w);
        }
        return tok.nextToken();
    }

    static int nextInt() {
        return Integer.parseInt(next());
    }

    static long nextLong() {
        return Long.parseLong(next());
    }

    static double nextDouble() {
        return Double.parseDouble(next());
    }

    static BigInteger nextBigInteger() {
        return new BigInteger(next());
    }
}


import java.util.Scanner;
import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		Scanner in = new Scanner(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
    public void solve(int testNumber, Scanner in, PrintWriter out) {
        int balance = in.nextInt();
        if (balance >= 0) {
            out.println(balance);
            return;
        }

        balance = -balance;
        int a = balance / 100;

        int b = Math.min(balance % 10, (balance / 10) % 10);

        balance = -(a * 10 + b);

        out.println(balance);
    }
}


import java.io.*;
import java.util.*;

public class Problem1 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		if (n < 0) {

			int first = n / 10;
			int second = (n / 100)*10 + (n % 10);
			if (first > second)
				System.out.println(first);
			else
				System.out.println(second);
		} else {
			System.out.println(n);
		}
	}

}


import java.io.*;
import java.util.*;
public class j
{
public static void main(String aa[])throws IOException
{
BufferedReader b=new BufferedReader(new InputStreamReader(System.in));
int i=0,m=0,p=0,n=0,k=0,j=0;
String s,r;
s=b.readLine();
r=s;
n=Integer.parseInt(s);
s=s.substring(0,s.length()-2);
s+=r.charAt(r.length()-1);
r=r.substring(0,r.length()-1);
m=Integer.parseInt(s);
p=Integer.parseInt(r);
System.out.print((long)Math.max(Math.max(m,n),p));
}
}


import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class A {
	public static void main(String[] args){
		FastScanner sc = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		String cur = sc.nextToken();
		int first = Integer.parseInt(cur);
		if(cur.length() > 1){
			String second = cur.substring(0,cur.length()-1);
			if(Character.isDigit(second.charAt(second.length()-1))){
				first = Math.max(first, Integer.parseInt(second));
			}
		}

		if(cur.length() > 2){
			String third = cur.substring(0,cur.length()-2) + cur.charAt(cur.length()-1);
			if(Character.isDigit(cur.charAt(cur.length()-2))){
				first = Math.max(first, Integer.parseInt(third));
			}
		}
		System.out.println(first);
		out.close();
	}

	public static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner(String s) {
			try {
				br = new BufferedReader(new FileReader(s));
			} catch (FileNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

		public FastScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String nextToken() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

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

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

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


import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import java.io.*;
import java.math.*;
import java.util.*;

@SuppressWarnings("unused")
public class A {
	public static void main(String[] args) throws Exception {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		TreeSet<Integer> set = new TreeSet<Integer>();
		set.add(n);
		try {
			String s = Integer.toString(n);
			s = s.substring(0, s.length() - 1);
			set.add(Integer.parseInt(s));
		} catch (Exception e) {
		}
		try {
			String s = Integer.toString(n);
			s = s.substring(0, s.length() - 2) + s.charAt(s.length() - 1);
			set.add(Integer.parseInt(s));
		} catch (Exception e) {
		}
		System.out.println(max(set));
	}
}


import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class Round313A {
	private static final int LOCAL_ENV = 0;

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		try {
			if (LOCAL_ENV == 1) {
				in = new Scanner(new File("input.txt"));
			}
		} catch (FileNotFoundException e) {
			in = new Scanner(System.in);
		}

		long n = in.nextLong();

		if (n >= -9) {
			System.out.println(n);
		} else {
			long absN = Math.abs(n);
			long m1 = -(absN / 10);
			long last = absN % 10;
			long m2 = -((absN / 100) * 10 + last);
			System.out.println(Math.max(m1, m2));
		}
	}
}


import java.util.Scanner;

public class A {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String ns = sc.next();
		sc.close();

		int n1 = Integer.parseInt(ns);
		int n2 = Integer.parseInt(ns.substring(0, ns.length() - 1));
		int n3 = Integer.parseInt(ns.substring(0, ns.length() - 2) + ns.substring(ns.length() - 1));

		int max = n1;
		max = (n2 > max) ? (n2) : (max);
		max = (n3 > max) ? (n3) : (max);

		System.out.println(max);
	}
}


/**
 * Created with IntelliJ IDEA.
 * User: Venky
 */

import java.io.*;
import java.util.StringTokenizer;

public class Main {
    static void solve() throws IOException {
        String str = br.readLine();
        StringBuffer sb1 = new StringBuffer(str);
        StringBuffer sb2 = new StringBuffer(str);
        StringBuffer sb3 = new StringBuffer(str);
        sb1.deleteCharAt(sb1.length()-1);
        sb2.deleteCharAt(sb2.length()-2);
        int n1 = Integer.parseInt(sb1.toString());
        int n2 = Integer.parseInt(sb2.toString());
        int n3 = Integer.parseInt(sb3.toString());
        out.println(Math.max(n1, Math.max(n2, n3)));
    }

    static BufferedReader br;
    static StringTokenizer st;
    static PrintWriter out;

    public static void main(String[] args) throws IOException {
        InputStream input = System.in;
        br = new BufferedReader(new InputStreamReader(input));
        out = new PrintWriter(System.out);
        solve();
        out.close();
    }

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

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

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

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


import java.util.*;

public class ex1 {

	public static void main(String[] args)	{
		int n,i,j;
		Scanner scan = new Scanner(System.in);
		n = Integer.parseInt(scan.nextLine());
		if(n>=0)
			System.out.println(n);
		else if(n<0)	{
			n=-1*n;
			i=n/10;
			j=(n/100)*10+n%10;
			i=-i;
			j=-j;
			if(i>=j)
				System.out.println(i);
			else
				System.out.println(j);
		}
	}

}


import java.io.*;

public class Main {

	public static void main(String[] args) throws Exception {

		int n = nextInt();
		String nn = Integer.toString(n);
		if(n >= 0){
			println(n);
		} else {
			println(Math.max(Integer.parseInt(nn.substring(0,nn.length() - 1)), Integer.parseInt(nn.substring(0, nn.length() - 2) + nn.charAt(nn.length() - 1))));
		}
	}

	private static PrintWriter out =  new PrintWriter(System.out);
	private static BufferedReader inB = new BufferedReader(new InputStreamReader(System.in));
	private static StreamTokenizer in = new StreamTokenizer(inB);

	private static void exit(Object o) throws Exception {
		out.println(o);
		out.flush();
		System.exit(0);
	}
	private static void println(Object o) throws Exception{
		out.println(o);
		out.flush();
	}
	private static void print(Object o) throws Exception{
		out.print(o);
		out.flush();
	}
	private static long nextLong() throws Exception {
		in.nextToken();
		return (long)in.nval;
	}
	private static int nextInt() throws Exception {
		in.nextToken();
		return (int)in.nval;
	}
	private static String nextString() throws Exception {
		in.nextToken();
		return in.sval;
	}

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class CF {

    public static void main(String[] args) throws IOException {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);

        int n = in.nextInt();
        if (n >= 0) {
            out.println(n);
        } else {
            int res = n;
            n = Math.abs(n);

            String s = String.valueOf(Math.abs(n));
            if (s.length() == 1) {
                res = 0;
            } else {
                res = Math.max(-Integer.parseInt(s.substring(0, s.length() - 1)), res);
                res = Math.max(-Integer.parseInt(s.substring(0, s.length() - 2) + s.charAt(s.length() - 1)), res);
            }

            out.println(res);
        }

        out.close();
    }
}

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

}


import java.util.Scanner;
import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author AndrewShmig
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		Scanner in = new Scanner(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
    public void solve(int testNumber, Scanner in, PrintWriter out) {
        String n = in.nextLine();

        int a = Integer.parseInt(n);
        int b = Integer.parseInt(n.substring(0, n.length() - 1));
        int c = Integer.parseInt(n.substring(0, n.length() - 2) + n.charAt(n.length() - 1));

        out.println(Math.max(a, Math.max(b, c)));
    }
}


import java.io.*;
import java.util.*;

public class TaskA  {
    public void run() {
        InputReader reader = new InputReader(System.in);
        PrintWriter writer = new PrintWriter(System.out, true);

        reader.nextLine();
        String statement = reader.next();

        if (!statement.startsWith("-")) {
            writer.println(statement);
        } else {
            try {
                int statement1 = Integer.parseInt(statement.substring(0, statement.length() - 1));
                int statement2 = Integer.parseInt(statement.substring(0, statement.length() - 2) + statement.charAt(statement.length() - 1));
                writer.println(Math.max(statement1, statement2));
            } catch (Exception e) {
                writer.println(statement);
            }
        }

        writer.close();
    }
    public static void main(String[] args) {
        new TaskA().run();
    }
    private class InputReader {
        BufferedReader reader;
        StringTokenizer token;

        private InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
        }

        private String next() {
            return token.nextToken();
        }

        private int nextInt() {
            return Integer.parseInt(this.next());
        }

        private double nextDouble() {
            return Double.parseDouble(this.next());
        }

        private long nextLong() {
            return Long.parseLong(this.next());
        }

        private String nextLine() {
            String line = "";
            try {
                line = reader.readLine();
                token = new StringTokenizer(line, " ");

            } catch(IOException e) {

            }
            return line;
        }
    }
}


import java.util.Scanner;

public class MargariteBestPresent_1080B {

	private static int f(int x) {
		return (x%2==0)?x/2:(x-1)/2-x;
	}

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n,r,l;
		n = sc.nextInt();
		while(n-->0) {
			l = sc.nextInt();
			r = sc.nextInt();

			System.out.println(f(r)-f(l-1));
		}
		sc.close();
	}

}


import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class e {

public static class FastReader {
	BufferedReader br;
	StringTokenizer st;
	//it reads the data about the specified point and divide the data about it ,it is quite fast
	//than using direct

	public FastReader() {
		br = new BufferedReader(new InputStreamReader(System.in));
	}

	String next() {
		while (st == null || !st.hasMoreTokens()) {
			try {
				st = new StringTokenizer(br.readLine());
			} catch (Exception r) {
				r.printStackTrace();
			}
		}
		return st.nextToken();
	}

	int nextInt() {
		return Integer.parseInt(next());//converts string to integer
	}

	double nextDouble() {
		return Double.parseDouble(next());
	}

	long nextLong() {
		return Long.parseLong(next());
	}

	String nextLine() {
		String str = "";
		try {
			str = br.readLine();
		} catch (Exception r) {
			r.printStackTrace();
		}
		return str;
	}
}
static ArrayList<String>list1=new ArrayList<String>();
static void combine(String instr, StringBuffer outstr, int index,int k)
{
	if(outstr.length()==k)
	{
		list1.add(outstr.toString());return;
	}
	if(outstr.toString().length()==0)
	outstr.append(instr.charAt(index));
    for (int i = 0; i < instr.length(); i++)
    {
        outstr.append(instr.charAt(i));

        combine(instr, outstr, i + 1,k);
        outstr.deleteCharAt(outstr.length() - 1);
    }
   index++;
}
static ArrayList<ArrayList<Integer>>l=new ArrayList<>();
static void comb(int n,int k,int ind,ArrayList<Integer>list)
{
	if(k==0)
	{
		l.add(new ArrayList<>(list));

		return;
	}

	for(int i=ind;i<=n;i++)
	{
		list.add(i);
		comb(n,k-1,ind+1,list);

		list.remove(list.size()-1);

	}

}

public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	FastReader in=new FastReader();
	HashMap<Integer,Integer>map=new HashMap<Integer,Integer>();

	int n=in.nextInt();
	int r=in.nextInt();

	double theta=(double)360/(double)n;

	double b=1-((double)2/(double)(1-Math.cos((double)2*Math.PI/(double)n)));
	double x=Math.sqrt(1-b)-1;
	double ans=(double)r/(double)x;
	System.out.println(ans);

	}
}


import java.io.*;
import java.util.*;
public class Codechef{
	static int max=Integer.MIN_VALUE;
	static int res=0;
	static int[] checkMax(int arr[],int j){
             int sum=0;
             int x=arr[j];
        		while(x!=0){
        		        if(j+1==15){
        		        	j=0;
        		        }else{
        		        	arr[j+1]=arr[j+1]+1;
        		        }
        		        // if(arr[j+1]%2==0){
        		        // 	sum=sum+arr[j+1];
        		        // 	if(sum>=max){
        		        // 	max=sum;
        		        // }
        		        // }

        		        x--;
        		        j++;
        		}
        		     return arr;

	}

    public static void main(String []args){
       Scanner sc = new Scanner (System.in);
    long a [] = new long [14];
    long b [] = new long [14];
    long p,q,r,s,max = 0;
    for(int i = 0; i < 14; i++) a[i] = sc.nextInt();
    for(int i = 0; i < 14; i++){
      p = a[i]%14;
      q = a[i]/14;
      r = 0;
      s = 0;
      for(int j = 0; j < 14; j++) b[j] = a[j];
      b[i] = 0;
      int j = (i+1)%14;
      for(; r < p; r++) {
        b[j]++;
        j=(j+1)%14;
      }
      for( j = 0; j < 14; j++) {
        b[j] += q;
        if(b[j] % 2 == 0) s+= b[j];
      }
      max = Math.max(max,s);
    }
    System.out.println(max);

    }

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.util.HashSet;
import java.util.StringTokenizer;

public class Main {
	public static String conv(String str) {
		boolean[] Arr = new boolean[26];
		for (int i = 0; i < str.length(); i++) {
			Arr[str.charAt(i) - 'a'] = true;
		}
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < 26; i++) {
			if (Arr[i])
				sb.append((char) (i + 'a'));
		}
		return "" + sb;
	}

	public static void main(String[] args) throws IOException, InterruptedException {
		PrintWriter pw = new PrintWriter(System.out);
		Scanner sc = new Scanner(System.in);
		HashSet<String> hs = new HashSet<String>();
		int[] Arr = new int[14];
		long max = 0;
		for (int i = 0; i < 14; i++) {
			Arr[i] = sc.nextInt();
		}

		for (int i = 0; i < 14; i++) {
			int[] arr = Arr.clone();

			long sum = 0;
			int r = arr[i];
			arr[i] = 0;
			for (int j = i + 1; j < arr.length && r > 0; j++) {
				arr[j]++;
				r--;
			}
			for (int j = 0; j < arr.length; j++) {
				arr[j] +=( r / 14);
				if (j + 1 <= (r % 14)) {
					arr[j]++;
				}
				if (arr[j] % 2 == 0) {
					sum += arr[j];
				}
			}
			max = Math.max(max, sum);

		}
		System.out.println(max);
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

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

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

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public double nextDouble() throws IOException {
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if (x.charAt(0) == '-') {
				neg = true;
				start++;
			}
			for (int i = start; i < x.length(); i++)
				if (x.charAt(i) == '.') {
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				} else {
					sb.append(x.charAt(i));
					if (dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg ? -1 : 1);
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

	}
}


import java.util.Scanner;

public class A {
  public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    String inp = in.nextLine();
    System.out.println(25);
  }
}


import java.util.Scanner;

/**
 * Created by Gantushig on 2/18/2016.
 */

public class A {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        long n = input.nextLong();
        System.out.println("25");
    }

}


public class P1 {

	public static void main(String[] args) {
		System.out.println("25");
	}

}


import java.io.BufferedReader;
import java.io.InputStreamReader;

public class A {
	public static void main(String[] args) throws Exception {
		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
		String l[] = bf.readLine().split(" ");
		System.out.println(25);
	}
}


import java.util.*;
public class a {
	public static void main(String[] args){
		Scanner br = new Scanner(System.in);
		long n = br.nextLong();
		System.out.println("25");
	}
}


	import java.io.BufferedReader;
	import java.io.IOException;
	import java.io.InputStreamReader;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collections;
	import java.util.Comparator;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.LinkedList;
	import java.util.List;
	import java.util.Map;
	import java.util.PriorityQueue;
	import java.util.Queue;
	import java.util.Random;
	import java.util.Set;
	import java.util.Stack;

	public class test {
		public static void main(String[] args) throws InterruptedException {
			//new careercup().run();
			//new CC().run();
			//System.out.println(Integer.MAX_VALUE);
			try{
				BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
				br.readLine();
				System.out.println(25);

			}catch(IOException io){
				io.printStackTrace();
			}
		}

	}


import java.io.*;
import java.util.*;

public class Main {

	void solve(Scanner in, PrintWriter out) {
		long a = in.nextLong();
		out.println(25);
	}
	void run() {
		Locale.setDefault(Locale.US);
		try (
				Scanner in = new Scanner(System.in);
				PrintWriter out = new PrintWriter(System.out);
		) {
			solve(in, out);
		  }
	}

	public static void main(String args[]) {
		new Main().run();
	}

}


import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.BufferedWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.io.OutputStream;
import java.io.OutputStreamWriter;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Alex
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }
    static class TaskA {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            out.printLine(25);
        }

    }

    static class InputReader {
        private InputStream stream;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void close() {
            writer.close();
        }

        public void printLine(int i) {
            writer.println(i);
        }

    }
}


import java.io.IOException;

/**
 * Created by ww on 13.02.2016.
 */
public class rgb {

    public static void main(String[] args) throws IOException {
        System.out.print(25);
        return ;

    }
}


/*
     * Code Author: Akshay Miterani
     * DA-IICT
     */
    import java.io.*;
    import java.util.*;

    public class MainY {

    	static double eps=(double)1e-6;
    	static long mod=(int)1e9+7;
    	static boolean f=true;
    	public static void main(String args[]){
    		InputReader in = new InputReader(System.in);
    		OutputStream outputStream = System.out;
    		PrintWriter out = new PrintWriter(outputStream);
    		//----------My Code Starts Here----------
    		long n=in.nextLong();
    		if(n==1){
    			System.out.println("5");
    		}
    		else{
    			System.out.println("25");
    		}
    		out.close();
    		//---------------The End------------------
    	}

    	static class Pair implements Comparable<Pair>{
    		int r1=-1;
    		int r2=-1;
    		int extra=0;
			@Override
			public int compareTo(Pair arg0) {
				// TODO Auto-generated method stub
				return 0;
			}
    	}

    	static class InputReader {
    	    public BufferedReader reader;
    	    public StringTokenizer tokenizer;

    	    public InputReader(InputStream inputstream) {
    	      reader = new BufferedReader(new InputStreamReader(inputstream));
    	      tokenizer = null;
    	    }

    	    public String nextLine(){
    	    	String fullLine=null;
    	    	while (tokenizer == null || !tokenizer.hasMoreTokens()) {
    	            try {
    	              fullLine=reader.readLine();
    	            } catch (IOException e) {
    	              throw new RuntimeException(e);
    	            }
    	            return fullLine;
    	          }
    	          return fullLine;
    	    }
    		public String next() {
    	      while (tokenizer == null || !tokenizer.hasMoreTokens()) {
    	        try {
    	          tokenizer = new StringTokenizer(reader.readLine());
    	        } catch (IOException e) {
    	          throw new RuntimeException(e);
    	        }
    	      }
    	      return tokenizer.nextToken();
    	    }
    		public long nextLong() {
    		      return Long.parseLong(next());
    		    }
    	    public int nextInt() {
    	      return Integer.parseInt(next());
    	    }
    	  }
    }


import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.*;

public class Main {

    private static void solve() throws IOException {
        long n = nextLong();
        out.println(25);
    }

    public static void main(String[] args) throws Exception {
        File file = new File("System.in");
        InputStream input = System.in;
        PrintStream output = System.out;
        if (file.exists() && file.canRead()) {
            input = new FileInputStream(file);
            output = new PrintStream("System.out");
        }
        br = new BufferedReader(new InputStreamReader(input));
        out = new PrintWriter(output);
        solve();
        out.close();
    }

    private static BufferedReader br;
    private static StringTokenizer st;
    private static PrintWriter out;

    private static boolean hasNextToken() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            String line = br.readLine();
            if (line == null) {
                return false;
            }
            st = new StringTokenizer(line);
        }
        return true;
    }

    private static String nextToken() throws IOException {
        return hasNextToken() ? st.nextToken() : null;
    }

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

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

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

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class A {
	static void solve(InputReader in, PrintWriter out) {
		long n = in.nextLong();
		out.print(25);
	}

	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);

		solve(in, out);

		out.close();
	}

	static class InputReader {
		public BufferedReader reader;
		public StringTokenizer tokenizer;

		public InputReader(InputStream stream) {
			reader = new BufferedReader(new InputStreamReader(stream), 32768);
			tokenizer = null;
		}

		public String next() {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			return tokenizer.nextToken();
		}

		public int nextInt() {
			return Integer.parseInt(next());
		}

		public long nextLong() {
			return Long.parseLong(next());
		}

		public long nextDouble() {
			return Long.parseLong(next());
		}

	}
}


import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;

public class main {
    public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    public static PrintWriter pw = new PrintWriter(System.out);
    public static String line;
    public static StringTokenizer st;
    public static ArrayList<ArrayList<Integer>> adjList;

    public static void main(String[] args) throws Exception{
        String s = br.readLine();
        pw.print(25);
        pw.print("\n");
        pw.close();
        br.close();
    }
}


import java.util.Scanner;

/**
 * Feb 18, 2016 | 4:00:49 PM
 *

 * Description
 *
 *

 *
 * @author Essiennta Emmanuel (colourfulemmanuel@gmail.com)
 */
public class ProblemA{

    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        sc.next();
        System.out.println(25);
        sc.close();
    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author ATailouloute
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        QuickScanner in = new QuickScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, QuickScanner in, PrintWriter out) {
            long n = in.nextLong();
            out.println(IntegerUtils.pow(5L, n, 100));
        }

    }

    static class QuickScanner {
        BufferedReader br;
        StringTokenizer st;
        InputStream is;

        public QuickScanner(InputStream stream) {
            is = stream;
            br = new BufferedReader(new InputStreamReader(stream), 32768);
        }

        String nextToken() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return st.nextToken();
        }

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

    }

    static class IntegerUtils {
        public static long pow(long a, long base, long mod) {
            if (base == 0) return 1;
            if (base == 1) return a;
            if ((base & 1) == 1)
                return (a * pow(a, base - 1, mod)) % mod;
            return pow((a * a) % mod, base / 2, mod);
        }

    }
}


import java.util.*;
public class AgainTwentyfive {
	public static void main(String[] args)
	{
		System.out.println("25");
	}
}


/* package whatever; // don't place package name! */

import java.util.*;
;

/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner s = new Scanner(System.in);
		long n = s.nextLong();
		System.out.println(25);
	}
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Egor Kulikov (egor@egork.net)
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            out.printLine(25);
        }

    }

    static class InputReader {
        private InputStream stream;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void close() {
            writer.close();
        }

        public void printLine(int i) {
            writer.println(i);
        }

    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.StringTokenizer;

public class LuxuriousHouses {

	public static void main(String[] args) throws IOException {
		System.out.println(25);

	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

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

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

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

	}
}


import java.io.*;
public class again_25 {
	public static void main(String ar[])throws IOException
	{
		long n;
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		n=Long.parseLong(br.readLine());
		System.out.println("25");
	}
}


import java.util.Scanner;

public class CF630_A {

    public static void main(String[] args) {
        try (Scanner s = new Scanner(System.in)) {
            long n = s.nextLong();

            System.out.println("25");
        }
    }
}


/**
 *
 * @author Mohammad Hadi
 */
public class A630 {
    public static void main(String[] args) {
        System.out.println(25);
    }
}


import java.util.*;
public class Contests {

	public static void main(String[] args) {
		Scanner clavier=new Scanner(System.in);
		long a=clavier.nextLong();
		clavier.close();
		if(a==1)
			System.out.println(5);
		else
			System.out.println(25);
	}

}


import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class Main {
    FastScanner in;
    PrintWriter out;

    static final String FILE = "";

    public void solve() {
        out.print(25);
    }

    public void run() {
        if (FILE.equals("")) {
            in = new FastScanner(System.in);
            out = new PrintWriter(System.out);
        } else {
            try {
                in = new FastScanner(new FileInputStream(FILE +
                        ".in"));
                out = new PrintWriter(new FileOutputStream(FILE +
                        ".out"));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
        solve();
        out.close();
    }

    public static void main(String[] args) {
        (new Main()).run();
    }

    class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(InputStream is) {
            br = new BufferedReader(new InputStreamReader(is));
        }

        public String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
                return "";
            }
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public float nextFloat() {
            return Float.parseFloat(next());
        }
    }

    class Pair<A extends Comparable<A>, B extends Comparable<B>>
            implements Comparable<Pair<A, B>> {
        public A a;
        public B b;

        public Pair(A a, B b) {
            this.a = a;
            this.b = b;
        }

        @Override
        public int compareTo(Pair<A, B> o) {
            if (o == null || o.getClass() != getClass())
                return 1;
            int cmp = a.compareTo(o.a);
            if (cmp == 0)
                return b.compareTo(o.b);
            return cmp;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;

            Pair<?, ?> pair = (Pair<?, ?>) o;

            if (a != null ? !a.equals(pair.a) : pair.a != null) return
                    false;
            return !(b != null ? !b.equals(pair.b) : pair.b != null);
        }
    }

    class PairInt extends Pair<Integer, Integer> {
        public PairInt(Integer u, Integer v) {
            super(u, v);
        }
    }

    class PairLong extends Pair<Long, Long> {
        public PairLong(Long u, Long v) {
            super(u, v);
        }
    }

}


import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

import java.util.Set;
import java.util.Map.Entry;

import java.util.HashMap;
import java.util.Iterator;

public class test {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String num = input.nextLine();

        System.out.println("25");
    }
}


import java.io.PrintWriter;
import java.util.Locale;
import java.util.Scanner;

public class Main {

	public static void main(String args[]) {
		new Main().run();
	}

	void run(){
		Locale.setDefault(Locale.US);
		try(Scanner in=new Scanner(System.in);
			PrintWriter out=new PrintWriter(System.out)){
			solve(in, out);
		}
		catch (Exception e) {
			e.printStackTrace();
		}
	}

	private void solve(Scanner in, PrintWriter out) {
		String a=in.nextLine();
		out.println("25");
	}

}


import java.util.Scanner;

public class A {

	public static void main(String[] args){
		Scanner in = new Scanner(System.in);

		long n = in.nextLong();

		System.out.println(25);
	}

}


public class pregunta1 {

	public static void main(String[] args) {
		System.out.println("25");
	}

}


import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class A {

	public static void main(String[] args) {
		System.out.println(25);
	}
}


import java.io. *;
import java.util. *;

public class Main  {

    void solve(Scanner in, PrintWriter out) {
        out.println(25);

    }
    void run() {
        Locale.setDefault(Locale.US);
        try (
                Scanner in = new Scanner(System.in);
                PrintWriter out = new PrintWriter(System.out);
        )
        {
            solve(in, out);
        }

    }

    public static void main(String args[]) {

        new Main().run();
    }
}


import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

public class Main
{
	static ArrayList<Integer> Unique(ArrayList<Integer> x)
	{
		TreeSet<Integer> tmp=new TreeSet<Integer>();
		tmp.addAll(x);
		x.clear();
		x.addAll(tmp);
		return x;
	}
	public static void main(String[] args)
	{
		InputReader in = new InputReader();
//		Scanner in=new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		while(in.hasNext())
		{
			long n=in.nextLong();
			out.println("25");
		}
		out.close();
	}
}

class node
{
	ArrayList<Integer> v=new ArrayList<Integer>();
	node(){}
	void push(Integer a)
	{
		v.add(a);
	}
}

class InputReader
{
	BufferedReader buf;
	StringTokenizer tok;
	InputReader()
	{
		buf = new BufferedReader(new InputStreamReader(System.in));
	}

	boolean hasNext()
	{
		while (tok == null || !tok.hasMoreElements())
		{
			try
			{
				tok = new StringTokenizer(buf.readLine());
			}
			catch (Exception e)
			{
				return false;
			}
		}
		return true;
	}

	String next()
	{
		if (hasNext())
			return tok.nextToken();
		return null;
	}

	int nextInt()
	{
		return Integer.parseInt(next());
	}

	long nextLong()
	{
		return Long.parseLong(next());
	}

	double nextDouble()
	{
		return Double.parseDouble(next());
	}

	BigInteger nextBigInteger()
	{
		return new BigInteger(next());
	}

	BigDecimal nextBigDecimal()
	{
		return new BigDecimal(next());
	}
}


import java.util.Scanner;

public class TwentyFive {

	public static void main(String[] args) {

		System.out.println(25);

	}

}


import java.io.PrintWriter;
import java.util.Scanner;

public class Main {
    Scanner in;
    PrintWriter out;

    void solve() {
    	out.print("25");
    }

    void run() {

            in = new Scanner(System.in);
            out = new PrintWriter(System.out);

            solve();

            out.close();
    }

    public static void main(String[] args) {
        new Main().run();

    }
}


public class Main {
  public static void main(String[] args){
    System.out.println("25");
  }
}