import java.lang.*;
import java.util.*;

public class PetyaAndOrigami {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        double n = scan.nextDouble();
        double k = scan.nextDouble();
        double ans = 0;
        double red, green, blue;
        red = 2 * n;
        green = 5 * n;
        blue = 8 * n;
        ans = (Math.ceil(red / k) + Math.ceil(green / k) + Math.ceil(blue / k));
        System.out.println((int)ans);
    }
}

import java.math.BigDecimal;
import java.util.Scanner;

public class PetyaOrigami {

    public static void main(String[] args) {
        System.out.println(new PetyaOrigami().solve(new Scanner(System.in).nextLine()));
    }

    long solve(String input) {
        String[] split = input.split(" ");
        BigDecimal friends = new BigDecimal(split[0]);
        BigDecimal notebookSheets = new BigDecimal(split[1]);
        BigDecimal redSheets = BigDecimal.valueOf(2);
        BigDecimal greenSheets = BigDecimal.valueOf(5);
        BigDecimal blueSheets = BigDecimal.valueOf(8);
        BigDecimal redNotebooks = friends.multiply(redSheets).divide(notebookSheets, BigDecimal.ROUND_UP);
        BigDecimal greenNotebooks = friends.multiply(greenSheets).divide(notebookSheets, BigDecimal.ROUND_UP);
        BigDecimal blueNotebooks = friends.multiply(blueSheets).divide(notebookSheets, BigDecimal.ROUND_UP);
        return redNotebooks.add(greenNotebooks).add(blueNotebooks).longValue();
    }
}

import java.util.Scanner;

public class Petyaorigami2 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		double n = scan.nextInt();
		double k = scan.nextInt();
		int res = 0;
		int red = (int) Math.ceil((2 * n) / k);
		int blu = (int) Math.ceil((5 * n) / k);
		int gre = (int) Math.ceil((8 * n) / k);
		res = red + blu + gre;
		System.out.println(res);
	}
}

import java.util.*;
import java.io.*;
public class Q3
{
	public static void main(String args[]) throws Exception
	{
		Scan scan = new Scan();
		Print print = new Print();
		double N=scan.scanDouble();
		double K=scan.scanDouble();
		long ans=0;
		ans+=(long)Math.ceil((2*N)/K);
		ans+=(long)Math.ceil((5*N)/K);
		ans+=(long)Math.ceil((8*N)/K);
		print.println(ans);
		print.close();
	}

	static class Print {
		private final BufferedWriter bw;

		public Print() {
			this.bw = new BufferedWriter(new OutputStreamWriter(System.out));
		}

		public void print(Object object) throws IOException {
			bw.append("" + object);
		}

		public void println(Object object) throws IOException {
			print(object);
			bw.append("\n");
		}

		public void close() throws IOException {
			bw.close();
		}
	}

	static class Scan {
		private byte[] buf = new byte[1024 * 1024 * 4];
		private int index;
		private InputStream in;
		private int total;

		public Scan() {
			in = System.in;
		}

		public int scan() throws IOException {
			if (total < 0)
				throw new InputMismatchException();
			if (index >= total) {
				index = 0;
				total = in.read(buf);
				if (total <= 0)
					return -1;
			}
			return buf[index++];
		}

		public int scanInt() throws IOException {
			int integer = 0;
			int n = scan();
			while (isWhiteSpace(n))
				n = scan();
			int neg = 1;
			if (n == '-') {
				neg = -1;
				n = scan();
			}
			while (!isWhiteSpace(n)) {
				if (n >= '0' && n <= '9') {
					integer *= 10;
					integer += n - '0';
					n = scan();
				} else
					throw new InputMismatchException();
			}
			return neg * integer;
		}

		public double scanDouble() throws IOException {
			double doub = 0;
			int n = scan();
			while (isWhiteSpace(n))
				n = scan();
			int neg = 1;
			if (n == '-') {
				neg = -1;
				n = scan();
			}
			while (!isWhiteSpace(n) && n != '.') {
				if (n >= '0' && n <= '9') {
					doub *= 10;
					doub += n - '0';
					n = scan();
				} else
					throw new InputMismatchException();
			}
			if (n == '.') {
				n = scan();
				double temp = 1;
				while (!isWhiteSpace(n)) {
					if (n >= '0' && n <= '9') {
						temp /= 10;
						doub += (n - '0') * temp;
						n = scan();
					} else
						throw new InputMismatchException();
				}
			}
			return doub * neg;
		}

		public long scanLong() throws IOException {
			long ret = 0;
			long c = scan();
			while (c <= ' ') {
				c = scan();
			}

			boolean neg = (c == '-');
			if (neg) {
				c = scan();
			}

			do {
				ret = ret * 10 + c - '0';
			} while ((c = scan()) >= '0' && c <= '9');

			if (neg) {
				return -ret;
			}
			return ret;
		}

		public String scanString() throws IOException {
			StringBuilder sb = new StringBuilder();
			int n = scan();
			while (isWhiteSpace(n))
				n = scan();
			while (!isWhiteSpace(n) || n == ' ') {
				sb.append((char) n);
				n = scan();
			}
			return sb.toString();
		}

		private boolean isWhiteSpace(int n) {
			if (n == ' ' || n == '\n' || n == '\r' || n == '\t' || n == -1)
				return true;
			return false;
		}
	}
}

/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
What do you think? What do you think?
1st on Billboard, what do you think of it
Next is a Grammy, what do you think of it
However you think, I’m sorry, but shit, I have no fcking interest
*******************************
I'm standing on top of my Monopoly board
That means I'm on top of my game and it don't stop
til my hip don't hop anymore
https://www.a2oj.com/Ladder16.html
*******************************
300iq as writer = Sad!
*/
import java.util.*;
import java.io.*;
import java.math.*;

   public class A
   {
      public static void main(String hi[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         int N = Integer.parseInt(st.nextToken());
         int K = Integer.parseInt(st.nextToken());
         int res = (2*N)/K+(N*5)/K+(8*N)/K;
         if((2*N)%K > 0)
            res++;
         if((8*N)%K > 0)
            res++;
         if((5*N)%K > 0)
            res++;
         System.out.println(res);
      }
   }

import java.util.Scanner;

public class petyaAndOrigami
{
	public static void main(String[] args)
	{
		Scanner sc = new Scanner(System.in);
		double n = sc.nextInt();
		double k = sc.nextInt();
		sc.close();
		System.out.println((int)(Math.ceil(2*n/k) + Math.ceil(5*n/k) + Math.ceil(8*n/k)));
	}
}

/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
If I'm the sun, you're the moon
Because when I go up, you go down
*******************************
I'm working for the day I will surpass you
https://www.a2oj.com/Ladder16.html
*/
import java.util.*;
import java.io.*;
import java.math.*;

   public class A
   {
      public static void main(String omkar[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         int N = Integer.parseInt(st.nextToken());
         int K = Integer.parseInt(st.nextToken());
         long red = 2*N;
         long green = 5*N;
         long blue = 8*N;
         long res = red/K+green/K+blue/K;
         if(red%K > 0)  res++;
         if(green%K > 0)  res++;
         if(blue%K > 0)  res++;
         System.out.println(res);
      }
   }

import java.util.Arrays;
import java.util.Scanner;

public class CF43A {
    public static void main(String[] args) {
        //1080A
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int k = scanner.nextInt();
        int answer = (2*n + k - 1)/k + (5*n + k - 1)/k  + (8*n + k - 1)/k;
        System.out.println(answer);
    }
}

import  java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.util.*;
import java.math.*;
import java.io.*;
import java.text.*;

public class hacker
{

    /*Fatt Gyi Bhai*/
    //Dekh le mera code
    public static boolean[] sieve(long n)
    {
        boolean[] prime = new boolean[(int)n+1];
        Arrays.fill(prime,true);
        prime[0] = false;
        prime[1] = false;
        long m = (long)Math.sqrt(n);
        for(int i=2;i<=m;i++)
        {
            if(prime[i])
            {
                for(int k=i*i;k<=n;k+=i)
                {
                    prime[k] = false;
                }
            }
        }
        return prime;
    }

    static long GCD(long a,long b)
    {
        if(a==0 || b==0)
        {
            return 0;
        }
        if(a==b)
        {
            return a;
        }
        if(a>b)
        {
            return GCD(a-b,b);
        }
        return GCD(a,b-a);
    }

    static long CountCoPrimes(long n)
    {
        long res = n;
        for(int i=2;i*i<=n;i++)
        {
            if(n%i==0)
            {
                while(n%i==0)
                {
                    n/=i;
                }
                res-=res/i;
            }
        }
        if(n>1)
        {
            res-=res/n;
        }
        return res;
    }

    //fastest way to find x**n
    static long modularExponentiation(long x,long n,long m)
    {
        long res = 1;
        while(n>0)
        {
            if(n%2==1)
            {
                res = (res*x)%m;
            }
            x =(x*x)%m;
            n/=2;
        }
        return res;
    }

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

    static int pow(int a,int b)
    {
        int res = 1;
        while(b>0)
        {
            if((b&1)==1)
            {
                res *= a;
            }

            b >>= 1;
            a *=a;
        }
        return res;
    }

   static long modInverse(long A,long M)
   {
    return modularExponentiation(A,M-2,M);
   }

    static void reverse(char[] a,int start,int end)
    {

        while(start<end)
        {
            char temp = a[start];
            a[start] = a[end];
            a[end] = temp;
            start++;
            end--;
        }

    }

    static boolean prime(int n)
    {
        for(int i=2;i*i<=n;i++)
        {
            if(i%2==0 ||i%3==0)
            {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) throws IOException
    {
      // = new PrintWriter("explicit.out");
        new hacker().run();

    }

    static int rev(int n)
    {
        int x=0;
        int num = 0;
        while(n>0)
        {
            x = n%10;
            num = num*10+x;
            n/=10;

        }
        return num;
    }

// Firse author  ka solution

   // static long N;
   static Scanner in = new Scanner(System.in);
    static void run() throws IOException
    {
        long n = nl();
        long k = nl();
        long res = 0;
        long curr = (n*8+k-1)/k;
        res+=curr;
        curr = (n*2+k-1)/k;
        res+=curr;
        curr = (n*5+k-1)/k;
        res+=curr;
        printL(res);

    }

    static void printL(long a)
    {
        System.out.println(a);
    }
    static void printS(String s)
    {
        System.out.println(s);
    }

    static void swap(char c,char p)
    {
        char t = c;
        c = p;
        p = t;
    }

    static long max(long n,long m)
    {
        return Math.max(n,m);
    }
    static long min(long n,long m)
    {
        return Math.min(n,m);
    }

    static double nd() throws IOException
    {
        return Double.parseDouble(in.next());
    }
    static int ni() throws IOException
    {
        return Integer.parseInt(in.next());
    }

    static long nl() throws IOException
    {
        return Long.parseLong(in.next());
    }

    static String si() throws IOException
    {
        return in.next();
    }

    static int abs(int n)
    {
        return Math.abs(n);
    }

    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();}

    }

}

class Pair implements Comparable<Pair>
{
    int value;
    int index;
    public Pair(int v,int i)
    {
        value = v;
        index = i;
    }

    public int compareTo(Pair a)
    {
        return this.value-a.value;
    }

}

import java.util.*;
public class Main {
    public static void main(String args[]) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt(),k=sc.nextInt();
        int r=0,b=0,g=0;
        if((2*n)%k==0){
            r=(2*n)/k;
        }
        else{
            r=(2*n)/k;
            r++;
        }
        if((5*n)%k==0){
            b=(5*n)/k;
        }
        else{
            b=(5*n)/k;
            b++;
        }
        if((8*n)%k==0){
            g=(8*n)/k;
        }
        else{
            g=(8*n)/k;
            g++;
        }
        System.out.println(r+b+g);
    }
}

import java.util.*;
public class Aa
{
   public static void main(String args[])
     {
         Scanner cin = new Scanner(System.in);
          int n = cin.nextInt();
          int k = cin.nextInt();
         int a = n*2;
         int b = n*5;
          int c = n*8;
         int res = (int) (Math.ceil(1.0*a/k) + Math.ceil(1.0*b/k) + Math.ceil(1.0*c/k));
        System.out.println(res);
   }
}

import java.util.Scanner;
public class Problem_1080_A {
    public static void main(String[] args) {
        Scanner Input = new Scanner(System.in);
        double F = Input.nextDouble();
        double K = Input.nextDouble();
        int R=(int)Math.ceil((2*F)/K) , G=(int)Math.ceil((5*F)/K) , B=(int)Math.ceil((8*F)/K) ;
        System.out.println(R+G+B);
    }
}

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

public class Main implements Runnable, AutoCloseable {
    Scanner in = new Scanner(new BufferedInputStream(System.in));
    PrintStream out = new PrintStream(new BufferedOutputStream(System.out));

    @Override
    public void run() {
//        int t = in.nextInt();
////        int t = 1;
//        for (int i = 0; i < t; i++) {
        doOnce();
//        }
    }

    private void doOnce() {
        int n = in.nextInt();
        int m = in.nextInt();
        long ansa = 0;
        ansa += n * 2 / m;
        if ((n * 2) % m != 0) {
            ansa++;
        }
        ansa += n * 5 / m;
        if ((n * 5) % m != 0) {
            ansa++;
        }
        ansa += n * 8 / m;
        if ((n * 8) % m != 0) {
            ansa++;
        }
        out.println(ansa);
    }

    //        if (test(n, m, k)) {
    //            out.println("YES");
    //        } else {
    //            out.println("NO");
    //        }

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

    @Override
    public void close() {
        out.close();
    }
}

import java.util.*;
public class Loader {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        long n = scanner.nextLong();
        long k = scanner.nextLong();
        double x = Math.ceil((2.0 * n)/k);
        double y = Math.ceil((5.0 * n)/k);
        double z  = Math.ceil((8.0 * n)/k);
        System.out.println((long)(x + y + z));
    }
}

