Petya is having a party soon, and he has decided to invite his $$$n$$$ friends.He wants to make invitations in the form of origami. For each invitation, he needs two red sheets, five green sheets, and eight blue sheets. The store sells an infinite number of notebooks of each color, but each notebook consists of only one color with $$$k$$$ sheets. That is, each notebook contains $$$k$$$ sheets of either red, green, or blue.Find the minimum number of notebooks that Petya needs to buy to invite all $$$n$$$ of his friends.

The first line contains two integers $$$n$$$ and $$$k$$$ ($$$1\leq n, k\leq 10^8$$$) — the number of Petya's friends and the number of sheets in each notebook respectively.

Print one number — the minimum number of notebooks that Petya needs to buy.

NoteIn the first example, we need $$$2$$$ red notebooks, $$$3$$$ green notebooks, and $$$5$$$ blue notebooks.In the second example, we need $$$5$$$ red notebooks, $$$13$$$ green notebooks, and $$$20$$$ blue 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 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.*;
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.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.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.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.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.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.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 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.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.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.*;
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.*;
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;

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

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

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

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

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 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.*;
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.*;
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.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.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 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.*;

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

/* 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.*;
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.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.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.*;

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

// #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.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 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);

    }
}

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.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.*;
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;
		}
	}
}

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.*;
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
*/

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

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

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

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

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

}

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

	}

}

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

}

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