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

public class Main
{

    public static void solve(FastScanner in, BufferedWriter out) throws IOException
    {
        int n = in.nextInt(), a = in.nextInt(), b = in.nextInt();
        int answer = 0;

        int ac = 4, bc = 2;

        while(ac > 0 || bc > 0)
        {
            answer++;
            int xa = 0, yb = 0, minRemain = Integer.MAX_VALUE;
            for(int i = ac; i >=0; i-- )
            {
                for (int j = bc; j >= 0 ; j--) {
                    int r = n - i*a - j*b;
                    if(r >= 0 && r < minRemain)
                    {
                        minRemain = r;
                        xa = i;
                        yb = j;
                    }
                }
            }
            ac -= xa;
            bc -= yb;
        }

        out.append(String.valueOf(answer));
    }

    /**************** ENTER HERE   ********************/
    public static void main(String[] args) throws Exception
    {
        FastScanner fscan = new FastScanner(System.in);
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        solve(fscan,bw);
        bw.close();
    }
}

class FastScanner {
    StringTokenizer st;
    BufferedReader br;

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

    public void nextIntArray(int[] a) throws IOException
    {
        for(int i =0;i<a.length;i++)
            a[i] = nextInt();
    }

    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 class Main {
  static int a, b, n;
  private static void solve() {
    n = ni();
    a = ni();
    b = ni();

    int ret = dfs(0, 4, 2, 0, 0);
    System.out.println(ret);
  }

  private static int dfs(int depth, int lastA, int lastB, int lastLen, int count) {
    if (depth == 6) {
      return count;
    }

    int ret = Integer.MAX_VALUE;
    if (lastA > 0) {
      if (lastLen < a) {
        int now = dfs(depth + 1, lastA - 1, lastB, n - a, count + 1);
        ret = Math.min(ret, now);
      } else {
        int now = dfs(depth + 1, lastA - 1, lastB, lastLen - a, count);
        ret = Math.min(ret, now);
      }
    }
    if (lastB > 0) {
      if (lastLen < b) {
        int now = dfs(depth + 1, lastA, lastB - 1, n - b, count + 1);
        ret = Math.min(ret, now);
      } else {
        int now = dfs(depth + 1, lastA, lastB - 1, lastLen - b, count);
        ret = Math.min(ret, now);
      }
    }
    return ret;
  }

  public static void main(String[] args) {
    new Thread(null, new Runnable() {
      @Override
      public void run() {
        long start = System.currentTimeMillis();
        String debug = args.length > 0 ? args[0] : null;
        if (debug != null) {
          try {
            is = java.nio.file.Files.newInputStream(java.nio.file.Paths.get(debug));
          } catch (Exception e) {
            throw new RuntimeException(e);
          }
        }
        reader = new java.io.BufferedReader(new java.io.InputStreamReader(is), 32768);
        solve();
        out.flush();
        tr((System.currentTimeMillis() - start) + "ms");
      }
    }, "", 64000000).start();
  }

  private static java.io.InputStream is = System.in;
  private static java.io.PrintWriter out = new java.io.PrintWriter(System.out);
  private static java.util.StringTokenizer tokenizer = null;
  private static java.io.BufferedReader reader;

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

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

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

  private static int[] na(int n) {
    int[] a = new int[n];
    for (int i = 0; i < n; i++)
      a[i] = ni();
    return a;
  }

  private static char[] ns() {
    return next().toCharArray();
  }

  private static long[] nal(int n) {
    long[] a = new long[n];
    for (int i = 0; i < n; i++)
      a[i] = nl();
    return a;
  }

  private static int[][] ntable(int n, int m) {
    int[][] table = new int[n][m];
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        table[i][j] = ni();
      }
    }
    return table;
  }

  private static int[][] nlist(int n, int m) {
    int[][] table = new int[m][n];
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        table[j][i] = ni();
      }
    }
    return table;
  }

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

  private static void tr(Object... o) {
    if (is != System.in)
      System.out.println(java.util.Arrays.deepToString(o));
  }
}

import java.util.Scanner;

public class Door_Frames {
	public static void main(String[] args) {
		Scanner sc=new Scanner (System.in);
		int n=sc.nextInt();
		int a=sc.nextInt();
		int x=sc.nextInt();
		int b,c,d,y,k;
		b=c=d=a;y=x;k=6;
		boolean fa,fb,fc,fd,fx,fy,f;f=true;
		if((4*a+2*x)<=n) {
			System.out.println(1);return;
		}
		if((2*a+x)<=n) {
			System.out.println(2);return;
		}
		fa=fb=fc=fd=fx=fy=f;
		int r=n;
		if(a>x) {
			while(fa||fb||fc||fd||fx||fy) {
				if(fa) {
					if(r>=a){r-=a;fa=false;
							if(r>=x&&fx) {r-=x;fx=false;}
							if(r>=x&&fy) {r-=x;fy=false;}
					}
					else {r=n;k--;continue;}
				}
				if(!(fa||fb||fc||fd||fx||fy)) {k--;break;}
				if(fb) {
					if(r>=a){r-=a;fb=false;
						if(r>=x&&fx) {r-=x;fx=false;}
						if(r>=x&&fy) {r-=x;fy=false;}
						}
					else {r=n;k--;continue;}
				}
				if(!(fa||fb||fc||fd||fx||fy)) {k--;break;}
				if(fc)
					{if(r>=a){r-=a;fc=false;
						if(r>=x&&fx) {r-=x;fx=false;}
						if(r>=x&&fy) {r-=x;fy=false;}
					}
					else {r=n;k--;continue;}
				}
				if(!(fa||fb||fc||fd||fx||fy)) {k--;break;}
				if(fd) {
					if(r>=a){r-=a;fd=false;
						if(r>=x&&fx) {r-=x;fx=false;}
						if(r>=x&&fy) {r-=x;fy=false;}
					}
					else {r=n;k--;continue;}
				}
				if(!(fa||fb||fc||fd||fx||fy)) {k--;break;}
				if(fx) {
					if(r>=x){r-=x;fx=false;
						if(r>=x&&fy) {r-=x;fy=false;k--;break;}}
					else {r=n;k--;continue;}
				}
				if(!(fa||fb||fc||fd||fx||fy)) {k--;break;}
				if(fy) {
					if(r>=x){r-=x;fy=false;k--;}
					else {
						r=n;k--;continue;}
				}
			}
		}
		else {
			while(fa||fb||fc||fd||fx||fy) {
				if(fx) {
					if(r>=x) {r-=x;fx=false;
							  if(r>=a&&fa) {r-=a;fa=false;}
							  if(r>=a&&fb) {r-=a;fb=false;}
							  if(r>=a&&fc) {r-=a;fc=false;}
							  if(r>=a&&fd) {r-=a;fd=false;}
					}
					else {r=n;k--;continue;}
				}
				if(!(fa||fb||fc||fd||fx||fy)) {k--;break;}
				if(fy) {
					if(r>=x) {r-=x;fy=false;
							  if(r>=a&&fa) {r-=a;fa=false;}
							  if(r>=a&&fb) {r-=a;fb=false;}
							  if(r>=a&&fc) {r-=a;fc=false;}
							  if(r>=a&&fd) {r-=a;fd=false;}
					}
					else {r=n;k--;continue;}
				}
				if(!(fa||fb||fc||fd||fx||fy)) {k--;break;}
				if(fa) {
					if(r>=a){r-=a;fa=false;
					  if(r>=a&&fb) {r-=a;fb=false;}
					  if(r>=a&&fc) {r-=a;fc=false;}
					  if(r>=a&&fd) {r-=a;fd=false;}
					}
					else {r=n;k--;continue;}
				}
				if(!(fa||fb||fc||fd||fx||fy)) {k--;break;}
				if(fb) {
					if(r>=a){r-=a;fb=false;
					  if(r>=a&&fc) {r-=a;fc=false;}
					  if(r>=a&&fd) {r-=a;fd=false;}
					}
					else {r=n;k--;continue;}
				}
				if(!(fa||fb||fc||fd||fx||fy)) {k--;break;}
				if(fc) {
					if(r>=a){r-=a;fc=false;
					  if(r>=a&&fd) {r-=a;fd=false;}
					}
					else {r=n;k--;continue;}
				}
				if(!(fa||fb||fc||fd||fx||fy)) {k--;break;}
				if(fd) {
					if(r>=a){r-=a;fd=false;
							k--;
							continue;
					}
					else {r=n;k--;continue;}
				}
			}
		}
		System.out.println(6-k);

	}
}

import java.util.Scanner;

public class B910 {

	static int sizeA;
	static int sizeB;
	static int sizeN;

	static void doit(int a, int b, int size, int count){
		if(a == 0 && b == 0) res = Math.min(res, count);
		else {
			if(a > 0 && size >= sizeA) doit(a-1,b,size-sizeA,count);
			if(a > 0 && size < sizeA) doit(a,b,sizeN,count+1);
			if(b > 0 && size >= sizeB) doit(a,b-1,size-sizeB,count);
			if(b > 0 && size < sizeB) doit(a,b,sizeN,count+1);
		}
	}

	static int res = 10;

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

		sizeN = in.nextInt();
		sizeA = in.nextInt();
		sizeB = in.nextInt();
		doit(4,2, sizeN,1);
		System.out.println(res);

		in.close();
	}
}

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

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

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

    public static void main(String[] args) throws IOException {
        FastReader scn = new FastReader();
        OutputStream out = new BufferedOutputStream(System.out);
        program(scn, out);
        out.flush();
    }

    public static void print(OutputStream out, Object str) throws IOException {
        out.write(str.toString().getBytes());
    }

    static class Length implements Comparable<Length> {
        Integer length;

        public Length(int length) {
            this.length = length;
        }

        @Override
        public int compareTo(Length o) {
            return o.length - this.length;
        }
    }

    private static void program(FastReader scn, OutputStream out) throws IOException {
        int n = scn.nextInt();
        int a = scn.nextInt();
        int b = scn.nextInt();
        PriorityQueue<Length> priorityQueue = new PriorityQueue<>();
        Integer ans = 0;
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(a);
        arrayList.add(b);
        arrayList.add(a);
        arrayList.add(a);
        arrayList.add(b);
        arrayList.add(a);
        for(int i = 0; i < 6; i++)
            ans = helper(priorityQueue, ans, arrayList.get(i), n);
        print(out, ans);
    }

    private static Integer helper(PriorityQueue<Length> priorityQueue, Integer ans, int a, int n) {
        Length k = priorityQueue.poll();
        if (k == null) {
            priorityQueue.add(new Length(n - a));
            return 1;
        }
        if (k.length >= a) {
            priorityQueue.add(new Length(k.length - a));
        } else {
            priorityQueue.add(new Length(n - a));
            priorityQueue.add(k);
            ans++;
        }
        return ans;
    }

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
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);
        _910b solver = new _910b();
        solver.solve(1, in, out);
        out.close();
    }

    static class _910b {
        static int n;
        static int a;
        static int b;
        static int[][] map;

        public void solve(int testNumber, Scanner in, PrintWriter out) {
            n = in.nextInt();
            a = in.nextInt();
            b = in.nextInt();
            map = new int[5][3]; //max 4 and 2 boards
            for (int[] r : map) {
                Arrays.fill(r, -1);
            }
            out.println(dp(4, 2));
        }

        static int dp(int cv, int ch) {
            if (cv == 0 && ch == 0) return 0;
            //if(map[cv][ch]!=-1) return map[cv][ch];
            int res = Integer.MAX_VALUE;
            for (int vNow = 0; vNow <= cv; vNow++) {
                for (int hNow = 0; hNow <= ch; hNow++) {
                    if (vNow + hNow > 0 && (vNow * a + hNow * b) <= n) {
                        res = Math.min(res, 1 + dp(cv - vNow, ch - hNow));
                    }
                }
            }
            return map[cv][ch] = res;
        }

    }
}

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

public class B {
	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		int a = sc.nextInt();
		int b = sc.nextInt();
		lengths = new int[] { a, a, a, a, b, b };
		min = 7;
		solve(0, new int[] { n, n, n, n, n, n });
		System.out.println(min);
	}

	static int[] lengths;
	static int min, n;
	static void solve(int idx, int[] arr) {
		if (idx == 6) {
			int cnt = 0;
			for (int i = 0; i < arr.length; i++)
				if (arr[i] != n)
					cnt++;
			min = Math.min(min, cnt);
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] - lengths[idx] >= 0) {
				int[] a = Arrays.copyOf(arr, arr.length);
				a[i] -= lengths[idx];
				solve(idx + 1, a);
			}
		}

	}

	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 String nextLine() throws IOException {
			return br.readLine();
		}
	}
}

import java.util.Scanner;
public class frame{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n,a,b,nn=0;
        n = sc.nextInt();
        a = sc.nextInt();
        b = sc.nextInt();
        if(n>=2*b+4*a) System.out.println("1");
        else if(n>=b+2*a) System.out.println("2");
        else{
            if(n>=2*b+a){
                if(n>=3*a) System.out.println("2");
                else if(n>=2*a) System.out.println("3");
                else if(n>=a) System.out.println("4");
            }
            else{
                if(n>=2*b){
                    if(n>=4*a) nn=2;
                    else if(n>=2*a) nn=3;
                    else if(n>=a) nn=5;
                }else if(n>=b){

                    if(n>=4*a) nn=3;
                    else if(n>=2*a) nn=4;
                    else if(n>=a) nn=6;
                }
                if(n>=b+a){
                    if(n>=2*a){if(nn>3) nn=3;}
                    else if(n>=a){if(nn>4) nn=4;}
                }
                System.out.println(nn);
            }
        }
    }
}

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

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);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();

	}

	static class TaskC {
		public void solve(int testNumber, InputReader in, PrintWriter out) {
			int n = in.nextInt();
			int a = in.nextInt();
			int b = in.nextInt();
			int bars = 0 ;

			int max = Math.max(a,b )	 ;
			int min = Math.min(a, b) ;

			if(n>=4*a + 2*b)
				bars = 1 ;
			else if(n>=3*a + b + max)
				bars = 2 ;
			else if(n>=3*a + b + min)
				bars = 2 ;
			else if(n>=2*a + b + max)
				bars = 2 ;
			else if(n>=2*a + b + min)
				bars = 2 ;
			else if(n>=a + b + max)
				bars = 2 ;
			else if(n>=a + b + min)
				if(min==a)
					bars = 2 ;
				else
					if (n>=2*a)
						bars =3 ;
					else
						bars=4 ;
			else if(n>=a + b)
				if(n>=2*a)
					bars = 3 ;
				else
					bars = 4 ;
			else if(n>=4*a)
				if(n>=2*b)
					bars =2 ;
				else
					bars =3 ;
			else if(n>=3*a)
				if(n>=2*b)
					bars =3 ;
				else
					bars =4 ;
			else if(n>=2*a)
				if(n>=2*b)
					bars =3 ;
				else
					bars =4 ;
			else if(n>=a)
				if(n>=2*b)
					bars =5 ;
				else
					bars =6 ;

			else if(n>=2*b)
				if(n>=4*a)
					bars =2 ;
				else if(n>=3*a)
					bars =3 ;
				else if(n>=2*a)
					bars =4 ;
				else bars =5 ;
			else bars =6 ;

			out.print(bars);

		}
		public static boolean isPrime (long num){
			if (num < 2) return false;
			if (num == 2) return true;
			if (num % 2 == 0) return false;
			for (long i = 3*1l; i * i <= num; i += 2)
				if (num % i == 0) return false;
			return true;
		}
	}
	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());
		}

	}
	static class Vertix{
		int x ;
		ArrayList<Vertix> children;
		Vertix parent;

		public Vertix(int x){
			this.x = x ;
			this.children= new ArrayList<Vertix>();
		}

	}

	static class Pair implements Comparable<Pair> {
		int x ;
		int y ;

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

		}

		@Override
		public int compareTo(Pair p) {
			if (this.x < p.x)
				return -1;
			else if (this.x > p.x)
				return 1;
			else
				return 0;

		}
		//
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;

public class B910 {
    public static void main(String[] args) throws IOException {
        BufferedReader inp = new BufferedReader(new InputStreamReader(System.in));
        int length = Integer.parseInt(inp.readLine());
        int a = Integer.parseInt(inp.readLine());
        int b = Integer.parseInt(inp.readLine());
        int counta = 4;
        int countb = 2;
        int ans = 0;
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0;i<4;i++){
            list.add(a);
        }
        for(int i=0;i<2;i++){
            list.add(b);
        }
        Collections.sort(list);
        ArrayList<Integer> list1 = new ArrayList<>(list);
        int cut = length;
        //System.out.println(list);
        while (!list.isEmpty()){
            if(cut==length){
                cut = length-list.get(list.size()-1);
                list.remove(list.size()-1);
                ans++;
            }
            else{
                if(list.get(0)<=cut){
                    cut = cut-list.get(0);
                    list.remove(0);
                }
                else{
                    cut = length;
                }
            }

        }
        int ans1 = 0;
        boolean one = false;
        list = list1;
        cut = length;
        while (!list.isEmpty()){
            if(cut==length){
                cut = length-list.get(list.size()-1);
                list.remove(list.size()-1);
                ans1++;
            }
            else{
                if(!one){
                    if(list.get(list.size()-1)<=cut){
                        cut = cut-list.get(list.size()-1);
                        list.remove(list.size()-1);
                        one = true;
                    }
                    else{
                        cut = length;
                    }
                }
                else {
                    if(list.get(0)<=cut){
                    cut = cut-list.get(0);
                    list.remove(0);
                    }
                else{
                    cut = length;
                    }
                }
            }

        }
        if(ans1!=0) {
            System.out.println(Math.min(ans, ans1));
        }
        else{
            System.out.println(ans);
        }
    }
}

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) throws Exception {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int a = in.nextInt();
        int b = in.nextInt();
        Solution solver = new Solution();
        System.out.println(solver.solve(n, a, b));
    }

    public int solve(int n, int a, int b) {
        if (4 * a + 2 * b <= n) return 1;
        else if (4 * a <= n && 2 * b <= n) return 2;
        else if (2 * a + b <= n) return 2;
        else if (4 * a <= n && 2 * b > n) return 3;
        else if (2 * a <= n && 2 * b <= n) return 3;
        else if (2 * a <= n && a + b <= n) return 3;
        else if (2 * a <= n && a + b > n) return 4;
        else if (2 * a > n && a + b <= n) return 4;
        else if (a + b > n && 2 * b <= n) return 5;
        else return 6;
    }
}

import java.util.Scanner;

public class issam {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
        int a = sc.nextInt();
        int b = sc.nextInt();
        int r = 6;
        int h = 0;
        if(n/b>=2){
            r = 1;
            int aa = (n-2*b)/a;
            while(aa<4){
                aa += n/a;
                r++;
            }
        }
        h=2;
        int bb = (n-b)/a;
        bb = bb*2;
        while(bb<4){
            bb += n/a;
            h++;
        }
        System.out.println(Math.min(h,r));
	}
}

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

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

    static class TaskB {
        int n;
        int a;
        int b;
        int[][] mem;

        int dp(int aWant, int bWant) {
            if (aWant == 0 && bWant == 0) return 0;
            if (mem[aWant][bWant] != -1) return mem[aWant][bWant];
            int res = 1000;
            for (int aHere = 0; aHere <= aWant; aHere++) {
                for (int bHere = 0; bHere <= bWant; bHere++) {
                    if (aHere + bHere > 0 && aHere * a + bHere * b <= n) {
                        res = Math.min(res, 1 + dp(aWant - aHere, bWant - bHere));
                    }
                }
            }
            return mem[aWant][bWant] = res;
        }

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            n = in.readInt();
            a = in.readInt();
            b = in.readInt();
            mem = new int[5][3];
            ArrayUtils.fill(mem, -1);
            out.printLine(dp(4, 2));
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

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

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

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

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

    }

    static class ArrayUtils {
        public static void fill(int[][] array, int value) {
            for (int[] row : array) {
                Arrays.fill(row, value);
            }
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.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 boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

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

        }

    }
}

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 s = new Scanner(System.in);
		int n= s.nextInt();
		int a = s.nextInt();
		int b= s.nextInt();
		int remver = 4;
		int remhor = 2;
		int avai = n;
		int count = 1;
		while((remver | remhor)!=0){
			if(a>b){
				if(avai>=a && remver>0){
					avai = avai-a;remver--;
				}else if(avai>=b && remhor>0){
					avai = avai-b;remhor--;
				}else{
					if(remver>0){
						avai = n-a;count++;remver--;
					}else if(remhor>0){
						avai=n-b;count++;remhor--;
					}
				}
			}else{
				if(avai>=b && remhor>0){
					avai = avai-b;remhor--;
				}else if(avai>=a && remver>0){
					avai = avai-a;remver--;
				}else{
					if(remhor>0){
						avai = n-b;count++;remhor--;
					}else if(remver>0){
						avai=n-a;count++;remver--;
					}
				}
			}
		}
		if(n==2*a+b){
		    System.out.println(2);
		}else
		System.out.println(count);
	}
}

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

public class Solution{

	static class FastReader {
        BufferedReader br;
        StringTokenizer st;

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

    static int a, b, n, inf=100000;

    static int func(int len, int cnta, int cntb, int i){
        /*
        if(cnta==0 && cntb==0)
            System.out.println(len+" "+i);
        */
        if(len<0 || cnta<0 || cntb<0)
            return inf;

        if(i==12){
            if(cnta==0 && cntb==0)
                return 1;
            return inf;
        }

        if(cnta==0 && cntb==0){
            return 1;
        }

        return  Math.min(   func(n, cnta, cntb, i+1)+1 ,
                Math.min(   func(len-a, cnta-1, cntb, i+1) ,
                            func(len-b, cnta, cntb-1, i+1) ) );

    }

	public static void main(String[] args){
    	FastReader sc = new FastReader();
        n = sc.nextInt();
        a = sc.nextInt();
        b = sc.nextInt();

        System.out.println( func(n,4,2,0) );
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.util.Stack;

public class Main {
	static Scanner scan = new Scanner(System.in);
	static PrintStream out = new PrintStream(System.out);
	//static PrintWriter out = new PrintWriter(System.out);
	//static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
	static int n, a, b;
	static int min;

	public static void main (String[] args) throws IOException {
	    n = scan.nextInt();
	    a = scan.nextInt();
	    b = scan.nextInt();
	    min = Integer.MAX_VALUE;
	    rec(0, n, 4, 2);
	    out.println(min);
	}

	static void rec (int count, int n1, int leftA, int leftB) {
		if (leftA == 0 && leftB == 0) {min = Math.min(min, count + 1); return;}

		if (leftA > 0 && n1 >= a) {
			rec(count, n1 - a, leftA - 1, leftB);
		}

		if (leftB > 0 && n1 >= b) {
			rec(count, n1 - b, leftA, leftB - 1);
		}
		if (leftA > 0 && n1 < a) {
			rec(count + 1, n - a, leftA - 1, leftB);
		}

		if (leftB > 0 && n1 < b) {
			rec(count + 1, n - b, leftA, leftB - 1);
		}
	}
}

/**
 * Created by Chirag on 23-12-2017.
 * DA-IICT (B.tech 3rd year)
 */

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

public class DoorFrames2 {
    public static void main(String[] args) {
        MyScanner sc = new MyScanner();
        out = new PrintWriter(new BufferedOutputStream(System.out));

      /*
      int n      = sc.nextInt();        // read input as integer
      long k     = sc.nextLong();       // read input as long
      double d   = sc.nextDouble();     // read input as double
      String str = sc.next();           // read input as String
      String s   = sc.nextLine();       // read whole line as String

      int result = 3*n;
      out.println(result);                    // print via PrintWriter
      */
        //The Code Starts here
        int n=sc.nextInt();
        int a=sc.nextInt();
        int b=sc.nextInt();

        int aS=4;
        int bS=2;

        ArrayList<Integer> woods=new ArrayList<>();

        for(int i=0;i<6;i++)
            woods.add(n);

        for(int i=0;i<6;i++)
        {
            int bestJ=0;
            int bestK=0;
            int minRem=Integer.MAX_VALUE;
            for(int j=0;j<=aS;j++)
            {
                for(int k=0;k<=bS;k++)
                {
                    int val=j*a+k*b;

                    if(woods.get(i)>=val && woods.get(i)-val<minRem)
                    {
                        minRem=woods.get(i)-val;
                        bestJ=j;
                        bestK=k;
                    }
                }
            }
            if(minRem!=Integer.MAX_VALUE)
            {
                woods.set(i,minRem);
                aS-=bestJ;
                bS-=bestK;
            }
        }

        int ans=0;

        for(int i=0;i<6;i++)
        {
            if(woods.get(i)!=n)
                ans++;
        }
        out.print(ans);

        //The Code ends here
        out.close();
    }

    //-----------PrintWriter for faster output---------------------------------
    public static PrintWriter out;

    //-----------MyScanner class for faster input----------
    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

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

        char nextCharacter() {
            return next().charAt(0);
        }

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

        public int[] nextIntArray(int n) {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextInt();
            }
            return arr;
        }

        public long[] nextLongArray(int n) {
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextLong();
            }
            return arr;
        }

        public int[][] nextInt2DArray(int m, int n) {
            int[][] arr = new int[m][n];
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++)
                    arr[i][j] = nextInt();
            }
            return arr;
        }

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

    }

    public static void debug(Object... o) {
        System.out.println(Arrays.deepToString(o));
    }

    public static class Pair implements Comparable<Pair> {
        long u;
        long v;

        public Pair(long u, long v) {
            this.u = u;
            this.v = v;
        }

        public int hashCode() {
            int hu = (int) (u ^ (u >>> 32));
            int hv = (int) (v ^ (v >>> 32));
            return 31 * hu + hv;
        }

        public boolean equals(Object o) {
            Pair other = (Pair) o;
            return u == other.u && v == other.v;
        }

        public int compareTo(Pair other) {
            return Long.compare(u, other.u) != 0 ? Long.compare(u, other.u) : Long.compare(v, other.v);
        }

        public String toString() {
            return "[u=" + u + ", v=" + v + "]";
        }
    }
    //--------------------------------------------------------

    // Different other methods

    public static long pow(long n, long p, long mod) {
        if (p == 0)
            return 1;
        if (p == 1)
            return n % mod;
        if (p % 2 == 0) {
            long temp = pow(n, p / 2, mod);
            return (temp * temp) % mod;
        } else {
            long temp = pow(n, p / 2, mod);
            temp = (temp * temp) % mod;
            return (temp * n) % mod;

        }
    }

    public static long pow(long n, long p) {
        if (p == 0)
            return 1;
        if (p == 1)
            return n;
        if (p % 2 == 0) {
            long temp = pow(n, p / 2);
            return (temp * temp);
        } else {
            long temp = pow(n, p / 2);
            temp = (temp * temp);
            return (temp * n);

        }
    }

    public static long gcd(long x, long y) {
        if (x == 0)
            return y;
        else
            return gcd(y % x, x);
    }

    static long modInverse(long a, long m) {
        long m0 = m, t, q;
        long x0 = 0, x1 = 1;

        if (m == 1)
            return 0;

        while (a > 1) {
            // q is quotient
            q = a / m;

            t = m;

            // m is remainder now, process
            // same as Euclid's algo
            m = a % m;
            a = t;

            t = x0;

            x0 = x1 - q * x0;

            x1 = t;
        }

        // Make x1 positive
        if (x1 < 0)
            x1 += m0;

        return x1;
    }

    public static boolean isPrime(int n) {
        if (n <= 1)
            return false;
        if (n <= 3)
            return true;

        if (n % 2 == 0 || n % 3 == 0)
            return false;

        for (int i = 5; i * i <= n; i = i + 6)
            if (n % i == 0 || n % (i + 2) == 0)
                return false;

        return true;
    }

    public static class DisjointSet {
        HashMap<Integer, Node> map = new HashMap<Integer, Node>();

        class Node {
            int data;
            int rank;
            Node parent;

            Node(int data) {
                this.data = data;
                this.rank = 0;
                this.parent = this;
            }
        }

        void makeSet(int data) {
            map.put(data, new Node(data));
        }

        Node findSet(int data) {
            return findSet(map.get(data));
        }

        boolean isConnected(int d1, int d2) {
            return findSet(d1) == findSet(d2);
        }

        Node findSet(Node node) {
            Node parent = node.parent;
            if (parent == node)
                return parent;
            node.parent = findSet(node.parent);
            return node.parent;
        }

        void union(int data1, int data2) {
            Node d1 = map.get(data1);
            Node d2 = map.get(data2);

            Node p1 = findSet(d1);
            Node p2 = findSet(d2);

            if (p1.data == p2.data)
                return;

            if (p1.rank >= p2.rank) {
                p1.rank = (p1.rank == p2.rank) ? p1.rank + 1 : p1.rank;
                p2.parent = p1;
            } else {
                p1.parent = p2;
            }
        }

    }

}

/*
 *
 * @Author  Ajudiya_13(Bhargav Girdharbhai Ajudiya)
 * Dhirubhai Ambani Institute of Information And Communication Technology
 *
 */

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

public class Code275
{

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

		int n = in.nextInt();
		int a = in.nextInt();
		int b = in.nextInt();
		int ans = 0;
		if(4*a+2*b<=n)
			ans = 1;
		else if((4*a<=n && 2*b<=n) || (3*a+b)<=n || (2*a+b)<=n || (3*a<=n && a+2*b<=n))
			ans = 2;
		else if((a+b<=n && 2*a<=n) || (4*a<=n && b<=n))
			ans = 3;
		else if((a+b<=n && a<=n) || (3*a<=n && b<=n) || (2*a<=n && b<=n))
			ans = 4;
		else if(a<=n && 2*b<=n)
			ans = 5;
		else
			ans = 6;

		pw.print(ans);
		pw.flush();
		pw.close();
	}

	static class InputReader
	{

		private final InputStream stream;
		private final byte[] buf = new byte[8192];
		private int curChar, snumChars;
		private SpaceCharFilter filter;

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

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

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

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

		public int[] nextIntArray(int n)
		{
			int a[] = new int[n];
			for (int i = 0; i < n; i++)
			{
				a[i] = nextInt();
			}
			return a;
		}

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

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

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

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

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

	public static long mod = 1000000007;
	public static int d;
	public static int p;
	public static int q;

	public static int[] suffle(int[] a,Random gen)
	{
		int n = a.length;
		for(int i=0;i<n;i++)
		{
			int ind = gen.nextInt(n-i)+i;
			int temp = a[ind];
			a[ind] = a[i];
			a[i] = temp;
		}
		return a;
	}

	public static void swap(int a, int b){
		int temp = a;
		a = b;
		b = temp;
	}

	public static HashSet<Integer> primeFactorization(int n)
	{
		HashSet<Integer> a =new HashSet<Integer>();
		for(int i=2;i*i<=n;i++)
		{
			while(n%i==0)
			{
				a.add(i);
				n/=i;
			}
		}
		if(n!=1)
			a.add(n);
		return a;
	}

	public static void sieve(boolean[] isPrime,int n)
	{
		for(int i=1;i<n;i++)
			isPrime[i] = true;

		isPrime[0] = false;
		isPrime[1] = false;

		for(int i=2;i*i<n;i++)
		{
			if(isPrime[i] == true)
			{
				for(int j=(2*i);j<n;j+=i)
					isPrime[j] = false;
			}
		}
	}

	public static int GCD(int a,int b)
	{
		if(b==0)
			return a;
		else
			return GCD(b,a%b);
	}

	public static long GCD(long a,long b)
	{
		if(b==0)
			return a;
		else
			return GCD(b,a%b);
	}

	public static void extendedEuclid(int A,int B)
	{
		if(B==0)
		{
			d = A;
			p = 1 ;
			q = 0;
		}
		else
		{
			extendedEuclid(B, A%B);
			int temp = p;
			p = q;
			q = temp - (A/B)*q;
		}
	}

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

	public static int LCM(int a,int b)
	{
		return (a*b)/GCD(a,b);
	}

	public static int binaryExponentiation(int x,int n)
	{
	    int result=1;
	    while(n>0)
	    {
	        if(n % 2 ==1)
	            result=result * x;
	        x=x*x;
	        n=n/2;
	    }
	    return result;
	}

	public static long binaryExponentiation(long x,long n)
	{
	    long result=1;
	    while(n>0)
	    {
	        if(n % 2 ==1)
	            result=result * x;
	        x=x*x;
	        n=n/2;
	    }
	    return result;
	}

	public static int modularExponentiation(int x,int n,int M)
	{
	    int result=1;
	    while(n>0)
	    {
	        if(n % 2 ==1)
	            result=(result * x)%M;
	        x=(x*x)%M;
	        n=n/2;
	    }
	    return result;
	}

	public static long modularExponentiation(long x,long n,long M)
	{
	    long result=1;
	    while(n>0)
	    {
	        if(n % 2 ==1)
	            result=(result * x)%M;
	        x=(x*x)%M;
	        n=n/2;
	    }
	    return result;
	}

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

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

	public static boolean isPrime(int n)
	{

	    if (n <= 1)  return false;
	    if (n <= 3)  return true;

	    if (n%2 == 0 || n%3 == 0)
	    	return false;

	    for (int i=5; i*i<=n; i=i+6)
	    {
	        if (n%i == 0 || n%(i+2) == 0)
	           return false;
	    }

	    return true;
	}

	static class pair implements Comparable<pair>
	{
		Integer x, y;
		pair(int x,int y)
		{
			this.x=x;
			this.y=y;
		}

		public int compareTo(pair o) {
			int result = x.compareTo(o.x);
			if(result==0)
				result = y.compareTo(o.y);

			return result;
		}

		public String toString()
		{
			return x+" "+y;
		}

		public boolean equals(Object o)
		{
			if (o instanceof pair)
		    {
				pair p = (pair)o;
				return p.x == x && p.y == y ;
			}
			return false;
		}

		public int hashCode()
		{
			return new Long(x).hashCode()*31 + new Long(y).hashCode();
		}
	}
}

import java.io.FileReader;
import java.util.ArrayList;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) throws Exception {
        new Main();
    }

	public Main() throws Exception{
		Scanner sc = new Scanner(System.in);
//		Scanner sc = new Scanner(new FileReader("input"));

		int n = sc.nextInt();
		int a = sc.nextInt();
		int b = sc.nextInt();

		int as = 4;
		int bs = 2;

		ArrayList<Integer> woods = new ArrayList<>();
		for (int i=0;i<6;i++) {

			woods.add(n);

		}

		for (int i=0;i<6;i++) {
			int bestF = 0;
			int bestS = 0;
			int minRem = Integer.MAX_VALUE;
			for (int f=0;f<=as;f++) {
				for (int s=0;s<=bs;s++) {
					int val = f*a + s*b;
//					System.out.println(val);
					if (woods.get(i) >= val && woods.get(i) - val < minRem) {
//						System.out.println("aa");
						minRem = woods.get(i) - val ;
						bestF = f;
						bestS = s;
					}
				}
			}
			if (minRem != Integer.MAX_VALUE) {
				woods.set(i, minRem);
				as-=bestF;
				bs-=bestS;
			}

		}
		int ans = 0;
		for (int i=0;i<6;i++) {
			if (woods.get(i) != n) {
				ans++;
			}
		}
		System.out.println(ans);
        sc.close();
	}

}

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.Random;
import java.util.StringTokenizer;
import java.util.TreeSet;
import java.util.TreeMap;

import static java.lang.Math.abs;
import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.sqrt;
import static java.util.Arrays.copyOf;
import static java.util.Arrays.fill;
import static java.util.Arrays.sort;
import static java.util.Collections.reverse;
import static java.util.Collections.reverseOrder;
import static java.util.Collections.sort;

public class Main {
    private FastScanner in;
    private PrintWriter out;

    int ans = 6;
    int n, a, b;

    private void solve() throws IOException {
        n = in.nextInt();
        a = in.nextInt();
        b = in.nextInt();
        dfs(n, 1, 0, 0);
        out.print(ans);
    }

    private void dfs(int n, int cur, int ka, int kb) {
        if (ka == 4 && kb == 2)
            ans = min(ans, cur);
        if (ka < 4) {
            if (n >= a)
                dfs(n - a, cur, ka + 1, kb);
            else
                dfs(this.n - a, cur + 1, ka + 1, kb);
        }
        if (kb < 2) {
            if (n >= b)
                dfs(n - b, cur, ka, kb + 1);
            else
                dfs(this.n - b, cur + 1, ka, kb + 1);
        }
    }

    private void solveA() throws IOException {

    }

    private void solveB() throws IOException {

    }

    private void solveC() throws IOException {

    }

    private void solveD() throws IOException {

    }

    private void solveE() throws IOException {

    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

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

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

        boolean hasNext() throws IOException {
            return br.ready() || (st != null && st.hasMoreTokens());
        }

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

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

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

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

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

    private void run() throws IOException {
        in = new FastScanner(System.in); // new FastScanner(new FileInputStream(".in"));
        out = new PrintWriter(System.out); // new PrintWriter(new FileOutputStream(".out"));

        solve();

        out.flush();
        out.close();
    }

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

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

/**
 * Created by trung.pham on 27/12/17.
 */
public class B_Testing_Round_14 {
    static int[][][]dp;
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        int n = in.nextInt();
        int a = in.nextInt();
        int b = in.nextInt();
        dp = new int[n + 1][5][3];
        for(int [][]x : dp){
            for(int[]y : x){
                Arrays.fill(y, -1);
            }
        }
        out.println(cal(n, 4, 2, n, a, b));
        out.close();
    }

    public static int cal(int left, int a, int b, int n, int A, int B){
        if(a == 0 && b == 0){
            return 1;
        }
        if(dp[left][a][b] != -1){
            return dp[left][a][b];
        }

        int result = 6;
        if(left >= A && a > 0){
            result = cal(left - A, a - 1, b, n,  A, B);
        }
        if(left >= B && b > 0){
            result = Math.min(result , cal(left - B, a, b - 1, n , A, B));
        }
        if((left < A || a == 0 ) && (left < B || b == 0)){
            result = 1 + cal(n, a, b, n, A, B);
        }
        //System.out.println(left + " " + a + " " + b + " " + result);
        return dp[left][a][b] = result;
    }
}

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

import static java.lang.Integer.max;

public class DoorFrames implements Closeable {

    private InputReader in = new InputReader(System.in);
    private PrintWriter out = new PrintWriter(System.out);

    public void solve() {
        int n = in.ni(), a = in.ni(), b = in.ni(), result = 6;
        if (4 * a + 2 * b <= n) result = 1;
        else if (2 * a + b <= n) result = 2;
        else if (max(2 * a, 2 * b) <= n || max(2 * b + a, 3 * a) <= n || max(a + b, 2 * a) <= n || max(4 * a, b) <= n) result = 3;
        else if (max(b, 2 * a) <= n || (a + b) <= n) result = 4;
        else if (max(2 * b, a) <= n) result = 5;

        out.println(result);
    }

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

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

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

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

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

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

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