import java.util.Scanner;

public class PetyaandOrigami {

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

		int n = scan.nextInt();
		int k = scan.nextInt();

		int r = (int) Math.ceil(2.0 * n / (double) k);
		int g = (int) Math.ceil(5.0 * n / (double) k);
		int b = (int) Math.ceil(8.0 * n / (double) k);

		System.out.println(r + g + b);

		scan.close();
	}

}

import java.util.*;
public class JavaApplication7 {
    public static void main(String[] args) {
       Scanner obj =new Scanner(System.in);
       int n1 = obj.nextInt();
       int n2 = obj.nextInt();
       int [] arr ={2,5,8};
       int c=0;
       for(int i=0;i<3 ;i++){
       if((n1*arr[i])%n2==0)
           c+=(n1*arr[i])/n2;
       else
           c+=((n1*arr[i])/n2)+1;
       }
       System.out.println(c);
    }}

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

public class One{
	public static void main(String[] args){
		Scanner in = new Scanner(System.in);
		double n = in.nextDouble();
		double k = in.nextDouble();

		System.out.println((int)(Math.ceil((n*2)/k) + Math.ceil((n*5)/k) + Math.ceil((n*8)/k)));
	}
}

//package com.baba;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        double k = s.nextDouble();
        int ans = 0;
        ans += Math.ceil((n*2)/k);
        ans += Math.ceil((n*5)/k);
        ans += Math.ceil((n*8)/k);
        System.out.println(ans);
    }
}

import java.util.Scanner;

public class A1080 {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int k = sc.nextInt();
		System.out.println((int)(Math.ceil((double)(n*2)/k)+Math.ceil((double)(n*5)/k)+Math.ceil((double)(n*8)/k)));
	}

}

import java.io.File;
import java.io.FileInputStream;
import java.util.Scanner;
import java.util.Set;
import java.util.Map.Entry;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.PriorityQueue;

public class Main {

	public static void main(String[] args) throws IOException {
		//File file = new File("input.txt");
		//Scanner sc = new Scanner(file);
		FastScanner sc = new FastScanner(System.in);

		int n = sc.nextInt();
		int k = sc.nextInt();
		int r = 2 * n;
		int g = 5 * n;
		int b = 8 * n;
		int sum = (int)Math.ceil(1.0*r/k) + (int)Math.ceil(1.0*g/k) + (int)Math.ceil(1.0*b/k);
		System.out.println(sum);
	}
}

class FastScanner {
    private InputStream in;
    private final byte[] buffer = new byte[1024];
    private int ptr = 0;
    private int buflen = 0;
    public FastScanner(InputStream in) {
		this.in = in;
	}
    private boolean hasNextByte() {
        if (ptr < buflen) {
            return true;
        }else{
            ptr = 0;
            try {
                buflen = in.read(buffer);
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (buflen <= 0) {
                return false;
            }
        }
        return true;
    }
    private int readByte() {
    	if (hasNextByte()) return buffer[ptr++];
    	else return -1;
    }
    private static boolean isPrintableChar(int c){
    	return 33 <= c && c <= 126;
    }
    public boolean hasNext() {
    	while(hasNextByte() && !isPrintableChar(buffer[ptr]))
    		ptr++; return hasNextByte();
    }
    public String next() {
        if (!hasNext()) throw new NoSuchElementException();
        StringBuilder sb = new StringBuilder();
        int b = readByte();
        while(isPrintableChar(b)) {
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }
    public long nextLong() {
        if (!hasNext()) throw new NoSuchElementException();
        long n = 0;
        boolean minus = false;
        int b = readByte();
        if (b == '-') {
            minus = true;
            b = readByte();
        }
        if (b < '0' || '9' < b) {
            throw new NumberFormatException();
        }
        while(true){
            if ('0' <= b && b <= '9') {
                n *= 10;
                n += b - '0';
            }else if(b == -1 || !isPrintableChar(b)){
                return minus ? -n : n;
            }else{
                throw new NumberFormatException();
            }
            b = readByte();
        }
    }
    public int nextInt() {
        long nl = nextLong();
        if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
        return (int) nl;
    }
    public double nextDouble() {
    	return Double.parseDouble(next());
    }
}

import java.util.Scanner;

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

        long n = reader.nextLong();
        long k = reader.nextLong();

        reader.close();

        long t1 = n * 2 / k;
        long t2 = n * 5 / k;
        long t3 = n * 8 / k;

        long sum = t1 + t2 + t3;

        if (n * 2 % k != 0)
            sum++;
        if (n * 5 % k != 0)
            sum++;
        if (n * 8 % k != 0)
            sum++;

        System.out.println(sum);
    }
}

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

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

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner sc=new Scanner(System.in);
		long n=sc.nextLong();
		long k=sc.nextLong();
		long total=0;
		long x=(long )Math.ceil((n*2.0)/k );
		long y=(long )Math.ceil((n*5.0)/k );
		long z=(long )Math.ceil((n*8.0)/k );
		//System.out.println(x+" "+y+" "+z);
		total=x+y+z;
		System.out.println(total);
	}
}

import java.util.Scanner;

public class test {
	static int a,b,c;
public static int min(int n,int k) {

		if(n>=1 && k<=100000000){
		a=(n*2)/k;
		b=(n*5)/k;
		c=(n*8)/k;
		if(0<(n*2)%k&&(n*2)%k<=k){
			a+=1;

		}
		if(0<(n*5)%k&&(n*5)%k<=k){
			b+=1;

		}
		if(0<(n*8)%k&&(n*8)%k<=k){
			c+=1;

		}
		}
		return a+b+c;

	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner s=new Scanner(System.in);
		int n=s.nextInt();
		int k=s.nextInt();
		System.out.println(min(n, k));

	}

}

import org.w3c.dom.ls.LSOutput;

import java.security.MessageDigest;
import java.util.*;
import java.math.*;
import java.lang.*;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int k = in.nextInt();

        int ans = ((5 * n) + k - 1) / k + ((8 * n) + k - 1) / k + ((2 * n) + k - 1) / k;
        System.out.println(ans);
    }
}

import java.util.*;
public class a
{
    public static void main(String args[])
    {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        int a=(2*n)/m;
        int b=(5*n)/m;
        int c=(8*n)/m;
        int d=0;
        if((2*n)%m!=0)
        {
            a+=1;
        }
        if((5*n)%m!=0)
        {
            b+=1;
        }
        if((8*n)%m!=0)
        {
            c+=1;
        }
        d=a+b+c;
        System.out.println(d);
    }
}

import java.util.*;
public class Main {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int a=sc.nextInt(),b=sc.nextInt();
		int x=a*2,y=a*5,z=a*8,sum=0;
		sum+=(x+b-1)/b+(y+b-1)/b+(z+b-1)/b;

		System.out.print(sum);
	}
}

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

public class petyaOrigami {

	public static void main(String[] args) throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));

		StringTokenizer st = new StringTokenizer(br.readLine());

		int n = Integer.parseInt(st.nextToken());
		int k = Integer.parseInt(st.nextToken());

		int r = n*2;
		int g = n*5;
		int b = n*8;

		int ans = ((r%k == 0) ? r/k : (r/k)+1) + ((g%k == 0) ? g/k : (g/k)+1) + ((b%k == 0) ? b/k : (b/k)+1);
		pw.println(ans);
		pw.close();

	}

}

import java.util.Scanner;
public class watermelon{
public static void main( String[] args) {
    Scanner scan = new Scanner(System.in);
    int n = scan.nextInt();
    int k = scan.nextInt();

    int x = (2*n) / k;
    if(2 * n % k != 0) x+=1;

    int y = (5*n) / k;
    if(5 * n % k != 0) y+=1;

    int z = (8*n) / k;
    if(8 * n % k != 0) z+=1;

    System.out.println(x+y+z);

}
}

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        double red =2 , green=5 , blue=8;
        int a = in.nextInt();
        int b = in.nextInt();
        System.out.println((int)(Math.ceil(red*a / b) + Math.ceil(green*a / b) + Math.ceil(blue*a / b)));
        }
}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int[] colourPaper = {2, 5, 8};
        int n = input.nextInt();
        int k = input.nextInt();
        int totalRequire = 0;
        for(int i = 0; i < colourPaper.length; i ++) {
            colourPaper[i] *= n;
            totalRequire += Math.ceil((double) colourPaper[i] / k);
        }
        System.out.println(totalRequire);
    }

}

import java.util.*;
public class problem1080A
{
   public static void main(String args[])
   {
      Scanner in=new Scanner(System.in);
      int n,k,r,g,b;
      n=in.nextInt();
      k=in.nextInt();
      r=(int)(Math.ceil((n*2)/(double)k));
      g=(int)(Math.ceil((n*5)/(double)k));
      b=(int)(Math.ceil((n*8)/(double)k));
      System.out.println(r+g+b);
   }
}

