
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int num = Integer.parseInt(sc.nextLine());
		sc.close();
		Main main = new Main();
		int ans = 0;
		for (int i = 1; i <= num; i += 2) {
			if(main.solve(i) == 8) {
				ans++;
			}
		}
		System.out.println(ans);
	}

	public int solve(int num) {
		int factorsCon = 0;
		if (num == 1) {
			factorsCon = 1;
			return factorsCon;
		}else {
			Main m = new Main();
			BigDecimal bigDecimalNum = new BigDecimal(num);

			for (Map.Entry<Integer, Integer> ent : m.factoring(num).entrySet()) {
				BigDecimal entBigDecimal= new BigDecimal(ent.getKey());
				bigDecimalNum = bigDecimalNum.multiply(BigDecimal.ONE.subtract(BigDecimal.ONE.divide(entBigDecimal,1,RoundingMode.HALF_UP)));
				if (factorsCon == 0) {
					factorsCon += (ent.getValue() + 1);
				} else {
					factorsCon *= (ent.getValue() + 1);
				}
			}
			return factorsCon;
		}
	}

	public Map<Integer, Integer> factoring(int num) {
		Map<Integer, Integer>factors = new HashMap<Integer, Integer>();
		int combNum = num;

		while (true) {
			int factor = 0;

			//入力された値が素数であるか調べる
			int numsPiv = (int)Math.sqrt(combNum); //√N = numsPiv とする
			for (int i = 2; i <= numsPiv; i++) {
				if (combNum % i == 0) {
					factor = i;
					if (factors.containsKey(factor)) {
						factors.put(factor, factors.get(factor) + 1);
					} else {
						factors.put(factor, 1);
					}
					break;
				}
			}
			//入力値自身が素数になればbreak
			if (factor == 0) {
				//Map更新
				if (factors.containsKey(combNum)) {
					factors.put(combNum, factors.get(combNum) + 1);
				} else {
					//なければadd
					factors.put(combNum, 1);
				}
				break;
			}else {
				//はじき出した値で入力値を割って更新
				combNum = combNum / factor;
			}
		}
		return factors;
	}
} import java.math.BigDecimal; BigDecimal java.math import java.math.RoundingMode; RoundingMode java.math import java.util.HashMap; HashMap java.util import java.util.Map; Map java.util import java.util.Scanner; Scanner java.util public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int num = Integer.parseInt(sc.nextLine());
		sc.close();
		Main main = new Main();
		int ans = 0;
		for (int i = 1; i <= num; i += 2) {
			if(main.solve(i) == 8) {
				ans++;
			}
		}
		System.out.println(ans);
	}

	public int solve(int num) {
		int factorsCon = 0;
		if (num == 1) {
			factorsCon = 1;
			return factorsCon;
		}else {
			Main m = new Main();
			BigDecimal bigDecimalNum = new BigDecimal(num);

			for (Map.Entry<Integer, Integer> ent : m.factoring(num).entrySet()) {
				BigDecimal entBigDecimal= new BigDecimal(ent.getKey());
				bigDecimalNum = bigDecimalNum.multiply(BigDecimal.ONE.subtract(BigDecimal.ONE.divide(entBigDecimal,1,RoundingMode.HALF_UP)));
				if (factorsCon == 0) {
					factorsCon += (ent.getValue() + 1);
				} else {
					factorsCon *= (ent.getValue() + 1);
				}
			}
			return factorsCon;
		}
	}

	public Map<Integer, Integer> factoring(int num) {
		Map<Integer, Integer>factors = new HashMap<Integer, Integer>();
		int combNum = num;

		while (true) {
			int factor = 0;

			//入力された値が素数であるか調べる
			int numsPiv = (int)Math.sqrt(combNum); //√N = numsPiv とする
			for (int i = 2; i <= numsPiv; i++) {
				if (combNum % i == 0) {
					factor = i;
					if (factors.containsKey(factor)) {
						factors.put(factor, factors.get(factor) + 1);
					} else {
						factors.put(factor, 1);
					}
					break;
				}
			}
			//入力値自身が素数になればbreak
			if (factor == 0) {
				//Map更新
				if (factors.containsKey(combNum)) {
					factors.put(combNum, factors.get(combNum) + 1);
				} else {
					//なければadd
					factors.put(combNum, 1);
				}
				break;
			}else {
				//はじき出した値で入力値を割って更新
				combNum = combNum / factor;
			}
		}
		return factors;
	}
} Main public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int num = Integer.parseInt(sc.nextLine());
		sc.close();
		Main main = new Main();
		int ans = 0;
		for (int i = 1; i <= num; i += 2) {
			if(main.solve(i) == 8) {
				ans++;
			}
		}
		System.out.println(ans);
	} main {
		Scanner sc = new Scanner(System.in);
		int num = Integer.parseInt(sc.nextLine());
		sc.close();
		Main main = new Main();
		int ans = 0;
		for (int i = 1; i <= num; i += 2) {
			if(main.solve(i) == 8) {
				ans++;
			}
		}
		System.out.println(ans);
	} Scanner sc = new Scanner(System.in); sc new Scanner(System.in) int num = Integer.parseInt(sc.nextLine()); num Integer.parseInt(sc.nextLine()) Integer.parseInt Integer sc.nextLine() sc.nextLine sc sc.close() sc.close sc Main main = new Main(); main new Main() int ans = 0; ans 0 for (int i = 1; i <= num; i += 2) {
			if(main.solve(i) == 8) {
				ans++;
			}
		} int i = 1; int i = 1; i 1 i <= num i num i += 2 i += 2 i 2 {
			if(main.solve(i) == 8) {
				ans++;
			}
		} {
			if(main.solve(i) == 8) {
				ans++;
			}
		} if(main.solve(i) == 8) {
				ans++;
			} main.solve(i) == 8 main.solve(i) main.solve main i 8 {
				ans++;
			} ans++ ans System.out.println(ans) System.out.println System.out System System.out ans String[] args args public int solve(int num) {
		int factorsCon = 0;
		if (num == 1) {
			factorsCon = 1;
			return factorsCon;
		}else {
			Main m = new Main();
			BigDecimal bigDecimalNum = new BigDecimal(num);

			for (Map.Entry<Integer, Integer> ent : m.factoring(num).entrySet()) {
				BigDecimal entBigDecimal= new BigDecimal(ent.getKey());
				bigDecimalNum = bigDecimalNum.multiply(BigDecimal.ONE.subtract(BigDecimal.ONE.divide(entBigDecimal,1,RoundingMode.HALF_UP)));
				if (factorsCon == 0) {
					factorsCon += (ent.getValue() + 1);
				} else {
					factorsCon *= (ent.getValue() + 1);
				}
			}
			return factorsCon;
		}
	} solve {
		int factorsCon = 0;
		if (num == 1) {
			factorsCon = 1;
			return factorsCon;
		}else {
			Main m = new Main();
			BigDecimal bigDecimalNum = new BigDecimal(num);

			for (Map.Entry<Integer, Integer> ent : m.factoring(num).entrySet()) {
				BigDecimal entBigDecimal= new BigDecimal(ent.getKey());
				bigDecimalNum = bigDecimalNum.multiply(BigDecimal.ONE.subtract(BigDecimal.ONE.divide(entBigDecimal,1,RoundingMode.HALF_UP)));
				if (factorsCon == 0) {
					factorsCon += (ent.getValue() + 1);
				} else {
					factorsCon *= (ent.getValue() + 1);
				}
			}
			return factorsCon;
		}
	} int factorsCon = 0; factorsCon 0 if (num == 1) {
			factorsCon = 1;
			return factorsCon;
		}else {
			Main m = new Main();
			BigDecimal bigDecimalNum = new BigDecimal(num);

			for (Map.Entry<Integer, Integer> ent : m.factoring(num).entrySet()) {
				BigDecimal entBigDecimal= new BigDecimal(ent.getKey());
				bigDecimalNum = bigDecimalNum.multiply(BigDecimal.ONE.subtract(BigDecimal.ONE.divide(entBigDecimal,1,RoundingMode.HALF_UP)));
				if (factorsCon == 0) {
					factorsCon += (ent.getValue() + 1);
				} else {
					factorsCon *= (ent.getValue() + 1);
				}
			}
			return factorsCon;
		} num == 1 num 1 {
			factorsCon = 1;
			return factorsCon;
		} factorsCon = 1 factorsCon 1 return factorsCon; factorsCon {
			Main m = new Main();
			BigDecimal bigDecimalNum = new BigDecimal(num);

			for (Map.Entry<Integer, Integer> ent : m.factoring(num).entrySet()) {
				BigDecimal entBigDecimal= new BigDecimal(ent.getKey());
				bigDecimalNum = bigDecimalNum.multiply(BigDecimal.ONE.subtract(BigDecimal.ONE.divide(entBigDecimal,1,RoundingMode.HALF_UP)));
				if (factorsCon == 0) {
					factorsCon += (ent.getValue() + 1);
				} else {
					factorsCon *= (ent.getValue() + 1);
				}
			}
			return factorsCon;
		} Main m = new Main(); m new Main() BigDecimal bigDecimalNum = new BigDecimal(num); bigDecimalNum new BigDecimal(num) for (Map.Entry<Integer, Integer> ent : m.factoring(num).entrySet()) {
				BigDecimal entBigDecimal= new BigDecimal(ent.getKey());
				bigDecimalNum = bigDecimalNum.multiply(BigDecimal.ONE.subtract(BigDecimal.ONE.divide(entBigDecimal,1,RoundingMode.HALF_UP)));
				if (factorsCon == 0) {
					factorsCon += (ent.getValue() + 1);
				} else {
					factorsCon *= (ent.getValue() + 1);
				}
			} Map.Entry<Integer, Integer> ent m.factoring(num).entrySet() m.factoring(num).entrySet m.factoring(num) m.factoring m num {
				BigDecimal entBigDecimal= new BigDecimal(ent.getKey());
				bigDecimalNum = bigDecimalNum.multiply(BigDecimal.ONE.subtract(BigDecimal.ONE.divide(entBigDecimal,1,RoundingMode.HALF_UP)));
				if (factorsCon == 0) {
					factorsCon += (ent.getValue() + 1);
				} else {
					factorsCon *= (ent.getValue() + 1);
				}
			} {
				BigDecimal entBigDecimal= new BigDecimal(ent.getKey());
				bigDecimalNum = bigDecimalNum.multiply(BigDecimal.ONE.subtract(BigDecimal.ONE.divide(entBigDecimal,1,RoundingMode.HALF_UP)));
				if (factorsCon == 0) {
					factorsCon += (ent.getValue() + 1);
				} else {
					factorsCon *= (ent.getValue() + 1);
				}
			} BigDecimal entBigDecimal= new BigDecimal(ent.getKey()); entBigDecimal new BigDecimal(ent.getKey()) bigDecimalNum = bigDecimalNum.multiply(BigDecimal.ONE.subtract(BigDecimal.ONE.divide(entBigDecimal,1,RoundingMode.HALF_UP))) bigDecimalNum bigDecimalNum.multiply(BigDecimal.ONE.subtract(BigDecimal.ONE.divide(entBigDecimal,1,RoundingMode.HALF_UP))) bigDecimalNum.multiply bigDecimalNum BigDecimal.ONE.subtract(BigDecimal.ONE.divide(entBigDecimal,1,RoundingMode.HALF_UP)) BigDecimal.ONE.subtract BigDecimal.ONE BigDecimal BigDecimal.ONE BigDecimal.ONE.divide(entBigDecimal,1,RoundingMode.HALF_UP) BigDecimal.ONE.divide BigDecimal.ONE BigDecimal BigDecimal.ONE entBigDecimal 1 RoundingMode.HALF_UP RoundingMode RoundingMode.HALF_UP if (factorsCon == 0) {
					factorsCon += (ent.getValue() + 1);
				} else {
					factorsCon *= (ent.getValue() + 1);
				} factorsCon == 0 factorsCon 0 {
					factorsCon += (ent.getValue() + 1);
				} factorsCon += (ent.getValue() + 1) factorsCon (ent.getValue() + 1) ent.getValue() ent.getValue ent 1 {
					factorsCon *= (ent.getValue() + 1);
				} factorsCon *= (ent.getValue() + 1) factorsCon (ent.getValue() + 1) ent.getValue() ent.getValue ent 1 return factorsCon; factorsCon int num num public Map<Integer, Integer> factoring(int num) {
		Map<Integer, Integer>factors = new HashMap<Integer, Integer>();
		int combNum = num;

		while (true) {
			int factor = 0;

			//入力された値が素数であるか調べる
			int numsPiv = (int)Math.sqrt(combNum); //√N = numsPiv とする
			for (int i = 2; i <= numsPiv; i++) {
				if (combNum % i == 0) {
					factor = i;
					if (factors.containsKey(factor)) {
						factors.put(factor, factors.get(factor) + 1);
					} else {
						factors.put(factor, 1);
					}
					break;
				}
			}
			//入力値自身が素数になればbreak
			if (factor == 0) {
				//Map更新
				if (factors.containsKey(combNum)) {
					factors.put(combNum, factors.get(combNum) + 1);
				} else {
					//なければadd
					factors.put(combNum, 1);
				}
				break;
			}else {
				//はじき出した値で入力値を割って更新
				combNum = combNum / factor;
			}
		}
		return factors;
	} factoring {
		Map<Integer, Integer>factors = new HashMap<Integer, Integer>();
		int combNum = num;

		while (true) {
			int factor = 0;

			//入力された値が素数であるか調べる
			int numsPiv = (int)Math.sqrt(combNum); //√N = numsPiv とする
			for (int i = 2; i <= numsPiv; i++) {
				if (combNum % i == 0) {
					factor = i;
					if (factors.containsKey(factor)) {
						factors.put(factor, factors.get(factor) + 1);
					} else {
						factors.put(factor, 1);
					}
					break;
				}
			}
			//入力値自身が素数になればbreak
			if (factor == 0) {
				//Map更新
				if (factors.containsKey(combNum)) {
					factors.put(combNum, factors.get(combNum) + 1);
				} else {
					//なければadd
					factors.put(combNum, 1);
				}
				break;
			}else {
				//はじき出した値で入力値を割って更新
				combNum = combNum / factor;
			}
		}
		return factors;
	} Map<Integer, Integer>factors = new HashMap<Integer, Integer>(); factors new HashMap<Integer, Integer>() int combNum = num; combNum num while (true) {
			int factor = 0;

			//入力された値が素数であるか調べる
			int numsPiv = (int)Math.sqrt(combNum); //√N = numsPiv とする
			for (int i = 2; i <= numsPiv; i++) {
				if (combNum % i == 0) {
					factor = i;
					if (factors.containsKey(factor)) {
						factors.put(factor, factors.get(factor) + 1);
					} else {
						factors.put(factor, 1);
					}
					break;
				}
			}
			//入力値自身が素数になればbreak
			if (factor == 0) {
				//Map更新
				if (factors.containsKey(combNum)) {
					factors.put(combNum, factors.get(combNum) + 1);
				} else {
					//なければadd
					factors.put(combNum, 1);
				}
				break;
			}else {
				//はじき出した値で入力値を割って更新
				combNum = combNum / factor;
			}
		} true {
			int factor = 0;

			//入力された値が素数であるか調べる
			int numsPiv = (int)Math.sqrt(combNum); //√N = numsPiv とする
			for (int i = 2; i <= numsPiv; i++) {
				if (combNum % i == 0) {
					factor = i;
					if (factors.containsKey(factor)) {
						factors.put(factor, factors.get(factor) + 1);
					} else {
						factors.put(factor, 1);
					}
					break;
				}
			}
			//入力値自身が素数になればbreak
			if (factor == 0) {
				//Map更新
				if (factors.containsKey(combNum)) {
					factors.put(combNum, factors.get(combNum) + 1);
				} else {
					//なければadd
					factors.put(combNum, 1);
				}
				break;
			}else {
				//はじき出した値で入力値を割って更新
				combNum = combNum / factor;
			}
		} int factor = 0; factor 0 int numsPiv = (int)Math.sqrt(combNum); numsPiv (int)Math.sqrt(combNum) Math.sqrt Math combNum for (int i = 2; i <= numsPiv; i++) {
				if (combNum % i == 0) {
					factor = i;
					if (factors.containsKey(factor)) {
						factors.put(factor, factors.get(factor) + 1);
					} else {
						factors.put(factor, 1);
					}
					break;
				}
			} int i = 2; int i = 2; i 2 i <= numsPiv i numsPiv i++ i++ i {
				if (combNum % i == 0) {
					factor = i;
					if (factors.containsKey(factor)) {
						factors.put(factor, factors.get(factor) + 1);
					} else {
						factors.put(factor, 1);
					}
					break;
				}
			} {
				if (combNum % i == 0) {
					factor = i;
					if (factors.containsKey(factor)) {
						factors.put(factor, factors.get(factor) + 1);
					} else {
						factors.put(factor, 1);
					}
					break;
				}
			} if (combNum % i == 0) {
					factor = i;
					if (factors.containsKey(factor)) {
						factors.put(factor, factors.get(factor) + 1);
					} else {
						factors.put(factor, 1);
					}
					break;
				} combNum % i == 0 combNum % i combNum i 0 {
					factor = i;
					if (factors.containsKey(factor)) {
						factors.put(factor, factors.get(factor) + 1);
					} else {
						factors.put(factor, 1);
					}
					break;
				} factor = i factor i if (factors.containsKey(factor)) {
						factors.put(factor, factors.get(factor) + 1);
					} else {
						factors.put(factor, 1);
					} factors.containsKey(factor) factors.containsKey factors factor {
						factors.put(factor, factors.get(factor) + 1);
					} factors.put(factor, factors.get(factor) + 1) factors.put factors factor factors.get(factor) + 1 factors.get(factor) factors.get factors factor 1 {
						factors.put(factor, 1);
					} factors.put(factor, 1) factors.put factors factor 1 break; if (factor == 0) {
				//Map更新
				if (factors.containsKey(combNum)) {
					factors.put(combNum, factors.get(combNum) + 1);
				} else {
					//なければadd
					factors.put(combNum, 1);
				}
				break;
			}else {
				//はじき出した値で入力値を割って更新
				combNum = combNum / factor;
			} factor == 0 factor 0 {
				//Map更新
				if (factors.containsKey(combNum)) {
					factors.put(combNum, factors.get(combNum) + 1);
				} else {
					//なければadd
					factors.put(combNum, 1);
				}
				break;
			} if (factors.containsKey(combNum)) {
					factors.put(combNum, factors.get(combNum) + 1);
				} else {
					//なければadd
					factors.put(combNum, 1);
				} factors.containsKey(combNum) factors.containsKey factors combNum {
					factors.put(combNum, factors.get(combNum) + 1);
				} factors.put(combNum, factors.get(combNum) + 1) factors.put factors combNum factors.get(combNum) + 1 factors.get(combNum) factors.get factors combNum 1 {
					//なければadd
					factors.put(combNum, 1);
				} factors.put(combNum, 1) factors.put factors combNum 1 break; {
				//はじき出した値で入力値を割って更新
				combNum = combNum / factor;
			} combNum = combNum / factor combNum combNum / factor combNum factor return factors; factors int num num public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int num = Integer.parseInt(sc.nextLine());
		sc.close();
		Main main = new Main();
		int ans = 0;
		for (int i = 1; i <= num; i += 2) {
			if(main.solve(i) == 8) {
				ans++;
			}
		}
		System.out.println(ans);
	}

	public int solve(int num) {
		int factorsCon = 0;
		if (num == 1) {
			factorsCon = 1;
			return factorsCon;
		}else {
			Main m = new Main();
			BigDecimal bigDecimalNum = new BigDecimal(num);

			for (Map.Entry<Integer, Integer> ent : m.factoring(num).entrySet()) {
				BigDecimal entBigDecimal= new BigDecimal(ent.getKey());
				bigDecimalNum = bigDecimalNum.multiply(BigDecimal.ONE.subtract(BigDecimal.ONE.divide(entBigDecimal,1,RoundingMode.HALF_UP)));
				if (factorsCon == 0) {
					factorsCon += (ent.getValue() + 1);
				} else {
					factorsCon *= (ent.getValue() + 1);
				}
			}
			return factorsCon;
		}
	}

	public Map<Integer, Integer> factoring(int num) {
		Map<Integer, Integer>factors = new HashMap<Integer, Integer>();
		int combNum = num;

		while (true) {
			int factor = 0;

			//入力された値が素数であるか調べる
			int numsPiv = (int)Math.sqrt(combNum); //√N = numsPiv とする
			for (int i = 2; i <= numsPiv; i++) {
				if (combNum % i == 0) {
					factor = i;
					if (factors.containsKey(factor)) {
						factors.put(factor, factors.get(factor) + 1);
					} else {
						factors.put(factor, 1);
					}
					break;
				}
			}
			//入力値自身が素数になればbreak
			if (factor == 0) {
				//Map更新
				if (factors.containsKey(combNum)) {
					factors.put(combNum, factors.get(combNum) + 1);
				} else {
					//なければadd
					factors.put(combNum, 1);
				}
				break;
			}else {
				//はじき出した値で入力値を割って更新
				combNum = combNum / factor;
			}
		}
		return factors;
	}
} public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int num = Integer.parseInt(sc.nextLine());
		sc.close();
		Main main = new Main();
		int ans = 0;
		for (int i = 1; i <= num; i += 2) {
			if(main.solve(i) == 8) {
				ans++;
			}
		}
		System.out.println(ans);
	}

	public int solve(int num) {
		int factorsCon = 0;
		if (num == 1) {
			factorsCon = 1;
			return factorsCon;
		}else {
			Main m = new Main();
			BigDecimal bigDecimalNum = new BigDecimal(num);

			for (Map.Entry<Integer, Integer> ent : m.factoring(num).entrySet()) {
				BigDecimal entBigDecimal= new BigDecimal(ent.getKey());
				bigDecimalNum = bigDecimalNum.multiply(BigDecimal.ONE.subtract(BigDecimal.ONE.divide(entBigDecimal,1,RoundingMode.HALF_UP)));
				if (factorsCon == 0) {
					factorsCon += (ent.getValue() + 1);
				} else {
					factorsCon *= (ent.getValue() + 1);
				}
			}
			return factorsCon;
		}
	}

	public Map<Integer, Integer> factoring(int num) {
		Map<Integer, Integer>factors = new HashMap<Integer, Integer>();
		int combNum = num;

		while (true) {
			int factor = 0;

			//入力された値が素数であるか調べる
			int numsPiv = (int)Math.sqrt(combNum); //√N = numsPiv とする
			for (int i = 2; i <= numsPiv; i++) {
				if (combNum % i == 0) {
					factor = i;
					if (factors.containsKey(factor)) {
						factors.put(factor, factors.get(factor) + 1);
					} else {
						factors.put(factor, 1);
					}
					break;
				}
			}
			//入力値自身が素数になればbreak
			if (factor == 0) {
				//Map更新
				if (factors.containsKey(combNum)) {
					factors.put(combNum, factors.get(combNum) + 1);
				} else {
					//なければadd
					factors.put(combNum, 1);
				}
				break;
			}else {
				//はじき出した値で入力値を割って更新
				combNum = combNum / factor;
			}
		}
		return factors;
	}
} Main

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int num = Integer.parseInt(sc.nextLine());
		sc.close();
		Main main = new Main();
		int ans = 0;
		for (int i = 1; i <= num; i += 2) {
			if(main.solve(i) == 8) {
				ans++;
			}
		}
		System.out.println(ans);
	}

	public int solve(int num) {
		int factorsCon = 0;
		if (num == 1) {
			factorsCon = 1;
			return factorsCon;
		}else {
			Main m = new Main();
			BigDecimal bigDecimalNum = new BigDecimal(num);

			for (Map.Entry<Integer, Integer> ent : m.factoring(num).entrySet()) {
				BigDecimal entBigDecimal= new BigDecimal(ent.getKey());
				bigDecimalNum = bigDecimalNum.multiply(BigDecimal.ONE.subtract(BigDecimal.ONE.divide(entBigDecimal,1,RoundingMode.HALF_UP)));
				if (factorsCon == 0) {
					factorsCon += (ent.getValue() + 1);
				} else {
					factorsCon *= (ent.getValue() + 1);
				}
			}
			return factorsCon;
		}
	}

	public Map<Integer, Integer> factoring(int num) {
		Map<Integer, Integer>factors = new HashMap<Integer, Integer>();
		int combNum = num;

		while (true) {
			int factor = 0;

			//入力された値が素数であるか調べる
			int numsPiv = (int)Math.sqrt(combNum); //√N = numsPiv とする
			for (int i = 2; i <= numsPiv; i++) {
				if (combNum % i == 0) {
					factor = i;
					if (factors.containsKey(factor)) {
						factors.put(factor, factors.get(factor) + 1);
					} else {
						factors.put(factor, 1);
					}
					break;
				}
			}
			//入力値自身が素数になればbreak
			if (factor == 0) {
				//Map更新
				if (factors.containsKey(combNum)) {
					factors.put(combNum, factors.get(combNum) + 1);
				} else {
					//なければadd
					factors.put(combNum, 1);
				}
				break;
			}else {
				//はじき出した値で入力値を割って更新
				combNum = combNum / factor;
			}
		}
		return factors;
	}
}