    public static void main(String[] args) throws IOException {
        try (DoorFrames instance = new DoorFrames()) {
            instance.solve();
        }
    }
}

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

public class b {
	public static void main(String[] Args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int a = sc.nextInt();
		int b = sc.nextInt();
		int ans = 6;
		for (int i = 0; i < 5; i++)
			for (int j = i + 1; j < 6; j++) {
				int tans = 1;
				int[] tx = new int[6];
				Arrays.fill(tx, a);
				tx[i] = b;
				tx[j] = b;
				int cur = n;
				for (int k = 0; k < 6; k++) {
					if (cur >= tx[k]) {
						cur -= tx[k];
					} else {
						tans++;
						cur = n - tx[k];
					}
				}
				if (ans > tans) {
					ans = tans;
				}
			}
		System.out.println(ans);
	}
}

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

public class B {

	public static void main(String[] args)  {
		FastScanner scan = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		int n = scan.nextInt(), a = scan.nextInt(), b = scan.nextInt();
		ArrayDeque<Integer> q = new ArrayDeque<Integer>();
		q.add(4); q.add(2); q.add(0);
		int res = 0x3f3f3f3f;
		while(!q.isEmpty()) {
			int ra = q.poll(), rb = q.poll(), t = q.poll();
			if(ra == 0 && rb == 0) {
				res = Math.min(res, t);
				continue;
			}
			for(int i = 0; i <= 4; i++) {
				for(int j = 0; j <= 2; j++) {
					if(i == 0 && j == 0) continue;
					if(ra >= i && rb >= j && n >= i*a+j*b) {
						q.add(ra-i); q.add(rb-j); q.add(t+1);
					}
				}
			}
		}
		out.println(res);
		out.close();
	}

	static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner() {
			try	{
				br = new BufferedReader(new InputStreamReader(System.in));
				st = new StringTokenizer(br.readLine());
			} catch (Exception e){e.printStackTrace();}
		}

		public String next() {
			if (st.hasMoreTokens())	return st.nextToken();
			try {st = new StringTokenizer(br.readLine());}
			catch (Exception e) {e.printStackTrace();}
			return st.nextToken();
		}

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

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

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

		public String nextLine() {
			String line = "";
			if(st.hasMoreTokens()) line = st.nextToken();
			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
			while(st.hasMoreTokens()) line += " "+st.nextToken();
			return line;
		}

		public int[] nextIntArray(int n) {
			int[] a = new int[n];
			for(int i = 0; i < n; i++) a[i] = nextInt();
			return a;
		}

		public long[] nextLongArray(int n){
			long[] a = new long[n];
			for(int i = 0; i < n; i++) a[i] = nextLong();
			return a;
		}

		public double[] nextDoubleArray(int n){
			double[] a = new double[n];
			for(int i = 0; i < n; i++) a[i] = nextDouble();
			return a;
		}

		public char[][] nextGrid(int n, int m){
			char[][] grid = new char[n][m];
			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
			return grid;
		}
	}

}

import javax.print.attribute.IntegerSyntax;
import java.util.*;
import java.io.*;
import java.lang.*;
import java.math.*;
import java.util.concurrent.ThreadLocalRandom;

import static java.lang.Math.*;

public class Sol implements Runnable {

    static long mod = 1000000007;

    int n, a, b, min;

    void swap(int arr[], int l, int x) {
        int temp = arr[l];
        arr[l] = arr[x];
        arr[x] = temp;
    }

    void permute(int arr[], int l, int r) {
        if(l == r) {
            int count = 1;
            int left = n;

            for(int i : arr) {
                if(i == 1) {        // it's a
                    if(left < a) {
                        count++;
                        left = n;
                    }
                    left -= a;
                }
                else {              // it's b
                    if(left < b) {
                        count++;
                        left = n;
                    }
                    left -= b;
                }
            }

            min = min(min, count);
        }
        else {
            for(int i=l;i<=r;i++) {
                swap(arr, l, i);
                permute(arr, l + 1, r);
                swap(arr, l, i);
            }
        }
    }

    void solve(int total_test_cases, InputReader in, PrintWriter w) {
        for (int test_case = 1; test_case <= total_test_cases; test_case++) {
            n = in.nextInt(); a = in.nextInt(); b = in.nextInt();
            int arr[] = {1, 1, 0, 1, 1, 0};     // 1 --> a && 0 --> b
            min = Integer.MAX_VALUE;
            permute(arr, 0, 5);
            w.println(min);
        }
    }

    // ************* Code ends here ***************

    void init() throws Exception {
        //Scanner in;
        InputReader in;
        PrintWriter w;
        boolean online = false;

        String common_in_fileName = "\\in";
        String common_out_fileName = "\\out";
        int test_files = 0;

        for(int file_no = 0; file_no <= test_files; file_no++) {

            String x = "" + file_no;
            if (x.length() == 1) x = "0" + x;

            String in_fileName = common_in_fileName + "" + x;
            String out_fileName = common_out_fileName + "" + x;

            if (online) {
                //in = new Scanner(new File(in_fileName + ".txt"));
                in = new InputReader(new FileInputStream(new File(in_fileName + ".txt")));
                w = new PrintWriter(new FileWriter(out_fileName + ".txt"));
            } else {
                //in = new Scanner(System.in);
                in = new InputReader(System.in);
                w = new PrintWriter(System.out);
            }

            solve(1, in, w);
            w.close();
        }
    }

    public void run() {
        try {
            init();
        }
        catch(Exception e) {
            System.out.println(e);
            e.printStackTrace();
        }
    }

    public static void main(String args[]) throws Exception {
        new Thread(null, new Sol(),"Sol",1<<28).start();
    }