import java.lang.*;
import java.util.*;
public class Main
{
	public static void main(String[] args) {
		int r=2,g=5,b=8,r1,g1,b1,n,k,ans1=0,ans2=0,ans3=0,ans=0,t1=0,t2=0,t3=0;
		Scanner sc=new Scanner(System.in);
		n=sc.nextInt();
		k=sc.nextInt();
		r1=r*n;
		g1=g*n;
		b1=b*n;
		if((r1%k)==0)
			ans1=r1/k;
		else{
			t1=r1%k;
			r1=r1-t2;
			ans1=r1/k;
			ans1=ans1+1;
		}

		if((g1%k)==0){
			ans2=g1/k;
		}
		else{
			t2=g1%k;
			g1=g1-t2;
			ans2=g1/k;
			ans2=ans2+1;
		}

		if((b1%k)==0){
			ans3=b1/k;
		}
		else{
			t3=b1%k;
			b1=b1-t3;
			ans3=b1/k;
			ans3=ans3+1;
		}
		ans=ans1+ans2+ans3;
		System.out.println(ans);
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Hashtable;
import java.util.StringTokenizer;

public class Solution {
	public static void main ( String args [] ) throws IOException {

			solve();}

public static void solve() throws IOException {
Scanner sc = new Scanner(System.in);
int n=sc.nextInt();
int k=sc.nextInt();
int sum=0;
int f=n*2;
int t= n*5;
int p=n*8;
if(f%k==0) {
	sum+=f/k;
}else {
	sum+= f/k;
	sum++;
}
if(t%k==0) {
	sum+=t/k;
}else {
	sum+= t/k;
	sum++;
}
if(p%k==0) {
	sum+=p/k;
}else {
	sum+= p/k;
	sum++;
}
System.out.println(sum);

}

static void shuffle(int[] a)
{
	int n = a.length;
	for(int i = 0; i < n; i++)
	{
		int r = i + (int)(Math.random() * (n - i));
		int tmp = a[i];
		a[i] = a[r];
		a[r] = tmp;
	}
}

}

class Triple{
	int start;
	int end;
	int peaks;
	public Triple(int s,int e,int p) {
		this.start=s;
		this.end=e;
		this.peaks=p;
	}
}

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.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Bisoye
 */
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);
        APetyaAndOrigami solver = new APetyaAndOrigami();
        solver.solve(1, in, out);
        out.close();
    }

    static class APetyaAndOrigami {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int n = in.nextInt(), k = in.nextInt();

            int nr = n * 2, ng = n * 5, nb = n * 8;

            int r = ((nr + k - 1) / k), g = ((ng + k - 1) / k), b = ((nb + k - 1) / k);

            int res = r + g + b;
            out.print(res);

        }

    }
}

import java.util.*;
public class Solution {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int k = sc.nextInt();
		int r = 2*n;
		int g = 5*n;
		int b = 8*n;
		int x = 0;
		if (r%k==0)
			x=x+r/k;
		else x = x+r/k+1;
		if (g%k==0)
			x=x+g/k;
		else x = x+g/k+1;
		if (b%k==0)
			x=x+b/k;
		else x = x+b/k+1;
		System.out.println(x);
	}
}

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

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author ky112233
 */
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);
        APetyaAndOrigami solver = new APetyaAndOrigami();
        solver.solve(1, in, out);
        out.close();
    }

    static class APetyaAndOrigami {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int n = in.nextInt();
            int k = in.nextInt();
            int red = 2 * n;
            int green = 5 * n;
            int blue = 8 * n;
            double cnt = 0;
            cnt += Math.ceil((0.0 + red) / k);
            cnt += Math.ceil((0.0 + green) / k);
            cnt += Math.ceil((0.0 + blue) / k);
            out.println((long) cnt);
        }

    }
}

import java.util.*;

public class petya_and_origami{
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n=sc.nextInt();
		int k=sc.nextInt();
		int count=0;
		int red=n*2;
		int green=n*5;
		int blue=n*8;

		while(red>0){
			red-=k;
			count++;
		}
		while(green>0){
			green-=k;
			count++;
		}
		while(blue>0){
			blue-=k;
			count++;
		}

		System.out.println(count);
	}
}

import java.util.*;
import static java.lang.Math.*;
public class Demo{
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		long n = in.nextInt();
		long k = in.nextInt();
		System.out.println(((2*n+k-1)/k)+((5*n+k-1)/k)+((8*n+k-1)/k));
	}
}

import java.util.*;
import java.lang.*;
public class PetyaAndOrigami{
	public static void main(String args[])
	{
		Scanner sc = new Scanner(System.in);
		double n = sc.nextInt(); double k = sc.nextInt();
		int totNotebook = (int)Math.ceil(2*n/k)+(int)Math.ceil(5*n/k)+(int)Math.ceil(8*n/k);
		System.out.println(totNotebook);
	}
}

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

import java.util.*;
import java.lang.*;
import java.io.*;
import java.util.Arrays;
import java.math.BigInteger;

/* 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
     {
     	Scanner in =new Scanner(System.in);
		int t=1,i,j,l,n,k;
		String s="",st="";
		long x=0,m,p,h;
		for(i=0;i<t;i++)
		{
		     n=in.nextInt();
		     k=in.nextInt();
		     p=n*2;
		     m=5*n;
		     h=8*n;
		     if(p%k==0)
     		     x+=(p/k);
     		else
     		     x+=(p/k)+1;
		     if(m%k==0)
     		     x+=(m/k);
     		else
     		     x+=(m/k)+1;
		     if(h%k==0)
     		     x+=(h/k);
     		else
     		     x+=(h/k)+1;
     		System.out.println(x);
		}
	}
}

import java.util.*;
import java.lang.*;
public class p2
{
	public static void main(String[] args)
	{
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		double k=sc.nextDouble();
		if(1<=n&&k<=100000000)
		{
			int r=2;
			int g=5;
			int b=8;
			for(int i=0;i<n-1;i++)
			{
				r=r+2;
				g=g+5;
				b=b+8;
			}
			double r2=Math.ceil(r/k);
			double g2=Math.ceil(g/k);
			double b2=Math.ceil(b/k);
			double nb=r2+g2+b2;
			int nb2=(int) nb;
			System.out.println(nb2);
		}
    }
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int k = scan.nextInt();
        scan.nextLine();
        int red = 2 * n;
        int green = 5 * n;
        int blue = 8 * n;

        int min;

        if (k > red) min = 1;
        else if (red % k == 0) min = red / k;
        else min = red / k + 1;

        if (k > green) min += 1;
        else if (green % k == 0) min += green / k;
        else min += green / k + 1;

        if (k > blue) min += 1;
        else if (blue % k == 0) min += blue / k;
        else min += blue / k + 1;

        System.out.println(min);
    }
}

import java.util.Scanner;

public class PetyaAndOrigami {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		double nFriends = sc.nextDouble();
		double nSheets = sc.nextDouble();

		double red = 2;
		double green = 5;
		double blue = 8;

		red = red * nFriends;
		green = green * nFriends;
		blue = blue * nFriends;

		red = Math.ceil(red/nSheets);
		green = Math.ceil(green/nSheets);
		blue = Math.ceil(blue/nSheets);

		System.out.println((int)red + (int)green + (int)blue);
	}

}

import java.util.Scanner;
public class PetyaAndOrigami
{
    public static void main(String[] args)
    {
        Scanner s = new Scanner(System.in);
        int invite = s.nextInt();
        int sheets = s.nextInt();
        double red,green,blue;
        red = Math.ceil((2.0*invite)/sheets);
        green = Math.ceil((5.0*invite)/sheets);
        blue = Math.ceil((8.0*invite)/sheets);
        System.out.println((int)red+(int)blue+(int)green);
    }

}

import java.util.Scanner;

public class Main2
{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int friends = scanner.nextInt();
        int paperPerNotebook = scanner.nextInt();
        int numberOfBlueNeeded = 8 * friends;
        int numberOfGreenNeeded = 5 * friends;
        int numberOfRedNeeded = 2 * friends;
        int noteBook = 0;
        while (numberOfBlueNeeded > 0)
        {
            numberOfBlueNeeded -= paperPerNotebook;
            noteBook++;
        }
        while (numberOfGreenNeeded > 0)
        {
            numberOfGreenNeeded -= paperPerNotebook;
            noteBook++;
        }
        while (numberOfRedNeeded > 0)
        {
            numberOfRedNeeded -= paperPerNotebook;
            noteBook++;
        }
        System.out.println(noteBook);
    }
}

import java.util.*;
public class mohammad {
    public static void main(String[] args) {
        //HashMap<Integer, Integer>map = new HashMap<>();
        //ArrayList<Integer> list = new ArrayList<>();
        /* --------------->Mohammad Abohasan<--------------- 2 red, 5 green, 8 blue*/
        Scanner sc = new Scanner (System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        int r = n*2 ;
        int g = n*5 ;
        int b = n*8 ;
        int s = r/k ;
        int s1 = g/k ;
        int s2 = b/k ;
        if (r%k != 0)
            s+=1;
        if (g%k != 0)
            s1+=1;
        if (b%k != 0)
            s2+=1;
        System.out.println(s+s1+s2);

    }
}
/*
3 5
-->10
15 6
-->38
*/

// #pragma GCC optimize("Ofast")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

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

import static java.lang.Math.*;

public class Main {
    static int infi = Integer.MAX_VALUE / 2, mod = (int) (1e9 + 7), maxn = (int) 1e5;
    static long infl = Long.MAX_VALUE / 2;

    public static void main(String[] args) throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
        long n = nextInt();
        long k = nextInt();
        long red = (n * 2) / k + min(1, (n * 2) % k);
        long green = (n * 5) / k + min(1, (n * 5) % k);
        long blue = (n * 8) / k + min(1, (n * 8) % k);
        out.println(red + green + blue);
        out.close();
    }

    static BufferedReader br;
    static StringTokenizer st = new StringTokenizer("");
    static PrintWriter out;

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

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

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

}

class f {
    int x, y;

    public f(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

import java.util.*;
public final class Solution{
    public static void main(String args[]){
        Scanner scan=new Scanner(System.in);
        int n=scan.nextInt();
        int k=scan.nextInt();
        int r=n*2;
        int g=n*5;
        int b=n*8;
        int cnt=0;
        if(r%k==0){
            cnt+=r/k;
        }
        else{
            cnt+=r/k+1;
        }
        if(g%k==0){
            cnt+=g/k;
        }
        else{
            cnt+=g/k+1;
        }
        if(b%k==0){
            cnt+=b/k;
        }
        else{
            cnt+=b/k+1;
        }
        System.out.print(cnt);
    }
}

import java.util.Scanner;
    import java.util.*;
    import java.lang.Math;
    public class Main {

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

                System.out.println((long)Math.ceil(2*(double)n / k) + (long)Math.ceil(5*(double)n / k) + (long)Math.ceil(8 *(double)n / k));
        }
    }

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

public class Main {

	public static void solve(InputReader in) {
		int n = in.readInt();
		int k = in.readInt();
		int ans = 0;
		ans += (2*n)%k == 0 ? (2*n)/k : (2*n)/k + 1;
		ans += (5*n) % k == 0 ? (5*n)/k : (5*n)/k + 1;
		ans += (8*n) % k == 0 ? (8*n)/k : (8*n)/k + 1;
		System.out.println(ans);
	}

	public static void main(String[] args) {
		InputReader in = new InputReader(System.in);
		int t = 1;
		while (t-- > 0)
			solve(in);
	}
}

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

	 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 readInt() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

