import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println(Math.pow(sc.nextDouble()/3,3));
    }
    static long factorial(long num){
        if (num<2)return 1;
        else return num*factorial(num-1);
    }
    static int arraySum(int[] array){
        int ans = 0;
        for (int value : array) ans += value;
        return ans;
    }
    static long combination(long a, long b){
        long data = 1;
        for (int i=0;i<b;i++){
            data*=a-i;
        }
        return data/factorial(b);
    }
    static double log(double base,double antilogarithm){
        return Math.log(antilogarithm)/Math.log(base);
    }

    static long gcd(long x,long y){
        if (y==0)return x;
        else return gcd(y,x%y);
    }
    static long lcm(long x,long y){
        return x/gcd(x,y)*y;
    }
    static HashMap<Long,Long> factorization(long num){
        HashMap<Long,Long> hash = new HashMap<>();
        long n = num;
        long count = 2;
        while (n>1){
            while (n%count==0){
                n/=count;
                if (hash.containsKey(count))hash.put(count,hash.get(count)+1);
                else hash.put(count,1L);
            }
            count++;
        }
        return hash;
    }

} import java.util.*; util.* java public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println(Math.pow(sc.nextDouble()/3,3));
    }
    static long factorial(long num){
        if (num<2)return 1;
        else return num*factorial(num-1);
    }
    static int arraySum(int[] array){
        int ans = 0;
        for (int value : array) ans += value;
        return ans;
    }
    static long combination(long a, long b){
        long data = 1;
        for (int i=0;i<b;i++){
            data*=a-i;
        }
        return data/factorial(b);
    }
    static double log(double base,double antilogarithm){
        return Math.log(antilogarithm)/Math.log(base);
    }

    static long gcd(long x,long y){
        if (y==0)return x;
        else return gcd(y,x%y);
    }
    static long lcm(long x,long y){
        return x/gcd(x,y)*y;
    }
    static HashMap<Long,Long> factorization(long num){
        HashMap<Long,Long> hash = new HashMap<>();
        long n = num;
        long count = 2;
        while (n>1){
            while (n%count==0){
                n/=count;
                if (hash.containsKey(count))hash.put(count,hash.get(count)+1);
                else hash.put(count,1L);
            }
            count++;
        }
        return hash;
    }

} Main public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println(Math.pow(sc.nextDouble()/3,3));
    } main {
        Scanner sc = new Scanner(System.in);
        System.out.println(Math.pow(sc.nextDouble()/3,3));
    } Scanner sc = new Scanner(System.in); sc new Scanner(System.in) System.out.println(Math.pow(sc.nextDouble()/3,3)) System.out.println System.out System System.out Math.pow(sc.nextDouble()/3,3) Math.pow Math sc.nextDouble()/3 sc.nextDouble() sc.nextDouble sc 3 3 String[] args args static long factorial(long num){
        if (num<2)return 1;
        else return num*factorial(num-1);
    } factorial {
        if (num<2)return 1;
        else return num*factorial(num-1);
    } if (num<2)return 1;
        else return num*factorial(num-1); num<2 num 2 return 1; 1 return num*factorial(num-1); num*factorial(num-1) num factorial(num-1) factorial num-1 num 1 long num num static int arraySum(int[] array){
        int ans = 0;
        for (int value : array) ans += value;
        return ans;
    } arraySum {
        int ans = 0;
        for (int value : array) ans += value;
        return ans;
    } int ans = 0; ans 0 for (int value : array) ans += value; int value array ans += value; ans += value ans value return ans; ans int[] array array static long combination(long a, long b){
        long data = 1;
        for (int i=0;i<b;i++){
            data*=a-i;
        }
        return data/factorial(b);
    } combination {
        long data = 1;
        for (int i=0;i<b;i++){
            data*=a-i;
        }
        return data/factorial(b);
    } long data = 1; data 1 for (int i=0;i<b;i++){
            data*=a-i;
        } int i=0; int i=0; i 0 i<b i b i++ i++ i {
            data*=a-i;
        } {
            data*=a-i;
        } data*=a-i data a-i a i return data/factorial(b); data/factorial(b) data factorial(b) factorial b long a a long b b static double log(double base,double antilogarithm){
        return Math.log(antilogarithm)/Math.log(base);
    } log {
        return Math.log(antilogarithm)/Math.log(base);
    } return Math.log(antilogarithm)/Math.log(base); Math.log(antilogarithm)/Math.log(base) Math.log(antilogarithm) Math.log Math antilogarithm Math.log(base) Math.log Math base double base base double antilogarithm antilogarithm static long gcd(long x,long y){
        if (y==0)return x;
        else return gcd(y,x%y);
    } gcd {
        if (y==0)return x;
        else return gcd(y,x%y);
    } if (y==0)return x;
        else return gcd(y,x%y); y==0 y 0 return x; x return gcd(y,x%y); gcd(y,x%y) gcd y x%y x y long x x long y y static long lcm(long x,long y){
        return x/gcd(x,y)*y;
    } lcm {
        return x/gcd(x,y)*y;
    } return x/gcd(x,y)*y; x/gcd(x,y)*y x/gcd(x,y) x gcd(x,y) gcd x y y long x x long y y static HashMap<Long,Long> factorization(long num){
        HashMap<Long,Long> hash = new HashMap<>();
        long n = num;
        long count = 2;
        while (n>1){
            while (n%count==0){
                n/=count;
                if (hash.containsKey(count))hash.put(count,hash.get(count)+1);
                else hash.put(count,1L);
            }
            count++;
        }
        return hash;
    } factorization {
        HashMap<Long,Long> hash = new HashMap<>();
        long n = num;
        long count = 2;
        while (n>1){
            while (n%count==0){
                n/=count;
                if (hash.containsKey(count))hash.put(count,hash.get(count)+1);
                else hash.put(count,1L);
            }
            count++;
        }
        return hash;
    } HashMap<Long,Long> hash = new HashMap<>(); hash new HashMap<>() long n = num; n num long count = 2; count 2 while (n>1){
            while (n%count==0){
                n/=count;
                if (hash.containsKey(count))hash.put(count,hash.get(count)+1);
                else hash.put(count,1L);
            }
            count++;
        } n>1 n 1 {
            while (n%count==0){
                n/=count;
                if (hash.containsKey(count))hash.put(count,hash.get(count)+1);
                else hash.put(count,1L);
            }
            count++;
        } while (n%count==0){
                n/=count;
                if (hash.containsKey(count))hash.put(count,hash.get(count)+1);
                else hash.put(count,1L);
            } n%count==0 n%count n count 0 {
                n/=count;
                if (hash.containsKey(count))hash.put(count,hash.get(count)+1);
                else hash.put(count,1L);
            } n/=count n count if (hash.containsKey(count))hash.put(count,hash.get(count)+1);
                else hash.put(count,1L); hash.containsKey(count) hash.containsKey hash count hash.put(count,hash.get(count)+1) hash.put hash count hash.get(count)+1 hash.get(count) hash.get hash count 1 hash.put(count,1L) hash.put hash count 1L count++ count return hash; hash long num num public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println(Math.pow(sc.nextDouble()/3,3));
    }
    static long factorial(long num){
        if (num<2)return 1;
        else return num*factorial(num-1);
    }
    static int arraySum(int[] array){
        int ans = 0;
        for (int value : array) ans += value;
        return ans;
    }
    static long combination(long a, long b){
        long data = 1;
        for (int i=0;i<b;i++){
            data*=a-i;
        }
        return data/factorial(b);
    }
    static double log(double base,double antilogarithm){
        return Math.log(antilogarithm)/Math.log(base);
    }

    static long gcd(long x,long y){
        if (y==0)return x;
        else return gcd(y,x%y);
    }
    static long lcm(long x,long y){
        return x/gcd(x,y)*y;
    }
    static HashMap<Long,Long> factorization(long num){
        HashMap<Long,Long> hash = new HashMap<>();
        long n = num;
        long count = 2;
        while (n>1){
            while (n%count==0){
                n/=count;
                if (hash.containsKey(count))hash.put(count,hash.get(count)+1);
                else hash.put(count,1L);
            }
            count++;
        }
        return hash;
    }

} public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println(Math.pow(sc.nextDouble()/3,3));
    }
    static long factorial(long num){
        if (num<2)return 1;
        else return num*factorial(num-1);
    }
    static int arraySum(int[] array){
        int ans = 0;
        for (int value : array) ans += value;
        return ans;
    }
    static long combination(long a, long b){
        long data = 1;
        for (int i=0;i<b;i++){
            data*=a-i;
        }
        return data/factorial(b);
    }
    static double log(double base,double antilogarithm){
        return Math.log(antilogarithm)/Math.log(base);
    }

    static long gcd(long x,long y){
        if (y==0)return x;
        else return gcd(y,x%y);
    }
    static long lcm(long x,long y){
        return x/gcd(x,y)*y;
    }
    static HashMap<Long,Long> factorization(long num){
        HashMap<Long,Long> hash = new HashMap<>();
        long n = num;
        long count = 2;
        while (n>1){
            while (n%count==0){
                n/=count;
                if (hash.containsKey(count))hash.put(count,hash.get(count)+1);
                else hash.put(count,1L);
            }
            count++;
        }
        return hash;
    }

} Main
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println(Math.pow(sc.nextDouble()/3,3));
    }
    static long factorial(long num){
        if (num<2)return 1;
        else return num*factorial(num-1);
    }
    static int arraySum(int[] array){
        int ans = 0;
        for (int value : array) ans += value;
        return ans;
    }
    static long combination(long a, long b){
        long data = 1;
        for (int i=0;i<b;i++){
            data*=a-i;
        }
        return data/factorial(b);
    }
    static double log(double base,double antilogarithm){
        return Math.log(antilogarithm)/Math.log(base);
    }

    static long gcd(long x,long y){
        if (y==0)return x;
        else return gcd(y,x%y);
    }
    static long lcm(long x,long y){
        return x/gcd(x,y)*y;
    }
    static HashMap<Long,Long> factorization(long num){
        HashMap<Long,Long> hash = new HashMap<>();
        long n = num;
        long count = 2;
        while (n>1){
            while (n%count==0){
                n/=count;
                if (hash.containsKey(count))hash.put(count,hash.get(count)+1);
                else hash.put(count,1L);
            }
            count++;
        }
        return hash;
    }

}