    static 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 String nextLine() {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        public int nextInt() {
            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 long nextLong() {
            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 double nextDouble() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E') {
                    return res * Math.pow(10, nextInt());
                }
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E') {
                        return res * Math.pow(10, nextInt());
                    }
                    if (c < '0' || c > '9') {
                        throw new InputMismatchException();
                    }
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            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 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 CodeForces {

    public static ArrayList<Integer>[] tree;
    public static int[] col;

    public static void main(String[] args) throws IOException {
        FastScanner in = new FastScanner(System.in);
        int n = in.nextInt();
        int a = in.nextInt();
        int totA = a * 4;
        int b = in.nextInt();
        int totB = b * 2;
        int bars = 0;
        int bars2 = 0;
        int temp;
        while (totA + totB > 0) {
            temp = n;
            bars++;
            if (totA > 0) {
                while (totA > 0 && temp >= a) {
                    temp -= a;
                    totA -= a;
                }
            }
            if (totB > 0 && temp >= b) {
                while (totB > 0 && temp >= b) {
                    temp -= b;
                    totB -= b;
                }
            }
        }
        totA = a * 4;
        totB = b * 2;
        while (totA + totB > 0) {
            temp = n;
            bars2++;
            if (totB > 0) {
                while (totB > 0 && temp >= b) {
                    temp -= b;
                    totB -= b;
                }
            }

            if (totA > 0 && temp >= a) {
                while (totA > 0 && temp >= a) {
                    temp -= a;
                    totA -= a;
                }
            }
        }
        if (n == (2 * a + b)) {
            System.out.println(2);
        } else {
            System.out.println(Math.min(bars, bars2));
        }

    }

    public static int[] radixSort(int[] f) {
        return radixSort(f, f.length);
    }

    public static int[] radixSort(int[] f, int n) {
        int[] to = new int[n];
        {
            int[] b = new int[65537];
            for (int i = 0; i < n; i++) {
                b[1 + (f[i] & 0xffff)]++;
            }
            for (int i = 1; i <= 65536; i++) {
                b[i] += b[i - 1];
            }
            for (int i = 0; i < n; i++) {
                to[b[f[i] & 0xffff]++] = f[i];
            }
            int[] d = f;
            f = to;
            to = d;
        }
        {
            int[] b = new int[65537];
            for (int i = 0; i < n; i++) {
                b[1 + (f[i] >>> 16)]++;
            }
            for (int i = 1; i <= 65536; i++) {
                b[i] += b[i - 1];
            }
            for (int i = 0; i < n; i++) {
                to[b[f[i] >>> 16]++] = f[i];
            }
            int[] d = f;
            f = to;
            to = d;
        }
        return f;
    }

    private static class FastScanner {

        private final InputStream stream;
        private final byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

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

        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++];
        }

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

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

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

        public int[] nextArrayInt(int n) {
            int tab[] = new int[n];
            for (int i = 0; i < n; i++) {
                tab[i] = nextInt();
            }
            return tab;
        }

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

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

        public String next() {
            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 String nextLine() {
            int c = read();
            while (isEndline(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndline(c));
            return res.toString();
        }
    }
}

import java.io.*;
import java.util.*;
import  java.math.*;
public class Main {
	public static void main(String[] args) throws IOException
	{
		// StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		FastScanner sc = new FastScanner();

		int a,b,n,s=0,cur,ia=4,ib=2,c;

		 n =sc.nextInt(); a =sc.nextInt(); b=sc.nextInt();
		while ((ia!=0)||(ib!=0)) {
			int m=99999,ma=0,mb=0;
			for(int i=0;i<=4;i++)
				for(int j=0;j<=2;j++)
					if(!(((i==0)&&(j==0))||i>ia||j>ib)&&(n-i*a-j*b)>=0){
						c=(n-i*a-j*b);
						if(c<m){m=c;ma=i;mb=j;}
					}
			++s;ia-=ma;ib-=mb;
		}
		out.println( s);
		out.flush();
	}
	static class FastScanner {
		BufferedReader br;
		StringTokenizer st;
		private FastScanner() {
			try	{
				br = new BufferedReader(new InputStreamReader(System.in));
				st = new StringTokenizer(br.readLine());
			} catch (Exception e){e.printStackTrace();}
		}
		private boolean hasNextToken()
		{
			if(st.countTokens()!=StreamTokenizer.TT_EOF)
			{
				return true;
			}
			else
				return false;
		}
		private String next() {
			if (st.hasMoreTokens())	return st.nextToken();
			try {st = new StringTokenizer(br.readLine());}
			catch (Exception e) {e.printStackTrace();}
			return st.nextToken();
		}
		private BigInteger nextBigInteger(){return new BigInteger(next());}
		private BigDecimal nextBigDecimal(){return new BigDecimal(next());}
		private  int nextInt() {return Integer.parseInt(next());}
		private long nextLong() {return Long.parseLong(next());}
		private double nextDouble() {return Double.parseDouble(next());}
		private String nextLine() {
			String line = "";
			if(st.hasMoreTokens()) line = st.nextToken();
			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
			while(st.hasMoreTokens()) line += " "+st.nextToken();
			return line;
		}
		private int[] nextIntArray(int n) {
			int[] a = new int[n];
			for(int i = 0; i < n; i++) a[i] = nextInt();
			return a;
		}
		private long[] nextLongArray(int n){
			long[] a = new long[n];
			for(int i = 0; i < n; i++) a[i] = nextLong();
			return a;
		}
		private double[] nextDoubleArray(int n){
			double[] a = new double[n];
			for(int i = 0; i < n; i++) a[i] = nextDouble();
			return a;
		}
		private char[][] nextGrid(int n, int m){
			char[][] grid = new char[n][m];
			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
			return grid;
		}
		private void sort(int arr[])
		{
			int cnt[]=new int[(1<<16)+1];
			int ys[]=new int[arr.length];
			for(int j=0;j<=16;j+=16){
				Arrays.fill(cnt,0);
				for(int x:arr){cnt[(x>>j&0xFFFF)+1]++;}
				for(int i=1;i<cnt.length;i++){cnt[i]+=cnt[i-1];}
				for(int x:arr){ys[cnt[x>>j&0xFFFF]++]=x;}
				{ final int t[]=arr;arr=ys;ys=t;}
			}
			if(arr[0]<0||arr[arr.length-1]>=0)return;
			int i,j,c;
			for(i=arr.length-1,c=0;arr[i]<0;i--,c++){ys[c]=arr[i];}
			for(j=arr.length-1;i>=0;i--,j--){arr[j]=arr[i];}
			for(i=c-1;i>=0;i--){arr[i]=ys[c-1-i];}
		}
	}

}

import java.awt.List;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.LinkedList;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Stack;
import java.util.TreeMap;
import java.util.TreeSet;

public class Main
{
	InputStream is;
	PrintWriter out;
	String INPUT = "";

	void solve()
	{

		int[][] dp = new int[5][3];
		for(int i = 0;i < 5;i++){
			Arrays.fill(dp[i], 99999999);
		}
		dp[0][0] = 0;
		int n = ni(), a = ni(), b = ni();
		for(int i = 0;i < 5;i++){
			for(int j = 0;j < 3;j++){
				for(int k = 0;a*k <= n;k++){
					int l = (n-a*k)/b;
					int ni = Math.min(i+k, 4);
					int nj = Math.min(j+l, 2);
					dp[ni][nj] = Math.min(dp[ni][nj],
							dp[i][j] + 1);
				}
			}
		}
		out.println(dp[4][2]);
	}

	void run() throws Exception
	{
		is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
		out = new PrintWriter(System.out);

		long s = System.currentTimeMillis();
		solve();
		out.flush();
		if(!INPUT.isEmpty())tr(System.currentTimeMillis()-s+"ms");
	}

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

	private byte[] inbuf = new byte[1024];
	public int lenbuf = 0, ptrbuf = 0;

	private int readByte()
	{
		if(lenbuf == -1)throw new InputMismatchException();
		if(ptrbuf >= lenbuf)
		{
			ptrbuf = 0;
			try
			{ lenbuf = is.read(inbuf); }
			catch (IOException e)
			{ throw new InputMismatchException(); }
			if(lenbuf <= 0)return -1;
		}
		return inbuf[ptrbuf++];
	}

	private boolean isSpaceChar(int c)
	{ return !(c >= 33 && c <= 126); }
	private int skip()
	{ int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }

	private double nd()
	{ return Double.parseDouble(ns()); }
	private char nc()
	{ return (char)skip(); }

	private String ns()
	{
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while(!(isSpaceChar(b)))
		{ // when nextLine, (isSpaceChar(b) && b != ' ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	private String nsl()
	{
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while(!(isSpaceChar(b) && b != ' '))
		{ // when nextLine, (isSpaceChar(b) && b != ' ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	private char[] ns(int n)
	{
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while(p < n && !(isSpaceChar(b)))
		{
			buf[p++] = (char)b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	private char[][] nm(int n, int m)
	{
		char[][] map = new char[n][];
		for(int i = 0;i < n;i++)map[i] = ns(m);
		return map;
	}

	private int[] na(int n)
	{
		int[] a = new int[n];
		for(int i = 0;i < n;i++)a[i] = ni();
		return a;
	}

	private int ni()
	{
		int num = 0, b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-')
		{
			minus = true;
			b = readByte();
		}

		while(true)
		{
			if(b >= '0' && b <= '9')
			{
				num = num * 10 + (b - '0');
			}else
			{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private long nl()
	{
		long num = 0;
		int b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-')
		{
			minus = true;
			b = readByte();
		}

		while(true){
			if(b >= '0' && b <= '9')
			{
				num = num * 10 + (b - '0');
			}else
			{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private static void tr(Object... o)
	{ System.out.println(Arrays.deepToString(o)); }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class Codeforces910B {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = Integer.parseInt(scanner.nextLine());
        int a = Integer.parseInt(scanner.nextLine());
        int b = Integer.parseInt(scanner.nextLine());
        List<Integer> frame = new ArrayList<Integer>();
        for (int i = 0; i < 4; i++) {
            frame.add(a);
        }
        for (int i = 0; i < 2; i++) {
            frame.add(b);
        }
        Collections.sort(frame);
        Collections.reverse(frame);
//        System.out.println(frame);
        ArrayList<Integer> wooden = new ArrayList<Integer>();
        int numberOfWooden = 0;
        if (n == a * 2 + b) {
            numberOfWooden = 2;
        } else {
            while (frame.size() > 0) {
                int curWooden;
                if (wooden.size() > 0) {
                    curWooden = wooden.get(0);
                    wooden.remove(0);
                } else {
                    curWooden = n;
                    numberOfWooden++;
//                System.out.println(curWooden);
//                System.out.println(numberOfWooden);
                }
                boolean cutted = false;
                for (int i = 0; i < frame.size(); i++) {
                    int curFrame = frame.get(i);
//                System.out.println(curFrame);
                    if (curWooden >= curFrame) {
                        curWooden -= curFrame;
                        frame.remove(i);
                        i--;
                        cutted = true;
                    }
                }
//            System.out.println(cutted);
                if (cutted) {
                    wooden.add(0, curWooden);
                } else {

                }

            }
        }
        System.out.println(numberOfWooden);
    }
}

import java.util.*;
public class DoorFrames {

	public static void main(String args[])
	{
		Scanner sc=new Scanner (System.in);
		int n=sc.nextInt();
		int a=sc.nextInt();
		int b=sc.nextInt();
		int ans=1,x=0,y=0,z=n;

		while(x<4 || y<2)
		{
			if (z>=a & x<4)
			{
				z-=a;
				x+=1;
			}
			if (z>=b & y<2)
			{
				z-=b;
				y+=1;
			}
			if(x==4 & y==2)
				break;
			if ((z<a || x==4) && (z<b || y==2))
			{
				z = n ;
				ans+=1;
			}
		}
		System.out.println(ans);
			sc.close();
	}

}

import java.util.*;
import java.io.*;
import java.math.*;
import java.awt.geom.*;
public class DoorFrames{
    static ArrayList<Integer> rems=new ArrayList<>();
    public static boolean findRem(int val){
      for(int i=0;i<rems.size();i++){
        if(rems.get(i)>=val){
          rems.set(i, rems.get(i)-val);
          return true;
        }
      }
      return false;
    }
    public static void main(String[] args) {
        MyScanner sc=new MyScanner();
        int l=sc.ni();
        int a=sc.ni();
        int b=sc.ni();
        if(l<Math.max(a,b)){
          System.out.println(0);
          System.exit(0);
        }
        if(l>=2*(2*a+b)){
          System.out.println(1);
          System.exit(0);
        }
        int ans=0;
        ans++;
        //make first a
        if(l-a != 0) rems.add(l-a);
        //make second a
        if(!findRem(a)){
          ans++;
          rems.add(l-a);
        }
        //make first b
        if(!findRem(b)){
          ans++;
          rems.add(l-b);
        }
        //make 1st a
        if(!findRem(a)){
          ans++;
          rems.add(l-a);
        }
        //make 2nd a
        if(!findRem(a)){
          ans++;
          rems.add(l-a);
        }
        //make 2nd b
        if(!findRem(b)){
          ans++;
          rems.add(l-b);
        }
        System.out.println(ans);
    }

    private static class MyScanner {
      BufferedReader br;
      StringTokenizer st;

      public MyScanner() {
         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 ni() {
          return Integer.parseInt(next());
      }
      float nf() {
        return Float.parseFloat(next());
      }
      long nl() {
          return Long.parseLong(next());
      }

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

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

// package codeforces.testing14;

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

public class B
{
	static int n, a, b;
	public static void main(String[] args) throws IOException
	{
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);

		n = sc.nextInt();
		a = sc.nextInt();
		b = sc.nextInt();
		// 4a 2b
		System.out.println(solve(1, n, 4, 2));

		pw.flush();
		pw.close();
	}
	private static int solve(int i, int rem, int na, int nb)
	{
		if(na == 0 && nb == 0)
			return i;
		int ans = Integer.MAX_VALUE;
		boolean bb = false;
		if(rem >= a && na > 0)
		{
			ans = Math.min(ans, solve(i, rem-a, na-1, nb));
			bb = true;
		}
		if(rem >= b && nb > 0)
		{
			ans = Math.min(ans, solve(i, rem-b, na, nb-1));
			bb = true;
		}

		if(!bb)
			ans = Math.min(ans, solve(i+1, n, na, nb));
		return ans;
	}
	static class Scanner
	{
		StringTokenizer st;
		BufferedReader br;

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

		public Scanner(String s) throws FileNotFoundException
		{
			br = new BufferedReader(new FileReader(new File((s))));
		}

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

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

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

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

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

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

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

@SuppressWarnings("unchecked")
public class P910B {

  int n;
  TreeMap<Integer, Integer> m;

  void use(int l) {
    Integer pl = m.ceilingKey(l);

    int c = m.get(pl) - 1;
    if (c > 0) {
      m.put(pl, c);
    } else {
      m.remove(pl);
    }

    if (pl != l) {
      m.put(pl - l, m.getOrDefault(pl - l, 0) + 1);
    }
  }

  public void run() throws Exception {
    n = nextInt();
    int a = nextInt(), b = nextInt(), k = Integer.MAX_VALUE;

    for (int mm = (1 << 6) - 1; mm > 0; mm--) {
      if (Integer.bitCount(mm) != 2) { continue; }

      m = new TreeMap();
      m.put(n, 6);
      for (int mi = 1 << 5; mi > 0; mi >>= 1) {
        if ((mm & mi) == 0) {
          use(a);
        } else {
          use(b);
        }
      }

      k = Math.min(k, 6 - m.getOrDefault(n, 0));
    }

    println(k);
  }

  public static void main(String... args) throws Exception {
    br = new BufferedReader(new InputStreamReader(System.in));
    pw = new PrintWriter(new BufferedOutputStream(System.out));
    new P910B().run();
    br.close();
    pw.close();
    System.err.println("\n[Time : " + (System.currentTimeMillis() - startTime) + " ms]");
  }

  static long startTime = System.currentTimeMillis();
  static BufferedReader br;
  static PrintWriter pw;
  StringTokenizer stok;

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

  void print(byte b) { print("" + b); }
  void print(int i) { print("" + i); }
  void print(long l) { print("" + l); }
  void print(double d) { print("" + d); }
  void print(char c) { print("" + c); }
  void print(Object o) {
    if (o instanceof int[]) { print(Arrays.toString((int [])o));
    } else if (o instanceof long[]) { print(Arrays.toString((long [])o));
    } else if (o instanceof char[]) { print(Arrays.toString((char [])o));
    } else if (o instanceof byte[]) { print(Arrays.toString((byte [])o));
    } else if (o instanceof short[]) { print(Arrays.toString((short [])o));
    } else if (o instanceof boolean[]) { print(Arrays.toString((boolean [])o));
    } else if (o instanceof float[]) { print(Arrays.toString((float [])o));
    } else if (o instanceof double[]) { print(Arrays.toString((double [])o));
    } else if (o instanceof Object[]) { print(Arrays.toString((Object [])o));
    } else { print("" + o); }
  }
  void print(String s) { pw.print(s); }
  void println() { println(""); }
  void println(byte b) { println("" + b); }
  void println(int i) { println("" + i); }
  void println(long l) { println("" + l); }
  void println(double d) { println("" + d); }
  void println(char c) { println("" + c); }
  void println(Object o) { print(o); println(); }
  void println(String s) { pw.println(s); }
  int nextInt() throws IOException { return Integer.parseInt(nextToken()); }
  long nextLong() throws IOException { return Long.parseLong(nextToken()); }
  double nextDouble() throws IOException { return Double.parseDouble(nextToken()); }
  char nextChar() throws IOException { return (char) (br.read()); }
  String next() throws IOException { return nextToken(); }
  String nextLine() throws IOException { return br.readLine(); }
  int [] readInt(int size) throws IOException {
    int [] array = new int [size];
    for (int i = 0; i < size; i++) { array[i] = nextInt(); }
    return array;
  }
  long [] readLong(int size) throws IOException {
    long [] array = new long [size];
    for (int i = 0; i < size; i++) { array[i] = nextLong(); }
    return array;
  }
  double [] readDouble(int size) throws IOException {
    double [] array = new double [size];
    for (int i = 0; i < size; i++) { array[i] = nextDouble(); }
    return array;
  }
  String [] readLines(int size) throws IOException {
    String [] array = new String [size];
    for (int i = 0; i < size; i++) { array[i] = nextLine(); }
    return array;
  }

  int gcd(int a, int b) {
    if (a == 0) return Math.abs(b); if (b == 0) return Math.abs(a);
    a = Math.abs(a); b = Math.abs(b);
    int az = Integer.numberOfTrailingZeros(a), bz = Integer.numberOfTrailingZeros(b);
    a >>>= az; b >>>= bz;
    while (a != b) {
      if (a > b) { a -= b; a >>>= Integer.numberOfTrailingZeros(a); }
            else { b -= a; b >>>= Integer.numberOfTrailingZeros(b); }
    }
    return (a << Math.min(az, bz));
  }

  long gcd(long a, long b) {
    if (a == 0) return Math.abs(b); if (b == 0) return Math.abs(a);
    a = Math.abs(a); b = Math.abs(b);
    int az = Long.numberOfTrailingZeros(a), bz = Long.numberOfTrailingZeros(b);
    a >>>= az; b >>>= bz;
    while (a != b) {
      if (a > b) { a -= b; a >>>= Long.numberOfTrailingZeros(a); }
            else { b -= a; b >>>= Long.numberOfTrailingZeros(b); }
    }
    return (a << Math.min(az, bz));
  }
}

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.math.*;
import java.util.InputMismatchException;
public class solution{
	public static void main(String args[]) throws Exception
		{
			InputReader sc = new InputReader(System.in);
			PrintWriter out = new PrintWriter(System.out);
			int n = sc.nextInt();
			int a = sc.nextInt();
			int b = sc.nextInt();
			if(n>=4*a+2*b)
			{
				out.println(1);
			}
			else if(n>=a+b)
			{
				int x = n-(a+b);
				if(x>=a)
				{
					out.println(2);
				}
				else if(x>=b)
				{
					if(n>=3*a)
					{
						out.println(2);
					}
					else if(n>=2*a)
					{
						out.println(3);
					}
					else
					{
						out.println(4);
					}
				}
				else
				{
					if(n>=2*a)
					{
						out.println(3);
					}
					else
					{
						out.println(4);
					}
				}
			}
			else
			{
				int ans = 0;
				if(n>=4*a)
				{
					ans = 1;
				}
				else if(n>=2*a)
				{
					ans = 2;
				}
				else
				{
					ans = 4;
				}
				if(n>=2*b)
				{
					ans+=1;
				}
				else
				{
					ans+=2;
				}
				out.println(ans);
			}
			out.close();
		}
	static class InputReader {

        private InputStream stream;
        private byte[] buf = new byte[8192];
        private int curChar, snumChars;
        private SpaceCharFilter filter;

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

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

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

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

        public int[] nextIntArray(int n) {
            int a[] = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }

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

        public int[] readCharCount() {
            int c = snext();
            while (isSpaceChar(c))
                c = snext();
            int[] map = new int[256];
            do {
                int val = c ;
                map[val]++;
                c = snext();
            } while (!isSpaceChar(c));
            return map;
        }

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

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

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

public class MainB {
	static StdIn in = new StdIn();
	static PrintWriter out = new PrintWriter(System.out);

	public static void main(String[] args) {
		int n=in.nextInt(), a=in.nextInt(), b=in.nextInt();
		int[] c = new int[]{a, a, a, a, b, b}, dp = new int[1<<6];
		for(int i=1; i<1<<6; ++i) {
			int min=Integer.MAX_VALUE;
			for(int j=i; j>0; j=(j-1)&i) {
				int t=0;
				for(int k=0; k<6; ++k)
					if(((j>>k)&1)==1)
						t+=c[k];
				if(t<=n)
					min=Math.min(dp[i^j]+1, min);
			}
			dp[i]=min;
		}
		out.println(dp[(1<<6)-1]);
		out.close();
	}

	interface Input {
		public String next();
		public String nextLine();
		public int nextInt();
		public long nextLong();
		public double nextDouble();
	}
	static class StdIn implements Input {
		final private int BUFFER_SIZE = 1 << 16;
		private DataInputStream din;
		private byte[] buffer;
		private int bufferPointer, bytesRead;
		public StdIn() {
			din = new DataInputStream(System.in);
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}
		public StdIn(InputStream in) {
			try{
				din = new DataInputStream(in);
			} catch(Exception e) {
				throw new RuntimeException();
			}
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}
		public String next() {
			int c;
			while((c=read())!=-1&&(c==' '||c=='\n'||c=='\r'));
			StringBuilder s = new StringBuilder();
			while (c != -1)
			{
				if (c == ' ' || c == '\n'||c=='\r')
					break;
				s.append((char)c);
				c=read();
			}
			return s.toString();
		}
		public String nextLine() {
			int c;
			while((c=read())!=-1&&(c==' '||c=='\n'||c=='\r'));
			StringBuilder s = new StringBuilder();
			while (c != -1)
			{
				if (c == '\n'||c=='\r')
					break;
				s.append((char)c);
				c = read();
			}
			return s.toString();
		}
		public int nextInt() {
			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[] readIntArray(int n) {
			int[] ar = new int[n];
			for(int i=0; i<n; ++i)
				ar[i]=nextInt();
			return ar;
		}
		public long nextLong() {
			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 long[] readLongArray(int n) {
			long[] ar = new long[n];
			for(int i=0; i<n; ++i)
				ar[i]=nextLong();
			return ar;
		}
		public double nextDouble() {
			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() {
			try{
				if (bufferPointer == bytesRead)
					fillBuffer();
				return buffer[bufferPointer++];
			} catch(IOException e) {
				throw new RuntimeException();
			}
		}
		public void close() throws IOException {
			if (din == null)
				return;
			din.close();
		}
	}
}

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

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

		int n = in.nextInt();
		int a = in.nextInt();
		int b = in.nextInt();
		boolean flage = false;

		int ans=0,temp=0;

		if(a+b<=n)
		{
			if(n/(a+b)==1)
			{
				if(a<=n-a-b)
					ans=2;
				else if(2*a<=n)
					ans=3;
				else
					ans=4;
			}
			else if(n/(a+b)>=2)
			{
				if(2*a<=n-2*(a+b))
					ans=1;
				else if(2*a<=n)
					ans=2;
				else
					ans=3;
			}
		}
		else
		{
			if(n/b==1 && n/a==1)
				ans=6;
			if(n/b==1 && (n/a==2 || n/a==3))
				ans=4;
			if(n/b==1 && n/a>=4)
				ans=3;
			if(n/b>=2 && n/a==1)
				ans=5;
			if(n/b>=2 && (n/a==2 || n/a==3))
				ans=3;
			if(n/b>=2 && n/a>=4)
				ans=2;

		}
		System.out.println(ans);
	}

}

import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;
public class Prac{
    static class InputReader {
        private final InputStream stream;
        private final byte[] buf = new byte[8192];
        private int curChar, snumChars;
        public InputReader(InputStream st) {
            this.stream = st;
        }
        public int read() {
            if (snumChars == -1)
                throw new InputMismatchException();
            if (curChar >= snumChars) {
                curChar = 0;
                try {
                    snumChars = stream.read(buf);
                }
                catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (snumChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }
        public int ni() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
        public long nl() {
            int c = read();
            while (isSpaceChar(c)) {
            c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
        public int[] nia(int n) {
            int a[] = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = ni();
            }
            return a;
        }
        public String rs() {
            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 String nextLine() {
            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 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;
        }
    }
    public static class Key {

        private final int x;
        private final int y;

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

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Key)) return false;
            Key key = (Key) o;
            return x == key.x && y == key.y;
        }

        @Override
        public int hashCode() {
            int result = x;
            result = 31 * result + y;
            return result;
        }

    }
    static class Pair{
        int x,y;
        public Pair(int x,int y){
            this.y=y;
            this.x=x;
        }
    }

    static PrintWriter w = new PrintWriter(System.out);
    static long mod=998244353L,mod1=1000000007;

    static void shuffleArray(int[] arr){
        int n = arr.length;
        Random rnd = new Random();
        for(int i=0; i<n; ++i){
            int tmp = arr[i];
            int randomPos = i + rnd.nextInt(n-i);
            arr[i] = arr[randomPos];
            arr[randomPos] = tmp;
        }
    }
    public static void main(String [] args){
        InputReader sc=new InputReader(System.in);
        int n=sc.ni();
        int a=sc.ni(),b=sc.ni();
        int ar[]={a,a,a,a,b,b};
        Arrays.sort(ar);
        int ans=6;
        int s=1000;
        while(s-->0){

            for(int i=1;i<=6;i++){
                int arr[]=new int[i];
                boolean in=false;
                for(int j=5;j>=0;j--){
                    int k=0;
                    boolean f=false;
                    while(k<i){
                        if((arr[k]+ar[j])<=n){
                            arr[k]+=ar[j];
                            f=true;
                            break;
                        }
                        k++;
                    }
                    if(!f)in=true;

                }
                if(!in){
                    ans=Math.min(ans,i);
                    break;
                }
            }
            shuffleArray(ar);
        }
        w.println(ans);
        w.close();
    }
}

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

/*
 public class _910B {

 }

 */
public class _910B {
  public void solve() throws FileNotFoundException {
    InputStream inputStream = System.in;

    InputHelper in = new InputHelper(inputStream);

    // actual solution
    int n = in.readInteger();
    int a = in.readInteger();
    int b = in.readInteger();

    List<Integer> remp = new ArrayList<Integer>();

    for (int i = 0; i < 2; i++)
      remp.add(b);

    for (int i = 0; i < 4; i++)
      remp.add(a);

    rec(remp, new ArrayList<Integer>(), a, b, n);

    System.out.println(ans);
    // end here
  }

  int ans = 6;

  void rec(List<Integer> remp, List<Integer> extp, int a, int b, int n) {
    if (remp.size() == 0) {
      ans = Math.min(ans, extp.size());
      return;
    }

    for (int i = 0; i < remp.size(); i++) {
      int crp = remp.get(i);

      for (int j = 0; j < extp.size(); j++) {
        int cep = extp.get(j);

        if (cep >= crp) {
          List<Integer> nextp = new ArrayList<Integer>(extp);
          List<Integer> nremp = new ArrayList<Integer>(remp);
          nextp.remove(j);
          nremp.remove(i);
          nextp.add(cep - crp);
          rec(nremp, nextp, a, b, n);
        }
      }

      List<Integer> nextp = new ArrayList<Integer>(extp);
      List<Integer> nremp = new ArrayList<Integer>(remp);
      nremp.remove(i);
      nextp.add(n - crp);
      rec(nremp, nextp, a, b, n);
    }
  }

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

  class InputHelper {
    StringTokenizer tokenizer = null;
    private BufferedReader bufferedReader;

    public InputHelper(InputStream inputStream) {
      InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
      bufferedReader = new BufferedReader(inputStreamReader, 16384);
    }

    public String read() {
      while (tokenizer == null || !tokenizer.hasMoreTokens()) {
        try {
          String line = bufferedReader.readLine();
          if (line == null) {
            return null;
          }
          tokenizer = new StringTokenizer(line);
        } catch (IOException e) {
          e.printStackTrace();
        }
      }

      return tokenizer.nextToken();
    }

    public Integer readInteger() {
      return Integer.parseInt(read());
    }

    public Long readLong() {
      return Long.parseLong(read());
    }
  }
}

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

	import javax.sound.midi.Synthesizer;

	public class Main
	{
		private InputStream is;
		private PrintWriter out;
		int time = 0, freq[], start[], end[], dist[], black[], MOD = (int) (1e9 + 7), arr[], weight[][], x[], y[], parent[];
		int MAX = 1000001, N, K;
		long red[], ans = Long.MAX_VALUE;

		ArrayList<Integer>[] amp;
		ArrayList<Pair>[] pmp;
		boolean b[];
		boolean boo[][], b1[];
		Pair prr[];
		HashMap<Pair, Integer> hm = new HashMap();
		int Dp[][] = new int[1100][1100];

		void soln()
		{
			is = System.in;
			out = new PrintWriter(System.out);
			long s = System.currentTimeMillis();
			solve();

			// out.close();
			out.flush();
			// tr(System.currentTimeMillis() - s + "ms");
		}

		 class ST1 // min ST
		{
			int arr[], st[];
			int size;

			ST1(int a[]) {
				arr = a.clone();
				size = 10 * arr.length;
				st = new int[size];
				build(0, arr.length - 1, 1);
			}

			void build(int ss, int se, int si) {
				if (ss == se) {
					st[si] = arr[ss];
					return;
				}
				int mid = (ss + se) / 2;
				int val = 2 * si;
				build(ss, mid, val);
				build(mid + 1, se, val + 1);
				st[si] = gcd(st[val], st[val + 1]);
			}

			/*void update(int ss, int se, int idx, long val, int si) {
				if (ss == se) {
					// if(si==idx+1)
					st[si] = val;
					return;
				}
				int mid = (ss + se) / 2;
				if (ss <= idx && idx <= mid) {
					update(ss, mid, idx, val, 2 * si);
				} else {
					update(mid + 1, se, idx, val, 2 * si + 1);
				}
				int v = 2 * si;
				st[si] = Math.min(st[v], st[v + 1]);
			}*/

			int get(int ss, int se, int l, int r, int si) {
				if (l > se || r < ss || l > r)
					return 0;
				if (l <= ss && r >= se)
					return st[si];
				int mid = (ss + se) / 2;
				int val = 2 * si;
				return gcd(get(ss, mid, l, r, val), get(mid + 1, se, l, r, val + 1));
			}
		}

		public static void main(String[] args) throws Exception
		{
			new Thread(null, new Runnable()
			{
				public void run()
				{
					try
					{
						// new Main().soln();
					} catch (Exception e)
					{
						System.out.println(e);
					}
				}
			}, "1", 1 << 26).start();
			new Main().soln();
		}

		int D[][];
		char ch[][], ch1[];
		int hash = 29;
		int x2, y2;
		HashSet<Integer>[] hs = (HashSet<Integer>[]) new HashSet[110];
		cell[] c;
		 boolean ar[] = new boolean[1000];
		Pair[] p = new Pair[4];
		 int a1[] = new int[7];
		 int a2[] = new int[7];
		 int a3[] = new int[7];
		 int a4[] = new int[7];
		 private static class Comp implements Comparable<Comp>{
				int ind;
				BigInteger v;

				@Override
				public int compareTo(Comp arg0) {
					if(v==arg0.v)
						return this.ind-arg0.ind;
					return this.v.compareTo(arg0.v);
				}
			}
		 private static class Comp1 implements Comparable<Comp1>{
				int ind;
				String v;

				@Override
				public int compareTo(Comp1 arg0) {
					if(v.equals(arg0.v))
						return this.ind-arg0.ind;
					return this.v.compareTo(arg0.v);
				}
			}
		 int N11, a, B;
		 void solve()
		 {
			N11 = ni(); a = ni(); B = ni();
			ans = 10000000;
			permutation("000011");
			System.out.println(ans);
		 }
		 public  void permutation(String str) {
			    permutation("", str);
		}
		 HashSet<String> ss = new HashSet<>();
		private  void permutation(String prefix, String str) {
			    int n = str.length();
			    if (n == 0) {
			    	if(!ss.contains(prefix)) {
			    		char ch[] = prefix.toCharArray();
			    		int cnt = 1, val = N11;
			    		for(int i = 0;i<6;i++) {
			    			if(ch[i]=='0') {
			    				if(val>=a) val -= a;
			    				else {
			    					cnt++; val = N11-a;
			    				}
			    			}
			    			else {
			    				if(val>=B) val -= B;
			    				else {
			    					cnt++; val = N11-B;
			    				}
			    			}
			    		}
			    		ans = Math.min(ans,cnt);
			    	}
			    }
			    else {
			        for (int i = 0; i < n; i++)
			            permutation(prefix + str.charAt(i), str.substring(0, i) + str.substring(i+1, n));
			    }
			}
		 void dfs(int v, int col) {
			 if(col!=arr[v]) {
				 ans++;
				 col = arr[v];
			 }
			 for(int i : amp[v]) {
				 dfs(i,col);
			 }
		 }
		 String check(String[] s) {
			 char ch[] = new char[] {'a','a','a','a'};
			 boolean b = false;
			 for(int i = 0;i<4;i++) {
				 if(i>0) {
					 if(ch[i]=='a') continue;
				 }
				 for(int j = i+1;j<4;j++) {
					 if(!s[i].equals(s[j])) {
						 if(ch[i] == 'a' && ch[j]=='a') ch[j] = 'b';
						 else if(ch[j]=='a') continue;
						 else {
							 System.out.println("NO");
							 System.exit(0);
						 }
					 }
					 else b = true;
				 }
			 }
			 return new String(ch);
		 }
		 boolean isVowel(char c) {
			 if(c=='a' || c=='e' ||c=='i' ||c=='o' ||c=='u' ) return true;
					 return false;
		 }
		 void recur1(int[] a1, int[] a2) {
			 for(int i = 1; i< 7;i++) {
				 for(int j = 1; j< 7;j++) {
					 ar[a1[i]*10+a2[j]] = true;
					 ar[a2[j]*10+a1[i]] = true;
				 }
			 }
		 }
		 int dfs(int x) {
			 b[x] = true;
			 for(int i : amp[x]) {
				 if(!b[i]) {
					 dist[i] = dist[x]+1;
					 arr[x] += dfs(i);
				 }
			 }
			 return ++arr[x];
		 }
		boolean binaryS(int a, int b, int c, int d) {
			double l = 0, r = 90;
			for(int count = 0;count<=300;count++)
			{
				double mid = (l + r) / 2;
				double temp = mid * Math.PI / 180;
				double x1 = Math.cos(temp) * c;
				double x2 = Math.sin(temp) * c;
				temp = Math.PI / 2 - temp;
				double y1 = Math.cos(temp) * d;
				double y2 = Math.sin(temp) * d;
				if ((x1 + y1 <= a) && (x2 + y2 <= b)) return true;
				else if (x1 + y1 > a) l = mid;
				else r = mid;
			}
			return false;
		}
		/*void bfs(int s, int n) {
			b = new boolean[n];
			dist = new int[n];
			Arrays.fill(dist, 1000000);
			dist[s] = 0;
			b[s] = true;
			Queue<Integer> q = new LinkedList<>();
			q.add(s);
			while(!q.isEmpty()) {
				int y = q.poll();
				for(int i : amp[y]) {
					dist[i] = min(dist[i],dist[y]+1);
					if(!b[i]) {
						b[i] = true;
						q.add(i);
					}
				}
			}
		}*/
		boolean check(String s, String s1) {
			char ch1[] = s.toCharArray(), ch2[] = s1.toCharArray();
			int arr[] = new int[10];
			for(char c : ch1) {
				arr[c-'0']++;
			}
			int ans = 0;
			for(char c:ch2) {
				arr[c-'0']--;
			}

			for(int i:arr) ans += ((i>0)?i:0);
			return ans==3;
		}
		void seive(int n)
		{
			start = new int[n];
			for(int i = 2;i<n;i++) {
				if(start[i]==0) {
					for(int j = 2*i;j<n;j+=i) {
						start[j] = i;
					}
				}
			}
		}
		void print(int[][] arr)
		{
			int seed = 110, n = arr.length - 220;
			for (int i = 0; i < n; i++) {
				for (int j = 0; j < n; j++) {
					System.out.print(arr[i + seed][j + seed] + " ");
				}
				System.out.println();
			}
			System.out.println();
		}

		 class cell implements Comparable<cell>
		 {
			int s, d, p, i;

			cell(int t, int d, int p, int i) {
				this.s = t;
				this.p = p;
				this.d = d;
				this.i = i;
			}

			public int compareTo(cell other) {
				// return Integer.compare(val, other.val);
				return Long.compare(d, other.d) != 0 ? (Long.compare(d, other.d)): (Long.compare(i,other.i));
												// other.v));//((Long.compare(u, other.u) != 0 ? (Long.compare(u, other.u)):
												// (Long.compare(v, other.v)))
				// &(Long.compare(u, other.v) != 0 ? (Long.compare(u, other.v)):
				// (Long.compare(v, other.u))));
			}

			public String toString() {
				return this.d + " " + this.s +" "+this.p+" "+this.i;
			}
		}

		int abs(int x)
		{
			return ((x > 0) ? x : -x);
		}

		long ret(int p)
		{
			if (p >= 0)
				return 0;
			else
				return 1;
		}

		long val(int p, int a, int b)
		{
			if (p >= 0) {
				return (a * 1l * p);
			}
			return (b * 1l * p);
		}

		public int getParent(int x)
		{
			while (parent[x] != x) {
				parent[x] = parent[parent[x]];
				x = parent[x];
			}
			return x;
		}

		void getFactors(int n, int x)
		{
			for (int i = 1; i * i <= n; i++) {
				if (n % i == 0) {
					hs[x].add(i);
					hs[x].add(n / i);
				}
			}
		}

		void recur(int a, int b, int k)
		{
			if (k == 0) {
				if (a == x2 && b == y2)
					ans++;
				return;
			}
			recur(a, b + 1, k - 1);
			recur(a, b - 1, k - 1);
			recur(a + 1, b, k - 1);
			recur(a - 1, b, k - 1);
		}

		int min(int a, int b)
		{
			return (a < b) ? a : b;
		}

		/*private class Cell implements Comparable<Cell> {
			int u, v, s;

			public Cell(int u, int v, int s) {
				this.u = u;
				this.v = v;
				this.s = s;
			}

			public int hashCode() {
				return Objects.hash();
			}

			public int compareTo(Cell other) {
				return (Long.compare(s, other.s) != 0 ? (Long.compare(s, other.s))
						: (Long.compare(v, other.v) != 0 ? Long.compare(v, other.v) : Long.compare(u, other.u)))
						& ((Long.compare(s, other.s) != 0 ? (Long.compare(s, other.s))
								: (Long.compare(u, other.v) != 0 ? Long.compare(u, other.v) : Long.compare(v, other.u))));
			}

			public String toString() {
				return this.u + " " + this.v;
			}
		}*/

		class Pair implements Comparable<Pair>
		{
			int u ,v,i;

			Pair(int u, int v) {
				this.u = u;
				this.i = v;
			}

			Pair(int u, int v, int i) {
				this.u = u;
				this.v = v;
				this.i = i;
			}

			public int hashCode() {
				return Objects.hash();
			}

			public boolean equals(Object o) {
				Pair other = (Pair) o;
				return ((u == other.u && v == other.v));
			}

			public int compareTo(Pair other) {
				// return Integer.compare(val, other.val);
				return Long.compare(u, other.u) != 0 ? (Long.compare(u, other.u)) : (Long.compare(i, other.i));// ((Long.compare(u,

			}
			public String toString() {
				return this.u + " " + this.v +" "+this.i;
			}
		}

		long max(long a, long b)
		{
			if (a > b)
				return a;
			return b;
		}

		static class FenwickTree
		{

			int[] array; // 1-indexed array, In this array We save cumulative
							// information to perform efficient range queries and
							// updates

			public FenwickTree(int size) {
				array = new int[size + 1];
			}

			public int rsq(int ind) {
				assert ind > 0;
				int sum = 0;
				while (ind > 0) {
					sum += array[ind];
					// Extracting the portion up to the first significant one of the
					// binary representation of 'ind' and decrementing ind by that
					// number
					ind -= ind & (-ind);
				}
				return sum;
			}

			public int rsq(int a, int b) {
				assert b >= a && a > 0 && b > 0;
				return rsq(b) - rsq(a - 1);
			}

			public void update(int ind, int value) {
				assert ind > 0;
				while (ind < array.length) {
					array[ind] += value;
					// Extracting the portion up to the first significant one of the
					// binary representation of 'ind' and incrementing ind by that
					// number
					ind += ind & (-ind);
				}
			}

			public int size() {
				return array.length - 1;
			}
		}
		void buildGraph(int n)
		{
			for (int i = 0; i < n; i++) {
				int x1 = ni(), y1 = ni();
				amp[x1-1].add(y1-1);
				amp[y1-1].add(x1-1);
			}
		}
		long modInverse(long a, long mOD2)
		{
			return power(a, mOD2 - 2, mOD2);
		}

		long power(long x, long y, long m)
		{
			if (y == 0)
				return 1;
			long p = power(x, y / 2, m) % m;
			p = (p * p) % m;

			return (y % 2 == 0) ? p : (x * p) % m;
		}

		public int gcd(int a, int b)
		{
			if (b == 0)
				return a;
			return gcd(b, a % b);
		}

		/*static class ST
		{
			int arr[], lazy[], n;

			ST(int a) {
				n = a;
				arr = new int[10 * n];
				lazy = new int[10 * n];
			}

			void up(int l, int r, int val) {
				update(0, n - 1, 0, l, r, val);
			}

			void update(int l, int r, int c, int x, int y, int val) {
				if (lazy[c] != 0) {
					lazy[2 * c + 1] += lazy[c];
					lazy[2 * c + 2] += lazy[c];
					if (l == r)
						arr[c] += lazy[c];
					lazy[c] = 0;
				}
				if (l > r || x > y || l > y || x > r)
					return;
				if (x <= l && y >= r)

				{
					lazy[c] += val;
					return;
				}
				int mid = l + r >> 1;
				update(l, mid, 2 * c + 1, x, y, val);
				update(mid + 1, r, 2 * c + 2, x, y, val);
				arr[c] = Math.max(arr[2 * c + 1], arr[2 * c + 2]);
			}

			int an(int ind) {
				return ans(0, n - 1, 0, ind);
			}

			int ans(int l, int r, int c, int ind) {
				if (lazy[c] != 0) {
					lazy[2 * c + 1] += lazy[c];
					lazy[2 * c + 2] += lazy[c];
					if (l == r)
						arr[c] += lazy[c];
					lazy[c] = 0;
				}
				if (l == r)
					return arr[c];
				int mid = l + r >> 1;
				if (mid >= ind)
					return ans(l, mid, 2 * c + 1, ind);
				return ans(mid + 1, r, 2 * c + 2, ind);
			}
		}*/

		public static int[] shuffle(int[] a, Random gen)
		{
			for (int i = 0, n = a.length; i < n; i++) {
				int ind = gen.nextInt(n - i) + i;
				int d = a[i];
				a[i] = a[ind];
				a[ind] = d;
			}
			return a;
		}

		long power(long x, long y, int mod)
		{
			long ans = 1;
			while (y > 0) {
				if (y % 2 == 0) {
					x = (x * x) % mod;
					y /= 2;
				} else {
					ans = (x * ans) % mod;
					y--;
				}
			}
			return ans;
		}

		// To Get Input
		// Some Buffer Methods
		private byte[] inbuf = new byte[1024];
		public int lenbuf = 0, ptrbuf = 0;

		private int readByte()
		{
			if (lenbuf == -1)
				throw new InputMismatchException();
			if (ptrbuf >= lenbuf) {
				ptrbuf = 0;
				try {
					lenbuf = is.read(inbuf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (lenbuf <= 0)
					return -1;
			}
			return inbuf[ptrbuf++];
		}

		private boolean isSpaceChar(int c) {
			return !(c >= 33 && c <= 126);
		}

		private int skip() {
			int b;
			while ((b = readByte()) != -1 && isSpaceChar(b))
				;
			return b;
		}

		private double nd() {
			return Double.parseDouble(ns());
		}

		private char nc() {
			return (char) skip();
		}

		private String ns() {
			int b = skip();
			StringBuilder sb = new StringBuilder();
			while (!(isSpaceChar(b) && b!=' ')) { // when nextLine, (isSpaceChar(b) && b != '
										// ')
				sb.appendCodePoint(b);
				b = readByte();
			}
			return sb.toString();
		}

		private char[] ns(int n) {
			char[] buf = new char[n];
			int b = skip(), p = 0;
			while (p < n && !(isSpaceChar(b))) {
				buf[p++] = (char) b;
				b = readByte();
			}
			return n == p ? buf : Arrays.copyOf(buf, p);
		}

		private char[][] nm(int n, int m) {
			char[][] map = new char[n][];
			for (int i = 0; i < n; i++)
				map[i] = ns(m);
			return map;
		}

		private int[] na(int n) {
			int[] a = new int[n];
			for (int i = 0; i < n; i++)
				a[i] = ni();
			return a;
		}

		private int ni() {
			int num = 0, b;
			boolean minus = false;
			while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
				;
			if (b == '-') {
				minus = true;
				b = readByte();
			}

			while (true) {
				if (b >= '0' && b <= '9') {
					num = num * 10 + (b - '0');
				} else {
					return minus ? -num : num;
				}
				b = readByte();
			}
		}

		private long nl() {
			long num = 0;
			int b;
			boolean minus = false;
			while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
				;
			if (b == '-') {
				minus = true;
				b = readByte();
			}

			while (true) {
				if (b >= '0' && b <= '9') {
					num = num * 10 + (b - '0');
				} else {
					return minus ? -num : num;
				}
				b = readByte();
			}
		}

		private boolean oj = System.getProperty("ONLINE_JUDGE") != null;

		private void tr(Object... o) {
			if (!oj)
				System.out.println(Arrays.deepToString(o));
		}
	}

import java.util.*;
public class DoorFrame {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int a = sc.nextInt();
		int b = sc.nextInt();
		int size = n;
		int barA = 4;
		int barB = 2;
		int count = 0;
		int typeA = size/barA;
		int typeB = size/barB;
		DoorClass door = new DoorClass(barA, barB, n, count, typeA, typeB);
		while (door.barA > 0 || door.barB > 0) {
			getReminder(door, a, b, size);
//			System.out.println((""+a) +"->" + door.typeA +(","+  b) +"->"+ door.typeB);
//			System.out.println();
			door.barA = door.barA - door.typeA;
			door.barB = door.barB - door.typeB;
			door.count++;
		}
//		while (door.barA > 0 || door.barB > 0) {
//			DoorClass door_1 = door;
//			DoorClass door_2 = door;
//			int reminder1 = getReminder(door_1, a, b, size, 1);
//			int reminder2 = getReminder(door_2, a, b, size, 2);
//			if (reminder1 <= reminder2) {
//				door = door_1;
//			}
//			else {
//				door = door_2;
//			}
//		}
//		while (barA > 0 || barB > 0) {
//			if (a >= b) {
//				if (barA != 0) {
//					if (n-a < 0) {
//						n = size;
//						count++;
//					}
//					int typeA = n/a;
//					if (typeA > barA) 		typeA = barA;
//					n = n - typeA*a;
////					System.out.println("n = " + n);
//					barA = barA-typeA;
////					System.out.println("barA ="+barA);
//				}
//				if (barB != 0) {
//					if (n-b < 0) {
//						n = size;
//						count++;
//					}
//					int typeB = n/b;
//					if (typeB > barB) 		typeB = barB;
//					n = n-typeB*b;
////					System.out.println("n = " + n);
//					barB = barB-typeB;
////					System.out.println("barB = "+barB);
////					System.out.println("count="+count);
//				}
//			}
//			else {
//				if (barB != 0) {
//					if (n-b < 0) {
//						n = size;
//						count++;
//					}
//					int typeB = n/b;
//					if (typeB > barB) 		typeB = barB;
//					n = n-typeB*b;
////					System.out.println("n = " + n);
//					barB = barB-typeB;
////					System.out.println("barB = "+barB);
////					System.out.println("count="+count);
//				}
//				if (barA != 0) {
//					if (n-a < 0) {
//						n = size;
//						count++;
//					}
//					int typeA = n/a;
//					if (typeA > barA) 		typeA = barA;
//					n = n - typeA*a;
////					System.out.println("n = " + n);
//					barA = barA-typeA;
////					System.out.println("barA ="+barA);
//				}
//			}
//
//
//		}
		System.out.println(door.count);
		sc.close();
	}
	private static void getReminder(DoorClass door, int a, int b,  int size) {

		int typeA_d = size/a;
		int typeB_d = size/b;
		if (typeA_d > door.barA)	typeA_d = door.barA;
		if (typeB_d > door.barB)	typeB_d = door.barB;
		int minDiff = Integer.MAX_VALUE;
		int n = size;
		int index = (a>=b ? typeA_d : typeB_d);
//		System.out.println("index = " + index);
		if (door.barA == 0)	{
//			System.out.println("door.barA is 0");
			door.typeA = 0;
			door.typeB = typeB_d;
			return;
		}
		if (door.barB == 0) 	{
//			System.out.println("door.barB is 0");
			door.typeA = typeA_d;
			door.typeB = 0;
			return;
		}

		if (index == typeA_d) {
			while (index >= 0) {
				n  = size;
				n = n - index * a;
				int factB = n/b;
				if (factB > 0) {
					if (factB > door.barB) 		factB = door.barB;
					n = n - factB * b;
				}
				if (n < minDiff) {
//					System.out.println("minDiff = " + minDiff);
					minDiff = n;
					door.typeA = index;
					door.typeB = factB;
				}
				if (n == 0) {
					minDiff = n;
					door.typeA = index;
					door.typeB = factB;
				}
//				System.out.println("minDiff = " + minDiff);
				index--;
			}
		}
		else {
			while (index >= 0) {
				n = size;
				n = n - index * b;
				int factA = n/a;
				if (factA > 0) {
					if (factA > door.barA)		factA = door.barA;
					n = n - factA * a;
				}
				if (n < minDiff) {
					minDiff = n;
					door.typeA = factA;
					door.typeB = index;
				}
				if (n == 0) {
					minDiff = n;
//					System.out.println("minDiff = " + minDiff);
					door.typeA = factA;
					door.typeB = index;
					return;
				}
//				System.out.println("minDiff = " + minDiff);
				index--;
			}
		}

		return;
	}
//	private static int getReminder(DoorClass door_d, int a, int b,  int size,  int choice) {
//
//		if (choice == 1) {
//			if (door_d.barA != 0) {
//				if (door_d.n-a < 0) {
//					door_d.n = size;
//					door_d.count++;
//				}
//				int typeA = door_d.n/a;
//				if (typeA > door_d.barA) 		typeA = door_d.barA;
//				door_d.n = door_d.n - typeA*a;
////				System.out.println("n = " + n);
//				door_d.barA = door_d.barA-typeA;
////				System.out.println("barA ="+barA);
//			}
//			if (door_d.barB != 0) {
//				if (door_d.n-b < 0) {
//					door_d.n = size;
//					door_d.count++;
//				}
//				int typeB = door_d.n/b;
//				if (typeB > door_d.barB) 		typeB = door_d.barB;
//				door_d.n = door_d.n-typeB*b;
////				System.out.println("n = " + n);
//				door_d.barB = door_d.barB-typeB;
////				System.out.println("barB = "+barB);
////				System.out.println("count="+count);
//			}
//		}
//		if (choice == 2) {
//			if (door_d.barB != 0) {
//				if (door_d.n-b < 0) {
//					door_d.n = size;
//					door_d.count++;
//				}
//				int typeB = door_d.n/b;
//				if (typeB > door_d.barB) 		typeB = door_d.barB;
//				door_d.n = door_d.n-typeB*b;
////				System.out.println("n = " + n);
//				door_d.barB = door_d.barB-typeB;
////				System.out.println("barB = "+barB);
////				System.out.println("count="+count);
//			}
//			if (door_d.barA != 0) {
//				if (door_d.n-a < 0) {
//					door_d.n = size;
//					door_d.count++;
//				}
//				int typeA = door_d.n/a;
//				if (typeA > door_d.barA) 		typeA = door_d.barA;
//				door_d.n = door_d.n - typeA*a;
////				System.out.println("n = " + n);
//				door_d.barA = door_d.barA-typeA;
////				System.out.println("barA ="+barA);
//			}
//		}
//		return door_d.n;
//	}

	public static class DoorClass {
		public int barA;
		public int barB;
		public int n;
		public int count;
		public int typeA;
		public int typeB;
		public DoorClass(int barA, int barB, int n, int count, int typeA, int typeB) {
			this.barA = barA;
			this.barB = barB;
			this.n = n;
			this.count = count;
			this.typeA = typeA;
			this.typeB = typeB;
		}
	}
}

/*
⣿⣿⣿⣿⣿⣿⡷⣯⢿⣿⣷⣻⢯⣿⡽⣻⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣇⠸⣿⣿⣆⠹⣿⣿⢾⣟⣯⣿⣿⣿⣿⣿⣿⣽⣻⣿⣿⣿⣿⣿⣿⣿
⣿⣿⣿⣿⣿⣿⣻⣽⡿⣿⣎⠙⣿⣞⣷⡌⢻⣟⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣿⣿⣿⣿⣿⣿⡄⠹⣿⣿⡆⠻⣿⣟⣯⡿⣽⡿⣿⣿⣿⣿⣽⡷⣯⣿⣿⣿⣿⣿⣿
⣿⣿⣿⣿⣿⣿⣟⣷⣿⣿⣿⡀⠹⣟⣾⣟⣆⠹⣯⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⢠⡘⣿⣿⡄⠉⢿⣿⣽⡷⣿⣻⣿⣿⣿⣿⡝⣷⣯⢿⣿⣿⣿⣿
⣿⣿⣿⣿⣿⣿⣯⢿⣾⢿⣿⡄⢄⠘⢿⣞⡿⣧⡈⢷⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⢸⣧⠘⣿⣷⠈⣦⠙⢿⣽⣷⣻⣽⣿⣿⣿⣿⣌⢿⣯⢿⣿⣿⣿
⣿⣿⣿⣿⣿⣿⣟⣯⣿⢿⣿⡆⢸⡷⡈⢻⡽⣷⡷⡄⠻⣽⣿⣿⡿⣿⣿⣿⣿⣿⣿⣷⣿⣿⣿⣿⣏⢰⣯⢷⠈⣿⡆⢹⢷⡌⠻⡾⢋⣱⣯⣿⣿⣿⣿⡆⢻⡿⣿⣿⣿
⣿⣿⣿⣿⣿⣿⡎⣿⢾⡿⣿⡆⢸⣽⢻⣄⠹⣷⣟⣿⣄⠹⣟⣿⣿⣟⣿⣿⣿⣿⣿⣿⣽⣿⣿⣿⡇⢸⣯⣟⣧⠘⣷⠈⡯⠛⢀⡐⢾⣟⣷⣻⣿⣿⣿⡿⡌⢿⣻⣿⣿
⣿⣿⣿⣿⣿⣿⣧⢸⡿⣟⣿⡇⢸⣯⣟⣮⢧⡈⢿⣞⡿⣦⠘⠏⣹⣿⣽⢿⣿⣿⣿⣿⣯⣿⣿⣿⡇⢸⣿⣿⣾⡆⠹⢀⣠⣾⣟⣷⡈⢿⣞⣯⢿⣿⣿⣿⢷⠘⣯⣿⣿
⣿⣿⣿⣿⣿⣿⣿⡈⣿⢿⣽⡇⠘⠛⠛⠛⠓⠓⠈⠛⠛⠟⠇⢀⢿⣻⣿⣯⢿⣿⣿⣿⣷⢿⣿⣿⠁⣾⣿⣿⣿⣧⡄⠇⣹⣿⣾⣯⣿⡄⠻⣽⣯⢿⣻⣿⣿⡇⢹⣾⣿
⣿⣿⣿⣿⣿⣿⣿⡇⢹⣿⡽⡇⢸⣿⣿⣿⣿⣿⣞⣆⠰⣶⣶⡄⢀⢻⡿⣯⣿⡽⣿⣿⣿⢯⣟⡿⢀⣿⣿⣿⣿⣿⣧⠐⣸⣿⣿⣷⣿⣿⣆⠹⣯⣿⣻⣿⣿⣿⢀⣿⢿
⣿⣿⣿⣿⣿⣿⣿⣿⠘⣯⡿⡇⢸⣿⣿⣿⣿⣿⣿⣿⣧⡈⢿⣳⠘⡄⠻⣿⢾⣽⣟⡿⣿⢯⣿⡇⢸⣿⣿⣿⣿⣿⣿⡀⢾⣿⣿⣿⣿⣿⣿⣆⠹⣾⣷⣻⣿⡿⡇⢸⣿
⣿⣿⣿⣿⣿⣿⣿⣿⡇⢹⣿⠇⢸⣿⣿⣿⣿⣿⣿⣿⣿⣷⣄⠻⡇⢹⣆⠹⣟⣾⣽⣻⣟⣿⣽⠁⣾⣿⣿⣿⣿⣿⣿⣇⣿⣿⠿⠛⠛⠉⠙⠋⢀⠁⢘⣯⣿⣿⣧⠘⣿
⣿⣿⣿⣿⣿⣿⣿⣿⣿⡈⣿⡃⢼⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⡙⠌⣿⣆⠘⣿⣞⡿⣞⡿⡞⢠⣿⣿⣿⣿⣿⡿⠛⠉⠁⢀⣀⣠⣤⣤⣶⣶⣶⡆⢻⣽⣞⡿⣷⠈⣿
⣿⣿⣿⣿⣿⣿⣿⣿⡿⠃⠘⠁⠉⠉⠉⠉⠉⠉⠉⠉⠉⠙⠛⠛⢿⣄⢻⣿⣧⠘⢯⣟⡿⣽⠁⣾⣿⣿⣿⣿⣿⡃⢀⢀⠘⠛⠿⢿⣻⣟⣯⣽⣻⣵⡀⢿⣯⣟⣿⢀⣿
⣿⣿⣿⣟⣿⣿⣿⣿⣶⣶⡆⢀⣿⣾⣿⣾⣷⣿⣶⠿⠚⠉⢀⢀⣤⣿⣷⣿⣿⣷⡈⢿⣻⢃⣼⣿⣿⣿⣿⣻⣿⣿⣿⡶⣦⣤⣄⣀⡀⠉⠛⠛⠷⣯⣳⠈⣾⡽⣾⢀⣿
⣿⢿⣿⣿⣻⣿⣿⣿⣿⣿⡿⠐⣿⣿⣿⣿⠿⠋⠁⢀⢀⣤⣾⣿⣿⣿⣿⣿⣿⣿⣿⣌⣥⣾⡿⣿⣿⣷⣿⣿⢿⣷⣿⣿⣟⣾⣽⣳⢯⣟⣶⣦⣤⡾⣟⣦⠘⣿⢾⡁⢺
⣿⣻⣿⣿⡷⣿⣿⣿⣿⣿⡗⣦⠸⡿⠋⠁⢀⢀⣠⣴⢿⣿⣽⣻⢽⣾⣟⣷⣿⣟⣿⣿⣿⣳⠿⣵⣧⣼⣿⣿⣿⣿⣿⣾⣿⣿⣿⣿⣿⣽⣳⣯⣿⣿⣿⣽⢀⢷⣻⠄⠘
⣿⢷⣻⣿⣿⣷⣻⣿⣿⣿⡷⠛⣁⢀⣀⣤⣶⣿⣛⡿⣿⣮⣽⡻⣿⣮⣽⣻⢯⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣯⢀⢸⣿⢀⡆
⠸⣟⣯⣿⣿⣷⢿⣽⣿⣿⣷⣿⣷⣆⠹⣿⣶⣯⠿⣿⣶⣟⣻⢿⣷⣽⣻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⢀⣯⣟⢀⡇
⣇⠹⣟⣾⣻⣿⣿⢾⡽⣿⣿⣿⣿⣿⣆⢹⣶⣿⣻⣷⣯⣟⣿⣿⣽⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⢀⡿⡇⢸⡇
⣿⣆⠹⣷⡻⣽⣿⣯⢿⣽⣻⣿⣿⣿⣿⣆⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠛⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠇⢸⣿⠇⣼⡇
⡙⠾⣆⠹⣿⣦⠛⣿⢯⣷⢿⡽⣿⣿⣿⣿⣆⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠃⠎⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠏⢀⣿⣾⣣⡿⡇
⣿⣷⡌⢦⠙⣿⣿⣌⠻⣽⢯⣿⣽⣻⣿⣿⣿⣧⠩⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡏⢰⢣⠘⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠃⢀⢀⢿⣞⣷⢿⡇
⣿⣽⣆⠹⣧⠘⣿⣿⡷⣌⠙⢷⣯⡷⣟⣿⣿⣿⣷⡀⡹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣈⠃⣸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠟⢀⣴⡧⢀⠸⣿⡽⣿⢀
⢻⣽⣿⡄⢻⣷⡈⢿⣿⣿⢧⢀⠙⢿⣻⡾⣽⣻⣿⣿⣄⠌⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠛⢁⣰⣾⣟⡿⢀⡄⢿⣟⣿⢀
⡄⢿⣿⣷⢀⠹⣟⣆⠻⣿⣿⣆⢀⣀⠉⠻⣿⡽⣯⣿⣿⣷⣈⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠋⢀⣠⠘⣯⣷⣿⡟⢀⢆⠸⣿⡟⢸
⣷⡈⢿⣿⣇⢱⡘⢿⣷⣬⣙⠿⣧⠘⣆⢀⠈⠻⣷⣟⣾⢿⣿⣆⠹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠋⣠⡞⢡⣿⢀⣿⣿⣿⠇⡄⢸⡄⢻⡇⣼
⣿⣷⡈⢿⣿⡆⢣⡀⠙⢾⣟⣿⣿⣷⡈⠂⠘⣦⡈⠿⣯⣿⢾⣿⣆⠙⠻⠿⠿⠿⠿⡿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠿⠛⢋⣠⣾⡟⢠⣿⣿⢀⣿⣿⡟⢠⣿⢈⣧⠘⢠⣿
⣿⣿⣿⣄⠻⣿⡄⢳⡄⢆⡙⠾⣽⣿⣿⣆⡀⢹⡷⣄⠙⢿⣿⡾⣿⣆⢀⡀⢀⢀⢀⢀⢀⢀⢀⢀⢀⢀⢀⢀⣀⣠⣴⡿⣯⠏⣠⣿⣿⡏⢸⣿⡿⢁⣿⣿⢀⣿⠆⢸⣿
⣿⣿⣿⣿⣦⡙⣿⣆⢻⡌⢿⣶⢤⣉⣙⣿⣷⡀⠙⠽⠷⠄⠹⣿⣟⣿⣆⢙⣋⣤⣤⣤⣄⣀⢀⢀⢀⢀⣾⣿⣟⡷⣯⡿⢃⣼⣿⣿⣿⠇⣼⡟⣡⣿⣿⣿⢀⡿⢠⠈⣿
⣿⣿⣿⣿⣿⣷⣮⣿⣿⣿⡌⠁⢤⣤⣤⣤⣬⣭⣴⣶⣶⣶⣆⠈⢻⣿⣿⣆⢻⣿⣿⣿⣿⣿⣿⣷⣶⣤⣌⣉⡘⠛⠻⠶⣿⣿⣿⣿⡟⣰⣫⣴⣿⣿⣿⣿⠄⣷⣿⣿⣿
*/
import java.util.*;

public class Main{

	public static void main(String[] args) {

		Scanner s=new Scanner(System.in);

		int n=s.nextInt();

		int a=s.nextInt();
		int b=s.nextInt();
		ArrayList<Integer> list=new ArrayList<>();
		help(n,a,b,0,0,0,list,0);
		Collections.sort(list);
		System.out.println(list.get(0)+1);

	}
	public static void help(int n,int a,int b,int ans,int d,int t,ArrayList<Integer> list,int r) {

		if(d==4&&t==2) {
			list.add(r);
			return;
		}

		if(d<4&&ans+a<=n) {
			help(n,a,b,ans+a,d+1,t,list,r);
		}else if(d<4){
			help(n,a,b,a,d+1,t,list,r+1);
		}

		if(t<2&&ans+b<=n) {
			help(n,a,b,ans+b,d,t+1,list,r);
		}else if(t<2){
			help(n,a,b,ans+b,d,t+1,list,r+1);
		}

	}
}

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

    static class TaskB {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int n = in.nextInt(), a = in.nextInt(), b = in.nextInt();
            int cntA = 4, cntB = 2;

            int cnt = 1, remain = n;
            while (cntA > 0 || cntB > 0) {
                int upper = 0;
                int cnti = 0, cntj = 0;
                for (int i = 0; i <= cntA; ++i) {
                    for (int j = 0; j <= cntB; ++j) {
                        int tmp = i * a + j * b;
                        if (tmp <= remain) {
                            if (tmp > upper) {
                                upper = tmp;
                                cnti = i;
                                cntj = j;
                            } else if (tmp == upper) {
                                if ((a > b && i > cnti) || (a < b && i < cnti)) {
                                    cnti = i;
                                    cntj = j;
                                }
                            }
                        }
                    }
                }
                if (cnti == 0 && cntj == 0) {
                    ++cnt;
                    remain = n;
                } else {
                    remain -= upper;
                    cntA -= cnti;
                    cntB -= cntj;
                }
            }
            out.println(cnt);
        }

    }
}

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

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

    static class TaskB {
        static int ans = 12312312;
        static int a = 0;
        static int b = 0;
        static int n = 0;

        public void solve(int testNumber, InputReader sc, PrintWriter w) {
            n = sc.nextInt();
            a = sc.nextInt();
            b = sc.nextInt();

            char c[] = {'a', 'a', 'a', 'a', 'b', 'b'};
            ans = 123123123;
            permute(c, 0, c.length - 1);
            w.println(ans);
        }

        private void permute(char[] c, int l, int r) {
            if (l == r) {
                int curr = 1;
                int len = n;

                for (char ch : c) {
                    if (ch == 'a') {
                        if (len >= a)
                            len -= a;
                        else {
                            len = n;
                            curr++;
                            len -= a;
                        }
                    } else {
                        if (len >= b)
                            len -= b;
                        else {
                            len = n;
                            curr++;
                            len -= b;
                        }
                    }
                }

                ans = Math.min(ans, curr);
            } else {
                for (int i = l; i <= r; i++) {
                    swap(c, l, i);
                    permute(c, l + 1, r);
                    swap(c, l, i);
                }
            }
        }

        private void swap(char[] c, int l, int i) {
            char temp = c[l];
            c[l] = c[i];
            c[i] = temp;
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.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 nextInt() {
            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 boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

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

        }

    }
}

import java.util.Scanner;

public class main {
	public static void main(String[] args){
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();
		int a = s.nextInt();
		int b = s.nextInt();
		int aNum = 4;
		int bNum = 2;
		int result = 0;
		for(int x = 0; x < 8; x++){
			int maxLength = 0;
			int maxA = 0;
			int maxB = 0;

			if(x == 7){
				System.out.println("INPUT ERROR");
				return;
			}else if(bNum == 0 && aNum == 0)
				break;

			result++;

			for(int j = bNum; j >= 0; j--){
				for(int i = aNum; i >= 0; i--){
					if((i*a)+(j*b) <= n && (i*a)+(j*b) > maxLength){
						maxA = i;
						maxB = j;
						maxLength = (i*a)+(j*b);
					}
				}
			}
			aNum -= maxA;
			bNum -= maxB;

		}
		System.out.println(result);
	}
}

//package test14;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;

public class B {
	InputStream is;
	PrintWriter out;
	String INPUT = "";

	void solve()
	{
		int[][] dp = new int[5][3];
		for(int i = 0;i < 5;i++){
			Arrays.fill(dp[i], 99999999);
		}
		dp[0][0] = 0;
		int n = ni(), a = ni(), b = ni();
		for(int i = 0;i < 5;i++){
			for(int j = 0;j < 3;j++){
				for(int k = 0;a*k <= n;k++){
					int l = (n-a*k)/b;
					int ni = Math.min(i+k, 4);
					int nj = Math.min(j+l, 2);
					dp[ni][nj] = Math.min(dp[ni][nj],
							dp[i][j] + 1);
				}
			}
		}
		out.println(dp[4][2]);
	}

	void run() throws Exception
	{
		is = oj ? System.in : new ByteArrayInputStream(INPUT.getBytes());
		out = new PrintWriter(System.out);

		long s = System.currentTimeMillis();
		solve();
		out.flush();
		tr(System.currentTimeMillis()-s+"ms");
	}

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

	private byte[] inbuf = new byte[1024];
	public int lenbuf = 0, ptrbuf = 0;

	private int readByte()
	{
		if(lenbuf == -1)throw new InputMismatchException();
		if(ptrbuf >= lenbuf){
			ptrbuf = 0;
			try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
			if(lenbuf <= 0)return -1;
		}
		return inbuf[ptrbuf++];
	}

	private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
	private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }

	private double nd() { return Double.parseDouble(ns()); }
	private char nc() { return (char)skip(); }

	private String ns()
	{
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	private char[] ns(int n)
	{
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while(p < n && !(isSpaceChar(b))){
			buf[p++] = (char)b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	private char[][] nm(int n, int m)
	{
		char[][] map = new char[n][];
		for(int i = 0;i < n;i++)map[i] = ns(m);
		return map;
	}

	private int[] na(int n)
	{
		int[] a = new int[n];
		for(int i = 0;i < n;i++)a[i] = ni();
		return a;
	}

	private int ni()
	{
		int num = 0, b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}

		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private long nl()
	{
		long num = 0;
		int b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}

		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
	private void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}

/*import java.util.*;

public class CodeForces910C{
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int n = input.nextInt();
		int a = input.nextInt();
		int b = input.nextInt();
		int count_a = n/a;
		int count_b = (n%a)/b;
		int ans = 1;
		if(count_a == 1){
			ans+= 3;
			if(count_b == 1){
				count_b = 2;
			}
		}
		else if(count_a >= 4){
			count_b = (n-(a*4))/b;
			//System.out.println(count_b);
			ans = 1;
		}
		else{
			count_b = Math.max(count_b,(n-((4-count_a)*a))/b);
			ans++;
		}
		if(count_b == 0){
			if(n/b >= 2){
				ans++;
			}
			else{
				ans+=2;
			}
		}
		else if(count_b < 2){
			ans++;
		}

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

import java.util.*;
public class CodeForces910C {

	public static void main(String args[])
	{
		Scanner sc=new Scanner (System.in);
		int n=sc.nextInt();
		int a=sc.nextInt();
		int b=sc.nextInt();
		int ans=1,x=0,y=0,z=n;

		while(x<4 || y<2)
		{
			if (z>=a & x<4)
			{
				z-=a;
				x+=1;
			}
			if (z>=b & y<2)
			{
				z-=b;
				y+=1;
			}
			if(x==4 & y==2)
				break;
			if ((z<a || x==4) && (z<b || y==2))
			{
				z = n ;
				ans+=1;
			}
		}
		System.out.println(ans);
			sc.close();
	}

}

import java.util.*;

public class door_frames {
    public static int[] swap(int data[], int left, int right)
    {

        int temp = data[left];
        data[left] = data[right];
        data[right] = temp;
        return data;
    }
    public static int[] reverse(int data[], int left, int right)
    {
        while (left < right) {
            int temp = data[left];
            data[left++] = data[right];
            data[right--] = temp;
        }

        return data;
    }

    public static boolean findNextPermutation(int data[])
    {
        if (data.length <= 1)
            return false;

        int last = data.length - 2;

        while (last >= 0) {
            if (data[last] < data[last + 1]) {
                break;
            }
            last--;
        }
     if (last < 0)
            return false;

        int nextGreater = data.length - 1;

        for (int i = data.length - 1; i > last; i--) {
            if (data[i] > data[last]) {
                nextGreater = i;
                break;
            }
        }

        data = swap(data, nextGreater, last);
        data = reverse(data, last + 1, data.length - 1);
        return true;
    } 	public static void main(String ar[])
	{
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
	    int a=sc.nextInt(),b=sc.nextInt(),min=1000000000;
	    int arr[]=  {a,a,a,a,b,b};
	    Arrays.sort(arr);
	    /*for(int i=0;i<6;i++)
		System.out.print(arr[i]+"  ");
	    System.out.println();
	    */
	    int c=0;
	    do
	    {
	    	/*for(int i=0;i<6;i++)
	    	{
	    		System.out.print(arr[i]+"  ");
	    	}
	    	System.out.println();
	    	*/

	    	c=0;
	       int left=0;
	        for(int i=0;i<6;i++)
	        {
	            if(left-arr[i]>=0)
	            {
	                left-=arr[i];
	            }
	            else
	            {
	                c++;
	                left=n-arr[i];
	            }
	        }

	        min=Math.min(c,min);
	    }while((findNextPermutation(arr)));
		System.out.println(min);

	}
}

import java.util.*;

public class Solution {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int n, a, b, ret = 0;
        ArrayList<Integer> pieces = new ArrayList<Integer>();
        ArrayList<Integer> ans = new ArrayList<Integer>();
        n = sc.nextInt();
        a = sc.nextInt();
        b = sc.nextInt();
        ans.add(n);
        for (int i = 0; i < 4; i++) {
            if (i < 2) {
                pieces.add(b);
            }
            pieces.add(a);
        }
        Collections.sort(pieces, Collections.reverseOrder());
        int sz;
        ret = 1;
        if ((a * 2 + b) == n) {
            System.out.println(2);
        } else {
            for (int i = 0; i < 6; i++) {
                int p = 0;
                boolean done = false;
                sz = ans.size();
                for (int j = 0; j < sz; j++) {
                    if (pieces.get(i) <= ans.get(j) && ans.get(j) != 0) {
                        p = ans.remove(j) - pieces.get(i);
                        ans.add(p);
                        done = true;
                        break;
                    }
                }
                if (!done) {
                    p = n - pieces.get(i);
                    ans.add(p);
                }
            }
            System.out.println(ans.size());
        }

    }
}

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

import static java.util.stream.Collectors.toList;

public class Solution {

    static MyScanner sc;
    private static PrintWriter out;
    static long M2 = 1_000_000_000L + 7;

    private static HashMap<Long, Long>[] mods;

    public static void main(String[] s) throws Exception {
        StringBuilder stringBuilder = new StringBuilder();
//        stringBuilder.append(" 4 0 3 2 1 0 3 2 1 ");
        if (stringBuilder.length() == 0) {
            sc = new MyScanner(System.in);
        } else {
            sc = new MyScanner(new BufferedReader(new StringReader(stringBuilder.toString())));
        }

        out = new PrintWriter(new OutputStreamWriter(System.out));

        initData();
        solve();
        out.flush();
    }

    private static void initData() {
    }

    static int k;

    private static void solve() throws IOException {
        int n = sc.nextInt();
        int r1 = sc.nextInt();
        int r2 = sc.nextInt();
        int[] x = new int[6];
        for (int i = 0; i < 4; i++) {
            x[i] = r1;
        }
        x[4] = r2;
        x[5] = r2;
        for (int k = 1; k <= 8; k++) {
            int[] d = new int[k];
            Arrays.fill(d, n);

            if (v(d, x, 0)) {
                out.println(k);
                return;
            }
        }

    }

    private static boolean v(int[] k, int[] r1, int l) {
        if (l == r1.length) return true;
        for (int t = 0; t < k.length; t++) {
            if (k[t] < r1[l]) continue;
            k[t] -= r1[l];
            if (v(k, r1, l + 1)) {
                return true;
            }
            k[t] += r1[l];
        }
        return false;
    }

    private static final class Type {
        int v;

        public Type(int v) {
            this.v = v;
        }

        int c;

        public Type(int v, int c) {
            this.v = v;
            this.c = c;
        }

        public Type copy() {
            return new Type(v, c);

        }
    }

    private static class Col {

    }

    private static int get(int i, int i1) {
//        int[] nn = new int[]{6, 7, 4, 5, 0, 1, 8, 9, 2, 3};
//        int[] rr = new int[nn.length];
//        for (int k = 0; k < nn.length; k++) {
//            rr[nn[k]] = k;
//        }
//        return nn[i] ^ rr[i1];
//
        out.println("? " + i + " " + i1);
        out.flush();
        return sc.nextInt();
    }

    private static boolean solve(int n, int p, int p1, int i) {
        return false;
    }

    private static boolean isset(long i, int k) {
        return (i & (1 << k)) > 0;
    }

    private static void solveT() throws IOException {
        int t = sc.nextInt();
        while (t-- > 0) {
            solve();
        }
    }

    private static long gcd(long l, long l1) {
        if (l > l1) return gcd(l1, l);
        if (l == 0) return l1;
        return gcd(l1 % l, l);
    }

    private static long pow(long a, long b, long m) {
        if (b == 0) return 1;
        if (b == 1) return a;
        long pp = pow(a, b / 2, m);
        pp *= pp;
        pp %= m;
        return (pp * (b % 2 == 0 ? 1 : a)) % m;
    }

    static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        MyScanner(BufferedReader br) {
            this.br = br;
        }

        public MyScanner(InputStream in) {
            this(new BufferedReader(new InputStreamReader(in)));
        }

        void findToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }

        String next() {
            findToken();
            return st.nextToken();
        }

        Integer[] nab(int n) {
            Integer[] k = new Integer[n];
            for (int i = 0; i < n; i++) {
                k[i] = sc.fi();
            }
            return k;
        }

        int[] na(int n) {
            int[] k = new int[n];
            for (int i = 0; i < n; i++) {
                k[i] = sc.fi();
            }
            return k;
        }

        long[] nl(int n) {
            long[] k = new long[n];
            for (int i = 0; i < n; i++) {
                k[i] = sc.nextLong();
            }
            return k;
        }

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

        int fi() {
            String t = next();
            int cur = 0;
            boolean n = t.charAt(0) == '-';
            for (int a = n ? 1 : 0; a < t.length(); a++) {
                cur = cur * 10 + t.charAt(a) - '0';
            }
            return n ? -cur : cur;
        }

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

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

}

import java.io.*;
import java.util.Arrays;
import java.util.StringJoiner;
import java.util.StringTokenizer;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Consumer;
import java.util.function.Function;

public class Main {

    static int N, A, B;

    public static void main(String[] args) {
        FastScanner sc = new FastScanner(System.in);
        N = sc.nextInt();
        A = sc.nextInt();
        B = sc.nextInt();

        System.out.println(solve());
    }

    static int solve() {
        int[] array = {A, A, A, A, B, B};

        AtomicInteger ans = new AtomicInteger(6);
        heapPermutation(array, 6, arr -> {
            ans.set( Math.min(calc(arr), ans.get()));
        });
        return ans.get();
    }

    static int calc(int[] A) {
        int ret = 1;
        int bar = N;
        for (int a : A) {
            if (a > bar) {
                ret++;
                bar = N;
            }
            bar -= a;
        }
        return ret;
    }

    static void heapPermutation(int[] arr, int size, Consumer<int[]> c) {
        if (size == 1) {
            c.accept(arr);
        }

        for (int i = 0; i < size; i++) {
            heapPermutation(arr, size-1, c);

            if (size % 2 == 1) {
                int temp = arr[0];
                arr[0] = arr[size-1];
                arr[size-1] = temp;

            } else {
                int temp = arr[i];
                arr[i] = arr[size-1];
                arr[size-1] = temp;
            }
        }
    }

    @SuppressWarnings("unused")
    static class FastScanner {
        private BufferedReader reader;
        private StringTokenizer tokenizer;

        FastScanner(InputStream in) {
            reader = new BufferedReader(new InputStreamReader(in));
            tokenizer = null;
        }

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

        String nextLine() {
            if (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    return reader.readLine();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken("\n");
        }

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

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

        int[] nextIntArray(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++) a[i] = nextInt();
            return a;
        }

        int[] nextIntArray(int n, int delta) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++) a[i] = nextInt() + delta;
            return a;
        }

        long[] nextLongArray(int n) {
            long[] a = new long[n];
            for (int i = 0; i < n; i++) a[i] = nextLong();
            return a;
        }
    }

    static <A> void writeLines(A[] as, Function<A, String> f) {
        PrintWriter pw = new PrintWriter(System.out);
        for (A a : as) pw.println(f.apply(a));
        pw.flush();
    }

    static void writeLines(int[] as) {
        PrintWriter pw = new PrintWriter(System.out);
        for (int a : as) pw.println(a);
        pw.flush();
    }

    static void writeLines(long[] as) {
        PrintWriter pw = new PrintWriter(System.out);
        for (long a : as) pw.println(a);
        pw.flush();
    }

    static void writeSingleLine(int[] as) {
        PrintWriter pw = new PrintWriter(System.out);
        for (int i = 0; i < as.length; i++) {
            if (i != 0) pw.print(" ");
            pw.print(i);
        }
        pw.println();
        pw.flush();
    }

    static int max(int... as) {
        int max = Integer.MIN_VALUE;
        for (int a : as) max = Math.max(a, max);
        return max;
    }

    static int min(int... as) {
        int min = Integer.MAX_VALUE;
        for (int a : as) min = Math.min(a, min);
        return min;
    }

    static int lowerBound(int[] array, int value) {
        int low = 0;
        int high = array.length;
        int mid;
        while (low < high) {
            mid = ((high - low) >>> 1) + low;
            if (array[mid] < value) low = mid + 1;
            else high = mid;
        }
        return low;
    }

    static int upperBound(long[] array, long value) {
        int low = 0;
        int high = array.length;
        int mid;
        while (low < high) {
            mid = ((high - low) >>> 1) + low;
            if (array[mid] <= value) low = mid + 1;
            else high = mid;
        }
        return low;
    }

    static void debug(Object... args) {
        StringJoiner j = new StringJoiner(" ");
        for (Object arg : args) {
            if (arg instanceof int[]) j.add(Arrays.toString((int[]) arg));
            else if (arg instanceof long[]) j.add(Arrays.toString((long[]) arg));
            else if (arg instanceof double[]) j.add(Arrays.toString((double[]) arg));
            else if (arg instanceof Object[]) j.add(Arrays.toString((Object[]) arg));
            else j.add(arg.toString());
        }
        System.err.println(j.toString());
    }
}

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

public class Main {

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

		int acount=4;
		int bcount=2;
		int count =0;
		while(acount!=0 || bcount!=0) {
			int temp=n;
			count++;
			while(temp>=a && acount!=0  || temp>=b &&  bcount!=0) {
			if(temp>=a && acount>0) {
				temp-=a;
				acount-=1;
			}	if(temp>=b && bcount>0) {
				temp-=b;
				bcount-=1;
			}
			}
		}

			System.out.println(count);

	}

}

import java.util.Scanner;

/**
 * Created by ASUS on 27/01/2018.
 */
public class BDoorFrames {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        length = in.nextInt();
        a = in.nextInt();
        b = in.nextInt();
        min = 4 * a + 2 * b;
        howMany(0, 0, 0, 0);
        System.out.println(min);
    }

    static int length;

    static int b;
    static int a;

    static int min;

    static void howMany(int tillNow, int aNum, int bNum, int remaineder) {
        if (aNum == 4 && bNum == 2) {
            if (tillNow < min) {
                min = tillNow;
                return;
            }
        }
        if (aNum < 4) {
            if (remaineder >= a) {
                howMany(tillNow, aNum + 1, bNum, remaineder - a);
            } else {
                howMany(tillNow + 1, aNum + 1, bNum, length - a);
            }
        }
        if (bNum < 2) {
            if (remaineder >= b) {
                howMany(tillNow, aNum, bNum + 1, remaineder - b);
            } else {
                howMany(tillNow + 1, aNum, bNum + 1, length - b);
            }
        }
    }

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.FilterInputStream;
import java.io.BufferedInputStream;
import java.io.InputStream;

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

    static class TaskB {
        public void solve(int testNumber, ScanReader in, PrintWriter out) {
            int a = in.scanInt(), temp1;
            int b = in.scanInt();
            int c = in.scanInt();
            int bb = 4;
            int cc = 2;
            int ans = 0;

            while (!(bb == 0 && cc == 0)) {
                int max1 = -1;
                int max2 = -1;
                int maxx = -1;
                for (int i = 0; i <= bb; i++) {
                    temp1 = (i * b);
                    if (temp1 > a) continue;
                    ;
                    for (int j = 0; j <= cc; j++) {
                        if (temp1 + (j * c) <= a && temp1 + (j * c) >= maxx) {
                            maxx = temp1 + (j * c);
                            max1 = i;
                            max2 = j;
                        }
                    }
                }
                bb -= max1;
                cc -= max2;
                ans++;
            }
            out.println(ans);
        }

    }

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

        public ScanReader(InputStream inputStream) {
            in = new BufferedInputStream(inputStream);
        }

        private int scan() {
            if (index >= total) {
                index = 0;
                try {
                    total = in.read(buf);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                if (total <= 0) return -1;
            }
            return buf[index++];
        }

        public int scanInt() {
            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();
                }
            }
            return neg * integer;
        }

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

    }
}

//package A;
/**
 * Created by Eesaa on 12/25/2017.
 */

import java.util.*;

public class B_910 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt(), a = in.nextInt(), b = in.nextInt(), res;
        //check if n can cover all
        if(n>=2*b+4*a)
        {
            System.out.println(1);
            return;
        }
        //check if n can cover one completely
        if(n>=2*a+b)
        {
            System.out.println(2);
            return;
        }
        if((n>=a+b && n>=2*a) || n>=4*a)
        {
            System.out.println(3);
            return;
        }
        //check if n can cover 2a or a+b
        if((n>=2*a && (n<a+b)) || (n>=a+b && n<2*a)) {
            System.out.println(4);
            return;
        }
        if(n>=2*b)
        {
            System.out.println(5);
            return;
        }
        System.out.println(6);
        in.close();
    }
}

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

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

    static class TaskB {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.nextInt();
            int a = in.nextInt();
            int b = in.nextInt();

            int m = n;
            int cta = 4;
            int ctb = 2;
            int ct = 1;

            while (true) {
                if (cta > 0 && m >= a) {
                    cta--;
                    m -= a;
                }

                if (ctb > 0 && m >= b) {
                    ctb--;
                    m -= b;
                }

                if (cta == 0 && ctb == 0)
                    break;

                if ((cta > 0 && m >= a) || (ctb > 0 && m >= b)) {

                } else {
                    ct++;
                    m = n;
                }
            }

            out.println(ct);
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

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

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

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

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

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.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 nextInt() {
            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 boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

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

        }

    }
}

import java.util.Scanner;

public class B_Door_Frames {

	@SuppressWarnings("resource")
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int n = input.nextInt();
		int a = input.nextInt();
		int b = input.nextInt();
		if (2 * b + 4 * a <= n){
			System.out.println(1);
		}else if (b + 2 * a <= n){
			System.out.println(2);
		}else if (4 * a <= n || 2 * b <= n && 2 * a <= n || a + b <= n && 2 * a <= n){
			System.out.println(3);
		}else if (a + b <= n || 2 * a <= n){
			System.out.println(4);
		}else if (2 * b <= n){
			System.out.println(5);
		}else{
			System.out.println(6);
		}
	}

}

// package cf910;

import java.io.IOException;
import java.io.InputStream;
import java.math.BigInteger;
import java.util.*;

public class CFB {
    static FastScanner sc;
    static int count = 7;
    static int[] as;

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

        int n = sc.nextInt();
        int a = sc.nextInt();
        int b = sc.nextInt();

        List<Integer> list = new ArrayList<>(Arrays.asList(a, a, a, a, b, b));
        dfs(list, n);
        System.out.println(count);
    }

    static void dfs(List<Integer> list, int n) {
        if (list.size() < count) {
            if (list.stream().allMatch(i -> i <= n)) count = list.size();
        }

        for (int i = 0; i < list.size(); i++) {
            for (int j = i+1; j < list.size(); j++) {
                List<Integer> newList = new ArrayList<>(list);
                Integer e1 = newList.remove(j);
                Integer e2 = newList.remove(i);
                newList.add(e1+e2);
                dfs(newList, n);
            }
        }
    }

    //********************************************************************************************
    //********************************************************************************************
    //********************************************************************************************

    private static int min(int... values) {
        if (values.length == 0) return -1;

        int ret = values[0];
        for (int val : values) ret = Math.min(ret, val);
        return ret;
    }

    private static int max(int... values) {
        if (values.length == 0) return -1;

        int ret = values[0];
        for (int val : values) ret = Math.max(ret, val);
        return ret;
    }

    private static int ceil(double d) {
        int ret = (int) d;
        return ret == d ? ret : ret + 1;
    }

    private static int round(double d) {
        return (int) (d + 0.5);
    }

    @SuppressWarnings("SameParameterValue")
    private static <T> T elvis(T obj, T defValue) {
        return obj == null ? defValue : obj;
    }

    private static int gcd(int a, int b) {
        BigInteger b1 = BigInteger.valueOf(a);
        BigInteger b2 = BigInteger.valueOf(b);
        BigInteger gcd = b1.gcd(b2);
        return gcd.intValue();
    }

    private static int[] readIntArray(int n) {
        int[] res = new int[n];
        for (int i = 0; i < n; i++) {
            res[i] = sc.nextInt();
        }
        return res;
    }

    private static long[] readLongArray(int n) {
        long[] res = new long[n];
        for (int i = 0; i < n; i++) {
            res[i] = sc.nextLong();
        }
        return res;
    }

    @SuppressWarnings("unused")
    static class FastScanner {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

        FastScanner(InputStream stream) {
            this.stream = stream;
        }

        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++];
        }

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

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

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

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

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

        public String next() {
            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 String nextLine() {
            int c = read();
            while (isEndline(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndline(c));
            return res.toString();
        }
    }
}

import java.io.*;
import java.util.*;
public class AA {
	public static void main(String[] args)throws Throwable {
		MyScanner sc=new MyScanner();
		PrintWriter pw=new PrintWriter(System.out);

		l=sc.nextInt();
		a=sc.nextInt();
		b=sc.nextInt();
		pw.println(solve(4, 2));
		pw.flush();
		pw.close();
	}
	static int l,a,b;

	static int solve(int ca,int cb){
		if(ca==0)
			return (cb+l/b-1)/(l/b);
		if(ca==0 && cb==0)
			return 0;
		int ans=600;
		for(int i=1;i<=ca;i++)
			if(l>=i*a)
				ans=Math.min(ans, 1+solve(ca-i, Math.max(0, cb-(l-i*a)/b)));

		return ans;
	}

	static class MyScanner {
		BufferedReader br;
		StringTokenizer st;
		public MyScanner() {
			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;}
	}
}

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

public class Solution{

	static class FastReader {
        BufferedReader br;
        StringTokenizer st;

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

	public static void main(String[] args){
    	FastReader sc = new FastReader();
        int n = sc.nextInt();
        int a = sc.nextInt();
        int b = sc.nextInt();

        int[][] dp = new int[5][3];
        int[][] rem = new int[5][3];

        for(int i=1;i<=4;i++){
            if(rem[i-1][0]>=a){
                dp[i][0] = dp[i-1][0];
                rem[i][0] = rem[i-1][0]-a;
            }else{
                dp[i][0] = dp[i-1][0]+1;
                rem[i][0] = n-a;
            }
        }

        for(int i=1;i<=2;i++){
            if(rem[0][i-1]>=b){
                dp[0][i] = dp[0][i-1];
                rem[0][i] = rem[0][i-1]-b;
            }else{
                dp[0][i] = dp[0][i-1]+1;
                rem[0][i] = n-b;
            }
        }

        for(int i=1;i<=4;i++){
            for(int j=1;j<=2;j++){

                int icnt , irem;
                if(rem[i-1][j]>=a){
                    icnt = dp[i-1][j];
                    irem = rem[i-1][j]-a;
                }else{
                    icnt = dp[i-1][j]+1;
                    irem = n-a;
                }

                int jcnt , jrem;
                if(rem[i][j-1]>=b){
                    jcnt = dp[i][j-1];
                    jrem = rem[i][j-1]-b;
                }else{
                    jcnt = dp[i][j-1]+1;
                    jrem = n-b;
                }

                dp[i][j] = (icnt>jcnt)?icnt:( (icnt==jcnt)?( (irem>jrem)?icnt:jcnt ):jcnt );
                rem[i][j] = (icnt>jcnt)?irem:( (icnt==jcnt)?( (irem>jrem)?irem:jrem ):jrem );
            }
        }

        System.out.println( dp[4][2] );
    }
}

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

public class Solution {
    public static void main(String[] args) {
        Solution solution = new Solution();
        solution.solve();
    }

    private int n, a, b;

    public void solve() {
        InputReader in = new InputReader();

        n = in.nextInt();
        a = in.nextInt();
        b = in.nextInt();

        System.out.println(findAns());
    }

    private int findAns() {
        if(a*4+b*2 <= n) {
            return 1;
        } else if(a*2+b<=n) {
            return 2;
        } else if(b*2>n && a*2>n && (a+b)>n) {
            return 6;
        } else if(a+b>n && a*2>n && b*2<=n) {
            return 5;
        } else if((b*2>n && a*2<=n && (a+b)>n && a*4>n) || ((a+b)<=n && a*2>n && a*2+b>n)) {
            return 4;
        } else {
            return 3;
        }
    }

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

        public InputReader() {
            reader = new BufferedReader(new InputStreamReader(System.in), 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.*;

public class P910B {
    private static class HpReader {
        private BufferedReader in;

        public HpReader(String dir, String inFile, String outFile) {
            initAndRedirectInOut(dir, inFile, outFile);
        }

        private int ivl(String val) {
            return Integer.parseInt(val);
        }

        private long lvl(String val) {
            return Long.parseLong(val);
        }

        private void initAndRedirectInOut(String dir, String inFile, String outFile) {
            if (dir != null) {
                try {
                    String containingDirPath = dir.endsWith(File.separator) ? dir : dir + File.separator;
                    if (isDebug && inFile != null) System.setIn(new FileInputStream(new File(containingDirPath + inFile)));
                    if (isDebug && outFile != null) System.setOut(new PrintStream(new File(containingDirPath + outFile)));
                } catch (FileNotFoundException e) {
                    // Do nothing, stdin & stdout are not redirected
                }
            }
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }

        private String nextSingleStr() throws IOException {
            return in.readLine();
        }

        private String[] nextLineStr() throws IOException {
            return nextLineStr(0);
        }

        private String[] nextLineStr(int offset) throws IOException {
            String[] inp = nextSingleStr().split(" ");
            String[] rs = new String[offset + inp.length];
            System.arraycopy(inp, 0, rs, offset, inp.length);
            return rs;
        }

        private int nextSingleInt() throws IOException {
            return ivl(in.readLine());
        }

        private int[] nextLineInt() throws IOException {
            return nextLineInt(0);
        }

        private int[] nextLineInt(int offset) throws IOException {
            String[] inp = nextLineStr();
            int[] rs = new int[offset + inp.length];
            for (int i = 0; i < inp.length; i++) rs[offset + i] = ivl(inp[i]);
            return rs;
        }

        private long nextSingleLong() throws IOException {
            return lvl(in.readLine());
        }

        private long[] nextLineLong() throws IOException {
            return nextLineLong(0);
        }

        private long[] nextLineLong(int offset) throws IOException {
            String[] inp = nextLineStr();
            long[] rs = new long[offset + inp.length];
            for (int i = 0; i < inp.length; i++) rs[offset + i] = lvl(inp[i]);
            return rs;
        }

        private int[][] nextMatInt(int lineCount) throws IOException {
            return nextMatInt(lineCount, 0, 0);
        }

        private int[][] nextMatInt(int lineCount, int rowOffset, int colOffset) throws IOException {
            int[][] rs = new int[rowOffset + lineCount][];
            for (int i = rowOffset; i < rs.length; i++) rs[i] = nextLineInt(colOffset);
            return rs;
        }
    }

    private static class HpHelper {
        private static final String LOCAL_DEBUG_FLAG = "COM_PROG_DEBUG";

        private static boolean isDebug() {
            try {
                return Boolean.parseBoolean(System.getenv(HpHelper.LOCAL_DEBUG_FLAG));
            } catch (Exception e) {
                return false;
            }
        }

        private static String createDelimiter(String delimiter) {
            return delimiter == null ? " " : delimiter;
        }

        private static void println(int[] data, String delimiter) {
            delimiter = createDelimiter(delimiter);
            for (int t : data) out.print(t + delimiter);
            out.println();
        }

        private static void println(long[] data, String delimiter) {
            delimiter = createDelimiter(delimiter);
            for (long t : data) out.print(t + delimiter);
            out.println();
        }

        private static <T> void println(T[] data, String delimiter) {
            delimiter = createDelimiter(delimiter);
            for (T t : data) {
                if (t instanceof int[]) {
                    println((int[]) t, delimiter);
                } else if (t instanceof long[]) {
                    println((long[]) t, delimiter);
                } else if (t instanceof Object[]) {
                    println((Object[]) t, delimiter);
                } else {
                    out.print(t + delimiter);
                }
            }
            out.println();
        }
    }

    private static boolean isDebug = HpHelper.isDebug();
    private static HpReader in = new HpReader("/Users/apple/Work/WorkSpaces/CompetitiveProg/", "in.txt", null);
    private static PrintWriter out;

    private static int tryUse(int val, int n, int a, int b) {
        int curL = 0, rs = 0;
        for (int i = 0; i < 6; i++, val /= 2) {
            int cur = (val % 2 == 0 ? a : b);
            if (curL < cur) {
                rs += 1;
                curL = n;
            }
            curL -= cur;
        }
        return rs;
    }

    private static boolean isValid(int val) {
        int na = 0, nb = 0;
        for (int i = 0; i < 6; i++, val /= 2) {
            na += (val % 2 == 0 ? 1 : 0);
            nb += (val % 2 == 0 ? 0 : 1);
        }

        return na == 4 && nb == 2;
    }

    public static void main(String[] args) throws IOException {
        int rs = 100, n = in.nextSingleInt(), a = in.nextSingleInt(), b = in.nextSingleInt();
        for (int i = 0; i < (1 << 6); i++) {
            if (isValid(i)) {
                rs = Math.min(rs, tryUse(i, n, a, b));
            }
        }
        out.println(rs);

        out.flush();
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;
public class cdfpc2a
{
	static void merge(int arr[], int l, int m, int r)
    {
        int n1 = m - l + 1;
        int n2 = r - m;
        int L[] = new int [n1];
        int R[] = new int [n2];
        for (int i=0; i<n1; ++i)
            L[i] = arr[l + i];
        for (int j=0; j<n2; ++j)
            R[j] = arr[m + 1+ j];
        int i = 0, j = 0;
        int k = l;
        while (i < n1 && j < n2)
        {
            if (L[i] <= R[j])
            {
                arr[k] = L[i];
                i++;
            }
            else
            {
                arr[k] = R[j];
                j++;
            }
            k++;
        }
        while (i < n1)
        {
            arr[k] = L[i];
            i++;
            k++;
        }
        while (j < n2)
        {
            arr[k] = R[j];
            j++;
            k++;
        }
    }
    static void sort(int arr[], int l, int r)
    {
        if (l < r)
        {
            int m = (l+r)/2;
            sort(arr, l, m);
            sort(arr , m+1, r);
            merge(arr, l, m, r);
        }
    }
    static int gcd(int a, int b)
    {
      if (b == 0)
        return a;
      return gcd(b, a % b);
    }
    static long power(long n,long m)
    {
    	if(m==0)
    		return 1;
    	long ans=1;
    	while(m>0)
    	{
    		ans=ans*n;
    		m--;
    	}
    	return ans;
    }
	static int binarySearch(ArrayList<Integer> arr, int x)
    {
        int l = 0, r = arr.size() - 1,m=l + (r - l) / 2;
        while (l <= r) {
            m = l + (r - l) / 2;
            if (arr.get(m) == x)
                return m;
            if (arr.get(m) < x)
                l = m + 1;
            else
                r = m - 1;
        }
        return (int)Math.max(l, m);
    }
	public static void main(String args[])throws Exception
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		int t=1;//Integer.parseInt(br.readLine());
	    for(int i=1;i<=t;i++)
	    {
	        int n=Integer.parseInt(br.readLine());
	        int a=Integer.parseInt(br.readLine());
	        int b=Integer.parseInt(br.readLine());
	        int ans=0,aa=4,bb=2;
	        if(2*(2*a+b)<=n)
	        {
	        	System.out.println("1");
	        	return;
	        }
	        int copy=n;
	        if((b+2*a)==n)
	        {
	        	System.out.println("2");
	        	return;
	        }
	        while(aa>0||bb>0)
	        {
	        	if(a>b)
	        	{
	        	while(aa>0&&n>=a)
	        	{
	        		n-=a;
	        		aa--;
	        	}
	        	while(n>=b&&bb>0)
	        	{
	        		n-=b;
	        		bb--;
	        	}}
	        	else
	        	{
		        	while(n>=b&&bb>0)
		        	{
		        		n-=b;
		        		bb--;
		        	}
		        	while(aa>0&&n>=a)
		        	{
		        		n-=a;
		        		aa--;
		        	}
	        	}
	        	n=copy;
	        	ans++;

	        	//System.out.println("inside "+n);
	        }
	        System.out.println(ans);
	    }
	}
}

import javax.print.attribute.IntegerSyntax;
import java.util.*;
import java.io.*;
import java.lang.*;
import java.math.*;
import java.util.concurrent.ThreadLocalRandom;

import static java.lang.Math.*;

public class Sol implements Runnable {

    static long mod = 1000000007;

    void solve(int total_test_cases, InputReader in, PrintWriter w) {
        for (int test_case = 1; test_case <= total_test_cases; test_case++) {
            int n = in.nextInt(), a = in.nextInt(), b = in.nextInt();
            int total_a = 4, total_b = 2;

            int count = 0;

            if(b > a) {
                while(true) {
                    int left = n;

                    while(left >= b && total_b > 0) {
                        left -= b;
                        total_b--;
                    }

                    while(left >= a && total_a > 0) {
                        left -= a;
                        total_a--;
                    }

                    count++;
                    if(total_a == 0 && total_b == 0) break;
                }
            }
            else {
                while(true) {
                    int left = n;

                    while(left >= a && total_a > 0) {
                        left -= a;
                        total_a--;
                    }

                    while(left >= b && total_b > 0) {
                        left -= b;
                        total_b--;
                    }

                    count++;
                    if(total_a == 0 && total_b == 0) break;
                }
            }

            w.println(count);
        }
    }

    // ************* Code ends here ***************

    void init() throws Exception {
        //Scanner in;
        InputReader in;
        PrintWriter w;
        boolean online = false;

        String common_in_fileName = "\\in";
        String common_out_fileName = "\\out";
        int test_files = 0;

        for(int file_no = 0; file_no <= test_files; file_no++) {

            String x = "" + file_no;
            if (x.length() == 1) x = "0" + x;

            String in_fileName = common_in_fileName + "" + x;
            String out_fileName = common_out_fileName + "" + x;

            if (online) {
                //in = new Scanner(new File(in_fileName + ".txt"));
                in = new InputReader(new FileInputStream(new File(in_fileName + ".txt")));
                w = new PrintWriter(new FileWriter(out_fileName + ".txt"));
            } else {
                //in = new Scanner(System.in);
                in = new InputReader(System.in);
                w = new PrintWriter(System.out);
            }

            solve(1, in, w);
            w.close();
        }
    }

    public void run() {
        try {
            init();
        }
        catch(Exception e) {
            System.out.println(e);
            e.printStackTrace();
        }
    }

    public static void main(String args[]) throws Exception {
        new Thread(null, new Sol(),"Sol",1<<28).start();
    }

    static 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 String nextLine() {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        public int nextInt() {
            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 long nextLong() {
            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 double nextDouble() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E') {
                    return res * Math.pow(10, nextInt());
                }
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E') {
                        return res * Math.pow(10, nextInt());
                    }
                    if (c < '0' || c > '9') {
                        throw new InputMismatchException();
                    }
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            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 boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

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

        public interface SpaceCharFilter {

            public boolean isSpaceChar(int ch);
        }
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class Codeforces910B {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = Integer.parseInt(scanner.nextLine());
        int a = Integer.parseInt(scanner.nextLine());
        int b = Integer.parseInt(scanner.nextLine());
        List<Integer> frame = new ArrayList<Integer>();
        for (int i = 0; i < 4; i++) {
            frame.add(a);
        }
        for (int i = 0; i < 2; i++) {
            frame.add(b);
        }
        Collections.sort(frame);
        Collections.reverse(frame);
//        System.out.println(frame);
        ArrayList<Integer> wooden = new ArrayList<Integer>();
        int numberOfWooden = 0;
        while (frame.size() > 0) {
            int curWooden;
            if (wooden.size() > 0) {
                curWooden = wooden.get(0);
                wooden.remove(0);
            } else {
                curWooden = n;
                numberOfWooden++;
//                System.out.println(curWooden);
//                System.out.println(numberOfWooden);
            }
            boolean cutted = false;
            for (int i = 0; i < frame.size(); i++) {
                int curFrame = frame.get(i);
//                System.out.println(curFrame);
                if (curWooden >= curFrame) {
                    curWooden -= curFrame;
                    frame.remove(i);
                    i--;
                    cutted = true;
                }
            }
//            System.out.println(cutted);
            if (cutted) {
                wooden.add(0, curWooden);
            } else {

            }

        }
        System.out.println(numberOfWooden);
    }
}

import java.util.*;
public class DoorFrames {
	static ArrayList<Integer> array;
	static int x=0;
	static boolean hasGreater(int a)
	{
		for(int i=0;i<array.size();i++)
		{
			if(array.get(i)>=a)
			{
				x=i;
				return true;
			}
		}
		return false;
	}
	public static void main(String args[])
	{
		Scanner sc=new Scanner (System.in);
		int n=sc.nextInt();
		int a=sc.nextInt();
		int b=sc.nextInt();
		int ans=0,cnt=0;
		array=new ArrayList<Integer>();

		while(cnt++<4)
		{
			if(hasGreater(a))
			{
				int z=array.get(x);
				array.set(x, z-a);
			}
			else
			{
				ans+=1;
				array.add(n-a);
			}
		}
		cnt=0;
		while(cnt++<2)
		{
			if(hasGreater(b))
			{
				int z=array.get(x);
				array.set(x, z-b);
			}
			else
			{
				ans+=1;
				array.add(n-b);
			}
		}

		System.out.println(ans);
			sc.close();
	}

}

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

@SuppressWarnings("unchecked")
public class P910B {

  int n;
  TreeMap<Integer, Integer> m = new TreeMap();

  void use(int l) {
    Integer pl = m.ceilingKey(l);

    int c = m.get(pl) - 1;
    if (c > 0) {
      m.put(pl, c);
    } else {
      m.remove(pl);
    }

    if (pl != l) {
      m.put(pl - l, m.getOrDefault(pl - l, 0) + 1);
    }
  }

  public void run() throws Exception {
    n = nextInt();
    int a = nextInt(), b = nextInt();

    m.put(n, 6);

    if (a > b) {
      use(a); use(a); use(a); use(a); use(b); use(b);
    } else {
      use(b); use(b); use(a); use(a); use(a); use(a);
    }

    println(6 - m.getOrDefault(n, 0));
  }

  public static void main(String... args) throws Exception {
    br = new BufferedReader(new InputStreamReader(System.in));
    pw = new PrintWriter(new BufferedOutputStream(System.out));
    new P910B().run();
    br.close();
    pw.close();
    System.err.println("\n[Time : " + (System.currentTimeMillis() - startTime) + " ms]");
  }

  static long startTime = System.currentTimeMillis();
  static BufferedReader br;
  static PrintWriter pw;
  StringTokenizer stok;

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

  void print(byte b) { print("" + b); }
  void print(int i) { print("" + i); }
  void print(long l) { print("" + l); }
  void print(double d) { print("" + d); }
  void print(char c) { print("" + c); }
  void print(Object o) {
    if (o instanceof int[]) { print(Arrays.toString((int [])o));
    } else if (o instanceof long[]) { print(Arrays.toString((long [])o));
    } else if (o instanceof char[]) { print(Arrays.toString((char [])o));
    } else if (o instanceof byte[]) { print(Arrays.toString((byte [])o));
    } else if (o instanceof short[]) { print(Arrays.toString((short [])o));
    } else if (o instanceof boolean[]) { print(Arrays.toString((boolean [])o));
    } else if (o instanceof float[]) { print(Arrays.toString((float [])o));
    } else if (o instanceof double[]) { print(Arrays.toString((double [])o));
    } else if (o instanceof Object[]) { print(Arrays.toString((Object [])o));
    } else { print("" + o); }
  }
  void print(String s) { pw.print(s); }
  void println() { println(""); }
  void println(byte b) { println("" + b); }
  void println(int i) { println("" + i); }
  void println(long l) { println("" + l); }
  void println(double d) { println("" + d); }
  void println(char c) { println("" + c); }
  void println(Object o) { print(o); println(); }
  void println(String s) { pw.println(s); }
  int nextInt() throws IOException { return Integer.parseInt(nextToken()); }
  long nextLong() throws IOException { return Long.parseLong(nextToken()); }
  double nextDouble() throws IOException { return Double.parseDouble(nextToken()); }
  char nextChar() throws IOException { return (char) (br.read()); }
  String next() throws IOException { return nextToken(); }
  String nextLine() throws IOException { return br.readLine(); }
  int [] readInt(int size) throws IOException {
    int [] array = new int [size];
    for (int i = 0; i < size; i++) { array[i] = nextInt(); }
    return array;
  }
  long [] readLong(int size) throws IOException {
    long [] array = new long [size];
    for (int i = 0; i < size; i++) { array[i] = nextLong(); }
    return array;
  }
  double [] readDouble(int size) throws IOException {
    double [] array = new double [size];
    for (int i = 0; i < size; i++) { array[i] = nextDouble(); }
    return array;
  }
  String [] readLines(int size) throws IOException {
    String [] array = new String [size];
    for (int i = 0; i < size; i++) { array[i] = nextLine(); }
    return array;
  }

  int gcd(int a, int b) {
    if (a == 0) return Math.abs(b); if (b == 0) return Math.abs(a);
    a = Math.abs(a); b = Math.abs(b);
    int az = Integer.numberOfTrailingZeros(a), bz = Integer.numberOfTrailingZeros(b);
    a >>>= az; b >>>= bz;
    while (a != b) {
      if (a > b) { a -= b; a >>>= Integer.numberOfTrailingZeros(a); }
            else { b -= a; b >>>= Integer.numberOfTrailingZeros(b); }
    }
    return (a << Math.min(az, bz));
  }

  long gcd(long a, long b) {
    if (a == 0) return Math.abs(b); if (b == 0) return Math.abs(a);
    a = Math.abs(a); b = Math.abs(b);
    int az = Long.numberOfTrailingZeros(a), bz = Long.numberOfTrailingZeros(b);
    a >>>= az; b >>>= bz;
    while (a != b) {
      if (a > b) { a -= b; a >>>= Long.numberOfTrailingZeros(a); }
            else { b -= a; b >>>= Long.numberOfTrailingZeros(b); }
    }
    return (a << Math.min(az, bz));
  }
}

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

@SuppressWarnings("unchecked")
public class P910B {

  int n;
  TreeMap<Integer, Integer> m = new TreeMap();

  void use(int l) {
    Integer pl = m.ceilingKey(l);

    int c = m.get(pl) - 1;
    if (c > 0) {
      m.put(pl, c);
    } else {
      m.remove(pl);
    }

    if (pl != l) {
      m.put(pl - l, m.getOrDefault(pl - l, 0) + 1);
    }
  }

  public void run() throws Exception {
    n = nextInt();
    int a = nextInt(), b = nextInt();

    m.put(n, 6);
    use(a);
    use(a);
    use(a);
    use(a);
    use(b);
    use(b);

    println(6 - m.getOrDefault(n, 0));
  }

  public static void main(String... args) throws Exception {
    br = new BufferedReader(new InputStreamReader(System.in));
    pw = new PrintWriter(new BufferedOutputStream(System.out));
    new P910B().run();
    br.close();
    pw.close();
    System.err.println("\n[Time : " + (System.currentTimeMillis() - startTime) + " ms]");
  }

  static long startTime = System.currentTimeMillis();
  static BufferedReader br;
  static PrintWriter pw;
  StringTokenizer stok;

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

  void print(byte b) { print("" + b); }
  void print(int i) { print("" + i); }
  void print(long l) { print("" + l); }
  void print(double d) { print("" + d); }
  void print(char c) { print("" + c); }
  void print(Object o) {
    if (o instanceof int[]) { print(Arrays.toString((int [])o));
    } else if (o instanceof long[]) { print(Arrays.toString((long [])o));
    } else if (o instanceof char[]) { print(Arrays.toString((char [])o));
    } else if (o instanceof byte[]) { print(Arrays.toString((byte [])o));
    } else if (o instanceof short[]) { print(Arrays.toString((short [])o));
    } else if (o instanceof boolean[]) { print(Arrays.toString((boolean [])o));
    } else if (o instanceof float[]) { print(Arrays.toString((float [])o));
    } else if (o instanceof double[]) { print(Arrays.toString((double [])o));
    } else if (o instanceof Object[]) { print(Arrays.toString((Object [])o));
    } else { print("" + o); }
  }
  void print(String s) { pw.print(s); }
  void println() { println(""); }
  void println(byte b) { println("" + b); }
  void println(int i) { println("" + i); }
  void println(long l) { println("" + l); }
  void println(double d) { println("" + d); }
  void println(char c) { println("" + c); }
  void println(Object o) { print(o); println(); }
  void println(String s) { pw.println(s); }
  int nextInt() throws IOException { return Integer.parseInt(nextToken()); }
  long nextLong() throws IOException { return Long.parseLong(nextToken()); }
  double nextDouble() throws IOException { return Double.parseDouble(nextToken()); }
  char nextChar() throws IOException { return (char) (br.read()); }
  String next() throws IOException { return nextToken(); }
  String nextLine() throws IOException { return br.readLine(); }
  int [] readInt(int size) throws IOException {
    int [] array = new int [size];
    for (int i = 0; i < size; i++) { array[i] = nextInt(); }
    return array;
  }
  long [] readLong(int size) throws IOException {
    long [] array = new long [size];
    for (int i = 0; i < size; i++) { array[i] = nextLong(); }
    return array;
  }
  double [] readDouble(int size) throws IOException {
    double [] array = new double [size];
    for (int i = 0; i < size; i++) { array[i] = nextDouble(); }
    return array;
  }
  String [] readLines(int size) throws IOException {
    String [] array = new String [size];
    for (int i = 0; i < size; i++) { array[i] = nextLine(); }
    return array;
  }

  int gcd(int a, int b) {
    if (a == 0) return Math.abs(b); if (b == 0) return Math.abs(a);
    a = Math.abs(a); b = Math.abs(b);
    int az = Integer.numberOfTrailingZeros(a), bz = Integer.numberOfTrailingZeros(b);
    a >>>= az; b >>>= bz;
    while (a != b) {
      if (a > b) { a -= b; a >>>= Integer.numberOfTrailingZeros(a); }
            else { b -= a; b >>>= Integer.numberOfTrailingZeros(b); }
    }
    return (a << Math.min(az, bz));
  }

  long gcd(long a, long b) {
    if (a == 0) return Math.abs(b); if (b == 0) return Math.abs(a);
    a = Math.abs(a); b = Math.abs(b);
    int az = Long.numberOfTrailingZeros(a), bz = Long.numberOfTrailingZeros(b);
    a >>>= az; b >>>= bz;
    while (a != b) {
      if (a > b) { a -= b; a >>>= Long.numberOfTrailingZeros(a); }
            else { b -= a; b >>>= Long.numberOfTrailingZeros(b); }
    }
    return (a << Math.min(az, bz));
  }
}

import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;
public class Prac{
    static class InputReader {
        private final InputStream stream;
        private final byte[] buf = new byte[8192];
        private int curChar, snumChars;
        public InputReader(InputStream st) {
            this.stream = st;
        }
        public int read() {
            if (snumChars == -1)
                throw new InputMismatchException();
            if (curChar >= snumChars) {
                curChar = 0;
                try {
                    snumChars = stream.read(buf);
                }
                catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (snumChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }
        public int ni() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
        public long nl() {
            int c = read();
            while (isSpaceChar(c)) {
            c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
        public int[] nia(int n) {
            int a[] = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = ni();
            }
            return a;
        }
        public String rs() {
            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 String nextLine() {
            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 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;
        }
    }
    public static class Key {

        private final int x;
        private final int y;

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

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Key)) return false;
            Key key = (Key) o;
            return x == key.x && y == key.y;
        }

        @Override
        public int hashCode() {
            int result = x;
            result = 31 * result + y;
            return result;
        }

    }
    static class Pair{
        int x,y;
        public Pair(int x,int y){
            this.y=y;
            this.x=x;
        }
    }

    static PrintWriter w = new PrintWriter(System.out);
    static long mod=998244353L,mod1=1000000007;

    public static void main(String [] args){
        InputReader sc=new InputReader(System.in);
        int n=sc.ni();
        int a=sc.ni(),b=sc.ni();
        int ar[]={a,a,a,a,b,b};
        Arrays.sort(ar);
        for(int i=1;i<=6;i++){
            int arr[]=new int[i];
            boolean in=false;
            for(int j=5;j>=0;j--){
                int k=0;
                boolean f=false;
                while(k<i){
                    if((arr[k]+ar[j])<=n){
                        arr[k]+=ar[j];
                        f=true;
                        break;
                    }
                    k++;
                }
                if(!f)in=true;

            }
            if(!in){
                w.println(i);
                break;
            }
            for(int j=0;j<6;j++){
                int k=0;
                boolean f=false;
                while(k<i){
                    if((arr[k]+ar[j])<=n){
                        arr[k]+=ar[j];
                        f=true;
                        break;
                    }
                    k++;
                }
                if(!f)in=true;

            }
            if(!in){
                w.println(i);
                break;
            }
        }
        w.close();
    }
}

import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;
public class Prac{
    static class InputReader {
        private final InputStream stream;
        private final byte[] buf = new byte[8192];
        private int curChar, snumChars;
        public InputReader(InputStream st) {
            this.stream = st;
        }
        public int read() {
            if (snumChars == -1)
                throw new InputMismatchException();
            if (curChar >= snumChars) {
                curChar = 0;
                try {
                    snumChars = stream.read(buf);
                }
                catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (snumChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }
        public int ni() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
        public long nl() {
            int c = read();
            while (isSpaceChar(c)) {
            c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
        public int[] nia(int n) {
            int a[] = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = ni();
            }
            return a;
        }
        public String rs() {
            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 String nextLine() {
            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 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;
        }
    }
    public static class Key {

        private final int x;
        private final int y;

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

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Key)) return false;
            Key key = (Key) o;
            return x == key.x && y == key.y;
        }

        @Override
        public int hashCode() {
            int result = x;
            result = 31 * result + y;
            return result;
        }

    }
    static class Pair{
        int x,y;
        public Pair(int x,int y){
            this.y=y;
            this.x=x;
        }
    }

    static PrintWriter w = new PrintWriter(System.out);
    static long mod=998244353L,mod1=1000000007;

    public static void main(String [] args){
        InputReader sc=new InputReader(System.in);
        int n=sc.ni();
        int a=sc.ni(),b=sc.ni();
        int ar[]={a,a,a,a,b,b};
        Arrays.sort(ar);
        for(int i=1;i<=6;i++){
            int arr[]=new int[i];
            boolean in=false;
            for(int j=5;j>=0;j--){
                int k=0;
                boolean f=false;
                while(k<i){
                    if((arr[k]+ar[j])<=n){
                        arr[k]+=ar[j];
                        f=true;
                        break;
                    }
                    k++;
                }
                if(!f)in=true;

            }
            if(!in){
                w.println(i);
                break;
            }
        }
        w.close();
    }
}

import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;
public class Prac{
    static class InputReader {
        private final InputStream stream;
        private final byte[] buf = new byte[8192];
        private int curChar, snumChars;
        public InputReader(InputStream st) {
            this.stream = st;
        }
        public int read() {
            if (snumChars == -1)
                throw new InputMismatchException();
            if (curChar >= snumChars) {
                curChar = 0;
                try {
                    snumChars = stream.read(buf);
                }
                catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (snumChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }
        public int ni() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
        public long nl() {
            int c = read();
            while (isSpaceChar(c)) {
            c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
        public int[] nia(int n) {
            int a[] = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = ni();
            }
            return a;
        }
        public String rs() {
            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 String nextLine() {
            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 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;
        }
    }
    public static class Key {

        private final int x;
        private final int y;

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

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Key)) return false;
            Key key = (Key) o;
            return x == key.x && y == key.y;
        }

        @Override
        public int hashCode() {
            int result = x;
            result = 31 * result + y;
            return result;
        }

    }
    static class Pair{
        int x,y;
        public Pair(int x,int y){
            this.y=y;
            this.x=x;
        }
    }

    static PrintWriter w = new PrintWriter(System.out);
    static long mod=998244353L,mod1=1000000007;

    public static void main(String [] args){
        InputReader sc=new InputReader(System.in);
        int n=sc.ni();
        int a=sc.ni(),b=sc.ni();
        int ar[]={a,a,a,a,b,b};
        Arrays.sort(ar);
        for(int i=1;i<=6;i++){
            int arr[]=new int[i];
            boolean in=false;
            for(int j=5;j>=0;j--){
                int k=0;
                boolean f=false;
                while(k<i){
                    if((arr[k]+ar[j])<=n){
                        arr[k]+=ar[j];
                        f=true;
                        break;
                    }
                    k++;
                }
                if(!f)in=true;

            }
            for(int j=0;j<6;j++){
                int k=0;
                boolean f=false;
                while(k<i){
                    if((arr[k]+ar[j])<=n){
                        arr[k]+=ar[j];
                        f=true;
                        break;
                    }
                    k++;
                }
                if(!f)in=true;

            }
            if(!in){
                w.println(i);
                break;
            }
        }
        w.close();
    }
}

import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;
public class Prac{
    static class InputReader {
        private final InputStream stream;
        private final byte[] buf = new byte[8192];
        private int curChar, snumChars;
        public InputReader(InputStream st) {
            this.stream = st;
        }
        public int read() {
            if (snumChars == -1)
                throw new InputMismatchException();
            if (curChar >= snumChars) {
                curChar = 0;
                try {
                    snumChars = stream.read(buf);
                }
                catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (snumChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }
        public int ni() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
        public long nl() {
            int c = read();
            while (isSpaceChar(c)) {
            c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
        public int[] nia(int n) {
            int a[] = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = ni();
            }
            return a;
        }
        public String rs() {
            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 String nextLine() {
            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 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;
        }
    }
    public static class Key {

        private final int x;
        private final int y;

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

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Key)) return false;
            Key key = (Key) o;
            return x == key.x && y == key.y;
        }

        @Override
        public int hashCode() {
            int result = x;
            result = 31 * result + y;
            return result;
        }

    }
    static class Pair{
        int x,y;
        public Pair(int x,int y){
            this.y=y;
            this.x=x;
        }
    }

    static PrintWriter w = new PrintWriter(System.out);
    static long mod=998244353L,mod1=1000000007;

    static void shuffleArray(int[] arr){
        int n = arr.length;
        Random rnd = new Random();
        for(int i=0; i<n; ++i){
            int tmp = arr[i];
            int randomPos = i + rnd.nextInt(n-i);
            arr[i] = arr[randomPos];
            arr[randomPos] = tmp;
        }
    }
    public static void main(String [] args){
        InputReader sc=new InputReader(System.in);
        int n=sc.ni();
        int a=sc.ni(),b=sc.ni();
        int ar[]={a,a,a,a,b,b};
        Arrays.sort(ar);
        int ans=6;
        int s=1000;
        while(s-->0){

            for(int i=1;i<=6;i++){
                int arr[]=new int[i];
                boolean in=false;
                for(int j=5;j>=0;j--){
                    int k=0;
                    boolean f=false;
                    while(k<i){
                        if((arr[k]+ar[j])<=n){
                            arr[k]+=ar[j];
                            f=true;
                            break;
                        }
                        k++;
                    }
                    if(!f)in=true;

                }
                if(!in){
                    ans=Math.min(ans,i);
                    break;
                }
            }
            shuffleArray(ar);
        }
        w.close();
    }
}

import java.util.*;
public class DoorFrame {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int a = sc.nextInt();
		int b = sc.nextInt();
		int size = n;
		int barA = 4;
		int barB = 2;
		int count = 1;
		while (barA > 0 || barB > 0) {
			if (barA != 0) {
				if (n-a < 0) {
					n = size;
					count++;
				}
				int typeA = n/a;
				if (typeA > barA) 		typeA -= barA;
				n = n - typeA*a;
//				System.out.println("n = " + n);
				barA = barA-typeA;
//				System.out.println("barA ="+barA);
			}
			if (barB != 0) {
				if (n-b < 0) {
					n = size;
					count++;
				}
				int typeB = n/b;
				if (typeB > barB) 		typeB -= barB;
				n = n-typeB*b;
//				System.out.println("n = " + n);
				barB = barB-typeB;
//				System.out.println("barB = "+barB);
//				System.out.println("count="+count);
			}

		}
		System.out.println(count);
		sc.close();
	}

}

import java.util.*;
public class DoorFrame {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int a = sc.nextInt();
		int b = sc.nextInt();
		int size = n;
		int barA = 4;
		int barB = 2;
		int count = 1;
		while (barA > 0 || barB > 0) {
			if (a >= b) {
				if (barA != 0) {
					if (n-a < 0) {
						n = size;
						count++;
					}
					int typeA = n/a;
					if (typeA > barA) 		typeA = barA;
					n = n - typeA*a;
//					System.out.println("n = " + n);
					barA = barA-typeA;
//					System.out.println("barA ="+barA);
				}
				if (barB != 0) {
					if (n-b < 0) {
						n = size;
						count++;
					}
					int typeB = n/b;
					if (typeB > barB) 		typeB = barB;
					n = n-typeB*b;
//					System.out.println("n = " + n);
					barB = barB-typeB;
//					System.out.println("barB = "+barB);
//					System.out.println("count="+count);
				}
			}
			else {
				if (barB != 0) {
					if (n-b < 0) {
						n = size;
						count++;
					}
					int typeB = n/b;
					if (typeB > barB) 		typeB = barB;
					n = n-typeB*b;
//					System.out.println("n = " + n);
					barB = barB-typeB;
//					System.out.println("barB = "+barB);
//					System.out.println("count="+count);
				}
				if (barA != 0) {
					if (n-a < 0) {
						n = size;
						count++;
					}
					int typeA = n/a;
					if (typeA > barA) 		typeA = barA;
					n = n - typeA*a;
//					System.out.println("n = " + n);
					barA = barA-typeA;
//					System.out.println("barA ="+barA);
				}
			}

		}
		System.out.println(count);
		sc.close();
	}

}

import java.util.*;
public class DoorFrame {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int a = sc.nextInt();
		int b = sc.nextInt();
		int size = n;
		int barA = 4;
		int barB = 2;
		int count = 1;
		while (barA > 0 || barB > 0) {
			if (barA != 0) {
				if (n-a < 0) {
					n = size;
					count++;
				}
				int typeA = n/a;
				if (typeA > barA) 		typeA = barA;
				n = n - typeA*a;
//				System.out.println("n = " + n);
				barA = barA-typeA;
//				System.out.println("barA ="+barA);
			}
			if (barB != 0) {
				if (n-b < 0) {
					n = size;
					count++;
				}
				int typeB = n/b;
				if (typeB > barB) 		typeB = barB;
				n = n-typeB*b;
//				System.out.println("n = " + n);
				barB = barB-typeB;
//				System.out.println("barB = "+barB);
//				System.out.println("count="+count);
			}

		}
		System.out.println(count);
		sc.close();
	}

}

import java.util.*;
public class maestro{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int a = sc.nextInt();
        int b = sc.nextInt();
        int ans=1;int x=0;int y=0;
        int z=n;
        int max = Math.max(a,b);
        int min = Math.min(a,b);
        if (max==a) {
            while (0 < 1) {
                while (z >= max && x < 4) {
                    z -= max;
                    x++;
                }
                while (z >= min && y < 2) {
                    z -= min;
                    y++;
                }
                if (x == 4 && y == 2) {
                    System.out.println(ans);
                    return;
                } else {
                    ans++;
                    z = n;
                }
            }
        }
        else {
            while (0 < 1) {
                while (z >= max && x < 2) {
                    z -= max;
                    x++;
                }
                while (z >= min && y < 4) {
                    z -= min;
                    y++;
                }
                if (x == 2 && y == 4) {
                    System.out.println(ans);
                    return;
                } else {
                    ans++;
                    z = n;
                }
            }
        }
    }
}

import java.util.Scanner;

public class door_frames {

	public static void main(String ar[])
	{
		Scanner sc=new Scanner(System.in);
		long n=sc.nextLong(),a=sc.nextLong(),b=sc.nextLong(),count=1L,flag=0L,m=n;
			if(n>=2*a)
			{
			 n=n-2*a;
			 flag=flag+2*a;
			 if(n>b)
			 {
				 n=n-b;
				 flag=flag+b;
			 }
			 else
			 {
				 count++;
			 }

			}
			else
			{
				if(n>=b+a)
				{

					count++;

				}
				else
				{
					count=count+2;
				}
			}
			//System.out.println(flag);
			if(flag!=(m/2) || count>=2)
			{
				count=2*count;
			}

		System.out.println(count);
	}
}

import java.util.*;

public class door_frames {
    public static int[] swap(int data[], int left, int right)
    {

        int temp = data[left];
        data[left] = data[right];
        data[right] = temp;
        return data;
    }
    public static int[] reverse(int data[], int left, int right)
    {
        while (left < right) {
            int temp = data[left];
            data[left++] = data[right];
            data[right--] = temp;
        }

        return data;
    }

    public static boolean findNextPermutation(int data[])
    {
        if (data.length <= 1)
            return false;

        int last = data.length - 2;

        while (last >= 0) {
            if (data[last] < data[last + 1]) {
                break;
            }
            last--;
        }
     if (last < 0)
            return false;

        int nextGreater = data.length - 1;

        for (int i = data.length - 1; i > last; i--) {
            if (data[i] > data[last]) {
                nextGreater = i;
                break;
            }
        }

        data = swap(data, nextGreater, last);
        data = reverse(data, last + 1, data.length - 1);
        return true;
    } 	public static void main(String ar[])
	{
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
	    int a=sc.nextInt(),b=sc.nextInt(),min=1000000000;
	    int arr[]=  {a,a,a,a,b,b};
	    Arrays.sort(arr);
	    for(int i=0;i<6;i++)
		System.out.print(arr[i]+"  ");
	    System.out.println();
	    int c=0;
	    while((findNextPermutation(arr)))
	    {
	    	for(int i=0;i<6;i++)
	    	{
	    		System.out.print(arr[i]+"  ");
	    	}
	    	System.out.println();

	    	c=0;
	       int left=0;
	        for(int i=0;i<6;i++)
	        {
	            if(left-arr[i]>=0)
	            {
	                left-=arr[i];
	            }
	            else
	            {
	                c++;
	                left=n-arr[i];
	            }
	        }
	        min=Math.min(c,min);
	    }
		System.out.println(min);

	}
}

import java.util.Scanner;

public class door_frames {

	public static void main(String ar[])
	{
		Scanner sc=new Scanner(System.in);
		long n=sc.nextLong(),a=sc.nextLong(),b=sc.nextLong(),count=1L,flag=0L,m=n;
			if(n>=2*a)
			{
			 n=n-2*a;
			 flag=flag+2*a;
			 if(n>b)
			 {
				 n=n-b;
				 flag=flag+b;
			 }
			 else
			 {
				 count++;
			 }

			}
			else
			{
				if(n>=b+a)
				{

					count++;

				}
				else
				{
					count=count+2;
				}
			}
			//System.out.println(flag);
			if(flag!=(m/2))
			{
				count=2*count;
			}

		System.out.println(count);
	}
}

import java.util.*;

public class door_frames {
    public static int[] swap(int data[], int left, int right)
    {

        int temp = data[left];
        data[left] = data[right];
        data[right] = temp;
        return data;
    }
    public static int[] reverse(int data[], int left, int right)
    {
        while (left < right) {
            int temp = data[left];
            data[left++] = data[right];
            data[right--] = temp;
        }

        return data;
    }

    public static boolean findNextPermutation(int data[])
    {
        if (data.length <= 1)
            return false;

        int last = data.length - 2;

        while (last >= 0) {
            if (data[last] < data[last + 1]) {
                break;
            }
            last--;
        }
     if (last < 0)
            return false;

        int nextGreater = data.length - 1;

        for (int i = data.length - 1; i > last; i--) {
            if (data[i] > data[last]) {
                nextGreater = i;
                break;
            }
        }

        data = swap(data, nextGreater, last);
        data = reverse(data, last + 1, data.length - 1);
        return true;
    } 	public static void main(String ar[])
	{
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
	    int a=sc.nextInt(),b=sc.nextInt(),min=1000000000;
	    int arr[]=  {a,a,a,a,b,b};
	    Arrays.sort(arr);
	    int c=0;
	    while((findNextPermutation(arr)))
	    {
	     	c=0;
	       int left=0;
	        for(int i=0;i<6;i++)
	        {
	            if(left-arr[i]>=0)
	            {
	                left-=arr[i];
	            }
	            else
	            {
	                c++;
	                left=n-arr[i];
	            }
	        }
	        min=Math.min(c,min);
	    }
		System.out.println(min);

	}
}

import java.util.Scanner;

/**
 * Created by ASUS on 27/01/2018.
 */
public class BDoorFrames {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        length = in.nextInt();
        a = in.nextInt();
        b = in.nextInt();
        min = a + b;
        howMany(0, 0, 0, 0);
        System.out.println(min);
    }

    static int length;

    static int b;
    static int a;

    static int min;

    static void howMany(int tillNow, int aNum, int bNum, int remaineder) {
        if (aNum == 4 && bNum == 2) {
            if (tillNow < min) {
                min = tillNow;
                return;
            }
        }
        if (aNum < 4) {
            if (remaineder >= a) {
                howMany(tillNow, aNum + 1, bNum, remaineder - a);
            } else {
                howMany(tillNow + 1, aNum + 1, bNum, length - a);
            }
        }
        if (bNum < 2) {
            if (remaineder >= b) {
                howMany(tillNow, aNum, bNum + 1, remaineder - b);
            } else {
                howMany(tillNow + 1, aNum, bNum + 1, length - b);
            }
        }
    }

}

//package A;
/**
 * Created by Eesaa on 12/25/2017.
 */

import java.util.*;

public class B_910 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt(), a = in.nextInt(), b = in.nextInt(), res;
        //check if n can cover all
        if(n>=2*b+4*a)
        {
            System.out.println(1);
            return;
        }
        //check if n can cover one completely
        if(n>=2*a+b)
        {
            System.out.println(2);
            return;
        }
        //check if n can cover 2a or a+b
        if((n>=2*a && (n<a+b)) || (n>=a+b && n<2*a)) {
            System.out.println(4);
            return;
        }
        if(n>=a+b && n>=2*a)
        {
            System.out.println(3);
            return;
        }
        System.out.println(6);
        in.close();
    }
}

//package A;
/**
 * Created by Eesaa on 12/25/2017.
 */

import java.util.*;

public class B_910 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt(), a = in.nextInt(), b = in.nextInt(), res;
        //check if n can cover all
        if(n>=2*b+4*a)
        {
            System.out.println(1);
            return;
        }
        //check if n can cover one completely
        if(n>=2*a+b)
        {
            System.out.println(2);
            return;
        }
        //check if n can cover 2a or a+b
        if((n>=2*a && (n<a+b)) || (n>=a+b && n<2*a)) {
            System.out.println(4);
            return;
        }
        if(n>=a+b && n>=2*a)
        {
            System.out.println(3);
            return;
        }
        if(n>=2*b)
        {
            System.out.println(5);
            return;
        }
        System.out.println(6);
        in.close();
    }
}

import java.util.Scanner;

public class B_Door_Frames {

	@SuppressWarnings("resource")
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int n = input.nextInt();
		int a = input.nextInt();
		int b = input.nextInt();
		if (2 * b + 4 * a <= n){
			System.out.println(1);
		}else if (b + 2 * a <= n){
			System.out.println(2);
		}else if (4 * a <= n || 2 * b <= n && 2 * a <= n){
			System.out.println(3);
		}else if (a + b <= n || 2 * a <= n){
			System.out.println(4);
		}else if (2 * b <= n){
			System.out.println(5);
		}else{
			System.out.println(6);
		}
	}

}

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

public class Solution {
    public static void main(String[] args) {
        Solution solution = new Solution();
        solution.solve();
    }

    private int n, a, b;

    public void solve() {
        InputReader in = new InputReader();

        n = in.nextInt();
        a = in.nextInt();
        b = in.nextInt();

        int[] wood = new int[] {n, n, n, n, n, n};
        int num1, num2, val1, val2;
        if(a>=b) {
            num1 = 4;
            num2 = 2;
            val1 = a;
            val2 = b;
        } else {
            num1 = 2;
            num2 = 4;
            val1 = b;
            val2 = a;
        }

        while(num1 > 0) {
            for(int i = 0; i < 6; i++) {
                if(wood[i] >= val1) {
                    wood[i] -= val1;
                    num1--;
                    break;
                }
            }
        }

        while(num2 > 0) {
            for(int i = 0; i < 6; i++) {
                if(wood[i] >= val2) {
                    wood[i] -= val2;
                    num2--;
                    i = 6;
                    break;
                }
            }
        }

        int ans = 6;
        for(int i = 0; i < 6; i++) {
            //System.out.print("**"+wood[i]+"||");
            if(wood[i] == n) {
                ans--;
            }
        }

        System.out.println(ans);
    }

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

        public InputReader() {
            reader = new BufferedReader(new InputStreamReader(System.in), 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.*;

public class Solution {
    public static void main(String[] args) {
        Solution solution = new Solution();
        solution.solve();
    }

    private int n, a, b;

    public void solve() {
        InputReader in = new InputReader();

        n = in.nextInt();
        a = in.nextInt();
        b = in.nextInt();

        System.out.println(findAns());
    }

    private int findAns() {
        if(a*4+b*2 <= n) {
            return 1;
        } else if(a*2+b<=n) {
            return 2;
        } else if(b*2>n && a*2>n && (a+b)>n) {
            return 6;
        } else if(a+b>n && a*2>n && b*2<=n) {
            return 5;
        } else if((b*2>n && a*2<=n) || (a+b)<=n && a*2>n) {
            return 4;
        } else {
            return 3;
        }
    }

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

        public InputReader() {
            reader = new BufferedReader(new InputStreamReader(System.in), 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.*;

public class Solution {
    public static void main(String[] args) {
        Solution solution = new Solution();
        solution.solve();
    }

    private int n, a, b;

    public void solve() {
        InputReader in = new InputReader();

        n = in.nextInt();
        a = in.nextInt();
        b = in.nextInt();

        System.out.println(findAns());
    }

    private int findAns() {
        if(a*4+b*2 <= n) {
            return 1;
        } else if(a*2+b<=n) {
            return 2;
        } else if(b*2>n && a*2>n && (a+b)>n) {
            return 6;
        } else if(a+b>n && a*2>n && b*2<=n) {
            return 5;
        } else if((b*2>n && a*2<=n && (a+b)>n) || ((a+b)<=n && a*2>n && a*2+b>n)) {
            return 4;
        } else {
            return 3;
        }
    }

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

        public InputReader() {
            reader = new BufferedReader(new InputStreamReader(System.in), 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 Door_Frames {
	public static void main(String[] args) {
		Scanner sc=new Scanner (System.in);
		int n=sc.nextInt();
		int a=sc.nextInt();
		int b=sc.nextInt();
		if(a+b<=n)
		{	int x=4*a+2*b;
			if(x%n==0)
				System.out.println(x/n);
			else
				System.out.println(x/n+1);
		}
		else
		{	System.out.println(6);

		}

	}
}

import java.util.Scanner;

public class Door_Frames {
	public static void main(String[] args) {
		Scanner sc=new Scanner (System.in);
		int n=sc.nextInt();
		int a=sc.nextInt();
		int x=sc.nextInt();
		int b,c,d,y,k;
		b=c=d=a;y=x;k=6;
		boolean fa,fb,fc,fd,fx,fy;
		fa=fb=fc=fd=fx=fy=true;
		int r=n;
		if(a>x) {
			while(fa||fb||fc||fd||fx||fy) {
				if(fa) {
					if(r>=a){r-=a;fa=false;
							if(r>=x&&fx) {r-=x;fx=false;}
							if(r>=x&&fy) {r-=x;fy=false;}
					}
					else {r=n;k--;continue;}
				}
				if(!(fa||fb||fc||fd||fx||fy)) {k--;break;}
				if(fb) {
					if(r>=a){r-=a;fb=false;
						if(r>=x&&fx) {r-=x;fx=false;}
						if(r>=x&&fy) {r-=x;fy=false;}
						}
					else {r=n;k--;continue;}
				}
				if(!(fa||fb||fc||fd||fx||fy)) {k--;break;}
				if(fc)
					{if(r>=a){r-=a;fc=false;
						if(r>=x&&fx) {r-=x;fx=false;}
						if(r>=x&&fy) {r-=x;fy=false;}
					}
					else {r=n;k--;continue;}
				}
				if(!(fa||fb||fc||fd||fx||fy)) {k--;break;}
				if(fd) {
					if(r>=a){r-=a;fd=false;
						if(r>=x&&fx) {r-=x;fx=false;}
						if(r>=x&&fy) {r-=x;fy=false;}
					}
					else {r=n;k--;continue;}
				}
				if(!(fa||fb||fc||fd||fx||fy)) {k--;break;}
				if(fx) {
					if(r>=x){r-=x;fx=false;
						if(r>=x&&fy) {r-=x;fy=false;k--;break;}}
					else {r=n;k--;continue;}
				}
				if(!(fa||fb||fc||fd||fx||fy)) {k--;break;}
				if(fy) {
					if(r>=x){r-=x;fy=false;k--;}
					else {
						r=n;k--;continue;}
				}
			}
		}
		else {
			while(fa||fb||fc||fd||fx||fy) {
				if(fx) {
					if(r>=x) {r-=x;fx=false;
							  if(r>=a&&fa) {r-=a;fa=false;}
							  if(r>=a&&fb) {r-=a;fb=false;}
							  if(r>=a&&fc) {r-=a;fc=false;}
							  if(r>=a&&fd) {r-=a;fd=false;}
					}
					else {r=n;k--;continue;}
				}
				if(!(fa||fb||fc||fd||fx||fy)) {k--;break;}
				if(fy) {
					if(r>=x) {r-=x;fy=false;
							  if(r>=a&&fa) {r-=a;fa=false;}
							  if(r>=a&&fb) {r-=a;fb=false;}
							  if(r>=a&&fc) {r-=a;fc=false;}
							  if(r>=a&&fd) {r-=a;fd=false;}
					}
					else {r=n;k--;continue;}
				}
				if(!(fa||fb||fc||fd||fx||fy)) {k--;break;}
				if(fa) {
					if(r>=a){r-=a;fa=false;
					  if(r>=a&&fb) {r-=a;fb=false;}
					  if(r>=a&&fc) {r-=a;fc=false;}
					  if(r>=a&&fd) {r-=a;fd=false;}
					}
					else {r=n;k--;continue;}
				}
				if(!(fa||fb||fc||fd||fx||fy)) {k--;break;}
				if(fb) {
					if(r>=a){r-=a;fb=false;
					  if(r>=a&&fc) {r-=a;fc=false;}
					  if(r>=a&&fd) {r-=a;fd=false;}
					}
					else {r=n;k--;continue;}
				}
				if(!(fa||fb||fc||fd||fx||fy)) {k--;break;}
				if(fc) {
					if(r>=a){r-=a;fc=false;
					  if(r>=a&&fd) {r-=a;fd=false;}
					}
					else {r=n;k--;continue;}
				}
				if(!(fa||fb||fc||fd||fx||fy)) {k--;break;}
				if(fd) {
					if(r>=a){r-=a;fd=false;
							k--;
							continue;
					}
					else {r=n;k--;continue;}
				}
			}
		}
		System.out.println(6-k);

	}
}

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

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

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

    public static void main(String[] args) throws IOException {
        FastReader scn = new FastReader();
        OutputStream out = new BufferedOutputStream(System.out);
        program(scn, out);
        out.flush();
    }

    public static void print(OutputStream out, Object str) throws IOException {
        out.write(str.toString().getBytes());
    }

    static class Length implements Comparable<Length> {
        Integer length;

        public Length(int length) {
            this.length = length;
        }

        @Override
        public int compareTo(Length o) {
            return o.length - this.length;
        }
    }

    private static void program(FastReader scn, OutputStream out) throws IOException {
        int n = scn.nextInt();
        int a = scn.nextInt();
        int b = scn.nextInt();
        PriorityQueue<Length> priorityQueue = new PriorityQueue<>();
        Integer ans = 0;
        priorityQueue.add(new Length(n - a));
        ans = 1;
        ans = helper(priorityQueue, ans, a, n);
        ans = helper(priorityQueue, ans, a, n);
        ans = helper(priorityQueue, ans, a, n);
        ans = helper(priorityQueue, ans, b, n);
        ans = helper(priorityQueue, ans, b, n);
        print(out, ans);
    }

    private static Integer helper(PriorityQueue<Length> priorityQueue, Integer ans, int a, int n) {
        Length k = priorityQueue.poll();
        if (k.length >= a) {
            priorityQueue.add(new Length(k.length - a));
        } else {
            priorityQueue.add(new Length(n - a));
            priorityQueue.add(k);
            ans++;
        }
        return ans;
    }

}

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

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

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

    public static void main(String[] args) throws IOException {
        FastReader scn = new FastReader();
        OutputStream out = new BufferedOutputStream(System.out);
        program(scn, out);
        out.flush();
    }

    public static void print(OutputStream out, Object str) throws IOException {
        out.write(str.toString().getBytes());
    }

    static class Length implements Comparable<Length> {
        Integer length;

        public Length(int length) {
            this.length = length;
        }

        @Override
        public int compareTo(Length o) {
            return o.length - this.length;
        }
    }

    private static void program(FastReader scn, OutputStream out) throws IOException {
        int n = scn.nextInt();
        int a = scn.nextInt();
        int b = scn.nextInt();
        PriorityQueue<Length> priorityQueue = new PriorityQueue<>();
        Integer ans = 0;
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(a);
        arrayList.add(b);
        arrayList.add(a);
        arrayList.add(a);
        arrayList.add(a);
        arrayList.add(b);
        Collections.sort(arrayList, Collections.reverseOrder());
        for(int i = 0; i < 6; i++)
            ans = helper(priorityQueue, ans, arrayList.get(i), n);
        print(out, ans);
    }

    private static Integer helper(PriorityQueue<Length> priorityQueue, Integer ans, int a, int n) {
        Length k = priorityQueue.poll();
        if (k == null) {
            priorityQueue.add(new Length(n - a));
            return 1;
        }
        if (k.length >= a) {
            priorityQueue.add(new Length(k.length - a));
        } else {
            priorityQueue.add(new Length(n - a));
            priorityQueue.add(k);
            ans++;
        }
        return ans;
    }

}

import java.util.Scanner;
public class frame{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n,a,b,nn=0;
        n = sc.nextInt();
        a = sc.nextInt();
        b = sc.nextInt();
        if(n>=2*b+4*a) System.out.println("1");
        else if(n>=b+2*a) System.out.println("2");
        else{
            if(n>=2*b+a){
                if(n>=3*a) System.out.println("2");
                else if(n>=2*a) System.out.println("3");
                else if(n>=a) System.out.println("4");
            }
            else{
                if(n>=2*b){
                    if(n>=4*a) nn=2;
                    else if(n>=2*a) nn=3;
                    else if(n>=a) nn=5;
                }else if(n>=b){

                    if(n>=4*a) nn=3;
                    else if(n>=2*a) nn=4;
                    else if(n>=a) nn=6;
                }
                if(n>=b+a){
                    if(n>=2*a){if(nn>3) nn=3;}
                    else if(n>=a){if(n>4) nn=4;}
                }
                System.out.println(nn);
            }
        }
    }
}

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

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);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();

	}

	static class TaskC {
		public void solve(int testNumber, InputReader in, PrintWriter out) {
			int n = in.nextInt();
			int a = in.nextInt();
			int b = in.nextInt();
			int bars = 0 ;

			int max = Math.max(a,b )	 ;
			int min = Math.min(a, b) ;

			if(n>=4*a + 2*b)
				bars = 1 ;
			else if(n>=3*a + b + max)
				bars = 2 ;
			else if(n>=3*a + b + min)
				bars = 2 ;
			else if(n>=2*a + b + max)
				bars = 2 ;
			else if(n>=2*a + b + min)
				bars = 2 ;
			else if(n>=a + b + max)
				bars = 2 ;
			else if(n>=a + b + min)
				if(min==a)
					bars = 2 ;
				else
					if (n>2*a)
						bars =3 ;
					else
						bars=4 ;
			else if(n>=a + b)
				if(n>=2*a)
					bars = 3 ;
				else
					bars = 4 ;
			else bars =6 ;

			out.print(bars);

		}
		public static boolean isPrime (long num){
			if (num < 2) return false;
			if (num == 2) return true;
			if (num % 2 == 0) return false;
			for (long i = 3*1l; i * i <= num; i += 2)
				if (num % i == 0) return false;
			return true;
		}
	}
	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());
		}

	}
	static class Vertix{
		int x ;
		ArrayList<Vertix> children;
		Vertix parent;

		public Vertix(int x){
			this.x = x ;
			this.children= new ArrayList<Vertix>();
		}

	}

	static class Pair implements Comparable<Pair> {
		int x ;
		int y ;

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

		}

		@Override
		public int compareTo(Pair p) {
			if (this.x < p.x)
				return -1;
			else if (this.x > p.x)
				return 1;
			else
				return 0;

		}
		//
	}

}

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

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);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();

	}

	static class TaskC {
		public void solve(int testNumber, InputReader in, PrintWriter out) {
			int n = in.nextInt();
			int a = in.nextInt();
			int b = in.nextInt();
			int bars = 0 ;

			int max = Math.max(a,b )	 ;
			int min = Math.min(a, b) ;

			if(n>=4*a + 2*b)
				bars = 1 ;
			else if(n>=3*a + b + max)
				bars = 2 ;
			else if(n>=3*a + b + min)
				bars = 2 ;
			else if(n>=2*a + b + max)
				bars = 2 ;
			else if(n>=2*a + b + min)
				bars = 2 ;
			else if(n>=a + b + max)
				bars = 2 ;
			else if(n>=a + b + min)
				if(min==a)
					bars = 2 ;
				else
					if (n>2*a)
						bars =3 ;
					else
						bars=4 ;
			else if(n>=a + b)
				if(n>=2*a)
					bars = 3 ;
				else
					bars = 4 ;
			else if(n>=4*a)
				if(n>=2*b)
					bars =2 ;
				else
					bars =3 ;
			else if(n>=3*a)
				if(n>=2*b)
					bars =3 ;
				else
					bars =4 ;
			else if(n>=2*a)
				if(n>=2*b)
					bars =3 ;
				else
					bars =4 ;
			else if(n>=a)
				if(n>=2*b)
					bars =5 ;
				else
					bars =6 ;

			else if(n>=2*b)
				if(n>=4*a)
					bars =2 ;
				else if(n>=3*a)
					bars =3 ;
				else if(n>=2*a)
					bars =4 ;
				else bars =5 ;
			else bars =6 ;

			out.print(bars);

		}
		public static boolean isPrime (long num){
			if (num < 2) return false;
			if (num == 2) return true;
			if (num % 2 == 0) return false;
			for (long i = 3*1l; i * i <= num; i += 2)
				if (num % i == 0) return false;
			return true;
		}
	}
	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());
		}

	}
	static class Vertix{
		int x ;
		ArrayList<Vertix> children;
		Vertix parent;

		public Vertix(int x){
			this.x = x ;
			this.children= new ArrayList<Vertix>();
		}

	}

	static class Pair implements Comparable<Pair> {
		int x ;
		int y ;

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

		}

		@Override
		public int compareTo(Pair p) {
			if (this.x < p.x)
				return -1;
			else if (this.x > p.x)
				return 1;
			else
				return 0;

		}
		//
	}

}

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

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);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();

	}

	static class TaskC {
		public void solve(int testNumber, InputReader in, PrintWriter out) {
			int n = in.nextInt();
			int a = in.nextInt();
			int b = in.nextInt();
			int bars = 0 ;

			int max = Math.max(a,b )	 ;
			int min = Math.min(a, b) ;

			if(n>=4*a + 2*b)
				bars = 1 ;
			else if(n>=3*a + b + max)
				bars = 2 ;
			else if(n>=3*a + b + min)
				bars = 2 ;
			else if(n>=2*a + b + max)
				bars = 2 ;
			else if(n>=2*a + b + min)
				bars = 2 ;
			else if(n>=a + b + max)
				bars = 2 ;
			else if(n>=a + b + min)
				if(min==a)
					bars = 2 ;
				else
					if (n>2*a)
						bars =3 ;
					else
						bars=4 ;
			else if(n>=a + b)
				if(n>=2*a)
					bars = 3 ;
				else
					bars = 4 ;
			else if(n>=2*a)
				if(n>=2*b)
					bars =3 ;
				else
					bars =4 ;
			else if(n>=2*b)
				if(n>=4*a)
					bars =2 ;
				else if(n>=3*a)
					bars =3 ;
				else if(n>=2*a)
					bars =4 ;
				else bars =5 ;
			else bars =6 ;

			out.print(bars);

		}
		public static boolean isPrime (long num){
			if (num < 2) return false;
			if (num == 2) return true;
			if (num % 2 == 0) return false;
			for (long i = 3*1l; i * i <= num; i += 2)
				if (num % i == 0) return false;
			return true;
		}
	}
	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());
		}

	}
	static class Vertix{
		int x ;
		ArrayList<Vertix> children;
		Vertix parent;

		public Vertix(int x){
			this.x = x ;
			this.children= new ArrayList<Vertix>();
		}

	}

	static class Pair implements Comparable<Pair> {
		int x ;
		int y ;

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

		}

		@Override
		public int compareTo(Pair p) {
			if (this.x < p.x)
				return -1;
			else if (this.x > p.x)
				return 1;
			else
				return 0;

		}
		//
	}

}

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) throws Exception {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int a = in.nextInt();
        int b = in.nextInt();
        Solution solver = new Solution();
        System.out.println(solver.solve(n, a, b));
    }

    public int solve(int n, int a, int b) {
        if (4 * a + 2 * b <= n) return 1;
        else if (2 * a + b <= n) return 2;
        else if (2 * a <= n && 2 * b <= n) return 3;
        else if (2 * a <= n && a + b <= n) return 3;
        else if (2 * a <= n && a + b > n) return 4;
        else if (2 * a > n && a + b <= n) return 4;
        else if (a + b > n && 2 * b <= n) return 5;
        else return 6;
    }
}