     public String readString() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isSpaceChar(c));
		return res.toString();
	}

     public long readLong() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		long res = 0;
		do {
			if (c < '0' || c > '9') {
				throw new InputMismatchException();
			}
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

     public boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

     public String next() {
		return readString();
	}

     public interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}
}

import java.util.Scanner;

public class PetyaAndOrigami {

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

        int n = input.nextInt() , k = input.nextInt();
        int red = n*2 , green = n*5 , blue = n*8;
        int rn = 0 , gn = 0 , bn = 0;

        if(red < k)
            rn++;
        else{
             while(red >= k){
             red -= k;
             rn++;
             if(red < k && red != 0)
              rn++;
            }
        }
        if(green < k)
            gn++;
        else{
             while(green >= k){
             green -= k;
             gn++;
             if(green < k && green != 0)
                gn++;
            }
        }

        if(blue < k)
            bn++;
        else{
             while(blue >= k){
             blue -= k;
             bn++;
             if(blue < k && blue != 0)
                bn++;
            }
        }

        System.out.println(rn + gn + bn);
    }
}

import java.util.*;

public class Codeforces{

	public static void main(String args[]){
		Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int k = in.nextInt();
        System.out.println((int)(Math.ceil(2*n/(double)k)+Math.ceil(5*n/(double)k)+Math.ceil(8*n/(double)k)));
	}

}

import java.util.Scanner;
public class Main {
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int k = scan.nextInt();

        int red = n*2;
        int green = n*5;
        int blue = n*8;

        int noteBooks=0;

        if(red%k==0){
            noteBooks+=red/k;
        }
        if(red%k!=0){
            noteBooks+=red/k+1;
        }
        if(green%k==0){
            noteBooks+=green/k;
        }
        if(green%k!=0){
            noteBooks+=green/k+1;
        }
        if(blue%k==0){
            noteBooks+=blue/k;
        }
        if(blue%k!=0){
            noteBooks+=blue/k+1;
        }
        System.out.println(noteBooks);
    }
}

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

public class Main
{

  public static void main(String[] args) throws Exception
  {
    long startTime = System.nanoTime();
    double n = in.nextInt();
    double k = in.nextInt();
    double red = 2*n;
    double green = 5*n;
    double blue = 8*n;
    double ans = Math.ceil(red/k) + Math.ceil(green/k) + Math.ceil(blue/k);
    out.println((long)ans);
    long endTime = System.nanoTime();
    err.println("Execution Time : +" + (endTime-startTime)/1000000 + " ms");
    exit(0);
  }

  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 long nextLong() {
            return Long.parseLong(next());
        }

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

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

    static void exit(int a)
    {
      out.close();
      err.close();
      System.exit(a);
    }

    static InputStream inputStream = System.in;
    static OutputStream outputStream = System.out;
    static OutputStream errStream = System.err;
    static InputReader in = new InputReader(inputStream);
    static PrintWriter out = new PrintWriter(outputStream);
    static PrintWriter err = new PrintWriter(errStream);
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

}

import java.util.*;

public class PetyaOrigami{
	public static void main(String args[]){
		Scanner kbd = new Scanner(System.in);
		int n = Integer.parseInt(kbd.next());
		int c = Integer.parseInt(kbd.next());
		int kol = ((n*2+c-1)/c) + ((n*5+c-1)/c) + ((n*8+c-1)/c);
		System.out.println(kol);
	}
}

//codeforces_1080A_live

import java.io.*;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import static java.lang.Math.*;
import java.math.*;

public class Main{

	static PrintWriter go = new PrintWriter(System.out);

	public static void main(String args[]) throws IOException,FileNotFoundException {
		BufferedReader gi = new BufferedReader(new InputStreamReader(System.in));
		int[] l = parseArray(gi);
		int n = l[0];
		int m = l[1];
		long ans = 0;
		ans = (n*2)/m;
		if (( 2*n )%m>0){ ans++; }
		ans += (n*5)/m;
		if (( 5*n )%m>0){ ans++; }
		ans += (n*8)/m;
		if (( 8*n )%m>0){ ans++; }
		go.println(ans);

		go.close();
	}

	static int[] parseArray(BufferedReader gi) throws IOException{
		String[] line = gi.readLine().trim().split(" ");
		int[] rez = new int[line.length];
		for ( int k = 0; k < line.length; k++){
			rez[k] = Integer.parseInt(line[k]);
		}
		return rez;
	}

}

import java.util.Scanner;
public class Main
{
	public static void main(String[] args) {
		Scanner newScanner = new Scanner(System.in);
		int n = newScanner.nextInt();
		int k = newScanner.nextInt();
		newScanner.close();
		int a = 0;
		if ((n * 2) % k == 0){
		    if ((n * 8) % k == 0)
		        a += (n * 8) / k + (n * 2) / k;
		    else
    		    a += (n * 8) / k + (n * 2) / k + 1;}
		else
		    if ((n * 8) % k == 0)
                a += (n * 8) / k + (n * 2) / k + 1;
            else
    		    a += (n * 8) / k + (n * 2) / k + 2;
		if ((n * 5) % k == 0)
		    a += (n * 5) / k;
		else
		    a += (n * 5) / k + 1;
		System.out.println(a);
	}
}

import java .util.Scanner;
public class add
{
	public static void main(String[] args)
	{
		double a,b,c,n,sum,d;
		long  ans;
		Scanner aaa=new Scanner(System.in);
		n=aaa.nextDouble();
		sum=aaa.nextDouble();
		a=n*2;
		b=n*5;
		c=n*8;
		d=Math.ceil(a/sum)+Math.ceil(b/sum)+Math.ceil(c/sum);
		ans=(int) d;
		System.out.print(ans);
	}
}

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

public class Solution {
	public static PrintWriter w = new PrintWriter(System.out);
	public static void main(String args[] ) throws Exception {
		Reader in = new Reader();
		int n = in.nextInt(), k = in.nextInt();
		w.println((int)Math.ceil(((2*n)/(double)k)) + (int)Math.ceil(((5*n)/(double)k)) + (int)Math.ceil(((8*n)/(double)k)));
		w.flush();
		return;
	}
}

class Reader {
	final private int BUFFER_SIZE = 1 << 16;
	private DataInputStream din;
	private byte[] buffer;
	private int bufferPointer, bytesRead;

	public Reader() {
		din = new DataInputStream(System.in);
		buffer = new byte[BUFFER_SIZE];
		bufferPointer = bytesRead = 0;
	}
	public String nextLine() throws IOException {
		int c = read();
		while(isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while(!isEndOfLine(c));
		return res.toString();
	}
	public String next() throws IOException {
		int c = read();
		while(isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while(!isSpaceChar(c));
		return res.toString();
	}
	public int nextInt() throws IOException {
		int ret = 0;
		byte c = read();
		while(c <= ' ')
			c = read();
		boolean neg = (c == '-');
		if(neg)
			c = read();
		do {
			ret = ret * 10 + c - '0';
		} while((c = read()) >= '0' && c <= '9');
		if (neg)
			return -ret;
		return ret;
	}
	public int[] nextIntArray(int n) throws IOException {
		int a[] = new int[n];
		for(int i = 0; i < n; i++)
			a[i] = nextInt();
		return a;
	}
	public int[][] next2dIntArray(int n, int m) throws IOException {
		int a[][] = new int[n][m];
		for(int i = 0; i < n; i++)
			for(int j = 0; j < m; j++)
				a[i][j] = nextInt();
		return a;
	}
	public char nextChar() throws IOException {
		return next().charAt(0);
	}
	public long nextLong() throws IOException {
		long ret = 0;
		byte c = read();
		while(c <= ' ')
			c = read();
		boolean neg = (c == '-');
		if(neg)
			c = read();
		do {
			ret = ret * 10 + c - '0';
		} while((c = read()) >= '0' && c <= '9');
		if (neg)
			return -ret;
		return ret;
	}
	public double nextDouble() throws IOException {
		double ret = 0, div = 1;
		byte c = read();
		while(c <= ' ')
			c = read();
		boolean neg = (c == '-');
		if(neg)
			c = read();
		do {
			ret = ret * 10 + c - '0';
		} while((c = read()) >= '0' && c <= '9');
		if (c == '.') {
			while((c = read()) >= '0' && c <= '9') {
				ret += (c - '0') / (div *= 10);
			}
		}
		if(neg)
			return -ret;
		return ret;
	}
	private void fillBuffer() throws IOException {
		bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
		if(bytesRead == -1)
			buffer[0] = -1;
	}
	private byte read() throws IOException {
		if(bufferPointer == bytesRead)
			fillBuffer();
		return buffer[bufferPointer++];
	}
	public void close() throws IOException {
		if(din == null)
			return;
		din.close();
	}
	public boolean isSpaceChar(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}
	private boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}
}

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

public class A {
	FastScanner in;
    PrintWriter out;

    void solve() {
       int n = in.nextInt();
       int k = in.nextInt();
       out.print(2*n/k + (2*n%k==0?0:1) + 5*n/k + (5*n%k==0?0:1) + 8*n/k + (8*n%k==0?0:1));

    }

	public static void main(String[] args) {
        new A().runIO();
    }

	void run() {
        try {
            in = new FastScanner(new File("A.in"));
            out = new PrintWriter(new File("A.out"));
            solve();
            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    void runIO() {
        in = new FastScanner(System.in);
        out = new PrintWriter(System.out);
        solve();
        out.close();
    }

	class FastScanner {
        BufferedReader br;
        StringTokenizer st;

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

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

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

        boolean hasMoreTokens() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return false;
                st = new StringTokenizer(s);
            }
            return true;
        }

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

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

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

import java.util.Scanner;

public class PetyaAndOrigami {
	public static void main(String[] args) {

		Scanner in = new Scanner(System.in);
		double n = in.nextInt(), k = in.nextInt();

		System.out.println((int)(Math.ceil(2 * n / k) + Math.ceil(5 * n / k) + Math.ceil(8 * n / k)));
		in.close();
	}
}

import java.util.Scanner;

public class PetyaAndOrigami {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int r=2;
        int g=5;
        int b=8;
        int ans=0;
        int n=sc.nextInt();
        int k=sc.nextInt();
        ans=(int)Math.ceil((double)(r*n)/k);
        ans=ans+(int)Math.ceil((double)(g*n)/k);
        ans=ans+(int)Math.ceil((double)(b*n)/k);
        System.out.println(ans);

    }
}

//make sure to make new file!
import java.io.*;
import java.util.*;

public class A524{

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

      StringTokenizer st = new StringTokenizer(f.readLine());

      int n = Integer.parseInt(st.nextToken());
      int m = Integer.parseInt(st.nextToken());

      int answer = (2*n+m-1)/m + (5*n+m-1)/m + (8*n+m-1)/m;
      out.println(answer);

      out.close();
   }

}

import java.util.Scanner;
public class A1080{
    public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    int n = scan.nextInt();
    int k = scan.nextInt();

    double na = (double)(k);
    int red = 2*n; // how many red sheets needed
    int green = 5 * n; // how many green sheets needed
    int blue = 8 * n; // how many blue sheets needed

    int r = red/k;
    if(red%k != 0){
        r += 1;
    }
    int g = green/k;
    if(green%k != 0){
        g += 1;
    }
    int b = blue/k;
    if(blue%k != 0){
        b += 1;
    }

