Petya has equal wooden bars of length n. He wants to make a frame for two equal doors. Each frame has two vertical (left and right) sides of length a and one top side of length b. A solid (i.e. continuous without breaks) piece of bar is needed for each side.Determine a minimal number of wooden bars which are needed to make the frames for two doors. Petya can cut the wooden bars into any parts, but each side of each door should be a solid piece of a wooden bar (or a whole wooden bar).

The first line contains a single integer n (1 ≤ n ≤ 1 000) — the length of each wooden bar. The second line contains a single integer a (1 ≤ a ≤ n) — the length of the vertical (left and right) sides of a door frame. The third line contains a single integer b (1 ≤ b ≤ n) — the length of the upper side of a door frame.

Print the minimal number of wooden bars with length n which are needed to make the frames for two doors.

NoteIn the first example one wooden bar is enough, since the total length of all six sides of the frames for two doors is 8.In the second example 6 wooden bars is enough, because for each side of the frames the new wooden bar is needed.

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

}

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

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

}

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

}

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

    }
}

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

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

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

    }
}

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

        }

    }
}

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

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