import java.util.Scanner;

public class Solution {
    public static void main(String[] args) throws Exception {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int a = in.nextInt();
        int b = in.nextInt();
        Solution solver = new Solution();
        System.out.println(solver.solve(n, a, b));
    }

    public int solve(int n, int a, int b) {
        if (4 * a + 2 * b <= n) return 1;
        else if (4 * a <= n && 2 * b <= n) return 2;
        else if (4 * a <= n && 2 * b > n) return 3;
        else if (2 * a + b <= n) return 2;
        else if (2 * a <= n && 2 * b <= n) return 3;
        else if (2 * a <= n && a + b <= n) return 3;
        else if (2 * a <= n && a + b > n) return 4;
        else if (2 * a > n && a + b <= n) return 4;
        else if (a + b > n && 2 * b <= n) return 5;
        else return 6;
    }
}

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

public class issam{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int a = sc.nextInt();
        int b = sc.nextInt();
        int k = n/a;
        int d = n/b;
        int f = (n%a)/b;
        int g = (n%b)/a;
        int r=0,h=0;
        if(k>=4){
            r=1;
            int aa = (n-4*a)/b;
            if(aa==1) r++;
            if(aa==0){
                if(d>=2) r++;
                else r+=2;
            }
        }
        if(k==3){
            r=2;
            int aa = (n-a)/b + f;
            if(aa==1) r++;
            if(aa==0){
                if(d>=2) r++;
                else r+=2;
            }
        }
        if(k==2){
            r=2;
            int aa = 2*f;
            if(aa==1) r++;
            if(aa==0){
                if(d>=2) r++;
                else r+=2;
            }
        }
        if(k==1){
            r=4;
            int aa = 4*f;
            if(aa==1) r++;
            if(aa==0){
                if(d>=2) r++;
                else r+=2;
            }
        }
        System.out.println(r);
    }
}

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int a= s.nextInt();
        int b=s.nextInt();
        int no =0;
        no++;
        int avai = n;
        avai = avai-b;
        if(avai>b){
            avai=avai-b;
        }
        else{
            avai=avai+n;
            no++;
            avai=avai-b;
        }
        if(avai>b){
            avai=avai-b;
        }else{
            avai=avai+n;
            no++;
            avai=avai-b;
        }
        if(avai>b){
            avai=avai-b;
        }else{
            avai=avai+n;
            no++;
            avai=avai-b;
        }
        if(avai>a){
            avai=avai-a;
        }
        else{
            avai=avai+n;
            no++;
            avai=avai-a;
        }
        if(avai>a){
            avai=avai-a;
        }
        else{
            avai=avai+n;
            no++;
            avai=avai-a;
        }
        System.out.println(no);
    }
}

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int a= s.nextInt();
        int b=s.nextInt();
        int no =0;
        if(n>=2*a){
            if(n>=3*a){
                if(n>=4*a){
                    if(n-4*a>=2*b){
                        no=1;
                    }else{
                        if(n-4*a>=b){
                            no=2;
                        }else{
                            if(n>=2*b){
                                no=2;
                            }else{
                                no=3;
                            }
                        }
                    }
                }else{
                    if(n-3*a>=2*b){
                        no=2;
                    }else{
                        if(n-3*a>=b){
                            no=2;
                        }else{
                            if(n-a>=2*b){
                                no=2;
                            }else{
                                if(n-a>=b){
                                    no=3;
                                }else{
                                    if(n>=2*b){
                                        no=3;
                                    }else{
                                        no=4;
                                    }
                                }
                            }
                        }
                    }
                }
            }else{
                if(n-2*a>=2*b){
                    no=2;
                }else{
                    if(n-2*a>=b){
                        no=2;
                    }else{
                        if(n>=2*b){
                            no=3;
                        }else{
                            if(n>=b){
                                no=3;
                            }else{
                                no=4;
                            }
                        }
                    }
                }
            }
        }else{
            if(n-a>=2*b){
                no=4;
            }else{
                if(n-a>=b){
                    no=4;
                }else{
                    if(n>2*b){
                        no=5;
                    }else{
                        no=6;
                    }
                }
            }
        }
        System.out.println(no);
    }
}

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 s = new Scanner(System.in);
		int n= s.nextInt();
		int a = s.nextInt();
		int b= s.nextInt();
		int remver = 4;
		int remhor = 2;
		int avai = n;
		int count = 1;
		while((remver | remhor)!=0){
			if(a>b){
				if(avai>=a && remver>0){
					avai = avai-a;remver--;
				}else if(avai>=b && remhor>0){
					avai = avai-b;remhor--;
				}else{
					if(remver>0){
						avai = n-a;count++;remver--;
					}else if(remhor>0){
						avai=n-b;count++;remhor--;
					}
				}
			}else{
				if(avai>=b && remhor>0){
					avai = avai-b;remhor--;
				}else if(avai>=a && remver>0){
					avai = avai-a;remver--;
				}else{
					if(remhor>0){
						avai = n-b;count++;remhor--;
					}else if(remver>0){
						avai=n-a;count++;remver--;
					}
				}
			}
		}
		if(n==2*a+b){
		    System.out.println(2*n);
		}else
		System.out.println(count);
	}
}