    System.out.println(r + g + b);

    }
}

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {

		Scanner scan = new Scanner(System.in);

		long n , k;
		n = scan.nextLong();
		k = scan.nextLong();
		long ans = 0;

		long temp = (2 * n) / k;
		if ((2 * n) % k != 0) {
			temp ++;
		}
		ans += temp;

		temp = (5 * n) / k;
		if ((5 * n) % k != 0) {
			temp ++;
		}
		ans += temp;

		temp = (8 * n) / k;
		if ((8 * n) % k != 0) {
			temp ++;
		}
		ans += temp;

		System.out.println(ans);

	}

}

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int k = sc.nextInt();
		sc.close();
		double ans = Math.ceil(n * 2.0 / k) + Math.ceil(n * 5.0 / k) + Math.ceil(n * 8.0 / k);
		System.out.println((int)ans);

	}

}

import java.lang.Math;
import java.util.Scanner;

public class HelloWorld
{
  public static void main(String[] args)
  {
	Scanner in = new Scanner(System.in);
    int n = in.nextInt();
    int k = in.nextInt();

    double c = Math.ceil(n*2.0/k) + Math.ceil(n*5.0/k) + Math.ceil(n*8.0/k);
    System.out.println((int)c);
  }
}

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

public class b {
	static class FastReader
	{
		BufferedReader br;
		StringTokenizer st;

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

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

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

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

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

		String nextLine()
		{
			String str = "";
			try
			{
				str = br.readLine();
			}
			catch (IOException e)
			{
				e.printStackTrace();
			}
			return str;
		}
		int[] readArray(int n) {
			int[] a = new int[n];
			for(int i = 0; i < n; i++) {
				a[i] = Integer.parseInt(next());
			}
			return a;
		}
	}
	public static void main(String[] args) throws Exception {
		FastReader scan =new FastReader();
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		int n = scan.nextInt();
		int k = scan.nextInt();
		int a = ((n * 2)+k-1)/k;
		int b = ((n * 5)+k-1)/k;
		int c = ((n * 8)+k-1)/k;
		out.println(a+b+c);
		out.flush();
	}
}

import java.util.Scanner;

public class Main {

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

		/*
		 * n명의 친구들 초대하는데 친구마다 2개의 red, 5개의 green, 8개의 blue 종이가 필요하다.
		 * 상점에선 종이를 판매하는데 한 색상씩 판매하고, 각 색상의 갯수는 k개 이다.
		 * red가 10개필요하고, k가 3일경우 -> 3개씩 4번을 사야 모든 친구를 초대할 수 있다.
		 */

		int n = scan.nextInt();	// 친구 수
		int k = scan.nextInt();	// 시트 수

		int R = n * 2;	// 필요한 red 종이 수
		int G = n * 5;	// 필요한 green 종이 수
		int B = n * 8; 	// 필요한 blue 종이 수

		int min = 0;	// 필요한 최소한의 종이 수
		min = (R/k) + (G/k) + (B/k);
		// 각 색상마다 나누어떨어지지 않을 경우 1묶음 더 필요.
		min += (R%k == 0) ? 0 : 1;
		min += (G%k == 0) ? 0 : 1;
		min += (B%k == 0) ? 0 : 1;

		System.out.println(min);

		scan.close();
	}

}

import java.util.*;
public class file{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
int n= scan.nextInt();
int k=scan.nextInt();
int red = 8*n;
int green =5*n;
int blue = 2*n;
int sum=0;
if(red%k == 0){
sum+=red/k;
}else{
sum+=(red/k)+1;
}

if(green%k == 0){
sum+=green/k;
}else{
sum+=(green/k)+1;
}

if(blue%k == 0){
sum+=blue/k;
}else{
sum+=(blue/k)+1;
}

System.out.println(sum);

}
}

import java.util.Scanner;

public class Main {

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

		Scanner scn=new Scanner(System.in);
		int friends=scn.nextInt();
		int sheets=scn.nextInt();
		scn.close();

		int notebooks=0;
		int redNote=0;
		int greenNote=0;
		int blueNote=0;

		if((friends*2) % sheets==0)  redNote=friends*2/sheets;
		else redNote=(friends*2/sheets)+1;
		if((friends*5) % sheets ==0) greenNote=friends*5/sheets;
		else greenNote=(friends*5/sheets)+1;
		if (friends*8 %sheets ==0) blueNote=friends*8/sheets;
		else blueNote=friends*8/sheets+1;

		notebooks=redNote+greenNote+blueNote;
		System.out.println(notebooks);

	}

}

public class PetyaOrigami{
	public static void main(String []args){

		java.util.Scanner scan=new java.util.Scanner(System.in);
		int n=scan.nextInt();
		int k=scan.nextInt();
		long red=2*n;
		long green=5*n;
		long blue=8*n;
		if(red%k==0){
			red=red/k;
		}else{
			red=red/k+1;
		}
		if(green%k==0){
			green=green/k;
		}else{
			green=green/k+1;
		}
		if(blue%k==0){
			blue=blue/k;
		}else{
			blue=blue/k+1;
		}
		long sum=red+green+blue;
		System.out.println(sum);
	}
}

import java.util.Scanner;

public class JavaApplication158 {

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

        int x = sc.nextInt(); int y = sc.nextInt();
        int sum= 0; int curr;
        curr = x*2;
        sum += (curr + y - 1) / y;
        curr = x*5;
        sum += (curr + y - 1) / y;
        curr = x*8;
        sum += (curr + y - 1) / y;
        System.out.println(sum);

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.List;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) {
        try {
            List<Double> val = Arrays.stream(new BufferedReader(new InputStreamReader(System.in)).readLine().split(" ")).map(Double::parseDouble).collect(Collectors.toList());
            double n = val.get(0);
            double k = val.get(1);
            long red = 2;
            long green = 5;
            long blue = 8;
            int totalRed = 0;
            int totalGreen = 0;
            int totalBlue = 0;
            if (validateRange(n) && validateRange(k)) {
                totalRed = (int) Math.ceil((n * red) / k);
                totalBlue = (int) Math.ceil((n * blue) / k);
                totalGreen = (int) Math.ceil((n * green) / k);
            }

            System.out.println(totalRed + totalBlue + totalGreen);
        } catch (InputMismatchException e) {
            System.out.println(e.getCause().toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static boolean validateRange(double range) {
        return 1 <= range && range <= Math.pow(10, 8);
    }
}

import java.util.Scanner;

public class PetyaAndOrigami {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int k = sc.nextInt();
		double red = Math.ceil((double)(n*2)/k);
//		System.out.println(red);
		double green = Math.ceil((double)(n*5)/k);
		double blue = Math.ceil((double)(n*8)/k);
		int sum = (int) (red+green+blue);
		System.out.println(sum);

	}

}

import java.text.DecimalFormat;
import java.util.Scanner;

public class test {
    static final double RED = 2;
    static final double GREEN = 5;
    static final double BLUE = 8;
    static long n, k;
    private static DecimalFormat df2 = new DecimalFormat(".######");

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

        System.out.println(howManySheets(RED) + howManySheets(GREEN) + howManySheets(BLUE));

    }

    private static long howManySheets(double color) {

        return (long) Math.ceil(color * n / k);
    }
}

import java.util.*;
public class Main
{
	public static void main(String[] args) {
		int a=2,
    b=5,
    c=8,
    cont=0;

    Scanner in =new Scanner(System.in);

    int n,k,com;

    n=in.nextInt();
    k=in.nextInt();

    a*=n;
    b*=n;
    c*=n;

    com=0;
    while(com<a)
    {
        com+=k;
        cont++;
    }

    com=0;
    while(com<b)
    {
        com+=k;
        cont++;
    }

    com=0;
    while(com<c)
    {
        com+=k;
        cont++;
    }

    System.out.print(cont);

	}
}

import java.util.*;

public class Solution{
    static Scanner scan = new Scanner(System.in);

    public static void main(String args[]){
        long n = scan.nextLong();
        long k = scan.nextLong();

        long red = (n*2) % k == 0 ? (n*2)/k : (n*2)/k + 1;
        long green = (n*5) % k == 0 ? (n*5)/k : (n*5)/k + 1;
        long blue = (n*8) % k == 0 ? (n*8)/k : (n*8)/k + 1;

        System.out.println(red+green+blue);
    }

}

import java.util.Scanner;
import java.lang.*;
public class Main {
    public static void main(String arg[]) {
        Scanner sc = new Scanner(System.in);

        long n,k;
        n = sc.nextLong();
        k = sc.nextLong();
        long sum=0;
        long red,green,blue;
        red=n*2;
        green=n*5;
        blue=n*8;
        sum=(red+k-1)/k+(green+k-1)/k+(blue+k-1)/k;
    System.out.println(sum);
        }
}

import java.util.Scanner;

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

        float n = reader.nextInt();
        float k = reader.nextInt();

        reader.close();

        System.out.print((int) (Math.ceil(n * 2 / k) + Math.ceil(n * 5 / k) + Math.ceil(n * 8 / k)));
    }
}

import java.util.*;
import java.lang.Math;
public class codechhef {

	public static void main(String[] args) {
		Scanner sh = new Scanner(System.in);
		int n,k;
		double red=2,green=5,blue=8;
		n=sh.nextInt();
		k=sh.nextInt();
		red=(red*n)/k;
		green=(green*n)/k;
		blue=(blue*n)/k;
		System.out.println(Math.ceil(red)+Math.ceil(green)+Math.ceil(blue));

	}

}

import java.util.Scanner;

public class petyaAndOrgami {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        int min = n * 15;
        int i = 0;
        if (n == 1 && k == 1) {
            System.out.println(15);
        }
        else if(k==1){
            System.out.println(15*n);
        }
    else {
            while (k * i <= min) {
                i++;
            }
            System.out.println(i);
        }
    }
}

import java.util.Scanner;

public class petyaAndOrgami {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        int min = n * 15;
        int i = 0;
        if (n == 1 && k == 1) {
            System.out.println(15);
        } else {
            while (k * i <= min) {
                i++;
            }
            System.out.println(i);
        }
    }
}

import java.util.Scanner;

public class petyaAndOrgami {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int k=sc.nextInt();
        int min=n*15;
        int i=0;
        while(k*i<=min){
            i++;
        }
        System.out.println(i);
    }
}

import java.util.Scanner;

public class PetyaAndOrigami {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int nFriends = sc.nextInt();
		int nSheets = sc.nextInt();

		int red = 2;
		int green = 5;
		int blue = 8;

		red = red * nFriends;
		green = green * nFriends;
		blue = blue * nFriends;

		red = (int) Math.ceil(red/nSheets);
		green = (int)Math.ceil(green/nSheets);
		blue = (int)Math.ceil(blue/nSheets);

		System.out.println(red + green + blue);
	}

}

import java.util.Scanner;

public class PetyaAndOrigami {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		double nFriends = sc.nextDouble();
		double nSheets = sc.nextDouble();

		double red = 2;
		double green = 5;
		double blue = 8;

		red = red * nFriends;
		green = green * nFriends;
		blue = blue * nFriends;

		red = Math.ceil(red/nSheets);
		green = Math.ceil(green/nSheets);
		blue = Math.ceil(blue/nSheets);

		System.out.println((red + blue + green));
	}

}

import java.util.*;
public class PetyaAndOrigami {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt(), b = sc.nextInt();
		int x = a*2, y = a*5, z = a*8;

