On the planet Mars a year lasts exactly n days (there are no leap years on Mars). But Martians have the same weeks as earthlings — 5 work days and then 2 days off. Your task is to determine the minimum possible and the maximum possible number of days off per year on Mars.

Input

The first line of the input contains a positive integer n (1 ≤ n ≤ 1 000 000) — the number of days in a year on Mars.

Output

Print two integers — the minimum possible and the maximum possible number of days off per year on Mars.

Examples

Input

14


Output

4 4


Input

2


Output

0 2

Note

In the first sample there are 14 days in a year on Mars, and therefore independently of the day a year starts with there will be exactly 4 days off .

In the second sample there are only 2 days in a year on Mars, and they can both be either work days or days off.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;

public class Solution implements Runnable
{
    private void solve() throws IOException
    {
        int n = nextInt();
        
        if (n == 1) {
        	writer.print("0 1");
            return;
        }
        if (n < 6) {
            writer.print("0 2");
            return;
        }
        if (n == 6) {
        	 writer.print("1 2");
             return;
        }
        
        int min = n % 7 == 6 ? n/7*2 + 1 : n/7*2;
        int max = n/7*2 + (n%7>2?2:n%7);
        
        writer.print(min + " " + max);
            
            

    }

    private static class Glass {
        double value;
        int level;

        public Glass (int level) {
            this.level = level;
        }
    }


    private String binaryXOR (String s1, String s2) {
        BigInteger a = new BigInteger( s1,2 );
        BigInteger b = new BigInteger( s2,2 );

        return a.xor( b ).toString(2);

    }


    private static void findDP( Node node )
    {
        for ( Node child : node.children )
        {
            if ( child.value > node.value )
            {
                child.dp = Math.max( child.dp, node.dp+1 );
                //findDP( child );
            }
        }
    }

    private static class Obj implements Comparable<Obj> {
        String name;
        int value;

        public Obj(int value) {
            this.value = value;
        }

        public Obj(String name, int value) {
            this.name = name;
            this.value = value;
        }

        @Override
        public int compareTo(Obj o) {
            return o.value-this.value;
        }
    }


    private static class Node
    {
        long value;
        long dp;
        List<Node> children;
        Node parent;

        public Node( int value )
        {
            this.value = value;
            dp = 1;
            children = new ArrayList<Node>();
        }
    }

    private static boolean isInt (String s) {
    	if (s.length() < 1)
    		return false;
    	else {
    		for (char c : s.toCharArray()) {
    			if (c < '0' || c > '9') {
    				return false;
    			}
    		}
    	}

    	return true;
    }

    private static Map<String,Integer> findSubString(String s, int k) {
        Map<String,Integer> map = new HashMap<>(  );
        for (int i = 0; i < s.length() - (k - 1); i++) {
            String str = new String( s.substring( i,i+k ) );
            if (map.containsKey( str )) {
                map.put( str, map.get( str ) + 1 );
            }
            else {
                map.put( str, 1 );

            }
        }

        return map;
    }



    //mergesort

    public static Comparable[] mergeSort(Comparable[] list)
    {
        if (list.length <= 1) {
            return list;
        }

        Comparable[] left = new Comparable[list.length / 2];
        Comparable[] right = new Comparable[list.length - left.length];
        System.arraycopy(list, 0, left, 0, left.length);
        System.arraycopy(list, left.length, right, 0, right.length);

        mergeSort(left);
        mergeSort(right);

        merge(left, right, list);
        return list;
    }

    private static void merge(Comparable[] left, Comparable[] right, Comparable[] result)
    {
        int leftIdx = 0;
        int rightIdx = 0;
        int index = 0;

        while (leftIdx < left.length && rightIdx < right.length)
        {
            if (left[leftIdx].compareTo(right[rightIdx]) < 0)
            {
                result[index++] = left[leftIdx];
                leftIdx++;
            }
            else
            {
                result[index++] = right[rightIdx];
                rightIdx++;
            }
        }

        System.arraycopy(left, leftIdx, result, index, left.length - leftIdx);
        System.arraycopy(right, rightIdx, result, index, right.length - rightIdx);
    }

    public static List<Obj> mergeSort(List<Obj> list) {
        if (list.size() <= 1) {
            return list;
        }

        List<Obj> left = new ArrayList(list.subList( 0, list.size()/2 ));
        List<Obj> right = new ArrayList (list.subList( left.size(), list.size() ));

        left = mergeSort(left);
        right = mergeSort(right);

        list = merge(left, right);

        return list;
    }

    private static List<Obj> merge(List<Obj> left,List<Obj> right)
   {
      int leftCounter = 0, rightCounter = 0;
       List<Obj> result = new ArrayList<>(  );

       while (leftCounter < left.size() && rightCounter < right.size()) {
           Obj leftItem = left.get( leftCounter );
           Obj rightItem = right.get( rightCounter );

           if ( leftItem.compareTo( rightItem ) < 0) {
               result.add( leftItem );
               leftCounter++;
            }
            else
            {
                result.add( rightItem );
                rightCounter++;
            }
       }

       if (leftCounter >= left.size())
           result.addAll( right.subList( rightCounter, right.size() ) );
       else if (rightCounter >= right.size())
           result.addAll( left.subList( leftCounter, left.size() ) );

       return result;
   }

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

    BufferedReader reader;
    StringTokenizer tokenizer;
    PrintWriter writer;

    public void run() {
        try {
            reader = new BufferedReader(new InputStreamReader(System.in));
            tokenizer = null;
            writer = new PrintWriter(System.out);
            solve();
            reader.close();
            writer.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();
    }
}