/* 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 s = new Scanner(System.in);
		int n= s.nextInt();
		int a = s.nextInt();
		int b= s.nextInt();
		int remver = 4;
		int remhor = 2;
		int avai = n;
		int count = 1;
		while((remver | remhor)!=0){
			if(a>b){
				if(avai>=a && remver>0){
					avai = avai-a;remver--;
				}else if(avai>=b && remhor>0){
					avai = avai-b;remhor--;
				}else{
					if(remver>0){
						avai = n-a;count++;remver--;
					}else if(remhor>0){
						avai=n-b;count++;remhor--;
					}
				}
			}else{
				if(avai>=b && remhor>0){
					avai = avai-b;remhor--;
				}else if(avai>=a && remver>0){
					avai = avai-a;remver--;
				}else{
					if(remhor>0){
						avai = n-b;count++;remhor--;
					}else if(remver>0){
						avai=n-a;count++;remver--;
					}
				}
			}
		}
		System.out.println(count);
	}
}

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int a= s.nextInt();
        int b=s.nextInt();
        int no =0;
        no++;
        int avai = n;
        avai = avai-a;
        if(avai>=a){
            avai=avai-a;
        }
        else{
            avai=avai+n;
            no++;
            avai=avai-a;
        }
        if(avai>=a){
            avai=avai-a;
        }else{
            avai=avai+n;
            no++;
            avai=avai-a;
        }
        if(avai>=a){
            avai=avai-a;
        }else{
            avai=avai+n;
            no++;
            avai=avai-a;
        }
        if(avai>=b){
            avai=avai-b;
        }
        else{
            avai=avai+n;
            no++;
            avai=avai-b;
        }
        if(avai>=b){
            avai=avai-b;
        }
        else{
            avai=avai+n;
            no++;
            avai=avai-b;
        }
        System.out.println(no);
    }
}

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int a= s.nextInt();
        int b=s.nextInt();
        int no =0;
        if(n>=2*a){
            if(n>=3*a){
                if(n>=4*a){
                    if(n-4*a>=2*b){
                        no=1;
                    }else if(n>=2*b){
                        no=2;
                    }
                    else{
                        no=3;
                    }
                }else{
                    if(n-3*a>=b){
                        no=2;
                    }else{
                        if(n-a>=2*b){
                            no=2;
                        }else{
                            no=4;
                        }
                    }
                }
            }else{
                if(n-2*a>=b){
                    no=2;
                }else{
                    no=4;
                }
            }
        }else{
            if(n-a>=b){
                no=4;
            }else{
                no=6;
            }
        }
        System.out.println(no);
    }
}

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int a= s.nextInt();
        int b=s.nextInt();
        int no =0;
        no++;
        int avai = n;
        avai = avai-a;
        if(avai>a){
            avai=avai-a;
        }
        else{
            avai=avai+n;
            no++;
            avai=avai-a;
        }
        if(avai>a){
            avai=avai-a;
        }else{
            avai=avai+n;
            no++;
            avai=avai-a;
        }
        if(avai>a){
            avai=avai-a;
        }else{
            avai=avai+n;
            no++;
            avai=avai-a;
        }
        if(avai>b){
            avai=avai-b;
        }
        else{
            avai=avai+n;
            no++;
            avai=avai-b;
        }
        if(avai>b){
            avai=avai-b;
        }
        else{
            avai=avai+n;
            no++;
            avai=avai-b;
        }
        System.out.println(no);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.util.Stack;

public class Main {
	static Scanner scan = new Scanner(System.in);
	static PrintStream out = new PrintStream(System.out);
	//static PrintWriter out = new PrintWriter(System.out);
	//static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
	static int n, a, b;

	public static void main (String[] args) throws IOException {
	    n = scan.nextInt();
	    a = scan.nextInt();
	    b = scan.nextInt();
	    int count = 0;
	    int needA = 4;
	    int needB = 2;
	    int min = Math.min(a, b);
	    if (a >= b) {
	    	while (needA > 0 || needB > 0) {
	    		int n1 = n;
	    		while (n1 >= min && (needA > 0 || needB > 0)) {
	    			//out.println(n1);
	    			if (n1 >= a && needA > 0) {n1-=a; needA--;}
	    			else if (n1 >= b && needB > 0) {n1-=b; needB--;}
	    			else break;
	    		}
	    		count++;
	    		//out.println(count + " " + needA + " " + needB);
	    	}
	    } else {
	    	while (needA > 0 || needB > 0) {
	    		int n1 = n;
	    		while (n1 >= min && (needA > 0 || needB > 0)) {
	    			//out.println(n1);
	    			if (n1 >= b && needB > 0) {n1-=b; needB--;}
	    			else if (n1 >= a && needA > 0) {n1-=a; needA--;}
	    			else break;
	    		}
	    		count++;
	    		//out.println(count + " " + needA + " " + needB);
	    	}
	    }
	    out.println(count);
	}
}

/**
 * Created by Chirag on 22-12-2017.
 * DA-IICT (B.tech 3rd year)
 */

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