		int x1 = 0;
		int y1 = 0;
		int z1 =0;
		if(x%5 == 0)
			x1= x/5;
		else
			x1 = x/5 +1;
		if(y%5 == 0)
			y1= y/5;
		else
			y1 = y/5 +1;
		if(z%5 == 0)
			z1= z/5;
		else
			z1 = z/5 +1;
	int sum = x1 + y1 + z1;
	System.out.println(sum);

	}

}

import java.util.Scanner;

public class aseel {
public static void main (String args []) {
	Scanner in = new Scanner(System.in);
int   x ,y ,c=0;
	x=in.nextInt();
	y=in.nextInt();
if ((x*15)%y==0){
System.out.println(((x*15)/y));
}else {
System.out.println(((x*15)/y)+1);
}
}
}

import java.util.Scanner;

public class aseel {
public static void main (String args []) {
	Scanner in = new Scanner(System.in);
int   x ,y ,c=0;
	x=in.nextInt();
	y=in.nextInt();
	if (x*2<=y) {
		c+=1;
	}else {
	c+=(((x*2)%y ) +1);
	}
	if (x*5<=y) {
		c+=1;

	}else {
		c+=(((x*5)%y ) +1);
	}
	if (x*8<=y) {
		c+=1;
	}else {
		c+=(((x*8)%y ) +1);
	}
	System.out.println(c);
}
}

import java.util.Scanner;

public class aseel {
public static void main (String args []) {
	Scanner in = new Scanner(System.in);
int   x ,y ,c=0;
	x=in.nextInt();
	y=in.nextInt();
	if (x*2<=y) {
		c+=1;
	}else {
	c+=(((x*2)/y ) +1);
	}
	if (x*5<=y) {
		c+=1;

	}else {
		c+=(((x*5)/y ) +1);
	}
	if (x*8<=y) {
		c+=1;
	}else {
		c+=(((x*8)/y ) +1);
	}
	System.out.println(c);
}
}

import java.util.Scanner;

public class aseel {
public static void main (String args []) {
	Scanner in = new Scanner(System.in);
int   x ,y ,c=0;
	x=in.nextInt();
	y=in.nextInt();
System.out.println(((x*15)/y)+1);
}
}

import java.util.*;

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

        int numberOfFriends = input.nextInt();

        int numberOfEachSheets = input.nextInt();

        double redCounter = numberOfFriends * 2;

        redCounter = Math.floor( redCounter / numberOfEachSheets );

        double greenCounter = numberOfFriends * 5;

        greenCounter = Math.floor( greenCounter / numberOfEachSheets );

        double blueCounter = numberOfFriends * 8;

        blueCounter = Math.floor( blueCounter / numberOfEachSheets );

        System.out.println( (int) ( redCounter + greenCounter + blueCounter ) );
    }
}

import java.util.Scanner;
public class P1080A
{
	public static void main(String[] args)
	{
	 Scanner scan=new Scanner(System.in);
	 int n,r1,b1,g1,sum,g2,r2,b2;
	 float r,g,b;
	 int k;
	 n=scan.nextInt();
	 k=scan.nextInt();
	 int red,green,blue;
	 red=n*2;	green=n*5;	blue=n*8;
	 r=red/k;
	 g=green/k;
	 b=blue/k;
	 r1=(int)r;
	 g1=(int)g;
	 b1=(int)b;
	 r2=red%k;
	 g2=green%k;
	 b2=blue%k;
	 if(!(r2==0))
		++r1;
	 if(!(g2==0))
		++g1;
	 if(!(b2==0))
		++b1;
	 sum=r1+g1+b1;
	 System.out.println(sum);
	}
}

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

public class One{
	public static void main(String[] args){
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int k = in.nextInt();

		System.out.println((int)(Math.ceil(((float)n*2)/k) + Math.ceil(((float)n*5)/k) + Math.ceil(((float)n*8)/k)));
	}
}

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

/**
 * 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();
    }

    static class TaskA {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            out.println(1);
        }

    }
}

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

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

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
Scanner sc=new Scanner(System.in);
float n=sc.nextFloat();
float k=sc.nextFloat();
float c1=(n*2)/k;;
float c2=(n*5)/k;
float c3=(n*8)/k;
int sum=0;
int a1=(int)Math.ceil(c1);
int a2=(int)Math.ceil(c2);
int a3=(int)Math.ceil(c3);
//System.out.println(a1+" "+a2+" "+a3);
sum=a1+a2+a3;
System.out.println(sum);
	}
}

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

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Nicklauss
 */
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);
        APetyaAndOrigami solver = new APetyaAndOrigami();
        solver.solve(1, in, out);
        out.close();
    }

    static class APetyaAndOrigami {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            long n = in.nextInt();
            long k = in.nextInt();

            long sum = ((15 * n) / k);
            sum++;

            out.print(sum);
        }

    }
}

import java.util.*;

public class Codeforces{

	public static void main(String args[]){
		Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int k = in.nextInt();
        System.out.println(((15*n)/k)+ 1);
	}

}

import java.util.Scanner;
public class Main
{
	public static void main(String[] args) {
		Scanner newScanner = new Scanner(System.in);
		int n = newScanner.nextInt();
		int k = newScanner.nextInt();
		newScanner.close();
		int a = 0;
		if ((n * 8) % k == 0)
		    a += (n * 8) / k + (n * 2) / k;
		else{
		    if ((n * 2) % k == 0)
		        a += (n * 8) / k + (n * 2) / k + 1;
		    else
		        a += (n * 8) / k + (n * 2) / k + 2;
		}
		if ((n * 5) % k == 0)
		    a += (n * 5) / k;
		else
		    a += (n * 5) / k + 1;
		System.out.println(a);

	}
}

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 Twinkle Twinkle Little Star
 */
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);
        APetyaAndOrigami solver = new APetyaAndOrigami();
        solver.solve(1, in, out);
        out.close();
    }

    static class APetyaAndOrigami {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int no_of_friends = in.nextInt();
            int sheets = in.nextInt();
            int red_sheets = 2 * no_of_friends;
            int green_sheets = 5 * no_of_friends;
            int blue_sheets = 8 * no_of_friends;
            int Needed_sheets = 15 * no_of_friends;
            if (no_of_friends == 1 && sheets != 1) {
                out.println(3);

            } else if (sheets == 1)
                out.println(no_of_friends * 15);
            else if (sheets == 1 && no_of_friends == 1)
                out.println(15);
            else {
                out.println((Needed_sheets / sheets) + 1);
            }

        }

    }

    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());
        }

    }
}

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

public class APetyaAndOrigami {

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

    }
static class Twinkle {
        public void star(int testNumber, InputReader in, PrintWriter out) {
            long n = in.nextLong();// 15
            long k = in.nextLong();// 6
            long red = n*2;// 30
            long green = n*5;// 75
            long blue = n*8;//120
            long sum =0;
            for (int i = 1; i <=n*k*k*n ; i++) {
                long diff= red-(k*i);//
                if(diff<=0)
                {
                    sum+=i;
                    break;
                }

            }
          //  System.out.println(sum);
            //int bum=0;
            for (int i = 1; i <=k*k*n*n ; i++) {
                long diff= green-(k*i);
                if(diff<=0)
                {
                    sum+=i;
                    break;
                }

            }
            for (int i = 1; i <=k*k*n*n ; i++) {
                long diff= blue-(k*i);
                if(diff<=0)
                {
                    sum+=i;
                    break;
                }

            }
            System.out.println(sum);

        }
}

    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   String nextLine()
        {
            String str = "";
            try
            {
                str = reader.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }

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

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

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

        public boolean hasNext() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    String line = reader.readLine();
                    if (line == null) {
                        return false;
                    }
                    tokenizer = new StringTokenizer(line);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return true;
        }
    }
}

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

public class APetyaAndOrigami {

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

    }
static class Twinkle {
        public void star(int testNumber, InputReader in, PrintWriter out) {
            long n = in.nextLong();// 15
            long k = in.nextLong();// 6
            if(n%2!=0 && k%2==0)
                System.out.println(n+k+15+2);
            else
                System.out.println(n+k+2);
            /*long red = n*2;// 30
            long green = n*5;// 75
            long blue = n*8;//120
            long sum =0;
            for (int i = 1; i <=n*k*k*n ; i++) {
                long diff= red-(k*i);//
                if(diff<=0)
                {
                    sum+=i;
                    break;
                }

            }
          //  System.out.println(sum);
            //int bum=0;
            for (int i = 1; i <=k*k*n*n ; i++) {
                long diff= green-(k*i);
                if(diff<=0)
                {
                    sum+=i;
                    break;
                }

            }
            for (int i = 1; i <=k*k*n*n ; i++) {
                long diff= blue-(k*i);
                if(diff<=0)
                {
                    sum+=i;
                    break;
                }

            }*/
            //System.out.println(sum);

        }
}

    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   String nextLine()
        {
            String str = "";
            try
            {
                str = reader.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }

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

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

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

        public boolean hasNext() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    String line = reader.readLine();
                    if (line == null) {
                        return false;
                    }
                    tokenizer = new StringTokenizer(line);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return true;
        }
    }
}

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 Twinkle Twinkle Little Star
 */
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);
        APetyaAndOrigami solver = new APetyaAndOrigami();
        solver.solve(1, in, out);
        out.close();
    }

    static class APetyaAndOrigami {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int no_of_friends = in.nextInt();
            int sheets = in.nextInt();
            int sheets_needed = (no_of_friends * 15);
            if (no_of_friends == 1 || sheets == 1)
                out.println(15 * no_of_friends);
            else
                out.println((sheets_needed / sheets) + 1);
        }

    }

    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());
        }

    }
}

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

public class APetyaAndOrigami {

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

    }
static class Twinkle {
        public void star(int testNumber, InputReader in, PrintWriter out) {
            long n = in.nextLong();// 15
            long k = in.nextLong();// 6
            long red = n*2;// 30
            long green = n*5;// 75
            long blue = n*8;//120
            long sum =0;
            for (int i = 1; i <=k*k ; i++) {
                long diff= red-(k*i);//
                if(diff<=0)
                {
                    sum+=i;
                    break;
                }

            }
          //  System.out.println(sum);
            //int bum=0;
            for (int i = 1; i <=k*k ; i++) {
                long diff= green-(k*i);
                if(diff<=0)
                {
                    sum+=i;
                    break;
                }

            }
            for (int i = 1; i <=k*k ; i++) {
                long diff= blue-(k*i);
                if(diff<=0)
                {
                    sum+=i;
                    break;
                }

            }
            System.out.println(sum);

        }
}

    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   String nextLine()
        {
            String str = "";
            try
            {
                str = reader.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }

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

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

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

        public boolean hasNext() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    String line = reader.readLine();
                    if (line == null) {
                        return false;
                    }
                    tokenizer = new StringTokenizer(line);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return true;
        }
    }
}

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 Twinkle Twinkle Little Star
 */
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);
        APetyaAndOrigami solver = new APetyaAndOrigami();
        solver.solve(1, in, out);
        out.close();
    }

    static class APetyaAndOrigami {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int no_of_friends = in.nextInt();
            int sheets = in.nextInt();
            int sheets_needed = (no_of_friends * 15);
            if (no_of_friends == 1)
                out.println(15);
            else
                out.println((sheets_needed / sheets) + 1);
        }

    }

    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());
        }

    }
}

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int k = sc.nextInt();
		sc.close();
		int ans = (int)Math.floor(n * 15.0 / k + 1);
		System.out.println(ans);

	}

}