public class DoorFrames {
    public static void main(String[] args) {
        MyScanner sc = new MyScanner();
        out = new PrintWriter(new BufferedOutputStream(System.out));

      /*
      int n      = sc.nextInt();        // read input as integer
      long k     = sc.nextLong();       // read input as long
      double d   = sc.nextDouble();     // read input as double
      String str = sc.next();           // read input as String
      String s   = sc.nextLine();       // read whole line as String

      int result = 3*n;
      out.println(result);                    // print via PrintWriter
      */
        //The Code Starts here
        int lengthOfBar=sc.nextInt();
        int lengthOfVertical=sc.nextInt();
        int lengthOfHorizontal=sc.nextInt();
        int noOfVertical=4;
        int noOfHorizontal=2;

        int noOfBarsNeeded=0;
        int newBar=lengthOfBar;
        while (!(noOfHorizontal==0 && noOfVertical==0) )
        {
            if (lengthOfVertical>lengthOfHorizontal) {
                if(noOfVertical!=0)
                {
                    int oldNoOfVertical=noOfVertical;
                    noOfVertical-=Math.min((newBar/lengthOfVertical),noOfVertical);
                    newBar=newBar -Math.min((lengthOfVertical)*(newBar/lengthOfVertical),oldNoOfVertical*lengthOfVertical);

                    if(newBar>=lengthOfHorizontal)
                    {
                        int oldNoOfHorizontal=noOfHorizontal;
                        noOfHorizontal-=Math.min((newBar/lengthOfHorizontal),noOfHorizontal);
                        newBar=newBar -Math.min((lengthOfHorizontal)*(newBar/lengthOfHorizontal),oldNoOfHorizontal*lengthOfHorizontal);

                    }
                }
                else
                {
                    noOfHorizontal-=Math.min((newBar/lengthOfHorizontal),noOfHorizontal);
                    newBar=newBar -Math.min((lengthOfHorizontal)*(newBar/lengthOfHorizontal),noOfHorizontal*lengthOfHorizontal);

                }
            }
            else
            {
                if(noOfHorizontal!=0)
                {
                    int oldNoOfHorizontal=noOfHorizontal;
                    noOfHorizontal-=Math.min((newBar/lengthOfHorizontal),noOfHorizontal);
                    newBar=newBar -Math.min((lengthOfHorizontal)*(newBar/lengthOfHorizontal),oldNoOfHorizontal*lengthOfHorizontal);

                    if(newBar>=lengthOfVertical)
                    {
                        int oldNoOfVertical=noOfVertical;
                        noOfVertical-=Math.min((newBar/lengthOfVertical),noOfVertical);
                        newBar=newBar -Math.min((lengthOfVertical)*(newBar/lengthOfVertical),oldNoOfVertical*lengthOfVertical);

                    }
                }
                else
                {
                    noOfVertical-=Math.min((newBar/lengthOfVertical),noOfVertical);
                    newBar=newBar -Math.min((lengthOfVertical)*(newBar/lengthOfVertical),noOfVertical*lengthOfVertical);

                }
            }
            noOfBarsNeeded++;
            newBar=lengthOfBar;
//            debug(newBar,noOfVertical,noOfHorizontal);
        }
        out.print(noOfBarsNeeded);

        //The Code ends here
        out.close();
    }

    //-----------PrintWriter for faster output---------------------------------
    public static PrintWriter out;

    //-----------MyScanner class for faster input----------
    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

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

        char nextCharacter() {
            return next().charAt(0);
        }

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

        public int[] nextIntArray(int n) {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextInt();
            }
            return arr;
        }

        public long[] nextLongArray(int n) {
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextLong();
            }
            return arr;
        }

        public int[][] nextInt2DArray(int m, int n) {
            int[][] arr = new int[m][n];
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++)
                    arr[i][j] = nextInt();
            }
            return arr;
        }

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

    }

    public static void debug(Object... o) {
        System.out.println(Arrays.deepToString(o));
    }

    public static class Pair implements Comparable<Pair> {
        long u;
        long v;

        public Pair(long u, long v) {
            this.u = u;
            this.v = v;
        }

        public int hashCode() {
            int hu = (int) (u ^ (u >>> 32));
            int hv = (int) (v ^ (v >>> 32));
            return 31 * hu + hv;
        }

        public boolean equals(Object o) {
            Pair other = (Pair) o;
            return u == other.u && v == other.v;
        }

        public int compareTo(Pair other) {
            return Long.compare(u, other.u) != 0 ? Long.compare(u, other.u) : Long.compare(v, other.v);
        }

        public String toString() {
            return "[u=" + u + ", v=" + v + "]";
        }
    }
    //--------------------------------------------------------

    // Different other methods

    public static long pow(long n, long p, long mod) {
        if (p == 0)
            return 1;
        if (p == 1)
            return n % mod;
        if (p % 2 == 0) {
            long temp = pow(n, p / 2, mod);
            return (temp * temp) % mod;
        } else {
            long temp = pow(n, p / 2, mod);
            temp = (temp * temp) % mod;
            return (temp * n) % mod;

        }
    }

    public static long pow(long n, long p) {
        if (p == 0)
            return 1;
        if (p == 1)
            return n;
        if (p % 2 == 0) {
            long temp = pow(n, p / 2);
            return (temp * temp);
        } else {
            long temp = pow(n, p / 2);
            temp = (temp * temp);
            return (temp * n);

        }
    }

    public static long gcd(long x, long y) {
        if (x == 0)
            return y;
        else
            return gcd(y % x, x);
    }

    static long modInverse(long a, long m) {
        long m0 = m, t, q;
        long x0 = 0, x1 = 1;

        if (m == 1)
            return 0;

        while (a > 1) {
            // q is quotient
            q = a / m;

            t = m;

            // m is remainder now, process
            // same as Euclid's algo
            m = a % m;
            a = t;

            t = x0;

            x0 = x1 - q * x0;

            x1 = t;
        }

        // Make x1 positive
        if (x1 < 0)
            x1 += m0;

        return x1;
    }

    public static boolean isPrime(int n) {
        if (n <= 1)
            return false;
        if (n <= 3)
            return true;

        if (n % 2 == 0 || n % 3 == 0)
            return false;

        for (int i = 5; i * i <= n; i = i + 6)
            if (n % i == 0 || n % (i + 2) == 0)
                return false;

        return true;
    }

    public static class DisjointSet {
        HashMap<Integer, Node> map = new HashMap<Integer, Node>();

        class Node {
            int data;
            int rank;
            Node parent;

            Node(int data) {
                this.data = data;
                this.rank = 0;
                this.parent = this;
            }
        }

        void makeSet(int data) {
            map.put(data, new Node(data));
        }

        Node findSet(int data) {
            return findSet(map.get(data));
        }

        boolean isConnected(int d1, int d2) {
            return findSet(d1) == findSet(d2);
        }

        Node findSet(Node node) {
            Node parent = node.parent;
            if (parent == node)
                return parent;
            node.parent = findSet(node.parent);
            return node.parent;
        }

        void union(int data1, int data2) {
            Node d1 = map.get(data1);
            Node d2 = map.get(data2);

            Node p1 = findSet(d1);
            Node p2 = findSet(d2);

            if (p1.data == p2.data)
                return;

            if (p1.rank >= p2.rank) {
                p1.rank = (p1.rank == p2.rank) ? p1.rank + 1 : p1.rank;
                p2.parent = p1;
            } else {
                p1.parent = p2;
            }
        }

    }

}

/**
 * Created by Chirag on 22-12-2017.
 * DA-IICT (B.tech 3rd year)
 */

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

public class DoorFrames {
    public static void main(String[] args) {
        MyScanner sc = new MyScanner();
        out = new PrintWriter(new BufferedOutputStream(System.out));

      /*
      int n      = sc.nextInt();        // read input as integer
      long k     = sc.nextLong();       // read input as long
      double d   = sc.nextDouble();     // read input as double
      String str = sc.next();           // read input as String
      String s   = sc.nextLine();       // read whole line as String

      int result = 3*n;
      out.println(result);                    // print via PrintWriter
      */
        //The Code Starts here
        int lengthOfBar=sc.nextInt();
        int lengthOfVertical=sc.nextInt();
        int lengthOfHorizontal=sc.nextInt();
        int noOfVertical=4;
        int noOfHorizontal=2;

        int noOfBarsNeeded=0;
        int newBar=lengthOfBar;
        while (!(noOfHorizontal==0 && noOfVertical==0) )
        {
            if(noOfVertical!=0)
            {
                int oldNoOfVertical=noOfVertical;
                noOfVertical-=Math.min((newBar/lengthOfVertical),noOfVertical);
                newBar=newBar -Math.min((lengthOfVertical)*(newBar/lengthOfVertical),oldNoOfVertical*lengthOfVertical);

                if(newBar>=lengthOfHorizontal)
                {
                    int oldNoOfHorizontal=noOfHorizontal;
                    noOfHorizontal-=Math.min((newBar/lengthOfHorizontal),noOfHorizontal);
                    newBar=newBar -Math.min((lengthOfHorizontal)*(newBar/lengthOfHorizontal),oldNoOfHorizontal*lengthOfHorizontal);

                }
            }
            else
            {
                noOfHorizontal-=Math.min((newBar/lengthOfHorizontal),noOfHorizontal);
                newBar=newBar -Math.min((lengthOfHorizontal)*(newBar/lengthOfHorizontal),noOfHorizontal*lengthOfHorizontal);

            }
            noOfBarsNeeded++;
            newBar=lengthOfBar;
//            debug(newBar,noOfVertical,noOfHorizontal);
        }
        out.print(noOfBarsNeeded);

        //The Code ends here
        out.close();
    }

    //-----------PrintWriter for faster output---------------------------------
    public static PrintWriter out;

    //-----------MyScanner class for faster input----------
    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

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

        char nextCharacter() {
            return next().charAt(0);
        }

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

        public int[] nextIntArray(int n) {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextInt();
            }
            return arr;
        }

        public long[] nextLongArray(int n) {
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextLong();
            }
            return arr;
        }

        public int[][] nextInt2DArray(int m, int n) {
            int[][] arr = new int[m][n];
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++)
                    arr[i][j] = nextInt();
            }
            return arr;
        }

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

    }

    public static void debug(Object... o) {
        System.out.println(Arrays.deepToString(o));
    }

    public static class Pair implements Comparable<Pair> {
        long u;
        long v;

        public Pair(long u, long v) {
            this.u = u;
            this.v = v;
        }

        public int hashCode() {
            int hu = (int) (u ^ (u >>> 32));
            int hv = (int) (v ^ (v >>> 32));
            return 31 * hu + hv;
        }

        public boolean equals(Object o) {
            Pair other = (Pair) o;
            return u == other.u && v == other.v;
        }

        public int compareTo(Pair other) {
            return Long.compare(u, other.u) != 0 ? Long.compare(u, other.u) : Long.compare(v, other.v);
        }

        public String toString() {
            return "[u=" + u + ", v=" + v + "]";
        }
    }
    //--------------------------------------------------------

    // Different other methods

    public static long pow(long n, long p, long mod) {
        if (p == 0)
            return 1;
        if (p == 1)
            return n % mod;
        if (p % 2 == 0) {
            long temp = pow(n, p / 2, mod);
            return (temp * temp) % mod;
        } else {
            long temp = pow(n, p / 2, mod);
            temp = (temp * temp) % mod;
            return (temp * n) % mod;

        }
    }

    public static long pow(long n, long p) {
        if (p == 0)
            return 1;
        if (p == 1)
            return n;
        if (p % 2 == 0) {
            long temp = pow(n, p / 2);
            return (temp * temp);
        } else {
            long temp = pow(n, p / 2);
            temp = (temp * temp);
            return (temp * n);

        }
    }

    public static long gcd(long x, long y) {
        if (x == 0)
            return y;
        else
            return gcd(y % x, x);
    }

    static long modInverse(long a, long m) {
        long m0 = m, t, q;
        long x0 = 0, x1 = 1;

        if (m == 1)
            return 0;

        while (a > 1) {
            // q is quotient
            q = a / m;

            t = m;

            // m is remainder now, process
            // same as Euclid's algo
            m = a % m;
            a = t;

            t = x0;

            x0 = x1 - q * x0;

            x1 = t;
        }

        // Make x1 positive
        if (x1 < 0)
            x1 += m0;

        return x1;
    }

    public static boolean isPrime(int n) {
        if (n <= 1)
            return false;
        if (n <= 3)
            return true;

        if (n % 2 == 0 || n % 3 == 0)
            return false;

        for (int i = 5; i * i <= n; i = i + 6)
            if (n % i == 0 || n % (i + 2) == 0)
                return false;

        return true;
    }

    public static class DisjointSet {
        HashMap<Integer, Node> map = new HashMap<Integer, Node>();

        class Node {
            int data;
            int rank;
            Node parent;

            Node(int data) {
                this.data = data;
                this.rank = 0;
                this.parent = this;
            }
        }

        void makeSet(int data) {
            map.put(data, new Node(data));
        }

        Node findSet(int data) {
            return findSet(map.get(data));
        }

        boolean isConnected(int d1, int d2) {
            return findSet(d1) == findSet(d2);
        }

        Node findSet(Node node) {
            Node parent = node.parent;
            if (parent == node)
                return parent;
            node.parent = findSet(node.parent);
            return node.parent;
        }

        void union(int data1, int data2) {
            Node d1 = map.get(data1);
            Node d2 = map.get(data2);

            Node p1 = findSet(d1);
            Node p2 = findSet(d2);

            if (p1.data == p2.data)
                return;

            if (p1.rank >= p2.rank) {
                p1.rank = (p1.rank == p2.rank) ? p1.rank + 1 : p1.rank;
                p2.parent = p1;
            } else {
                p1.parent = p2;
            }
        }

    }

}

/*
 *
 * @Author  Ajudiya_13(Bhargav Girdharbhai Ajudiya)
 * Dhirubhai Ambani Institute of Information And Communication Technology
 *
 */

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

public class Code275
{

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

		int n = in.nextInt();
		int a = in.nextInt();
		int b = in.nextInt();
		int ans = 0;
		if(4*a+2*b<=n)
			ans = 1;
		else if((4*a<=n && 2*b<=n) || (3*a+b)<=n || (2*a+b)<=n || (3*a<=n && a+2*b<=n))
			ans = 2;
		else if(a+b<=n && 2*a<=n)
			ans = 3;
		else if(a+b<=n && a<=n)
			ans = 4;
		else if(a<=n && 2*b<=n)
			ans = 5;
		else
			ans = 6;

		pw.print(ans);
		pw.flush();
		pw.close();
	}

	static class InputReader
	{

		private final InputStream stream;
		private final byte[] buf = new byte[8192];
		private int curChar, snumChars;
		private SpaceCharFilter filter;

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

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

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

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

		public int[] nextIntArray(int n)
		{
			int a[] = new int[n];
			for (int i = 0; i < n; i++)
			{
				a[i] = nextInt();
			}
			return a;
		}

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

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

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

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

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

	public static long mod = 1000000007;
	public static int d;
	public static int p;
	public static int q;

	public static int[] suffle(int[] a,Random gen)
	{
		int n = a.length;
		for(int i=0;i<n;i++)
		{
			int ind = gen.nextInt(n-i)+i;
			int temp = a[ind];
			a[ind] = a[i];
			a[i] = temp;
		}
		return a;
	}

	public static void swap(int a, int b){
		int temp = a;
		a = b;
		b = temp;
	}

	public static HashSet<Integer> primeFactorization(int n)
	{
		HashSet<Integer> a =new HashSet<Integer>();
		for(int i=2;i*i<=n;i++)
		{
			while(n%i==0)
			{
				a.add(i);
				n/=i;
			}
		}
		if(n!=1)
			a.add(n);
		return a;
	}

	public static void sieve(boolean[] isPrime,int n)
	{
		for(int i=1;i<n;i++)
			isPrime[i] = true;

		isPrime[0] = false;
		isPrime[1] = false;

		for(int i=2;i*i<n;i++)
		{
			if(isPrime[i] == true)
			{
				for(int j=(2*i);j<n;j+=i)
					isPrime[j] = false;
			}
		}
	}

	public static int GCD(int a,int b)
	{
		if(b==0)
			return a;
		else
			return GCD(b,a%b);
	}

	public static long GCD(long a,long b)
	{
		if(b==0)
			return a;
		else
			return GCD(b,a%b);
	}

	public static void extendedEuclid(int A,int B)
	{
		if(B==0)
		{
			d = A;
			p = 1 ;
			q = 0;
		}
		else
		{
			extendedEuclid(B, A%B);
			int temp = p;
			p = q;
			q = temp - (A/B)*q;
		}
	}

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

	public static int LCM(int a,int b)
	{
		return (a*b)/GCD(a,b);
	}

	public static int binaryExponentiation(int x,int n)
	{
	    int result=1;
	    while(n>0)
	    {
	        if(n % 2 ==1)
	            result=result * x;
	        x=x*x;
	        n=n/2;
	    }
	    return result;
	}

	public static long binaryExponentiation(long x,long n)
	{
	    long result=1;
	    while(n>0)
	    {
	        if(n % 2 ==1)
	            result=result * x;
	        x=x*x;
	        n=n/2;
	    }
	    return result;
	}

	public static int modularExponentiation(int x,int n,int M)
	{
	    int result=1;
	    while(n>0)
	    {
	        if(n % 2 ==1)
	            result=(result * x)%M;
	        x=(x*x)%M;
	        n=n/2;
	    }
	    return result;
	}

	public static long modularExponentiation(long x,long n,long M)
	{
	    long result=1;
	    while(n>0)
	    {
	        if(n % 2 ==1)
	            result=(result * x)%M;
	        x=(x*x)%M;
	        n=n/2;
	    }
	    return result;
	}

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

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

	public static boolean isPrime(int n)
	{

	    if (n <= 1)  return false;
	    if (n <= 3)  return true;

	    if (n%2 == 0 || n%3 == 0)
	    	return false;

	    for (int i=5; i*i<=n; i=i+6)
	    {
	        if (n%i == 0 || n%(i+2) == 0)
	           return false;
	    }

	    return true;
	}

	static class pair implements Comparable<pair>
	{
		Integer x, y;
		pair(int x,int y)
		{
			this.x=x;
			this.y=y;
		}

		public int compareTo(pair o) {
			int result = x.compareTo(o.x);
			if(result==0)
				result = y.compareTo(o.y);

			return result;
		}

		public String toString()
		{
			return x+" "+y;
		}

		public boolean equals(Object o)
		{
			if (o instanceof pair)
		    {
				pair p = (pair)o;
				return p.x == x && p.y == y ;
			}
			return false;
		}

		public int hashCode()
		{
			return new Long(x).hashCode()*31 + new Long(y).hashCode();
		}
	}
}

/*
 *
 * @Author  Ajudiya_13(Bhargav Girdharbhai Ajudiya)
 * Dhirubhai Ambani Institute of Information And Communication Technology
 *
 */

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

public class Code275
{

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

		int n = in.nextInt();
		int a = in.nextInt();
		int b = in.nextInt();
		int ans = 0;
		if(4*a+2*b<=n)
			ans = 1;
		else if((4*a<=n && 2*b<=n) || (3*a+b)<=n || (2*a+b)<=n || (3*a<=n && a+2*b<=n))
			ans = 2;
		else if((a+b<=n && 2*a<=n) || (4*a<=n && b<=n))
			ans = 3;
		else if(a+b<=n && a<=n)
			ans = 4;
		else if(a<=n && 2*b<=n)
			ans = 5;
		else
			ans = 6;

		pw.print(ans);
		pw.flush();
		pw.close();
	}

	static class InputReader
	{

		private final InputStream stream;
		private final byte[] buf = new byte[8192];
		private int curChar, snumChars;
		private SpaceCharFilter filter;

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

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

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

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

		public int[] nextIntArray(int n)
		{
			int a[] = new int[n];
			for (int i = 0; i < n; i++)
			{
				a[i] = nextInt();
			}
			return a;
		}

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

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

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

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

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

	public static long mod = 1000000007;
	public static int d;
	public static int p;
	public static int q;

	public static int[] suffle(int[] a,Random gen)
	{
		int n = a.length;
		for(int i=0;i<n;i++)
		{
			int ind = gen.nextInt(n-i)+i;
			int temp = a[ind];
			a[ind] = a[i];
			a[i] = temp;
		}
		return a;
	}

	public static void swap(int a, int b){
		int temp = a;
		a = b;
		b = temp;
	}

	public static HashSet<Integer> primeFactorization(int n)
	{
		HashSet<Integer> a =new HashSet<Integer>();
		for(int i=2;i*i<=n;i++)
		{
			while(n%i==0)
			{
				a.add(i);
				n/=i;
			}
		}
		if(n!=1)
			a.add(n);
		return a;
	}

	public static void sieve(boolean[] isPrime,int n)
	{
		for(int i=1;i<n;i++)
			isPrime[i] = true;

		isPrime[0] = false;
		isPrime[1] = false;

		for(int i=2;i*i<n;i++)
		{
			if(isPrime[i] == true)
			{
				for(int j=(2*i);j<n;j+=i)
					isPrime[j] = false;
			}
		}
	}

	public static int GCD(int a,int b)
	{
		if(b==0)
			return a;
		else
			return GCD(b,a%b);
	}

	public static long GCD(long a,long b)
	{
		if(b==0)
			return a;
		else
			return GCD(b,a%b);
	}

	public static void extendedEuclid(int A,int B)
	{
		if(B==0)
		{
			d = A;
			p = 1 ;
			q = 0;
		}
		else
		{
			extendedEuclid(B, A%B);
			int temp = p;
			p = q;
			q = temp - (A/B)*q;
		}
	}

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

	public static int LCM(int a,int b)
	{
		return (a*b)/GCD(a,b);
	}

	public static int binaryExponentiation(int x,int n)
	{
	    int result=1;
	    while(n>0)
	    {
	        if(n % 2 ==1)
	            result=result * x;
	        x=x*x;
	        n=n/2;
	    }
	    return result;
	}

	public static long binaryExponentiation(long x,long n)
	{
	    long result=1;
	    while(n>0)
	    {
	        if(n % 2 ==1)
	            result=result * x;
	        x=x*x;
	        n=n/2;
	    }
	    return result;
	}

	public static int modularExponentiation(int x,int n,int M)
	{
	    int result=1;
	    while(n>0)
	    {
	        if(n % 2 ==1)
	            result=(result * x)%M;
	        x=(x*x)%M;
	        n=n/2;
	    }
	    return result;
	}

	public static long modularExponentiation(long x,long n,long M)
	{
	    long result=1;
	    while(n>0)
	    {
	        if(n % 2 ==1)
	            result=(result * x)%M;
	        x=(x*x)%M;
	        n=n/2;
	    }
	    return result;
	}

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

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

	public static boolean isPrime(int n)
	{

	    if (n <= 1)  return false;
	    if (n <= 3)  return true;

	    if (n%2 == 0 || n%3 == 0)
	    	return false;

	    for (int i=5; i*i<=n; i=i+6)
	    {
	        if (n%i == 0 || n%(i+2) == 0)
	           return false;
	    }

	    return true;
	}

	static class pair implements Comparable<pair>
	{
		Integer x, y;
		pair(int x,int y)
		{
			this.x=x;
			this.y=y;
		}

		public int compareTo(pair o) {
			int result = x.compareTo(o.x);
			if(result==0)
				result = y.compareTo(o.y);

			return result;
		}

		public String toString()
		{
			return x+" "+y;
		}

		public boolean equals(Object o)
		{
			if (o instanceof pair)
		    {
				pair p = (pair)o;
				return p.x == x && p.y == y ;
			}
			return false;
		}

		public int hashCode()
		{
			return new Long(x).hashCode()*31 + new Long(y).hashCode();
		}
	}
}