import java.lang.Math;
import java.util.Scanner;

public class HelloWorld
{
  public static void main(String[] args)
  {
	Scanner in = new Scanner(System.in);
    int n = in.nextInt();
    int k = in.nextInt();

    double c = Math.ceil(n*2.0/k) + Math.ceil(n*5.0/k) + Math.ceil(n*8.0/k);
    System.out.println(c);
  }
}

import java.lang.*;
import java.util.*;
public class A
{
    public static void main(String args[])
    {
        Scanner sc = new Scanner(System.in);
        int n=sc.nextInt();
        int k=sc.nextInt();
        int r=2,g=5,b=8;
        int r1,g1,b1;
        if((r*n)/k == 0)
        {
           r1=(r*n)/k;
        }
        else
        {
            r1=((r*n)/k) + 1;
        }

         if((g*n)/k == 0)
        {
           g1=(g*n)/k;
        }
        else
        {
            g1=((g*n)/k) + 1;
        }

         if((b*n)/k == 0)
        {
           b1=(b*n)/k;
        }
        else
        {
            b1=((b*n)/k) + 1;
        }

        System.out.println(r1+g1+b1);

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.List;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) {
        try {
            List<Double> val = Arrays.stream(new BufferedReader(new InputStreamReader(System.in)).readLine().split(" ")).map(Double::parseDouble).collect(Collectors.toList());
            double n = val.get(0);
            double k = val.get(1);
            long red = 2;
            long green = 5;
            long blue = 8;
            double totalRed = 0;
            double totalGreen = 0;
            double totalBlue = 0;
            if (validateRange(n) && validateRange(k)) {
                totalRed = (n*red)/k;
                totalBlue = (n*blue)/k;
                totalGreen = (n*green)/k;
            }

            System.out.println(Math.round(totalRed) + Math.round(totalGreen) + Math.round(totalBlue));
        } catch (InputMismatchException e) {
            System.out.println(e.getCause().toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static boolean validateRange(double range) {
        return 1 <= range && range <= Math.pow(10, 8);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.List;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) {
        try {
            List<Long> val = Arrays.stream(new BufferedReader(new InputStreamReader(System.in)).readLine().split(" ")).map(Long::parseLong).collect(Collectors.toList());
            long n = val.get(0);
            long k = val.get(1);
            long red = 2;
            long green = 5;
            long blue = 8;
            long totalRed = 0;
            long totalGreen = 0;
            long totalBlue = 0;
            if (validateRange(n) && validateRange(k)) {
                while ((n * red) < totalRed) {
                    totalRed += red;
                }
                while ((n * green) < totalGreen) {
                    totalGreen += green;
                }
                while ((n * blue) < totalBlue) {
                    totalBlue += blue;
                }
            }

            System.out.println(totalRed + totalGreen + totalBlue);
        } catch (InputMismatchException e) {
            System.out.println(e.getCause().toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static boolean validateRange(long range) {
        return 1 <= range && range <= Math.pow(10, 8);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.List;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) {
        try {
            List<Double> val = Arrays.stream(new BufferedReader(new InputStreamReader(System.in)).readLine().split(" ")).map(Double::parseDouble).collect(Collectors.toList());
            double n = val.get(0);
            double k = val.get(1);
            long red = 2;
            long green = 5;
            long blue = 8;
            double totalRed = 0;
            double totalGreen = 0;
            double totalBlue = 0;
            if (validateRange(n) && validateRange(k)) {
                totalRed = Math.ceil((n * red) / k);
                totalBlue = Math.ceil((n * blue) / k);
                totalGreen = Math.ceil((n * green) / k);
            }

            System.out.println(totalRed + totalBlue + totalGreen);
        } catch (InputMismatchException e) {
            System.out.println(e.getCause().toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static boolean validateRange(double range) {
        return 1 <= range && range <= Math.pow(10, 8);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.List;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) {
        try {
            List<Long> val = Arrays.stream(new BufferedReader(new InputStreamReader(System.in)).readLine().split(" ")).map(Long::parseLong).collect(Collectors.toList());
            long n = val.get(0);
            long k = val.get(1);
            long red = 2;
            long green = 5;
            long blue = 8;
            long totalRed = 0;
            long totalGreen = 0;
            long totalBlue = 0;
            if (validateRange(n) && validateRange(k)) {
                while ((n * red) > totalRed) {
                    totalRed += red;
                }
                while ((n * green) > totalGreen) {
                    totalGreen += green;
                }
                while ((n * blue) > totalBlue) {
                    totalBlue += blue;
                }
            }

            System.out.println(totalRed + totalGreen + totalBlue);
        } catch (InputMismatchException e) {
            System.out.println(e.getCause().toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static boolean validateRange(long range) {
        return 1 <= range && range <= Math.pow(10, 8);
    }
}

import java.util.Scanner;
    import java.util.*;
    import java.lang.Math;
    public class Main {

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

                System.out.println(Math.ceil((double) 2 * n / k) + Math.ceil((double) 5 * n / k) + Math.ceil((double) 8 * n / k));

        }
    }

import java.util.*;
public class Main{
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int k=scan.nextInt();
        double red=n*2;
        double green=n*5;
        double blue=n*8;
        System.out.println(Math.ceil(red/k)+Math.ceil(green/k)+Math.ceil(blue/k));

    }
}

import java.util.Scanner;

public class PetyaOrigami {

    public static void main(String[] args) {
        System.out.println(new PetyaOrigami().solve(new Scanner(System.in).nextLine()));
    }

    long solve(String input) {
        String[] split = input.split(" ");
        long friends = Long.parseLong(split[0]);
        long notebookSheets = Long.parseLong(split[1]);
        int redSheets = 2;
        int greenSheets = 5;
        int blueSheets = 8;
        long requiredSheets = friends * (blueSheets + redSheets + greenSheets);
        return requiredSheets / notebookSheets + 1;
    }
}

import java.util.Arrays;
import java.util.Scanner;

public class CF43A {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n1 = scanner.nextInt();
        int n2 = scanner.nextInt();

        int answer = (int) (Math.ceil(2.0*n1/n2) + Math.ceil(5.0*n1/n2) + Math.ceil(8*n1/n2));
        System.out.println(answer);
    }
}

import  java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.util.*;
import java.math.*;
import java.io.*;
import java.text.*;

public class hacker
{

    /*Fatt Gyi Bhai*/
    //Dekh le mera code
    public static boolean[] sieve(long n)
    {
        boolean[] prime = new boolean[(int)n+1];
        Arrays.fill(prime,true);
        prime[0] = false;
        prime[1] = false;
        long m = (long)Math.sqrt(n);
        for(int i=2;i<=m;i++)
        {
            if(prime[i])
            {
                for(int k=i*i;k<=n;k+=i)
                {
                    prime[k] = false;
                }
            }
        }
        return prime;
    }

    static long GCD(long a,long b)
    {
        if(a==0 || b==0)
        {
            return 0;
        }
        if(a==b)
        {
            return a;
        }
        if(a>b)
        {
            return GCD(a-b,b);
        }
        return GCD(a,b-a);
    }

    static long CountCoPrimes(long n)
    {
        long res = n;
        for(int i=2;i*i<=n;i++)
        {
            if(n%i==0)
            {
                while(n%i==0)
                {
                    n/=i;
                }
                res-=res/i;
            }
        }
        if(n>1)
        {
            res-=res/n;
        }
        return res;
    }

    //fastest way to find x**n
    static long modularExponentiation(long x,long n,long m)
    {
        long res = 1;
        while(n>0)
        {
            if(n%2==1)
            {
                res = (res*x)%m;
            }
            x =(x*x)%m;
            n/=2;
        }
        return res;
    }

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

    static int pow(int a,int b)
    {
        int res = 1;
        while(b>0)
        {
            if((b&1)==1)
            {
                res *= a;
            }

            b >>= 1;
            a *=a;
        }
        return res;
    }

   static long modInverse(long A,long M)
   {
    return modularExponentiation(A,M-2,M);
   }

    static void reverse(char[] a,int start,int end)
    {

        while(start<end)
        {
            char temp = a[start];
            a[start] = a[end];
            a[end] = temp;
            start++;
            end--;
        }

    }

    static boolean prime(int n)
    {
        for(int i=2;i*i<=n;i++)
        {
            if(i%2==0 ||i%3==0)
            {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) throws IOException
    {
      // = new PrintWriter("explicit.out");
        new hacker().run();

    }

    static int rev(int n)
    {
        int x=0;
        int num = 0;
        while(n>0)
        {
            x = n%10;
            num = num*10+x;
            n/=10;

        }
        return num;
    }

// Firse author  ka solution

   // static long N;
   static Scanner in = new Scanner(System.in);
    static void run() throws IOException
    {
        long n = nl();
        long k = nl();
        System.out.print((2*n+8*n+5*n)/k+1);

    }

    static void printL(long a)
    {
        System.out.println(a);
    }
    static void printS(String s)
    {
        System.out.println(s);
    }

    static void swap(char c,char p)
    {
        char t = c;
        c = p;
        p = t;
    }

    static long max(long n,long m)
    {
        return Math.max(n,m);
    }
    static long min(long n,long m)
    {
        return Math.min(n,m);
    }

    static double nd() throws IOException
    {
        return Double.parseDouble(in.next());
    }
    static int ni() throws IOException
    {
        return Integer.parseInt(in.next());
    }

    static long nl() throws IOException
    {
        return Long.parseLong(in.next());
    }

    static String si() throws IOException
    {
        return in.next();
    }

    static int abs(int n)
    {
        return Math.abs(n);
    }

    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();}

    }

}

class Pair implements Comparable<Pair>
{
    int value;
    int index;
    public Pair(int v,int i)
    {
        value = v;
        index = i;
    }

    public int compareTo(Pair a)
    {
        return this.value-a.value;
    }

}

import java.util.*;

public class P1080A {
    public static void main(String [] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int k = in.nextInt();
        int max_num_of_blue_sheets = 8 * n;
        int max_num_of_green_sheets = 5 * n;
        int max_num_of_red_sheets = 2 * n;

        int num_of_books = max_num_of_blue_sheets / k;
        if (max_num_of_blue_sheets % k != 0)
            num_of_books++;

        num_of_books = max_num_of_green_sheets / k;
        if (max_num_of_green_sheets % k != 0)
            num_of_books++;

        num_of_books += max_num_of_red_sheets / k;
        if (max_num_of_red_sheets % k != 0)
            num_of_books++;

        System.out.println(num_of_books);
        in.close();
    }
}

import java.util.*;
public class petyaOrigami {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        long n = sc.nextInt();
        long k = sc.nextInt();
        long res = (long)Math.ceil((float)(n*2)/k)+(long)Math.ceil((float)(n*5)/k)+(long)Math.ceil((float)(n*8)/k);
        System.out.print(res);
    }
}

import java.util.Scanner;

public class test {
	static int a,b,c;
public static int min(int n,int k) {

		if(n>=1 && k<=100000000){
		a=(n*2)/k;
		b=(n*5)/k;
		c=(n*8)/k;
		if(0<(n*2)%k&&(n*2)%k<=2){
			a+=1;

		}
		if(0<(n*5)%k&&(n*5)%k<=5){
			b+=1;

		}
		if(0<(n*8)%k&&(n*8)%k<=8){
			c+=1;

		}
		}
		return a+b+c;

	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner s=new Scanner(System.in);
		int n=s.nextInt();
		int k=s.nextInt();
		System.out.println(min(n, k));

	}

}

import java.util.Scanner;

public class test {
	static int a,b,c;
public static int min(int n,int k) {

		if(n>=1 && k<=Math.pow(10, 8)){
		a=(n*2)/k;
		b=(n*5)/k;
		c=(n*8)/k;
		if(0<(n*2)%k&&(n*2)%k<2){
			a+=1;

		}
		if(0<(n*5)%k&&(n*5)%k<5){
			b+=1;

		}
		if(0<(n*8)%k&&(n*8)%k<8){
			c+=1;

		}
		}
		return a+b+c;

	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner s=new Scanner(System.in);
		int n=s.nextInt();
		int k=s.nextInt();
		System.out.println(min(n, k));

	}

}

import java.util.Scanner;

public class PetyaAndOrigami {

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

        int n = input.nextInt() , k = input.nextInt();
        int red = n*2 , green = n*5 , blue = n*8;
        int rn = 0 , gn = 0 , bn = 0;

        while(red >= k){
            red -= k;
            rn++;
            if(red < k && red != 0)
                rn++;
        }
        while(green >= k){
            green -= k;
            gn++;
            if(green < k && green != 0)
                gn++;
        }
        while(blue >= k){
            blue -= k;
            bn++;
            if(blue < k && blue != 0)
                bn++;
        }
        System.out.println(rn + gn + bn);
    }
}

import java.util.Scanner;

public class PetyaAndOrigami {
	public static void main(String[] args) {

		Scanner in = new Scanner(System.in);
		double n = in.nextInt(), k = in.nextInt();

		System.out.println(Math.ceil(2 * n / k) + Math.ceil(5 * n / k) + Math.ceil(8 * n / k));
		in.close();
	}
}

import java.util.Scanner;
public class A1080{
    public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    int n = scan.nextInt();
    int k = scan.nextInt();
    int red = 2*n; // how many red sheets needed
    int blue = 8 * n; // how many blue sheets needed
    int green = 5 * n; // how many green sheets needed
    double r = Math.ceil(red/k); //
    double g = Math.ceil(green/k);
    double b = Math.ceil(blue/k);

    System.out.println(r + g + b);

    }
}

import java.util.Scanner;
public class A1080{
    public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    int n = scan.nextInt();
    int k = scan.nextInt();
    int red = 2*n;
    int blue = 8 * n;
    int green = 5 * n;
    double r = red/k;
    double g = green/n;
    double b = blue/n;
    double one = (int)(Math.ceil(r));
    double two = (int)(Math.ceil(g));
    double three = (int)(Math.ceil(b));
    System.out.println(one + two + three);

    }
}

import java.util.Scanner;
public class A1080{
    public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    int n = scan.nextInt();
    int k = scan.nextInt();
    int red = 2*n; // how many red sheets needed
    int blue = 8 * n; // how many blue sheets needed
    int green = 5 * n; // how many green sheets needed
    double r = Math.ceil(red/k); //
    double g = Math.ceil(green/k);
    double b = Math.ceil(blue/k);

    System.out.println((int)(r) + (int)(g) + (int)(b));

    }
}

import java.util.Scanner;
public class A1080{
    public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    int n = scan.nextInt();
    int k = scan.nextInt();
    int red = 2*n; // how many red sheets needed
    int blue = 8 * n; // how many blue sheets needed
    int green = 5 * n; // how many green sheets needed
    double r = Math.ceil(red/k); //
    double g = Math.ceil(green/n);
    double b = Math.ceil(blue/n);

    System.out.println(r + g + b);

    }
}

import java.util.Scanner;
public class A1080{
    public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    int n = scan.nextInt();
    int k = scan.nextInt();

    double na = (double)(k);
    int red = 2*n; // how many red sheets needed
    int blue = 8 * n; // how many blue sheets needed
    int green = 5 * n; // how many green sheets needed

    double r = Math.ceil(red/k); //
    double g = Math.ceil(green/k);
    double b = Math.ceil(blue/k);

    System.out.println(r + g + b);

    }
}

import java.util.Scanner;
public class A1080{
    public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    int n = scan.nextInt();
    int k = scan.nextInt();

    double na = (double)(k);
    int red = 2*n; // how many red sheets needed
    int blue = 8 * n; // how many blue sheets needed
    int green = 5 * n; // how many green sheets needed
    double r = red/k;
    double g = green/k;
    double b = blue/k;

  //  double r = Math.ceil(red/k); //
//    double g = Math.ceil(green/k);
 //   double b = Math.ceil(blue/k);

    System.out.println(r + g + b);

    }
}

import java.util.Scanner;
public class A1080{
    public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    int n = scan.nextInt();
    int k = scan.nextInt();
    int red = 2*n;
    int blue = 8 * n;
    int green = 5 * n;
    double r = red/k;
    double g = green/n;
    double b = blue/n;
    System.out.println(Math.ceil(r));
   // int output  = (int)(Math.ceil(r) + Math.ceil(g) + Math.ceil(b));
    //System.out.println(output);

    }
}