/*
 *
 * @Author  Ajudiya_13(Bhargav Girdharbhai Ajudiya)
 * Dhirubhai Ambani Institute of Information And Communication Technology
 *
 */

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

public class Code275
{

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

		int n = in.nextInt();
		int a = in.nextInt();
		int b = in.nextInt();

		int x = n/a;
		int y = n/b;
		int moda = n%a;
		int modb = n%b;

		int ans = 6;
		if(moda>=b || moda==0)
		{
			if(n/a==4)
			{
				int p = 2 - moda/b;
				if(p<=0)
					ans = Math.min(ans, 1);
				else
				{
					//System.out.println("xx");
					ans = Math.min(ans, 1+(int)Math.ceil((double)p/y));
				}
			}
			else if(n/a>4)
			{

				int p = 2 - (n-4*a)/b;
				if(p<=0)
					ans = Math.min(ans, 1);
				else
					ans = Math.min(ans, 1+(int)Math.ceil((double)p/y));
			}
			else if(n/a<4)
			{
				ans = Math.min(ans, (int)Math.ceil(4/(double)x));
			}
		}
		else if(modb>=a || modb==0)
		{
			if(n/b==2)
			{
				int p = 4 - modb/a;
				if(p<=0)
					ans = Math.min(ans, 1);
				else
					ans = Math.min(ans, 1+(int)Math.ceil((double)p/x));
			}
			else if(n/b>2)
			{
				int p = 4 - (n-2*b)/a;
				if(p<=0)
					ans = Math.min(ans, 1);
				else
					ans = Math.min(ans, 1+(int)Math.ceil((double)p/x));
			}
			else if(n/b==1)
			{
				int p = 4 - 2*(modb/a);
				if(p<=0)
					ans = Math.min(ans, 2);
				else
					ans = Math.min(ans, 2+(int)Math.ceil((double)p/x));
			}

		}
		pw.println(ans);
		pw.flush();
		pw.close();
	}

	static class InputReader
	{

		private final InputStream stream;
		private final byte[] buf = new byte[8192];
		private int curChar, snumChars;
		private SpaceCharFilter filter;

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

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

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

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

		public int[] nextIntArray(int n)
		{
			int a[] = new int[n];
			for (int i = 0; i < n; i++)
			{
				a[i] = nextInt();
			}
			return a;
		}

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

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

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

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

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

	public static long mod = 1000000007;
	public static int d;
	public static int p;
	public static int q;

	public static int[] suffle(int[] a,Random gen)
	{
		int n = a.length;
		for(int i=0;i<n;i++)
		{
			int ind = gen.nextInt(n-i)+i;
			int temp = a[ind];
			a[ind] = a[i];
			a[i] = temp;
		}
		return a;
	}

	public static void swap(int a, int b){
		int temp = a;
		a = b;
		b = temp;
	}

	public static HashSet<Integer> primeFactorization(int n)
	{
		HashSet<Integer> a =new HashSet<Integer>();
		for(int i=2;i*i<=n;i++)
		{
			while(n%i==0)
			{
				a.add(i);
				n/=i;
			}
		}
		if(n!=1)
			a.add(n);
		return a;
	}

	public static void sieve(boolean[] isPrime,int n)
	{
		for(int i=1;i<n;i++)
			isPrime[i] = true;

		isPrime[0] = false;
		isPrime[1] = false;

		for(int i=2;i*i<n;i++)
		{
			if(isPrime[i] == true)
			{
				for(int j=(2*i);j<n;j+=i)
					isPrime[j] = false;
			}
		}
	}

	public static int GCD(int a,int b)
	{
		if(b==0)
			return a;
		else
			return GCD(b,a%b);
	}

	public static long GCD(long a,long b)
	{
		if(b==0)
			return a;
		else
			return GCD(b,a%b);
	}

	public static void extendedEuclid(int A,int B)
	{
		if(B==0)
		{
			d = A;
			p = 1 ;
			q = 0;
		}
		else
		{
			extendedEuclid(B, A%B);
			int temp = p;
			p = q;
			q = temp - (A/B)*q;
		}
	}

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

	public static int LCM(int a,int b)
	{
		return (a*b)/GCD(a,b);
	}

	public static int binaryExponentiation(int x,int n)
	{
	    int result=1;
	    while(n>0)
	    {
	        if(n % 2 ==1)
	            result=result * x;
	        x=x*x;
	        n=n/2;
	    }
	    return result;
	}

	public static long binaryExponentiation(long x,long n)
	{
	    long result=1;
	    while(n>0)
	    {
	        if(n % 2 ==1)
	            result=result * x;
	        x=x*x;
	        n=n/2;
	    }
	    return result;
	}

	public static int modularExponentiation(int x,int n,int M)
	{
	    int result=1;
	    while(n>0)
	    {
	        if(n % 2 ==1)
	            result=(result * x)%M;
	        x=(x*x)%M;
	        n=n/2;
	    }
	    return result;
	}

	public static long modularExponentiation(long x,long n,long M)
	{
	    long result=1;
	    while(n>0)
	    {
	        if(n % 2 ==1)
	            result=(result * x)%M;
	        x=(x*x)%M;
	        n=n/2;
	    }
	    return result;
	}

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

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

	public static boolean isPrime(int n)
	{

	    if (n <= 1)  return false;
	    if (n <= 3)  return true;

	    if (n%2 == 0 || n%3 == 0)
	    	return false;

	    for (int i=5; i*i<=n; i=i+6)
	    {
	        if (n%i == 0 || n%(i+2) == 0)
	           return false;
	    }

	    return true;
	}

	static class pair implements Comparable<pair>
	{
		Integer x, y;
		pair(int x,int y)
		{
			this.x=x;
			this.y=y;
		}

		public int compareTo(pair o) {
			int result = x.compareTo(o.x);
			if(result==0)
				result = y.compareTo(o.y);

			return result;
		}

		public String toString()
		{
			return x+" "+y;
		}

		public boolean equals(Object o)
		{
			if (o instanceof pair)
		    {
				pair p = (pair)o;
				return p.x == x && p.y == y ;
			}
			return false;
		}

		public int hashCode()
		{
			return new Long(x).hashCode()*31 + new Long(y).hashCode();
		}
	}
}

/*
 *
 * @Author  Ajudiya_13(Bhargav Girdharbhai Ajudiya)
 * Dhirubhai Ambani Institute of Information And Communication Technology
 *
 */

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

public class Code275
{

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

		int n = in.nextInt();
		int a = in.nextInt();
		int b = in.nextInt();
		int ans = 0;
		if(4*a+2*b<=n)
			ans = 1;
		else if((4*a<=n && 2*b<=n) || (3*a+b)<=n || (2*a+b)<=n || (3*a<=n && a+2*b<=n))
			ans = 2;
		else if((a+b<=n && 2*a<=n) || (4*a<=n && b<=n))
			ans = 3;
		else if((a+b<=n && a<=n) || (3*a<=n && b<=n))
			ans = 4;
		else if(a<=n && 2*b<=n)
			ans = 5;
		else
			ans = 6;

		pw.print(ans);
		pw.flush();
		pw.close();
	}

	static class InputReader
	{

		private final InputStream stream;
		private final byte[] buf = new byte[8192];
		private int curChar, snumChars;
		private SpaceCharFilter filter;

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

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

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

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

		public int[] nextIntArray(int n)
		{
			int a[] = new int[n];
			for (int i = 0; i < n; i++)
			{
				a[i] = nextInt();
			}
			return a;
		}

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

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

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

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

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

	public static long mod = 1000000007;
	public static int d;
	public static int p;
	public static int q;

	public static int[] suffle(int[] a,Random gen)
	{
		int n = a.length;
		for(int i=0;i<n;i++)
		{
			int ind = gen.nextInt(n-i)+i;
			int temp = a[ind];
			a[ind] = a[i];
			a[i] = temp;
		}
		return a;
	}

	public static void swap(int a, int b){
		int temp = a;
		a = b;
		b = temp;
	}

	public static HashSet<Integer> primeFactorization(int n)
	{
		HashSet<Integer> a =new HashSet<Integer>();
		for(int i=2;i*i<=n;i++)
		{
			while(n%i==0)
			{
				a.add(i);
				n/=i;
			}
		}
		if(n!=1)
			a.add(n);
		return a;
	}

	public static void sieve(boolean[] isPrime,int n)
	{
		for(int i=1;i<n;i++)
			isPrime[i] = true;

		isPrime[0] = false;
		isPrime[1] = false;

		for(int i=2;i*i<n;i++)
		{
			if(isPrime[i] == true)
			{
				for(int j=(2*i);j<n;j+=i)
					isPrime[j] = false;
			}
		}
	}

	public static int GCD(int a,int b)
	{
		if(b==0)
			return a;
		else
			return GCD(b,a%b);
	}

	public static long GCD(long a,long b)
	{
		if(b==0)
			return a;
		else
			return GCD(b,a%b);
	}

	public static void extendedEuclid(int A,int B)
	{
		if(B==0)
		{
			d = A;
			p = 1 ;
			q = 0;
		}
		else
		{
			extendedEuclid(B, A%B);
			int temp = p;
			p = q;
			q = temp - (A/B)*q;
		}
	}

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

	public static int LCM(int a,int b)
	{
		return (a*b)/GCD(a,b);
	}

	public static int binaryExponentiation(int x,int n)
	{
	    int result=1;
	    while(n>0)
	    {
	        if(n % 2 ==1)
	            result=result * x;
	        x=x*x;
	        n=n/2;
	    }
	    return result;
	}

	public static long binaryExponentiation(long x,long n)
	{
	    long result=1;
	    while(n>0)
	    {
	        if(n % 2 ==1)
	            result=result * x;
	        x=x*x;
	        n=n/2;
	    }
	    return result;
	}

	public static int modularExponentiation(int x,int n,int M)
	{
	    int result=1;
	    while(n>0)
	    {
	        if(n % 2 ==1)
	            result=(result * x)%M;
	        x=(x*x)%M;
	        n=n/2;
	    }
	    return result;
	}

	public static long modularExponentiation(long x,long n,long M)
	{
	    long result=1;
	    while(n>0)
	    {
	        if(n % 2 ==1)
	            result=(result * x)%M;
	        x=(x*x)%M;
	        n=n/2;
	    }
	    return result;
	}

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

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

	public static boolean isPrime(int n)
	{

	    if (n <= 1)  return false;
	    if (n <= 3)  return true;

	    if (n%2 == 0 || n%3 == 0)
	    	return false;

	    for (int i=5; i*i<=n; i=i+6)
	    {
	        if (n%i == 0 || n%(i+2) == 0)
	           return false;
	    }

	    return true;
	}

	static class pair implements Comparable<pair>
	{
		Integer x, y;
		pair(int x,int y)
		{
			this.x=x;
			this.y=y;
		}

		public int compareTo(pair o) {
			int result = x.compareTo(o.x);
			if(result==0)
				result = y.compareTo(o.y);

			return result;
		}

		public String toString()
		{
			return x+" "+y;
		}

		public boolean equals(Object o)
		{
			if (o instanceof pair)
		    {
				pair p = (pair)o;
				return p.x == x && p.y == y ;
			}
			return false;
		}

		public int hashCode()
		{
			return new Long(x).hashCode()*31 + new Long(y).hashCode();
		}
	}
}

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.Random;
import java.util.StringTokenizer;
import java.util.TreeSet;
import java.util.TreeMap;

import static java.lang.Math.abs;
import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.sqrt;
import static java.util.Arrays.copyOf;
import static java.util.Arrays.fill;
import static java.util.Arrays.sort;
import static java.util.Collections.reverse;
import static java.util.Collections.reverseOrder;
import static java.util.Collections.sort;

public class Main {
    private FastScanner in;
    private PrintWriter out;

    private void solve() throws IOException {
        int n = in.nextInt(), a = in.nextInt(), b = in.nextInt();
        int[] have = {n, n, n, n};
        for (int need : new int[]{max(a, b), max(a, b), min(a, b), min(a, b)}) {
            int next = -1;
            for (int j = 0; j < have.length; j++)
                if (have[j] >= need && (next == -1 || have[j] < have[next]))
                    next = j;
            have[next] -= need;
        }
        int ans = 4;
        for (int i : have)
            if (i == n)
                ans--;
        out.print(ans);
    }

    private void solveA() throws IOException {

    }

    private void solveB() throws IOException {

    }

    private void solveC() throws IOException {

    }

    private void solveD() throws IOException {

    }