import java.util.Scanner;
public class test20{
    public static int testCase20(int n,int k) {

        return 15*n/k+1;
    }
    public static void main(String[] args) {
       Scanner input = new Scanner(System.in);
         int n= input.nextInt();
         int k = input.nextInt();
          System.out.println(testCase20(n,k));
        }
}

import java.util.Scanner;
public class test20{
    public static int testCase20(int n,int k) {
        return 8*n/k+5*n/k+2*n/k+2*n%k;
    }
    public static void main(String[] args) {
        int i=0;
       Scanner input = new Scanner(System.in);
         int n= input.nextInt();
         int k = input.nextInt();
          System.out.println(testCase20(n,k));
    }
}

import java.util.Scanner;
public class test20{
    public static int testCase20(int n,int k) {
        return 15*n/k;
    }
    public static void main(String[] args) {
        int i=0;
       Scanner input = new Scanner(System.in);
         int n= input.nextInt();
         int k = input.nextInt();
         if((2*n)%k!=0)
             i++;
         if((5*n)%k!=0)
             i++;
         if((8*n)%k!=0)
             i++;
          System.out.println(i+testCase20(n,k));
    }
}

import java.util.Scanner;

public class Main
{
    static final float RED = 2;
    static final float GREEN = 5;
    static final float BLUE = 8;

	public static void main(String[] args) {
	    Scanner scanner = new Scanner(System.in);
	    long n = scanner.nextInt();
	    long k = scanner.nextInt();

	    System.out.println(howManySheets(n, k, RED) + howManySheets(n, k, GREEN) + howManySheets(n, k, BLUE));

	}

    private static int howManySheets(long n, long k, float color){

        return (int)Math.ceil(color * n / k);
    }
}

import java.util.Scanner;

public class Main
{
    static final float RED = 2;
    static final float GREEN = 5;
    static final float BLUE = 8;

	public static void main(String[] args) {
	    Scanner scanner = new Scanner(System.in);
	    int n = scanner.nextInt();
	    int k = scanner.nextInt();

	    System.out.println(howManySheets(n, k, RED) + howManySheets(n, k, GREEN) + howManySheets(n, k, BLUE));

	}

    private static int howManySheets(int n, int k, float color){

        return (int)Math.ceil(color * n / k);
    }
}

import java.util.Scanner;

public class Main
{
    static final float RED = 2;
    static final float GREEN = 5;
    static final float BLUE = 8;

	public static void main(String[] args) {
	    Scanner scanner = new Scanner(System.in);
	    long n = scanner.nextInt();
	    long k = scanner.nextInt();

	    System.out.println(howManySheets(n, k, RED) + howManySheets(n, k, GREEN) + howManySheets(n, k, BLUE));

	}

    private static long howManySheets(long n, long k, float color){

        return (long)Math.ceil(color * n / k);
    }
}

import java.io.*;

public class Solution{

    public static void main(String args[])throws IOException{
        InputStreamReader r = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(r);
        int n,k;
        String in[] = new String[2];
        in = br.readLine().split(" ");
        n = Integer.parseInt(in[0]);
        k = Integer.parseInt(in[1]);
        float red,blue,green;
        red = 2*n;
        blue = 5*n;
        green = 8*n;
        int count = 0;
        count+=(int)red/k;
        count+=(int)blue/k;
        count+=(int)green/k;

        if((int)red/k!=red/k){
            count+=1;}
        if((int)blue/k!=blue/k){
                count+=1;}
        if((int)green/k!=green/k){
            count+=1;}

        System.out.println(count);
    }

}

import java.util.*;
import java.io.*;
public class a{
    static long f(long n,long k){
        return (long)Math.ceil((float)n/k);
    }
    static Scanner sc=new Scanner(System.in);
    public static void main(String [] args){
     long n=sc.nextLong();
     long k=sc.nextLong();

     long r=2*n;
     long g=5*n;
     long b=8*n;

     long ans=f(r,k)+f(g,k)+f(b,k);
     System.out.println(ans);

    }
}

import java.util.Scanner;

public class Problem_1080_A {

    public static void main(String[] args) {
        Scanner Input = new Scanner(System.in);
        int Friend = Input.nextInt();
        int Sheets = Input.nextInt();

        int R = Friend * 2, G = Friend * 5, B = Friend * 8;
        int Save = R+G+B;
        int NoteCount = 0;

        while (Save >0) {
            Save -= Sheets;
            NoteCount++;
        }
        System.out.println(NoteCount);
//        int Num = Input.nextInt();
//        for (int I = 0; I < Num; I++) {
//            int L = Input.nextInt();
//            int R = Input.nextInt();
//            System.out.println(UnRecursive(L, R));
    }

}

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

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

        int n = sc.nextInt(), k = sc.nextInt();

        int p1 = (int)Math.ceil((double)k/(2*n));
        int p2 = (int)Math.ceil((double)k/(5*n));
        int p3 = (int)Math.ceil((double)k/(8*n));

        System.out.println(+(p1+p2+p3));
    }
}

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

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

/* 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 sc=new Scanner(System.in);
		long n=sc.nextLong();
		long k=sc.nextLong();
		long total=0;
		long x=(long )Math.ceil((n*2.0)/k );
		long y=(long )Math.ceil((n*5.0)/k );
		long z=(long )Math.ceil((n*8.0)/k );
		System.out.println(x+" "+y+" "+z);
		total=x+y+z;
		System.out.println(total);
	}
}

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

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

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner sc=new Scanner(System.in);
		long n=sc.nextLong();
		long k=sc.nextLong();
		long total=0;
		long x=(long )Math.ceil((n*2.0)/k );
		long y=(long )Math.ceil((n*5.0)/k );
		long z=(long )Math.ceil((n*8.0)/k );
		System.out.println(x+" "+y+" "+z);
		total=x+y+z;
		System.out.println(total);
	}
}

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

public class J1080A {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());

		int n = Integer.parseInt(st.nextToken());
		int k = Integer.parseInt(st.nextToken());

		int numRed, numGreen, numBlue;

		numRed = (int)Math.ceil(((float)n * 2) / k);
		numGreen = (int)Math.ceil(((float)n * 5) / k);
		numBlue = (int)Math.ceil(((float)n * 8) / k);

		System.out.println(numRed + numGreen + numBlue);
	}
}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        long r = n * 15;
        if (r % k == 0) {
            System.out.println(r / k + 1);
        }else{
            System.out.println((long)Math.ceil((double)r/(double)k));
        }
    }
}