    private void solveE() throws IOException {

    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

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

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

        boolean hasNext() throws IOException {
            return br.ready() || (st != null && st.hasMoreTokens());
        }

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

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

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

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

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

    private void run() throws IOException {
        in = new FastScanner(System.in); // new FastScanner(new FileInputStream(".in"));
        out = new PrintWriter(System.out); // new PrintWriter(new FileOutputStream(".out"));

        solve();

        out.flush();
        out.close();
    }

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

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.Random;
import java.util.StringTokenizer;
import java.util.TreeSet;
import java.util.TreeMap;

import static java.lang.Math.abs;
import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.sqrt;
import static java.util.Arrays.copyOf;
import static java.util.Arrays.fill;
import static java.util.Arrays.sort;
import static java.util.Collections.reverse;
import static java.util.Collections.reverseOrder;
import static java.util.Collections.sort;

public class Main {
    private FastScanner in;
    private PrintWriter out;

    void reverse(int[] a) {
        int b;
        for (int i = 0, j = a.length - 1; i < j; i++, j--) {
            b = a[i];
            a[i] = a[j];
            a[j] = b;
        }
    }

    private void solve() throws IOException {
        int n = in.nextInt(), a = in.nextInt(), b = in.nextInt();
        int[] have = {n, n, n, n, n, n}, need = {a, a, b, a, a, b};
        sort(need);
        reverse(need);
        for (int i : need) {
            int next = -1;
            for (int j = 0; j < have.length; j++)
                if (have[j] >= i && (next == -1 || have[j] < have[next]))
                    next = j;
            have[next] -= i;
        }
        int ans = have.length;
        for (int i : have)
            if (i == n)
                ans--;
        out.print(ans);
    }

    private void solveA() throws IOException {

    }

    private void solveB() throws IOException {

    }

    private void solveC() throws IOException {

    }

    private void solveD() throws IOException {

    }

    private void solveE() throws IOException {

    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

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

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

        boolean hasNext() throws IOException {
            return br.ready() || (st != null && st.hasMoreTokens());
        }

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

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

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

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

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

    private void run() throws IOException {
        in = new FastScanner(System.in); // new FastScanner(new FileInputStream(".in"));
        out = new PrintWriter(System.out); // new PrintWriter(new FileOutputStream(".out"));

        solve();

        out.flush();
        out.close();
    }

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

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

/**
 * Created by trung.pham on 27/12/17.
 */
public class B_Testing_Round_14 {
    static int[][][]dp;
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        int n = in.nextInt();
        int a = in.nextInt();
        int b = in.nextInt();
        dp = new int[n + 1][5][3];
        for(int [][]x : dp){
            for(int[]y : x){
                Arrays.fill(y, -1);
            }
        }
        out.println(cal(n, 4, 2, n, a, b));
        out.close();
    }

    public static int cal(int left, int a, int b, int n, int A, int B){
        if(a == 0 && b == 0){
            return 1;
        }
        if(dp[left][a][b] != -1){
            return dp[left][a][b];
        }
        int result = Integer.MAX_VALUE;
        if(left >= A && a > 0){
            result = cal(left - A, a - 1, b, n,  A, B);
        }
        if(left >= B && b > 0){
            result = Math.min(result , cal(left - B, a, b - 1, n , A, B));
        }
        if(left < A && left < B){
            result = 1 + cal(n, a, b, n, A, B);
        }
        return dp[left][a][b] = result;
    }
}

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

import static java.util.Collections.reverseOrder;

public class DoorFrames implements Closeable {

    private InputReader in = new InputReader(System.in);
    private PrintWriter out = new PrintWriter(System.out);

    public void solve() {
        n = in.ni();
        int a = in.ni(), b = in.ni();
        Integer[] need = {a, a, a, a, b, b};
        Arrays.sort(need, reverseOrder());
        for (int i = 0; i < need.length; i++) {
            build(need[i]);
        }
        out.println(result);
    }

    private List<Integer> extra = new ArrayList<>();
    private int n, result;

    private void build(int need) {
        boolean ok = false;
        Iterator<Integer> iterator = extra.iterator();
        int removed = -1;
        while (iterator.hasNext()) {
            int next = iterator.next();
            if (next >= need) {
                iterator.remove();
                removed = next;
                ok = true;
                break;
            }
        }
        if (!ok) {
            result++;
            int rem = n - need;
            if (rem > 0) extra.add(rem);
        } else {
            extra.add(removed - need);
        }
        extra.sort(reverseOrder());
    }

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

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

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

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

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

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

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

    public static void main(String[] args) throws IOException {
        try (DoorFrames instance = new DoorFrames()) {
            instance.solve();
        }
    }
}

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

import static java.lang.Integer.max;

public class DoorFrames implements Closeable {

    private InputReader in = new InputReader(System.in);
    private PrintWriter out = new PrintWriter(System.out);

    public void solve() {
        int n = in.ni(), a = in.ni(), b = in.ni(), result = 6;
        if (4 * a + 2 * b <= n) result = 1;
        else if (2 * a + b <= n) result = 2;
        else if (max(a, b) <= n || max(2 * b + a, 3 * a) <= n || max(a + b, 2 * a) <= n || max(4 * a, b) <= n) result = 3;
        else if (max(b, 2 * a) <= n || a + b <= n) result = 4;
        else if (max(2 * b, a) <= n) result = 5;

        out.println(result);
    }

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

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

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

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

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

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

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

    public static void main(String[] args) throws IOException {
        try (DoorFrames instance = new DoorFrames()) {
            instance.solve();
        }
    }
}

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

public class CodeForces {

    public static ArrayList<Integer>[] tree;
    public static int[] col;

    public static void main(String[] args) throws IOException {
        FastScanner in = new FastScanner(System.in);
        int n = in.nextInt();
        int a = in.nextInt();
        int totA = a * 4;
        int b = in.nextInt();
        int totB = b * 2;
        int bars = 0;
        int bars2 = 0;
        int temp;
        while (totA + totB > 0) {
            temp = n;
            bars++;
            if (totA > 0) {
                while (totA > 0 && temp >= a) {
                    temp -= a;
                    totA -= a;
                }
            }
            if (totB > 0 && temp >= b) {
                while (totB > 0 && temp >= b) {
                    temp -= b;
                    totB -= b;
                }
            }
        }
        totA = a * 4;
        totB = b * 2;
        while (totA + totB > 0) {
            temp = n;
            bars2++;
            if (totB > 0) {
                while (totB > 0 && temp >= b) {
                    temp -= b;
                    totB -= b;
                }
            }

            if (totA > 0 && temp >= a) {
                while (totA > 0 && temp >= a) {
                    temp -= a;
                    totA -= a;
                }
            }
        }
        System.out.println(Math.min(bars, bars2));

    }

    public static int[] radixSort(int[] f) {
        return radixSort(f, f.length);
    }

    public static int[] radixSort(int[] f, int n) {
        int[] to = new int[n];
        {
            int[] b = new int[65537];
            for (int i = 0; i < n; i++) {
                b[1 + (f[i] & 0xffff)]++;
            }
            for (int i = 1; i <= 65536; i++) {
                b[i] += b[i - 1];
            }
            for (int i = 0; i < n; i++) {
                to[b[f[i] & 0xffff]++] = f[i];
            }
            int[] d = f;
            f = to;
            to = d;
        }
        {
            int[] b = new int[65537];
            for (int i = 0; i < n; i++) {
                b[1 + (f[i] >>> 16)]++;
            }
            for (int i = 1; i <= 65536; i++) {
                b[i] += b[i - 1];
            }
            for (int i = 0; i < n; i++) {
                to[b[f[i] >>> 16]++] = f[i];
            }
            int[] d = f;
            f = to;
            to = d;
        }
        return f;
    }

    private static class FastScanner {

        private final InputStream stream;
        private final byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

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

        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++];
        }

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

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

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

        public int[] nextArrayInt(int n) {
            int tab[] = new int[n];
            for (int i = 0; i < n; i++) {
                tab[i] = nextInt();
            }
            return tab;
        }

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

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

        public String next() {
            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 String nextLine() {
            int c = read();
            while (isEndline(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndline(c));
            return res.toString();
        }
    }
}

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

public class CodeForces {

    public static ArrayList<Integer>[] tree;
    public static int[] col;

    public static void main(String[] args) throws IOException {
        FastScanner in = new FastScanner(System.in);
        int n = in.nextInt();
        int a = in.nextInt();
        int totA = a*4;
        int b = in.nextInt();
        int totB = b*2;
        int bars = 0;
        int temp;
        while(totA+totB>0){
            temp = n;
            bars++;
            if (totA>0){
                while(totA>0 && temp>=a){
                    temp-=a;
                    totA-=a;
                }
            }
            if (totB>0 && temp>=b){
                while(totB>0 && temp>=b){
                    temp-=b;
                    totB-=b;
                }
            }
        }
        System.out.println(bars);

    }

    public static int[] radixSort(int[] f) {
        return radixSort(f, f.length);
    }

    public static int[] radixSort(int[] f, int n) {
        int[] to = new int[n];
        {
            int[] b = new int[65537];
            for (int i = 0; i < n; i++) {
                b[1 + (f[i] & 0xffff)]++;
            }
            for (int i = 1; i <= 65536; i++) {
                b[i] += b[i - 1];
            }
            for (int i = 0; i < n; i++) {
                to[b[f[i] & 0xffff]++] = f[i];
            }
            int[] d = f;
            f = to;
            to = d;
        }
        {
            int[] b = new int[65537];
            for (int i = 0; i < n; i++) {
                b[1 + (f[i] >>> 16)]++;
            }
            for (int i = 1; i <= 65536; i++) {
                b[i] += b[i - 1];
            }
            for (int i = 0; i < n; i++) {
                to[b[f[i] >>> 16]++] = f[i];
            }
            int[] d = f;
            f = to;
            to = d;
        }
        return f;
    }

    private static class FastScanner {

        private final InputStream stream;
        private final byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

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

        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++];
        }

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

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

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

        public int[] nextArrayInt(int n) {
            int tab[] = new int[n];
            for (int i = 0; i < n; i++) {
                tab[i] = nextInt();
            }
            return tab;
        }

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

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

        public String next() {
            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 String nextLine() {
            int c = read();
            while (isEndline(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndline(c));
            return res.toString();
        }
    }
}

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.Stack;
import java.util.TreeMap;
import java.util.TreeSet;

public class Tester
{
	InputStream is;
	PrintWriter out;
	String INPUT = "";
	void solve()
	{
		int n=ni(),a=ni(),b=ni();
		int ans=0;
		int rem1=0,rem2=0,rem3=0,rem4=0,rem5=0;
		int t=n;
		rem1=t-a;
		ans++;
		if(rem1>=a) {
			rem1-=a;
		}
		else {
			rem2=t-a;
			ans++;
		}

		if(rem1>=b) {
			rem1-=a;
		}
		else if(rem2>=b) {
			rem2-=b;
		}
		else {
			rem3=t-b;
			ans++;
		}

		if(rem1>=a) {
			rem1-=a;
		}
		else if(rem2>=a) {
			rem2-=a;
		}
		else if(rem3>=a) {
			rem3-=a;
		}
		else {
			rem4=t-a;
			ans++;
		}

		if(rem1>=a) {
			rem1-=a;
		}
		else if(rem2>=a) {
			rem2-=a;
		}
		else if(rem3>=a) {
			rem3-=a;
		}
		else if(rem4>=a) {
			rem4-=a;
		}
		else {
			rem5=t-a;
			ans++;
		}

		if(rem1>=b) {
			rem1-=b;
		}
		else if(rem2>=b) {
			rem2-=b;
		}
		else if(rem3>=b) {
			rem3-=b;
		}
		else if(rem4>=b) {
			rem4-=b;
		}
		else if(rem5>=b) {
			rem5-=b;
		}
		else {
			ans++;
		}

		out.println(ans);

	}

	void run() throws Exception
	{
		is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
		out = new PrintWriter(System.out);

		long s = System.currentTimeMillis();
		solve();
		out.flush();
		if(!INPUT.isEmpty())tr(System.currentTimeMillis()-s+"ms");
	}

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

	private byte[] inbuf = new byte[1024];
	public int lenbuf = 0, ptrbuf = 0;

	private int readByte()
	{
		if(lenbuf == -1)throw new InputMismatchException();
		if(ptrbuf >= lenbuf)
		{
			ptrbuf = 0;
			try
			{ lenbuf = is.read(inbuf); }
			catch (IOException e)
			{ throw new InputMismatchException(); }
			if(lenbuf <= 0)return -1;
		}
		return inbuf[ptrbuf++];
	}

	private boolean isSpaceChar(int c)
	{ return !(c >= 33 && c <= 126); }
	private int skip()
	{ int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }

	private double nd()
	{ return Double.parseDouble(ns()); }
	private char nc()
	{ return (char)skip(); }

	private String ns()
	{
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while(!(isSpaceChar(b)))
		{ // when nextLine, (isSpaceChar(b) && b != ' ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	private char[] ns(int n)
	{
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while(p < n && !(isSpaceChar(b)))
		{
			buf[p++] = (char)b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	private char[][] nm(int n, int m)
	{
		char[][] map = new char[n][];
		for(int i = 0;i < n;i++)map[i] = ns(m);
		return map;
	}

	private int[] na(int n)
	{
		int[] a = new int[n];
		for(int i = 0;i < n;i++)a[i] = ni();
		return a;
	}

	private int ni()
	{
		int num = 0, b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-')
		{
			minus = true;
			b = readByte();
		}

		while(true)
		{
			if(b >= '0' && b <= '9')
			{
				num = num * 10 + (b - '0');
			}else
			{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private long nl()
	{
		long num = 0;
		int b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-')
		{
			minus = true;
			b = readByte();
		}

		while(true){
			if(b >= '0' && b <= '9')
			{
				num = num * 10 + (b - '0');
			}else
			{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private static void tr(Object... o)
	{ System.out.println(Arrays.deepToString(o)); }
}

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.math.*;
import java.util.InputMismatchException;
public class solution{
	public static void main(String args[]) throws Exception
		{
			InputReader sc = new InputReader(System.in);
			PrintWriter out = new PrintWriter(System.out);
			int n = sc.nextInt();
			int a = sc.nextInt();
			int b = sc.nextInt();
			if(n>=4*a+2*b)
			{
				out.println(1);
			}
			else if(n>=a+b)
			{
				int x = n-(a+b);
				if(x>=a)
				{
					out.println(2);
				}
				else if(x>=b)
				{
					if(n>=3*a)
					{
						out.println(2);
					}
					else if(n>=2*a)
					{
						out.println(3);
					}
					else
					{
						out.println(4);
					}
				}
				else
				{
					if(n>=2*a)
					{
						out.println(3);
					}
					else
					{
						out.println(4);
					}
				}
			}
			else
			{
				int ans = 0;
				if(n>=4*a)
				{
					ans = 1;
				}
				else if(n>=2*a)
				{
					ans = 2;
				}
				else
				{
					ans = 4;
				}
				if(n>=2*b)
				{
					ans+=1;
				}
				else
				{
					ans+=2;
				}
				out.println(6);
			}
			out.close();
		}
	static class InputReader {

        private InputStream stream;
        private byte[] buf = new byte[8192];
        private int curChar, snumChars;
        private SpaceCharFilter filter;

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

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

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

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

        public int[] nextIntArray(int n) {
            int a[] = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }

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

        public int[] readCharCount() {
            int c = snext();
            while (isSpaceChar(c))
                c = snext();
            int[] map = new int[256];
            do {
                int val = c ;
                map[val]++;
                c = snext();
            } while (!isSpaceChar(c));
            return map;
        }

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

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

import java.util.*;
import java.io.*;
public class solution
{
	public static void main(String args[])
	{
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int a = sc.nextInt();
		int b = sc.nextInt();
		if(a+b>n)
		{
			System.out.println(6);
			return;
		}
		else if(a+b==n)
		{
			System.out.println(4);
		}
		else
		{
			int a_r = 4;
			int b_r = 2;
			int ans = 0;
			int w = 0;
			while(a_r!=0||b_r!=0)
			{
				if(w<a&&w<b)
				{
					ans++;
					w = n;
				}
				if(a_r!=0&&w>=a)
				{
					w = w-a;
					a_r--;
				}
				if(b_r!=0&&w>=b)
				{
					w = w-b;
					b_r--;
				}
			}
			System.out.println(ans);
		}
	}
}

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.math.*;
import java.util.InputMismatchException;
public class solution{
	public static void main(String args[]) throws Exception
		{
			InputReader sc = new InputReader(System.in);
			PrintWriter out = new PrintWriter(System.out);
			int n = sc.nextInt();
			int a = sc.nextInt();
			int b = sc.nextInt();
			if(n>=4*a+2*b)
			{
				out.println(1);
			}
			else if(n>=a+b)
			{
				int x = n-(a+b);
				if(x>=a)
				{
					out.println(2);
				}
				else if(x>=b)
				{
					if(n>=3*a)
					{
						out.println(2);
					}
					else if(n>=2*a)
					{
						out.println(3);
					}
					else
					{
						out.println(4);
					}
				}
				else
				{
					if(n>=2*a)
					{
						out.println(3);
					}
					else
					{
						out.println(4);
					}
				}
			}
			else
			{
				out.println(6);
			}
			out.close();
		}
	static class InputReader {

        private InputStream stream;
        private byte[] buf = new byte[8192];
        private int curChar, snumChars;
        private SpaceCharFilter filter;

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

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

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

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

        public int[] nextIntArray(int n) {
            int a[] = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }

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

        public int[] readCharCount() {
            int c = snext();
            while (isSpaceChar(c))
                c = snext();
            int[] map = new int[256];
            do {
                int val = c ;
                map[val]++;
                c = snext();
            } while (!isSpaceChar(c));
            return map;
        }

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

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

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.math.*;
import java.util.InputMismatchException;
public class solution{
	public static void main(String args[]) throws Exception
		{
			InputReader sc = new InputReader(System.in);
			PrintWriter out = new PrintWriter(System.out);
			int n = sc.nextInt();
			int a = sc.nextInt();
			int b = sc.nextInt();
			if(n>=4*a+2*b)
			{
				out.println(1);
			}
			else if(n>=4*a&&n>=2*b)
			{
				out.println(2);
			}
			else if(n>=a+b)
			{
				int x = n-(a+b);
				if(x>=a)
				{
					out.println(2);
				}
				else if(x>=b)
				{
					if(n>=3*a)
					{
						out.println(2);
					}
					else if(n>=2*a)
					{
						out.println(3);
					}
					else
					{
						out.println(4);
					}
				}
				else
				{
					if(n>=2*a)
					{
						out.println(3);
					}
					else
					{
						out.println(4);
					}
				}
			}
			else
			{
				out.println(6);
			}
			out.close();
		}
	static class InputReader {

        private InputStream stream;
        private byte[] buf = new byte[8192];
        private int curChar, snumChars;
        private SpaceCharFilter filter;

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

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

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

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

        public int[] nextIntArray(int n) {
            int a[] = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }

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

        public int[] readCharCount() {
            int c = snext();
            while (isSpaceChar(c))
                c = snext();
            int[] map = new int[256];
            do {
                int val = c ;
                map[val]++;
                c = snext();
            } while (!isSpaceChar(c));
            return map;
        }

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

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

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

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

		int n = in.nextInt();
		int a = in.nextInt();
		int b = in.nextInt();
		boolean flage = false;

		int ans=0;

		if(a>=b)
		{
			if(n/a==1)
				ans=4;
			else if(n/a==2 || n/a==3)
				ans=2;
			else
			{
				ans=1;
				flage = true;
			}

			if(flage==true)
			{
				if((n - 4*a)/b==0)
				{
					if(n/b==1)
						ans+=2;
					else
						ans+=1;
				}
				else if((n - 4*a)/b==1)
					ans+=1;
			}
			else if(n/a==3)
			{
				if((n%a)/b==0)
				{
					if((n-a)/b==0)
					{
						if(n/b==1)
							ans+=2;
						else
							ans+=1;
					}
					else if((n-a)/b==1)
						ans+=1;
				}
			}
			else
			{
				if((n%a)/b==0)
				{
					if(n/b==1)
						ans+=2;
					else
						ans+=1;
				}
			}

		}
		else
		{
			if(n/b==1)
				ans=2;
			else
			{
				ans=1;
				flage = true;
			}

			if(flage==true)
			{
				if((n - 2*b)/a==0)
				{
					if(n/a==1)
						ans+=4;
					else if(n/a==2 || n/a==3)
						ans+=2;
					else
						ans+=1;
				}
				else if((n - 2*b)/a==1)
				{
					if(n/a==1)
						ans+=3;
					else if(n/a==2)
						ans+=2;
					else
						ans+=1;
				}
				else if((n - 2*b)/a==2)
				{
					if(n/a==1)
						ans+=2;
					else if(n/a==2)
						ans+=1;
				}
				else if((n - 2*b)/a==3)
					ans++;
			}
			else
			{
				if((n%b)/a==0)
				{
					if(n/a==1)
						ans+=4;
					else if(n/a==2 || n/a==3)
						ans+=2;
					else
						ans+=1;
				}
				else if((n%b)/a==1)
				{
					if(n/a==1)
						ans+=2;
					else
						ans+=1;
				}
			}

		}

		System.out.println(ans);
	}

}

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

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

		int n = in.nextInt();
		int a = in.nextInt();
		int b = in.nextInt();
		boolean flage = false;

		int ans=0;

		if(n/a==1)
			ans=4;
		else if(n/a==2 || n/a==3)
			ans=2;
		else
		{
			ans=1;
			flage = true;
		}

		if(flage==true)
		{
			if((n - 4*a)/b==0)
			{
				if(n/b==1)
					ans+=2;
				else
					ans+=1;
			}
			else if((n - 4*a)/b==1)
				ans+=1;
		}
		else
		{
			if((n%a)/b==0)
			{
				if(n/b==1)
					ans+=2;
				else
					ans+=1;
			}
		}

		System.out.println(ans);
	}

}

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

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

		int n = in.nextInt();
		int a = in.nextInt();
		int b = in.nextInt();
		boolean flage = false;

		int ans=0,temp=0;

		if(a+b<=n)
		{
			if(n/(a+b)==1)
			{
				if(a<=n-a-b)
					ans=2;
				else if(2*a<=n)
					ans=3;
				else
					ans=4;
			}
			else if(n/(a+b)>=2)
			{
				if(2*a<=n-2*(a+b))
					ans=1;
				else if(2*a<=n)
					ans=2;
				else
					ans=3;
			}
		}
		else
		{
			if(n/b==1 && n/a==1)
				ans=6;
			if(n/b==1 && (n/a==2 || n/a==3))
				ans=4;
			if(n/b==1 && n/a>=4)
				ans=3;
			if(n/b>=2 && n/a==1)
				ans=5;
			if(n/b>=2 && (n/a==2 || n/a==3))
				ans=3;
			if(n/b>=1 && n/a>=4)
				ans=2;

		}
		System.out.println(ans);
	}

}

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

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

		int n = in.nextInt();
		int a = in.nextInt();
		int b = in.nextInt();
		boolean flage = false;

		int ans=0;

		if(n/a==1)
			ans=4;
		else if(n/a==2 || n/a==3)
			ans=2;
		else
		{
			ans=1;
			flage = true;
		}

		if(flage==true)
		{
			if((n - 4*a)/b==0)
			{
				if(n/b==1)
					ans+=2;
				else
					ans+=1;
			}
			else if((n - 4*a)/b==1)
				ans+=1;
		}
		else if(n/a==3)
		{
			if((n%a)/b==0)
			{
				if((n-a)/b==0)
				{
					if(n/b==1)
						ans+=2;
					else
						ans+=1;
				}
				else if((n-a)/b==1)
					ans+=1;
			}
		}
		else
		{
			if((n%a)/b==0)
			{
				if(n/b==1)
					ans+=2;
				else
					ans+=1;
			}
		}

		System.out.println(ans);
	}

}

/*
⣿⣿⣿⣿⣿⣿⡷⣯⢿⣿⣷⣻⢯⣿⡽⣻⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣇⠸⣿⣿⣆⠹⣿⣿⢾⣟⣯⣿⣿⣿⣿⣿⣿⣽⣻⣿⣿⣿⣿⣿⣿⣿
⣿⣿⣿⣿⣿⣿⣻⣽⡿⣿⣎⠙⣿⣞⣷⡌⢻⣟⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣿⣿⣿⣿⣿⣿⡄⠹⣿⣿⡆⠻⣿⣟⣯⡿⣽⡿⣿⣿⣿⣿⣽⡷⣯⣿⣿⣿⣿⣿⣿
⣿⣿⣿⣿⣿⣿⣟⣷⣿⣿⣿⡀⠹⣟⣾⣟⣆⠹⣯⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⢠⡘⣿⣿⡄⠉⢿⣿⣽⡷⣿⣻⣿⣿⣿⣿⡝⣷⣯⢿⣿⣿⣿⣿
⣿⣿⣿⣿⣿⣿⣯⢿⣾⢿⣿⡄⢄⠘⢿⣞⡿⣧⡈⢷⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⢸⣧⠘⣿⣷⠈⣦⠙⢿⣽⣷⣻⣽⣿⣿⣿⣿⣌⢿⣯⢿⣿⣿⣿
⣿⣿⣿⣿⣿⣿⣟⣯⣿⢿⣿⡆⢸⡷⡈⢻⡽⣷⡷⡄⠻⣽⣿⣿⡿⣿⣿⣿⣿⣿⣿⣷⣿⣿⣿⣿⣏⢰⣯⢷⠈⣿⡆⢹⢷⡌⠻⡾⢋⣱⣯⣿⣿⣿⣿⡆⢻⡿⣿⣿⣿
⣿⣿⣿⣿⣿⣿⡎⣿⢾⡿⣿⡆⢸⣽⢻⣄⠹⣷⣟⣿⣄⠹⣟⣿⣿⣟⣿⣿⣿⣿⣿⣿⣽⣿⣿⣿⡇⢸⣯⣟⣧⠘⣷⠈⡯⠛⢀⡐⢾⣟⣷⣻⣿⣿⣿⡿⡌⢿⣻⣿⣿
⣿⣿⣿⣿⣿⣿⣧⢸⡿⣟⣿⡇⢸⣯⣟⣮⢧⡈⢿⣞⡿⣦⠘⠏⣹⣿⣽⢿⣿⣿⣿⣿⣯⣿⣿⣿⡇⢸⣿⣿⣾⡆⠹⢀⣠⣾⣟⣷⡈⢿⣞⣯⢿⣿⣿⣿⢷⠘⣯⣿⣿
⣿⣿⣿⣿⣿⣿⣿⡈⣿⢿⣽⡇⠘⠛⠛⠛⠓⠓⠈⠛⠛⠟⠇⢀⢿⣻⣿⣯⢿⣿⣿⣿⣷⢿⣿⣿⠁⣾⣿⣿⣿⣧⡄⠇⣹⣿⣾⣯⣿⡄⠻⣽⣯⢿⣻⣿⣿⡇⢹⣾⣿
⣿⣿⣿⣿⣿⣿⣿⡇⢹⣿⡽⡇⢸⣿⣿⣿⣿⣿⣞⣆⠰⣶⣶⡄⢀⢻⡿⣯⣿⡽⣿⣿⣿⢯⣟⡿⢀⣿⣿⣿⣿⣿⣧⠐⣸⣿⣿⣷⣿⣿⣆⠹⣯⣿⣻⣿⣿⣿⢀⣿⢿
⣿⣿⣿⣿⣿⣿⣿⣿⠘⣯⡿⡇⢸⣿⣿⣿⣿⣿⣿⣿⣧⡈⢿⣳⠘⡄⠻⣿⢾⣽⣟⡿⣿⢯⣿⡇⢸⣿⣿⣿⣿⣿⣿⡀⢾⣿⣿⣿⣿⣿⣿⣆⠹⣾⣷⣻⣿⡿⡇⢸⣿
⣿⣿⣿⣿⣿⣿⣿⣿⡇⢹⣿⠇⢸⣿⣿⣿⣿⣿⣿⣿⣿⣷⣄⠻⡇⢹⣆⠹⣟⣾⣽⣻⣟⣿⣽⠁⣾⣿⣿⣿⣿⣿⣿⣇⣿⣿⠿⠛⠛⠉⠙⠋⢀⠁⢘⣯⣿⣿⣧⠘⣿
⣿⣿⣿⣿⣿⣿⣿⣿⣿⡈⣿⡃⢼⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⡙⠌⣿⣆⠘⣿⣞⡿⣞⡿⡞⢠⣿⣿⣿⣿⣿⡿⠛⠉⠁⢀⣀⣠⣤⣤⣶⣶⣶⡆⢻⣽⣞⡿⣷⠈⣿
⣿⣿⣿⣿⣿⣿⣿⣿⡿⠃⠘⠁⠉⠉⠉⠉⠉⠉⠉⠉⠉⠙⠛⠛⢿⣄⢻⣿⣧⠘⢯⣟⡿⣽⠁⣾⣿⣿⣿⣿⣿⡃⢀⢀⠘⠛⠿⢿⣻⣟⣯⣽⣻⣵⡀⢿⣯⣟⣿⢀⣿
⣿⣿⣿⣟⣿⣿⣿⣿⣶⣶⡆⢀⣿⣾⣿⣾⣷⣿⣶⠿⠚⠉⢀⢀⣤⣿⣷⣿⣿⣷⡈⢿⣻⢃⣼⣿⣿⣿⣿⣻⣿⣿⣿⡶⣦⣤⣄⣀⡀⠉⠛⠛⠷⣯⣳⠈⣾⡽⣾⢀⣿
⣿⢿⣿⣿⣻⣿⣿⣿⣿⣿⡿⠐⣿⣿⣿⣿⠿⠋⠁⢀⢀⣤⣾⣿⣿⣿⣿⣿⣿⣿⣿⣌⣥⣾⡿⣿⣿⣷⣿⣿⢿⣷⣿⣿⣟⣾⣽⣳⢯⣟⣶⣦⣤⡾⣟⣦⠘⣿⢾⡁⢺
⣿⣻⣿⣿⡷⣿⣿⣿⣿⣿⡗⣦⠸⡿⠋⠁⢀⢀⣠⣴⢿⣿⣽⣻⢽⣾⣟⣷⣿⣟⣿⣿⣿⣳⠿⣵⣧⣼⣿⣿⣿⣿⣿⣾⣿⣿⣿⣿⣿⣽⣳⣯⣿⣿⣿⣽⢀⢷⣻⠄⠘
⣿⢷⣻⣿⣿⣷⣻⣿⣿⣿⡷⠛⣁⢀⣀⣤⣶⣿⣛⡿⣿⣮⣽⡻⣿⣮⣽⣻⢯⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣯⢀⢸⣿⢀⡆
⠸⣟⣯⣿⣿⣷⢿⣽⣿⣿⣷⣿⣷⣆⠹⣿⣶⣯⠿⣿⣶⣟⣻⢿⣷⣽⣻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⢀⣯⣟⢀⡇
⣇⠹⣟⣾⣻⣿⣿⢾⡽⣿⣿⣿⣿⣿⣆⢹⣶⣿⣻⣷⣯⣟⣿⣿⣽⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⢀⡿⡇⢸⡇
⣿⣆⠹⣷⡻⣽⣿⣯⢿⣽⣻⣿⣿⣿⣿⣆⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠛⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠇⢸⣿⠇⣼⡇
⡙⠾⣆⠹⣿⣦⠛⣿⢯⣷⢿⡽⣿⣿⣿⣿⣆⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠃⠎⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠏⢀⣿⣾⣣⡿⡇
⣿⣷⡌⢦⠙⣿⣿⣌⠻⣽⢯⣿⣽⣻⣿⣿⣿⣧⠩⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡏⢰⢣⠘⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠃⢀⢀⢿⣞⣷⢿⡇
⣿⣽⣆⠹⣧⠘⣿⣿⡷⣌⠙⢷⣯⡷⣟⣿⣿⣿⣷⡀⡹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣈⠃⣸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠟⢀⣴⡧⢀⠸⣿⡽⣿⢀
⢻⣽⣿⡄⢻⣷⡈⢿⣿⣿⢧⢀⠙⢿⣻⡾⣽⣻⣿⣿⣄⠌⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠛⢁⣰⣾⣟⡿⢀⡄⢿⣟⣿⢀
⡄⢿⣿⣷⢀⠹⣟⣆⠻⣿⣿⣆⢀⣀⠉⠻⣿⡽⣯⣿⣿⣷⣈⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠋⢀⣠⠘⣯⣷⣿⡟⢀⢆⠸⣿⡟⢸
⣷⡈⢿⣿⣇⢱⡘⢿⣷⣬⣙⠿⣧⠘⣆⢀⠈⠻⣷⣟⣾⢿⣿⣆⠹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠋⣠⡞⢡⣿⢀⣿⣿⣿⠇⡄⢸⡄⢻⡇⣼
⣿⣷⡈⢿⣿⡆⢣⡀⠙⢾⣟⣿⣿⣷⡈⠂⠘⣦⡈⠿⣯⣿⢾⣿⣆⠙⠻⠿⠿⠿⠿⡿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠿⠛⢋⣠⣾⡟⢠⣿⣿⢀⣿⣿⡟⢠⣿⢈⣧⠘⢠⣿
⣿⣿⣿⣄⠻⣿⡄⢳⡄⢆⡙⠾⣽⣿⣿⣆⡀⢹⡷⣄⠙⢿⣿⡾⣿⣆⢀⡀⢀⢀⢀⢀⢀⢀⢀⢀⢀⢀⢀⢀⣀⣠⣴⡿⣯⠏⣠⣿⣿⡏⢸⣿⡿⢁⣿⣿⢀⣿⠆⢸⣿
⣿⣿⣿⣿⣦⡙⣿⣆⢻⡌⢿⣶⢤⣉⣙⣿⣷⡀⠙⠽⠷⠄⠹⣿⣟⣿⣆⢙⣋⣤⣤⣤⣄⣀⢀⢀⢀⢀⣾⣿⣟⡷⣯⡿⢃⣼⣿⣿⣿⠇⣼⡟⣡⣿⣿⣿⢀⡿⢠⠈⣿
⣿⣿⣿⣿⣿⣷⣮⣿⣿⣿⡌⠁⢤⣤⣤⣤⣬⣭⣴⣶⣶⣶⣆⠈⢻⣿⣿⣆⢻⣿⣿⣿⣿⣿⣿⣷⣶⣤⣌⣉⡘⠛⠻⠶⣿⣿⣿⣿⡟⣰⣫⣴⣿⣿⣿⣿⠄⣷⣿⣿⣿
*/
import java.util.*;

public class Main{

	public static void main(String[] args) {

		Scanner s=new Scanner(System.in);

		int n=s.nextInt();

		int a=s.nextInt();
		int b=s.nextInt();

		int h=Math.min(n/a,4);
		int ne=n;
		n=n-Math.min(4*a,(n/a)*a);
		int k=Math.min(2, n/b);

		int c=0;
		int d=0;
		int ans=0;
		while(c<4) {
			c=c+h;
			ans++;
			if(d<2&&k!=0) {
				d=d+k;
			}

		}
		//System.out.println(ans);
		 int left=d-4;
		int j=0;
		if(left>0)
		 j=ne-a;

		 if(d!=2) {
			 if(j>0) {

				 if(d==0) {
					 if(2*b<=j) {

					 }else {
						 ans=ans+1;
					 }
					 }else if(d==1&&b<=j) {

					 }else {
						 ans++;
					 }

			 }else {
			 if(d==0) {
			 if(2*b<=ne) {
				 ans++;
			 }else {
				 ans=ans+2;
			 }
			 }else if(d==1) {
				 ans++;
			 }
			 }
		 }

		 System.out.println(ans);

	}
}

/*
⣿⣿⣿⣿⣿⣿⡷⣯⢿⣿⣷⣻⢯⣿⡽⣻⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣇⠸⣿⣿⣆⠹⣿⣿⢾⣟⣯⣿⣿⣿⣿⣿⣿⣽⣻⣿⣿⣿⣿⣿⣿⣿
⣿⣿⣿⣿⣿⣿⣻⣽⡿⣿⣎⠙⣿⣞⣷⡌⢻⣟⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣿⣿⣿⣿⣿⣿⡄⠹⣿⣿⡆⠻⣿⣟⣯⡿⣽⡿⣿⣿⣿⣿⣽⡷⣯⣿⣿⣿⣿⣿⣿
⣿⣿⣿⣿⣿⣿⣟⣷⣿⣿⣿⡀⠹⣟⣾⣟⣆⠹⣯⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⢠⡘⣿⣿⡄⠉⢿⣿⣽⡷⣿⣻⣿⣿⣿⣿⡝⣷⣯⢿⣿⣿⣿⣿
⣿⣿⣿⣿⣿⣿⣯⢿⣾⢿⣿⡄⢄⠘⢿⣞⡿⣧⡈⢷⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⢸⣧⠘⣿⣷⠈⣦⠙⢿⣽⣷⣻⣽⣿⣿⣿⣿⣌⢿⣯⢿⣿⣿⣿
⣿⣿⣿⣿⣿⣿⣟⣯⣿⢿⣿⡆⢸⡷⡈⢻⡽⣷⡷⡄⠻⣽⣿⣿⡿⣿⣿⣿⣿⣿⣿⣷⣿⣿⣿⣿⣏⢰⣯⢷⠈⣿⡆⢹⢷⡌⠻⡾⢋⣱⣯⣿⣿⣿⣿⡆⢻⡿⣿⣿⣿
⣿⣿⣿⣿⣿⣿⡎⣿⢾⡿⣿⡆⢸⣽⢻⣄⠹⣷⣟⣿⣄⠹⣟⣿⣿⣟⣿⣿⣿⣿⣿⣿⣽⣿⣿⣿⡇⢸⣯⣟⣧⠘⣷⠈⡯⠛⢀⡐⢾⣟⣷⣻⣿⣿⣿⡿⡌⢿⣻⣿⣿
⣿⣿⣿⣿⣿⣿⣧⢸⡿⣟⣿⡇⢸⣯⣟⣮⢧⡈⢿⣞⡿⣦⠘⠏⣹⣿⣽⢿⣿⣿⣿⣿⣯⣿⣿⣿⡇⢸⣿⣿⣾⡆⠹⢀⣠⣾⣟⣷⡈⢿⣞⣯⢿⣿⣿⣿⢷⠘⣯⣿⣿
⣿⣿⣿⣿⣿⣿⣿⡈⣿⢿⣽⡇⠘⠛⠛⠛⠓⠓⠈⠛⠛⠟⠇⢀⢿⣻⣿⣯⢿⣿⣿⣿⣷⢿⣿⣿⠁⣾⣿⣿⣿⣧⡄⠇⣹⣿⣾⣯⣿⡄⠻⣽⣯⢿⣻⣿⣿⡇⢹⣾⣿
⣿⣿⣿⣿⣿⣿⣿⡇⢹⣿⡽⡇⢸⣿⣿⣿⣿⣿⣞⣆⠰⣶⣶⡄⢀⢻⡿⣯⣿⡽⣿⣿⣿⢯⣟⡿⢀⣿⣿⣿⣿⣿⣧⠐⣸⣿⣿⣷⣿⣿⣆⠹⣯⣿⣻⣿⣿⣿⢀⣿⢿
⣿⣿⣿⣿⣿⣿⣿⣿⠘⣯⡿⡇⢸⣿⣿⣿⣿⣿⣿⣿⣧⡈⢿⣳⠘⡄⠻⣿⢾⣽⣟⡿⣿⢯⣿⡇⢸⣿⣿⣿⣿⣿⣿⡀⢾⣿⣿⣿⣿⣿⣿⣆⠹⣾⣷⣻⣿⡿⡇⢸⣿
⣿⣿⣿⣿⣿⣿⣿⣿⡇⢹⣿⠇⢸⣿⣿⣿⣿⣿⣿⣿⣿⣷⣄⠻⡇⢹⣆⠹⣟⣾⣽⣻⣟⣿⣽⠁⣾⣿⣿⣿⣿⣿⣿⣇⣿⣿⠿⠛⠛⠉⠙⠋⢀⠁⢘⣯⣿⣿⣧⠘⣿
⣿⣿⣿⣿⣿⣿⣿⣿⣿⡈⣿⡃⢼⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⡙⠌⣿⣆⠘⣿⣞⡿⣞⡿⡞⢠⣿⣿⣿⣿⣿⡿⠛⠉⠁⢀⣀⣠⣤⣤⣶⣶⣶⡆⢻⣽⣞⡿⣷⠈⣿
⣿⣿⣿⣿⣿⣿⣿⣿⡿⠃⠘⠁⠉⠉⠉⠉⠉⠉⠉⠉⠉⠙⠛⠛⢿⣄⢻⣿⣧⠘⢯⣟⡿⣽⠁⣾⣿⣿⣿⣿⣿⡃⢀⢀⠘⠛⠿⢿⣻⣟⣯⣽⣻⣵⡀⢿⣯⣟⣿⢀⣿
⣿⣿⣿⣟⣿⣿⣿⣿⣶⣶⡆⢀⣿⣾⣿⣾⣷⣿⣶⠿⠚⠉⢀⢀⣤⣿⣷⣿⣿⣷⡈⢿⣻⢃⣼⣿⣿⣿⣿⣻⣿⣿⣿⡶⣦⣤⣄⣀⡀⠉⠛⠛⠷⣯⣳⠈⣾⡽⣾⢀⣿
⣿⢿⣿⣿⣻⣿⣿⣿⣿⣿⡿⠐⣿⣿⣿⣿⠿⠋⠁⢀⢀⣤⣾⣿⣿⣿⣿⣿⣿⣿⣿⣌⣥⣾⡿⣿⣿⣷⣿⣿⢿⣷⣿⣿⣟⣾⣽⣳⢯⣟⣶⣦⣤⡾⣟⣦⠘⣿⢾⡁⢺
⣿⣻⣿⣿⡷⣿⣿⣿⣿⣿⡗⣦⠸⡿⠋⠁⢀⢀⣠⣴⢿⣿⣽⣻⢽⣾⣟⣷⣿⣟⣿⣿⣿⣳⠿⣵⣧⣼⣿⣿⣿⣿⣿⣾⣿⣿⣿⣿⣿⣽⣳⣯⣿⣿⣿⣽⢀⢷⣻⠄⠘
⣿⢷⣻⣿⣿⣷⣻⣿⣿⣿⡷⠛⣁⢀⣀⣤⣶⣿⣛⡿⣿⣮⣽⡻⣿⣮⣽⣻⢯⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣯⢀⢸⣿⢀⡆
⠸⣟⣯⣿⣿⣷⢿⣽⣿⣿⣷⣿⣷⣆⠹⣿⣶⣯⠿⣿⣶⣟⣻⢿⣷⣽⣻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⢀⣯⣟⢀⡇
⣇⠹⣟⣾⣻⣿⣿⢾⡽⣿⣿⣿⣿⣿⣆⢹⣶⣿⣻⣷⣯⣟⣿⣿⣽⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⢀⡿⡇⢸⡇
⣿⣆⠹⣷⡻⣽⣿⣯⢿⣽⣻⣿⣿⣿⣿⣆⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠛⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠇⢸⣿⠇⣼⡇
⡙⠾⣆⠹⣿⣦⠛⣿⢯⣷⢿⡽⣿⣿⣿⣿⣆⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠃⠎⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠏⢀⣿⣾⣣⡿⡇
⣿⣷⡌⢦⠙⣿⣿⣌⠻⣽⢯⣿⣽⣻⣿⣿⣿⣧⠩⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡏⢰⢣⠘⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠃⢀⢀⢿⣞⣷⢿⡇
⣿⣽⣆⠹⣧⠘⣿⣿⡷⣌⠙⢷⣯⡷⣟⣿⣿⣿⣷⡀⡹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣈⠃⣸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠟⢀⣴⡧⢀⠸⣿⡽⣿⢀
⢻⣽⣿⡄⢻⣷⡈⢿⣿⣿⢧⢀⠙⢿⣻⡾⣽⣻⣿⣿⣄⠌⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠛⢁⣰⣾⣟⡿⢀⡄⢿⣟⣿⢀
⡄⢿⣿⣷⢀⠹⣟⣆⠻⣿⣿⣆⢀⣀⠉⠻⣿⡽⣯⣿⣿⣷⣈⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠋⢀⣠⠘⣯⣷⣿⡟⢀⢆⠸⣿⡟⢸
⣷⡈⢿⣿⣇⢱⡘⢿⣷⣬⣙⠿⣧⠘⣆⢀⠈⠻⣷⣟⣾⢿⣿⣆⠹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠋⣠⡞⢡⣿⢀⣿⣿⣿⠇⡄⢸⡄⢻⡇⣼
⣿⣷⡈⢿⣿⡆⢣⡀⠙⢾⣟⣿⣿⣷⡈⠂⠘⣦⡈⠿⣯⣿⢾⣿⣆⠙⠻⠿⠿⠿⠿⡿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠿⠛⢋⣠⣾⡟⢠⣿⣿⢀⣿⣿⡟⢠⣿⢈⣧⠘⢠⣿
⣿⣿⣿⣄⠻⣿⡄⢳⡄⢆⡙⠾⣽⣿⣿⣆⡀⢹⡷⣄⠙⢿⣿⡾⣿⣆⢀⡀⢀⢀⢀⢀⢀⢀⢀⢀⢀⢀⢀⢀⣀⣠⣴⡿⣯⠏⣠⣿⣿⡏⢸⣿⡿⢁⣿⣿⢀⣿⠆⢸⣿
⣿⣿⣿⣿⣦⡙⣿⣆⢻⡌⢿⣶⢤⣉⣙⣿⣷⡀⠙⠽⠷⠄⠹⣿⣟⣿⣆⢙⣋⣤⣤⣤⣄⣀⢀⢀⢀⢀⣾⣿⣟⡷⣯⡿⢃⣼⣿⣿⣿⠇⣼⡟⣡⣿⣿⣿⢀⡿⢠⠈⣿
⣿⣿⣿⣿⣿⣷⣮⣿⣿⣿⡌⠁⢤⣤⣤⣤⣬⣭⣴⣶⣶⣶⣆⠈⢻⣿⣿⣆⢻⣿⣿⣿⣿⣿⣿⣷⣶⣤⣌⣉⡘⠛⠻⠶⣿⣿⣿⣿⡟⣰⣫⣴⣿⣿⣿⣿⠄⣷⣿⣿⣿
*/
import java.util.*;

public class Main{

	public static void main(String[] args) {

		Scanner s=new Scanner(System.in);

		int n=s.nextInt();

		int a=s.nextInt();
		int b=s.nextInt();

		int h=Math.min(n/a,4);
		int ne=n;
		n=n-Math.min(4*a,(n/a)*a);
		int k=Math.min(2, n/b);

		int c=0;
		int d=0;
		int ans=0;
		while(c<4) {
			c=c+h;
			ans++;
			if(d<2&&k!=0) {
				d=d+k;
			}

		}

		 int left=c-4;
		int j=0;
		if(left>0)
		 j=ne-a;

		 if(d!=2) {
			 if(j>0) {

				 if(d==0) {
					 if(2*b<=j) {

					 }else {
						 ans=ans+1;
					 }
					 }else if(d==1&&b<=j) {

					 }else {
						 ans++;
					 }

			 }else {
			 if(d==0) {
			 if(2*b<=ne) {
				 ans++;
			 }else {
				 ans=ans+2;
			 }
			 }else if(d==1) {
				 ans++;
			 }
			 }
		 }

		 System.out.println(ans);

	}
}

import java.util.*;

public class CodeForces910C{
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int n = input.nextInt();
		int a = input.nextInt();
		int b = input.nextInt();
		int count_a = n/a;
		int count_b = (n%a)/b;
		int ans = 1;
		if(count_a == 1){
			ans+= 3;
			if(count_b == 1){
				count_b = 2;
			}
		}
		else if(count_a >= 4){
			count_b = (n-(a*4))/b;
			//System.out.println(count_b);
			ans = 1;
		}
		else{
			count_b = Math.max(count_b,(n-((4-count_a)*a))/b);
			ans++;
		}
		if(count_b == 0){
			if(n/b >= 2){
				ans++;
			}
			else{
				ans+=2;
			}
		}
		else if(count_b < 2){
			ans++;
		}

		System.out.println(ans);
	}
}

import java.util.*;

public class CodeForces910C{
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int n = input.nextInt();
		int a = input.nextInt();
		int b = input.nextInt();
		int count_a = n/a;
		int count_b = (n%a)/b;
		int ans = 1;
		if(count_a == 1){
			ans+= 3;
			if(count_b == 1){
				count_b = 2;
			}
		}
		else if(count_a >= 4){
			count_b = (n-(a*4))/b;
			//System.out.println(count_b);
			ans = 1;
		}
		else{
			count_b = Math.max(count_b,n-((4-count_a)*a));
			ans++;
		}
		if(count_b == 0){
			if(n/b >= 2){
				ans++;
			}
			else{
				ans+=2;
			}
		}
		else if(count_b < 2){
			ans++;
		}

		System.out.println(ans);
	}
}

import java.util.*;

public class Solution {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int n, a, b, ret = 0;
        ArrayList<Integer> pieces = new ArrayList<Integer>();
        ArrayList<Integer> ans = new ArrayList<Integer>();
        n = sc.nextInt();
        a = sc.nextInt();
        b = sc.nextInt();
        ans.add(n);
        for (int i = 0; i < 4; i++) {
            if (i < 2) {
                pieces.add(b);
            }
            pieces.add(a);
        }
        Collections.sort(pieces, Collections.reverseOrder());
        int sz;
        ret = 1;
        if ((a * 2 + b) == n) {
            System.out.println(2);
        } else {
            for (int i = 0; i < 6; i++) {
                int p = 0;
                boolean done = false;
                sz = ans.size();
                for (int j = 0; j < sz; j++) {
                    if (pieces.get(i) <= ans.get(j) && ans.get(j) != 0) {
                        p = ans.remove(j) - pieces.get(i);
                        ans.add(p);
                        done = true;
                        break;
                    }
                }
                if (!done) {
                    p = n - pieces.get(i);
                    ans.add(p);
                }
                System.out.println(p);
            }
            System.out.println(ans.size());
        }

    }
}

import java.util.*;

public class Solution {

    public static void main(String[] args) {

      Scanner sc = new Scanner(System.in);
      int n,a,b;
      int pieces,ans,r;
      ArrayList<Integer> rP= new ArrayList<Integer>();
      n=sc.nextInt();
      a=sc.nextInt();
      b=sc.nextInt();
      ans=1;
      r=0;
      pieces=n/a;
      if(pieces>=4)
      {
          rP.add(n-(a*4));
      }else if(pieces==3)
      {
          ans++;
          rP.add(n-a);
          rP.add(n-(a*3));
      }else if(pieces==2)
      {
          ans++;
          rP.add(n-(a*2));
          rP.add(n-(a*2));
      }else
      {
          ans+=3;
          rP.add(n-a);
          rP.add(n-a);
          rP.add(n-a);
          rP.add(n-a);
      }
        for (Integer i : rP) {
            if(i/b>0)r+=i/b;
        }
        if(r<2)
        {
            if(n>(b*(2-r)))ans++;
            else ans+=2;
        }
        System.out.println(ans);
    }
}

import java.util.*;

public class Solution {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int n, a, b, ret = 0;
        ArrayList<Integer> pieces = new ArrayList<Integer>();
        ArrayList<Integer> ans = new ArrayList<Integer>();
        n = sc.nextInt();
        a = sc.nextInt();
        b = sc.nextInt();
        ans.add(n);
        for (int i = 0; i < 4; i++) {
            if (i < 2) {
                pieces.add(b);
            }
            pieces.add(a);
        }
        Collections.sort(pieces, Collections.reverseOrder());
        int sz;
        ret = 1;
        for (int i = 0; i < 6; i++) {
            int p = 0;
            boolean done = false;
            sz = ans.size();
            for (int j = 0; j < sz; j++) {
                if (pieces.get(i) <= ans.get(j) && ans.get(j) != 0) {
                    p = ans.remove(j) - pieces.get(i);
                    ans.add(p);
                    done = true;
                    break;
                }
            }
            if (!done) {
                p = n - pieces.get(i);
                ans.add(p);
            }

        }
        System.out.println(ans.size());
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;

public class B910 {
    public static void main(String[] args) throws IOException {
        BufferedReader inp = new BufferedReader(new InputStreamReader(System.in));
        int length = Integer.parseInt(inp.readLine());
        int a = Integer.parseInt(inp.readLine());
        int b = Integer.parseInt(inp.readLine());
        int counta = 4;
        int countb = 2;
        int ans = 0;
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0;i<4;i++){
            list.add(a);
        }
        for(int i=0;i<2;i++){
            list.add(b);
        }
        Collections.sort(list);
        ArrayList<Integer> list1 = new ArrayList<>(list);
        int cut = length;
        //System.out.println(list);
        while (!list.isEmpty()){
            if(cut==length){
                cut = length-list.get(list.size()-1);
                list.remove(list.size()-1);
                ans++;
            }
            else{
                if(list.get(0)<=cut){
                    cut = cut-list.get(0);
                    list.remove(0);
                }
                else{
                    cut = length;
                }
            }

        }
        int ans1 = 0;
        boolean one = false;
        list = list1;
        while (!list.isEmpty()){
            if(cut==length){
                cut = length-list.get(list.size()-1);
                list.remove(list.size()-1);
                ans1++;
            }
            else{
                if(!one){
                    if(list.get(0)<=cut){
                        cut = cut-list.get(list.size()-1);
                        list.remove(list.size()-1);
                        one = true;
                    }
                    else{
                        cut = length;
                    }
                }
                else {
                    if(list.get(0)<=cut){
                    cut = cut-list.get(0);
                    list.remove(0);
                    }
                else{
                    cut = length;
                    }
                }
            }

        }
        System.out.println(Math.min(ans,ans1));

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;

public class B910 {
    public static void main(String[] args) throws IOException {
        BufferedReader inp = new BufferedReader(new InputStreamReader(System.in));
        int length = Integer.parseInt(inp.readLine());
        int a = Integer.parseInt(inp.readLine());
        int b = Integer.parseInt(inp.readLine());
        int counta = 4;
        int countb = 2;
        int ans = 0;
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0;i<4;i++){
            list.add(a);
        }
        for(int i=0;i<2;i++){
            list.add(b);
        }
        Collections.sort(list);
        ArrayList<Integer> list1 = new ArrayList<>(list);
        int cut = length;
        //System.out.println(list);
        while (!list.isEmpty()){
            if(cut==length){
                cut = length-list.get(list.size()-1);
                list.remove(list.size()-1);
                ans++;
            }
            else{
                if(list.get(0)<=cut){
                    cut = cut-list.get(0);
                    list.remove(0);
                }
                else{
                    cut = length;
                }
            }

        }
        int ans1 = 0;
        boolean one = false;
        list = list1;
        while (!list.isEmpty()){
            if(cut==length){
                cut = length-list.get(list.size()-1);
                list.remove(list.size()-1);
                ans1++;
            }
            else{
                if(!one){
                    if(list.get(list.size()-1)<=cut){
                        cut = cut-list.get(list.size()-1);
                        list.remove(list.size()-1);
                        one = true;
                    }
                    else{
                        cut = length;
                    }
                }
                else {
                    if(list.get(0)<=cut){
                    cut = cut-list.get(0);
                    list.remove(0);
                    }
                else{
                    cut = length;
                    }
                }
            }

        }
        if(ans1!=0) {
            System.out.println(Math.min(ans, ans1));
        }
        else{
            System.out.println(ans);
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;

public class B910 {
    public static void main(String[] args) throws IOException {
        BufferedReader inp = new BufferedReader(new InputStreamReader(System.in));
        int length = Integer.parseInt(inp.readLine());
        int a = Integer.parseInt(inp.readLine());
        int b = Integer.parseInt(inp.readLine());
        int counta = 4;
        int countb = 2;
        int ans = 0;
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0;i<4;i++){
            list.add(a);
        }
        for(int i=0;i<2;i++){
            list.add(b);
        }
        Collections.sort(list);
        int cut = length;
        //System.out.println(list);
       while (!list.isEmpty()){
            if(cut==length){
                cut = length-list.get(list.size()-1);
                list.remove(list.size()-1);
                ans++;
            }
            else{
                if(list.get(0)<=cut){
                    cut = cut-list.get(0);
                    list.remove(0);
                }
                else{
                    cut = length;
                }
            }

        }
       System.out.println(ans);

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;

public class B910 {
    public static void main(String[] args) throws IOException {
        BufferedReader inp = new BufferedReader(new InputStreamReader(System.in));
        int length = Integer.parseInt(inp.readLine());
        int a = Integer.parseInt(inp.readLine());
        int b = Integer.parseInt(inp.readLine());
        int counta = 4;
        int countb = 2;
        int ans = 0;
        ArrayList<Integer> list = new ArrayList<>();
        for(int i=0;i<4;i++){
            list.add(a);
        }
        for(int i=0;i<2;i++){
            list.add(b);
        }
        Collections.sort(list);
        ArrayList<Integer> list1 = new ArrayList<>(list);
        int cut = length;
        //System.out.println(list);
        while (!list.isEmpty()){
            if(cut==length){
                cut = length-list.get(list.size()-1);
                list.remove(list.size()-1);
                ans++;
            }
            else{
                if(list.get(0)<=cut){
                    cut = cut-list.get(0);
                    list.remove(0);
                }
                else{
                    cut = length;
                }
            }

        }
        int ans1 = 0;
        boolean one = false;
        list = list1;
        while (!list.isEmpty()){
            if(cut==length){
                cut = length-list.get(list.size()-1);
                list.remove(list.size()-1);
                ans1++;
            }
            else{
                if(!one){
                    if(list.get(list.size()-1)<=cut){
                        cut = cut-list.get(list.size()-1);
                        list.remove(list.size()-1);
                        one = true;
                    }
                    else{
                        cut = length;
                    }
                }
                else {
                    if(list.get(0)<=cut){
                    cut = cut-list.get(0);
                    list.remove(0);
                    }
                else{
                    cut = length;
                    }
                }
            }

        }
        System.out.println(Math.min(ans,ans1));

    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;
public class cdfpc2a
{
	static void merge(int arr[], int l, int m, int r)
    {
        int n1 = m - l + 1;
        int n2 = r - m;
        int L[] = new int [n1];
        int R[] = new int [n2];
        for (int i=0; i<n1; ++i)
            L[i] = arr[l + i];
        for (int j=0; j<n2; ++j)
            R[j] = arr[m + 1+ j];
        int i = 0, j = 0;
        int k = l;
        while (i < n1 && j < n2)
        {
            if (L[i] <= R[j])
            {
                arr[k] = L[i];
                i++;
            }
            else
            {
                arr[k] = R[j];
                j++;
            }
            k++;
        }
        while (i < n1)
        {
            arr[k] = L[i];
            i++;
            k++;
        }
        while (j < n2)
        {
            arr[k] = R[j];
            j++;
            k++;
        }
    }
    static void sort(int arr[], int l, int r)
    {
        if (l < r)
        {
            int m = (l+r)/2;
            sort(arr, l, m);
            sort(arr , m+1, r);
            merge(arr, l, m, r);
        }
    }
    static int gcd(int a, int b)
    {
      if (b == 0)
        return a;
      return gcd(b, a % b);
    }
    static long power(long n,long m)
    {
    	if(m==0)
    		return 1;
    	long ans=1;
    	while(m>0)
    	{
    		ans=ans*n;
    		m--;
    	}
    	return ans;
    }
	static int binarySearch(ArrayList<Integer> arr, int x)
    {
        int l = 0, r = arr.size() - 1,m=l + (r - l) / 2;
        while (l <= r) {
            m = l + (r - l) / 2;
            if (arr.get(m) == x)
                return m;
            if (arr.get(m) < x)
                l = m + 1;
            else
                r = m - 1;
        }
        return (int)Math.max(l, m);
    }
	public static void main(String args[])throws Exception
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		int t=1;//Integer.parseInt(br.readLine());
	    for(int i=1;i<=t;i++)
	    {
	        int n=Integer.parseInt(br.readLine());
	        int a=Integer.parseInt(br.readLine());
	        int b=Integer.parseInt(br.readLine());
	        int ans=0,aa=4,bb=2;
	        if(2*(2*a+b)<=n)
	        {
	        	System.out.println("1");
	        	return;
	        }
	        int copy=n;
	        while(aa>0||bb>0)
	        {
	        	if(a>b)
	        	{
	        	while(aa>0&&n>=a)
	        	{
	        		n-=a;
	        		aa--;
	        	}
	        	while(n>=b&&bb>0)
	        	{
	        		n-=b;
	        		bb--;
	        	}}
	        	else
	        	{
		        	while(n>=b&&bb>0)
		        	{
		        		n-=b;
		        		bb--;
		        	}
		        	while(aa>0&&n>=a)
		        	{
		        		n-=a;
		        		aa--;
		        	}
	        	}
	        	n=copy;
	        	ans++;

	        	//System.out.println("inside "+n);
	        }
	        System.out.println(ans);
	    }
	}
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;
public class cdfpc2a
{
	static void merge(int arr[], int l, int m, int r)
    {
        int n1 = m - l + 1;
        int n2 = r - m;
        int L[] = new int [n1];
        int R[] = new int [n2];
        for (int i=0; i<n1; ++i)
            L[i] = arr[l + i];
        for (int j=0; j<n2; ++j)
            R[j] = arr[m + 1+ j];
        int i = 0, j = 0;
        int k = l;
        while (i < n1 && j < n2)
        {
            if (L[i] <= R[j])
            {
                arr[k] = L[i];
                i++;
            }
            else
            {
                arr[k] = R[j];
                j++;
            }
            k++;
        }
        while (i < n1)
        {
            arr[k] = L[i];
            i++;
            k++;
        }
        while (j < n2)
        {
            arr[k] = R[j];
            j++;
            k++;
        }
    }
    static void sort(int arr[], int l, int r)
    {
        if (l < r)
        {
            int m = (l+r)/2;
            sort(arr, l, m);
            sort(arr , m+1, r);
            merge(arr, l, m, r);
        }
    }
    static int gcd(int a, int b)
    {
      if (b == 0)
        return a;
      return gcd(b, a % b);
    }
    static long power(long n,long m)
    {
    	if(m==0)
    		return 1;
    	long ans=1;
    	while(m>0)
    	{
    		ans=ans*n;
    		m--;
    	}
    	return ans;
    }
	static int binarySearch(ArrayList<Integer> arr, int x)
    {
        int l = 0, r = arr.size() - 1,m=l + (r - l) / 2;
        while (l <= r) {
            m = l + (r - l) / 2;
            if (arr.get(m) == x)
                return m;
            if (arr.get(m) < x)
                l = m + 1;
            else
                r = m - 1;
        }
        return (int)Math.max(l, m);
    }
	public static void main(String args[])throws Exception
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		int t=1;//Integer.parseInt(br.readLine());
	    for(int i=1;i<=t;i++)
	    {
	        int n=Integer.parseInt(br.readLine());
	        int a=Integer.parseInt(br.readLine());
	        int b=Integer.parseInt(br.readLine());
	        int ans=0,aa=4,bb=2;
	        if(2*(2*a+b)<=n)
	        {
	        	System.out.println("1");
	        	return;
	        }
	        int copy=n;
	        while(aa>0||bb>0)
	        {
	        	while(aa>0&&n>=a)
	        	{
	        		n-=a;
	        		aa--;
	        	}
	        	while(n>=b&&bb>0)
	        	{
	        		n-=b;
	        		bb--;
	        	}
	        	n=copy;
	        	ans++;

	        	//System.out.println("inside "+n);
	        }
	        System.out.println(ans);
	    }
	}
}